def generate(self): self.level = 12 self.maxHealth = 200 self.health = 200 Suit.generate(self, FactorySneakGuardSuit.SUIT, FactorySneakGuardSuit.VARIANT, hideFirst=False) self.setName(self.suitPlan.getName(), None) self.cleanupPropeller() base.taskMgr.add(self.__viewDistance, self.viewDistanceTaskName) self.setPythonTag('guard', self) self.eyeLight = Spotlight('eyes') self.eyeLens = PerspectiveLens() self.eyeLens.setMinFov(90.0 / (4. / 3.)) self.eyeLight.setLens(self.eyeLens) self.eyeNode = self.headModel.attachNewNode(self.eyeLight) self.eyeNode.setZ(-5) self.eyeNode.setY(-4.5) self.trav = CollisionTraverser(self.uniqueName('eyeTrav')) ray = CollisionRay(0, 0, 0, 0, 1, 0) rayNode = CollisionNode('ToonFPS.rayNode') rayNode.addSolid(ray) rayNode.setFromCollideMask(CGG.GuardBitmask | CIGlobals.WallBitmask) rayNode.setIntoCollideMask(BitMask32.allOff()) self.rayNP = base.camera.attachNewNode(rayNode) self.rayNP.setZ(3) self.queue = CollisionHandlerQueue() self.trav.addCollider(self.rayNP, self.queue) self.trav.addCollider(self.gameWorld.mg.avatarBody, self.queue) self.request('Guard')
def __init__(self): self.hotelModel = loader.loadModel("menuBG/menuback") self.hotelModel.reparentTo(render) self.hotelModel.stash() # setup some lights plight = PointLight("mapgen_plight") plight.setColor(VBase4(0.45, 0.35, 0.35, 1)) self.plnp = self.hotelModel.attachNewNode(plight) self.plnp.setPos(-3, 3, 5) base.render.setLight(self.plnp) # setup a default ambient light alight = AmbientLight("mapgen_alight") alight.setColor(VBase4(0.20, 0.20, 0.28, 1)) self.alnp = self.hotelModel.attachNewNode(alight) base.render.setLight(self.alnp) sun = DirectionalLight('sun') sun.setColor(VBase4(0.8, 0.8, 0.8, 1)) lens = PerspectiveLens() lens.setFar(50) lens.setFov(80, 80) sun.setLens(lens) ms = 1024 #graphicMgr.shadowMapSize sun.setShadowCaster(True, ms, ms) self.sunnp = self.hotelModel.attachNewNode(sun) self.sunnp.setHpr(85, -50, 0) self.sunnp.setPos(12, 0, 10) base.render.setLight(self.sunnp)
def __init__(self, _base): self.game = _base # Player object self.playerObject = self.game.meotech.engine.GameObjects["player"] # Attach the flashlight cone to the player (self, _height, _radius, _pos, _hpr) self.flashlightConeBody = self.game.meotech.engine.factory.basePhysics.buildConeShape(10.0, 1.5, self.playerObject.bulletBody.getPos(), self.playerObject.bulletBody.getHpr()) # Attach the flashlight model to the player self.flashlight = loader.loadModel("game/models/flashlight") self.flashlight.setScale(0.2) self.flashlight.reparentTo(self.flashlightConeBody) # Attach the light to the flashlight model slight = Spotlight('slight') slight.setColor(VBase4(1, 1, 1, 1)) lens = PerspectiveLens() lens.setFar(25) lens.setFov(40, 40) slight.setLens(lens) slight.setShadowCaster(True, 512, 512) self.flashlightLight = render.attachNewNode(slight) self.flashlightLight.reparentTo(self.flashlight.find("LightPos")) render.setLight(self.flashlightLight) self.flashlightConeBody.reparentTo(self.playerObject.bulletBody) self.flashlightConeBody.setPos(base.cam.getPos())
def toggle_flashlight(): current_flashlight = self.render.find_all_matches("**/flashlight") if self.flashlight_state == 0: if len(current_flashlight) == 0: self.slight = 0 self.slight = Spotlight('flashlight') self.slight.set_shadow_caster(True, 1024, 1024) self.slight.set_color(VBase4(0.5, 0.6, 0.6, 1)) # slightly bluish lens = PerspectiveLens() lens.set_near_far(0.5, 5000) self.slight.set_lens(lens) self.slight.set_attenuation((0.5, 0, 0.0000005)) self.slight = self.render.attach_new_node(self.slight) self.slight.set_pos(-0.1, 0.3, -0.4) self.slight.reparent_to(self.camera) self.flashlight_state = 1 self.render.set_light(self.slight) elif len(current_flashlight) > 0: self.render.set_light(self.slight) self.flashlight_state = 1 elif self.flashlight_state > 0: self.render.set_light_off(self.slight) self.flashlight_state = 0
def generate(self): data = CIGlobals.SuitBodyData[self.SUIT] type = data[0] team = data[1] self.team = team self.level = 12 self.suit = type Suit.generate(self, SuitBank.MrHollywood, 0, hideFirst=False) self.suit = type base.taskMgr.add(self.__viewDistance, self.viewDistanceTaskName) self.setPythonTag('guard', self) self.eyeLight = Spotlight('eyes') self.eyeLens = PerspectiveLens() self.eyeLens.setMinFov(90.0 / (4.0 / 3.0)) self.eyeLight.setLens(self.eyeLens) self.eyeNode = self.headModel.attachNewNode(self.eyeLight) self.eyeNode.setZ(-5) self.eyeNode.setY(-4.5) self.trav = CollisionTraverser(self.uniqueName('eyeTrav')) ray = CollisionRay(0, 0, 0, 0, 1, 0) rayNode = CollisionNode('ToonFPS.rayNode') rayNode.addSolid(ray) rayNode.setFromCollideMask(CGG.GuardBitmask | CIGlobals.WallBitmask) rayNode.setIntoCollideMask(BitMask32.allOff()) self.rayNP = base.camera.attachNewNode(rayNode) self.rayNP.setZ(3) self.queue = CollisionHandlerQueue() self.trav.addCollider(self.rayNP, self.queue) self.trav.addCollider(self.gameWorld.mg.avatarBody, self.queue) self.request('Guard')
def __setDirectionalLight(self,props): light = DirectionalLight(props['name']) light.setShadowCaster(props['castShadows'],1024,1024) lens = PerspectiveLens() light.setLens(lens) lens.setFov(1200/props['pos'].z) return self.__createLight(light,props)
def __setDirectionalLight(self, props): light = DirectionalLight(props['name']) light.setShadowCaster(props['castShadows'], 1024, 1024) lens = PerspectiveLens() light.setLens(lens) lens.setFov(1200 / props['pos'].z) return self.__createLight(light, props)
def setupPerspectiveLens(self, near=0.1, far=100.0, fov=(90, 90)): self.lens = PerspectiveLens() self.lens.setNearFar(near, far) self.lens.setFov(fov[0], fov[1]) self.camera.setLens(self.lens) self.nearPlane = near self.farPlane = far
def _setup_camera_rig(self): """ Setups the cameras to render a cubemap """ directions = (Vec3(1, 0, 0), Vec3(-1, 0, 0), Vec3(0, 1, 0), Vec3(0, -1, 0), Vec3(0, 0, 1), Vec3(0, 0, -1)) # Prepare the display regions for i in range(6): region = self.target.internal_buffer.make_display_region( i / 6, i / 6 + 1 / 6, 0, 1) region.set_sort(25 + i) region.set_active(True) region.disable_clears() lens = PerspectiveLens() lens.set_fov(90) lens.set_near_far(0.001, 1.0) camera = Camera("EnvmapCam-" + str(i), lens) camera_np = self.rig_node.attach_new_node(camera) camera_np.look_at(camera_np, directions[i]) region.set_camera(camera_np) self.regions.append(region) self.cameras.append(camera_np) self.cameras[0].set_r(90) self.cameras[1].set_r(-90) self.cameras[3].set_r(180) self.cameras[5].set_r(180) # Register cameras for camera_np in self.cameras: self._pipeline.tag_mgr.register_envmap_camera(camera_np.node())
def set_up(self): self.display_region = base.camNode.get_display_region(0) win = self.display_region.get_window() self.perspective_lens = PerspectiveLens() self.perspective_lens = base.camLens # use panda3d's default for automatic aspect ratio on window resize self.lens = self.perspective_lens self.perspective_lens.set_aspect_ratio(window.aspect_ratio) self.perspective_lens_node = LensNode('perspective_lens_node', self.perspective_lens) self.lens_node = self.perspective_lens_node self.orthographic_lens = OrthographicLens() self.orthographic_lens.set_film_size(self.fov * window.aspect_ratio, self.fov) self.orthographic_lens_node = LensNode('orthographic_lens_node', self.orthographic_lens) application.base.cam.node().set_lens(self.lens) self.orthographic = False self.fov = 40 # horizontal fov # self.fov = 22.5 self.clip_plane_near = 0.1 self.clip_plane_far = 10000 self.ui_display_region = win.make_display_region() self.ui_display_region.set_sort(20) self.ui_camera = NodePath(PandaCamera('ui_camera')) self.ui_lens = OrthographicLens() # moved set_film_size() to window module for correct aspect ratio after setting window size self.ui_lens.set_near_far(-1000, 1000) self.ui_camera.node().set_lens(self.ui_lens) self._ui_lens_node = LensNode('_ui_lens_node', self.ui_lens) self.ui_render = NodePath('ui_render') self.ui_render.set_depth_test(0) self.ui_render.set_depth_write(0) self.ui_camera.reparent_to(self.ui_render) self.ui_display_region.set_camera(self.ui_camera) scene.ui_camera = self.ui_camera self.ui = Entity(eternal=True, name='ui', parent=self.ui_camera, scale=(self.ui_size * .5, self.ui_size * .5)) self.overlay = Entity(parent=self.ui, model='quad', scale=99, color=color.clear, eternal=True, z=-99) # these get created when setting a shader self.filter_manager = None self.filter_quad = None self.render_texture = None self.filter_quad = None self.depth_texture = None
def makeSpot(parent, color=VBase4(1,1,1,1), fov=8, atten=.003): x = parent.attachNewNode(Spotlight("spot")) x.node().setColor(color) lens = PerspectiveLens() lens.setFov(fov) x.node().setLens(lens) x.node().setAttenuation(VBase3(0,0,atten)) return x
def makeSpot(parent, color=VBase4(1, 1, 1, 1), fov=8, atten=.003): x = parent.attachNewNode(Spotlight("spot")) x.node().setColor(color) lens = PerspectiveLens() lens.setFov(fov) x.node().setLens(lens) x.node().setAttenuation(VBase3(0, 0, atten)) return x
def set_up(self, use_filters=True): self.display_region = base.camNode.get_display_region(0) win = self.display_region.get_window() self.perspective_lens = PerspectiveLens() self.lens = self.perspective_lens self.perspective_lens.set_aspect_ratio(window.aspect_ratio) self.perspective_lens.set_focal_length(50) self.perspective_lens_node = LensNode('perspective_lens_node', self.perspective_lens) self.lens_node = self.perspective_lens_node self.orthographic_lens = OrthographicLens() self.orthographic_lens.set_film_size(self.fov * window.aspect_ratio, self.fov) self.orthographic_lens_node = LensNode('orthographic_lens_node', self.orthographic_lens) application.base.cam.node().set_lens(self.lens) self.orthographic = False self.fov = 40 self.clip_plane_near = 0.0001 self.clip_plane_far = 70000000 self.ui_display_region = win.make_display_region() self.ui_display_region.set_sort(20) self.ui_camera = NodePath(PandaCamera('ui_camera')) self.ui_lens = OrthographicLens() self.ui_lens.set_film_size(self.ui_size * .5 * self.aspect_ratio, self.ui_size * .5) self.ui_lens.set_near_far(-1000, 70000) self.ui_camera.node().set_lens(self.ui_lens) self._ui_lens_node = LensNode('_ui_lens_node', self.ui_lens) self.ui_render = NodePath('ui_render') self.ui_render.set_depth_test(0) self.ui_render.set_depth_write(0) self.ui_camera.reparent_to(self.ui_render) self.ui_display_region.set_camera(self.ui_camera) scene.ui_camera = self.ui_camera # ui_camera.hide() # self.black_bars_display_region = win.make_display_region() # self.black_bars_display_region.set_sort(-100) self.ui = Entity(eternal=True, name='ui', parent=self.ui_camera, scale=(self.ui_size * .5, self.ui_size * .5)) scene.ui = self.ui if (use_filters): self.filter_manager = FilterManager(base.win, base.cam) self.render_texture = PandaTexture() self.filter_quad = None
def initLights(self): # Create some lighting #self.environ.ls() #print(self.environ.findAllMatches("**/Spot")) ambientLight = AmbientLight("ambientLight") ambientLight.setColor(Vec4(0.8, 0.8, 0.8, 0.65)) """ directionalLight = DirectionalLight("directionalLight") directionalLight.setDirection(Vec3(-10, -10, 5)) directionalLight.showFrustum() directionalLight.setColor(Vec4(1, 1, 1, 1)) directionalLight.setSpecularColor(Vec4(1, 1, 1, 1)) dirnp = render.attachNewNode(directionalLight) dirnp.setPos(10, 0, 6) """ plight1 = PointLight('plight1') plight1.setColor(VBase4(1, 1, 1, 1)) plight1.showFrustum() #plight1.setShadowCaster(True) plnp1 = render.attachNewNode(plight1) plnp1.setPos(26.71, -33.2, 26) plight2 = PointLight('plight2') plight2.setColor(VBase4(1, 1, 1, 1)) plight2.showFrustum() plnp2 = render.attachNewNode(plight2) plnp2.setPos(-25, 25, 25) slight = Spotlight('slight') slight.setColor(VBase4(1, 1, 1, 1)) lens = PerspectiveLens() lens.setFilmSize(1, 1) # Or whatever is appropriate for your scene slight.setLens(lens) slight.setShadowCaster(True, 512, 512) slight.showFrustum() slnp = render.attachNewNode(slight) slnp.setPos(0, 0, 100) slnp.lookAt(Vec3(0,0,0)) render.setLight(slnp) render.setLight(plnp1) render.setLight(plnp2) #render.setLight(render.attachNewNode(ambientLight)) #render.setLight(dirnp) render.setShaderAuto() #render.setLight(render.attachNewNode(directionalLight)) """
def aspect_ratio(self, value): self.perspective_lens = PerspectiveLens() self.perspective_lens.set_aspect_ratio(value) application.base.cam.node().set_lens(self.perspective_lens) self.ui_lens.set_film_size(self.ui_size * .5 * value, self.ui_size * .5) self.ui_camera.node().set_lens(self.ui_lens) self._ui_lens_node = LensNode('_ui_lens_node', self.ui_lens) print('setting camera aspect ratio')
def _initDepthCapture(self): for camera in self.cameras: camNode = Camera('Depth camera') camNode.setCameraMask(self.cameraMask) lens = PerspectiveLens() lens.setFov(self.fov) lens.setAspectRatio(float(self.size[0]) / float(self.size[1])) lens.setNear(self.zNear) lens.setFar(self.zFar) camNode.setLens(lens) camNode.setScene(self.scene.scene) cam = camera.attachNewNode(camNode) winprops = WindowProperties.size(self.size[0], self.size[1]) fbprops = FrameBufferProperties.getDefault() fbprops = FrameBufferProperties(fbprops) fbprops.setRgbColor(False) fbprops.setRgbaBits(0, 0, 0, 0) fbprops.setStencilBits(0) fbprops.setMultisamples(0) fbprops.setBackBuffers(0) fbprops.setDepthBits(16) flags = GraphicsPipe.BFFbPropsOptional if self.mode == 'onscreen': flags = flags | GraphicsPipe.BFRequireWindow elif self.mode == 'offscreen': flags = flags | GraphicsPipe.BFRefuseWindow else: raise Exception('Unsupported rendering mode: %s' % (self.mode)) buf = self.graphicsEngine.makeOutput(self.pipe, 'Depth buffer', 0, fbprops, winprops, flags) if buf is None: raise Exception('Unable to create depth buffer') # Set to render at the end buf.setSort(10000) dr = buf.makeDisplayRegion() dr.setSort(0) dr.setCamera(cam) dr = camNode.getDisplayRegion(0) tex = Texture() tex.setFormat(Texture.FDepthComponent) tex.setComponentType(Texture.TFloat) buf.addRenderTexture(tex, GraphicsOutput.RTMCopyRam, GraphicsOutput.RTPDepth) # XXX: should use tex.setMatchFramebufferFormat(True)? agent = camera.getParent() self.depthBuffers[agent.getName()] = buf self.depthTextures[agent.getName()] = tex
def set_up(self): self.display_region = base.camNode.get_display_region(0) win = self.display_region.get_window() self.perspective_lens = PerspectiveLens() self.lens = self.perspective_lens self.perspective_lens.set_aspect_ratio(window.aspect_ratio) self.perspective_lens.set_focal_length(50) self.perspective_lens_node = LensNode('perspective_lens_node', self.perspective_lens) self.lens_node = self.perspective_lens_node self.orthographic_lens = OrthographicLens() self.orthographic_lens.set_film_size(self.fov * window.aspect_ratio, self.fov) self.orthographic_lens_node = LensNode('orthographic_lens_node', self.orthographic_lens) application.base.cam.node().set_lens(self.lens) self.orthographic = False self.fov = 40 self.clip_plane_near = 0.0001 self.clip_plane_far = 10000 self.ui_display_region = win.make_display_region() self.ui_display_region.set_sort(20) self.ui_camera = NodePath(PandaCamera('ui_camera')) self.ui_lens = OrthographicLens() self.ui_lens.set_film_size(self.ui_size * .5 * self.aspect_ratio, self.ui_size * .5) self.ui_lens.set_near_far(-1000, 1000) self.ui_camera.node().set_lens(self.ui_lens) self._ui_lens_node = LensNode('_ui_lens_node', self.ui_lens) self.ui_render = NodePath('ui_render') self.ui_render.set_depth_test(0) self.ui_render.set_depth_write(0) self.ui_camera.reparent_to(self.ui_render) self.ui_display_region.set_camera(self.ui_camera) scene.ui_camera = self.ui_camera # ui_camera.hide() # self.black_bars_display_region = win.make_display_region() # self.black_bars_display_region.set_sort(-100) self.ui = Entity() self.ui.eternal = True self.ui.name = 'ui' self.ui.parent = self.ui_camera self.ui.scale = (self.ui_size * .5, self.ui_size * .5) # self.ui.model = 'quad' scene.ui = self.ui
def __setSpotlight(self,props): light = Spotlight(props['name']) light.setShadowCaster(props['castShadows'],2048,2048) light.setAttenuation(props['attenuation']) lens = PerspectiveLens() fov = math.degrees( props['range'].x ) lens.setFov(fov) lens.setFilmSize(5096); light.setLens(lens) return self.__createLight(light,props)
def set_perspective_lens(self, fov, near_plane, far_plane, pos, direction): transform_mat = Mat4.translate_mat(-pos) temp_lens = PerspectiveLens(fov, fov) temp_lens.set_film_offset(0, 0) temp_lens.set_near_far(near_plane, far_plane) temp_lens.set_view_vector(direction, LVector3.up()) self.set_matrix_lens(transform_mat * temp_lens.get_projection_mat()) hexahedron = temp_lens.make_bounds() center = (hexahedron.get_min() + hexahedron.get_max()) * 0.5 self._bounds = BoundingSphere(pos + center, (hexahedron.get_max() - center).length())
def create_frustum(pos=None, mat=None): """Return an infinite frustum centered on the origin, looking towards +Y and with a near plane at (0, 1.0, 0) The default FoV is 30deg""" if pos is None: pos = LPoint3d() if mat is None: mat = LMatrix4() lens = PerspectiveLens() bh = lens.make_bounds() f = InfiniteFrustum(bh, mat, pos) return f
def _initRgbCapture(self): for camera in self.cameras: camNode = Camera('Semantic camera') camNode.setCameraMask(self.cameraMask) lens = PerspectiveLens() lens.setFov(self.fov) lens.setAspectRatio(float(self.size[0]) / float(self.size[1])) lens.setNear(self.zNear) lens.setFar(self.zFar) camNode.setLens(lens) camNode.setScene(self.scene.scene) cam = camera.attachNewNode(camNode) winprops = WindowProperties.size(self.size[0], self.size[1]) fbprops = FrameBufferProperties.getDefault() fbprops = FrameBufferProperties(fbprops) fbprops.setRgbaBits(8, 8, 8, 8) flags = GraphicsPipe.BFFbPropsOptional if self.mode == 'onscreen': flags = flags | GraphicsPipe.BFRequireWindow elif self.mode == 'offscreen': flags = flags | GraphicsPipe.BFRefuseWindow else: raise Exception('Unsupported rendering mode: %s' % (self.mode)) buf = self.graphicsEngine.makeOutput(self.pipe, 'RGB-buffer-Semantics', 0, fbprops, winprops, flags) if buf is None: raise Exception('Unable to create RGB buffer') # Set to render at the end buf.setSort(10000) dr = buf.makeDisplayRegion() dr.setSort(0) dr.setCamera(cam) dr = camNode.getDisplayRegion(0) tex = Texture() tex.setFormat(Texture.FRgba8) tex.setComponentType(Texture.TUnsignedByte) buf.addRenderTexture(tex, GraphicsOutput.RTMCopyRam, GraphicsOutput.RTPColor) # XXX: should use tex.setMatchFramebufferFormat(True)? self.rgbBuffers[camera.getNetTag('agent-id')] = buf self.rgbTextures[camera.getNetTag('agent-id')] = tex
def set_perspective_lens(self, fov, near_plane, far_plane, pos, direction): transform_mat = Mat4.translate_mat(-pos) temp_lens = PerspectiveLens(fov, fov) temp_lens.set_film_offset(0, 0) temp_lens.set_near_far(near_plane, far_plane) temp_lens.set_view_vector(direction, LVector3.up()) self.set_matrix_lens(transform_mat * temp_lens.get_projection_mat())
def setupLights(self): """Setup extrnal lights""" # ambient light alight = AmbientLight('alight') alight.setColor((0.2, 0.2, 0.2, 1)) alnp = self.render.attachNewNode(alight) self.render.setLight(alnp) # directional light dlight = DirectionalLight('dlight') dlight.setColor((0.8, 0.8, 0.5, 1)) lens = PerspectiveLens() lens.setNearFar(1, 5) dlight.setLens(lens) dlight.setShadowCaster(True, args.shadow_resolution, args.shadow_resolution) dlnp = self.render.attachNewNode(dlight) dlnp.setPos(2, -2, 3) dlnp.lookAt(0, 0, 0) self.render.setLight(dlnp) # spotlight slight = Spotlight('slight') slight.setColor((0.7, 0.7, 1.0, 1)) lens = PerspectiveLens() lens.setNearFar(1, 5) slight.setLens(lens) slight.setShadowCaster(True, args.shadow_resolution, args.shadow_resolution) slnp = self.render.attachNewNode(slight) slnp.setPos(1, 1, 2) slnp.lookAt(0, 0, 0) self.render.setLight(slnp)
def __init__(self, arenaNr): arenaPath = "levels/arena{}/".format(arenaNr) self.arena = loader.loadModel(arenaPath + "arena") self.arena.setScale(2) self.arena.reparentTo(render) self.arena.hide() ambientLight = AmbientLight("ambient_light") ambientLight.setColor((0.2, 0.2, 0.2, 1)) self.alnp = render.attachNewNode(ambientLight) sunLens = PerspectiveLens() sunLens.setFilmSize(50) sun = DirectionalLight("sun") sun.setColor((1, 1, 1, 1)) sun.setShadowCaster(True, 2048, 2048) sun.setScene(render) #sun.showFrustum() self.ambientSound = None self.levelParticles = None if arenaNr == 1: sunLens.setNearFar(25, 45) sun.setLens(sunLens) self.sunNp = render.attachNewNode(sun) self.sunNp.setPos(-10, -10, 30) self.sunNp.lookAt(0, 0, 0) self.ambientSound = loader.loadSfx( "assets/audio/ambientLevel1.ogg") self.ambientSound.setLoop(True) self.fog = Fog("Outside Fog") self.fog.setColor(0.3, 0.3, 0.5) self.fog.setExpDensity(0.025) self.levelParticles = ParticleEffect() self.levelParticles.loadConfig("assets/fx/Leafs.ptf") self.levelParticles.start(parent=render2d, renderParent=render2d) elif arenaNr == 2: sunLens.setFov(120, 40) sunLens.setNearFar(2, 10) sun.setLens(sunLens) self.sunNp = render.attachNewNode(sun) self.sunNp.setPos(0, 0, 5) self.sunNp.lookAt(0, 0, 0) self.fog = Fog("Temple Fog") self.fog.setColor(0, 0, 0) self.fog.setExpDensity(0.065)
def __init__(self): """initialise and start the Game""" ShowBase.__init__(self) self.accept("escape", exit) render.setShaderAuto(True) # # SIMPLE LEVEL SETUP # self.ralph = Actor("Ralph", { "idle": "Ralph-Idle", "walk": "Ralph-Walk", "run": "Ralph-Run" }) self.ralph.loop("idle") self.ralph.reparentTo(render) self.ralph.setPos(0, 3, -2) #self.ralph.setScale(10) self.ralphIval = self.ralph.hprInterval(5.0, Vec3(-360, 0, 0)) self.ralphIval.loop() #self.ralph.setH(-20) self.environment = loader.loadModel("environment") self.environment.reparentTo(render) self.environment.setScale(0.08) self.environment.setPos(-0.5, 15, -2) base.trackball.node().setHpr(0, 22, 0) # # Lights # alight = AmbientLight("Ambient") alight.setColor(VBase4(0.3, 0.3, 0.3, 1)) alnp = render.attachNewNode(alight) render.setLight(alnp) slight = Spotlight("slight") slight.setColor(VBase4(1, 1, 1, 1)) # Use a 512x512 resolution shadow map slight.setShadowCaster(True, 2048, 2048) lens = PerspectiveLens() lens.setFov(45) slight.setLens(lens) slnp = render.attachNewNode(slight) slnp.setPos(5, -10, 5) slnp.lookAt(0, 3, -2) render.setLight(slnp)
def announceGenerate(self): DistributedAvatarAI.announceGenerate(self) if not self.eyeLensNP: lens = PerspectiveLens() lens.setMinFov(180.0 / (4. / 3.)) node = LensNode('toonEyes', lens) node.activateLens(0) self.eyeLensNP = self.attachNewNode(node) self.eyeLensNP.setZ(self.getHeight() - 0.5) self.eyeLensNP.setY(-1) self.setEyesOpenDuration() taskMgr.add(self.__eyesLookTask, self.taskName("eyesLookTask"))
def __init__(self, Input16bitTif, Texture, HFilmSize, VFilmSize, FocalLenght, VUTProject, Directory, videoFile, VideoWidth, VideoHeight, StartSecond, BBXMin, BBYMin, BBXMax, BBYMax): # , cameraCoord): load_prc_file_data( "", """ textures-power-2 none gl-coordinate-system default window-title Video UAV Tracker 3D """) ShowBase.__init__(self) self.set_background_color(0.4, 0.4, 1) self.setFrameRateMeter(True) self.lens = PerspectiveLens() self.lens.setFilmSize(float(HFilmSize) / 1000, float(VFilmSize) / 1000) self.lens.setFocalLength(float(FocalLenght) / 1000) base.cam.node().setLens(self.lens) self.VRTBoundingBox = str(BBXMin) + ',' + str(BBYMin) + ':' + str( BBXMax) + ',' + str(BBYMax) self.SetupCommunication() self.ManageDEM(Input16bitTif) self.SetupTexture(Texture) self.SetupVisibleTerrain() self.SetupBulletTerrain() self.accept("f3", self.toggleWireframe) self.EraseTmpFiles() self.Directory = Directory self.SetupModel(VUTProject) self.VideoFile = videoFile self.VideoWidth = VideoWidth self.VideoHeight = VideoHeight self.StartSecond = StartSecond self.OutputDir = self.VideoFile.split('.')[0] + '_Mosaic/' self.Mosaic = False self.MosaicCounter = 0 self.taskMgr.setupTaskChain('MosaicChain', numThreads=1, tickClock=None, threadPriority=None, frameBudget=None, frameSync=None, timeslicePriority=None) self.SendReadySignal(str(Directory))
def __init__(self): """initialise and start the Game""" ShowBase.__init__(self) self.accept("escape", exit) render.setShaderAuto(True) # # SIMPLE LEVEL SETUP # self.ralph = Actor("Ralph", {"idle": "Ralph-Idle", "walk": "Ralph-Walk", "run": "Ralph-Run"}) self.ralph.loop("idle") self.ralph.reparentTo(render) self.ralph.setPos(0, 3, -2) #self.ralph.setScale(10) self.ralphIval = self.ralph.hprInterval(5.0, Vec3(-360, 0, 0)) self.ralphIval.loop() #self.ralph.setH(-20) self.environment = loader.loadModel("environment") self.environment.reparentTo(render) self.environment.setScale(0.08) self.environment.setPos(-0.5, 15, -2) base.trackball.node().setHpr(0, 22, 0) # # Lights # alight = AmbientLight("Ambient") alight.setColor(VBase4(0.3, 0.3, 0.3, 1)) alnp = render.attachNewNode(alight) render.setLight(alnp) slight = Spotlight("slight") slight.setColor(VBase4(1, 1, 1, 1)) # Use a 512x512 resolution shadow map slight.setShadowCaster(True, 2048, 2048) lens = PerspectiveLens() lens.setFov(45) slight.setLens(lens) slnp = render.attachNewNode(slight) slnp.setPos(5, -10, 5) slnp.lookAt(0, 3, -2) render.setLight(slnp)
def launch_panda_window(panda_widget, size): """ Configure and create Panda window Connect to the gtk widget resize event Load a panda """ props = WindowProperties().getDefault() props.setOrigin(0, 0) props.setSize(*size) props.setParentWindow(panda_widget.window.xid) base.openDefaultWindow(props=props) # == panda_widget.connect("size_allocate", resize_panda_window) # == panda = loader.loadModel("panda") panda.reparentTo(render) panda.setPos(0, 40, -5) pl = render.attachNewNode(PointLight("redPointLight")) pl.node().setColor(Vec4(.9, .8, .8, 1)) render.setLight(pl) pl.node().setAttenuation(Vec3(0, 0, 0.05)) slight = Spotlight('slight') slight.setColor(VBase4(1, 1, 1, 1)) lens = PerspectiveLens() slight.setLens(lens) slnp = render.attachNewNode(slight) slnp.setPos(2, 20, 0) mid = PandaNode('mid') panda.attachNewNode(mid) # slnp.lookAt(mid) render.setLight(slnp)
def __init__(self, manager, xml): self.light = PSpotLight('slight') lens = PerspectiveLens() self.light.setLens(lens) self.lightNode = render.attachNewNode(self.light) self.reload(manager, xml)
def addLight(self, id, parent, attenuation, position, color, specular, stroboscopic, spot, lookat): if spot: slight = Spotlight(id) slight.setColor(VBase4(1, 1, 1, 1)) lens = PerspectiveLens() slight.setLens(lens) light = render.attachNewNode(slight) light.setPos(LVector3(position[0], position[1], position[2])) if lookat == None: light.lookAt(parent) else: light.lookAt(render.find("**/" + lookat)) else: light = parent.attachNewNode(PointLight(id)) light.node().setAttenuation(attenuation) light.setPos(LVector3(position[0], position[1], position[2])) light.node().setColor(color) light.node().setSpecularColor(specular) render.setLight(light) self.light_elements[id] = light if stroboscopic: self.stroboscopic_lights.append(id) if id: self.nodes_by_id[id] = light return light
def debugCamera(): global PERSPECTIVE PERSPECTIVE = True sandbox.base.enableMouse() lens = PerspectiveLens() sandbox.base.cam.node().setLens(lens) sandbox.base.cam.setPos(0, 0, 0)
def set_lens(self, lens_type="OrthographicLens"): """ Permite cambiar la lente de la camara :param lens_type: El tipo de lente a utilizar: OrthographicLens/PerspectiveLens :return: None """ self.lens_type = lens_type width = self.panda3d.win.getXSize() height = self.panda3d.win.getYSize() if lens_type is "OrthographicLens": lens = OrthographicLens() lens.setFilmSize(width, height ) if lens_type is "PerspectiveLens": lens = PerspectiveLens() lens.setFilmSize(width , height ) else: # Default value lens = OrthographicLens() lens.setFilmSize(width / 100, height / 100) print("new lens {}: {} {}".format(lens_type, width / 100, height / 100)) print(lens) self.panda3d.cam.node().setLens(lens) shader_control = self.panda3d.shader_control if shader_control is not None: shader_control.update_camera_lens(lens)
def setupLights(self): panda = self.app.panda panda.setBackgroundColor(.9, .9, .9, 1) panda.render.clearLight() keylight = Spotlight('keylight') keylight.setLens(PerspectiveLens()) np = self._insertLight( keylight, colour=(1, 1, 1, 1), pos=(0, -5, 2), ) np.lookAt((0, 0, 0.9)) # Turn off shadows until we have fix for # https://bugs.launchpad.net/panda3d/+bug/1212752 # keylight.setShadowCaster(True, 512, 512) sunlight = PointLight('sunlight') self._insertLight( sunlight, colour=(1, 1, 1, 1), pos=(1, -2, 20), ) self._insertLight( AmbientLight('ambientLight'), colour=(.25, .25, .25, 1), )
def initLights(self): torches = self.level.findAllMatches("**/TorchTop*") self.lights = [] for torch in torches: tLight = PointLight(torch.getName()) tLight.setColor((.4, .2, .0, 1)) tlnp = render.attachNewNode(tLight) tlnp.setPos(torch.getPos(render)) render.setLight(tlnp) self.lights.append(tlnp) windows = self.level.findAllMatches("**/Window*") plates = self.level.findAllMatches("**/Plate*") spikes = self.level.findAllMatches("**/Spikes*") for window in windows: wLight = Spotlight(window.getName()) lens = PerspectiveLens() wLight.setLens(lens) wLight.setColor((0.5, 0.4, 0.5, 1)) wlnp = render.attachNewNode(wLight) wlnp.setPos(window.getPos(render)) wlnp.lookAt((0, window.getY(), 0)) for plate in plates: plate.setLight(wlnp) self.lights.append(wlnp) ambientLight = AmbientLight("ambientLight") ambientLight.setColor((.1, .1, .025, 1)) render.setLight(render.attachNewNode(ambientLight))
def test_perspectivelens_near_inf(): lens = PerspectiveLens() lens.set_fov(90, 90) lens.set_near_far(float("inf"), 2) lens.coordinate_system = CS_zup_right mat = lens.get_projection_mat() assert mat[1][2] == -1 assert mat[3][2] == 4
def __init__(self, name, owner, scene, pos, fov=60, near=0.01, far=100, resol=(1920, 1080)): self.owner = owner self.scene = scene self.last = 0.0 self.power = 1.0 self.on = True self.powerrate = Flashlight.POWER_DRAIN_RATE #TODO: Change lens parameters for a unique 'lens' parameter lens = PerspectiveLens() lens.setFov(fov) lens.setNearFar(near, far) lens.setFilmSize(resol[0], resol[1]) self.light = Spotlight(name + '/wide') self.light.setLens(lens) #TODO: Shadows don't work well anymore #self.light.setShadowCaster(True, resol[0], resol[1]) self.light.setColor(Flashlight.COLOR) self.light.setExponent(40) self.nodepath = owner.cam.attachNewNode(self.light) self.nodepath.setPos(pos) self.nodepath.setHpr((5,5,0)) self.scene.setLight(self.nodepath)
def create(self): Level.create(self) # reset game vars when going to main menu self.level_holder.reset_game_vars() self.sprites = loader.loadModel("mainmenu/mainmenu.egg") # red pawn pawn_red = Actor("pawns/pawn.bam") pawn_red.setPos(-4, 20, -2) pawn_red.setH(-145) pawn_red.loop('breath') self.actors["actor_pawn_red"] = pawn_red # red pawn light dlight_red = DirectionalLight('DL Red') dlight_red.setColor((0.682 / 1.5, 0.125 / 1.5, 0.121 / 1.5, 1)) dlight_red.setLens(PerspectiveLens()) dlight_red_np = render.attachNewNode(dlight_red) self.lights["dlight_red_np"] = dlight_red_np self.lights["dlight_red_np"].setPos(10, 15, 10) self.lights["dlight_red_np"].lookAt(self.actors["actor_pawn_red"]) # white pawn pawn_white = Actor("pawns/pawn.bam") pawn_white.setPos(4, 20, -2) pawn_white.setH(145) pawn_white.loop('breath') self.actors["actor_pawn_white"] = pawn_white # light dlight_white = DirectionalLight('DL White') dlight_white.setColor((0.9 / 2.5, 0.9 / 2.5, 0.9 / 2.5, 1)) dlight_white.setLens(PerspectiveLens()) dlight_white_np = render.attachNewNode(dlight_white) self.lights["dlight_white_np"] = dlight_white_np self.lights["dlight_white_np"].setPos(-10, 15, 10) self.lights["dlight_white_np"].lookAt(self.actors["actor_pawn_white"]) # upon creation, enable these items self.actors["actor_pawn_red"].reparentTo(render) self.actors["actor_pawn_red"].setLight(self.lights["dlight_red_np"]) self.actors["actor_pawn_white"].reparentTo(render) self.actors["actor_pawn_white"].setLight( self.lights["dlight_white_np"]) self.goto_home()
def __init__(self, arenaNr): arenaPath = "levels/arena%d/" % arenaNr self.arena = loader.loadModel(arenaPath + "arena") self.arena.setScale(2) self.arena.reparentTo(render) self.arena.hide() ambientLight = AmbientLight("ambient_light") ambientLight.setColor((0.2, 0.2, 0.2, 1)) self.alnp = render.attachNewNode(ambientLight) sunLens = PerspectiveLens() sunLens.setFilmSize(50) sun = DirectionalLight("sun") sun.setColor((1, 1, 1, 1)) sun.setShadowCaster(True, 2048, 2048) sun.setScene(render) #sun.showFrustum() self.ambientSound = None self.levelParticles = None if arenaNr == 1: sunLens.setNearFar(25,45) sun.setLens(sunLens) self.sunNp = render.attachNewNode(sun) self.sunNp.setPos(-10, -10, 30) self.sunNp.lookAt(0,0,0) self.ambientSound = loader.loadSfx("assets/audio/ambientLevel1.ogg") self.ambientSound.setLoop(True) self.fog = Fog("Outside Fog") self.fog.setColor(0.3,0.3,0.5) self.fog.setExpDensity(0.025) self.levelParticles = ParticleEffect() self.levelParticles.loadConfig("assets/fx/Leafs.ptf") self.levelParticles.start(parent = render2d, renderParent = render2d) elif arenaNr == 2: sunLens.setFov(120, 40) sunLens.setNearFar(2,10) sun.setLens(sunLens) self.sunNp = render.attachNewNode(sun) self.sunNp.setPos(0, 0, 5) self.sunNp.lookAt(0,0,0) self.fog = Fog("Temple Fog") self.fog.setColor(0,0,0) self.fog.setExpDensity(0.065)
def setupPerspectiveLens(self, near=0.1, far=100.0, fov=(90, 90)): """ Setups a PerspectiveLens with a given near plane, far plane and FoV. The FoV is a tuple in the format (Horizontal FoV, Vertical FoV) """ self.lens = PerspectiveLens() self.lens.setNearFar(near, far) self.lens.setFov(fov[0], fov[1]) self.camera.setLens(self.lens) self.nearPlane = near self.farPlane = far self.rebuildMatrixCache()
def __init__(self,base): self.base = base self.base.disableMouse() x_win = self.base.win.getXSize() y_win = self.base.win.getYSize() aspect_win = float(x_win)/float(y_win) self.active_lens = 1 self.ortho_lens = OrthographicLens() self.ortho_lens.setAspectRatio(aspect_win) self.ortho_lens.setNearFar(1.0,100.0) self.persp_lens = PerspectiveLens() self.persp_lens.setAspectRatio(aspect_win) self.persp_lens.setFov(5.0) self.persp_lens.setNearFar(1.0,100.0) self.lenses = [self.persp_lens, self.ortho_lens] self.set_lens(lens=self.active_lens) self.set_view(Vec3(50.0,50.0,50.0)) self.old_x = None self.old_y = None self.zoom_speed = 0.05 self.pan_speed = 0.005 self.rotate_speed = 0.1 #these are pointers self.keys = self.base.keyboard_reader.keys self.key_map = self.base.keyboard_reader.key_map #registering camera functions self.base.taskMgr.add(hold_caller_multikey(trigger=self.keys, indices=[self.key_map['shift'], self.key_map['mouse2']], values=[1,1], init_handle=None, loop_handle=self.pan_camera, cleanup_handle=self.mouse_delta_cleanup), 'pan_camera_task') self.base.taskMgr.add(hold_caller_multikey(trigger=self.keys, indices=[self.key_map['control'], self.key_map['shift'], self.key_map['mouse2']], values=[0, 0,1], init_handle=None, loop_handle=self.rotate_camera_fixed_pivot, cleanup_handle=self.mouse_delta_cleanup), 'rotate_camera_task') self.base.taskMgr.add(hold_caller_multikey(trigger=self.keys, indices=[self.key_map['control'], self.key_map['mouse2']], values=[1,1], init_handle=None, loop_handle=self.zoom_camera, cleanup_handle=self.mouse_delta_cleanup), 'rotate_camera_task') #register camera presets self.base.taskMgr.add( delta_caller(handle = self.set_viewpoint_front , trigger = self.keys, index = self.key_map['1'], value=1), 'camera_preset_front_task') self.base.taskMgr.add( delta_caller(handle = self.set_viewpoint_side , trigger = self.keys, index = self.key_map['2'], value=1), 'camera_preset_side_task') self.base.taskMgr.add( delta_caller(handle = self.set_viewpoint_top , trigger = self.keys, index = self.key_map['3'], value=1), 'camera_preset_top_task') #register switching perspective #TODO: currently disabled because perspective camera is stupid and should feel bad #self.base.taskMgr.add( delta_caller(handle = self.switch_perspective , trigger = self.keys, index = self.key_map['5'], value=1), 'camera_switch_perspective_task') #makes the zoom level of the orthographic camera more reasonable self.fixed_zoom_camera(10.0)
def __init__(self, name, root, route, mass, movforce, maxforce): AICharacter.__init__(self, name, root, mass, movforce, maxforce) self.state = Hooded.STATE_PATROL self.initTimer = True self.attackTimer = True # we create a spotlight that will be the sentinel's eye and will be used to fire the inView method self.slight = Spotlight('slight') self.slight.setColor((1, 1, 1, 1)) lens = PerspectiveLens() lens.setNear(0.1) lens.setFar(Hooded.SIGHT) lens.setFov(Hooded.FOV) self.slight.setLens(lens) self.slnp = self.get_node_path().attachNewNode(self.slight) #TODO: Substitute for a collision polygon, so that the player class alerts an enemy of its presence #self.slight.showFrustum() self.slnp.setH(self.slnp.getH()-180) self.slnp.setPos(0, 0, Hooded.HEIGHT) self.hearing = 5.0 self.dynamicObstacles = [] self.detected = False self.pathfinding = False self.lostTarget = False self.countTime = False self.goingBack = False self.heard = False self.isProtected = False self.attacked = False self.started = False self.sentinelHandler = CollisionHandlerQueue() #TODO: Intruders should be added via an external method self.intruders = [] # this is important: as we said the inView method don't cull geometry but take everything is in sight frustum - therefore to simulate an hide and seek feature we gotta cheat a little: this ray is masked to collide with walls and so if the avatar is behind a wall the ray will be 'deflected' (we'll see how later in the sent_traverse function) - so we know who's behind a wall but we fake we can't see it. sentraygeom = CollisionSegment(0, 0, Hooded.HEIGHT, 0, Hooded.SIGHT, Hooded.HEIGHT) sentinelRay = self.get_node_path().attachNewNode(CollisionNode('sentinelray')) sentinelRay.node().addSolid(sentraygeom) # we set to the ray a cumulative masking using the or operator to detect either the avatar's body and the wall geometry sentinelRay.node().setFromCollideMask(CollisionMask.PLAYER) sentinelRay.node().setIntoCollideMask(CollisionMask.NONE) # we add the ray to the sentinel collider and now it is ready to go base.cTrav.addCollider(sentinelRay, self.sentinelHandler) self.screechsound = loader.loadSfx("assets/sounds/enemies/nazgul_scream.mp3") self.setPatrolPos(route)
def generate(self): data = CIGlobals.SuitBodyData[self.SUIT] type = data[0] team = data[1] self.generateSuit(type, self.SUIT, team, self.MAX_HP, 0, False) base.taskMgr.add(self.__viewDistance, self.viewDistanceTaskName) self.setPythonTag('guard', self) self.eyeLight = Spotlight('eyes') self.eyeLens = PerspectiveLens() self.eyeLens.setMinFov(90.0 / (4.0 / 3.0)) self.eyeLight.setLens(self.eyeLens) self.eyeNode = self.headModel.attachNewNode(self.eyeLight) self.eyeNode.setZ(-5) self.eyeNode.setY(-4.5) self.request('Guard')
def __init__(self): """ Creates a new spot light. """ Light.__init__(self) DebugObject.__init__(self, "SpotLight") self.typeName = "SpotLight" self.nearPlane = 0.5 self.radius = 30.0 self.spotSize = Vec2(30, 30) # Used to compute the MVP self.ghostCamera = Camera("PointLight") self.ghostCamera.setActive(False) self.ghostLens = PerspectiveLens() self.ghostLens.setFov(130) self.ghostCamera.setLens(self.ghostLens) self.ghostCameraNode = NodePath(self.ghostCamera) self.ghostCameraNode.reparentTo(Globals.render) self.ghostCameraNode.hide()
class FactorySneakGuardSuit(Suit, FSM): notify = directNotify.newCategory('FactorySneakGuardSuit') SUIT = 'mrhollywood' VIEW_DISTANCE_TASK_NAME = 'ViewDistanceTask' MAX_VIEW_DISTANCE = 100.0 GUARD_DIED_DELAY = 6.0 MAX_HP = 200 IN_VIEW = 'somethingInSight' HEARD = 'heard' TRY_TO_CONFIRM_TIME = 5.0 def __init__(self, world, guardKey): Suit.__init__(self) FSM.__init__(self, 'FactorySneakGuardSuit') self.gameWorld = world self.guardKey = guardKey self.viewDistanceTaskName = self.VIEW_DISTANCE_TASK_NAME + '-' + str(id(self)) self.diedTaskName = 'GuardDied-' + str(id(self)) self.health = 0 self.maxHealth = self.MAX_HP self.eyeLight = None self.eyeLens = None self.eyeNode = None self.moveTrack = None return def enterGuard(self): self.loop('neutral') pos, hpr = CGG.FactoryGuardPoints[self.guardKey] self.setHpr(hpr - (180, 0, 0)) self.setPos(pos) base.taskMgr.add(self.__guard, self.taskName('guard')) def __guard(self, task): if self.eyeNode.node().isInView(base.localAvatar.getPos(self.eyeNode)): self.request('SeekTarget', self.IN_VIEW) return task.done return task.cont def exitGuard(self): base.taskMgr.remove(self.taskName('guard')) def enterTurnToGuardSpot(self): self.loop('walk') _, hpr = CGG.FactoryGuardPoints[self.guardKey] self.moveTrack = LerpHprInterval(self, duration=1.0, hpr=hpr, startHpr=self.getHpr()) self.moveTrack.setDoneEvent(self.uniqueName('TurnedToGuardSpot')) self.acceptOnce(self.moveTrack.getDoneEvent(), self.request, ['Guard']) self.moveTrack.start() def exitTurnToGuardSpot(self): if self.moveTrack: self.ignore(self.moveTrack.getDoneEvent()) self.moveTrack.finish() self.moveTrack = None return def enterSeekTarget(self, event): dialogue = random.choice(CGG.GuardDialog[event]) self.setChat(dialogue) self.loop('walk') self.moveTrack = NPCLookInterval(self, base.localAvatar) self.moveTrack.setDoneEvent(self.uniqueName('SeekLocalAvatar')) self.acceptOnce(self.moveTrack.getDoneEvent(), self.request, ['TryToConfirmTarget']) self.moveTrack.start() def exitSeekTarget(self): if self.moveTrack: self.ignore(self.moveTrack.getDoneEvent()) self.moveTrack.finish() self.moveTrack = None return def enterTryToConfirmTarget(self): self.loop('neutral') base.taskMgr.add(self.__tryToConfirmTarget, self.uniqueName('TryToConfirmTarget')) def __tryToConfirmTarget(self, task): if task.time >= self.TRY_TO_CONFIRM_TIME: chat = random.choice(CGG.GuardDialog['disregard']) self.setChat(chat) self.request('TurnToGuardSpot') return task.done if self.eyeNode.node().isInView(base.localAvatar.getPos(self.eyeNode)): chat = random.choice(CGG.GuardDialog['spot']) self.setChat(chat) return task.done return task.cont def exitTryToConfirmTarget(self): base.taskMgr.remove(self.uniqueName('TryToConfirmTarget')) def uniqueName(self, name): return self.taskName(name) def taskName(self, name): return name + '-' + str(id(self)) def setHealth(self, hp): self.health = hp def getHealth(self): return self.health def shot(self): dialogue = random.choice(CGG.GuardDialog['shot']) self.setChat(dialogue) def dead(self): self.animFSM.request('die') base.taskMgr.doMethodLater(self.GUARD_DIED_DELAY, self.__diedDone, self.diedTaskName) def __diedDone(self, task): self.gameWorld.deleteGuard(self) return task.done def generate(self): data = CIGlobals.SuitBodyData[self.SUIT] type = data[0] team = data[1] self.generateSuit(type, self.SUIT, team, self.MAX_HP, 0, False) base.taskMgr.add(self.__viewDistance, self.viewDistanceTaskName) self.setPythonTag('guard', self) self.eyeLight = Spotlight('eyes') self.eyeLens = PerspectiveLens() self.eyeLens.setMinFov(90.0 / (4.0 / 3.0)) self.eyeLight.setLens(self.eyeLens) self.eyeNode = self.headModel.attachNewNode(self.eyeLight) self.eyeNode.setZ(-5) self.eyeNode.setY(-4.5) self.request('Guard') def __viewDistance(self, task): if self.getDistance(base.localAvatar) > self.MAX_VIEW_DISTANCE: if not self.isHidden(): self.hide() elif self.isHidden(): self.show() task.delayTime = 1.0 return task.again def disable(self): base.taskMgr.remove(self.diedTaskName) base.taskMgr.remove(self.viewDistanceTaskName) if self.eyeNode: self.eyeNode.removeNode() self.eyeNode = None self.eyeLens = None self.eyeLight = None self.viewDistanceTaskName = None self.guardKey = None self.gameWorld = None Suit.disable(self) return
def __init__(self): # this will be in the config file usually path_to_models = '../goBananas/' # using log.txt in this directory (gobananas), Yummy banana09 #avatar_head = -23.0306647431 #avatar_pos = Point3(-0.499429, 4.01372, 1) #banana_pos = Point3(-0.461612, 4.1383, 1) #banana_h = 35 # using giz_bananarchy.txt in this directory Yummy banana4 avatar_head = 32.6150996909 avatar_pos = Point3(-2.53202, 3.98558, 1) banana_pos = Point3(-2.88193, 4.38051, 1) banana_h = -418 # Things that can affect camera: # options resolution resW resH base = ShowBase() wp = WindowProperties() wp.setFullscreen(True) base.win.requestProperties(wp) lens = PerspectiveLens() # Fov is set in config for 60 lens.setFov(60) # aspectratio should be same as window size # this was for 800x600 # field of view 60 46.8264... # aspect ratio 1.3333 #lens.setAspectRatio(800.0 / 600.0) lens.setAspectRatio(1024.0 / 768.0) base.cam.node().setLens(lens) print lens.getFov() print lens.getAspectRatio() # set near to be same as avatar's radius lens.setNear(0.1) print 'near camera', lens.getNear() #base.cam.setPos(0, 0, 1) base.cam.setPos(avatar_pos) base.cam.setH(avatar_head) #self.smiley = base.loader.loadModel('smiley') #self.smiley.setPos(Point3(0, 6, 0)) #self.smiley.reparentTo(render) #print 'smiley', self.smiley.getPos() # load environment load_models() for item in PlaceModels._registry: if 'original' in item.group: #if 'better' in item.group: item.model = path_to_models + item.model model = base.loader.loadModel(item.model) model.setPos(item.location) model.setScale(item.scale) model.reparentTo(render) #if item.name is not 'sky': #if item.name is not 'sky' and item.name is not 'terrain': #item.model = path_to_models + item.model #model = base.loader.loadModel(item.model) #model.setPos(item.location) #model.setScale(item.scale) #model.reparentTo(render) #sky = base.loader.loadModel('models/sky.egg') #sky = base.loader.loadModel('models/good_sky_hole.egg') #scale = 6 # 6 gets you just outside the walls. The further # back you go after that the more it cuts off, opposite of # what I had assumed #sky.setPos(0, 0, 0) #sky.setPos(-5.89054 * scale, 3.23145 * scale, -0.8 * scale) # z = 0 is too high. weird. -0.8 seems about even #sky.setScale(scale) #sky.reparentTo(render) #sky.setHpr(0, 0, 0) #terrain = base.loader.loadModel('models/courtyard_one.egg') #terrain.setPos(0, 0, 0.5) #terrain.setScale(2.5) #terrain.reparentTo(render) #b=OnscreenImage(image="models/pics/Mount_Rainier_6874h.jpg") #b.parent = base.cam #b.scale = (640, 0, 360) #b.pos = (20, 20, 10) #base.cam.node().getDisplayRegion(0).setSort(20) #imageObject = OnscreenImage(image = 'models/pics/Mount_Rainier_6874h.jpg', pos = (-0.5, 0, 0.02)) #imageObject.parent = camera # A dictionary of what keys are curently being pressed self.keys = {"right" : 0, "left" : 0} self.accept("escape", sys.exit) self.accept("arrow_right", self.setKey, ['right', 1]) self.accept("arrow_left", self.setKey, ['left', 1]) self.accept("arrow_right-up", self.setKey, ['right', 0]) self.accept("arrow_left-up", self.setKey, ['left', 0]) self.playTask = base.taskMgr.add(self.frame_loop, "frame_loop") self.playTask.last = 0
def __init__(self): ShowBase.__init__(self) self.cellmanager = CellManager(self) self.xray_mode = False self.show_model_bounds = False # Display instructions add_title("Panda3D Tutorial: Portal Culling") add_instructions(0.06, "[Esc]: Quit") add_instructions(0.12, "[W]: Move Forward") add_instructions(0.18, "[A]: Move Left") add_instructions(0.24, "[S]: Move Right") add_instructions(0.30, "[D]: Move Back") add_instructions(0.36, "Arrow Keys: Look Around") add_instructions(0.42, "[F]: Toggle Wireframe") add_instructions(0.48, "[X]: Toggle X-Ray Mode") add_instructions(0.54, "[B]: Toggle Bounding Volumes") # Setup controls self.keys = {} for key in ['arrow_left', 'arrow_right', 'arrow_up', 'arrow_down', 'a', 'd', 'w', 's']: self.keys[key] = 0 self.accept(key, self.push_key, [key, 1]) self.accept('shift-%s' % key, self.push_key, [key, 1]) self.accept('%s-up' % key, self.push_key, [key, 0]) self.accept('f', self.toggleWireframe) self.accept('x', self.toggle_xray_mode) self.accept('b', self.toggle_model_bounds) self.accept('escape', __import__('sys').exit, [0]) self.disableMouse() # Setup camera lens = PerspectiveLens() lens.setFov(60) lens.setNear(0.01) lens.setFar(1000.0) self.cam.node().setLens(lens) self.camera.setPos(-9, -0.5, 1) self.heading = -95.0 self.pitch = 0.0 # Load level geometry self.level_model = self.loader.loadModel('models/level') self.level_model.reparentTo(self.render) self.level_model.setTexGen(TextureStage.getDefault(), TexGenAttrib.MWorldPosition) self.level_model.setTexProjector(TextureStage.getDefault(), self.render, self.level_model) self.level_model.setTexScale(TextureStage.getDefault(), 4) tex = self.loader.load3DTexture('models/tex_#.png') self.level_model.setTexture(tex) # Load cells self.cellmanager.load_cells_from_model('models/cells') # Load portals self.cellmanager.load_portals_from_model('models/portals') # Randomly spawn some models to test the portals self.models = [] for dummy in range(0, 500): pos = LPoint3((random.random() - 0.5) * 6, (random.random() - 0.5) * 6, random.random() * 7) cell = self.cellmanager.get_cell(pos) if cell is None: # skip if the random position is not over a cell continue dist = self.cellmanager.get_dist_to_cell(pos) if dist > 1.5: # skip if the random position is too far from ground continue box = self.loader.loadModel('box') box.setScale(random.random() * 0.2 + 0.1) box.setPos(pos) box.setHpr(random.random() * 360, random.random() * 360, random.random() * 360) box.reparentTo(cell.nodepath) self.models.append(box) self.taskMgr.add(self.update, 'main loop')
def __init__(self): with open('../play_data/pickle_data') as variable: start_time = pickle.load(variable) banana_pos = pickle.load(variable) #print(banana_pos) banana_h = pickle.load(variable) #print(banana_h) gone_bananas = pickle.load(variable) #print(gone_bananas) #print(int(gone_bananas[0][-2:])) self.avatar_h = float(pickle.load(variable)[-1]) #print(avatar_h) apl = pickle.load(variable)[-1] #print(avatar_pos) self.avatar_pos = Point3(float(apl[0]), float(apl[1]), float(apl[2])) #print(self.avatar_pos) #config = #data_file = #time_stamp = # using log.txt in this directory (gobananas), Yummy banana09 #avatar_head = -23.0306647431 #avatar_pos = Point3(-0.499429, 4.01372, 1) #banana_pos = Point3(-0.461612, 4.1383, 1) #banana_h = 35 # using giz_bananarchy.txt in this directory Yummy banana4 #avatar_h = 32.6150996909 #avatar_pos = Point3(-2.53202, 3.98558, 1) #banana_pos = Point3(-2.88193, 4.38051, 1) #banana_h = -418 # Things that can affect camera: # options resolution resW resH base = ShowBase() lens = PerspectiveLens() # Fov is set in config for 60 lens.setFov(60) # aspectratio should be same as window size # this was for 800x600 # field of view 60 46.8264... # aspect ratio 1.3333 lens.setAspectRatio(800.0 / 600.0) base.cam.node().setLens(lens) print lens.getFov() print lens.getAspectRatio() # set near to be same as avatar's radius lens.setNear(0.1) print 'near camera', lens.getNear() #base.cam.setPos(0, 0, 1) base.cam.setPos(self.avatar_pos) base.cam.setH(self.avatar_h) #print(base.cam.getHpr()) #self.smiley = base.loader.loadModel('smiley') #self.smiley.setPos(Point3(0, 6, 0)) #self.smiley.reparentTo(render) #print 'smiley', self.smiley.getPos() terrainModel = base.loader.loadModel('../goBananas/models/towns/field.bam') terrainModel.setPos(Point3(0, 0, 0)) terrainModel.reparentTo(render) #print 'terrain', terrainModel.getPos() skyModel = base.loader.loadModel('../goBananas/models/sky/sky.bam') skyModel.setPos(Point3(0, 0, 0)) skyModel.setScale(1.6) skyModel.reparentTo(render) #print 'sky', skyModel.getPos() treeModel = base.loader.loadModel('../goBananas/models/trees/palmTree.bam') treeModel.setPos(Point3(13, 13, 0)) treeModel.setScale(0.0175) treeModel.reparentTo(render) skyscraper = base.loader.loadModel('../goBananas/models/skyscraper/skyscraper.bam') skyscraper.setPos(Point3(-13, -13, 0)) skyscraper.setScale(0.3) skyscraper.reparentTo(render) stLightModel = base.loader.loadModel('../goBananas/models/streetlight/streetlight.bam') stLightModel.setPos(Point3(-13, 13, 0)) stLightModel.setScale(0.75) stLightModel.reparentTo(render) windmillModel = base.loader.loadModel('../goBananas/models/windmill/windmill.bam') windmillModel.setPos(Point3(13, -13, 0)) windmillModel.setScale(0.2) windmillModel.setH(45) windmillModel.reparentTo(render) # get rid of bananas already gone ind = range(len(banana_h)) for i in gone_bananas: ind.pop(int(i[-2:])) for i in ind: #print('go', i) bananaModel = base.loader.loadModel('../goBananas/models/bananas/banana.bam') bananaModel.setPos(Point3(float(banana_pos[i][0]), float(banana_pos[i][1]), float(banana_pos[i][2]))) bananaModel.setScale(0.5) bananaModel.setH(float(banana_h[i])) bananaModel.reparentTo(render) # Create Ambient Light #ambientLight = AmbientLight('ambientLight') #ambientLight.setColor(Vec4(0.2, 0.2, 0.2, 1)) #ambientLightNP = render.attachNewNode(ambientLight) #render.setLight(ambientLightNP) #self.spot = Spotlight("spot") #self.spot.setColor(Vec4(1, 1, 1, 1)) #self.lens = PerspectiveLens() #self.lens.setFov(10) #self.spot.setLens(self.lens) #self.spotNP = render.attachNewNode(self.spot) #render.setLight(self.spotNP) #self.spotNP.setPos(self.avatar_pos) #print('spotlight position', self.avatar_pos) #self.spotNP.setHpr(90, 5, 90) # A dictionary of what keys are currently being pressed self.keys = {"right" : 0, "left" : 0} self.accept("escape", sys.exit) self.accept("arrow_right", self.setKey, ['right', 1]) self.accept("arrow_left", self.setKey, ['left', 1]) self.accept("arrow_right-up", self.setKey, ['right', 0]) self.accept("arrow_left-up", self.setKey, ['left', 0]) self.playTask = base.taskMgr.add(self.frame_loop, "frame_loop") self.playTask.last = 0
def __init__(self): # Set up the window, camera, etc. ShowBase.__init__(self) # Set the background color to black self.win.setClearColor((0, 0, 0, 1)) # This is used to store which keys are currently pressed. self.keyMap = { "left": 0, "right": 0, "forward": 0, "back": 0, "cam-left": 0, "cam-right": 0} # Post the instructions self.title = addTitle( "Adventurer: 3rd Person File Manager (in progress)") self.inst1 = addInstructions(0.06, "[ESC]: Quit") self.inst2 = addInstructions(0.12, "[Arrows]: Angle Camera") self.inst3 = addInstructions(0.18, "[WASD]: Move") # Set up the environment # # This environment model contains collision meshes. If you look # in the egg file, you will see the following: # # <Collide> { Polyset keep descend } # # This tag causes the following mesh to be converted to a collision # mesh -- a mesh which is optimized for collision, not rendering. # It also keeps the original mesh, so there are now two copies --- # one optimized for rendering, one for collisions. #self.environ = loader.loadModel("models/world") #self.environ.reparentTo(render) #loader.unload_model startPos = Point3(0,0,0)#self.environ.find("**/start_point").getPos() # Setup controls self.keys = {} for key in ['arrow_left', 'arrow_right', 'arrow_up', 'arrow_down', 'a', 'd', 'w', 's']: self.keys[key] = 0 self.accept(key, self.push_key, [key, 1]) self.accept('shift-%s' % key, self.push_key, [key, 1]) self.accept('%s-up' % key, self.push_key, [key, 0]) #self.accept('f', self.toggleWireframe) #self.accept('x', self.toggle_xray_mode) #self.accept('b', self.toggle_model_bounds) self.accept('escape', __import__('sys').exit, [0]) self.disableMouse() taskMgr.add(self.update, "moveTask") #insert test features #addCube(models, render, startPos + (0, 1, 0.5), 0.5) #addWall(models, render, startPos + (0, 1, 0.5), 30, 0.2) addDir(render, startPos + (0, 1, 0.5)) # Game state variables self.isMoving = False # Set up the camera self.disableMouse() lens = PerspectiveLens() lens.setFov(60) lens.setNear(0.01) lens.setFar(1000.0) self.cam.node().setLens(lens) self.camera.setPos(startPos) self.heading = -95.0 self.pitch = 0.0 # Add collision to keept he camera in the room cn = CollisionNode('camera') cn.addSolid(CollisionSphere(0, 0, 0, 0.5)) camColl = self.camera.attachNewNode(cn) self.cTrav = CollisionTraverser('camera traverser') self.camGroundHandler = CollisionHandlerPusher() self.camGroundHandler.addCollider(camColl, NodePath(self.camera)) self.cTrav.addCollider(camColl, self.camGroundHandler) # Makes colliding objects show up self.cTrav.showCollisions(render) # Create some lighting ambientLight = AmbientLight("ambientLight") ambientLight.setColor((.3, .3, .3, 1)) directionalLight = DirectionalLight("directionalLight") directionalLight.setDirection((-5, -5, -5)) directionalLight.setColor((1, 1, 1, 1)) directionalLight.setSpecularColor((1, 1, 1, 1)) render.setLight(render.attachNewNode(ambientLight)) render.setLight(render.attachNewNode(directionalLight))
def createLens(self, aspect_ratio, fov=60.0, near=1.0, far=1000.0): lens = PerspectiveLens() lens.setFov(fov) lens.setAspectRatio(aspect_ratio) lens.setNearFar(near, far) return lens
def make_camera(self, output, sort=0, dr_dims=(0, 1, 0, 1), aspect_ratio=None, clear_depth=False, clear_color=None, lens=None, cam_name="camera0", mask=None): """ Makes a new 3-d camera associated with the indicated window, and creates a display region in the indicated subrectangle. If stereo is True, then a stereo camera is created, with a pair of DisplayRegions. If stereo is False, then a standard camera is created. If stereo is None or omitted, a stereo camera is created if the window says it can render in stereo. If useCamera is not None, it is a NodePath to be used as the camera to apply to the window, rather than creating a new camera. Args: output (GraphicsOutput): Output object. Keyword Args: sort (int): Sort order. dr_dims (Iterable, 4): DisplayRegion dimensions. aspect_ratio (float): Aspect ratio. clear_depth (bool): Indicator to clear depth buffer. clear_color (bool): Indicator to clear color buffer. lens (Lens): Lens object. cam_name (str): Window name. mask (BitMask32): Bit mask that indicates which objects to render. Return: (NodePath): Camera nodepath. """ # self.cameras is the parent node of all cameras: a node that # we can move around to move all cameras as a group. if self.cameras is None: # We make it a ModelNode with the PTLocal flag, so that a # wayward flatten operations won't attempt to mangle the # camera. self.cameras = self.root.attachNewNode(ModelNode("cameras")) self.cameras.node().setPreserveTransform(ModelNode.PTLocal) # Make a new Camera node. cam_node = Camera(cam_name) if lens is None: lens = PerspectiveLens() if aspect_ratio is None: aspect_ratio = self.get_aspect_ratio(output) lens.setAspectRatio(aspect_ratio) lens.setNear(0.1) lens.setFar(1000.0) if lens is not None: cam_node.setLens(lens) camera = self.cameras.attachNewNode(cam_node) # Masks out part of scene from camera if mask is not None: if (isinstance(mask, int)): mask = BitMask32(mask) cam_node.setCameraMask(mask) # Make a display region dr = output.makeDisplayRegion(*dr_dims) # By default, we do not clear 3-d display regions (the entire # window will be cleared, which is normally sufficient). But # we will if clearDepth is specified. if clear_depth: dr.setClearDepthActive(1) if clear_color: dr.setClearColorActive(1) dr.setClearColor(clear_color) dr.setSort(sort) dr.setCamera(camera) dr.setActive(True) return camera
class SpotLight(Light, DebugObject): """ This light type simulates a SpotLight. It has a position and an orientation. """ def __init__(self): """ Creates a new spot light. """ Light.__init__(self) DebugObject.__init__(self, "SpotLight") self.typeName = "SpotLight" self.nearPlane = 0.5 self.radius = 30.0 self.spotSize = Vec2(30, 30) # Used to compute the MVP self.ghostCamera = Camera("PointLight") self.ghostCamera.setActive(False) self.ghostLens = PerspectiveLens() self.ghostLens.setFov(130) self.ghostCamera.setLens(self.ghostLens) self.ghostCameraNode = NodePath(self.ghostCamera) self.ghostCameraNode.reparentTo(Globals.render) self.ghostCameraNode.hide() def getLightType(self): """ Internal method to fetch the type of this light, used by Light """ return LightType.Spot def _updateLens(self): """ Internal method which gets called when the lens properties changed """ for source in self.shadowSources: source.rebuildMatrixCache() def cleanup(self): """ Internal method which gets called when the light got deleted """ self.ghostCameraNode.removeNode() Light.cleanup(self) def setFov(self, fov): """ Sets the field of view of the spotlight """ assert(fov > 1 and fov < 180) self.ghostLens.setFov(fov) self._updateLens() def setPos(self, pos): """ Sets the position of the spotlight """ self.ghostCameraNode.setPos(pos) Light.setPos(self, pos) def lookAt(self, pos): """ Makes the spotlight look at the given position """ self.ghostCameraNode.lookAt(pos) def _computeAdditionalData(self): """ Internal method to recompute the spotlight MVP """ self.ghostCameraNode.setPos(self.position) projMat = self.ghostLens.getProjectionMat() modelViewMat = Globals.render.getTransform(self.ghostCameraNode).getMat() self.mvp = modelViewMat * projMat def _computeLightBounds(self): """ Recomputes the bounds of this light. For a SpotLight, we for now use a simple BoundingSphere """ self.bounds = BoundingSphere(Point3(self.position), self.radius * 2.0) def setNearFar(self, near, far): """ Sets the near and far plane of the spotlight """ self.nearPlane = near self.radius = far self.ghostLens.setNearFar(near, far) self._updateLens() def _updateDebugNode(self): """ Internal method to generate new debug geometry. """ debugNode = NodePath("SpotLightDebugNode") # Create the inner image cm = CardMaker("SpotLightDebug") cm.setFrameFullscreenQuad() innerNode = NodePath(cm.generate()) innerNode.setTexture(Globals.loader.loadTexture("Data/GUI/Visualization/SpotLight.png")) innerNode.setBillboardPointEye() innerNode.reparentTo(debugNode) innerNode.setPos(self.position) innerNode.setColorScale(1,1,0,1) # Create the outer lines lineNode = debugNode.attachNewNode("lines") currentNodeTransform = render.getTransform(self.ghostCameraNode).getMat() currentCamTransform = self.ghostLens.getProjectionMat() currentRelativeCamPos = self.ghostCameraNode.getPos(render) currentCamBounds = self.ghostLens.makeBounds() currentCamBounds.xform(self.ghostCameraNode.getMat(render)) p = lambda index: currentCamBounds.getPoint(index) # Make a circle at the bottom frustumBottomCenter = (p(0) + p(1) + p(2) + p(3)) * 0.25 upVector = (p(0) + p(1)) / 2 - frustumBottomCenter rightVector = (p(1) + p(2)) / 2 - frustumBottomCenter points = [] for idx in xrange(64): rad = idx / 64.0 * math.pi * 2.0 pos = upVector * math.sin(rad) + rightVector * math.cos(rad) pos += frustumBottomCenter points.append(pos) frustumLine = self._createDebugLine(points, True) frustumLine.setColorScale(1,1,0,1) frustumLine.reparentTo(lineNode) # Create frustum lines which connect the origin to the bottom circle pointArrays = [ [self.position, frustumBottomCenter + upVector], [self.position, frustumBottomCenter - upVector], [self.position, frustumBottomCenter + rightVector], [self.position, frustumBottomCenter - rightVector], ] for pointArray in pointArrays: frustumLine = self._createDebugLine(pointArray, False) frustumLine.setColorScale(1,1,0,1) frustumLine.reparentTo(lineNode) # Create line which is in the direction of the spot light startPoint = (p(0) + p(1) + p(2) + p(3)) * 0.25 endPoint = (p(4) + p(5) + p(6) + p(7)) * 0.25 line = self._createDebugLine([startPoint, endPoint], False) line.setColorScale(1,1,1,1) line.reparentTo(lineNode) # Remove the old debug node self.debugNode.node().removeAllChildren() # Attach the new debug node debugNode.reparentTo(self.debugNode) # self.debugNode.flattenStrong() def _initShadowSources(self): """ Internal method to init the shadow sources """ source = ShadowSource() source.setResolution(self.shadowResolution) source.setLens(self.ghostLens) self._addShadowSource(source) def _updateShadowSources(self): """ Recomputes the position of the shadow source """ self.shadowSources[0].setPos(self.position) self.shadowSources[0].setHpr(self.ghostCameraNode.getHpr()) def __repr__(self): """ Generates a string representation of this instance """ return "SpotLight[]"
def __init__(self): ShowBase.__init__(self) #Setup scene = BulletWorld() scene.setGravity(Vec3(0, 0, -9.81)) base.setBackgroundColor(0.6,0.9,0.9) fog = Fog("The Fog") fog.setColor(0.9,0.9,1.0) fog.setExpDensity(0.003) render.setFog(fog) #Lighting #Sun light sun = DirectionalLight("The Sun") sun_np = render.attachNewNode(sun) sun_np.setHpr(0,-60,0) render.setLight(sun_np) #Ambient light amb = AmbientLight("The Ambient Light") amb.setColor(VBase4(0.39,0.39,0.39, 1)) amb_np = render.attachNewNode(amb) render.setLight(amb_np) #Variables self.gear = 0 self.start = 0 self.Pbrake = 0 self.terrain_var = 1 self.time = 0 self.headlight_var = 0 self.RPM = 0 self.clutch = 0 self.carmaxspeed = 100 #KPH self.carmaxreversespeed = -40 #KPH self.steering = 0 #Functions def V1(): camera.setPos(0.25,-1.2,0.5) camera.setHpr(0,-13,0) def V2(): camera.setPos(0,-15,3) camera.setHpr(0,-10,0) def V3(): camera.setPos(0,0,9) camera.setHpr(0,-90,0) def up(): self.gear = self.gear -1 if self.gear < -1: self.gear = -1 def down(): self.gear = self.gear +1 if self.gear > 1: self.gear = 1 def start_function(): self.start = 1 self.start_sound.play() self.engine_idle_sound.play() self.RPM = 1000 def stop_function(): self.start = 0 self.engine_idle_sound.stop() def parkingbrake(): self.Pbrake = (self.Pbrake + 1) % 2 def rotate(): Car_np.setHpr(0, 0, 0) def horn(): self.horn_sound.play() def set_time(): if self.time == -1: sun.setColor(VBase4(0.4, 0.3, 0.3, 1)) base.setBackgroundColor(0.8,0.7,0.7) if self.time == 0: sun.setColor(VBase4(0.7, 0.7, 0.7, 1)) base.setBackgroundColor(0.6,0.9,0.9) if self.time == 1: sun.setColor(VBase4(0.2, 0.2, 0.2, 1)) base.setBackgroundColor(0.55,0.5,0.5) if self.time == 2: sun.setColor(VBase4(0.02, 0.02, 0.05, 1)) base.setBackgroundColor(0.3,0.3,0.3) if self.time == -2: self.time = -1 if self.time == 3: self.time = 2 def time_forward(): self.time = self.time + 1 def time_backward(): self.time = self.time -1 def set_terrain(): if self.terrain_var == 1: self.ground_model.setTexture(self.ground_tex, 1) self.ground_model.setScale(3) if self.terrain_var == 2: self.ground_model.setTexture(self.ground_tex2, 1) self.ground_model.setScale(3) if self.terrain_var == 3: self.ground_model.setTexture(self.ground_tex3, 1) self.ground_model.setScale(4) if self.terrain_var == 4: self.terrain_var = 1 if self.terrain_var == 0: self.terrain_var = 3 def next_terrain(): self.terrain_var = self.terrain_var + 1 def previous_terrain(): self.terrain_var = self.terrain_var - 1 def show_menu(): self.menu_win.show() self.a1.show() self.a2.show() self.a3.show() self.a4.show() self.t1.show() self.t2.show() self.ok.show() self.exit_button.show() def hide_menu(): self.menu_win.hide() self.a1.hide() self.a2.hide() self.a3.hide() self.a4.hide() self.ok.hide() self.t1.hide() self.t2.hide() self.exit_button.hide() def Menu(): self.menu_win = OnscreenImage(image = "Textures/menu.png", pos = (0.9,0,0), scale = (0.5)) self.menu_win.setTransparency(TransparencyAttrib.MAlpha) #The Arrow Buttons self.a1 = DirectButton(text = "<", scale = 0.2, pos = (0.55,0,0.25), command = previous_terrain) self.a2 = DirectButton(text = ">", scale = 0.2, pos = (1.15,0,0.25), command = next_terrain) self.a3 = DirectButton(text = "<", scale = 0.2, pos = (0.55,0,0.0), command = time_backward) self.a4 = DirectButton(text = ">", scale = 0.2, pos = (1.15,0,0.0), command = time_forward) #The Text self.t1 = OnscreenText(text = "Terrain", pos = (0.85,0.25,0), scale = 0.1, fg = (0.4,0.4,0.5,1)) self.t2 = OnscreenText(text = "Time", pos = (0.85,0,0), scale = 0.1, fg = (0.4,0.4,0.5,1)) #The Buttons self.ok = DirectButton(text = "Okay", scale = 0.11, pos = (0.87,0,-0.25), command = hide_menu) self.exit_button = DirectButton(text = "Quit", scale = 0.11, pos = (0.87,0,-0.42), command = sys.exit) Menu() def take_screenshot(): base.screenshot("Screenshot") def set_headlights(): if self.headlight_var == 1: Headlight1.setColor(VBase4(9.0,8.9,8.9,1)) Headlight2.setColor(VBase4(9.0,8.9,8.9,1)) if self.headlight_var == 0: Headlight1.setColor(VBase4(0,0,0,1)) Headlight2.setColor(VBase4(0,0,0,1)) def headlights(): self.headlight_var = (self.headlight_var + 1) % 2 def update_rpm(): #Simulate RPM if self.start == 1: if self.gear == 0: self.RPM = self.RPM - self.RPM / 400 else: self.RPM = self.RPM + self.carspeed / 9 self.RPM = self.RPM - self.RPM / 200 #Reset RPM to 0 when engine is off if self.start == 0: if self.RPM > 0.0: self.RPM = self.RPM - 40 if self.RPM < 10: self.RPM = 0.0 #Idle RPM power if self.start == 1: if self.RPM < 650: self.RPM = self.RPM + 4 if self.RPM < 600: self.clutch = 1 else: self.clutch = 0 #RPM limit if self.RPM > 6000: self.RPM = 6000 #Controls inputState.watchWithModifiers("F", "arrow_up") inputState.watchWithModifiers("B", "arrow_down") inputState.watchWithModifiers("L", "arrow_left") inputState.watchWithModifiers("R", "arrow_right") do = DirectObject() do.accept("escape", show_menu) do.accept("1", V1) do.accept("2", V2) do.accept("3", V3) do.accept("page_up", up) do.accept("page_down", down) do.accept("x-repeat", start_function) do.accept("x", stop_function) do.accept("p", parkingbrake) do.accept("backspace", rotate) do.accept("enter", horn) do.accept("f12", take_screenshot) do.accept("h", headlights) #The ground self.ground = BulletPlaneShape(Vec3(0, 0, 1,), 1) self.ground_node = BulletRigidBodyNode("The ground") self.ground_node.addShape(self.ground) self.ground_np = render.attachNewNode(self.ground_node) self.ground_np.setPos(0, 0, -2) scene.attachRigidBody(self.ground_node) self.ground_model = loader.loadModel("Models/plane.egg") self.ground_model.reparentTo(render) self.ground_model.setPos(0,0,-1) self.ground_model.setScale(3) self.ground_tex = loader.loadTexture("Textures/ground.png") self.ground_tex2 = loader.loadTexture("Textures/ground2.png") self.ground_tex3 = loader.loadTexture("Textures/ground3.png") self.ground_model.setTexture(self.ground_tex, 1) #The car Car_shape = BulletBoxShape(Vec3(1, 2.0, 1.0)) Car_node = BulletRigidBodyNode("The Car") Car_node.setMass(1200.0) Car_node.addShape(Car_shape) Car_np = render.attachNewNode(Car_node) Car_np.setPos(0,0,3) Car_np.setHpr(0,0,0) Car_np.node().setDeactivationEnabled(False) scene.attachRigidBody(Car_node) Car_model = loader.loadModel("Models/Car.egg") Car_model.reparentTo(Car_np) Car_tex = loader.loadTexture("Textures/Car1.png") Car_model.setTexture(Car_tex, 1) self.Car_sim = BulletVehicle(scene, Car_np.node()) self.Car_sim.setCoordinateSystem(ZUp) scene.attachVehicle(self.Car_sim) #The inside of the car Car_int = loader.loadModel("Models/inside.egg") Car_int.reparentTo(Car_np) Car_int_tex = loader.loadTexture("Textures/inside.png") Car_int.setTexture(Car_int_tex, 1) Car_int.setTransparency(TransparencyAttrib.MAlpha) #The steering wheel Sw = loader.loadModel("Models/Steering wheel.egg") Sw.reparentTo(Car_np) Sw.setPos(0.25,0,-0.025) #The first headlight Headlight1 = Spotlight("Headlight1") lens = PerspectiveLens() lens.setFov(180) Headlight1.setLens(lens) Headlight1np = render.attachNewNode(Headlight1) Headlight1np.reparentTo(Car_np) Headlight1np.setPos(-0.8,2.5,-0.5) Headlight1np.setP(-15) render.setLight(Headlight1np) #The second headlight Headlight2 = Spotlight("Headlight2") Headlight2.setLens(lens) Headlight2np = render.attachNewNode(Headlight2) Headlight2np.reparentTo(Car_np) Headlight2np.setPos(0.8,2.5,-0.5) Headlight2np.setP(-15) render.setLight(Headlight2np) #Sounds self.horn_sound = loader.loadSfx("Sounds/horn.ogg") self.start_sound = loader.loadSfx("Sounds/enginestart.ogg") self.engine_idle_sound = loader.loadSfx("Sounds/engineidle.ogg") self.engine_idle_sound.setLoop(True) self.accelerate_sound = loader.loadSfx("Sounds/enginethrottle.ogg") #Camera base.disableMouse() camera.reparentTo(Car_np) camera.setPos(0,-15,3) camera.setHpr(0,-10,0) #Wheel function def Wheel(pos, np, r, f): w = self.Car_sim.createWheel() w.setNode(np.node()) w.setChassisConnectionPointCs(pos) w.setFrontWheel(f) w.setWheelDirectionCs(Vec3(0, 0, -1)) w.setWheelAxleCs(Vec3(1, 0, 0)) w.setWheelRadius(r) w.setMaxSuspensionTravelCm(40) w.setSuspensionStiffness(120) w.setWheelsDampingRelaxation(2.3) w.setWheelsDampingCompression(4.4) w.setFrictionSlip(50) w.setRollInfluence(0.1) #Wheels w1_np = loader.loadModel("Models/Lwheel") w1_np.reparentTo(render) w1_np.setColorScale(0,6) Wheel(Point3(-1,1,-0.6), w1_np, 0.4, False) w2_np = loader.loadModel("Models/Rwheel") w2_np.reparentTo(render) w2_np.setColorScale(0,6) Wheel(Point3(-1.1,-1.2,-0.6), w2_np, 0.4, True) w3_np = loader.loadModel("Models/Lwheel") w3_np.reparentTo(render) w3_np.setColorScale(0,6) Wheel(Point3(1.1,-1,-0.6), w3_np, 0.4, True) w4_np = loader.loadModel("Models/Rwheel") w4_np.reparentTo(render) w4_np.setColorScale(0,6) Wheel(Point3(1,1,-0.6), w4_np, 0.4, False) #The engine and steering def processInput(dt): #Vehicle properties self.steeringClamp = 35.0 self.steeringIncrement = 70 engineForce = 0.0 brakeForce = 0.0 #Get the vehicle's current speed self.carspeed = self.Car_sim.getCurrentSpeedKmHour() #Engage clutch when in gear 0 if self.gear == 0: self.clutch = 1 #Slow the steering when at higher speeds self.steeringIncrement = self.steeringIncrement - self.carspeed / 1.5 #Reset the steering if not inputState.isSet("L") and not inputState.isSet("R"): if self.steering < 0.00: self.steering = self.steering + 0.6 if self.steering > 0.00: self.steering = self.steering - 0.6 if self.steering < 1.0 and self.steering > -1.0: self.steering = 0 #Slow the car down while it's moving if self.clutch == 0: brakeForce = brakeForce + self.carspeed / 5 else: brakeForce = brakeForce + self.carspeed / 15 #Forward if self.start == 1: if inputState.isSet("F"): self.RPM = self.RPM + 35 self.accelerate_sound.play() if self.clutch == 0: if self.gear == -1: if self.carspeed > self.carmaxreversespeed: engineForce = -self.RPM / 3 if self.gear == 1: if self.carspeed < self.carmaxspeed: engineForce = self.RPM / 1 #Brake if inputState.isSet("B"): engineForce = 0.0 brakeForce = 12.0 if self.gear != 0 and self.clutch == 0: self.RPM = self.RPM - 20 #Left if inputState.isSet("L"): if self.steering < 0.0: #This makes the steering reset at the correct speed when turning from right to left self.steering += dt * self.steeringIncrement + 0.6 self.steering = min(self.steering, self.steeringClamp) else: #Normal steering self.steering += dt * self.steeringIncrement self.steering = min(self.steering, self.steeringClamp) #Right if inputState.isSet("R"): if self.steering > 0.0: #This makes the steering reset at the correct speed when turning from left to right self.steering -= dt * self.steeringIncrement + 0.6 self.steering = max(self.steering, -self.steeringClamp) else: #Normal steering self.steering -= dt * self.steeringIncrement self.steering = max(self.steering, -self.steeringClamp) #Park if self.Pbrake == 1: brakeForce = 10.0 if self.gear != 0 and self. clutch == 0: self.RPM = self.RPM - 20 #Apply forces to wheels self.Car_sim.applyEngineForce(engineForce, 0); self.Car_sim.applyEngineForce(engineForce, 3); self.Car_sim.setBrake(brakeForce, 1); self.Car_sim.setBrake(brakeForce, 2); self.Car_sim.setSteeringValue(self.steering, 0); self.Car_sim.setSteeringValue(self.steering, 3); #Steering wheel Sw.setHpr(0,0,-self.steering*10) #The HUD self.gear_hud = OnscreenImage(image = "Textures/gear_hud.png", pos = (-1,0,-0.85), scale = (0.2)) self.gear_hud.setTransparency(TransparencyAttrib.MAlpha) self.gear2_hud = OnscreenImage(image = "Textures/gear2_hud.png", pos = (-1,0,-0.85), scale = (0.2)) self.gear2_hud.setTransparency(TransparencyAttrib.MAlpha) self.starter = OnscreenImage(image = "Textures/starter.png", pos = (-1.2,0,-0.85), scale = (0.15)) self.starter.setTransparency(TransparencyAttrib.MAlpha) self.park = OnscreenImage(image = "Textures/pbrake.png", pos = (-0.8,0,-0.85), scale = (0.1)) self.park.setTransparency(TransparencyAttrib.MAlpha) self.rev_counter = OnscreenImage(image = "Textures/dial.png", pos = (-1.6, 0.0, -0.70), scale = (0.6,0.6,0.4)) self.rev_counter.setTransparency(TransparencyAttrib.MAlpha) self.rev_needle = OnscreenImage(image = "Textures/needle.png", pos = (-1.6, 0.0, -0.70), scale = (0.5)) self.rev_needle.setTransparency(TransparencyAttrib.MAlpha) self.rev_text = OnscreenText(text = " ", pos = (-1.6, -0.90, 0), scale = 0.05) self.speedometer = OnscreenImage(image = "Textures/dial.png", pos = (-1.68, 0.0, -0.10), scale = (0.7,0.7,0.5)) self.speedometer.setTransparency(TransparencyAttrib.MAlpha) self.speedometer_needle = OnscreenImage(image = "Textures/needle.png", pos = (-1.68, 0.0, -0.10), scale = (0.5)) self.speedometer_needle.setTransparency(TransparencyAttrib.MAlpha) self.speedometer_text = OnscreenText(text = " ", pos = (-1.68, -0.35, 0), scale = 0.05) #Update the HUD def Update_HUD(): #Move gear selector if self.gear == -1: self.gear2_hud.setPos(-1,0,-0.785) if self.gear == 0: self.gear2_hud.setPos(-1,0,-0.85) if self.gear == 1: self.gear2_hud.setPos(-1,0,-0.91) #Rotate starter if self.start == 0: self.starter.setHpr(0,0,0) else: self.starter.setHpr(0,0,45) #Update the parking brake light if self.Pbrake == 1: self.park.setImage("Textures/pbrake2.png") self.park.setTransparency(TransparencyAttrib.MAlpha) else: self.park.setImage("Textures/pbrake.png") self.park.setTransparency(TransparencyAttrib.MAlpha) #Update the rev counter self.rev_needle.setR(self.RPM/22) rev_string = str(self.RPM)[:4] self.rev_text.setText(rev_string+" RPM") #Update the speedometer if self.carspeed > 0.0: self.speedometer_needle.setR(self.carspeed*2.5) if self.carspeed < 0.0: self.speedometer_needle.setR(-self.carspeed*2.5) speed_string = str(self.carspeed)[:3] self.speedometer_text.setText(speed_string+" KPH") #Update the program def update(task): dt = globalClock.getDt() processInput(dt) Update_HUD() set_time() set_terrain() set_headlights() update_rpm() scene.doPhysics(dt, 5, 1.0/180.0) return task.cont taskMgr.add(update, "Update")
def __init__(self, mainWin=base.win, mainCam=base.cam, scene=render): self.lastMousePos = Vec2(-2, -2) self.lastId = 0 self.pressedNode = None self.mDownId = 0 self.idStack = range(1, 256) self.idTable = {} self.aspectRatio = 1 self.checkCursorTask = Task(self.checkCursor, 'checkCursorTask') self.enabled = True self.mouseListeners = [] self.mainCam = mainCam mainCam.node().setCameraMask(BitMask32(1)) tempnode = NodePath(PandaNode('temp node')) tempnode.setShaderAuto() tempnode.setShaderInput('hi_id', Vec4(0, 0, 0, 0), 2) mainCam.node().setInitialState(tempnode.getState()) # Set up a node with the silhouetteGen shader. We'll apply this node's # state to custom cameras below. tempnode.setShader(loader.loadShader('silhouetteGen.sha'), 100) tempnode.setShaderInput('hi_id', Vec4(0, 0, 0, 0), 0) tempnode.setAntialias(AntialiasAttrib.MNone, 100) tempnode.setBin('inactive', 0, 1) initialState = tempnode.getState() tempnode.setBin('opaque', 0, 1) selnodeState = tempnode.getState() # We'll be using this a few times, so make an easy name for it. mainLens = mainCam.node().getLens() # Set up a buffer to which we draw a silhouette of any geometry that # we want to outline. We draw the outline by applying a Sobel edge # detection shader to the contents of this buffer. silhouetteBuffer = mainWin.makeTextureBuffer('silhouetteBuffer', 0, 0) silhouetteBuffer.setClearColor(Vec4(0, 0, 0, 1)) self.silhouetteBuffer = silhouetteBuffer silhouetteCamera = base.makeCamera(silhouetteBuffer, lens=mainLens) silhouetteCamera.node().setScene(scene) silhouetteCamera.node().setInitialState(initialState) silhouetteCamera.node().setTagState('sel', selnodeState) silhouetteCamera.node().setTagStateKey('sel') silhouetteCamera.node().setCameraMask(BitMask32(8)) tempnode.setShader(loader.loadShader('mousePicker.sha'), 100) selnodeState = tempnode.getState() tempnode.setBin('inactive', 0, 1) initialState = tempnode.getState() # Set up a 1-by-1 buffer to which we'll just render the pixel under # the mouse. selectBuffer = mainWin.makeTextureBuffer('selectBuffer', 1, 1) selectBuffer.setClearColor(Vec4(0, 0, 0, 1)) self.selectBuffer = selectBuffer selectLens = PerspectiveLens() selectLens.setNearFar(mainLens.getNear(), mainLens.getFar()) selectLens.setFocalLength(mainLens.getFocalLength()) selectCamera = base.makeCamera(selectBuffer, lens=selectLens) selectCamera.node().setScene(scene) selectCamera.node().setInitialState(initialState) selectCamera.node().setTagState('sel', selnodeState) selectCamera.node().setTagStateKey('sel') selectCamera.node().setCameraMask(BitMask32(16)) self.selectLens = selectLens self.selectTex = selectBuffer.getTexture() self.selectTex.makeRamImage() self.gsg = mainWin.getGsg() # Set up a texture card to render the silhouette texture with the # Sobel shader, which will draw the edges of the silhouettes. silhouetteCard = silhouetteBuffer.getTextureCard() silhouetteCard.setTransparency(1) inkGen = loader.loadShader('sobel.sha') silhouetteCard.setShader(inkGen) silhouetteCard.setShaderInput('separation', 0.001, 0) silhouetteCard.reparentTo(render2d) self.silhouetteCard = silhouetteCard self.accept(mainWin.getWindowEvent(), self.windowEventHandler) self.accept('mouse1', self.mouseDownHandler, ['l']) self.accept('mouse1-up', self.mouseUpHandler, ['l']) self.accept('mouse3', self.mouseDownHandler, ['r']) self.accept('mouse3-up', self.mouseUpHandler, ['r']) self.buttonWatcher = ButtonWatcher([ KeyboardButton.shift(), KeyboardButton.control(), MouseButton.one(), MouseButton.three(), ]) CameraController.getInstance().addEventHandler(EVT_CAMERA_MODE, self._cameraModeHandler) self.enable(False)
def __init__(self, movie_data_file, record, use_eye_data=False, use_lfp_data=False): DirectObject.__init__(self) self.record = record # make sure directory exists movie_name = '../movies/frames/game/game' environ = 'original' # environ = 'circle' data = MovieData(movie_data_file, use_eye_data) # Things that can affect camera: # options resolution resW resH self.base = ShowBase() lens = PerspectiveLens() # Fov is set in config for 60 lens.setFov(60) # aspect ratio should be same as window size # this was for 800x600 # field of view 60 46.8264... # aspect ratio 1.3333 movie_res = [800, 600] # set aspect ratio to original game #print resolution lens.setAspectRatio(data.resolution[0] / data.resolution[1]) #print lens.getAspectRatio() #lens.setAspectRatio(800.0 / 600.0) self.base.cam.node().setLens(lens) # print('Fov', lens.getFov()) # print('Aspect Ratio', lens.getAspectRatio()) # set near to be same as avatar's radius # affects how close you get to the bananas lens.setNear(0.1) #print('near camera', lens.getNear()) #base.cam.setPos(0, 0, 1) #print('x', base.win.getXSize()) #print('y', base.win.getYSize()) # when doing the calibration task I used the orthographic lens with normal render, # so the origin was in the center, but when using pixel2d the origin is in the top # left corner, so we must move the coordinate system to the right and down by half # the screen # covert resolution eye_factor = [movie_res[0]/data.resolution[0], movie_res[1]/data.resolution[1]] # print('move_res', movie_res) # print('actual movie res', self.base.win.getXSize(), self.base.win.getYSize()) # print('data_res', data.resolution) # print('eye factor', eye_factor) # calibration not very good... #fudge_factor_x = 50 #fudge_factor_y = 80 fudge_factor_x = 0 fudge_factor_y = 60 self.eye_data = deque() self.last_eye_ts = None # since for eye_data we are looping and adding to the end of the list, # but then we will be pulling from the front of the list, we have a queue, # so let's use deque. (Other data was reversed in movie_data). if use_eye_data: for i in data.raw_eye_data: x = (float(i[0]) * eye_factor[0]) + (self.base.win.getXSize() / 2) + fudge_factor_x y = (float(i[1]) * eye_factor[1]) - (self.base.win.getYSize() / 2) + fudge_factor_y self.eye_data.append((x, y)) #print self.eye_data # container for eye trace self.eyes = [] #print(len(self.eye_data)) # make generators for eye data self.last_eye = self.eye_data.popleft() #print(len(self.eye_data)) # time stamps are all reversed, so can use normal pop and then assign directly, # like other time variables self.last_eye_ts = data.eye_ts.pop() self.eye_ts = data.eye_ts # need to adjust y position for lfp self.lfp_gain = 0.05 # lfp_offset determines where each trace is on the y axis lfp_offset = -500 # bottom self.lfp_offset = [] #self.lfp_offset = -100 # top of screen self.last_lfp = [] self.gen_lfp = [] # make a generator for lfp data # this code is a little silliness, and I'm popping a giant list from the wrong end # when I start plotting lfp again, fix this! if use_lfp_data: for data in data.lfp_data: self.lfp_offset.append(lfp_offset) self.last_lfp.append([(data.pop(0) * self.lfp_gain) + lfp_offset]) lfp_offset += 100 # self.gen_lfp.append(get_data(data)) # last_lfp_x determines where on the x axis we start the lfp trace self.start_x_trace = 50 # bring in data we care about. self.avatar_pos = data.avatar_pos self.avatar_pt = data.avatar_pt self.avatar_h = data.avatar_h self.avatar_ht = data.avatar_ht self.fruit_status = data.fruit_status self.fruit_status_ts = data.fruit_status_ts self.fruit_pos = data.fruit_pos self.fruit_pos_ts = data.fruit_pos_ts self.trial_mark = data.trial_mark # print 'fruit pos timestamps', self.fruit_pos_ts # initialize other variables self.eye_spot = None # set starting point for avatar points = self.avatar_pos.pop() self.base.cam.setPos(Point3(points[0], points[1], points[2])) self.base.cam.setH(self.avatar_h.pop()) self.avatar_ht.pop() self.avatar_pt.pop() # get last time stamp (first of list) for avatar to calculate length of movie # add half a second buffer. movie_length = self.avatar_ht[0] + 0.8 print('movie length', movie_length) self.set_environment(environ) #load bananas # if we are not starting at the beginning of the trial, some of the bananas may # already be gone. Create them, and then stash them, so the index still refers to # the correct banana self.fruitModel = {} # print('fruit', self.fruit_pos) for k, v in self.fruit_pos.iteritems(): #print('i', i) # print('k', k) #print('v', v) if 'banana' in k: self.fruitModel[k] = self.base.loader.loadModel('../goBananas/models/bananas/banana.bam') self.fruitModel[k].setScale(0.5) elif 'cherry' in k: self.fruitModel[k] = self.base.loader.loadModel('../goBananas/models/fruit/cherries.egg') self.fruitModel[k].setScale(0.08) # position = self.fruit_pos[k]['position'].pop(0) # print position heading = v['head'] #print heading # self.fruitModel[k].setPos( # Point3(float(position[0]), float(position[1]), float(position[2]))) self.fruitModel[k].setH(float(heading)) self.fruitModel[k].reparentTo(self.base.render) # assume all fruit stashed to start self.fruitModel[k].stash() if k in data.alpha: print 'set alpha', data.alpha self.alpha_node_path = self.fruitModel[k] self.alpha_node_path.setTransparency(TransparencyAttrib.MAlpha) if self.record: print('make movie', movie_name) self.movie_task = self.base.movie(movie_name, movie_length, 30, 'png', 4) self.gameTask = taskMgr.add(self.frame_loop, "frame_loop") self.gameTask.last = 0 # Task time of the last frame
class Camera_Controller: def __init__(self,base): self.base = base self.base.disableMouse() x_win = self.base.win.getXSize() y_win = self.base.win.getYSize() aspect_win = float(x_win)/float(y_win) self.active_lens = 1 self.ortho_lens = OrthographicLens() self.ortho_lens.setAspectRatio(aspect_win) self.ortho_lens.setNearFar(1.0,100.0) self.persp_lens = PerspectiveLens() self.persp_lens.setAspectRatio(aspect_win) self.persp_lens.setFov(5.0) self.persp_lens.setNearFar(1.0,100.0) self.lenses = [self.persp_lens, self.ortho_lens] self.set_lens(lens=self.active_lens) self.set_view(Vec3(50.0,50.0,50.0)) self.old_x = None self.old_y = None self.zoom_speed = 0.05 self.pan_speed = 0.005 self.rotate_speed = 0.1 #these are pointers self.keys = self.base.keyboard_reader.keys self.key_map = self.base.keyboard_reader.key_map #registering camera functions self.base.taskMgr.add(hold_caller_multikey(trigger=self.keys, indices=[self.key_map['shift'], self.key_map['mouse2']], values=[1,1], init_handle=None, loop_handle=self.pan_camera, cleanup_handle=self.mouse_delta_cleanup), 'pan_camera_task') self.base.taskMgr.add(hold_caller_multikey(trigger=self.keys, indices=[self.key_map['control'], self.key_map['shift'], self.key_map['mouse2']], values=[0, 0,1], init_handle=None, loop_handle=self.rotate_camera_fixed_pivot, cleanup_handle=self.mouse_delta_cleanup), 'rotate_camera_task') self.base.taskMgr.add(hold_caller_multikey(trigger=self.keys, indices=[self.key_map['control'], self.key_map['mouse2']], values=[1,1], init_handle=None, loop_handle=self.zoom_camera, cleanup_handle=self.mouse_delta_cleanup), 'rotate_camera_task') #register camera presets self.base.taskMgr.add( delta_caller(handle = self.set_viewpoint_front , trigger = self.keys, index = self.key_map['1'], value=1), 'camera_preset_front_task') self.base.taskMgr.add( delta_caller(handle = self.set_viewpoint_side , trigger = self.keys, index = self.key_map['2'], value=1), 'camera_preset_side_task') self.base.taskMgr.add( delta_caller(handle = self.set_viewpoint_top , trigger = self.keys, index = self.key_map['3'], value=1), 'camera_preset_top_task') #register switching perspective #TODO: currently disabled because perspective camera is stupid and should feel bad #self.base.taskMgr.add( delta_caller(handle = self.switch_perspective , trigger = self.keys, index = self.key_map['5'], value=1), 'camera_switch_perspective_task') #makes the zoom level of the orthographic camera more reasonable self.fixed_zoom_camera(10.0) def set_view(self, position): self.pos = Vec3(position) self.base.cam.setPos(self.pos) self.pivot = Vec3(0.0,0.0,0.0) self.base.cam.lookAt(0.0,0.0,0.0) self.hpr = self.base.cam.getHpr() def set_lens(self,lens): old_pos = self.base.cam.getPos() self.active_lens = lens self.base.cam.node().setLens(self.lenses[self.active_lens]) self.base.cam.setPos(old_pos) def mouse_delta_cleanup(self): self.old_x = None self.old_y = None def get_mouse_delta(self): md = self.base.win.getPointer(0) x = md.getX() y = md.getY() d_x = None d_y = None if self.old_x == None or self.old_y == None: self.old_x = x self.old_y = y else: d_y = (y - self.old_y) d_x = (x - self.old_x) self.old_x = x self.old_y = y return (d_x, d_y) def pan_camera(self): pan_speed = self.pan_speed (d_x,d_y) = self.get_mouse_delta() if (d_x != None) and (d_y != None): up = self.base.cam.getMat().getRow3(2) side = self.base.cam.getMat().getRow3(0) d_up = up * d_y * pan_speed d_side = side * -d_x * pan_speed self.pos = self.pos + d_up + d_side self.pivot = self.pivot + d_up + d_side self.base.cam.setPos(self.pos) def zoom_forward(self): self.fixed_zoom_camera(self.zoom_speed) def zoom_backward(self): self.fixed_zoom_camera(-self.zoom_speed) def fixed_zoom_camera(self, zoom_speed): if self.active_lens == 0: forward = self.base.cam.getMat().getRow3(1) d_forward = forward * zoom_speed self.pos = self.pos + d_forward self.base.cam.setPos(self.pos) if self.active_lens == 1: zoom_level = self.ortho_lens.getFilmSize() z_x = max(zoom_level.x + zoom_speed, 0.1) z_y = z_x*0.75 self.ortho_lens.setFilmSize(z_x , z_y) def zoom_camera(self): zoom_speed = self.zoom_speed (d_x,d_y) = self.get_mouse_delta() if (d_y != None): if self.active_lens == 0: forward = self.base.cam.getMat().getRow3(1) d_forward = forward * d_y * zoom_speed self.pos = self.pos + d_forward self.base.cam.setPos(self.pos) if self.active_lens == 1: zoom_level = self.ortho_lens.getFilmSize() z_x = max(zoom_level.x + d_y * zoom_speed, 0.1) z_y = z_x*0.75 self.ortho_lens.setFilmSize(z_x , z_y) def rotate_camera_fixed_location(self): rotate_speed = self.rotate_speed (d_x,d_y) = self.get_mouse_delta() if (d_x != None) and (d_y != None): self.hpr = self.hpr + Vec3(-d_x * rotate_speed ,-d_y * rotate_speed ,0) self.base.cam.setHpr(self.hpr) def rotate_camera_fixed_pivot(self): pivot = self.pivot rotate_speed = self.rotate_speed (d_x,d_y) = self.get_mouse_delta() if (d_x != None) and (d_y != None): up = self.base.cam.getMat().getRow3(2) side = self.base.cam.getMat().getRow3(0) d_up = up * d_y * rotate_speed d_side = side * -d_x * rotate_speed old_length = self.pos.length() self.pos = self.pos + d_up + d_side self.pos = self.pos / self.pos.length() * old_length print self.pos.length() self.base.cam.setPos(self.pos) self.base.cam.lookAt(pivot) def set_viewpoint_front(self): self.set_view(Vec3(20.0,0.0,0.0)) def set_viewpoint_side(self): self.set_view(Vec3(0.0,20.0,0.0)) def set_viewpoint_top(self): self.set_view(Vec3(0.0,0.0,20.0)) def switch_perspective(self): lens = (self.active_lens + 1) % 2 self.set_lens(lens)
def __init__(self): ShowBase.__init__(self) self.dirTypes = ['heading', 'pitch', 'roll'] self.dirType = 0 # Display instructions add_title("Panda3D Tutorial: Portal Culling") add_instructions(0.06, "[Esc]: Quit") self.posText = add_instructions(0.12, "pos") self.anglesText = add_instructions(0.18, "angle") self.armHprText = add_instructions(0.24, "hpr") self.dirText = add_instructions(.30, self.dirTypes[0]) self.forearmText = add_instructions(0.36, "angle") self.baseText = add_instructions(0.42, "angle") """add_instructions(0.12, "[W]: Move Forward") add_instructions(0.18, "[A]: Move Left") add_instructions(0.24, "[S]: Move Right") add_instructions(0.30, "[D]: Move Back") add_instructions(0.36, "Arrow Keys: Look Around") add_instructions(0.42, "[F]: Toggle Wireframe") add_instructions(0.48, "[X]: Toggle X-Ray Mode") add_instructions(0.54, "[B]: Toggle Bounding Volumes")""" # Setup controls self.keys = {} for key in ['arrow_left', 'arrow_right', 'arrow_up', 'arrow_down', 'a', 'd', 'w', 's', 'q', 'e']: self.keys[key] = 0 self.accept(key, self.push_key, [key, 1]) self.accept('shift-%s' % key, self.push_key, [key, 1]) self.accept('%s-up' % key, self.push_key, [key, 0]) self.accept("b", self.push_key, ["Rleft", True]) self.accept("b-up", self.push_key, ["Rleft", False]) self.accept("n", self.push_key, ["Rright", True]) self.accept("n-up", self.push_key, ["Rright", False]) self.accept("h", self.push_key, ["Rforward", True]) self.accept("h-up", self.push_key, ["Rforward", False]) self.keys['Rleft'] = self.keys['Rright'] = self.keys['Rforward'] = 0 self.accept('escape', self.exitButton) self.accept('p', self.selectDir) self.accept('[', self.incDir, [-15]) self.accept(']', self.incDir, [15]) #self.disableMouse() # Setup camera lens = PerspectiveLens() lens.setFov(60) lens.setNear(0.01) lens.setFar(1000.0) self.cam.node().setLens(lens) self.camera.setPos(-50, 0, 0) self.pitch = 0.0 self.heading = 0 ambientLight = AmbientLight("ambientLight") ambientLight.setColor((.3, .3, .3, 1)) directionalLight = DirectionalLight("directionalLight") directionalLight.setDirection((-5, -5, -5)) directionalLight.setColor((1, 1, 1, 1)) directionalLight.setSpecularColor((1, 1, 1, 1)) render.setLight(render.attachNewNode(ambientLight)) render.setLight(render.attachNewNode(directionalLight)) # Load level geometry self.level = self.loader.loadModel('models/theater') self.level.reparentTo(self.render) self.isMoving = False self.ralph = Actor("models/ralph", {"run": "models/ralph-run", "walk": "models/ralph-walk"}) self.ralph.reparentTo(render) self.ralph.setScale(.2) self.arms = [] idMap = {0:9, 1:11, 2:17, 3:27, 4:29} for node in self.level.get_children(): if not node.getName().startswith('arm'): continue arm = Actor("models/robotarm") self.arms.append(arm) arm.reparentTo(render) arm.setName(node.getName()) arm.setPos(node.getPos()) arm.setHpr(node.getHpr()) #arm.setScale(.2) tokens = node.getName().split('.') try: id = int(tokens[1]) except: id = 0 arm.baseID = idMap[id] arm.jointForearm = arm.controlJoint(None, "modelRoot", "forearm") arm.jointBase = arm.controlJoint(None, "modelRoot", "base") print node.getName(), str(node.getPos()), str(node.getHpr()) taskMgr.add(self.printLoc, "printLoc") taskMgr.add(self.monitorArms, "robot arms") self.taskMgr.add(self.update, 'main loop')
def __init__(self): ShowBase.__init__(self) self.xray_mode = False self.show_model_bounds = False # Display instructions add_title("Panda3D Tutorial: Occluder Culling") add_instructions(0.06, "[Esc]: Quit") add_instructions(0.12, "[W]: Move Forward") add_instructions(0.18, "[A]: Move Left") add_instructions(0.24, "[S]: Move Right") add_instructions(0.30, "[D]: Move Back") add_instructions(0.36, "Arrow Keys: Look Around") add_instructions(0.42, "[F]: Toggle Wireframe") add_instructions(0.48, "[X]: Toggle X-Ray Mode") add_instructions(0.54, "[B]: Toggle Bounding Volumes") # Setup controls self.keys = {} for key in ["arrow_left", "arrow_right", "arrow_up", "arrow_down", "a", "d", "w", "s"]: self.keys[key] = 0 self.accept(key, self.push_key, [key, 1]) self.accept("shift-%s" % key, self.push_key, [key, 1]) self.accept("%s-up" % key, self.push_key, [key, 0]) self.accept("f", self.toggleWireframe) self.accept("x", self.toggle_xray_mode) self.accept("b", self.toggle_model_bounds) self.accept("escape", __import__("sys").exit, [0]) self.disableMouse() # Setup camera self.lens = PerspectiveLens() self.lens.setFov(60) self.lens.setNear(0.01) self.lens.setFar(1000.0) self.cam.node().setLens(self.lens) self.camera.setPos(-9, -0.5, 1) self.heading = -95.0 self.pitch = 0.0 # Load level geometry self.level_model = self.loader.loadModel("models/level") self.level_model.reparentTo(self.render) self.level_model.setTexGen(TextureStage.getDefault(), TexGenAttrib.MWorldPosition) self.level_model.setTexProjector(TextureStage.getDefault(), self.render, self.level_model) self.level_model.setTexScale(TextureStage.getDefault(), 4) tex = self.loader.load3DTexture("models/tex_#.png") self.level_model.setTexture(tex) # Load occluders occluder_model = self.loader.loadModel("models/occluders") occluder_nodepaths = occluder_model.findAllMatches("**/+OccluderNode") for occluder_nodepath in occluder_nodepaths: self.render.setOccluder(occluder_nodepath) occluder_nodepath.node().setDoubleSided(True) # Randomly spawn some models to test the occluders self.models = [] box_model = self.loader.loadModel("box") for dummy in range(0, 500): pos = LPoint3((random.random() - 0.5) * 9, (random.random() - 0.5) * 9, random.random() * 8) box = box_model.copy_to(self.render) box.setScale(random.random() * 0.2 + 0.1) box.setPos(pos) box.setHpr(random.random() * 360, random.random() * 360, random.random() * 360) box.reparentTo(self.render) self.models.append(box) self.taskMgr.add(self.update, "main loop")