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 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):
# 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)
