def __init__(self):
# Preliminary capabilities check.
if (base.win.getGsg().getSupportsBasicShaders()==0):
self.t=addTitle("Firefly Demo: Video driver reports that shaders are not supported.")
return
if (base.win.getGsg().getSupportsDepthTexture()==0):
self.t=addTitle("Firefly Demo: Video driver reports that depth textures are not supported.")
return
# This algorithm uses two offscreen buffers, one of which has
# an auxiliary bitplane, and the offscreen buffers share a single
# depth buffer. This is a heck of a complicated buffer setup.
self.modelbuffer = self.makeFBO("model buffer",1)
self.lightbuffer = self.makeFBO("light buffer",0)
# Creation of a high-powered buffer can fail, if the graphics card
# doesn't support the necessary OpenGL extensions.
if (self.modelbuffer == None) or (self.lightbuffer == None):
self.t=addTitle("Toon Shader: Video driver does not support multiple render targets")
return
# Create four render textures: depth, normal, albedo, and final.
# attach them to the various bitplanes of the offscreen buffers.
self.texDepth = Texture()
self.texDepth.setFormat(Texture.FDepthStencil)
self.texAlbedo = Texture()
self.texNormal = Texture()
self.texFinal = Texture()
self.modelbuffer.addRenderTexture(self.texDepth, GraphicsOutput.RTMBindOrCopy, GraphicsOutput.RTPDepthStencil)
self.modelbuffer.addRenderTexture(self.texAlbedo, GraphicsOutput.RTMBindOrCopy, GraphicsOutput.RTPColor)
self.modelbuffer.addRenderTexture(self.texNormal, GraphicsOutput.RTMBindOrCopy, GraphicsOutput.RTPAuxRgba0)
self.lightbuffer.addRenderTexture(self.texFinal, GraphicsOutput.RTMBindOrCopy, GraphicsOutput.RTPColor)
# Set the near and far clipping planes.
base.cam.node().getLens().setNear(50.0)
base.cam.node().getLens().setFar(500.0)
lens = base.cam.node().getLens()
# This algorithm uses three cameras: one to render the models into the
# model buffer, one to render the lights into the light buffer, and
# one to render "plain" stuff (non-deferred shaded) stuff into the light
# buffer. Each camera has a bitmask to identify it.
self.modelMask = 1
self.lightMask = 2
self.plainMask = 4
self.modelcam=base.makeCamera(self.modelbuffer, lens=lens, scene=render, mask=self.modelMask)
self.lightcam=base.makeCamera(self.lightbuffer, lens=lens, scene=render, mask=self.lightMask)
self.plaincam=base.makeCamera(self.lightbuffer, lens=lens, scene=render, mask=self.plainMask)
# Panda's main camera is not used.
base.cam.node().setActive(0)
# Take explicit control over the order in which the three
# buffers are rendered.
self.modelbuffer.setSort(1)
self.lightbuffer.setSort(2)
base.win.setSort(3)
# Within the light buffer, control the order of the two cams.
self.lightcam.node().getDisplayRegion(0).setSort(1)
self.plaincam.node().getDisplayRegion(0).setSort(2)
# By default, panda usually clears the screen before every
# camera and before every window. Tell it not to do that.
# Then, tell it specifically when to clear and what to clear.
self.modelcam.node().getDisplayRegion(0).disableClears()
self.lightcam.node().getDisplayRegion(0).disableClears()
self.plaincam.node().getDisplayRegion(0).disableClears()
base.cam.node().getDisplayRegion(0).disableClears()
base.cam2d.node().getDisplayRegion(0).disableClears()
self.modelbuffer.disableClears()
base.win.disableClears()
self.modelbuffer.setClearColorActive(1)
self.modelbuffer.setClearDepthActive(1)
self.lightbuffer.setClearColorActive(1)
self.lightbuffer.setClearColor(Vec4(0,0,0,1))
# Miscellaneous stuff.
base.disableMouse()
base.camera.setPos(-9.112,-211.077,46.951)
base.camera.setHpr(0, -7.5, 2.4)
base.setBackgroundColor(Vec4(0,0,0,0))
random.seed()
# Calculate the projection parameters for the final shader.
# The math here is too complex to explain in an inline comment,
# I've put in a full explanation into the HTML intro.
proj = base.cam.node().getLens().getProjectionMat()
proj_x = 0.5 * proj.getCell(3,2) / proj.getCell(0,0)
proj_y = 0.5 * proj.getCell(3,2)
proj_z = 0.5 * proj.getCell(3,2) / proj.getCell(2,1)
proj_w = -0.5 - 0.5*proj.getCell(1,2)
# Configure the render state of the model camera.
tempnode = NodePath(PandaNode("temp node"))
tempnode.setAttrib(AlphaTestAttrib.make(RenderAttrib.MGreaterEqual, 0.5))
tempnode.setShader(Shader.load(os.path.join(PANDA_SHADER_PATH, \
"samples/fireflies/fireflies_model.sha")))
tempnode.setAttrib(DepthTestAttrib.make(RenderAttrib.MLessEqual))
self.modelcam.node().setInitialState(tempnode.getState())
# Configure the render state of the light camera.
tempnode = NodePath(PandaNode("temp node"))
tempnode.setShader(Shader.load(os.path.join(PANDA_SHADER_PATH, \
"samples/fireflies/fireflies_lighting.sha")))
tempnode.setShaderInput("texnormal",self.texNormal)
tempnode.setShaderInput("texalbedo",self.texAlbedo)
tempnode.setShaderInput("texdepth",self.texDepth)
tempnode.setShaderInput("proj",Vec4(proj_x,proj_y,proj_z,proj_w))
tempnode.setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.MAdd, ColorBlendAttrib.OOne, ColorBlendAttrib.OOne))
tempnode.setAttrib(CullFaceAttrib.make(CullFaceAttrib.MCullCounterClockwise))
# The next line causes problems on Linux.
#tempnode.setAttrib(DepthTestAttrib.make(RenderAttrib.MGreaterEqual))
tempnode.setAttrib(DepthWriteAttrib.make(DepthWriteAttrib.MOff))
self.lightcam.node().setInitialState(tempnode.getState())
# Configure the render state of the plain camera.
rs = RenderState.makeEmpty()
self.plaincam.node().setInitialState(rs)
# Clear any render attribs on the root node. This is necessary
# because by default, panda assigns some attribs to the root
# node. These default attribs will override the
# carefully-configured render attribs that we just attached
# to the cameras. The simplest solution is to just clear
# them all out.
render.setState(RenderState.makeEmpty())
# My artist created a model in which some of the polygons
# don't have textures. This confuses the shader I wrote.
# This little hack guarantees that everything has a texture.
white = loader.loadTexture("models/samples/fireflies/white.jpg")
render.setTexture(white,0)
# Create two subroots, to help speed cull traversal.
self.lightroot = NodePath(PandaNode("lightroot"))
self.lightroot.reparentTo(render)
self.modelroot = NodePath(PandaNode("modelroot"))
self.modelroot.reparentTo(render)
self.lightroot.hide(BitMask32(self.modelMask))
self.modelroot.hide(BitMask32(self.lightMask))
self.modelroot.hide(BitMask32(self.plainMask))
# Load the model of a forest. Make it visible to the model camera.
self.forest=NodePath(PandaNode("Forest Root"))
self.forest.reparentTo(render)
loader.loadModel( \
"models/samples/fireflies/background").reparentTo(self.forest)
loader.loadModel( \
"models/samples/fireflies/foliage01").reparentTo(self.forest)
loader.loadModel( \
"models/samples/fireflies/foliage02").reparentTo(self.forest)
loader.loadModel( \
"models/samples/fireflies/foliage03").reparentTo(self.forest)
loader.loadModel( \
"models/samples/fireflies/foliage04").reparentTo(self.forest)
loader.loadModel( \
"models/samples/fireflies/foliage05").reparentTo(self.forest)
loader.loadModel( \
"models/samples/fireflies/foliage06").reparentTo(self.forest)
loader.loadModel( \
"models/samples/fireflies/foliage07").reparentTo(self.forest)
loader.loadModel( \
"models/samples/fireflies/foliage08").reparentTo(self.forest)
loader.loadModel( \
"models/samples/fireflies/foliage09").reparentTo(self.forest)
self.forest.hide(BitMask32(self.lightMask | self.plainMask))
# Cause the final results to be rendered into the main window on a card.
cm = CardMaker("card")
cm.setFrameFullscreenQuad()
self.card = render2d.attachNewNode(cm.generate())
self.card.setTexture(self.texFinal)
# Post the instructions.
self.title = addTitle("Panda3D: Tutorial - Fireflies using Deferred Shading")
self.inst1 = addInstructions(0.95,"ESC: Quit")
self.inst2 = addInstructions(0.90,"Up/Down: More / Fewer Fireflies (Count: unknown)")
self.inst3 = addInstructions(0.85,"Right/Left: Bigger / Smaller Fireflies (Radius: unknown)")
self.inst4 = addInstructions(0.80,"V: View the render-to-texture results")
# Panda contains a built-in viewer that lets you view the results of
# your render-to-texture operations. This code configures the viewer.
base.bufferViewer.setPosition("llcorner")
base.bufferViewer.setCardSize(0,0.40)
base.bufferViewer.setLayout("vline")
self.toggleCards()
self.toggleCards()
# Firefly parameters
self.fireflies = []
self.sequences = []
self.scaleseqs = []
self.glowspheres = []
self.fireflysize = 1.0
self.spheremodel = loader.loadModel("models/misc/sphere.flt")
self.setFireflySize(25.0)
while (len(self.fireflies)<5): self.addFirefly()
self.updateReadout()
# these allow you to change parameters in realtime
self.accept("escape", sys.exit, [0])
self.accept("arrow_up", self.incFireflyCount, [1.1111111])
self.accept("arrow_down", self.decFireflyCount, [0.9000000])
self.accept("arrow_right", self.setFireflySize, [1.1111111])
self.accept("arrow_left", self.setFireflySize, [0.9000000])
self.accept("v", self.toggleCards)
self.accept("V", self.toggleCards)
self.nextadd = 0
taskMgr.add(self.spawnTask, "spawner")
def __init__(self):
# create a texture into which we can copy the main window.
self.tex = Texture()
self.tex.setMinfilter(Texture.FTLinear)
base.win.addRenderTexture(self.tex, GraphicsOutput.RTMTriggeredCopyTexture)
# Create another 2D camera. Tell it to render before the main camera.
self.backcam = base.makeCamera2d(base.win, sort=-10)
self.background = NodePath("background")
self.backcam.reparentTo(self.background)
self.background.setDepthTest(0)
self.background.setDepthWrite(0)
self.backcam.node().getDisplayRegion(0).setClearDepthActive(0)
# Obtain two texture cards. One renders before the dragon, the other after.
self.bcard = base.win.getTextureCard()
self.bcard.reparentTo(self.background)
self.bcard.setTransparency(1)
self.fcard = base.win.getTextureCard()
self.fcard.reparentTo(render2d)
self.fcard.setTransparency(1)
# Initialize one of the nice effects.
self.chooseEffectGhost()
# Add the task that initiates the screenshots.
taskMgr.add(self.takeSnapShot, "takeSnapShot")
# Create some black squares on top of which we will
# place the instructions.
blackmaker = CardMaker("blackmaker")
blackmaker.setColor(0,0,0,1)
blackmaker.setFrame(-1.00, -0.50, 0.65, 1.00)
instcard = NodePath(blackmaker.generate())
instcard.reparentTo(render2d)
blackmaker.setFrame(-0.5, 0.5, -1.00, -0.85)
titlecard = NodePath(blackmaker.generate())
titlecard.reparentTo(render2d)
# Panda does its best to hide the differences between DirectX and
# OpenGL. But there are a few differences that it cannot hide.
# One such difference is that when OpenGL copies from a
# visible window to a texture, it gets it right-side-up. When
# DirectX does it, it gets it upside-down. There is nothing panda
# can do to compensate except to expose a flag and let the
# application programmer deal with it. You should only do this
# in the rare event that you're copying from a visible window
# to a texture.
if (base.win.getGsg().getCopyTextureInverted()):
print "Copy texture is inverted."
self.bcard.setScale(1,1,-1)
self.fcard.setScale(1,1,-1)
# Put up the instructions
title = OnscreenText(text="Panda3D: Tutorial - Motion Trails",
style=1, fg=(1,1,1,1), font = font,
pos=(0,-0.95), scale = .07)
instr0 = addInstructions(0.95, "Press ESC to exit")
instr1 = addInstructions(0.90, "Press 1: Ghost effect")
instr2 = addInstructions(0.85, "Press 2: PaintBrush effect")
instr3 = addInstructions(0.80, "Press 3: Double Vision effect")
instr4 = addInstructions(0.75, "Press 4: Wings of Blue effect")
instr5 = addInstructions(0.70, "Press 5: Whirlpool effect")
# enable the key events
self.accept("escape", sys.exit, [0])
self.accept("1", self.chooseEffectGhost)
self.accept("2", self.chooseEffectPaintBrush)
self.accept("3", self.chooseEffectDoubleVision)
self.accept("4", self.chooseEffectWingsOfBlue)
self.accept("5", self.chooseEffectWhirlpool)
class FireflyDemo(DirectObject):
def __init__(self):
# Preliminary capabilities check.
if (base.win.getGsg().getSupportsBasicShaders()==0):
self.t=addTitle("Firefly Demo: Video driver reports that shaders are not supported.")
return
if (base.win.getGsg().getSupportsDepthTexture()==0):
self.t=addTitle("Firefly Demo: Video driver reports that depth textures are not supported.")
return
# This algorithm uses two offscreen buffers, one of which has
# an auxiliary bitplane, and the offscreen buffers share a single
# depth buffer. This is a heck of a complicated buffer setup.
self.modelbuffer = self.makeFBO("model buffer",1)
self.lightbuffer = self.makeFBO("light buffer",0)
# Creation of a high-powered buffer can fail, if the graphics card
# doesn't support the necessary OpenGL extensions.
if (self.modelbuffer == None) or (self.lightbuffer == None):
self.t=addTitle("Toon Shader: Video driver does not support multiple render targets")
return
# Create four render textures: depth, normal, albedo, and final.
# attach them to the various bitplanes of the offscreen buffers.
self.texDepth = Texture()
self.texDepth.setFormat(Texture.FDepthStencil)
self.texAlbedo = Texture()
self.texNormal = Texture()
self.texFinal = Texture()
self.modelbuffer.addRenderTexture(self.texDepth, GraphicsOutput.RTMBindOrCopy, GraphicsOutput.RTPDepthStencil)
self.modelbuffer.addRenderTexture(self.texAlbedo, GraphicsOutput.RTMBindOrCopy, GraphicsOutput.RTPColor)
self.modelbuffer.addRenderTexture(self.texNormal, GraphicsOutput.RTMBindOrCopy, GraphicsOutput.RTPAuxRgba0)
self.lightbuffer.addRenderTexture(self.texFinal, GraphicsOutput.RTMBindOrCopy, GraphicsOutput.RTPColor)
# Set the near and far clipping planes.
base.cam.node().getLens().setNear(50.0)
base.cam.node().getLens().setFar(500.0)
lens = base.cam.node().getLens()
# This algorithm uses three cameras: one to render the models into the
# model buffer, one to render the lights into the light buffer, and
# one to render "plain" stuff (non-deferred shaded) stuff into the light
# buffer. Each camera has a bitmask to identify it.
self.modelMask = 1
self.lightMask = 2
self.plainMask = 4
self.modelcam=base.makeCamera(self.modelbuffer, lens=lens, scene=render, mask=self.modelMask)
self.lightcam=base.makeCamera(self.lightbuffer, lens=lens, scene=render, mask=self.lightMask)
self.plaincam=base.makeCamera(self.lightbuffer, lens=lens, scene=render, mask=self.plainMask)
# Panda's main camera is not used.
base.cam.node().setActive(0)
# Take explicit control over the order in which the three
# buffers are rendered.
self.modelbuffer.setSort(1)
self.lightbuffer.setSort(2)
base.win.setSort(3)
# Within the light buffer, control the order of the two cams.
self.lightcam.node().getDisplayRegion(0).setSort(1)
self.plaincam.node().getDisplayRegion(0).setSort(2)
# By default, panda usually clears the screen before every
# camera and before every window. Tell it not to do that.
# Then, tell it specifically when to clear and what to clear.
self.modelcam.node().getDisplayRegion(0).disableClears()
self.lightcam.node().getDisplayRegion(0).disableClears()
self.plaincam.node().getDisplayRegion(0).disableClears()
base.cam.node().getDisplayRegion(0).disableClears()
base.cam2d.node().getDisplayRegion(0).disableClears()
self.modelbuffer.disableClears()
base.win.disableClears()
self.modelbuffer.setClearColorActive(1)
self.modelbuffer.setClearDepthActive(1)
self.lightbuffer.setClearColorActive(1)
self.lightbuffer.setClearColor(Vec4(0,0,0,1))
# Miscellaneous stuff.
base.disableMouse()
base.camera.setPos(-9.112,-211.077,46.951)
base.camera.setHpr(0, -7.5, 2.4)
base.setBackgroundColor(Vec4(0,0,0,0))
random.seed()
# Calculate the projection parameters for the final shader.
# The math here is too complex to explain in an inline comment,
# I've put in a full explanation into the HTML intro.
proj = base.cam.node().getLens().getProjectionMat()
proj_x = 0.5 * proj.getCell(3,2) / proj.getCell(0,0)
proj_y = 0.5 * proj.getCell(3,2)
proj_z = 0.5 * proj.getCell(3,2) / proj.getCell(2,1)
proj_w = -0.5 - 0.5*proj.getCell(1,2)
# Configure the render state of the model camera.
tempnode = NodePath(PandaNode("temp node"))
tempnode.setAttrib(AlphaTestAttrib.make(RenderAttrib.MGreaterEqual, 0.5))
tempnode.setShader(Shader.load(os.path.join(PANDA_SHADER_PATH, \
"samples/fireflies/fireflies_model.sha")))
tempnode.setAttrib(DepthTestAttrib.make(RenderAttrib.MLessEqual))
self.modelcam.node().setInitialState(tempnode.getState())
# Configure the render state of the light camera.
tempnode = NodePath(PandaNode("temp node"))
tempnode.setShader(Shader.load(os.path.join(PANDA_SHADER_PATH, \
"samples/fireflies/fireflies_lighting.sha")))
tempnode.setShaderInput("texnormal",self.texNormal)
tempnode.setShaderInput("texalbedo",self.texAlbedo)
tempnode.setShaderInput("texdepth",self.texDepth)
tempnode.setShaderInput("proj",Vec4(proj_x,proj_y,proj_z,proj_w))
tempnode.setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.MAdd, ColorBlendAttrib.OOne, ColorBlendAttrib.OOne))
tempnode.setAttrib(CullFaceAttrib.make(CullFaceAttrib.MCullCounterClockwise))
# The next line causes problems on Linux.
#tempnode.setAttrib(DepthTestAttrib.make(RenderAttrib.MGreaterEqual))
tempnode.setAttrib(DepthWriteAttrib.make(DepthWriteAttrib.MOff))
self.lightcam.node().setInitialState(tempnode.getState())
# Configure the render state of the plain camera.
rs = RenderState.makeEmpty()
self.plaincam.node().setInitialState(rs)
# Clear any render attribs on the root node. This is necessary
# because by default, panda assigns some attribs to the root
# node. These default attribs will override the
# carefully-configured render attribs that we just attached
# to the cameras. The simplest solution is to just clear
# them all out.
render.setState(RenderState.makeEmpty())
# My artist created a model in which some of the polygons
# don't have textures. This confuses the shader I wrote.
# This little hack guarantees that everything has a texture.
white = loader.loadTexture("models/samples/fireflies/white.jpg")
render.setTexture(white,0)
# Create two subroots, to help speed cull traversal.
self.lightroot = NodePath(PandaNode("lightroot"))
self.lightroot.reparentTo(render)
self.modelroot = NodePath(PandaNode("modelroot"))
self.modelroot.reparentTo(render)
self.lightroot.hide(BitMask32(self.modelMask))
self.modelroot.hide(BitMask32(self.lightMask))
self.modelroot.hide(BitMask32(self.plainMask))
# Load the model of a forest. Make it visible to the model camera.
self.forest=NodePath(PandaNode("Forest Root"))
self.forest.reparentTo(render)
loader.loadModel( \
"models/samples/fireflies/background").reparentTo(self.forest)
loader.loadModel( \
"models/samples/fireflies/foliage01").reparentTo(self.forest)
loader.loadModel( \
"models/samples/fireflies/foliage02").reparentTo(self.forest)
loader.loadModel( \
"models/samples/fireflies/foliage03").reparentTo(self.forest)
loader.loadModel( \
"models/samples/fireflies/foliage04").reparentTo(self.forest)
loader.loadModel( \
"models/samples/fireflies/foliage05").reparentTo(self.forest)
loader.loadModel( \
"models/samples/fireflies/foliage06").reparentTo(self.forest)
loader.loadModel( \
"models/samples/fireflies/foliage07").reparentTo(self.forest)
loader.loadModel( \
"models/samples/fireflies/foliage08").reparentTo(self.forest)
loader.loadModel( \
"models/samples/fireflies/foliage09").reparentTo(self.forest)
self.forest.hide(BitMask32(self.lightMask | self.plainMask))
# Cause the final results to be rendered into the main window on a card.
cm = CardMaker("card")
cm.setFrameFullscreenQuad()
self.card = render2d.attachNewNode(cm.generate())
self.card.setTexture(self.texFinal)
# Post the instructions.
self.title = addTitle("Panda3D: Tutorial - Fireflies using Deferred Shading")
self.inst1 = addInstructions(0.95,"ESC: Quit")
self.inst2 = addInstructions(0.90,"Up/Down: More / Fewer Fireflies (Count: unknown)")
self.inst3 = addInstructions(0.85,"Right/Left: Bigger / Smaller Fireflies (Radius: unknown)")
self.inst4 = addInstructions(0.80,"V: View the render-to-texture results")
# Panda contains a built-in viewer that lets you view the results of
# your render-to-texture operations. This code configures the viewer.
base.bufferViewer.setPosition("llcorner")
base.bufferViewer.setCardSize(0,0.40)
base.bufferViewer.setLayout("vline")
self.toggleCards()
self.toggleCards()
# Firefly parameters
self.fireflies = []
self.sequences = []
self.scaleseqs = []
self.glowspheres = []
self.fireflysize = 1.0
self.spheremodel = loader.loadModel("models/misc/sphere.flt")
self.setFireflySize(25.0)
while (len(self.fireflies)<5): self.addFirefly()
self.updateReadout()
# these allow you to change parameters in realtime
self.accept("escape", sys.exit, [0])
self.accept("arrow_up", self.incFireflyCount, [1.1111111])
self.accept("arrow_down", self.decFireflyCount, [0.9000000])
self.accept("arrow_right", self.setFireflySize, [1.1111111])
self.accept("arrow_left", self.setFireflySize, [0.9000000])
self.accept("v", self.toggleCards)
self.accept("V", self.toggleCards)
self.nextadd = 0
taskMgr.add(self.spawnTask, "spawner")
def makeFBO(self, name, auxrgba):
# This routine creates an offscreen buffer. All the complicated
# parameters are basically demanding capabilities from the offscreen
# buffer - we demand that it be able to render to texture on every
# bitplane, that it can support aux bitplanes, that it track
# the size of the host window, that it can render to texture
# cumulatively, and so forth.
winprops = WindowProperties()
props = FrameBufferProperties()
props.setRgbColor(1)
props.setAlphaBits(1)
props.setDepthBits(1)
props.setAuxRgba(auxrgba)
return base.graphicsEngine.makeOutput(
base.pipe, "model buffer", -2,
props, winprops,
GraphicsPipe.BFSizeTrackHost | GraphicsPipe.BFCanBindEvery |
GraphicsPipe.BFRttCumulative | GraphicsPipe.BFRefuseWindow,
base.win.getGsg(), base.win)
def addFirefly(self):
pos1 = Point3(random.uniform(-50, 50), random.uniform(-100, 150), random.uniform(-10,80))
dir = Vec3(random.uniform(-1, 1), random.uniform(-1, 1), random.uniform(-1, 1))
dir.normalize()
pos2 = pos1 + (dir*20)
fly = self.lightroot.attachNewNode(PandaNode("fly"))
glow = fly.attachNewNode(PandaNode("glow"))
dot = fly.attachNewNode(PandaNode("dot"))
color_r = random.uniform(0.7,1.0)
color_g = 1.0
color_b = 0.8
fly.setShaderInput("lightcolor", color_r, color_g, color_b, 1.0)
int1 = fly.posInterval(random.uniform(7,12), pos1, pos2)
int2 = fly.posInterval(random.uniform(7,12), pos2, pos1)
si1 = fly.scaleInterval(random.uniform(0.8,1.5), Point3(0.2,0.2,0.2), Point3(0.2,0.2,0.2))
si2 = fly.scaleInterval(random.uniform(1.5,0.8), Point3(1.0,1.0,1.0), Point3(0.2,0.2,0.2))
si3 = fly.scaleInterval(random.uniform(1.0,2.0), Point3(0.2,0.2,0.2), Point3(1.0,1.0,1.0))
siseq = Sequence(si1, si2, si3)
siseq.loop()
siseq.setT(random.uniform(0,1000))
seq = Sequence(int1, int2)
seq.loop()
self.spheremodel.instanceTo(glow)
self.spheremodel.instanceTo(dot)
glow.setScale(self.fireflysize*1.1)
glow.hide(BitMask32(self.modelMask | self.plainMask))
dot.setScale(0.6)
dot.hide(BitMask32(self.modelMask | self.lightMask))
dot.setColor(color_r, color_g, color_b, 1.0)
self.fireflies.append(fly)
self.sequences.append(seq)
self.glowspheres.append(glow)
self.scaleseqs.append(siseq)
def updateReadout(self):
self.inst2.destroy()
self.inst2 = addInstructions(0.90,"Up/Down: More / Fewer Fireflies (Currently: "+str(len(self.fireflies))+")")
self.inst3.destroy()
self.inst3 = addInstructions(0.85,"Right/Left: Bigger / Smaller Fireflies (Radius: "+str(self.fireflysize)+" ft)")
def toggleCards(self):
base.bufferViewer.toggleEnable()
# When the cards are not visible, I also disable the color clear.
# This color-clear is actually not necessary, the depth-clear is
# sufficient for the purposes of the algorithm.
if (base.bufferViewer.isEnabled()):
self.modelbuffer.setClearColorActive(1)
else:
self.modelbuffer.setClearColorActive(0)
def incFireflyCount(self, scale):
n = int((len(self.fireflies) * scale) + 1)
while (n > len(self.fireflies)):
self.addFirefly()
self.updateReadout()
def decFireflyCount(self, scale):
n = int(len(self.fireflies) * scale)
if (n < 1): n=1
while (len(self.fireflies) > n):
self.glowspheres.pop()
self.sequences.pop().finish()
self.scaleseqs.pop().finish()
self.fireflies.pop().removeNode()
self.updateReadout()
def setFireflySize(self, n):
n = n * self.fireflysize
self.fireflysize = n
for x in self.glowspheres:
x.setScale(self.fireflysize * 1.1)
self.updateReadout()
def spawnTask(self, task):
if task.time > self.nextadd:
self.nextadd = task.time + 1.0
if (len(self.fireflies) < 300):
self.incFireflyCount(1.03)
return Task.cont
def renderSceneInto(self,
depthtex=None,
colortex=None,
auxtex=None,
auxbits=0,
textures=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)
if (colortex == None):
colortex = Texture("filter-base-color")
colortex.setWrapU(Texture.WMClamp)
colortex.setWrapV(Texture.WMClamp)
texgroup = (depthtex, colortex, auxtex, None)
# Choose the size of the offscreen buffer.
(winx, winy) = self.getScaledSize(1, 1, 1)
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(Vec4(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))
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)
dr = buffer.getDisplayRegion(0)
self.setStackedClears(dr, self.rclears, self.wclears)
if (auxtex):
dr.setClearActive(GraphicsOutput.RTPAuxRgba0, 1)
dr.setClearValue(GraphicsOutput.RTPAuxRgba0,
Vec4(0.5, 0.5, 1.0, 0.0))
self.region.disableClears()
if (self.isFullscreen()):
self.win.disableClears()
dr.setCamera(self.camera)
dr.setActive(1)
self.buffers.append(buffer)
self.sizes.append((1, 1, 1))
return quad
def __init__(self):
base.disableMouse()
base.setBackgroundColor(0, 0, 0)
taskMgr.add(self.updateScene, "updateScene")
# Show the instructions
self.title = addTitle("Panda3D: Tutorial - Distortion Effect")
self.inst1 = addInstructions(0.95, "ESC: Quit")
self.inst2 = addInstructions(0.90,
"Space: Toggle distortion filter On/Off")
self.inst4 = addInstructions(0.85,
"V: View the render-to-texture results")
# Load background
self.seascape = loader.loadModel("models/samples/distortion/plane")
self.seascape.reparentTo(render)
self.seascape.setPosHpr(0, 145, 0, 0, 0, 0)
self.seascape.setScale(100)
self.seascape.setTexture(loader.loadTexture( \
"models/samples/distortion/ocean.jpg"))
# Create the distortion buffer. This buffer renders like a normal scene,
self.distortionBuffer = self.makeFBO("model buffer")
self.distortionBuffer.setSort(-3)
self.distortionBuffer.setClearColor(Vec4(0, 0, 0, 0))
# We have to attach a camera to the distortion buffer. The distortion
# camera must have the same frustum as the main camera. As long
# as the aspect ratios match, the rest will take care of itself.
distortionCamera = base.makeCamera(self.distortionBuffer, scene = \
render, lens = base.cam.node().getLens(), mask = BitMask32.bit(4))
# load the object with the distortion
self.distortionObject = loader.loadModel( \
"models/samples/distortion/boat")
self.distortionObject.setScale(1)
self.distortionObject.setPos(0, 20, -3)
self.distortionObject.hprInterval(10, Point3(360, 0, 0)).loop()
self.distortionObject.reparentTo(render)
# Create the shader that will determime what parts of the scene will
# distortion
distortionShader = loader.loadShader(os.path.join(PANDA_SHADER_PATH, \
"samples/distortion/distortion.sha"))
self.distortionObject.setShader(distortionShader)
self.distortionObject.hide(BitMask32.bit(4))
# Textures
tex1 = loader.loadTexture("models/samples/distortion/water.png")
self.distortionObject.setShaderInput("waves", tex1)
self.texDistortion = Texture()
self.distortionBuffer.addRenderTexture(self.texDistortion,
GraphicsOutput.RTMBindOrCopy,
GraphicsOutput.RTPColor)
self.distortionObject.setShaderInput("screen", self.texDistortion)
# Panda contains a built-in viewer that lets you view the results of
# your render-to-texture operations. This code configures the viewer.
self.accept("v", base.bufferViewer.toggleEnable)
self.accept("V", base.bufferViewer.toggleEnable)
base.bufferViewer.setPosition("llcorner")
base.bufferViewer.setLayout("hline")
base.bufferViewer.setCardSize(0.652, 0)
# event handling
self.accept("space", self.toggleDistortion)
self.accept("escape", exit, [0])
self.distortionOn = True
def reconfigure(self, fullrebuild, changed):
""" Reconfigure is called whenever any configuration change is made. """
configuration = self.configuration
if (fullrebuild):
self.cleanup()
if (len(configuration) == 0):
return
auxbits = 0
needtex = {}
needtex["color"] = True
if (configuration.has_key("CartoonInk")):
needtex["aux"] = True
auxbits |= AuxBitplaneAttrib.ABOAuxNormal
if (configuration.has_key("Bloom")):
needtex["bloom0"] = True
needtex["bloom1"] = True
needtex["bloom2"] = True
needtex["bloom3"] = True
auxbits |= AuxBitplaneAttrib.ABOGlow
if (configuration.has_key("ViewGlow")):
auxbits |= AuxBitplaneAttrib.ABOGlow
for tex in needtex:
self.textures[tex] = Texture("scene-" + tex)
self.textures[tex].setWrapU(Texture.WMClamp)
self.textures[tex].setWrapV(Texture.WMClamp)
needtexpix = True
self.finalQuad = self.manager.renderSceneInto(
textures=self.textures, auxbits=auxbits)
if (self.finalQuad == None):
self.cleanup()
return False
if (configuration.has_key("Bloom")):
bloomconf = configuration["Bloom"]
bloom0 = self.textures["bloom0"]
bloom1 = self.textures["bloom1"]
bloom2 = self.textures["bloom2"]
bloom3 = self.textures["bloom3"]
if (bloomconf.size == "large"):
scale = 8
downsampler = "filter_down4.sha"
elif (bloomconf.size == "medium"):
scale = 4
downsampler = "filter_copy.sha"
else:
scale = 2
downsampler = "filter_copy.sha"
self.bloom.append(
self.manager.renderQuadInto(colortex=bloom0,
div=2,
align=scale))
self.bloom.append(
self.manager.renderQuadInto(colortex=bloom1,
div=scale,
align=scale))
self.bloom.append(
self.manager.renderQuadInto(colortex=bloom2,
div=scale,
align=scale))
self.bloom.append(
self.manager.renderQuadInto(colortex=bloom3,
div=scale,
align=scale))
self.bloom[0].setShaderInput("src", self.textures["color"])
self.bloom[0].setShader(self.loadShader("filter_bloomi.sha"))
self.bloom[1].setShaderInput("src", bloom0)
self.bloom[1].setShader(self.loadShader(downsampler))
self.bloom[2].setShaderInput("src", bloom1)
self.bloom[2].setShader(self.loadShader("filter_bloomx.sha"))
self.bloom[3].setShaderInput("src", bloom2)
self.bloom[3].setShader(self.loadShader("filter_bloomy.sha"))
text = "//Cg\n"
text += "void vshader(float4 vtx_position : POSITION,\n"
text += " out float4 l_position : POSITION,\n"
text += " uniform float4 texpad_txcolor,\n"
text += " uniform float4 texpix_txcolor,\n"
text += " out float4 l_texcoordC : TEXCOORD0,\n"
if (configuration.has_key("CartoonInk")):
text += " uniform float4 texpad_txaux,\n"
text += " uniform float4 texpix_txaux,\n"
text += " out float4 l_texcoordN : TEXCOORD1,\n"
if (configuration.has_key("Bloom")):
text += " uniform float4 texpad_txbloom3,\n"
text += " out float4 l_texcoordB : TEXCOORD2,\n"
text += " uniform float4x4 mat_modelproj)\n"
text += "{\n"
text += " l_position=mul(mat_modelproj, vtx_position);\n"
text += " l_texcoordC=(vtx_position.xzxz * texpad_txcolor) + texpad_txcolor;\n"
if (configuration.has_key("CartoonInk")):
text += " l_texcoordN=(vtx_position.xzxz * texpad_txaux) + texpad_txaux;\n"
if (configuration.has_key("Bloom")):
text += " l_texcoordB=(vtx_position.xzxz * texpad_txbloom3) + texpad_txbloom3;\n"
if (configuration.has_key("HalfPixelShift")):
text += " l_texcoordC+=texpix_txcolor*0.5;\n"
if (configuration.has_key("CartoonInk")):
text += " l_texcoordN+=texpix_txaux*0.5;\n"
text += "}\n"
text += "void fshader(\n"
text += "float4 l_texcoordC : TEXCOORD0,\n"
text += "uniform float4 texpix_txcolor,\n"
if (configuration.has_key("CartoonInk")):
text += "float4 l_texcoordN : TEXCOORD1,\n"
text += "uniform float4 texpix_txaux,\n"
if (configuration.has_key("Bloom")):
text += "float4 l_texcoordB : TEXCOORD2,\n"
for key in self.textures:
text += "uniform sampler2D k_tx" + key + ",\n"
if (configuration.has_key("CartoonInk")):
text += "uniform float4 k_cartoonseparation,\n"
if (configuration.has_key("VolumetricLighting")):
text += "uniform float4 k_casterpos,\n"
text += "uniform float4 k_vlparams,\n"
text += "out float4 o_color : COLOR)\n"
text += "{\n"
text += " o_color = tex2D(k_txcolor, l_texcoordC.xy);\n"
if (configuration.has_key("CartoonInk")):
text += CARTOON_BODY
if (configuration.has_key("Bloom")):
text += "o_color = saturate(o_color);\n"
text += "float4 bloom = 0.5*tex2D(k_txbloom3, l_texcoordB.xy);\n"
text += "o_color = 1-((1-bloom)*(1-o_color));\n"
if (configuration.has_key("ViewGlow")):
text += "o_color.r = o_color.a;\n"
if (configuration.has_key("VolumetricLighting")):
text += "float decay = 1.0f;\n"
text += "float2 curcoord = l_texcoordC.xy;\n"
text += "float2 lightdir = curcoord - k_casterpos.xy;\n"
text += "lightdir *= k_vlparams.y;\n"
text += "half4 sample = tex2D(k_txcolor, curcoord);\n"
text += "float3 vlcolor = sample.rgb * sample.a;\n"
text += "for (int i = 0; i < k_vlparams.x; i++) {\n"
text += " curcoord -= lightdir;\n"
text += " sample = tex2D(k_txcolor, curcoord);\n"
text += " sample *= sample.a * decay;//*weight\n"
text += " vlcolor += sample.rgb;\n"
text += " decay *= k_vlparams.z;\n"
text += "}\n"
text += "o_color += float4(vlcolor * k_vlparams.w, 1);\n"
if (configuration.has_key("Inverted")):
text += "o_color = float4(1, 1, 1, 1) - o_color;\n"
text += "}\n"
self.finalQuad.setShader(Shader.make(text))
for tex in self.textures:
self.finalQuad.setShaderInput("tx" + tex, self.textures[tex])
if (changed == "CartoonInk") or fullrebuild:
if (configuration.has_key("CartoonInk")):
separation = configuration["CartoonInk"]
self.finalQuad.setShaderInput(
"cartoonseparation", Vec4(separation, 0, separation, 0))
if (changed == "Bloom") or fullrebuild:
if (configuration.has_key("Bloom")):
bloomconf = configuration["Bloom"]
intensity = bloomconf.intensity * 3.0
self.bloom[0].setShaderInput("blend", bloomconf.blendx,
bloomconf.blendy,
bloomconf.blendz,
bloomconf.blendw * 2.0)
self.bloom[0].setShaderInput(
"trigger", bloomconf.mintrigger,
1.0 / (bloomconf.maxtrigger - bloomconf.mintrigger), 0.0,
0.0)
self.bloom[0].setShaderInput("desat", bloomconf.desat)
self.bloom[3].setShaderInput("intensity", intensity, intensity,
intensity, intensity)
if (changed == "VolumetricLighting") or fullrebuild:
if (configuration.has_key("VolumetricLighting")):
config = configuration["VolumetricLighting"]
tcparam = config.density / float(config.numsamples)
self.finalQuad.setShaderInput("vlparams", config.numsamples,
tcparam, config.decay,
config.exposure)
self.update()
return True
def renderSceneInto(self, depthtex=None, colortex=None, auxtex=None, auxbits=0, textures=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)
if colortex == None:
colortex = Texture("filter-base-color")
colortex.setWrapU(Texture.WMClamp)
colortex.setWrapV(Texture.WMClamp)
texgroup = (depthtex, colortex, auxtex, None)
# Choose the size of the offscreen buffer.
(winx, winy) = self.getScaledSize(1, 1, 1)
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(Vec4(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))
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)
dr = buffer.getDisplayRegion(0)
self.setStackedClears(dr, self.rclears, self.wclears)
if auxtex:
dr.setClearActive(GraphicsOutput.RTPAuxRgba0, 1)
dr.setClearValue(GraphicsOutput.RTPAuxRgba0, Vec4(0.5, 0.5, 1.0, 0.0))
self.region.disableClears()
if self.isFullscreen():
self.win.disableClears()
dr.setCamera(self.camera)
dr.setActive(1)
self.buffers.append(buffer)
self.sizes.append((1, 1, 1))
return quad
def __init__(self):
# Preliminary capabilities check.
if (base.win.getGsg().getSupportsBasicShaders() == 0):
self.t = addTitle(
"Firefly Demo: Video driver reports that shaders are not supported."
)
return
if (base.win.getGsg().getSupportsDepthTexture() == 0):
self.t = addTitle(
"Firefly Demo: Video driver reports that depth textures are not supported."
)
return
# This algorithm uses two offscreen buffers, one of which has
# an auxiliary bitplane, and the offscreen buffers share a single
# depth buffer. This is a heck of a complicated buffer setup.
self.modelbuffer = self.makeFBO("model buffer", 1)
self.lightbuffer = self.makeFBO("light buffer", 0)
# Creation of a high-powered buffer can fail, if the graphics card
# doesn't support the necessary OpenGL extensions.
if (self.modelbuffer == None) or (self.lightbuffer == None):
self.t = addTitle(
"Toon Shader: Video driver does not support multiple render targets"
)
return
# Create four render textures: depth, normal, albedo, and final.
# attach them to the various bitplanes of the offscreen buffers.
self.texDepth = Texture()
self.texDepth.setFormat(Texture.FDepthStencil)
self.texAlbedo = Texture()
self.texNormal = Texture()
self.texFinal = Texture()
self.modelbuffer.addRenderTexture(self.texDepth,
GraphicsOutput.RTMBindOrCopy,
GraphicsOutput.RTPDepthStencil)
self.modelbuffer.addRenderTexture(self.texAlbedo,
GraphicsOutput.RTMBindOrCopy,
GraphicsOutput.RTPColor)
self.modelbuffer.addRenderTexture(self.texNormal,
GraphicsOutput.RTMBindOrCopy,
GraphicsOutput.RTPAuxRgba0)
self.lightbuffer.addRenderTexture(self.texFinal,
GraphicsOutput.RTMBindOrCopy,
GraphicsOutput.RTPColor)
# Set the near and far clipping planes.
base.cam.node().getLens().setNear(50.0)
base.cam.node().getLens().setFar(500.0)
lens = base.cam.node().getLens()
# This algorithm uses three cameras: one to render the models into the
# model buffer, one to render the lights into the light buffer, and
# one to render "plain" stuff (non-deferred shaded) stuff into the light
# buffer. Each camera has a bitmask to identify it.
self.modelMask = 1
self.lightMask = 2
self.plainMask = 4
self.modelcam = base.makeCamera(self.modelbuffer,
lens=lens,
scene=render,
mask=self.modelMask)
self.lightcam = base.makeCamera(self.lightbuffer,
lens=lens,
scene=render,
mask=self.lightMask)
self.plaincam = base.makeCamera(self.lightbuffer,
lens=lens,
scene=render,
mask=self.plainMask)
# Panda's main camera is not used.
base.cam.node().setActive(0)
# Take explicit control over the order in which the three
# buffers are rendered.
self.modelbuffer.setSort(1)
self.lightbuffer.setSort(2)
base.win.setSort(3)
# Within the light buffer, control the order of the two cams.
self.lightcam.node().getDisplayRegion(0).setSort(1)
self.plaincam.node().getDisplayRegion(0).setSort(2)
# By default, panda usually clears the screen before every
# camera and before every window. Tell it not to do that.
# Then, tell it specifically when to clear and what to clear.
self.modelcam.node().getDisplayRegion(0).disableClears()
self.lightcam.node().getDisplayRegion(0).disableClears()
self.plaincam.node().getDisplayRegion(0).disableClears()
base.cam.node().getDisplayRegion(0).disableClears()
base.cam2d.node().getDisplayRegion(0).disableClears()
self.modelbuffer.disableClears()
base.win.disableClears()
self.modelbuffer.setClearColorActive(1)
self.modelbuffer.setClearDepthActive(1)
self.lightbuffer.setClearColorActive(1)
self.lightbuffer.setClearColor(Vec4(0, 0, 0, 1))
# Miscellaneous stuff.
base.disableMouse()
base.camera.setPos(-9.112, -211.077, 46.951)
base.camera.setHpr(0, -7.5, 2.4)
base.setBackgroundColor(Vec4(0, 0, 0, 0))
random.seed()
# Calculate the projection parameters for the final shader.
# The math here is too complex to explain in an inline comment,
# I've put in a full explanation into the HTML intro.
proj = base.cam.node().getLens().getProjectionMat()
proj_x = 0.5 * proj.getCell(3, 2) / proj.getCell(0, 0)
proj_y = 0.5 * proj.getCell(3, 2)
proj_z = 0.5 * proj.getCell(3, 2) / proj.getCell(2, 1)
proj_w = -0.5 - 0.5 * proj.getCell(1, 2)
# Configure the render state of the model camera.
tempnode = NodePath(PandaNode("temp node"))
tempnode.setAttrib(
AlphaTestAttrib.make(RenderAttrib.MGreaterEqual, 0.5))
tempnode.setShader(Shader.load(os.path.join(PANDA_SHADER_PATH, \
"samples/fireflies/fireflies_model.sha")))
tempnode.setAttrib(DepthTestAttrib.make(RenderAttrib.MLessEqual))
self.modelcam.node().setInitialState(tempnode.getState())
# Configure the render state of the light camera.
tempnode = NodePath(PandaNode("temp node"))
tempnode.setShader(Shader.load(os.path.join(PANDA_SHADER_PATH, \
"samples/fireflies/fireflies_lighting.sha")))
tempnode.setShaderInput("texnormal", self.texNormal)
tempnode.setShaderInput("texalbedo", self.texAlbedo)
tempnode.setShaderInput("texdepth", self.texDepth)
tempnode.setShaderInput("proj", Vec4(proj_x, proj_y, proj_z, proj_w))
tempnode.setAttrib(
ColorBlendAttrib.make(ColorBlendAttrib.MAdd, ColorBlendAttrib.OOne,
ColorBlendAttrib.OOne))
tempnode.setAttrib(
CullFaceAttrib.make(CullFaceAttrib.MCullCounterClockwise))
# The next line causes problems on Linux.
#tempnode.setAttrib(DepthTestAttrib.make(RenderAttrib.MGreaterEqual))
tempnode.setAttrib(DepthWriteAttrib.make(DepthWriteAttrib.MOff))
self.lightcam.node().setInitialState(tempnode.getState())
# Configure the render state of the plain camera.
rs = RenderState.makeEmpty()
self.plaincam.node().setInitialState(rs)
# Clear any render attribs on the root node. This is necessary
# because by default, panda assigns some attribs to the root
# node. These default attribs will override the
# carefully-configured render attribs that we just attached
# to the cameras. The simplest solution is to just clear
# them all out.
render.setState(RenderState.makeEmpty())
# My artist created a model in which some of the polygons
# don't have textures. This confuses the shader I wrote.
# This little hack guarantees that everything has a texture.
white = loader.loadTexture("models/samples/fireflies/white.jpg")
render.setTexture(white, 0)
# Create two subroots, to help speed cull traversal.
self.lightroot = NodePath(PandaNode("lightroot"))
self.lightroot.reparentTo(render)
self.modelroot = NodePath(PandaNode("modelroot"))
self.modelroot.reparentTo(render)
self.lightroot.hide(BitMask32(self.modelMask))
self.modelroot.hide(BitMask32(self.lightMask))
self.modelroot.hide(BitMask32(self.plainMask))
# Load the model of a forest. Make it visible to the model camera.
self.forest = NodePath(PandaNode("Forest Root"))
self.forest.reparentTo(render)
loader.loadModel( \
"models/samples/fireflies/background").reparentTo(self.forest)
loader.loadModel( \
"models/samples/fireflies/foliage01").reparentTo(self.forest)
loader.loadModel( \
"models/samples/fireflies/foliage02").reparentTo(self.forest)
loader.loadModel( \
"models/samples/fireflies/foliage03").reparentTo(self.forest)
loader.loadModel( \
"models/samples/fireflies/foliage04").reparentTo(self.forest)
loader.loadModel( \
"models/samples/fireflies/foliage05").reparentTo(self.forest)
loader.loadModel( \
"models/samples/fireflies/foliage06").reparentTo(self.forest)
loader.loadModel( \
"models/samples/fireflies/foliage07").reparentTo(self.forest)
loader.loadModel( \
"models/samples/fireflies/foliage08").reparentTo(self.forest)
loader.loadModel( \
"models/samples/fireflies/foliage09").reparentTo(self.forest)
self.forest.hide(BitMask32(self.lightMask | self.plainMask))
# Cause the final results to be rendered into the main window on a card.
cm = CardMaker("card")
cm.setFrameFullscreenQuad()
self.card = render2d.attachNewNode(cm.generate())
self.card.setTexture(self.texFinal)
# Post the instructions.
self.title = addTitle(
"Panda3D: Tutorial - Fireflies using Deferred Shading")
self.inst1 = addInstructions(0.95, "ESC: Quit")
self.inst2 = addInstructions(
0.90, "Up/Down: More / Fewer Fireflies (Count: unknown)")
self.inst3 = addInstructions(
0.85, "Right/Left: Bigger / Smaller Fireflies (Radius: unknown)")
self.inst4 = addInstructions(0.80,
"V: View the render-to-texture results")
# Panda contains a built-in viewer that lets you view the results of
# your render-to-texture operations. This code configures the viewer.
base.bufferViewer.setPosition("llcorner")
base.bufferViewer.setCardSize(0, 0.40)
base.bufferViewer.setLayout("vline")
self.toggleCards()
self.toggleCards()
# Firefly parameters
self.fireflies = []
self.sequences = []
self.scaleseqs = []
self.glowspheres = []
self.fireflysize = 1.0
self.spheremodel = loader.loadModel("models/misc/sphere.flt")
self.setFireflySize(25.0)
while (len(self.fireflies) < 5):
self.addFirefly()
self.updateReadout()
# these allow you to change parameters in realtime
self.accept("escape", sys.exit, [0])
self.accept("arrow_up", self.incFireflyCount, [1.1111111])
self.accept("arrow_down", self.decFireflyCount, [0.9000000])
self.accept("arrow_right", self.setFireflySize, [1.1111111])
self.accept("arrow_left", self.setFireflySize, [0.9000000])
self.accept("v", self.toggleCards)
self.accept("V", self.toggleCards)
self.nextadd = 0
taskMgr.add(self.spawnTask, "spawner")
class FireflyDemo(DirectObject):
def __init__(self):
# Preliminary capabilities check.
if (base.win.getGsg().getSupportsBasicShaders() == 0):
self.t = addTitle(
"Firefly Demo: Video driver reports that shaders are not supported."
)
return
if (base.win.getGsg().getSupportsDepthTexture() == 0):
self.t = addTitle(
"Firefly Demo: Video driver reports that depth textures are not supported."
)
return
# This algorithm uses two offscreen buffers, one of which has
# an auxiliary bitplane, and the offscreen buffers share a single
# depth buffer. This is a heck of a complicated buffer setup.
self.modelbuffer = self.makeFBO("model buffer", 1)
self.lightbuffer = self.makeFBO("light buffer", 0)
# Creation of a high-powered buffer can fail, if the graphics card
# doesn't support the necessary OpenGL extensions.
if (self.modelbuffer == None) or (self.lightbuffer == None):
self.t = addTitle(
"Toon Shader: Video driver does not support multiple render targets"
)
return
# Create four render textures: depth, normal, albedo, and final.
# attach them to the various bitplanes of the offscreen buffers.
self.texDepth = Texture()
self.texDepth.setFormat(Texture.FDepthStencil)
self.texAlbedo = Texture()
self.texNormal = Texture()
self.texFinal = Texture()
self.modelbuffer.addRenderTexture(self.texDepth,
GraphicsOutput.RTMBindOrCopy,
GraphicsOutput.RTPDepthStencil)
self.modelbuffer.addRenderTexture(self.texAlbedo,
GraphicsOutput.RTMBindOrCopy,
GraphicsOutput.RTPColor)
self.modelbuffer.addRenderTexture(self.texNormal,
GraphicsOutput.RTMBindOrCopy,
GraphicsOutput.RTPAuxRgba0)
self.lightbuffer.addRenderTexture(self.texFinal,
GraphicsOutput.RTMBindOrCopy,
GraphicsOutput.RTPColor)
# Set the near and far clipping planes.
base.cam.node().getLens().setNear(50.0)
base.cam.node().getLens().setFar(500.0)
lens = base.cam.node().getLens()
# This algorithm uses three cameras: one to render the models into the
# model buffer, one to render the lights into the light buffer, and
# one to render "plain" stuff (non-deferred shaded) stuff into the light
# buffer. Each camera has a bitmask to identify it.
self.modelMask = 1
self.lightMask = 2
self.plainMask = 4
self.modelcam = base.makeCamera(self.modelbuffer,
lens=lens,
scene=render,
mask=self.modelMask)
self.lightcam = base.makeCamera(self.lightbuffer,
lens=lens,
scene=render,
mask=self.lightMask)
self.plaincam = base.makeCamera(self.lightbuffer,
lens=lens,
scene=render,
mask=self.plainMask)
# Panda's main camera is not used.
base.cam.node().setActive(0)
# Take explicit control over the order in which the three
# buffers are rendered.
self.modelbuffer.setSort(1)
self.lightbuffer.setSort(2)
base.win.setSort(3)
# Within the light buffer, control the order of the two cams.
self.lightcam.node().getDisplayRegion(0).setSort(1)
self.plaincam.node().getDisplayRegion(0).setSort(2)
# By default, panda usually clears the screen before every
# camera and before every window. Tell it not to do that.
# Then, tell it specifically when to clear and what to clear.
self.modelcam.node().getDisplayRegion(0).disableClears()
self.lightcam.node().getDisplayRegion(0).disableClears()
self.plaincam.node().getDisplayRegion(0).disableClears()
base.cam.node().getDisplayRegion(0).disableClears()
base.cam2d.node().getDisplayRegion(0).disableClears()
self.modelbuffer.disableClears()
base.win.disableClears()
self.modelbuffer.setClearColorActive(1)
self.modelbuffer.setClearDepthActive(1)
self.lightbuffer.setClearColorActive(1)
self.lightbuffer.setClearColor(Vec4(0, 0, 0, 1))
# Miscellaneous stuff.
base.disableMouse()
base.camera.setPos(-9.112, -211.077, 46.951)
base.camera.setHpr(0, -7.5, 2.4)
base.setBackgroundColor(Vec4(0, 0, 0, 0))
random.seed()
# Calculate the projection parameters for the final shader.
# The math here is too complex to explain in an inline comment,
# I've put in a full explanation into the HTML intro.
proj = base.cam.node().getLens().getProjectionMat()
proj_x = 0.5 * proj.getCell(3, 2) / proj.getCell(0, 0)
proj_y = 0.5 * proj.getCell(3, 2)
proj_z = 0.5 * proj.getCell(3, 2) / proj.getCell(2, 1)
proj_w = -0.5 - 0.5 * proj.getCell(1, 2)
# Configure the render state of the model camera.
tempnode = NodePath(PandaNode("temp node"))
tempnode.setAttrib(
AlphaTestAttrib.make(RenderAttrib.MGreaterEqual, 0.5))
tempnode.setShader(Shader.load(os.path.join(PANDA_SHADER_PATH, \
"samples/fireflies/fireflies_model.sha")))
tempnode.setAttrib(DepthTestAttrib.make(RenderAttrib.MLessEqual))
self.modelcam.node().setInitialState(tempnode.getState())
# Configure the render state of the light camera.
tempnode = NodePath(PandaNode("temp node"))
tempnode.setShader(Shader.load(os.path.join(PANDA_SHADER_PATH, \
"samples/fireflies/fireflies_lighting.sha")))
tempnode.setShaderInput("texnormal", self.texNormal)
tempnode.setShaderInput("texalbedo", self.texAlbedo)
tempnode.setShaderInput("texdepth", self.texDepth)
tempnode.setShaderInput("proj", Vec4(proj_x, proj_y, proj_z, proj_w))
tempnode.setAttrib(
ColorBlendAttrib.make(ColorBlendAttrib.MAdd, ColorBlendAttrib.OOne,
ColorBlendAttrib.OOne))
tempnode.setAttrib(
CullFaceAttrib.make(CullFaceAttrib.MCullCounterClockwise))
# The next line causes problems on Linux.
#tempnode.setAttrib(DepthTestAttrib.make(RenderAttrib.MGreaterEqual))
tempnode.setAttrib(DepthWriteAttrib.make(DepthWriteAttrib.MOff))
self.lightcam.node().setInitialState(tempnode.getState())
# Configure the render state of the plain camera.
rs = RenderState.makeEmpty()
self.plaincam.node().setInitialState(rs)
# Clear any render attribs on the root node. This is necessary
# because by default, panda assigns some attribs to the root
# node. These default attribs will override the
# carefully-configured render attribs that we just attached
# to the cameras. The simplest solution is to just clear
# them all out.
render.setState(RenderState.makeEmpty())
# My artist created a model in which some of the polygons
# don't have textures. This confuses the shader I wrote.
# This little hack guarantees that everything has a texture.
white = loader.loadTexture("models/samples/fireflies/white.jpg")
render.setTexture(white, 0)
# Create two subroots, to help speed cull traversal.
self.lightroot = NodePath(PandaNode("lightroot"))
self.lightroot.reparentTo(render)
self.modelroot = NodePath(PandaNode("modelroot"))
self.modelroot.reparentTo(render)
self.lightroot.hide(BitMask32(self.modelMask))
self.modelroot.hide(BitMask32(self.lightMask))
self.modelroot.hide(BitMask32(self.plainMask))
# Load the model of a forest. Make it visible to the model camera.
self.forest = NodePath(PandaNode("Forest Root"))
self.forest.reparentTo(render)
loader.loadModel( \
"models/samples/fireflies/background").reparentTo(self.forest)
loader.loadModel( \
"models/samples/fireflies/foliage01").reparentTo(self.forest)
loader.loadModel( \
"models/samples/fireflies/foliage02").reparentTo(self.forest)
loader.loadModel( \
"models/samples/fireflies/foliage03").reparentTo(self.forest)
loader.loadModel( \
"models/samples/fireflies/foliage04").reparentTo(self.forest)
loader.loadModel( \
"models/samples/fireflies/foliage05").reparentTo(self.forest)
loader.loadModel( \
"models/samples/fireflies/foliage06").reparentTo(self.forest)
loader.loadModel( \
"models/samples/fireflies/foliage07").reparentTo(self.forest)
loader.loadModel( \
"models/samples/fireflies/foliage08").reparentTo(self.forest)
loader.loadModel( \
"models/samples/fireflies/foliage09").reparentTo(self.forest)
self.forest.hide(BitMask32(self.lightMask | self.plainMask))
# Cause the final results to be rendered into the main window on a card.
cm = CardMaker("card")
cm.setFrameFullscreenQuad()
self.card = render2d.attachNewNode(cm.generate())
self.card.setTexture(self.texFinal)
# Post the instructions.
self.title = addTitle(
"Panda3D: Tutorial - Fireflies using Deferred Shading")
self.inst1 = addInstructions(0.95, "ESC: Quit")
self.inst2 = addInstructions(
0.90, "Up/Down: More / Fewer Fireflies (Count: unknown)")
self.inst3 = addInstructions(
0.85, "Right/Left: Bigger / Smaller Fireflies (Radius: unknown)")
self.inst4 = addInstructions(0.80,
"V: View the render-to-texture results")
# Panda contains a built-in viewer that lets you view the results of
# your render-to-texture operations. This code configures the viewer.
base.bufferViewer.setPosition("llcorner")
base.bufferViewer.setCardSize(0, 0.40)
base.bufferViewer.setLayout("vline")
self.toggleCards()
self.toggleCards()
# Firefly parameters
self.fireflies = []
self.sequences = []
self.scaleseqs = []
self.glowspheres = []
self.fireflysize = 1.0
self.spheremodel = loader.loadModel("models/misc/sphere.flt")
self.setFireflySize(25.0)
while (len(self.fireflies) < 5):
self.addFirefly()
self.updateReadout()
# these allow you to change parameters in realtime
self.accept("escape", sys.exit, [0])
self.accept("arrow_up", self.incFireflyCount, [1.1111111])
self.accept("arrow_down", self.decFireflyCount, [0.9000000])
self.accept("arrow_right", self.setFireflySize, [1.1111111])
self.accept("arrow_left", self.setFireflySize, [0.9000000])
self.accept("v", self.toggleCards)
self.accept("V", self.toggleCards)
self.nextadd = 0
taskMgr.add(self.spawnTask, "spawner")
def makeFBO(self, name, auxrgba):
# This routine creates an offscreen buffer. All the complicated
# parameters are basically demanding capabilities from the offscreen
# buffer - we demand that it be able to render to texture on every
# bitplane, that it can support aux bitplanes, that it track
# the size of the host window, that it can render to texture
# cumulatively, and so forth.
winprops = WindowProperties()
props = FrameBufferProperties()
props.setRgbColor(1)
props.setAlphaBits(1)
props.setDepthBits(1)
props.setAuxRgba(auxrgba)
return base.graphicsEngine.makeOutput(
base.pipe, "model buffer", -2, props, winprops,
GraphicsPipe.BFSizeTrackHost | GraphicsPipe.BFCanBindEvery
| GraphicsPipe.BFRttCumulative | GraphicsPipe.BFRefuseWindow,
base.win.getGsg(), base.win)
def addFirefly(self):
pos1 = Point3(random.uniform(-50, 50), random.uniform(-100, 150),
random.uniform(-10, 80))
dir = Vec3(random.uniform(-1, 1), random.uniform(-1, 1),
random.uniform(-1, 1))
dir.normalize()
pos2 = pos1 + (dir * 20)
fly = self.lightroot.attachNewNode(PandaNode("fly"))
glow = fly.attachNewNode(PandaNode("glow"))
dot = fly.attachNewNode(PandaNode("dot"))
color_r = random.uniform(0.7, 1.0)
color_g = 1.0
color_b = 0.8
fly.setShaderInput("lightcolor", color_r, color_g, color_b, 1.0)
int1 = fly.posInterval(random.uniform(7, 12), pos1, pos2)
int2 = fly.posInterval(random.uniform(7, 12), pos2, pos1)
si1 = fly.scaleInterval(random.uniform(0.8, 1.5),
Point3(0.2, 0.2, 0.2), Point3(0.2, 0.2, 0.2))
si2 = fly.scaleInterval(random.uniform(1.5, 0.8),
Point3(1.0, 1.0, 1.0), Point3(0.2, 0.2, 0.2))
si3 = fly.scaleInterval(random.uniform(1.0, 2.0),
Point3(0.2, 0.2, 0.2), Point3(1.0, 1.0, 1.0))
siseq = Sequence(si1, si2, si3)
siseq.loop()
siseq.setT(random.uniform(0, 1000))
seq = Sequence(int1, int2)
seq.loop()
self.spheremodel.instanceTo(glow)
self.spheremodel.instanceTo(dot)
glow.setScale(self.fireflysize * 1.1)
glow.hide(BitMask32(self.modelMask | self.plainMask))
dot.setScale(0.6)
dot.hide(BitMask32(self.modelMask | self.lightMask))
dot.setColor(color_r, color_g, color_b, 1.0)
self.fireflies.append(fly)
self.sequences.append(seq)
self.glowspheres.append(glow)
self.scaleseqs.append(siseq)
def updateReadout(self):
self.inst2.destroy()
self.inst2 = addInstructions(
0.90, "Up/Down: More / Fewer Fireflies (Currently: " +
str(len(self.fireflies)) + ")")
self.inst3.destroy()
self.inst3 = addInstructions(
0.85, "Right/Left: Bigger / Smaller Fireflies (Radius: " +
str(self.fireflysize) + " ft)")
def toggleCards(self):
base.bufferViewer.toggleEnable()
# When the cards are not visible, I also disable the color clear.
# This color-clear is actually not necessary, the depth-clear is
# sufficient for the purposes of the algorithm.
if (base.bufferViewer.isEnabled()):
self.modelbuffer.setClearColorActive(1)
else:
self.modelbuffer.setClearColorActive(0)
def incFireflyCount(self, scale):
n = int((len(self.fireflies) * scale) + 1)
while (n > len(self.fireflies)):
self.addFirefly()
self.updateReadout()
def decFireflyCount(self, scale):
n = int(len(self.fireflies) * scale)
if (n < 1): n = 1
while (len(self.fireflies) > n):
self.glowspheres.pop()
self.sequences.pop().finish()
self.scaleseqs.pop().finish()
self.fireflies.pop().removeNode()
self.updateReadout()
def setFireflySize(self, n):
n = n * self.fireflysize
self.fireflysize = n
for x in self.glowspheres:
x.setScale(self.fireflysize * 1.1)
self.updateReadout()
def spawnTask(self, task):
if task.time > self.nextadd:
self.nextadd = task.time + 1.0
if (len(self.fireflies) < 300):
self.incFireflyCount(1.03)
return Task.cont
def __init__(self):
# create a texture into which we can copy the main window.
self.tex = Texture()
self.tex.setMinfilter(Texture.FTLinear)
base.win.addRenderTexture(self.tex,
GraphicsOutput.RTMTriggeredCopyTexture)
# Create another 2D camera. Tell it to render before the main camera.
self.backcam = base.makeCamera2d(base.win, sort=-10)
self.background = NodePath("background")
self.backcam.reparentTo(self.background)
self.background.setDepthTest(0)
self.background.setDepthWrite(0)
self.backcam.node().getDisplayRegion(0).setClearDepthActive(0)
# Obtain two texture cards. One renders before the dragon, the other after.
self.bcard = base.win.getTextureCard()
self.bcard.reparentTo(self.background)
self.bcard.setTransparency(1)
self.fcard = base.win.getTextureCard()
self.fcard.reparentTo(render2d)
self.fcard.setTransparency(1)
# Initialize one of the nice effects.
self.chooseEffectGhost()
# Add the task that initiates the screenshots.
taskMgr.add(self.takeSnapShot, "takeSnapShot")
# Create some black squares on top of which we will
# place the instructions.
blackmaker = CardMaker("blackmaker")
blackmaker.setColor(0, 0, 0, 1)
blackmaker.setFrame(-1.00, -0.50, 0.65, 1.00)
instcard = NodePath(blackmaker.generate())
instcard.reparentTo(render2d)
blackmaker.setFrame(-0.5, 0.5, -1.00, -0.85)
titlecard = NodePath(blackmaker.generate())
titlecard.reparentTo(render2d)
# Panda does its best to hide the differences between DirectX and
# OpenGL. But there are a few differences that it cannot hide.
# One such difference is that when OpenGL copies from a
# visible window to a texture, it gets it right-side-up. When
# DirectX does it, it gets it upside-down. There is nothing panda
# can do to compensate except to expose a flag and let the
# application programmer deal with it. You should only do this
# in the rare event that you're copying from a visible window
# to a texture.
if (base.win.getGsg().getCopyTextureInverted()):
print "Copy texture is inverted."
self.bcard.setScale(1, 1, -1)
self.fcard.setScale(1, 1, -1)
# Put up the instructions
title = OnscreenText(text="Panda3D: Tutorial - Motion Trails",
style=1,
fg=(1, 1, 1, 1),
font=font,
pos=(0, -0.95),
scale=.07)
instr0 = addInstructions(0.95, "Press ESC to exit")
instr1 = addInstructions(0.90, "Press 1: Ghost effect")
instr2 = addInstructions(0.85, "Press 2: PaintBrush effect")
instr3 = addInstructions(0.80, "Press 3: Double Vision effect")
instr4 = addInstructions(0.75, "Press 4: Wings of Blue effect")
instr5 = addInstructions(0.70, "Press 5: Whirlpool effect")
# enable the key events
self.accept("escape", sys.exit, [0])
self.accept("1", self.chooseEffectGhost)
self.accept("2", self.chooseEffectPaintBrush)
self.accept("3", self.chooseEffectDoubleVision)
self.accept("4", self.chooseEffectWingsOfBlue)
self.accept("5", self.chooseEffectWhirlpool)
