def setHDR(self, toggle): self.hdrToggle = toggle if toggle: # Don't clamp lighting calculations with hdr. render.setAttrib(LightRampAttrib.makeIdentity()) else: render.setAttrib(LightRampAttrib.makeDefault())
def enable_hdr(self, enable): """Turn HDR effect on or off. Arguments: enable {bool} -- flag """ if enable: self.render.set_attrib(LightRampAttrib.makeHdr0()) else: self.render.set_attrib(LightRampAttrib.makeDefault()) self._hdr_enabled = enable
def toggle_hdr(self): self.hdr += 1 if self.hdr > 3: self.hdr = 0 print("HDR:", self.hdr) if self.hdr == 0: self.world.clearAttrib(LightRampAttrib.getClassType()) elif self.hdr == 1: self.world.setAttrib(LightRampAttrib.makeHdr0()) elif self.hdr == 2: self.world.setAttrib(LightRampAttrib.makeHdr1()) elif self.hdr == 3: self.world.setAttrib(LightRampAttrib.makeHdr2())
def setHDR(self, toggle): self.hdrToggle = toggle #if not hasattr(self, 'hdr'): # return if toggle: # Don't clamp lighting calculations with hdr. render.setAttrib(LightRampAttrib.makeIdentity()) #self.hdr.enable() else: render.setAttrib(LightRampAttrib.makeDefault())
def new_game(self): Maze.__init__(self, self.total_rooms) self.items = [] self.tiles = defaultdict(Tile) self.root = render.attach_new_node("map_root") self.static = self.root.attach_new_node("map-static") self.unlit = render.attach_new_node("map-unlit") self.backsides = self.root.attach_new_node("map-backsides") self.dynamic = render.attach_new_node("map-dynamic") self.enemies = [] self.rooms = {} self.rooms_visited = 0 self.current_set = 0 self.tile_set = self.tile_sets[self.sets[self.current_set]] self.dynamic.hide(0b001) base.player.root.hide(0b001) for target_np in [ self.static, self.backsides, self.unlit, self.dynamic, ]: target_np.set_attrib( LightRampAttrib.make_single_threshold(0.0, 1.0)) target_np.set_light(base.fov_point_np) base.fov_point_np.reparent_to(base.player.root) base.fov_point.set_scene(self.root) p = self.pos(8) self.rooms[p] = Room(*p) base.player.root.set_pos((p[0] + 4, -p[1] - 4, 0)) base.player.reset()
def __init__(self): base.disableMouse() base.cam.node().getLens().setNear(10.0) base.cam.node().getLens().setFar(9999999) camera.setPos(0, -50, 0) # Check video card capabilities. if (base.win.getGsg().getSupportsBasicShaders() == 0): addTitle("Toon Shader: Video driver reports that shaders are not supported.") return # Enable a 'light ramp' - this discretizes the lighting, # which is half of what makes a model look like a cartoon. # Light ramps only work if shader generation is enabled, # so we call 'setShaderAuto'. tempnode = NodePath(PandaNode("temp node")) tempnode.setAttrib(LightRampAttrib.makeSingleThreshold(0.5, 0.4)) tempnode.setShaderAuto() base.cam.node().setInitialState(tempnode.getState()) # Use class 'CommonFilters' to enable a cartoon inking filter. # This can fail if the video card is not powerful enough, if so, # display an error and exit. self.separation = 1 # Pixels self.filters = CommonFilters(base.win, base.cam) filterok = self.filters.setCartoonInk(separation=self.separation) if (filterok == False): addTitle("Toon Shader: Video card not powerful enough to do image postprocessing") return # Create a non-attenuating point light and an ambient light. plightnode = PointLight("point light") plightnode.setAttenuation(Vec3(1,0,0)) plight = render.attachNewNode(plightnode) plight.setPos(30,-50,0) alightnode = AmbientLight("ambient light") alightnode.setColor(Vec4(0.8,0.8,0.8,1)) alight = render.attachNewNode(alightnode) render.setLight(alight) render.setLight(plight) # Panda contains a built-in viewer that lets you view the # results of all render-to-texture operations. This lets you # see what class CommonFilters is doing behind the scenes. self.accept("v", base.bufferViewer.toggleEnable) self.accept("V", base.bufferViewer.toggleEnable) base.bufferViewer.setPosition("llcorner") self.accept("s", self.filters.manager.resizeBuffers) # These allow you to change cartooning parameters in realtime self.accept("escape", sys.exit, [0])
def __init__(self, aCol, dDir, dCol): render.setAttrib(LightRampAttrib.makeHdr1()) ambientLight = AmbientLight("ambientLight") ambientLight.setColor(aCol) directionalLight = DirectionalLight("directionalLight") directionalLight.setDirection(dDir) directionalLight.setColor(dCol) directionalLight.setSpecularColor(Vec4(2.0, 2.0, 2.0, 0)) render.setLight(render.attachNewNode(ambientLight)) render.setLight(render.attachNewNode(directionalLight))
def stop(self): if self.hdrtype!=None: render.clearAttrib(LightRampAttrib.getClassType()) if self.perpixel: render.setShaderOff() if self.bloomSize!=None: self.cf.delBloom() if self.showbuffers: base.bufferViewer.toggleEnable()
def toggle_cartoon(self): ''' Use Cartoon ink filter ''' self.cartoon = not self.cartoon if self.cartoon: tempnode = NodePath(PandaNode("temp node")) tempnode.setAttrib(LightRampAttrib.makeSingleThreshold(0.4, 0.6)) tempnode.setShaderAuto() base.cam.node().setInitialState(tempnode.getState()) self.separation = 1.3 # Pixels self.filters = CommonFilters(base.win, base.cam) self.filters.setCartoonInk(separation=self.separation) # Currently using MAuto antialias, uncomment to use different #render.setAntialias(AntialiasAttrib.MBetter) #self.filters.finalQuad.setAntialias(AntialiasAttrib.MBetter) else: self.filters.cleanup() base.cam.node().setInitialState(self.alight.getState())
def register(self, render, camera, keys, render2d): State.register(self, render, camera, keys, render2d) self.node.attachNewNode(self.stage.maps[self.room].getNode()) for c in self.characters: self.status[c].reparentTo(self.node2d) for char in self.characters.values(): char.getNode().reparentTo(self.node) char.stunRender = self.node for l in self.stage.getLights(): render.setLight(l) # COWABUNGA test!!! self.hearts = {} numChar=0 self.heartsNode = NodePath(PandaNode('hearts')) self.heartsNode.reparentTo(self.node2d) for char in self.characters: self.hearts[char] = [] for i in range(Character.maxHearts): self.hearts[char].append(Sprite("heart.png", 0.05, 0.05)) self.hearts[char][i].setPos(-0.8 + 1.4*numChar + (i%3)*0.055 , -0.9 - int(i/3)*0.055) self.hearts[char][i].getNode().reparentTo(self.heartsNode) numChar += 1 #COWABUNGA comment this to stop the madness render.setAttrib(LightRampAttrib.makeSingleThreshold(0.1, 1)) # THE TRUE CARTOON SHADER :P # self.separation = 1 # Pixels self.filters = CommonFilters(base.win, self.camera.camera) # cell shading # filterok = self.filters.setCartoonInk(separation=self.separation) # glow filterok = self.filters.setBloom(blend=(0.5,0.5,0.5,1), desat=-0.5, intensity=0.5, size="small") self.camera.setPos(0, -2.5, -2.5) self.camera.lookAt(0, 0, 0)
def compose_filters(self, win, cam, seperation=.6): """ function to handle the composing, which makes for the basic look and feel of the game also handles any filters which are attached to the cam :return: """ # set up the lightramp effect tempnode = NodePath(PandaNode("temp node")) tempnode.setAttrib(LightRampAttrib.makeSingleThreshold( 0.5, 0.4)) # warning can be ignored.. tempnode.setShaderAuto() cam.node().setInitialState(tempnode.getState()) self.separation = seperation # Pixels self.filters = CommonFilters(win, cam) filterok = self.filters.setCartoonInk(separation=self.separation) if (filterok == False): return
def setShaders(self): if not base.win.getGsg().getSupportsBasicShaders(): print( "Toon Shader: Video driver reports that Cg shaders are not supported." ) return tempnode = NodePath(PandaNode("temp node")) tempnode.setAttrib(LightRampAttrib.makeHdr0()) self.filters = CommonFilters(base.win, base.cam) # GLOW self.filters.setBloom(blend=(0.3, 0.4, 0.3, 0.0), mintrigger=0.6, maxtrigger=1.0, desat=0.6, intensity=1.0, size="medium") tempnode.setShaderAuto() base.cam.node().setInitialState(tempnode.getState())
def __init__(self): DirectObject.__init__(self) self.filename = None self.unsaved = False self.idGenerator = IDGenerator() self.world = None self.isOpen = False self.gsg = None self.page = None self.shaderGenerator = None self.numlights = 0 # Each document has its own message bus, task manager, and event manager. self.taskMgr = TaskManager() self.taskMgr.mgr = AsyncTaskManager("documentTaskMgr") self.messenger = Messenger(self.taskMgr) self.eventMgr = EventManager(messenger=self.messenger, taskMgr=self.taskMgr) self.messenger.setEventMgr(self.eventMgr) self.render = NodePath("docRender") self.render.setAttrib(LightRampAttrib.makeIdentity()) #self.render.setShaderAuto() self.viewportMgr = ViewportManager(self) self.toolMgr = ToolManager(self) self.selectionMgr = SelectionManager(self) self.actionMgr = ActionManager(self) # Create the page that the document is viewed in. self.page = DocumentWindow(self) #self.createShaderGenerator() self.toolMgr.addTools() self.eventMgr.restart()
def renderSceneInto(self, depthtex=None, colortex=None, auxtex=None, auxbits=0, textures=None, fbprops=None, clamping=None): """ Causes the scene to be rendered into the supplied textures instead of into the original window. Puts a fullscreen quad into the original window to show the render-to-texture results. Returns the quad. Normally, the caller would then apply a shader to the quad. To elaborate on how this all works: * An offscreen buffer is created. It is set up to mimic the original display region - it is the same size, uses the same clear colors, and contains a DisplayRegion that uses the original camera. * A fullscreen quad and an orthographic camera to render that quad are both created. The original camera is removed from the original window, and in its place, the orthographic quad-camera is installed. * The fullscreen quad is textured with the data from the offscreen buffer. A shader is applied that tints the results pink. * Automatic shader generation NOT enabled. If you have a filter that depends on a render target from the auto-shader, you either need to set an auto-shader attrib on the main camera or scene, or, you need to provide these outputs in your own shader. * All clears are disabled on the original display region. If the display region fills the whole window, then clears are disabled on the original window as well. It is assumed that rendering the full-screen quad eliminates the need to do clears. Hence, the original window which used to contain the actual scene, now contains a pink-tinted quad with a texture of the scene. It is assumed that the user will replace the shader on the quad with a more interesting filter. """ if textures: colortex = textures.get("color", None) depthtex = textures.get("depth", None) auxtex = textures.get("aux", None) auxtex0 = textures.get("aux0", auxtex) auxtex1 = textures.get("aux1", None) else: auxtex0 = auxtex auxtex1 = None if colortex is None: colortex = Texture("filter-base-color") colortex.setWrapU(Texture.WMClamp) colortex.setWrapV(Texture.WMClamp) texgroup = (depthtex, colortex, auxtex0, auxtex1) # Choose the size of the offscreen buffer. (winx, winy) = self.getScaledSize(1, 1, 1) if fbprops is not None: buffer = self.createBuffer("filter-base", winx, winy, texgroup, fbprops=fbprops) else: buffer = self.createBuffer("filter-base", winx, winy, texgroup) if buffer is None: return None cm = CardMaker("filter-base-quad") cm.setFrameFullscreenQuad() quad = NodePath(cm.generate()) quad.setDepthTest(0) quad.setDepthWrite(0) quad.setTexture(colortex) quad.setColor(1, 0.5, 0.5, 1) cs = NodePath("dummy") cs.setState(self.camstate) # Do we really need to turn on the Shader Generator? #cs.setShaderAuto() if auxbits: cs.setAttrib(AuxBitplaneAttrib.make(auxbits)) if clamping is False: # Disables clamping in the shader generator. cs.setAttrib(LightRampAttrib.make_identity()) self.camera.node().setInitialState(cs.getState()) quadcamnode = Camera("filter-quad-cam") lens = OrthographicLens() lens.setFilmSize(2, 2) lens.setFilmOffset(0, 0) lens.setNearFar(-1000, 1000) quadcamnode.setLens(lens) quadcam = quad.attachNewNode(quadcamnode) self.region.setCamera(quadcam) self.setStackedClears(buffer, self.rclears, self.wclears) if auxtex0: buffer.setClearActive(GraphicsOutput.RTPAuxRgba0, 1) buffer.setClearValue(GraphicsOutput.RTPAuxRgba0, (0.5, 0.5, 1.0, 0.0)) if auxtex1: buffer.setClearActive(GraphicsOutput.RTPAuxRgba1, 1) self.region.disableClears() if self.isFullscreen(): self.win.disableClears() dr = buffer.makeDisplayRegion() dr.disableClears() dr.setCamera(self.camera) dr.setActive(1) self.buffers.append(buffer) self.sizes.append((1, 1, 1)) return quad
def __init__(self): # Initialize the ShowBase class from which we inherit, which will # create a window and set up everything we need for rendering into it. ShowBase.__init__(self) self.disableMouse() self.cam.node().getLens().setNear(10.0) self.cam.node().getLens().setFar(200.0) camera.setPos(0, -50, 0) # Check video card capabilities. if not self.win.getGsg().getSupportsBasicShaders(): addTitle("Toon Shader: Video driver reports that Cg shaders are not supported.") return # Enable a 'light ramp' - this discretizes the lighting, # which is half of what makes a model look like a cartoon. # Light ramps only work if shader generation is enabled, # so we call 'setShaderAuto'. tempnode = NodePath(PandaNode("temp node")) tempnode.setAttrib(LightRampAttrib.makeSingleThreshold(0.5, 0.4)) tempnode.setShaderAuto() self.cam.node().setInitialState(tempnode.getState()) # Use class 'CommonFilters' to enable a cartoon inking filter. # This can fail if the video card is not powerful enough, if so, # display an error and exit. self.separation = 1 # Pixels self.filters = CommonFilters(self.win, self.cam) filterok = self.filters.setCartoonInk(separation=self.separation) if (filterok == False): addTitle( "Toon Shader: Video card not powerful enough to do image postprocessing") return # Show instructions in the corner of the window. self.title = addTitle( "Panda3D: Tutorial - Toon Shading with Normals-Based Inking") self.inst1 = addInstructions(0.06, "ESC: Quit") self.inst2 = addInstructions(0.12, "Up/Down: Increase/Decrease Line Thickness") self.inst3 = addInstructions(0.18, "V: View the render-to-texture results") # Load a dragon model and animate it. self.character = Actor() self.character.loadModel('models/nik-dragon') self.character.reparentTo(render) self.character.loadAnims({'win': 'models/nik-dragon'}) self.character.loop('win') self.character.hprInterval(15, (360, 0, 0)).loop() # Create a non-attenuating point light and an ambient light. plightnode = PointLight("point light") plightnode.setAttenuation((1, 0, 0)) plight = render.attachNewNode(plightnode) plight.setPos(30, -50, 0) alightnode = AmbientLight("ambient light") alightnode.setColor((0.8, 0.8, 0.8, 1)) alight = render.attachNewNode(alightnode) render.setLight(alight) render.setLight(plight) # Panda contains a built-in viewer that lets you view the # results of all render-to-texture operations. This lets you # see what class CommonFilters is doing behind the scenes. self.accept("v", self.bufferViewer.toggleEnable) self.accept("V", self.bufferViewer.toggleEnable) self.bufferViewer.setPosition("llcorner") self.accept("s", self.filters.manager.resizeBuffers) # These allow you to change cartooning parameters in realtime self.accept("escape", sys.exit, [0]) self.accept("arrow_up", self.increaseSeparation) self.accept("arrow_down", self.decreaseSeparation)
def __init__(self): ShowBase.__init__(self) self.disableMouse() self.camLens.setNear(0.01) self.camLens.setFar(100) self.camLens.setFov(config.camera_angle) self.setBackgroundColor(Vec4(0, 0, 0, 0)) self.setFrameRateMeter(True) self.level = load_level(config.start_level) self.dir = Direction() self.pos = Vector([0, 0]) level_node = render_level(self.level) level_node.reparentTo(self.render) self.accept("escape", exit) self.accept("arrow_up", self.forward) self.accept("arrow_down", self.reverse) self.accept("arrow_down", self.backwards) self.accept("arrow_left", self.turn_left) self.accept("arrow_right", self.turn_right) self.accept("1", self.set_camera_in) self.accept("2", self.set_camera_out) self.accept("3", self.spin_camera_left) self.accept("4", self.spin_camera_right) self.accept("s", self.toggle_smoke) title = OnscreenText(text="Bard's Tale I", style=1, fg=(1,1,1,1), pos=(0.7,0.92), scale = .07) slight = PointLight('slight') slight.setColor(Vec4(1, 1, 1, 1)) slnp = render.attachNewNode(slight) #slight.setAttenuation((1, 0, 0.02)) render.setLight(slnp) self.slight = slight self.light = slnp alight = AmbientLight('alight') amb = 0.05 alight.setColor((amb, amb, amb, 1)) alnp = render.attachNewNode(alight) self.alight = alight render.setLight(alnp) text = TextNode("foo") text.setText("") text.setShadow(0.2,0.2) text.setShadowColor(0, 0, 0, 1) tn = NodePath(text) tn.setScale(0.1) tn.reparentTo(aspect2d) tn.setPos(-1, -1, 0) self.text = text print self.eventMgr from panda3d.core import AntialiasAttrib self.render.setAntialias(AntialiasAttrib.MMultisample) self.follow = True self.set_camera() render.setAttrib(LightRampAttrib.makeIdentity()) render.setShaderAuto()
def __set_toon(): tempnode = NodePath(PandaNode('temp node')) tempnode.setAttrib(LightRampAttrib.make_single_threshold(.5, .4)) tempnode.set_shader_auto() base.cam.node().set_initial_state(tempnode.get_state()) CommonFilters(base.win, base.cam).set_cartoon_ink(separation=1)
def __init__(self): # Set up the window, camera, etc. ShowBase.__init__(self) base.render.setAttrib(LightRampAttrib.makeHdr0()) # Configure depth pre-pass prepass_pass = lionrender.DepthScenePass() # Configure scene pass scene_fb_props = FrameBufferProperties() scene_fb_props.set_rgb_color(True) scene_fb_props.set_rgba_bits(8, 8, 8, 0) scene_fb_props.set_depth_bits(32) scene_pass = lionrender.ScenePass( frame_buffer_properties=scene_fb_props, clear_color=LColor(0.53, 0.80, 0.92, 1), share_depth_with=prepass_pass) scene_pass.node_path.set_depth_write(False) # Configure post processing filter_pass = lionrender.FilterPass(fragment_path='shaders/fsq.frag') filter_pass.node_path.set_shader_input('inputTexture', scene_pass.output) # Enable FXAA fxaa_pass = lionrender.FxaaFilterPass() fxaa_pass.node_path.set_shader_input('inputTexture', filter_pass.output) # Output result fxaa_pass.output_to(render2d) # This is used to store which keys are currently pressed. self.keyMap = { "left": 0, "right": 0, "forward": 0, "backward": 0, "cam-left": 0, "cam-right": 0, } # Post the instructions self.title = addTitle( "Panda3D Tutorial: Roaming Ralph (Walking on Uneven Terrain)") self.inst1 = addInstructions(0.06, "[ESC]: Quit") self.inst2 = addInstructions(0.12, "[Left Arrow]: Rotate Ralph Left") self.inst3 = addInstructions(0.18, "[Right Arrow]: Rotate Ralph Right") self.inst4 = addInstructions(0.24, "[Up Arrow]: Run Ralph Forward") self.inst5 = addInstructions(0.30, "[Down Arrow]: Walk Ralph Backward") self.inst6 = addInstructions(0.36, "[A]: Rotate Camera Left") self.inst7 = addInstructions(0.42, "[S]: Rotate Camera Right") # 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) # We do not have a skybox, so we will just use a sky blue background color self.setBackgroundColor(0.53, 0.80, 0.92, 1) # Create the main character, Ralph ralphStartPos = self.environ.find("**/start_point").getPos() self.ralph = Actor("models/ralph", { "run": "models/ralph-run", "walk": "models/ralph-walk" }) self.ralph.reparentTo(render) self.ralph.setScale(.2) self.ralph.setPos(ralphStartPos + (0, 0, 1.5)) # Create a floater object, which floats 2 units above ralph. We # use this as a target for the camera to look at. self.floater = NodePath(PandaNode("floater")) self.floater.reparentTo(self.ralph) self.floater.setZ(2.0) # Accept the control keys for movement and rotation self.accept("escape", sys.exit) self.accept("arrow_left", self.setKey, ["left", True]) self.accept("arrow_right", self.setKey, ["right", True]) self.accept("arrow_up", self.setKey, ["forward", True]) self.accept("arrow_down", self.setKey, ["backward", True]) self.accept("a", self.setKey, ["cam-left", True]) self.accept("s", self.setKey, ["cam-right", True]) self.accept("arrow_left-up", self.setKey, ["left", False]) self.accept("arrow_right-up", self.setKey, ["right", False]) self.accept("arrow_up-up", self.setKey, ["forward", False]) self.accept("arrow_down-up", self.setKey, ["backward", False]) self.accept("a-up", self.setKey, ["cam-left", False]) self.accept("s-up", self.setKey, ["cam-right", False]) self.accept("v", self.toggleCards) taskMgr.add(self.move, "moveTask") # Set up the camera self.disableMouse() self.camera.setPos(self.ralph.getX(), self.ralph.getY() + 10, 2) self.cTrav = CollisionTraverser() # Use a CollisionHandlerPusher to handle collisions between Ralph and # the environment. Ralph is added as a "from" object which will be # "pushed" out of the environment if he walks into obstacles. # # Ralph is composed of two spheres, one around the torso and one # around the head. They are slightly oversized since we want Ralph to # keep some distance from obstacles. self.ralphCol = CollisionNode('ralph') self.ralphCol.addSolid(CollisionSphere(center=(0, 0, 2), radius=1.5)) self.ralphCol.addSolid( CollisionSphere(center=(0, -0.25, 4), radius=1.5)) self.ralphCol.setFromCollideMask(CollideMask.bit(0)) self.ralphCol.setIntoCollideMask(CollideMask.allOff()) self.ralphColNp = self.ralph.attachNewNode(self.ralphCol) self.ralphPusher = CollisionHandlerPusher() self.ralphPusher.horizontal = True # Note that we need to add ralph both to the pusher and to the # traverser; the pusher needs to know which node to push back when a # collision occurs! self.ralphPusher.addCollider(self.ralphColNp, self.ralph) self.cTrav.addCollider(self.ralphColNp, self.ralphPusher) # We will detect the height of the terrain by creating a collision # ray and casting it downward toward the terrain. One ray will # start above ralph's head, and the other will start above the camera. # A ray may hit the terrain, or it may hit a rock or a tree. If it # hits the terrain, we can detect the height. self.ralphGroundRay = CollisionRay() self.ralphGroundRay.setOrigin(0, 0, 9) self.ralphGroundRay.setDirection(0, 0, -1) self.ralphGroundCol = CollisionNode('ralphRay') self.ralphGroundCol.addSolid(self.ralphGroundRay) self.ralphGroundCol.setFromCollideMask(CollideMask.bit(0)) self.ralphGroundCol.setIntoCollideMask(CollideMask.allOff()) self.ralphGroundColNp = self.ralph.attachNewNode(self.ralphGroundCol) self.ralphGroundHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.ralphGroundColNp, self.ralphGroundHandler) self.camGroundRay = CollisionRay() self.camGroundRay.setOrigin(0, 0, 9) self.camGroundRay.setDirection(0, 0, -1) self.camGroundCol = CollisionNode('camRay') self.camGroundCol.addSolid(self.camGroundRay) self.camGroundCol.setFromCollideMask(CollideMask.bit(0)) self.camGroundCol.setIntoCollideMask(CollideMask.allOff()) self.camGroundColNp = self.camera.attachNewNode(self.camGroundCol) self.camGroundHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler) # Uncomment this line to see the collision rays #self.ralphColNp.show() #self.camGroundColNp.show() # Uncomment this line to show a visual representation of the # collisions occuring #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)) # Clean up texture attributes for texture in self.render.find_all_textures(): texture.set_format(Texture.F_srgb)
def __init__(self): # Initialize the ShowBase class from which we inherit, which will # create a window and set up everything we need for rendering into it. ShowBase.__init__(self) self.disableMouse() self.cam.node().getLens().setNear(10.0) self.cam.node().getLens().setFar(200.0) camera.setPos(0, -50, 0) # Check video card capabilities. if not self.win.getGsg().getSupportsBasicShaders(): addTitle( "Toon Shader: Video driver reports that Cg shaders are not supported." ) return # Enable a 'light ramp' - this discretizes the lighting, # which is half of what makes a model look like a cartoon. # Light ramps only work if shader generation is enabled, # so we call 'setShaderAuto'. tempnode = NodePath(PandaNode("temp node")) tempnode.setAttrib(LightRampAttrib.makeSingleThreshold(0.5, 0.4)) tempnode.setShaderAuto() self.cam.node().setInitialState(tempnode.getState()) # Use class 'CommonFilters' to enable a cartoon inking filter. # This can fail if the video card is not powerful enough, if so, # display an error and exit. self.separation = 1 # Pixels self.filters = CommonFilters(self.win, self.cam) filterok = self.filters.setCartoonInk(separation=self.separation) if (filterok == False): addTitle( "Toon Shader: Video card not powerful enough to do image postprocessing" ) return # Show instructions in the corner of the window. self.title = addTitle( "Panda3D: Tutorial - Toon Shading with Normals-Based Inking") self.inst1 = addInstructions(0.06, "ESC: Quit") self.inst2 = addInstructions( 0.12, "Up/Down: Increase/Decrease Line Thickness") self.inst3 = addInstructions(0.18, "V: View the render-to-texture results") # Load a dragon model and animate it. self.character = Actor() self.character.loadModel('models/nik-dragon') self.character.reparentTo(render) self.character.loadAnims({'win': 'models/nik-dragon'}) self.character.loop('win') self.character.hprInterval(15, (360, 0, 0)).loop() # Create a non-attenuating point light and an ambient light. plightnode = PointLight("point light") plightnode.setAttenuation((1, 0, 0)) plight = render.attachNewNode(plightnode) plight.setPos(30, -50, 0) alightnode = AmbientLight("ambient light") alightnode.setColor((0.8, 0.8, 0.8, 1)) alight = render.attachNewNode(alightnode) render.setLight(alight) render.setLight(plight) # Panda contains a built-in viewer that lets you view the # results of all render-to-texture operations. This lets you # see what class CommonFilters is doing behind the scenes. self.accept("v", self.bufferViewer.toggleEnable) self.accept("V", self.bufferViewer.toggleEnable) self.bufferViewer.setPosition("llcorner") self.accept("s", self.filters.manager.resizeBuffers) # These allow you to change cartooning parameters in realtime self.accept("escape", sys.exit, [0]) self.accept("arrow_up", self.increaseSeparation) self.accept("arrow_down", self.decreaseSeparation)
def __init__(self, *args, **kwargs): ShowBase.__init__(self, *args, **kwargs) from panda3d.core import RenderAttribRegistry from panda3d.core import ShaderAttrib, TransparencyAttrib from panda3d.bsp import BSPMaterialAttrib attribRegistry = RenderAttribRegistry.getGlobalPtr() attribRegistry.setSlotSort(BSPMaterialAttrib.getClassSlot(), 0) attribRegistry.setSlotSort(ShaderAttrib.getClassSlot(), 1) attribRegistry.setSlotSort(TransparencyAttrib.getClassSlot(), 2) gsg = self.win.getGsg() # Let's print out the Graphics information. self.notify.info( 'Graphics Information:\n\tVendor: {0}\n\tRenderer: {1}\n' '\tVersion: {2}\n\tSupports Cube Maps: {3}\n' '\tSupports 3D Textures: {4}\n\tSupports Compute Shaders: {5}'. format(gsg.getDriverVendor(), gsg.getDriverRenderer(), gsg.getDriverVersion(), str(gsg.getSupportsCubeMap()), str(gsg.getSupports3dTexture()), str(gsg.getSupportsComputeShaders()))) # Enable shader generation on all of the main scenes if gsg.getSupportsBasicShaders() and gsg.getSupportsGlsl(): self.render.setShaderAuto() self.render2d.setShaderAuto() self.render2dp.setShaderAuto() self.aspect2d.setShaderAuto() self.pixel2d.setShaderAuto() else: # I don't know how this could be possible self.notify.error("GLSL shaders unsupported by graphics driver.") return self.camNode.setCameraMask(CAMERA_MAIN) # Any ComputeNodes should be parented to this node, not render. # We isolate ComputeNodes to avoid traversing the same ComputeNodes # when doing multi-pass rendering. self.computeRoot = NodePath('computeRoot') self.computeCam = self.makeCamera(self.win) self.computeCam.node().setCameraMask(CAMERA_COMPUTE) self.computeCam.node().setCullBounds(OmniBoundingVolume()) self.computeCam.node().setFinal(True) self.computeCam.reparentTo(self.computeRoot) self.bspLoader = None self.bspLevel = None self.brushCollisionMaterialData = {} self.createBSPLoader() self.audio3d = None self.create3DAudio() # Initialized in createShaderGenerator() self.shaderGenerator = None # Initialized in createPostProcess() self.filters = None self.render.show(CAMERA_SHADOW) self.render.setAttrib(LightRampAttrib.makeIdentity())
def __init__(self): #basic init start base.disableMouse() self.wp = WindowProperties() self.wp.setCursorHidden(True) base.win.requestProperties(self.wp) cm = CardMaker("cursor") cm.setFrame(0, 0.1, -0.13, 0) self.cust_mouse = render.attachNewNode(cm.generate()) self.cust_mouse_tex = [] self.cust_mouse_tex.append( loader.loadTexture("models/cursors/blank_cursor.png")) self.cust_mouse_tex.append( loader.loadTexture("models/cursors/main_cursor.png")) self.cust_mouse.setTexture(self.cust_mouse_tex[0]) self.cust_mouse.setTransparency(TransparencyAttrib.MAlpha) self.cust_mouse.reparentTo(render2d) self.cust_mouse.setBin("gui-popup", 100) base.mouseWatcherNode.setGeometry(self.cust_mouse.node()) #text and background textVersion = OnscreenText(text="v0.0", font=arcFont, pos=(1.15, -0.95), fg=(0, 0, 0, 1), bg=(1, 1, 1, 0.8)) base.setBackgroundColor(1, 1, 1) self.curdir = (appRunner.p3dFilename.getDirname() if appRunner else "..") self.main_config = json.loads("".join([ line.rstrip().lstrip() for line in file(self.curdir + "/config.json", "rb") ])) #arrows (GENERAL) self.arrow = loader.loadModel("models/static/arrow") self.lst_arrows = [] self.c_arr = CardMaker("arrow_hide") self.c_arr.setFrame(-1, 1, -0.8, 0.6) #light ramp self.rampnode = NodePath(PandaNode("temp node")) self.rampnode.setAttrib(LightRampAttrib.makeSingleThreshold(0.1, 0.7)) self.rampnode.setShaderAuto() base.cam.node().setInitialState(self.rampnode.getState()) #ink filter self.filters = CommonFilters(base.win, base.cam) self.filterok = self.filters.setCartoonInk(separation=1) #keyboard inputs self.accept("escape", sys.exit, [0]) #lights self.lst_lghts = [] #ambient light (permanent) self.alghtnode = AmbientLight("amb light") self.alghtnode.setColor(Vec4(0.4, 0.4, 0.4, 1)) self.alght = render.attachNewNode(self.alghtnode) render.setLight(self.alght) #language recup self.langtab = self.main_config["lang"][self.main_config["lang_chx"]] self.lang = json.loads("".join([ line.rstrip().lstrip() for line in file("misc/lang/" + self.langtab[0] + ".json", "rb") ])) #common gui elements self.voile = [] self.voile.append( DirectFrame(frameSize=(-2, 2, -2, 2), frameColor=(0, 0, 0, 0.8))) self.voile[0].setBin("gui-popup", 1) self.voile[0].hide() self.voile.append(arcLabel("", (0, 0, 0.3), txtalgn=TextNode.ACenter)) self.voile[1].setBin("gui-popup", 1) self.voile[1].reparentTo(self.voile[0]) self.voile.append(arcLabel("", (0, 0, 0.17), txtalgn=TextNode.ACenter)) self.voile[2].setBin("gui-popup", 1) self.voile[2].reparentTo(self.voile[0]) self.voile.append( arcButton(self.lang["main_dialog"]["valid"], (-0.2, 0, 0), None, txtalgn=TextNode.ACenter)) self.voile[3].setBin("gui-popup", 1) self.voile[3].reparentTo(self.voile[0]) self.voile.append( arcButton(self.lang["main_dialog"]["cancel"], (0.2, 0, 0), None, txtalgn=TextNode.ACenter)) self.voile[4].setBin("gui-popup", 1) self.voile[4].reparentTo(self.voile[0]) #mouse handler self.mouse_trav = CollisionTraverser() self.mouse_hand = CollisionHandlerQueue() self.pickerNode = CollisionNode('mouseRay') self.pickerNP = camera.attachNewNode(self.pickerNode) self.pickerNode.setFromCollideMask(BitMask32.bit(1)) self.pickerRay = CollisionRay() self.pickerNode.addSolid(self.pickerRay) self.mouse_trav.addCollider(self.pickerNP, self.mouse_hand) self.pickly_node = render.attachNewNode("pickly_node") #init main scene self.scene = mainScene(self)
def __init__(self): self.controlMap = {"left":0, "right":0, "forward":0, "backward":0, "zoom-in":0, "zoom-out":0, "wheel-in":0, "wheel-out":0} self.mousebtn = [0,0,0] base.win.setClearColor(Vec4(0,0,0,1)) # Post the instructions self.title = addTitle("Panda3D Tutorial: Better Ralph (Walking on Uneven Terrain)") self.inst1 = addInstructions(0.95, "[ESC]: Quit") self.inst2 = addInstructions(0.90, "W A S D keys move Ralph forward, left, back, and right, respectively.") self.inst3 = addInstructions(0.85, "Use the mouse to look around and steer Ralph.") self.inst4 = addInstructions(0.80, "Zoom in and out using the mouse wheel, or page up and page down keys.") # 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) self.environ.setPos(0,0,0) # Create the main character, Ralph ralphStartPos = self.environ.find("**/start_point").getPos() self.ralph = Actor("models/ralph", {"run":"models/ralph-run", "walk":"models/ralph-walk"}) self.ralph.reparentTo(render) self.ralph.setScale(.2) self.ralph.setPos(ralphStartPos) # Accept the control keys for movement and rotation self.accept("escape", sys.exit) self.accept("w", self.setControl, ["forward",1]) self.accept("a", self.setControl, ["left",1]) self.accept("s", self.setControl, ["backward",1]) self.accept("d", self.setControl, ["right",1]) self.accept("w-up", self.setControl, ["forward",0]) self.accept("a-up", self.setControl, ["left",0]) self.accept("s-up", self.setControl, ["backward",0]) self.accept("d-up", self.setControl, ["right",0]) # self.accept("mouse1", self.setControl, ["zoom-in", 1]) # self.accept("mouse1-up", self.setControl, ["zoom-in", 0]) # self.accept("mouse3", self.setControl, ["zoom-out", 1]) # self.accept("mouse3-up", self.setControl, ["zoom-out", 0]) self.accept("wheel_up", self.setControl, ["wheel-in", 1]) self.accept("wheel_down", self.setControl, ["wheel-out", 1]) self.accept("page_up", self.setControl, ["zoom-in", 1]) self.accept("page_up-up", self.setControl, ["zoom-in", 0]) self.accept("page_down", self.setControl, ["zoom-out", 1]) self.accept("page_down-up", self.setControl, ["zoom-out", 0]) taskMgr.add(self.move,"moveTask") # Game state variables self.isMoving = False # Set up the camera # Adding the camera to Ralph is a simple way to keep the camera locked # in behind Ralph regardless of ralph's movement. base.camera.reparentTo(self.ralph) # We don't actually want to point the camera at Ralph's feet. # This value will serve as a vertical offset so we can look over Ralph self.cameraTargetHeight = 6.0 # How far should the camera be from Ralph self.cameraDistance = 30 # Initialize the pitch of the camera self.cameraPitch = 10 # This just disables the built in camera controls; we're using our own. base.disableMouse() # The mouse moves rotates the camera so lets get rid of the cursor props = WindowProperties() props.setCursorHidden(True) base.win.requestProperties(props) # We will detect the height of the terrain by creating a collision # ray and casting it downward toward the terrain. One ray will # start above ralph's head. # A ray may hit the terrain, or it may hit a rock or a tree. If it # hits the terrain, we can detect the height. If it hits anything # else, we rule that the move is illegal. self.cTrav = CollisionTraverser() self.ralphGroundRay = CollisionRay() self.ralphGroundRay.setOrigin(0,0,1000) self.ralphGroundRay.setDirection(0,0,-1) self.ralphGroundCol = CollisionNode('ralphRay') self.ralphGroundCol.addSolid(self.ralphGroundRay) self.ralphGroundCol.setFromCollideMask(BitMask32.bit(0)) self.ralphGroundCol.setIntoCollideMask(BitMask32.allOff()) self.ralphGroundColNp = self.ralph.attachNewNode(self.ralphGroundCol) self.ralphGroundHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.ralphGroundColNp, self.ralphGroundHandler) # We will detect anything obstructing the camera's view of the player self.cameraRay = CollisionSegment((0,0,self.cameraTargetHeight),(0,5,5)) self.cameraCol = CollisionNode('cameraRay') self.cameraCol.addSolid(self.cameraRay) self.cameraCol.setFromCollideMask(BitMask32.bit(0)) self.cameraCol.setIntoCollideMask(BitMask32.allOff()) self.cameraColNp = self.ralph.attachNewNode(self.cameraCol) self.cameraColHandler = CollisionHandlerQueue() self.cTrav.addCollider(self.cameraColNp, self.cameraColHandler) ############## CollisionTube doesn't seem to be working # self.cameraRay = CollisionTube( (0,0,self.cameraTargetHeight), # (0,25,25), # (self.cameraTargetHeight/2)) # self.cameraCol = CollisionNode('cameraRay') # self.cameraCol.addSolid(self.cameraRay) # self.cameraCol.setFromCollideMask(BitMask32.bit(0)) # self.cameraCol.setIntoCollideMask(BitMask32.allOff()) # self.cameraColNp = self.ralph.attachNewNode(self.cameraCol) # self.cameraColHandler = CollisionHandlerQueue() # self.cTrav.addCollider(self.cameraColNp, self.cameraColHandler) ############ # Uncomment this line to see the collision rays #self.ralphGroundColNp.show() #self.camGroundColNp.show() #self.cameraColNp.show() # Uncomment this line to show a visual representation of the # collisions occuring #self.cTrav.showCollisions(render) # Create some lighting # lets add hdr lighting for fun render.setShaderAuto() render.setAttrib(LightRampAttrib.makeHdr1()) ambientLight = AmbientLight("ambientLight") # existing lighting is effectively darkened so boost ambient a bit ambientLight.setColor(Vec4(.4, .4, .4, 1)) directionalLight = DirectionalLight("directionalLight") directionalLight.setDirection(Vec3(-5, -5, -5)) # hdr can handle any amount of lighting # lets make things nice and sunny directionalLight.setColor(Vec4(2.0, 2.0, 2.0, 1.0)) directionalLight.setSpecularColor(Vec4(2.0, 2.0, 2.0, 1)) render.setLight(render.attachNewNode(ambientLight)) render.setLight(render.attachNewNode(directionalLight))
def __init__(self): self.keyMap = {"left":0, "right":0, "forward":0, "backward":0} self.angles = {"left":-90, "right":90, "forward":0, "backward":180} self.title = addTitle("Moving like nowaday's action game") # load the scene base.setBackgroundColor(0,0,0.2,1) floorTex = loader.loadTexture("maps/envir-ground.jpg") cm = CardMaker("") cm.setFrame(-2,2,-2,2) floor = render.attachNewNode(PandaNode("floor")) for y in range(12): for x in range(12): nn = floor.attachNewNode(cm.generate()) nn.setP(-90) nn.setPos((x-6)*4, (y-6)*4, 0) floor.setTexture(floorTex) floor.flattenStrong() # create main character self.eve = Actor("models/eve", {"run":"models/eve_run", "walk":"models/eve_walk"}) self.eve.reparentTo(render) self.eve.setScale(.4) self.eve.setPos(0, 0, 0) # accept the control keys for movement and rotation self.accept("escape", sys.exit) self.accept("a", self.setKey, ["left",1]) self.accept("d", self.setKey, ["right",1]) self.accept("w", self.setKey, ["forward",1]) self.accept("s", self.setKey, ["backward",1]) self.accept("a-up", self.setKey, ["left",0]) self.accept("d-up", self.setKey, ["right",0]) self.accept("w-up", self.setKey, ["forward",0]) self.accept("s-up", self.setKey, ["backward",0]) self.pre_move = "forward" taskMgr.add(self.move, "moveTask") # game start variable self.isMoving = False # set up the camera base.camera.reparentTo(self.eve) #look over eve self.cameraTargetHeight = 6.0 self.cameraDistance = 30 self.cameraPitch = 10 # disable the default camera control by mouse base.disableMouse() # hide mouse props = WindowProperties() props.setCursorHidden(True) base.win.requestProperties(props) # create some lighting render.setShaderAuto() render.setAttrib(LightRampAttrib.makeHdr1()) ambientLight = AmbientLight("ambientLight") ambientLight.setColor(Vec4(.4, .4, .3, 1)) directionalLight = DirectionalLight("directionalLight") directionalLight.setDirection(Vec3(0, 8, -2.5)) directionalLight.setColor(Vec4(2.0, 2.0, 2.0, 1)) directionalLight.setSpecularColor(Vec4(2.0, 2.0, 2.0, 1)) render.setLight(render.attachNewNode(ambientLight)) render.setLight(render.attachNewNode(directionalLight))
def renderSceneInto(self, depthtex=None, colortex=None, auxtex=None, auxbits=0, textures=None, fbprops=None, clamping=None): """ overload direct.filters.FilterManager.renderSceneInto :param depthtex: :param colortex: :param auxtex: :param auxbits: :param textures: :param fbprops: :param clamping: :return: """ if (textures): colortex = textures.get("color", None) depthtex = textures.get("depth", None) auxtex = textures.get("aux", None) auxtex0 = textures.get("aux0", auxtex) auxtex1 = textures.get("aux1", None) else: auxtex0 = auxtex auxtex1 = None if (colortex == None): colortex = Texture("filter-base-color") colortex.setWrapU(Texture.WMClamp) colortex.setWrapV(Texture.WMClamp) texgroup = (depthtex, colortex, auxtex0, auxtex1) # Choose the size of the offscreen buffer. (winx, winy) = self.getScaledSize(1, 1, 1) if fbprops is not None: buffer = self.createBuffer("filter-base", winx, winy, texgroup, fbprops=fbprops) else: buffer = self.createBuffer("filter-base", winx, winy, texgroup) if (buffer == None): return None cm = CardMaker("filter-base-quad") cm.setFrameFullscreenQuad() quad = NodePath(cm.generate()) quad.setDepthTest(0) quad.setDepthWrite(0) quad.setTexture(colortex) quad.setColor(1, 0.5, 0.5, 1) cs = NodePath("dummy") cs.setState(self.camstate) # Do we really need to turn on the Shader Generator? # cs.setShaderAuto() if (auxbits): cs.setAttrib(AuxBitplaneAttrib.make(auxbits)) if clamping is False: # Disables clamping in the shader generator. cs.setAttrib(LightRampAttrib.make_identity()) self.camera.node().setInitialState(cs.getState()) quadcamnode = Camera("filter-quad-cam") lens = OrthographicLens() lens.setFilmSize(2, 2) lens.setFilmOffset(0, 0) lens.setNearFar(-1000, 1000) quadcamnode.setLens(lens) quadcam = quad.attachNewNode(quadcamnode) self.region.setCamera(quadcam) self.setStackedClears(buffer, self.rclears, self.wclears) if (auxtex0): buffer.setClearActive(GraphicsOutput.RTPAuxRgba0, 1) buffer.setClearValue(GraphicsOutput.RTPAuxRgba0, (0.5, 0.5, 1.0, 0.0)) if (auxtex1): buffer.setClearActive(GraphicsOutput.RTPAuxRgba1, 1) self.region.disableClears() if (self.isFullscreen()): self.win.disableClears() dr = buffer.makeDisplayRegion() dr.disableClears() dr.setCamera(self.camera) dr.setActive(1) self.buffers.append(buffer) self.sizes.append((1, 1, 1)) return quad