def __init__(self): ShowBase.__init__(self) # Turn Auto Shaders and Antialiasing self.render.setShaderAuto() self.render.setAntialias(AntialiasAttrib.MAuto) # Setup Bloom and Blur Filters self.filters = CommonFilters(base.win, base.cam) self.filters.setBloom(blend=(1, 0, 0, 1), desat=-0.5, intensity=6.0, size=2) #self.filters.setBlurSharpen(amount=0.5) # Create Ambient Lighting alight = AmbientLight('alight') alight.setColor(VBase4(1, 1, 1, 1)) alnp = render.attachNewNode(alight) self.render.setLight(alnp) # Load Model and Add it to Scene self.environ = self.loader.loadModel("untitled.egg") self.environ.reparentTo(self.render) self.environ.setTransparency(TransparencyAttrib.MAlpha)
def __init__(self): BaseRenderer.__init__(self) # <- important ShowBase.__init__(self) client = BulletClient(pb.DIRECT) client.setAdditionalSearchPath(pybullet_data.getDataPath()) self.client = client # bind external renderer plugin = RenderingPlugin(client, self) # setup scene self.nodes = {} self.camLens.setNearFar(3, 7) self.camLens.setFilmSize(Vec2(0.030, 0.030)) self.render.setAntialias(AntialiasAttrib.MAuto) self.render.setDepthOffset(1) self.render.setShaderAuto() self.setupScene(client) self.setupLights() # setup filters if args.ambient_occlusion: filters = CommonFilters(self.win, self.cam) filters.setAmbientOcclusion() # setup periodic tasks self.time = 0 self.taskMgr.add(self.spinCameraTask, "SpinCameraTask") self.taskMgr.add(self.stepSimulationTask, "StepSimulationTask") if args.debug: self.oobe()
class MyApp(ShowBase): def __init__(self): ShowBase.__init__(self) # Turn Auto Shaders and Antialiasing self.render.setShaderAuto() self.render.setAntialias(AntialiasAttrib.MAuto) # Setup Bloom and Blur Filters self.filters = CommonFilters(base.win, base.cam) self.filters.setBloom(blend=(1,0,0,1), desat=-0.5, intensity=6.0, size=2) #self.filters.setBlurSharpen(amount=0.5) # Create Ambient Lighting alight = AmbientLight('alight') alight.setColor(VBase4(1, 1, 1, 1)) alnp = render.attachNewNode(alight) self.render.setLight(alnp) # Load Model and Add it to Scene self.environ = self.loader.loadModel("untitled.egg") self.environ.reparentTo(self.render) self.environ.setTransparency(TransparencyAttrib.MAlpha)
def __init__(self): base.disableMouse() # Turns off the default mouse-camera controls in Panda3D. base.setBackgroundColor(0, 0, 0) # Sets the background to black. self.inputManager = InputManager() # Creates an InputManager to handle all of the user input in the game. self.track = Track() # Creates the track the cycles will race on. self.cycle1 = Cycle(self.inputManager, self.track, 1, "Bert", ai=False) self.cycle2 = Cycle(self.inputManager, self.track, 2, "Ernie") # Creates one uncontrolled cycle, and one player controlled cycle. taskMgr.doMethodLater(10, self.debugTask, "Debug Task") # Tells the debugTask to run once every ten seconds. The debug task is a good # place to put various data print outs about the game to help with debugging. self.filters = CommonFilters(base.win, base.cam) filterok = self.filters.setBloom(blend=(0, 0, 0, 1), desat=-0.5, intensity=3.0, size=2) render.setShaderAuto()
def __init__(self): ShowBase.__init__(self) base.setBackgroundColor(0, 0, 0) #render.setShaderAuto() #Load the Lights ambilight = AmbientLight('ambilight') ambilight.setColor(VBase4(1, 1, 1, 1)) render.setLight(render.attachNewNode(ambilight)) self.filters = CommonFilters(base.win, base.cam) filterok = self.filters.setBloom(blend=(0, 0, 0, 1), desat=-0.8, intensity=4.0, size="big") ## self.glowSize=4 ## ts = TextureStage('ts') ## ts.setMode(TextureStage.MGlow) self.tron = loader.loadModel("data/models/vehicles/vehicle01") self.tron.reparentTo(render) self.tron2 = loader.loadModel("data/models/vehicles/vehicle02") self.tron2.reparentTo(render) self.tron2.setX(5) self.tron3 = loader.loadModel("data/models/vehicles/vehicle03") self.tron3.reparentTo(render) self.tron3.setX(-5)
def __init__(self): #Create a buffer for storing the shadow texture, #the higher the buffer size the better quality the shadow. self.shadowBuffer = base.win.makeTextureBuffer("Shadow Buffer",2048,2048) self.shadowBuffer.setClearColorActive(True) self.shadowBuffer.setClearColor((0,0,0,1)) self.shadowCamera = base.makeCamera(self.shadowBuffer) self.shadowCamera.reparentTo(render) self.lens = base.camLens self.lens.setAspectRatio(1/1) self.shadowCamera.node().setLens(self.lens) self.shadowCamera.node().setCameraMask(BitMask32.bit(1)) #Make everything rendered by the shadow camera grey: self.initial = NodePath('initial') self.initial.setColor(.75,.75,.75,1,1) self.initial.setTextureOff(2) self.initial.setMaterialOff(2) self.initial.setLightOff(2) self.shadowCamera.node().setInitialState(self.initial.getState()) #The cameras pos effects the shadows dirrection: self.shadowCamera.setPos(-10, 0,20) self.shadowCamera.lookAt(0,0,0) #Make the shadows soft by bluring the screen: self.filters = CommonFilters(self.shadowBuffer,self.shadowCamera) self.filters.setBlurSharpen(.1) self.shadowTexture = self.shadowBuffer.getTexture() #Draw the shadowTexture on sceen: self.imageObject = OnscreenImage(image = self.shadowTexture,pos = (-.75,0,.75),scale=.2)
def __createBuffer(self): if self.shadowsHidden or not (self.shadowsEnabled): return None self.__destroyBuffer() if not base.win.getGsg(): return None if self.fMoreShadows and False: self.shadowBuffer = base.win.makeTextureBuffer('shadow', 1024 * 4, 1024 * 4, tex=self.shadowTex) else: self.shadowBuffer = base.win.makeTextureBuffer('shadow', 1024, 1024, tex=self.shadowTex) #self.shadowBuffer.setSort(30) self.shadowBuffer.setClearColor(self.clearColor) dr = self.shadowBuffer.makeDisplayRegion() dr.setCamera(self.shadowCam) #self.setupTask = taskMgr.doMethodLater(0, self.__setupCamera, 'setupCamera') self.filters = CommonFilters(self.shadowBuffer, self.shadowCam) self.filters.setBlurSharpen(.5)
def __init__(self): #loadPrcFile("Config.prc") ShowBase.__init__(self) self.config = ConfigManager.loadSettings() #Config stuff here self.filters = CommonFilters(base.win, base.cam) self.AOEnabled = False self.bloomEnabled = False self.invertEnabled = False self.OSD = True self.shadersLoaded = False self.xray_mode = False self.show_model_bounds = False self.fogEnabled = True self.mouseEnabled = False #Store which keys are currently pressed self.keyMap = { "1": 0, "escape": 0, "left": 0, "right": 0, "forward": 0, "backward": 0, "cam-left": 0, "cam-right": 0, } self.ButtonImage = loader.loadModel( "phase_3/models/gui/quit_button.bam") self.introButtons()
def __init__(self): ShowBase.__init__(self) self.disableMouse() props = WindowProperties() props.setTitle('Test') self.win.requestProperties(props) # self.render.setAntiAlias(AntialiasAttrib.MAuto) self.transitions = Transitions(self.loader) self.transitions.setFadeColor(0, 0, 0) self.filters = CommonFilters(self.win, self.cam) # self.filters.setCartoonInk() self.filters.setBlurSharpen(1) # self.filters.setVolumetricLighting(self.render) # self.buffer = self.win.makeTextureBuffer("Post-processing buffer", self.win.getXSize(), self.win.getXSize()) # print self.buffer.getYSize() # self.texture = self.buffer.getTexture() # self.buffer.setSort(-100) # # self.originalCamera = self.camera # self.offScreenCamera = self.makeCamera(self.buffer) # self.camera = self.offScreenCamera # # self.img = OnscreenImage(image=self.texture, pos=(0, 0, 0.5)) self.scene = None self.channel = Channel()
def __init__(self): base.disableMouse() # Turns off the default mouse-camera controls in Panda3D. base.setBackgroundColor(0, 0, 0) # Sets the background to black. self.inputManager = InputManager() # Creates an InputManager to handle all of the user input in the game. taskMgr.doMethodLater(10, self.debugTask, "Debug Task") # Tells the debugTask to run once every ten seconds. The debug task is a good # place to put various data print outs about the game to help with debugging. self.filters = CommonFilters(base.win, base.cam) filterok = self.filters.setBloom(blend=(0, 0, 0, 1), desat=-0.5, intensity=3.0, size=2) render.setShaderAuto() # Turns on Panda3D's automatic shader generation. self.menuGraphics = loader.loadModel("../Models/MenuGraphics.egg") self.fonts = { "silver": loader.loadFont("../Fonts/LuconSilver.egg"), "blue": loader.loadFont("../Fonts/LuconBlue.egg"), "orange": loader.loadFont("../Fonts/LuconOrange.egg") } self.race = Race(self.inputManager) self.race.createDemoRace() self.createStartMenu()
class ShadowCreator: def __init__(self): self.shadowBuffer = base.win.makeTextureBuffer('Shadow Buffer', 2048, 2048) self.shadowBuffer.setClearColorActive(True) self.shadowBuffer.setClearColor((0, 0, 0, 1)) self.shadowCamera = base.makeCamera(self.shadowBuffer) self.shadowCamera.reparentTo(render) self.lens = base.camLens self.lens.setAspectRatio(1 / 1) self.shadowCamera.node().setLens(self.lens) self.shadowCamera.node().setCameraMask(BitMask32.bit(1)) self.initial = NodePath('initial') self.initial.setColor(0.75, 0.75, 0.75, 1, 1) self.initial.setTextureOff(2) self.initial.setMaterialOff(2) self.initial.setLightOff(2) self.shadowCamera.node().setInitialState(self.initial.getState()) self.shadowCamera.setPos(-10, 0, 20) self.shadowCamera.lookAt(0, 0, 0) self.filters = CommonFilters(self.shadowBuffer, self.shadowCamera) self.filters.setBlurSharpen(0.1) self.shadowTexture = self.shadowBuffer.getTexture() self.imageObject = OnscreenImage(image=self.shadowTexture, pos=(-0.75, 0, 0.75), scale=0.2)
def toggleAmbientOcclusion(self, checked): filters = CommonFilters(base.win, base.cam) if checked == True: filters.setAmbientOcclusion() else: filters.delAmbientOcclusion()
def toggleToonShading(self, checked): filters = CommonFilters(base.win, base.cam) if checked == True: filters.setCartoonInk() else: filters.delCartoonInk()
def setBloomed(self): #setupfilters and shaders self.filters = CommonFilters(base.win, base.cam) #self.filters.setCartoonInk(separation=1.0) self.filters.setBloom(size="small") #self.filters.setVolumetricLighting(myCamera.cameraLightNode) render.setAttrib(LightRampAttrib.makeHdr0()) pass
def __init__(self): ShowBase.__init__(self) # Disable the camera trackball controls. self.disableMouse() # Load the environment model. self.environ = self.loader.loadModel("models/environment") # Reparent the model to render. self.environ.reparentTo(self.render) # Apply scale and position transforms on the model. self.environ.setScale(0.25, 0.25, 0.25) self.environ.setPos(-8, 42, 0) # Add the spinCameraTask procedure to the task manager. self.taskMgr.add(self.spinCameraTask, "SpinCameraTask") # Load and transform the panda actor. self.pandaActor = Actor(models="models/panda-model", anims={"walk": "models/panda-walk4"}) self.pandaActor.setScale(0.005, 0.005, 0.005) self.pandaActor.reparentTo(self.render) # Loop its animation. self.pandaActor.loop("walk") # Create the four lerp intervals needed for the panda to # walk back and forth. A = Point3(0, 10, 0) B = Point3(0, -10, 0) pandaPosInterval1 = self.pandaActor.posInterval(13, B, startPos=A) pandaPosInterval2 = self.pandaActor.posInterval(13, A, startPos=B) pandaHprInterval1 = self.pandaActor.hprInterval(3, Point3(180, 0, 0), startHpr=Point3( 0, 0, 0)) pandaHprInterval2 = self.pandaActor.hprInterval(3, Point3(0, 0, 0), startHpr=Point3( 180, 0, 0)) # Create and play the sequence that coordinates the intervals. self.pandaPace = Sequence(pandaPosInterval1, pandaHprInterval1, pandaPosInterval2, pandaHprInterval2, name="pandaPace") self.pandaPace.loop() self.teapot = self.loader.loadModel('models/teapot') self.teapot.reparentTo(self.render) self.console = Console(self) self.filters = CommonFilters(self.win, self.cam) self.filters.setCartoonInk() self.filters.setAmbientOcclusion() self.filters.setBloom()
class BurdenOfProof(ShowBase): def __init__(self): ShowBase.__init__(self) self.useAdvancedVisualEffects = ConfigVariableBool( "use-advanced-visual-effects", True) self.game = Game() self.setupFilters() self.setupModels() self.setupKeyboardControl() self.motionController = MotionController(self) self.camera.setPos(0.0, 0.0, 1.7) def setupKeyboardControl(self): self.accept("escape", sys.exit) def setupFilters(self): if (self.useAdvancedVisualEffects): self.filters = CommonFilters(self.win, self.cam) self.filters.setBloom() def setupModels(self): self.cityModel = self.loader.loadModel("data/models/city") self.cityModel.reparentTo(self.render) self.cityModel.setP(-90.0) self.pandaActor = Actor("models/panda-model", {"walk": "models/panda-walk4"}) self.pandaActor.setScale(0.005, 0.005, 0.005) self.pandaActor.loop("walk") population = self.game.getPopulation() self.characterInstances = [] for i in range(1, population.getCharacterCount()): instance = self.render.attachNewNode("characterInstance") instance.setPos( population.getCharacter(i).getPosition(self.game.getTime())) self.pandaActor.instanceTo(instance) self.characterInstances.append(instance) self.taskMgr.add(self.update, "updateTask") def update(self, task): self.game.update(oneMinute) # TODO(?) compute actual milliseconds population = self.game.getPopulation() for i in range(1, population.getCharacterCount()): self.characterInstances[i - 1].setPos( population.getCharacter(i).getPosition(self.game.getTime())) return Task.cont
class filters(): def __init__(self): self.filters = CommonFilters(base.win, base.cam) self.initCartoonInk() def initCartoonInk(self): self.filters.setCartoonInk(separation=-1)
class filters(): def __init__(self): self.filters = CommonFilters(base.win, base.cam) self.initCartoonInk() def initCartoonInk(self): self.filters.setCartoonInk(separation= -1)
def __init__(self): base.disableMouse() # Turns off the default mouse-camera controls in Panda3D. base.setBackgroundColor(0, 0, 0) # Sets the background to black. self.inputManager = InputManager() # Creates an InputManager to handle all of the user input in the game. #taskMgr.doMethodLater(10, self.debugTask, "Debug Task") # Tells the debugTask to run once every ten seconds. The debug task is a good # place to put various data print outs about the game to help with debugging. self.filters = CommonFilters(base.win, base.cam) filterok = self.filters.setBloom(blend=(0, 0, 0, 1), desat=-0.5, intensity=3.0, size=2) # Creates a bloom filter that will integrate with the Glow maps applied to objects to create # the halos around glowing objects. render.setShaderAuto() # Turns on Panda3D's automatic shader generation. self.menuGraphics = loader.loadModel("../Models/MenuGraphics.egg") # Loads the egg that contains all the menu graphics. self.fonts = { "silver": loader.loadFont("../Fonts/LuconSilver.egg"), "blue": loader.loadFont("../Fonts/LuconBlue.egg"), "orange": loader.loadFont("../Fonts/LuconOrange.egg") } # Loads the three custom fonts our game will use. preloader = Preloader(self.fonts) hud = HUD(self.fonts) # Creates the HUD. self.race = Race(self.inputManager, hud) self.race.createDemoRace() # creates an instance of the race class and tells it to # start a demo race. self.createStartMenu() # creates the start menu. musicMgr = base.musicManager self.music = musicMgr.getSound( "../Sound/Loveshadow-Takin_Yo_Time_(The_Wingman_Mix).wav") self.music.setLoop(True) self.music.setVolume(.5) self.music.play()
def _loadFilters(self): self.terrain.setShaderInput('waterlevel', self._water_level) # load default shaders cf = CommonFilters(base.win, base.cam) # bloomSize cf.setBloom(size='small', desat=0.7, intensity=1.5, mintrigger=0.6, maxtrigger=0.95) # hdrtype: render.setAttrib(LightRampAttrib.makeHdr1()) # perpixel: render.setShaderAuto()
def _loadFilters(self): self.terrain.setShaderInput('waterlevel', self._water_level) # load default shaders cf = CommonFilters(base.win, base.cam) #bloomSize cf.setBloom(size='small', desat=0.7, intensity=1.5, mintrigger=0.6, maxtrigger=0.95) #hdrtype: render.setAttrib(LightRampAttrib.makeHdr1()) #perpixel: render.setShaderAuto()
def postProcessingChanged(): global filters if enablePostProcessing: if filters == None: filters = CommonFilters(base.win, base.cam) render.setAttrib(LightRampAttrib.makeHdr1()) filters.setBloom(intensity = 1, size = 2) else: if filters != None: filters.delBloom() saveConfigFile()
def __init__(self, mouse): ShowBase.__init__(self) self.mouse = mouse self.joy_x = None self.joy_y = None props = WindowProperties() props.setMouseMode(WindowProperties.MRelative) # keep mouse in screen self.disableMouse() self.win.requestProperties(props) self.setBackgroundColor(0, 0, 0) # Make missiles glow self.filters = CommonFilters(self.win, self.cam) self.filters.setBloom(blend=(0, 0, 0, 1), desat=-0.5, intensity=3.0, size="large") self.screen_width = self.win.getXSize() self.screen_height = self.win.getYSize() self.center_x = self.screen_width/2 self.center_y = self.screen_height/2 # self.win.movePointer(0, self.center_x, self.center_y) self.enableParticles() self.cTrav = CollisionTraverser() # self.cTrav.setRespectPrevTransform(True) self.pusher = PhysicsCollisionHandler() self.pusher.addInPattern('%fn-into-%in') self.target = None self.maxvel = 50 self.roll_time = 0 self.fuel = 1000 self.ship() self.sounds() self.hud() self.part = Spacedust(self) self.events() self.camLens.setFov(70) self.camLens.setNear(1) self.camLens.setFar(500) self.get_key = { "ACCEL": False, "DECEL": False, "FORWARD_THRUST": False, "REVERSE_THRUST": False, "ROLL_LEFT": False, "ROLL_RIGHT": False, "ROLL_LEFT_BEG": False, "ROLL_RIGHT_BEG": False, "FIRE": False, "FIRING": False, "LOCK": False, "LOCKING": False, } self.AIworld = AIWorld(self.render) self.taskMgr.add(self.update, "task-update") self.taskMgr.doMethodLater(1, self.fuel_usage, "task-fuel-usage") self.taskMgr.add(self.AI_update, "AI-update") self.gen_enemy()
class Filters: """Class handles postprocessing filters and effects""" def __init__(self,manager,xml): self.cf = CommonFilters(base.win,base.cam) self.reload(manager,xml) def reload(self,manager,xml): hdr = xml.find('hdr') if hdr!=None: self.hdrtype = hdr.get('type') assert self.hdrtype in ['0', '1', '2'] else: self.hdrtype = None self.perpixel = xml.find('perpixel')!=None bloom = xml.find('bloom') if bloom!=None: self.bloomSize = bloom.get('size', 'medium') else: self.bloomSize = None self.showbuffers = xml.find('showbuffers')!=None def start(self): if self.hdrtype!=None: render.setAttrib(getattr(LightRampAttrib, "makeHdr" + self.hdrtype)()) if self.perpixel: render.setShaderAuto() if self.bloomSize!=None: self.cf.setBloom(size=self.bloomSize) if self.showbuffers: base.bufferViewer.toggleEnable() def stop(self): if self.hdrtype!=None: render.clearAttrib(LightRampAttrib.getClassType()) if self.perpixel: render.setShaderOff() if self.bloomSize!=None: self.cf.delBloom() if self.showbuffers: base.bufferViewer.toggleEnable()
def initShader(self): tempnode = NodePath(PandaNode("temp node")) tempnode.setAttrib(LightRampAttrib.makeSingleThreshold(0.5, 0.9)) tempnode.setShaderAuto() base.cam.node().setInitialState(tempnode.getState()) self.separation = 1 # Pixels self.filters = CommonFilters(base.win, base.cam) filterok = self.filters.setBloom() if (filterok == False): addTitle( "Toon Shader: Video card not powerful enough to do image postprocessing" ) sys.exit
class ShaderManager(): def __init__(self): #needed for physics and particle system base.enableParticles() render.setShaderAuto() def setBloomed(self): #setupfilters and shaders self.filters = CommonFilters(base.win, base.cam) #self.filters.setCartoonInk(separation=1.0) self.filters.setBloom(size="small") #self.filters.setVolumetricLighting(myCamera.cameraLightNode) render.setAttrib(LightRampAttrib.makeHdr0()) pass
def __init__(self): base.enableParticles() # noqa: F821 render.setShaderAuto() # noqa: F821 self._explosion_lights = self._set_explosion_lights() self._transition = Transitions(loader) # noqa: F821 self._transition.setFadeColor(0, 0, 0) self.stench_effect = Stench() self.love_fog = LoveFog() filters = CommonFilters(base.win, base.cam) # noqa: F821 filters.setBloom(size="large", mintrigger=0.8, intensity=2.1)
def __init__(self, parent): self._parent = parent DirectFrame.__init__(self, parent=self._parent, relief=None, pos=(0.0, 0.0, 0.0), scale=(1.0, 1.0, 1.0)) self.filter = CommonFilters(base.win, base.cam) # Only affects primary window # Ambient Occlusion self.samples = 0 self.radius = 0.0 self.amount = 0.0 self.strength = 0.0 # Blur/Sharpen self.blur = 1.0 # this is normal value, 0.0 blurs it # Cartoon Ink self.cartoonSep = 0.0 self.cartoonR = 0.0 self.cartoonB = 0.0 self.cartoonG = 0.0 # todo: Add bloom # Boolean Filters self.HDREnabled = False self.invertedEnabled = False self.sRGBEnabled = False self.halfPixelShiftEnabled = False self.viewGlowEnabled = False # Other Filters self.exposure = 0.0 self.SAMPLES_MAX = 128 self.RAD_MAX = 1.0 self.AMT_MAX = 64.0 self.STR_MAX = 0.01 self.INCREMENT = 1 self.numSamples = None self.numRadius = None self.circleModel = loader.loadModel( 'phase_3/models/gui/tt_m_gui_mat_nameShop') self.barTexture = loader.loadTexture('phase_3/maps/slider.png') self.loadGUI()
def __init__(self): super().__init__() self.set_background_color(0, 0, 0, 1) self.cam.setPos(0, -12, 0) self.trees = NodePath("trees") self.tree1 = self.loader.loadModel('my-models/christmas_tree') self.tree1.setPos(0, 0, -2.5) self.tree1.reparentTo(self.trees) self.tree2 = self.loader.loadModel('my-models/christmas_tree') self.tree2.setPos(4, 5, -2.5) self.tree2.reparentTo(self.trees) self.tree3 = self.loader.loadModel('my-models/christmas_tree') self.tree3.setPos(-4, 7, -2.5) self.tree3.reparentTo(self.trees) self.trees.reparentTo(self.render) self.floor = self.loader.loadModel('my-models/floor') self.floor.setPos(0, 0, -2.5) self.floor.reparentTo(self.render) self.light_model = self.loader.loadModel('models/misc/sphere') self.light_model.setScale(0.2, 0.2, 0.2) # self.light_model.setPos(4, -4, 0) self.light_model.reparentTo(self.render) plight = PointLight("plight") plight.setShadowCaster(True, 1024, 1024) self.render.setShaderAuto() plnp = self.light_model.attachNewNode(plight) # plight.setAttenuation((1, 0, 0)) # constant, linear, and quadratic. self.trees.setLight(plnp) alight = AmbientLight("alight") alight.setColor((0.04, 0.04, 0.04, 1)) alnp = self.render.attachNewNode(alight) self.trees.setLight(alnp) self.floor.setLight(plnp) self.floor.setLight(alnp) filters = CommonFilters(self.win, self.cam) filters.setBloom(size="large") self.taskMgr.add(self.move_light, "move-light")
def runConfiguration(): #Grundeinstellungen base.setFrameRateMeter(True) base.setBackgroundColor(0, 0, 0) #Bloom Filter CFilters = CommonFilters(base.win, base.cam) filterok = CFilters.setBloom(blend=(0, 0, 0, 1), desat=-0.1, mintrigger=0.0, intensity=6.0, size="small") if filterok == 0: print "Deine Grafikkarte unterstuetzt kein Bloom Filter: Shader Error"
def __init__(self): base.disableMouse() base.setBackgroundColor(0.52, 0.80, 0.99) self.inputManager = InputManager() self.filters = CommonFilters(base.win, base.cam) filterok = self.filters.setBloom(blend=(0, 0, 0, 1), desat=-0.5, intensity=3.0, size=2) render.setShaderAuto() self.menuGraphics = loader.loadModel("Models/MenuGraphics.egg") self.fonts = { "silver": loader.loadFont("Fonts/LuconSilver.egg"), "blue": loader.loadFont("Fonts/LuconBlue.egg"), "orange": loader.loadFont("Fonts/LuconOrange.egg") } gui = Gui(self.fonts) self.race = Race(self.inputManager, gui) self.race.createDemoRace() self.createStartMenu() musicMgr = base.musicManager self.music = musicMgr.getSound("Sound/music_1.wav") self.music.setLoop(True) self.music.setVolume(.5) self.music.play()
def postInit(self): # # initialize game content # # camera base.camLens.setNearFar(1.0, 10000) base.camLens.setFov(75) a = 33 base.camera.setPos(0, -a, a + 3) #80) # collision base.cTrav = CollisionTraverser("base collision traverser") base.cHandler = CollisionHandlerEvent() base.cPusher = CollisionHandlerPusher() base.cQueue = CollisionHandlerQueue() base.globalClock = ClockObject.getGlobalClock() base.cHandler.addInPattern('%fn-into-%in') base.cHandler.addOutPattern('%fn-out-%in') base.cHandler.addAgainPattern('%fn-again-%in') # ai init base.AIworld = AIWorld(render) # 3d manager base.audio3d = Audio3DManager(base.sfxManagerList[0], camera) # manager self.archiveManager = ArchiveManager() self.mapManager = MapManager() self.initHeroInfo = None # Lock self.lock = threading.Lock() self.gameThread = None self.filters = CommonFilters(base.win, base.cam) # UI self.menu = Menu() self.option = Option() self.archive = Archive() self.death = Death() # self.oobe() #self.Archive_status = 0 # self.menuMusic = loader.loadMusic("assets/audio/menuMusic.ogg") # self.menuMusic.setLoop(True) # self.fightMusic = loader.loadMusic("assets/audio/fightMusic.ogg") # self.fightMusic.setLoop(True) # base.audio3d = Audio3DManager(base.sfxManagerList[0], camera) self.titleVideo, self.titleCard = loadVideo('title.mp4') self.isInited = False self.isSkip = False self.isRenew = False # # Event handling # self.accept("escape", self.__escape) # # Start with the menu # self.request("Menu")
def toggle_cartoon(self): ''' Use Cartoon ink filter ''' self.cartoon = not self.cartoon if self.cartoon: tempnode = NodePath(PandaNode("temp node")) tempnode.setAttrib(LightRampAttrib.makeSingleThreshold(0.4, 0.6)) tempnode.setShaderAuto() base.cam.node().setInitialState(tempnode.getState()) self.separation = 1.3 # Pixels self.filters = CommonFilters(base.win, base.cam) self.filters.setCartoonInk(separation=self.separation) # Currently using MAuto antialias, uncomment to use different #render.setAntialias(AntialiasAttrib.MBetter) #self.filters.finalQuad.setAntialias(AntialiasAttrib.MBetter) else: self.filters.cleanup() base.cam.node().setInitialState(self.alight.getState())
class ToonMaker(DirectObject): def __init__(self): base.disableMouse() base.cam.node().getLens().setNear(10.0) base.cam.node().getLens().setFar(9999999) camera.setPos(0, -50, 0) # Check video card capabilities. if (base.win.getGsg().getSupportsBasicShaders() == 0): addTitle("Toon Shader: Video driver reports that shaders are not supported.") return # Enable a 'light ramp' - this discretizes the lighting, # which is half of what makes a model look like a cartoon. # Light ramps only work if shader generation is enabled, # so we call 'setShaderAuto'. tempnode = NodePath(PandaNode("temp node")) tempnode.setAttrib(LightRampAttrib.makeSingleThreshold(0.5, 0.4)) tempnode.setShaderAuto() base.cam.node().setInitialState(tempnode.getState()) # Use class 'CommonFilters' to enable a cartoon inking filter. # This can fail if the video card is not powerful enough, if so, # display an error and exit. self.separation = 1 # Pixels self.filters = CommonFilters(base.win, base.cam) filterok = self.filters.setCartoonInk(separation=self.separation) if (filterok == False): addTitle("Toon Shader: Video card not powerful enough to do image postprocessing") return # Create a non-attenuating point light and an ambient light. plightnode = PointLight("point light") plightnode.setAttenuation(Vec3(1,0,0)) plight = render.attachNewNode(plightnode) plight.setPos(30,-50,0) alightnode = AmbientLight("ambient light") alightnode.setColor(Vec4(0.8,0.8,0.8,1)) alight = render.attachNewNode(alightnode) render.setLight(alight) render.setLight(plight) # Panda contains a built-in viewer that lets you view the # results of all render-to-texture operations. This lets you # see what class CommonFilters is doing behind the scenes. self.accept("v", base.bufferViewer.toggleEnable) self.accept("V", base.bufferViewer.toggleEnable) base.bufferViewer.setPosition("llcorner") self.accept("s", self.filters.manager.resizeBuffers) # These allow you to change cartooning parameters in realtime self.accept("escape", sys.exit, [0])
def __init__(self, neweval, starList=[]):#, console=[]): #messenger.toggleVerbose() self.stars=starList self.mouselook=True self.zoom = .33 self.mapMode = False self.evaluator = neweval self.hudScale = 1 self.objectScale=.01 self.starScale = .1 self.skyScale=40000 self.dt=.02 self.starting=True self.mouseX = 0 self.mouseY = 0 self.dX=0 self.dY=0 self.dZ=0 self.player = Body() ## self.mouseBody = Body() ## self.mouseBody.name = "mouse" self.player.name = "player" self.player.mass = 0 self.player.position.x=0 self.player.position.y=0 self.player.position.z=-0.04 self.player.orientation.y=90 self.accRate =2 # self.player.bodies=[] # self.evaluator.system.bodies.append(self.player) neweval.system.bodies.append(self.player) self.evaluator= soPhysics.soPhysics(neweval.system) self.evaluator.system.moveToStar() self.filters = CommonFilters(base.win, base.cam) self.filterok = self.filters.setBloom(blend=(1,1,1,1), desat=-0.5, intensity=1.0, size="small") self.glowSize=1 #base.enableParticles() #self.p = ParticleEffect() #self.p.loadConfig("sun2.ptf") self.loadPlanets() #self.console = console self.toggleConsole() if len(starList)>0: self.loadStars() base.camLens.setNear(0.01) base.camLens.setFar(100000) # base.camLens.setFar(170000000000000000000000000000000000000) self.mouselook=False #render.setShaderAuto() self.loadLights() taskMgr.add(self.move,"move")
def compose_filters(self, win, cam, seperation=.6): """ function to handle the composing, which makes for the basic look and feel of the game also handles any filters which are attached to the cam :return: """ # set up the lightramp effect tempnode = NodePath(PandaNode("temp node")) tempnode.setAttrib(LightRampAttrib.makeSingleThreshold( 0.5, 0.4)) # warning can be ignored.. tempnode.setShaderAuto() cam.node().setInitialState(tempnode.getState()) self.separation = seperation # Pixels self.filters = CommonFilters(win, cam) filterok = self.filters.setCartoonInk(separation=self.separation) if (filterok == False): return
def __init__(self): super().__init__(self) self.var1 = 0 self.scene = loader.loadModel("models/world") playerTexture = loader.loadTexture("models/starfoxShip.jpg") self.player = self.scene.find("player") self.player.setTexture(playerTexture) base.setBackgroundColor(0.1, 0.1, 0.1, 1) enemyTexture = loader.loadTexture("models/enemyShip.jpg") self.enemy = self.scene.find("enemy1") self.enemy.setTexture(enemyTexture) self.basePlane = self.scene.find("basePlane") self.scene.reparentTo(self.render) self.player.setPos(50, 50, 3) self.enemy.setPos(50, 55, 0) self.ambient = AmbientLight("ambient") self.ambient.color = (0.1, 0.1, 0.1, 1) self.ambientPath = self.render.attachNewNode(self.ambient) render.setLight(self.ambientPath) self.dirLight = DirectionalLight("dir light") self.dirLight.color = (1, 1, 1, 1) self.dirLightPath = self.render.attachNewNode(self.dirLight) self.dirLightPath.setHpr(0, -90, 0) self.dirLight.setShadowCaster(True, 512, 512) render.setLight(self.dirLightPath) self.pointLight = PointLight("point light") self.pointLight.color = (1, 1, 1, 1) self.pointLightPath = self.render.attachNewNode(self.pointLight) self.pointLightPath.setPos(50, 52.5, 4) self.pointLight.attenuation = (.5, 0, 0) self.pointLight.setShadowCaster(True, 1024, 1024) self.render.setLight(self.pointLightPath) self.fog = Fog("fog") self.fog.setColor(0.1, 0.1, 0.1) self.fog.setExpDensity(.3) self.fog.setLinearRange(150, 300) self.fog.setLinearFallback(45, 160, 320) self.render.setFog(self.fog) self.render.setShaderAuto() self.render.setAntialias(AntialiasAttrib.MAuto) filters = CommonFilters(base.win, base.cam) filters.setBloom(size="large") filters.setAmbientOcclusion(strength=0.6, falloff=0.0005, radius=0.1) filters.setCartoonInk(separation=2, color=(0, 0, 0, 1)) self.taskMgr.add(self.update, "update")
class World: def __init__(self): base.disableMouse() # Turns off the default mouse-camera controls in Panda3D. base.setBackgroundColor(0, 0, 0) # Sets the background to black. self.inputManager = InputManager() # Creates an InputManager to handle all of the user input in the game. taskMgr.doMethodLater(10, self.debugTask, "Debug Task") # Tells the debugTask to run once every ten seconds. The debug task is a good # place to put various data print outs about the game to help with debugging. self.filters = CommonFilters(base.win, base.cam) filterok = self.filters.setBloom(blend=(0, 0, 0, 1), desat=-0.5, intensity=3.0, size=2) render.setShaderAuto() # Turns on Panda3D's automatic shader generation. self.menuGraphics = loader.loadModel("../Models/MenuGraphics.egg") self.fonts = { "silver": loader.loadFont("../Fonts/LuconSilver.egg"), "blue": loader.loadFont("../Fonts/LuconBlue.egg"), "orange": loader.loadFont("../Fonts/LuconOrange.egg") } self.race = Race(self.inputManager) self.race.createDemoRace() self.createStartMenu() def createStartMenu(self): menu = Menu(self.menuGraphics, self.fonts, self.inputManager) menu.initMenu([ 0, None, ["New Game", "Quit Game"], [[self.race.createRace, self.createReadyDialogue], [base.userExit]], [[None, None], [None]] ]) def createReadyDialogue(self): menu = Menu(self.menuGraphics, self.fonts, self.inputManager) menu.initMenu([ 3, "Are you ready?", ["Yes", "Exit"], [[self.race.startRace], [self.race.createDemoRace]], [[3], [None]] ]) def debugTask(self, task): print(taskMgr) # prints all of the tasks in the task manager. return task.again
class Filters(): def __init__(self): self.filters = CommonFilters(base.win, base.cam) self.glowShader = loader.loadShader("./shaders/glowShader.sha") def enableFilters(self, player): #self.filters.setBloom(mintrigger=.35) self.filters.setBloom(blend=(1, 0, .2, 1), desat=-1, intensity=10, size="small") #self.filters.setCartoonInk(separation=-5) self.filters.setAmbientOcclusion(numsamples = 2, radius = 0.0025, amount = 2, strength = 0.001, falloff = 0.01) player.setShader(self.glowShader) player.setShaderInput("scale",4,4) path = render.find("renderDummy") path.setShader(self.glowShader) path.setShaderInput("scale",1,1,1)
def __init__(self): ShowBase.__init__(self) self.filters = CommonFilters(self.win, self.cam) self.render.setShaderAuto() self.initP3D() self.audio3d = Audio3DManager.Audio3DManager(self.sfxManagerList[0], self.cam) self.audio3d.setDopplerFactor(.7) self.splash = Splash(base, self, sys.argv[1] if len(sys.argv) > 1 else False )
def initShader(self): tempnode = NodePath(PandaNode("temp node")) tempnode.setAttrib(LightRampAttrib.makeSingleThreshold(0.5, 0.9)) tempnode.setShaderAuto() base.cam.node().setInitialState(tempnode.getState()) self.separation = 1 # Pixels self.filters = CommonFilters(base.win, base.cam) filterok = self.filters.setBloom() if (filterok == False): addTitle("Toon Shader: Video card not powerful enough to do image postprocessing") sys.exit
def init_lights(self): """init_lights Set up light system """ self.filters = CommonFilters(base.win, base.cam) filterok = self.filters.setBloom(blend=(0,0,0,.5), desat=-0.5, intensity=1.0, size="small") if filterok == False: print "Your video card cannot handle this" return self.glowSize=.2 # Create a simple directional light self.lights = {} #Set up directional light self.lights['dlight'] = render.attachNewNode (DirectionalLight\ ('DirectionalLight')) self.lights['dlight'].setColor(VBase4(1, 1, 1, 1)) render.setLight(self.lights['dlight']) self.lights['dlight'].setPos(50,50,50) self.lights['dlight'].lookAt(0,0,0) #Sun position self.lights['sunPos'] = 0 # Create an ambient light self.lights['alight'] = AmbientLight('AmbientLight') self.lights['alight'].setColor(VBase4(0.1, 0.1, 0.1, 0.1)) self.lights['alnp'] = render.attachNewNode(self.lights['alight']) render.setLight(self.lights['alnp']) #Create an invisible "sun" node which the dlight will lookAt() self.lights['sun_node'] = render.attachNewNode("sun_node") self.lights['sun_node'].setPos(10,10,10) self.lights['sun_node'].setScale(2) #Create a sun model that will be a visual representation of where the # sun is. Will be, essentially, in the opposite position of the # fake sun node self.lights['sun_model'] = loader.loadModel(target_dir+'/models/sphere.egg') self.lights['sun_model'].reparentTo(render) self.lights['sun_model'].setPos(10,10,10) self.lights['sun_model'].setScale(2) self.lights['sky_box'] = loader.loadModel(target_dir+'/models/skybox.egg') self.lights['sky_box'].reparentTo(render) self.lights['sky_box'].setScale(5) sky_tex = loader.loadTexture(\ target_dir+'/models/textures/clouds_bw.png') sky_tex.setWrapU(Texture.WMRepeat) sky_tex.setWrapV(Texture.WMRepeat) self.lights['sky_box'].setTexture(sky_tex,1)
def __init__(self, app_object): self.app = app_object self.n = 0 cmnd = "" self.commandBox = "" self.store = ["","","",""] ShowBase.__init__(self) self.title1 = self.AddTitle(-0.65, "Type your commands here:") self.title2 = self.AddTitle(0.90, "You have entered:") self.instArea = self.AddInstructions(0.82, cmnd) self.cmndArea = self.AddArea() base.setFrameRateMeter(True) base.setBackgroundColor(0,0,0) self.cube = loader.loadModel("models/cube") self.cube.setPos(0, 0, 0) self.cube.reparentTo(self.render) self.cube.setScale((cx), 3, 1) # cam self.cam.setPos(60, -80, 22) light = PointLight('light') self.render.setLight(self.cam.attachNewNode(light)) self.cam.lookAt(self.cube) self.i = 1 self.sy = 1 self.sx = 1 self.sz = 1 self.addx =1 self.addy =1 self.addz =1 #self.negy = -7 #self.posy = 7 #CENTER #setting up the bloom effect filters = CommonFilters(base.win, base.cam) filters.setBloom(blend=(0.0,0.0,0.0,1.0), mintrigger = 0.9, desat=-0.5, intensity=8.0, size="small") rootDir = os.path.abspath(os.path.dirname(sys.argv[0])) loadPrcFile(os.path.join(rootDir, "config.prc"))
def register(self, render, camera, keys, render2d): State.register(self, render, camera, keys, render2d) self.node.attachNewNode(self.stage.maps[self.room].getNode()) for c in self.characters: self.status[c].reparentTo(self.node2d) for char in self.characters.values(): char.getNode().reparentTo(self.node) char.stunRender = self.node for l in self.stage.getLights(): render.setLight(l) # COWABUNGA test!!! self.hearts = {} numChar=0 self.heartsNode = NodePath(PandaNode('hearts')) self.heartsNode.reparentTo(self.node2d) for char in self.characters: self.hearts[char] = [] for i in range(Character.maxHearts): self.hearts[char].append(Sprite("heart.png", 0.05, 0.05)) self.hearts[char][i].setPos(-0.8 + 1.4*numChar + (i%3)*0.055 , -0.9 - int(i/3)*0.055) self.hearts[char][i].getNode().reparentTo(self.heartsNode) numChar += 1 #COWABUNGA comment this to stop the madness render.setAttrib(LightRampAttrib.makeSingleThreshold(0.1, 1)) # THE TRUE CARTOON SHADER :P # self.separation = 1 # Pixels self.filters = CommonFilters(base.win, self.camera.camera) # cell shading # filterok = self.filters.setCartoonInk(separation=self.separation) # glow filterok = self.filters.setBloom(blend=(0.5,0.5,0.5,1), desat=-0.5, intensity=0.5, size="small") self.camera.setPos(0, -2.5, -2.5) self.camera.lookAt(0, 0, 0)
def loadShaders(self): # Check video card capabilities for shaders. if (base.win.getGsg().getSupportsBasicShaders() == 0): addTitle("Glow Filter: Video driver reports that shaders are not supported.") return False # Load filters self.filters = CommonFilters(base.win, base.cam) filterok = self.filters.setBloom(blend=(0,0,0,1), desat=-0.5, intensity=3.0, size="small") if (filterok == False): addTitle("Toon Shader: Video card not powerful enough to do image postprocessing") return False self.glowSize=1 # Shadow shaders # TODO: Implement shadows return True
def setupShaders(self): """ Creates shaders for cartoon outline and enables shaders for shadows """ if self.base.win.getGsg().getSupportsBasicShaders() == 0: return thickness = 1.0 for camera in self.playerCameras: self.filters = CommonFilters(self.base.win, camera) filterEnabled = self.filters.setCartoonInk(separation=thickness) if filterEnabled == False: # Couldn't enable filter, video card probably # doesn't support filter return self.worldRender.setShaderAuto()
def configurePanda(self): """configurePanda parameters: self returns: none Description: Set the rendering and display options for panda. """ props = WindowProperties() props.setCursorHidden(True) #props.setSize(1440, 900) #props.setFullscreen(1) base.win.requestProperties(props) render.setShaderAuto() base.disableMouse() base.setFrameRateMeter(True) #render.setAntialias(AntialiasAttrib.MAuto) #render.setAntialias(AntialiasAttrib.MMultisample,4) self.filters = CommonFilters(base.win, base.cam) self.filters.setBloom(blend=(1,0,0,1), desat=-0.5, intensity=6.0, size=2)
class World: def __init__(self): base.disableMouse() base.setBackgroundColor(0.52, 0.80, 0.99) self.inputManager = InputManager() self.filters = CommonFilters(base.win, base.cam) filterok = self.filters.setBloom(blend=(0, 0, 0, 1), desat=-0.5, intensity=3.0, size=2) render.setShaderAuto() self.menuGraphics = loader.loadModel("Models/MenuGraphics.egg") self.fonts = { "silver": loader.loadFont("Fonts/LuconSilver.egg"), "blue": loader.loadFont("Fonts/LuconBlue.egg"), "orange": loader.loadFont("Fonts/LuconOrange.egg") } gui = Gui(self.fonts) self.race = Race(self.inputManager, gui) self.race.createDemoRace() self.createStartMenu() musicMgr = base.musicManager self.music = musicMgr.getSound("Sound/music_1.wav") self.music.setLoop(True) self.music.setVolume(.5) self.music.play() def createStartMenu(self): menu = Menu(self.menuGraphics, self.fonts, self.inputManager) menu.initMenu([0, None, ["New Game", "Quit Game"], [[self.race.createRace, self.createReadyDialogue], [base.userExit]], [[None, None], [None]]]) def createReadyDialogue(self): menu = Menu(self.menuGraphics, self.fonts, self.inputManager) menu.initMenu([3, "Ready?", ["Yes", "Exit"], [[self.race.startRace], [self.race.createDemoRace]], [[3], [None]]]) def debugTask(self, task): print(taskMgr) return task.again
def __init__(self): ShowBase.__init__(self) self.createLoadScreen('./LEGameAssets/Textures/title_screen.png') base.graphicsEngine.renderFrame() #== Environment and Rendering Settings == base.setFrameRateMeter(FLAG_SHOW_FRAMES_PER_SECOND) if FLAG_USE_AUTOSHADER: render.setShaderAuto() self.filters = CommonFilters(base.win, self.cam) # NEW if FLAG_SHOW_GLOW: bloomSize = 4#'small' filterok = self.filters.setBloom(blend=(0,0,0,1), desat=-0.5, intensity=3.0, size=bloomSize) if (filterok == False): print 'WARNING:Video card not powerful enough to do image postprocessing' #tex = loader.loadTexture("./LEGameAssets/Textures/loadbar_tray.png") self.loadBar = DirectWaitBar(text = "", value = 0, scale =(.35,.5,.5), pos = (0.006,.83,.83)) #self.loadBar['barRelief'] = DirectWaitBar.GROOVE #self.loadBar['scale'] = 0.05 #self.loadBar['barTexture'] = tex self.loadBar['barColor'] = (6.0/255.0, 11.0/255, 28.0/255.0, 1) self.loadBar.reparentTo(render2d) self.loadBar.hide() base.graphicsEngine.renderFrame() self.setBackgroundColor(166.0/255.0,207.0/255.0,240.0/255.0,1) self.skybox = self.loader.loadModel("LEGameAssets/Models/skybox_final.egg") self.skybox.setScale(50) self.skybox.reparentTo(render) #== Load the level and the managers == self.assets, self.objects, self.gameObjects, self.sounds, self.sequences= loadWorld(SCENE_FILE, LIBRARY_INDEX) self.loadBar['value'] += 5 base.graphicsEngine.renderFrame() self.conversations = loadConversations(SCENE_FILE, LIBRARY_INDEX) self.scenes = {} self.loadScenes() self.loadBar['value'] += 5 base.graphicsEngine.renderFrame() self.journalMgr = JournalMgr(self) self.loadJournal(self.journalMgr,JOURNAL_FILE) self.conversationMgr = ConversationMgr(self, self.conversations) self.scriptMgr = ScriptMgr(self) self.scriptMgr.loadScripts(SCRIPTS_LIST) self.scriptInterface = ScriptInterface(self) self.inventoryMgr = InventoryMgr(self) loadInventory(self.inventoryMgr,INVENTORY_FILE) self.loadBar['value'] += 5 base.graphicsEngine.renderFrame() self.ranSequences = [] #== Main Character == self.hero = None for name, gameObj in self.gameObjects.iteritems(): if gameObj.getNP().hasTag('LE-mainChar'): self.hero = gameObj break else: # make a default hero defaultHeroNP = loader.loadModel("panda") self.hero = GameObject(defaultHeroNP) self.hero.reparentTo(render) self.hero.setPos(0, 0, 0) self.hero.setTag('LE-mainChar', '180') self.gameObjects[self.hero.getName()] = self.hero self.setCollideMasks(self.gameObjects) # remove the hero from the objects dict so it cannot be clicked by player if self.hero.getName() in self.objects: del self.objects[self.hero.getName()] #== Camera == camHeightFactor = CAMERA_HEIGHT camTrailFactor = -CAMERA_TRAIL # careful of +/- distinction self.heroHeight = self.getModelHeight(self.hero) self.heroHeadingOffset = float(self.hero.getTag('LE-mainChar')) self.lastHeroH = self.hero.getH(render) + self.heroHeadingOffset # setup the camera pivot, which will follow the main character model and anchor the camera self.camPivot = NodePath('camPivot') self.camPivot.reparentTo(render) self.camHeight = camHeightFactor*self.heroHeight self.camTrail = camTrailFactor*self.heroHeight self.cam.setPos(self.camPivot.getPos() + (0, self.camTrail, self.camHeight)) self.cam.wrtReparentTo(self.camPivot) self.placeCamera(self.hero) # match X and Y to main character self.alignCamera(self.hero) # match heading to main character #self.camPivot.setH(render, self.hero.getH(render) + self.heroHeadingOffset) self.gameCam = self.cam #== Collisions == self.setupCollisions() #== Controls == self.disableMouse() self.keyMap = { 'w':False, 'a':False, 's':False, 'd':False } self.enableMovement(self.hero) self.accept("mouse1", self.onClickin3D) self.accept('escape', sys.exit) self.accept('z', render.place) #== UI and Combat == self.gameplayUI = GameplayUI(self) self.gameplayUI.hideAll() # for health bars and on screen UI self.overlayAmbientLight = AmbientLight('overlayAmbientLight') self.overlayAmbientLight.setColor(VBase4(1.0, 1.0, 1.0, 1.0)) self.overlayAmbientLightNP = render.attachNewNode(self.overlayAmbientLight) # initialize the combat manager (which includes AI) now that a main character and gameplayUI instance and overlay light is established self.combatMgr = CombatMgr(self) # initialize player's spells self.heroSpells = [] for properties in PLAYER_SPELLS: spell = Spell(self.hero, properties) self.heroSpells.append(spell) #== Start Tasks taskMgr.add(self.moveHeroTask, 'moveHeroTask', appendTask=True) taskMgr.add(self.cameraFollowTask, 'cameraFollowTask', appendTask=True) taskMgr.add(self.processHeroCollisions, 'processHeroCollisions') taskMgr.add(self.updateHeroHeight, 'updateHeroHeight') self.combatMgr.startTasks() self.accept('enter', self.destroyLoadScreen) self.destroyLoadScreen()
def __init__(self): # Initialize the ShowBase class from which we inherit, which will # create a window and set up everything we need for rendering into it. ShowBase.__init__(self) self.disableMouse() self.cam.node().getLens().setNear(10.0) self.cam.node().getLens().setFar(200.0) camera.setPos(0, -50, 0) # Check video card capabilities. if not self.win.getGsg().getSupportsBasicShaders(): addTitle("Toon Shader: Video driver reports that Cg shaders are not supported.") return # Enable a 'light ramp' - this discretizes the lighting, # which is half of what makes a model look like a cartoon. # Light ramps only work if shader generation is enabled, # so we call 'setShaderAuto'. tempnode = NodePath(PandaNode("temp node")) tempnode.setAttrib(LightRampAttrib.makeSingleThreshold(0.5, 0.4)) tempnode.setShaderAuto() self.cam.node().setInitialState(tempnode.getState()) # Use class 'CommonFilters' to enable a cartoon inking filter. # This can fail if the video card is not powerful enough, if so, # display an error and exit. self.separation = 1 # Pixels self.filters = CommonFilters(self.win, self.cam) filterok = self.filters.setCartoonInk(separation=self.separation) if (filterok == False): addTitle( "Toon Shader: Video card not powerful enough to do image postprocessing") return # Show instructions in the corner of the window. self.title = addTitle( "Panda3D: Tutorial - Toon Shading with Normals-Based Inking") self.inst1 = addInstructions(0.06, "ESC: Quit") self.inst2 = addInstructions(0.12, "Up/Down: Increase/Decrease Line Thickness") self.inst3 = addInstructions(0.18, "V: View the render-to-texture results") # Load a dragon model and animate it. self.character = Actor() self.character.loadModel('models/nik-dragon') self.character.reparentTo(render) self.character.loadAnims({'win': 'models/nik-dragon'}) self.character.loop('win') self.character.hprInterval(15, (360, 0, 0)).loop() # Create a non-attenuating point light and an ambient light. plightnode = PointLight("point light") plightnode.setAttenuation((1, 0, 0)) plight = render.attachNewNode(plightnode) plight.setPos(30, -50, 0) alightnode = AmbientLight("ambient light") alightnode.setColor((0.8, 0.8, 0.8, 1)) alight = render.attachNewNode(alightnode) render.setLight(alight) render.setLight(plight) # Panda contains a built-in viewer that lets you view the # results of all render-to-texture operations. This lets you # see what class CommonFilters is doing behind the scenes. self.accept("v", self.bufferViewer.toggleEnable) self.accept("V", self.bufferViewer.toggleEnable) self.bufferViewer.setPosition("llcorner") self.accept("s", self.filters.manager.resizeBuffers) # These allow you to change cartooning parameters in realtime self.accept("escape", sys.exit, [0]) self.accept("arrow_up", self.increaseSeparation) self.accept("arrow_down", self.decreaseSeparation)
class World(ShowBase): # CONDISER: change to DirectObject/FSM def __init__(self): ShowBase.__init__(self) self.createLoadScreen('./LEGameAssets/Textures/title_screen.png') base.graphicsEngine.renderFrame() #== Environment and Rendering Settings == base.setFrameRateMeter(FLAG_SHOW_FRAMES_PER_SECOND) if FLAG_USE_AUTOSHADER: render.setShaderAuto() self.filters = CommonFilters(base.win, self.cam) # NEW if FLAG_SHOW_GLOW: bloomSize = 4#'small' filterok = self.filters.setBloom(blend=(0,0,0,1), desat=-0.5, intensity=3.0, size=bloomSize) if (filterok == False): print 'WARNING:Video card not powerful enough to do image postprocessing' #tex = loader.loadTexture("./LEGameAssets/Textures/loadbar_tray.png") self.loadBar = DirectWaitBar(text = "", value = 0, scale =(.35,.5,.5), pos = (0.006,.83,.83)) #self.loadBar['barRelief'] = DirectWaitBar.GROOVE #self.loadBar['scale'] = 0.05 #self.loadBar['barTexture'] = tex self.loadBar['barColor'] = (6.0/255.0, 11.0/255, 28.0/255.0, 1) self.loadBar.reparentTo(render2d) self.loadBar.hide() base.graphicsEngine.renderFrame() self.setBackgroundColor(166.0/255.0,207.0/255.0,240.0/255.0,1) self.skybox = self.loader.loadModel("LEGameAssets/Models/skybox_final.egg") self.skybox.setScale(50) self.skybox.reparentTo(render) #== Load the level and the managers == self.assets, self.objects, self.gameObjects, self.sounds, self.sequences= loadWorld(SCENE_FILE, LIBRARY_INDEX) self.loadBar['value'] += 5 base.graphicsEngine.renderFrame() self.conversations = loadConversations(SCENE_FILE, LIBRARY_INDEX) self.scenes = {} self.loadScenes() self.loadBar['value'] += 5 base.graphicsEngine.renderFrame() self.journalMgr = JournalMgr(self) self.loadJournal(self.journalMgr,JOURNAL_FILE) self.conversationMgr = ConversationMgr(self, self.conversations) self.scriptMgr = ScriptMgr(self) self.scriptMgr.loadScripts(SCRIPTS_LIST) self.scriptInterface = ScriptInterface(self) self.inventoryMgr = InventoryMgr(self) loadInventory(self.inventoryMgr,INVENTORY_FILE) self.loadBar['value'] += 5 base.graphicsEngine.renderFrame() self.ranSequences = [] #== Main Character == self.hero = None for name, gameObj in self.gameObjects.iteritems(): if gameObj.getNP().hasTag('LE-mainChar'): self.hero = gameObj break else: # make a default hero defaultHeroNP = loader.loadModel("panda") self.hero = GameObject(defaultHeroNP) self.hero.reparentTo(render) self.hero.setPos(0, 0, 0) self.hero.setTag('LE-mainChar', '180') self.gameObjects[self.hero.getName()] = self.hero self.setCollideMasks(self.gameObjects) # remove the hero from the objects dict so it cannot be clicked by player if self.hero.getName() in self.objects: del self.objects[self.hero.getName()] #== Camera == camHeightFactor = CAMERA_HEIGHT camTrailFactor = -CAMERA_TRAIL # careful of +/- distinction self.heroHeight = self.getModelHeight(self.hero) self.heroHeadingOffset = float(self.hero.getTag('LE-mainChar')) self.lastHeroH = self.hero.getH(render) + self.heroHeadingOffset # setup the camera pivot, which will follow the main character model and anchor the camera self.camPivot = NodePath('camPivot') self.camPivot.reparentTo(render) self.camHeight = camHeightFactor*self.heroHeight self.camTrail = camTrailFactor*self.heroHeight self.cam.setPos(self.camPivot.getPos() + (0, self.camTrail, self.camHeight)) self.cam.wrtReparentTo(self.camPivot) self.placeCamera(self.hero) # match X and Y to main character self.alignCamera(self.hero) # match heading to main character #self.camPivot.setH(render, self.hero.getH(render) + self.heroHeadingOffset) self.gameCam = self.cam #== Collisions == self.setupCollisions() #== Controls == self.disableMouse() self.keyMap = { 'w':False, 'a':False, 's':False, 'd':False } self.enableMovement(self.hero) self.accept("mouse1", self.onClickin3D) self.accept('escape', sys.exit) self.accept('z', render.place) #== UI and Combat == self.gameplayUI = GameplayUI(self) self.gameplayUI.hideAll() # for health bars and on screen UI self.overlayAmbientLight = AmbientLight('overlayAmbientLight') self.overlayAmbientLight.setColor(VBase4(1.0, 1.0, 1.0, 1.0)) self.overlayAmbientLightNP = render.attachNewNode(self.overlayAmbientLight) # initialize the combat manager (which includes AI) now that a main character and gameplayUI instance and overlay light is established self.combatMgr = CombatMgr(self) # initialize player's spells self.heroSpells = [] for properties in PLAYER_SPELLS: spell = Spell(self.hero, properties) self.heroSpells.append(spell) #== Start Tasks taskMgr.add(self.moveHeroTask, 'moveHeroTask', appendTask=True) taskMgr.add(self.cameraFollowTask, 'cameraFollowTask', appendTask=True) taskMgr.add(self.processHeroCollisions, 'processHeroCollisions') taskMgr.add(self.updateHeroHeight, 'updateHeroHeight') self.combatMgr.startTasks() self.accept('enter', self.destroyLoadScreen) self.destroyLoadScreen() ##== Utility and World Initialization functions =============================## def loadJournal(self,journalMgr,journalFile): f = open(Filename(journalFile).toOsSpecific()) doc = xml.dom.minidom.parse(f) root = doc.childNodes[0] for n in root.childNodes: if n.localName == "journalEntries": journalMgr.decode(n) f.close() def getModelHeight(self, model): min, max = Point3(), Point3() model.calcTightBounds(min, max) return max.getZ() - min.getZ() def createLoadScreen(self, imageFile='./LEGameAssets/Textures/load_screen.png'): self.loadScreen = OnscreenImage(image=imageFile) aspect2d.hide() self.loadScreen.reparentTo(render2d) if(hasattr(self, "gameplayUI")): self.gameplayUI.hideAll() def destroyLoadScreen(self): self.loadBar.hide() self.loadScreen.detachNode() self.loadScreen.destroy() aspect2d.show() self.ignore('enter') self.gameplayUI.showAll() for name, gameObj in self.gameObjects.iteritems(): gameObj.callTrigger(self, 'LE-trigger-onScene') def startLoadBar(self, range=100): self.loadBar.show() self.loadBar['range'] = range self.loadBar['value'] = 0 base.graphicsEngine.renderFrame() def increaseLoadBar(self, value): self.loadBar['value'] += value base.graphicsEngine.renderFrame() ##== Collisions =============================================================## def setupCollisions(self): self.cTrav = CollisionTraverser('mainTraverser') self.cTrav.setRespectPrevTransform(True) # Line collider for setting hero height based on ground geometry heroLine = CollisionNode('heroLine') heroLine.addSolid(CollisionRay(Point3(0,0,self.heroHeight), Vec3(0,0,-1))) heroLine.setFromCollideMask(BITMASK_GROUND) heroLine.setIntoCollideMask(BitMask32.allOff()) self.heroGroundCollide = render.attachNewNode(heroLine) self.heroGroundHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.heroGroundCollide, self.heroGroundHandler) # cameraSphere = CollisionNode('cameraSphere') # cameraSphere.addSolid(CollisionSphere(0,0,0,10)) # cameraSphere.setFromCollideMask(BITMASK_CAMERA) # cameraSphere.setIntoCollideMask(BitMask32.allOff()) # self.cameraSphereCollide = self.cam.attachNewNode(cameraSphere) # self.cameraSphereQueue = CollisionHandlerQueue() # self.cTrav.addCollider(self.cameraSphereCollide, self.cameraSphereQueue) self.herowallcollision = False self.heroWallCollideX = render.attachNewNode("heroWallX") self.heroWallCollideY = render.attachNewNode("heroWallY") self.heroWallCollideZ = render.attachNewNode("heroWallZ") # Line collider for running into obstacles and walls in X direction heroLineX = CollisionNode('heroLineX') heroLineX.addSolid(CollisionRay(Point3(0,0,0), Vec3(0,0,1))) self.heroWallCollideLineX = self.heroWallCollideX.attachNewNode(heroLineX) self.heroWallCollideLineX.node().setFromCollideMask(BITMASK_WALL_TERRAIN) self.heroWallCollideLineX.node().setIntoCollideMask(BitMask32.allOff()) self.heroWallQueueX = CollisionHandlerQueue() self.cTrav.addCollider(self.heroWallCollideLineX, self.heroWallQueueX) # Line collider for running into obstacles and walls in Y direction heroLineY = CollisionNode('heroLineY') heroLineY.addSolid(CollisionRay(Point3(0,0,0), Vec3(0,0,1))) self.heroWallCollideLineY = self.heroWallCollideY.attachNewNode(heroLineY) self.heroWallCollideLineY.node().setFromCollideMask(BITMASK_WALL_TERRAIN) self.heroWallCollideLineY.node().setIntoCollideMask(BitMask32.allOff()) self.heroWallQueueY = CollisionHandlerQueue() self.cTrav.addCollider(self.heroWallCollideLineY, self.heroWallQueueY) # Line collider for running into obstacles and walls in Z direction heroLineZ = CollisionNode('heroLineZ') heroLineZ.addSolid(CollisionRay(Point3(0,0,0), Vec3(0,0,1))) self.heroWallCollideLineZ = self.heroWallCollideZ.attachNewNode(heroLineZ) self.heroWallCollideLineZ.node().setFromCollideMask(BITMASK_WALL_TERRAIN) self.heroWallCollideLineZ.node().setIntoCollideMask(BitMask32.allOff()) self.heroWallQueueZ = CollisionHandlerQueue() self.cTrav.addCollider(self.heroWallCollideLineZ, self.heroWallQueueZ) # # Sphere collider for running into obstacles and walls # heroSphere = CollisionNode('heroSphere') # heroSphere.addSolid(CollisionSphere(0,0,0,7)) # self.heroWallCollide = render.attachNewNode(heroSphere) # self.heroWallCollide.node().setFromCollideMask(BITMASK_WALL) # self.heroWallCollide.node().setIntoCollideMask(BitMask32.allOff()) # self.heroWallQueue = CollisionHandlerQueue() # self.cTrav.addCollider(self.heroWallCollide, self.heroWallQueue) # self.herowallcollision = False # Sphere collider for running into obstacles and walls in X direction heroSphereX = CollisionNode('heroSphereX') heroSphereX.addSolid(CollisionSphere(0,0,0,7)) self.heroWallCollideSphereX = self.heroWallCollideX.attachNewNode(heroSphereX) self.heroWallCollideSphereX.node().setFromCollideMask(BITMASK_WALL) self.heroWallCollideSphereX.node().setIntoCollideMask(BitMask32.allOff()) #self.heroWallQueueX = CollisionHandlerQueue() self.cTrav.addCollider(self.heroWallCollideSphereX, self.heroWallQueueX) self.herowallcollision = False # Sphere collider for running into obstacles and walls in Y direction heroSphereY = CollisionNode('heroSphereY') heroSphereY.addSolid(CollisionSphere(0,0,0,7)) self.heroWallCollideSphereY = self.heroWallCollideY.attachNewNode(heroSphereY) self.heroWallCollideSphereY.node().setFromCollideMask(BITMASK_WALL) self.heroWallCollideSphereY.node().setIntoCollideMask(BitMask32.allOff()) #self.heroWallQueueY = CollisionHandlerQueue() self.cTrav.addCollider(self.heroWallCollideSphereY, self.heroWallQueueY) # Sphere collider for running into obstacles and walls in Z direction heroSphereZ = CollisionNode('heroSphereZ') heroSphereZ.addSolid(CollisionSphere(0,0,0,7)) self.heroWallCollideSphereZ = self.heroWallCollideZ.attachNewNode(heroSphereZ) self.heroWallCollideSphereZ.node().setFromCollideMask(BITMASK_WALL) self.heroWallCollideSphereZ.node().setIntoCollideMask(BitMask32.allOff()) #self.heroWallQueueZ = CollisionHandlerQueue() self.cTrav.addCollider(self.heroWallCollideSphereZ, self.heroWallQueueZ) # Ray collider for clicking on objects in the game self.pickerCollisionQueue = CollisionHandlerQueue() self.pickerCN = CollisionNode('pickerRayCN') self.pickerCNP = self.cam.attachNewNode(self.pickerCN) self.pickerCN.setFromCollideMask(BITMASK_CLICK) self.pickerCN.setIntoCollideMask(BitMask32.allOff()) self.pickerRay = CollisionRay() self.pickerCN.addSolid(self.pickerRay) self.cTrav.addCollider(self.pickerCNP, self.pickerCollisionQueue) # Sphere collider for triggering scripts self.heroCN = CollisionNode('heroCN') self.heroCN.addSolid(CollisionSphere(0, 0, 0, 5)) # TODO: find good radius self.heroCNP = self.hero.attachNewNode(self.heroCN) self.heroCN.setFromCollideMask(BITMASK_HERO_COLLIDE) self.heroCN.setIntoCollideMask(BitMask32.allOff()) self.heroCollisionQueue = CollisionHandlerQueue() self.cTrav.addCollider(self.heroCNP, self.heroCollisionQueue) # Line collider for transparency self.cameraEntriesPre = [] radius = self.getModelHeight(self.hero)*CAMERA_TRAIL/2 self.cameraCollisionQueue = CollisionHandlerQueue() self.cameraHero = CollisionNode('cameraHero') self.cameraHeroLine = CollisionSegment(self.hero.getPos(render), self.cam.getPos(render)) self.cameraHero.addSolid(self.cameraHeroLine) self.cameraHero.setFromCollideMask(BITMASK_CAMERA) self.cameraHero.setIntoCollideMask(BitMask32.allOff()) self.cameraHeroP = self.render.attachNewNode(self.cameraHero) self.cTrav.addCollider(self.cameraHeroP, self.cameraCollisionQueue) #self.cameraHeroP.show() if FLAG_SHOW_COLLISIONS: self.cTrav.showCollisions(render) # TODO: show specific collision nodepaths def setCollideMasks(self, gameObjDict): for name, obj in gameObjDict.iteritems(): bitmask = obj.getCollideMask() if obj.hasTag('LE-ground'): bitmask |= BITMASK_GROUND #obj.getNP().setCollideMask(bitmask) # TODO: remove if obj.hasTag('LE-attackable'): bitmask |= BITMASK_CLICK if obj.hasTag('LE-wall'): if(isinstance(obj.getNP(), GeoMipTerrain)): bitmask |= BITMASK_TERRAIN else: bitmask |= BITMASK_WALL if obj.scripts.has_key('LE-trigger-onClick'): bitmask |=BITMASK_CLICK if obj.scripts.has_key('LE-trigger-onCollision'): bitmask |=BITMASK_HERO_COLLIDE if obj.hasTag('OBJRoot'): if obj.hasTag('LE-ground') or obj.hasTag('LE-mainChar'): pass else: bitmask |= BITMASK_CAMERA obj.setCollideMask(bitmask) def onClickin3D(self): pickedObj = None if self.conversationMgr.isConversationOpen(): return if base.mouseWatcherNode.hasMouse(): mpos = base.mouseWatcherNode.getMouse() else: return self.cTrav.addCollider(self.pickerCNP, self.pickerCollisionQueue) self.pickerRay.setFromLens(self.cam.node(), mpos.getX(), mpos.getY()) self.cTrav.traverse(render) if(self.pickerCollisionQueue.getNumEntries() > 0): self.pickerCollisionQueue.sortEntries() for i in range(self.pickerCollisionQueue.getNumEntries()): parent = self.pickerCollisionQueue.getEntry(i).getIntoNodePath().getParent() while not self.objects.has_key(parent.getName()): if(parent.getName() == "render"): return parent = parent.getParent() pickedObj = parent if(pickedObj == None): continue else: break #if pickedObj.hasTag("LE-trigger-onClick"): # TODO: needed, or is having key in self.objects enough? if (pickedObj == None): return self.pickerCollisionQueue.clearEntries() self.cTrav.removeCollider(self.pickerCNP) gameObj = self.gameObjects[pickedObj.getName()] distToTarget = self.hero.getDistance(gameObj) if self.combatMgr.checkCanAttack(self.hero, gameObj): if distToTarget <= self.heroSpells[self.curSpellIndex].getAttackRange(): self.combatMgr.queueAttack(self.hero, self.heroSpells[self.curSpellIndex], gameObj) else: textObject = OnscreenText(text = 'The target is out of range!',fg =(1,0,0,1), pos = (0, 0), scale = 0.09, align = TextNode.ACenter ) def destroyWarning1(): textObject.destroy() sequence =Sequence(Wait(2), Func(destroyWarning1)) sequence.start() return elif(distToTarget > CLICK_RANGE): textObject = OnscreenText(text = 'The target is out of range!',fg =(1,0,0,1), pos = (0, 0), scale = 0.09, align = TextNode.ACenter ) def destroyWarning2(): textObject.destroy() sequence =Sequence(Wait(2), Func(destroyWarning2)) sequence.start() return gameObj.callTrigger(self, 'LE-trigger-onClick') # Task for processing hero's collisions with GameObjects, triggering OnCollision scripts def processHeroCollisions(self, task): #self.cTrav.traverse(render) debug("processHeroCollisions") # CONSIDER: may not be necessary to sort if(self.heroCollisionQueue.getNumEntries() > 0): self.heroCollisionQueue.sortEntries() debug("queue size: "+str(self.heroCollisionQueue.getNumEntries())) for i in range(self.heroCollisionQueue.getNumEntries()): # CONSIDER: if entry.hasInto(): for efficiency debug("i: "+str(i)) # TODO: check if GameObject is passable, and react accordingly (store old position, revert to it) if(self.heroCollisionQueue.getNumEntries() <= 0): return entry = self.heroCollisionQueue.getEntry(i) debug("entry: "+str(entry)) if(entry): intoNP = entry.getIntoNodePath() else: continue if (intoNP != None) or (not intoNP.isEmpty()): while not self.objects.has_key(intoNP.getName()): if(intoNP.getName() == "render"): return task.cont intoNP = intoNP.getParent() pickedObj = intoNP if pickedObj == None: continue gameObj = self.gameObjects[pickedObj.getName()] gameObj.callTrigger(self, 'LE-trigger-onCollision') return task.cont ##== Camera Movement ========================================================## # places the camera pivot to match the position of the node path parameter # used to have the camera pivot match the main character's position as he moves def placeCamera(self, np): self.camPivot.setX(render, np.getX(render)) self.camPivot.setY(render, np.getY(render)) def alignCamera(self, np): self.camPivot.setH(render, self.hero.getH(render) + self.heroHeadingOffset) self.cam.setP(CAMERA_PITCH) def cameraFollowTask(self, task): heroH = self.hero.getH(render) + self.heroHeadingOffset camPivotH = self.camPivot.getH(render) # normalizes the headings to avoid jumps in the difference # which could come from passing 360 and going back to 0, for example # TODO: stress test, esp. with different values of self.heroHeadingOffset while heroH + 180 < camPivotH: heroH += 360 while camPivotH + 180 < heroH: camPivotH += 360 self.lastHeroH = heroH rotateLeft = (heroH >= camPivotH) rotateRight = not rotateLeft diff = math.fabs(heroH - camPivotH) if diff > CAMERA_TURN_THRESHOLD: if rotateLeft: self.camPivot.setH(self.camPivot.getH() + CAMERA_TURN_SPEED) elif rotateRight: self.camPivot.setH(self.camPivot.getH() - CAMERA_TURN_SPEED) # if(len(self.cameraEntriesPre)>0): # #print self.cameraEntriesPre # if(self.hero.getDistance(self.cam) > 5): # moveAmount = min(globalClock.getDt()*200,5.0) # pos = self.cam.getQuat().getForward()*moveAmount # newpos = self.cam.getPos() + pos # self.oldCameraEntriesPre = [] # for e in self.cameraEntriesPre: # self.oldCameraEntriesPre.append(e) # self.cam.setFluidPos(newpos) # # else: # if(self.hero.getDistance(self.cam) < 100): # moveAmount = min(globalClock.getDt()*200,5.0) # pos = self.cam.getQuat().getForward()*(-moveAmount) # oldpos = self.cam.getPos() # newpos = self.cam.getPos() + pos # self.cam.setFluidPos(newpos) # for e in self.oldCameraEntriesPre: # #print e.getIntoNodePath() # self.cTrav.traverse(e.getIntoNodePath()) # #self.cTrav.traverse(render) # if(len(self.cameraSphereQueue.getEntries())>0): # self.cam.setFluidPos(oldpos) return task.cont def runCamera(self, cameraName, sequence, isLoop = False): debug("Running the camera") #debug(str(self.sequences)) self.oldCamera = self.cam self.dr = self.win.makeDisplayRegion() dr2 = self.cam.node().getDisplayRegion(0)# self.objects[cameraName].node().setLens(base.camLens) parent = self.cam.getParent() self.cam.detachNode() self.dr.setCamera(self.objects[cameraName]) def temp(): dr2.setCamera(self.oldCamera) self.oldCamera.reparentTo(parent) self.dr.setActive(False) del self.dr self.dr = None self.accept("mouse1", self.onClickin3D) debug("Ran") if(isLoop): newSequence = Sequence(sequence) self.addSequence(newSequence) def stopCameraFromLoop(): newSequence.finish() temp() self.accept("mouse1", stopCameraFromLoop) self.addSequence(newSequence) newSequence.loop() else: newSequence = Sequence(sequence,Func(temp)) def stopCamera(): newSequence.finish() self.accept("mouse1", stopCamera) self.addSequence(newSequence) newSequence.start() ##== Character Movement =====================================================## def moveHeroTo(self, destinationObj): pos = destinationObj.getPos(render) hpr = destinationObj.getHpr(render) self.hero.setPosHpr(render, pos, hpr) self.placeCamera(self.hero) self.alignCamera(self.hero) def updateHeroHeight(self, task=None): groundEntries = [] #move the collision line to the hero position self.heroGroundCollide.setPos(self.hero.getPos(render)) #loop through every collision entry for the line for e in self.heroGroundHandler.getEntries(): if e.getIntoNodePath().hasNetTag('OBJRoot'): #find the actual root of the object np = e.getIntoNodePath().findNetTag('OBJRoot') #only react to objects that are tagged as the ground if np.hasTag('LE-ground'): groundEntries.append(e) if groundEntries: #sort the collision entries based on height groundEntries.sort(lambda x,y: cmp(y.getSurfacePoint(render).getZ(),\ x.getSurfacePoint(render).getZ())) #set hero height and pivot height self.hero.setZ(groundEntries[0].getSurfacePoint(render).getZ() + MAIN_CHAR_GROUND_OFFSET) self.camPivot.setZ(groundEntries[0].getSurfacePoint(render).getZ() + MAIN_CHAR_GROUND_OFFSET) # TODO: unlink these from being in the same task in case we want pivot to not be linked to hero (ex. cutscene) self.heroGroundHandler.clearEntries() return task.cont def updateHeroPos(self, queue, stepSize): wallEntries = [] for w in queue.getEntries(): np = w.getIntoNodePath().findNetTag('OBJRoot') if np.hasTag('LE-wall'): if self.isInObstacleRange(self.hero, w, stepSize): wallEntries.append(w) if len(wallEntries) > 0: self.herowallcollision = True #self.collisionsurfaceP = wallEntries[0].getSurfacePoint(render) else: self.herowallcollision = False def updateCameraCollision(self): self.cameraHeroLine.setPointA(self.cam.getPos(render)) self.cameraHeroLine.setPointB(self.hero.getPos(render)) if(self.cameraEntriesPre): for i in self.cameraEntriesPre: i.getIntoNodePath().setTransparency(TransparencyAttrib.MAlpha) i.getIntoNodePath().setAlphaScale(1.0) del self.cameraEntriesPre[:] for i in self.cameraCollisionQueue.getEntries(): i.getIntoNodePath().setAlphaScale(0.5) self.cameraEntriesPre.append(i) def moveHero(self,direction, dt): temp = render.attachNewNode("Dummy")#NodePath() moveStep = MAIN_CHAR_MOVE_SPEED*dt if moveStep > MAIN_CHAR_MAX_STEP: moveStep = MAIN_CHAR_MAX_STEP temp.setPos(self.camPivot, 0,direction*moveStep, 0) #oldPos = self.heroWallCollideX.getPos() self.heroWallCollideX.setX(temp.getX()) self.heroWallCollideY.setY(temp.getY()) self.heroWallCollideZ.setZ(temp.getZ())#+10) self.cTrav.traverse(render) #check on X direction self.updateHeroPos(self.heroWallQueueX, moveStep) self.moveHeroToWallCollide(Point3(temp.getX(),self.hero.getY(),self.hero.getZ())) #check on Y direction self.updateHeroPos(self.heroWallQueueY, moveStep) self.moveHeroToWallCollide(Point3(self.hero.getX(),temp.getY(),self.hero.getZ())) #check on Z direction self.updateHeroPos(self.heroWallQueueZ, moveStep) self.moveHeroToWallCollide(Point3(self.hero.getX(),self.hero.getY(),temp.getZ())) self.heroWallCollideX.setPos(self.hero.getPos()) self.heroWallCollideY.setPos(self.hero.getPos()) self.heroWallCollideZ.setPos(self.hero.getPos()) self.placeCamera(self.hero) self.updateCameraCollision() temp.detachNode() def moveHeroToWallCollide(self,pos): if self.herowallcollision==False: self.hero.setPos(pos)#self.camPivot, 0, MAIN_CHAR_MOVE_SPEED, 0) def isInObstacleRange(self, mover, colEntry, stepSize): colPoint = colEntry.getSurfacePoint(render) if colPoint[2] >= mover.getZ(render): dist = findDistance3D(mover.getX(), mover.getY(), mover.getZ(), colPoint[0], colPoint[1], colPoint[2]) obstacleThreshold = self.heroHeight*self.heroHeight + stepSize*stepSize if dist*dist <= obstacleThreshold: return True return False def turnHeroLeft(self): up = render.getRelativeVector(base.cam, Vec3(0, 0, 1)) up.normalize() curHeroQuat = self.hero.getQuat() newHeroQuat = Quat() newHeroQuat.setFromAxisAngle(MAIN_CHAR_ROTATE_SPEED, up) self.hero.setQuat(curHeroQuat*newHeroQuat) self.hero.setR(0) self.hero.setP(0) self.updateCameraCollision() def turnHeroRight(self): up = render.getRelativeVector(base.cam, Vec3(0, 0, 1)) up.normalize() curHeroQuat = self.hero.getQuat() newHeroQuat = Quat() newHeroQuat.setFromAxisAngle(-MAIN_CHAR_ROTATE_SPEED, up) self.hero.setQuat(curHeroQuat*newHeroQuat) self.hero.setR(0) self.hero.setP(0) self.updateCameraCollision() def disableMovement(self, gameObj): if gameObj.getName() == self.hero.getName(): self.ignore('w') self.ignore('w-up') self.ignore('a') self.ignore('a-up') self.ignore('s') self.ignore('s-up') self.ignore('d') self.ignore('d-up') else: if gameObj.getAIBehaviorsHandle().behaviorStatus('pursue') != -1: gameObj.getAIBehaviorsHandle().pauseAi('pursue') def enableMovement(self, gameObj): if gameObj.getName() == self.hero.getName(): self.accept('w', self.setKeyStatus, extraArgs=['w', True]) self.accept('w-up', self.setKeyStatus, extraArgs=['w', False]) self.accept('a', self.setKeyStatus, extraArgs=['a', True]) self.accept('a-up', self.setKeyStatus, extraArgs=['a', False]) self.accept('s', self.setKeyStatus, extraArgs=['s', True]) self.accept('s-up', self.setKeyStatus, extraArgs=['s', False]) self.accept('d', self.setKeyStatus, extraArgs=['d', True]) self.accept('d-up', self.setKeyStatus, extraArgs=['d', False]) else: if gameObj.getAIBehaviorsHandle().behaviorStatus('pursue') == 'paused': gameObj.getAIBehaviorsHandle().resumeAi('pursue') def setKeyStatus(self, key, isDown): self.keyMap[key] = isDown print self.hero.getName() ###################################################################### ## # ZJC - 07/29/2011: THIS CODE WAS COMMENTED OUT BECAUSE A MORE EFFICIENT WAY WAS FOUND ## ## prefixList = [] ## #NEXT LINE- ZJC - 07/29/2011: This line is used to mark where to import the array used to deal with import flags. ## #LoaderFlagImportArray ## name = self.hero.getName().split('_')[0] # ZJC - 07/29/2011: name is assumed to be formatted NAME_otherstuff ## name2 = self.hero.getName().split('_')[1] # ZJC - 07/29/2011: name2 is assumed to be PREFIX_NAME_otherstuff ## if name in prefixList: # ZJC - 07/29/2011: Checks if the name is in the array, if it is name is not formatted as assumed ## name = name2 # ZJC - 07/29/2011: Use the second format if the first name is in the list ## print name ###################################################################### name = self.hero.getName().split('_')[0] # ZJC - 07/29/2011: Assumes format is Name_mod:# ## print name for i in range(len(self.here.getName().split('_'))): # ZJC - 07/29/2011: Loop will check every possibility in the name string for any level of merges/imports name2 = self.hero.getName().split('_')[i] # ZJC - 07/29/2011: name2 holds the current piece of the name string if ("mod:" in name2) and (name != name2): # ZJC - 07/29/2011: This means the name format is Prefix(es)_Name_mod:# name = self.hero.getName().split('_')[i-1] # ZJC - 07/29/2011: Assigns correct model name, the one just before mod:# if isDown: if key == 'w': if self.hero.getActorHandle() != None: self.hero.getActorHandle().stop(name + '_ani_idle') # ZJC - 07/26/2011: Stop the 'name' specific idle animation self.hero.getActorHandle().setPlayRate(1.0, name + '_ani_run') # ZJC - 07/26/2011: Set play rate for the 'name' specific run animation self.hero.getActorHandle().loop(name + '_ani_run') # ZJC - 07/26/2011: Run the 'name' specific run animation self.keyMap['s'] = False elif key == 's': if self.hero.getActorHandle() != None: self.hero.getActorHandle().stop(name + '_ani_idle') # ZJC - 07/26/2011: Stop the 'name' specific idle animation self.hero.getActorHandle().setPlayRate(-0.7, name + '_ani_run') # ZJC - 07/26/2011: Set play rate for the 'name' specific run animation self.hero.getActorHandle().loop(name + '_ani_run') # ZJC - 07/26/2011: Run the 'name' specific run animation self.keyMap['w'] = False elif key == 'a': self.keyMap['d'] = False elif key == 'd': self.keyMap['a'] = False elif not isDown: if key == 'w': if not self.keyMap['s']: if self.hero.getActorHandle() != None: self.hero.getActorHandle().stop(name + '_ani_run') # ZJC - 07/26/2011: Stop the 'name' specific run animation self.hero.getActorHandle().loop(name + '_ani_idle') # ZJC - 07/26/2011: Run the 'name' specific idle animation elif key == 's': if not self.keyMap['w']: if self.hero.getActorHandle() != None: self.hero.getActorHandle().stop(name + '_ani_run') # ZJC - 07/26/2011: Stop the 'name' specific run animation self.hero.getActorHandle().loop(name + '_ani_idle') # ZJC - 07/26/2011: Run the 'name' specific idle animation elif key == 'a': pass elif key == 'd': pass ## ZJC - 07/26/2011: This was the previous version of the code, it has been commented out and left as ## a reference. The changes made are defined in the comments above. ## if isDown: ## if key == 'w': ## if self.hero.getActorHandle() != None: ## self.hero.getActorHandle().stop('anim_idleFemale') # TODO: make a constant / set in LE ## self.hero.getActorHandle().setPlayRate(1.0, 'anim_jogFemale') ## self.hero.getActorHandle().loop('anim_jogFemale') ## self.keyMap['s'] = False ## elif key == 's': ## if self.hero.getActorHandle() != None: ## self.hero.getActorHandle().stop('anim_idleFemale') # TODO: make a constant / set in LE ## self.hero.getActorHandle().setPlayRate(-0.7, 'anim_jogFemale') ## self.hero.getActorHandle().loop('anim_jogFemale') ## self.keyMap['w'] = False ## elif key == 'a': ## self.keyMap['d'] = False ## elif key == 'd': ## self.keyMap['a'] = False ## elif not isDown: ## if key == 'w': ## if not self.keyMap['s']: ## if self.hero.getActorHandle() != None: ## self.hero.getActorHandle().stop('anim_jogFemale') ## self.hero.getActorHandle().loop('anim_idleFemale') ## elif key == 's': ## if not self.keyMap['w']: ## if self.hero.getActorHandle() != None: ## self.hero.getActorHandle().stop('anim_jogFemale') ## self.hero.getActorHandle().loop('anim_idleFemale') ## elif key == 'a': ## pass ## elif key == 'd': ## pass def moveHeroTask(self, task): dt = globalClock.getDt() direction = int(self.keyMap['w'])-int(self.keyMap['s']) self.moveHero(direction, dt) if self.keyMap['a']: self.turnHeroLeft() elif self.keyMap['d']: self.turnHeroRight() return task.cont ##== Scene Handling =========================================================## def loadScenes(self): # NOTE: Do not remove! This function is populated by StandaloneExporter pass def addSequence(self, sequence): self.ranSequences.append(sequence) #this is for changing scenes def resetAllSequences(self): for seq in self.ranSequences: seq.finish() dr = self.cam.node().getDisplayRegion(0) dr.setCamera(self.gameCam) self.ranSequences = [] def openScene(self, sceneName): if (self.scenes.has_key(sceneName)==False): print "ERROR:There is no scene under the name ", sceneName,"." return self.startLoadBar(12) self.createLoadScreen() #Part2:Clear all of the collision lists self.cTrav.removeCollider(self.heroCNP) self.heroGroundHandler.clearEntries() self.heroCollisionQueue.clearEntries() self.resetAllSequences() self.increaseLoadBar(1) #Part3: stop all of the tasks taskMgr.remove('processHeroCollisions') taskMgr.remove('updateHeroHeight') taskMgr.remove('moveHeroTask') taskMgr.remove('cameraFollowTask') taskMgr.remove("updateShaders") # ? self.combatMgr.stopTasks() self.gameplayUI.stop() self.gameplayUI.removeAllHealthBars() self.increaseLoadBar(1) #Part1.1: Stop currently running parts like conversations or camera if(self.conversationMgr.isConversationOpen()): self.conversationMgr.closeConversation() #Part 1.2: stop the camera self.increaseLoadBar(1) #Part4: Turn-Off all of the player controls self.ignore("mouse1") self.increaseLoadBar(1) #Part5: Remove all of the game elements that are related with the current scene del self.combatMgr self.increaseLoadBar(1) #Part6: Remove all of the children and the lights from the render render.getChildren().detach() render.clearLight() self.increaseLoadBar(1) #Part7:Add the camera and hero or any game element that should be exist in any scene back self.camPivot.reparentTo(render) self.hero.reparentTo(render) #self.heroWallCollide.reparentTo(render) self.heroWallCollideX.reparentTo(render) self.heroWallCollideY.reparentTo(render) self.heroWallCollideZ.reparentTo(render) self.heroGroundCollide.reparentTo(render) self.cameraHeroP.reparentTo(render) self.overlayAmbientLightNP.reparentTo(render) self.increaseLoadBar(1) #Part8:Add the new objects from the new scene self.assets, self.objects, self.gameObjects, self.sounds, self.sequences = loadWorld(self.scenes[sceneName], LIBRARY_INDEX) self.increaseLoadBar(1) #Part9:Add the hero to the new gameObject list and remove the duplicates of the hero self.gameObjects[self.hero.getName()] = self.hero if(self.objects.has_key(self.hero.getName())): object = self.objects[self.hero.getName()] if(object.hasTag('LE-mainChar')): object.detachNode() del self.objects[self.hero.getName()] for name, gameObj in self.gameObjects.iteritems(): if gameObj.getNP().hasTag('LE-ground'): #debug("is Ground") bitmask = gameObj.getNP().getCollideMask() bitmask |= BITMASK_GROUND gameObj.getNP().setCollideMask(bitmask) self.increaseLoadBar(1) #Part10:Restart the tasks. self.combatMgr = CombatMgr(self) taskMgr.add(self.processHeroCollisions, 'processHeroCollisions') taskMgr.add(self.updateHeroHeight, 'updateHeroHeight') taskMgr.add(self.moveHeroTask, 'moveHeroTask') taskMgr.add(self.cameraFollowTask, 'cameraFollowTask') self.combatMgr.startTasks() self.gameplayUI.start() self.increaseLoadBar(1) self.setCollideMasks(self.gameObjects) self.increaseLoadBar(1) #Part11: Change the color of the sky if(sceneName.startswith("interior") or sceneName.startswith("Interior")): self.setBackgroundColor(BGC_DARK_GREY) else: self.skybox.reparentTo(render) self.setBackgroundColor(BGC_LIGHT_BLUE) self.increaseLoadBar(1) #Part12: Restart the player controls self.accept("mouse1", self.onClickin3D) self.increaseLoadBar(1) self.accept("enter",self.destroyLoadScreen) debug("After open Scene: "+str(self.heroCollisionQueue.getNumEntries())) self.heroCollisionQueue.clearEntries() self.cTrav.addCollider(self.heroCNP, self.heroCollisionQueue) self.destroyLoadScreen()
def volumetricLightTest(self, model): fltr = CommonFilters(base.win, base.cam) fltr.setVolumetricLighting(model,64,2,.85,0.3)
class Universe(DirectObject): def __init__(self, neweval, starList=[]):#, console=[]): #messenger.toggleVerbose() self.stars=starList self.mouselook=True self.zoom = .33 self.mapMode = False self.evaluator = neweval self.hudScale = 1 self.objectScale=.01 self.starScale = .1 self.skyScale=40000 self.dt=.02 self.starting=True self.mouseX = 0 self.mouseY = 0 self.dX=0 self.dY=0 self.dZ=0 self.player = Body() ## self.mouseBody = Body() ## self.mouseBody.name = "mouse" self.player.name = "player" self.player.mass = 0 self.player.position.x=0 self.player.position.y=0 self.player.position.z=-0.04 self.player.orientation.y=90 self.accRate =2 # self.player.bodies=[] # self.evaluator.system.bodies.append(self.player) neweval.system.bodies.append(self.player) self.evaluator= soPhysics.soPhysics(neweval.system) self.evaluator.system.moveToStar() self.filters = CommonFilters(base.win, base.cam) self.filterok = self.filters.setBloom(blend=(1,1,1,1), desat=-0.5, intensity=1.0, size="small") self.glowSize=1 #base.enableParticles() #self.p = ParticleEffect() #self.p.loadConfig("sun2.ptf") self.loadPlanets() #self.console = console self.toggleConsole() if len(starList)>0: self.loadStars() base.camLens.setNear(0.01) base.camLens.setFar(100000) # base.camLens.setFar(170000000000000000000000000000000000000) self.mouselook=False #render.setShaderAuto() self.loadLights() taskMgr.add(self.move,"move") def loadLights(self): plight = PointLight('plight') plight.setColor(VBase4(1, 1, 1, 1)) self.plnp = render.attachNewNode(plight) self.plnp.setPos(0, 0, 0) render.setLight(self.plnp) self.ambientLight = AmbientLight( 'ambientLight' ) self.ambientLight.setColor( Vec4( 0.1, 0.1, 0.1, 1 ) ) self.ambientLightNP = render.attachNewNode( self.ambientLight.upcastToPandaNode() ) render.setLight(self.ambientLightNP) def loadStars(self): print "loading stars" for star in self.stars: star.body.node = render.attachNewNode(star.body.name) star.body.sphere = loader.loadModelCopy("models/dodecahedron") sunMaterial =Material() #sunMaterial.setEmission(VBase4(1,1,1,1)) sunMaterial.setEmission(VBase4(star.color[0],star.color[1],star.color[2], 1)) star.body.node.setMaterial(sunMaterial) star.body.sphere.reparentTo(star.body.node) star.body.sphere.setScale(self.starScale * star.radius) star.body.node.setPos(star.body.position.x,star.body.position.y,star.body.position.z) def setTexture(self, body, i): if body.mass< 0.001: body.texture = loader.loadTexture("models/earthmoon.jpg") elif body.mass >= 0.001 and body.mass < .002: body.texture = loader.loadTexture("models/mars.jpg") elif body.mass >= .002 and body.mass < .003: body.texture = loader.loadTexture("models/venus.jpg") elif body.mass >= .003 and body.mass < .006: body.texture = loader.loadTexture("models/mercury.jpg") elif body.mass >= .006 and body.mass < .009: body.texture = loader.loadTexture("models/pluto.jpg") elif body.mass >= .009 and body.mass < .01: body.texture = loader.loadTexture("models/uranus.jpg") elif body.mass >= .01 and body.mass < .03: body.texture = loader.loadTexture("models/saturn.jpg") elif body.mass >= .03 and body.mass < .05: body.texture = loader.loadTexture("models/neptune.jpg") elif body.mass >= .05 and body.mass < .1: body.texture = loader.loadTexture("models/saturn.jpg") elif body.mass >= .1 and body.mass < .2: body.texture = loader.loadTexture("models/jupiter.jpg") else : print body.mass sunMaterial =Material() sunMaterial.setTwoside(True) body.name = "star" #body.setColor(VBase4(1,1,1,1)) #self.p.start(parent = body.node, renderParent = body.node) if body.mass >=.7 and body.mass < 1.0: #M type body.texture = loader.loadTexture("models/Mstar.jpg") sunMaterial.setEmission(VBase4(1,.6,.6,1)) elif body.mass >= 1.0 and body.mass < 1.5: #K type body.texture = loader.loadTexture("models/Kstar.jpg") sunMaterial.setEmission(VBase4(1,.6,.6,1)) elif body.mass >= 1.0 and body.mass < 1.5: #G type body.texture = loader.loadTexture("models/GMstar.jpg") sunMaterial.setEmission(VBase4(1,.6,.6,1)) #elif body.mass >= 1.5 and body.mass < 1.5: #G type #body.texture = loader.loadTexture("models/Mstar.jpg") #sunMaterial.setEmission(VBase4(1,.6,.6,1)) else: body.texture = loader.loadTexture("models/Ostar.jpg") sunMaterial.setEmission(VBase4(.8,.8,1,1)) body.node.setShaderAuto() body.node.setMaterial(sunMaterial) body.sphere.setTexture(body.texture,1) def loadSinglePlanet(self, body,i): body.node = render.attachNewNode(body.name) if self.evaluator.gridSystem.names[i]!="player" and body.name != "player": body.sphere = loader.loadModelCopy("models/planet_sphere") body.sphere.reparentTo(body.node) self.scalebody( i) ## scaleRate = ((math.sqrt(self.evaluator.gridSystem.mass[i]))/100)+.01 ## body.sphere.setScale(scaleRate) ## self.evaluator.gridSystem.rad[i]=scaleRate ## body.mass=self.evaluator.gridSystem.mass[i] ## self.setTexture(body, i) body.node.setPos(self.evaluator.gridSystem.pos[i][0], self.evaluator.gridSystem.pos[i][1], self.evaluator.gridSystem.pos[i][2]) else: self.loadPlayer(body) def detachNode(self, i): #count = len(self.evaluator.system.bodies)-1 print "detaching node: ",i#count self.evaluator.system.bodies[i].node.detachNode() def loadPlanets(self): pval = self.evaluator.gridSystem.player print "player: ",pval print self.evaluator.gridSystem.getPlayerIndex() i=0 for body in self.evaluator.system.bodies: if i ==pval: print "player at: ",i self.loadPlayer(self.player) if i != pval: self.loadSinglePlanet(body,i) i+=1 self.sky = loader.loadModel("models/solar_sky_sphere") self.sky_tex = loader.loadTexture("models/startex.jpg") self.sky.setTexture(self.sky_tex, 1) self.sky.setScale(self.skyScale) self.sky.reparentTo(render) def scaleUp(self): self.accRate*= 1.01 print "accRate increasing",self.accRate ## print self.starScale ## for star in self.stars: ## star.body.sphere.setScale(self.starScale) def scaleDown(self): self.accRate*= .99 print "accRate decreasing",self.accRate ## print self.starScale ## for star in self.stars: ## star.body.sphere.setScale(self.starScale) def toggleConsole(self): print "toggle console" #self.console.toggle() def addPlanet(self): self.loadSinglePlanet(self.evaluator.system.addSinglePlanet()) return def loadRoid(self, abody): if(len(self.player.bodies)<10): self.player.bodies.append(abody) self.evaluator.system.bodies.append(abody) self.evaluator.accelerateCuda() abody.node = render.attachNewNode(abody.name) abody.model = loader.loadModelCopy("models/planet_sphere") abody.model.reparentTo(abody.node) abody.texture = loader.loadTexture("models/pluto.jpg") abody.model.setScale(.01) abody.node.setPos(abody.position.x ,abody.position.y ,abody.position.z) return def deloadRoid(self): if(len(self.player.bodies) >0): abody = self.player.bodies.pop() self.evaluator.system.bodies.pop() abody.node.detachNode() return def loadPlayer(self, abody): abody.node = render.attachNewNode(abody.name) abody.model = loader.loadModelCopy("models/fighter") abody.model.reparentTo(abody.node) if abody.name == "player": abody.texture = loader.loadTexture("models/texturemap.png") elif abody.name == "mouse": abody.texture = loader.loadTexture("models/sun.jpg") abody.model.setScale(.00005) abody.radius=.00005 i = self.evaluator.gridSystem.getPlayerIndex() self.evaluator.gridSystem.rad[i]=0.01 abody.node.setPos(self.evaluator.gridSystem.pos[i][0], self.evaluator.gridSystem.pos[i][1], self.evaluator.gridSystem.pos[i][2]) def exit(self): quit() return def fullscreen(self): print "doh" def move(self,task): # self.accept("p", self.addPlanet) self.accept("`", self.toggleConsole) self.accept("wheel_right", self.tiltLeft) self.accept("wheel_left", self.tiltRight) # self.accept("mouse6", self.tiltLeft) # self.accept("mouse7", self.tiltRight) #self.accept("w", self.tiltLeft) #self.accept("r", self.tiltRight) self.accept("mouse2", self.handlemouse2Click) #self.accept("mouse3", self.handleRightMouseClick) #self.accept("mouse1", self.handleLeftMouseClick) self.accept("wheel_up", self.zoomIn) self.accept("wheel_down", self.zoomOut) self.accept("escape", self.exit) self.accept("space",self.stop) self.accept("s",self.brake) self.accept("w",self.accelerate) self.accept("f",self.fullscreen) self.accept("m",self.togglemap) self.accept("[",self.scaleDown) self.accept("]",self.scaleUp) self.accept("l",self.togglemouselook) dt = self.dt if not self.mapMode: self.evaluator.accelerateCuda() self.updateMouse(self.player) if self.starting: dt=dt/2.0 self.starting=False #self.reloadPlanets() self.setAllPositions() return Task.cont def tiltLeft(self): print "left" self.player.orientation.z-=10 def tiltRight(self): print "right" self.player.orientation.z+=10 def togglemouselook(self): print "toggling mouselook" if self.mouselook: self.mouselook = False else: self.mouselook = True def togglemap(self): print "toggling map" if (self.mapMode): self.mapMode=False self.zoom=1.1 else: self.mapMode=True self.zoom = 59000 def accelerate(self): print "accelerating ship" i = self.evaluator.gridSystem.getPlayerIndex() self.evaluator.gridSystem.acc[i][0]+=self.dX*8 self.evaluator.gridSystem.acc[i][1]+=self.dY*8 self.evaluator.gridSystem.acc[i][2]+=self.dZ*8 #self.evaluator.gridSystem.printBody(i) return def stop(self): i = self.evaluator.gridSystem.player print "stopping ship", i self.evaluator.gridSystem.printBody(i) self.evaluator.gridSystem.vel[i][0]=0.0 self.evaluator.gridSystem.vel[i][1]=0.0 self.evaluator.gridSystem.vel[i][2]=0.0 return def brake(self): print "slowing ship" i = self.evaluator.gridSystem.player self.evaluator.gridSystem.printBody(i) self.evaluator.gridSystem.acc[i][0]-=self.dX self.evaluator.gridSystem.acc[i][1]-=self.dY self.evaluator.gridSystem.acc[i][2]-=self.dZ def handleMouse2(self): print "deccelerating ship" self.player.acceleration.x-=self.dX/10 self.player.acceleration.y-=self.dY/10 self.player.acceleration.z-=self.dZ/10 def handlemouse2Click(self): print "mouse2" self.togglemouselook() def handlemouseLeftClick(self): print "mouseLeft" def handlemouseRightClick(self): print "mouseRight" def handleLeftMouseClick(self): print "impactor deployed" abody=Body() abody.velocity.x = self.player.velocity.x abody.velocity.y = self.player.velocity.y abody.velocity.z = self.player.velocity.z abody.position.x = self.player.position.x abody.position.y = self.player.position.y abody.position.z = self.player.position.z abody.acceleration.x += self.dX/15 abody.acceleration.y += self.dY/15 abody.acceleration.z += self.dZ/15 abody.mass =0.00000001 self.loadRoid(abody) return def handleRightMouseClick(self): print "removing impactor" self.deloadRoid() def zoomIn(self): self.zoom*=0.9 print self.zoom #self.scaleDown() return def zoomOut(self): self.zoom*=1.1 print self.zoom #self.scaleUp() if self.zoom > 60000: self.zoomIn() return def updateMouse(self, abody): if (True): newX=self.mouseX newY=self.mouseY if self.mouselook and base.mouseWatcherNode.hasMouse(): newX = base.mouseWatcherNode.getMouseX() newY = base.mouseWatcherNode.getMouseY() deltaX = self.mouseX - newX deltaY = self.mouseY - newY self.mouseX = newX self.mouseY = newY if abody.orientation.y >360: abody.orientation.y -=360 if abody.orientation.x >360: abody.orientation.x -=360 if abody.orientation.y > 180: abody.orientation.y += (360*deltaY) else: abody.orientation.y -= (360*deltaY) if abody.orientation.y > 180: abody.orientation.x -= (360*deltaX) else: abody.orientation.x += (360*deltaX) self.dZ = self.zoom*math.sin((-abody.orientation.y+180)*(math.pi / 180.0)) hyp = self.zoom*math.cos((-abody.orientation.y+180)*(math.pi / 180.0)) self.dX = hyp * math.sin((-abody.orientation.x+180)*(math.pi / 180.0)) self.dY = hyp * math.cos((-abody.orientation.x+180)*(math.pi / 180.0)) base.camera.setHpr(abody.orientation.x, abody.orientation.y,abody.orientation.z) cpos=self.evaluator.gridSystem.getPlayerIndex() #base.camera.printPos() base.camera.setPos(self.evaluator.gridSystem.pos[cpos][0]-self.dX, self.evaluator.gridSystem.pos[cpos][1]-self.dY, self.evaluator.gridSystem.pos[cpos][2]-self.dZ) def setAllPositions(self): for j in self.evaluator.gridSystem.collisions: self.scalebody(j) self.evaluator.gridSystem.collisoins=[] for k in self.evaluator.gridSystem.removed: self.detachNode(k) ## abody = Body(self.evaluator.system.getDirectedPlanet()) ## self.evaluator.gridSystem.insertBody(abody,k) ## self.loadSinglePlanet(abody, k) self.evaluator.gridSystem.removed=[] i=0 for body in self.evaluator.system.bodies: self.set_body_position(body, self.evaluator.gridSystem.pos[i][0], self.evaluator.gridSystem.pos[i][1], self.evaluator.gridSystem.pos[i][2]) i+=1 def scalebody(self, i): body = self.evaluator.system.bodies[i] if body.name == "player": print "rescaling: ",i," ",body.name raw_input() scaleRate = ((math.sqrt(self.evaluator.gridSystem.mass[i]))/50)+.001 body.sphere.setScale(scaleRate) self.evaluator.gridSystem.rad[i]=scaleRate body.mass=self.evaluator.gridSystem.mass[i] self.setTexture(body, i) def set_body_position(self,body,x,y,z): if body.name == "star": #print "moving light" self.plnp.setPos(x,y,z) body.node.setPos(x,y,z) body.node.setHpr(body.orientation.x, body.orientation.y, body.orientation.z)
def __init__(self,manager,xml): self.cf = CommonFilters(base.win,base.cam) self.reload(manager,xml)