class ToonMaker(DirectObject):
def __init__(self):
base.disableMouse()
base.cam.node().getLens().setNear(10.0)
base.cam.node().getLens().setFar(200.0)
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
# Post the instructions.
self.title = addTitle(
"Panda3D: Tutorial - Toon Shading with Normals-Based Inking")
self.inst1 = addInstructions(0.95, "ESC: Quit")
self.inst2 = addInstructions(
0.90, "Up/Down: Increase/Decrease Line Thickness")
self.inst3 = addInstructions(0.85,
"V: View the render-to-texture results")
# Load a dragon model and animate it.
self.character = Actor()
self.character.loadModel('models/samples/cartoon/nik_dragon')
self.character.reparentTo(render)
self.character.loadAnims({'win': 'models/samples/cartoon/nik_dragon'})
self.character.loop('win')
self.character.hprInterval(15, Point3(360, 0, 0)).loop()
# 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])
self.accept("arrow_up", self.increaseSeparation)
self.accept("arrow_down", self.decreaseSeparation)
def increaseSeparation(self):
self.separation = self.separation * 1.11111111
print self.separation
self.filters.setCartoonInk(separation=self.separation)
def decreaseSeparation(self):
self.separation = self.separation * 0.90000000
print self.separation
self.filters.setCartoonInk(separation=self.separation)
class ToonMaker(DirectObject):
def __init__(self):
base.disableMouse()
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
# Post the instructions.
self.title = addTitle(
"Panda3D: Tutorial - Toon Shading with Normals-Based Inking")
self.inst1 = addInstructions(0.95, "ESC: Quit")
self.inst2 = addInstructions(
0.90, "Up/Down: Increase/Decrease Line Thickness")
self.inst3 = addInstructions(
0.85, "Left/Right: Decrease/Increase Line Darkness")
self.inst4 = addInstructions(0.80,
"V: View the render-to-texture results")
# This shader's job is to render the model with discrete lighting
# levels. The lighting calculations built into the shader assume
# a single nonattenuating point light.
tempnode = NodePath(PandaNode("temp node"))
tempnode.setShader(Shader.load(os.path.join(PANDA_SHADER_PATH, \
"samples/cartoon/cartoon_lighting.sha")))
base.cam.node().setInitialState(tempnode.getState())
# This is the object that represents the single "light", as far
# the shader is concerned. It's not a real Panda3D LightNode, but
# the shader doesn't care about that.
light = render.attachNewNode("light")
light.setPos(30, -50, 0)
# this call puts the light's nodepath into the render state.
# this enables the shader to access this light by name.
render.setShaderInput("light", light)
# The "normals buffer" will contain a picture of the model colorized
# so that the color of the model is a representation of the model's
# normal at that point.
normalsBuffer = base.win.makeTextureBuffer("normalsBuffer", 0, 0)
normalsBuffer.setClearColor(Vec4(0.5, 0.5, 0.5, 1))
self.normalsBuffer = normalsBuffer
normalsCamera = base.makeCamera(normalsBuffer,
lens=base.cam.node().getLens())
normalsCamera.node().setScene(render)
tempnode = NodePath(PandaNode("temp node"))
tempnode.setShader(Shader.load(os.path.join(PANDA_SHADER_PATH, \
"samples/cartoon/cartoon_normal.sha")))
normalsCamera.node().setInitialState(tempnode.getState())
#what we actually do to put edges on screen is apply them as a texture to
#a transparent screen-fitted card
drawnScene = normalsBuffer.getTextureCard()
drawnScene.setTransparency(1)
drawnScene.setColor(1, 1, 1, 0)
drawnScene.reparentTo(render2d)
self.drawnScene = drawnScene
# this shader accepts, as input, the picture from the normals buffer.
# it compares each adjacent pixel, looking for discontinuities.
# wherever a discontinuity exists, it emits black ink.
self.separation = 0.001
self.cutoff = 0.3
inkGen=Shader.load(os.path.join(PANDA_SHADER_PATH, \
"samples/cartoon/cartoon_ink.sha"))
drawnScene.setShader(inkGen)
drawnScene.setShaderInput("separation",
Vec4(self.separation, 0, self.separation, 0))
drawnScene.setShaderInput(
"cutoff", Vec4(self.cutoff, self.cutoff, self.cutoff, self.cutoff))
# 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")
# Load a dragon model and animate it.
self.character = Actor()
self.character.loadModel('models/samples/cartoon/nik_dragon')
self.character.reparentTo(render)
self.character.loadAnims({'win': 'models/samples/cartoon/nik_dragon'})
self.character.loop('win')
self.character.hprInterval(15, Point3(360, 0, 0)).loop()
# 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)
self.accept("arrow_left", self.increaseCutoff)
self.accept("arrow_right", self.decreaseCutoff)
def increaseSeparation(self):
self.separation = self.separation * 1.11111111
print self.separation
self.drawnScene.setShaderInput(
"separation", Vec4(self.separation, 0, self.separation, 0))
def decreaseSeparation(self):
self.separation = self.separation * 0.90000000
print self.separation
self.drawnScene.setShaderInput(
"separation", Vec4(self.separation, 0, self.separation, 0))
def increaseCutoff(self):
self.cutoff = self.cutoff * 1.11111111
print self.cutoff
self.drawnScene.setShaderInput(
"cutoff", Vec4(self.cutoff, self.cutoff, self.cutoff, self.cutoff))
def decreaseCutoff(self):
self.cutoff = self.cutoff * 0.90000000
print self.cutoff
self.drawnScene.setShaderInput(
"cutoff", Vec4(self.cutoff, self.cutoff, self.cutoff, self.cutoff))
class GlowDemo(DirectObject):
def __init__(self):
base.disableMouse()
base.setBackgroundColor(0, 0, 0)
camera.setPos(0, -50, 0)
# Check video card capabilities.
if (base.win.getGsg().getSupportsBasicShaders() == 0):
addTitle(
"Glow Filter: Video driver reports that shaders are not supported."
)
return
# Post the instructions
self.title = addTitle("Panda3D: Tutorial - Glow Filter")
self.inst1 = addInstructions(0.95, "ESC: Quit")
self.inst2 = addInstructions(0.90, "Space: Toggle Glow Filter On/Off")
self.inst3 = addInstructions(0.85, "Enter: Toggle Running/Spinning")
self.inst4 = addInstructions(0.80,
"V: View the render-to-texture results")
#create the shader that will determime what parts of the scene will glow
glowShader=Shader.load(os.path.join(PANDA_SHADER_PATH, \
"samples/glow/glow_shader.sha"))
# load our model
self.tron = Actor()
self.tron.loadModel("models/samples/glow/tron")
self.tron.loadAnims({"running": "models/samples/glow/tron_anim"})
self.tron.reparentTo(render)
self.interval = self.tron.hprInterval(60, Point3(360, 0, 0))
self.interval.loop()
self.isRunning = False
#put some lighting on the tron model
dlight = DirectionalLight('dlight')
alight = AmbientLight('alight')
dlnp = render.attachNewNode(dlight)
alnp = render.attachNewNode(alight)
dlight.setColor(Vec4(1.0, 0.7, 0.2, 1))
alight.setColor(Vec4(0.2, 0.2, 0.2, 1))
dlnp.setHpr(0, -60, 0)
render.setLight(dlnp)
render.setLight(alnp)
# create the glow buffer. This buffer renders like a normal scene,
# except that only the glowing materials should show up nonblack.
glowBuffer = base.win.makeTextureBuffer("Glow scene", 512, 512)
glowBuffer.setSort(-3)
glowBuffer.setClearColor(Vec4(0, 0, 0, 1))
# We have to attach a camera to the glow buffer. The glow camera
# must have the same frustum as the main camera. As long as the aspect
# ratios match, the rest will take care of itself.
glowCamera = base.makeCamera(glowBuffer,
lens=base.cam.node().getLens())
# Tell the glow camera to use the glow shader
tempnode = NodePath(PandaNode("temp node"))
tempnode.setShader(glowShader)
glowCamera.node().setInitialState(tempnode.getState())
# set up the pipeline: from glow scene to blur x to blur y to main window.
blurXBuffer=makeFilterBuffer(glowBuffer, "Blur X", -2, \
os.path.join(PANDA_SHADER_PATH, "samples/glow/glow_xblur.sha"))
blurYBuffer=makeFilterBuffer(blurXBuffer, "Blur Y", -1, \
os.path.join(PANDA_SHADER_PATH, "samples/glow/glow_yblur.sha"))
self.finalcard = blurYBuffer.getTextureCard()
self.finalcard.reparentTo(render2d)
self.finalcard.setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.MAdd))
# 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.toggleGlow)
self.accept("enter", self.toggleDisplay)
self.accept("escape", sys.exit, [0])
self.glowOn = True
def toggleGlow(self):
if self.glowOn:
self.finalcard.reparentTo(hidden)
else:
self.finalcard.reparentTo(render2d)
self.glowOn = not (self.glowOn)
def toggleDisplay(self):
self.isRunning = not (self.isRunning)
if not (self.isRunning):
camera.setPos(0, -50, 0)
self.tron.stop("running")
self.tron.pose("running", 0)
self.interval.loop()
else:
camera.setPos(0, -170, 3)
self.interval.finish()
self.tron.setHpr(0, 0, 0)
self.tron.loop("running")
class ToonMaker(DirectObject):
def __init__(self):
base.disableMouse()
base.cam.node().getLens().setNear(10.0)
base.cam.node().getLens().setFar(200.0)
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
# Post the instructions.
self.title = addTitle("Panda3D: Tutorial - Toon Shading with Normals-Based Inking")
self.inst1 = addInstructions(0.95,"ESC: Quit")
self.inst2 = addInstructions(0.90,"Up/Down: Increase/Decrease Line Thickness")
self.inst3 = addInstructions(0.85,"V: View the render-to-texture results")
# Load a dragon model and animate it.
self.character = Actor()
self.character.loadModel('models/samples/cartoon/nik_dragon')
self.character.reparentTo(render)
self.character.loadAnims({'win': 'models/samples/cartoon/nik_dragon'})
self.character.loop('win')
self.character.hprInterval(15, Point3(360, 0,0)).loop()
# 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])
self.accept("arrow_up", self.increaseSeparation)
self.accept("arrow_down", self.decreaseSeparation)
def increaseSeparation(self):
self.separation = self.separation * 1.11111111;
print self.separation
self.filters.setCartoonInk(separation = self.separation)
def decreaseSeparation(self):
self.separation = self.separation * 0.90000000;
print self.separation
self.filters.setCartoonInk(separation = self.separation)
class GlowDemo(DirectObject):
def __init__(self):
base.disableMouse()
base.setBackgroundColor(0,0,0)
camera.setPos(0,-50,0)
# Check video card capabilities.
if (base.win.getGsg().getSupportsBasicShaders() == 0):
addTitle("Glow Filter: Video driver reports that shaders are not supported.")
return
# Use class 'CommonFilters' to enable a bloom filter.
# The brightness of a pixel is measured using a weighted average
# of R,G,B,A. We put all the weight on Alpha, meaning that for
# us, the framebuffer's alpha channel alpha controls bloom.
self.filters = CommonFilters(base.win, base.cam)
filterok = self.filters.setBloom(blend=(0,0,0,1), desat=-0.5, intensity=3.0, size="small")
if (filterok == False):
addTitle("Toon Shader: Video card not powerful enough to do image postprocessing")
return
self.glowSize=1
# Post the instructions
self.title = addTitle("Panda3D: Tutorial - Glow Filter")
self.inst1 = addInstructions(0.95,"ESC: Quit")
self.inst2 = addInstructions(0.90,"Space: Toggle Glow Filter Small/Med/Large/Off")
self.inst3 = addInstructions(0.85,"Enter: Toggle Running/Spinning")
self.inst4 = addInstructions(0.80,"V: View the render-to-texture results")
# load our model
self.tron=Actor()
self.tron.loadModel("samples/glow/tron")
self.tron.loadAnims({"running":"samples/glow/models/tron_anim"})
self.tron.reparentTo(render)
self.interval = self.tron.hprInterval(60,Point3(360,0,0))
self.interval.loop()
self.isRunning=False
# put some lighting on the model
dlight = DirectionalLight('dlight')
alight = AmbientLight('alight')
dlnp = render.attachNewNode(dlight)
alnp = render.attachNewNode(alight)
dlight.setColor(Vec4(1.0, 0.7, 0.2, 1))
alight.setColor(Vec4(0.2, 0.2, 0.2, 1))
dlnp.setHpr(0, -60, 0)
render.setLight(dlnp)
render.setLight(alnp)
# 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.camLens.setFov(100)
# event handling
self.accept("space", self.toggleGlow)
self.accept("enter", self.toggleDisplay)
self.accept("escape", sys.exit, [0])
def toggleGlow(self):
self.glowSize = self.glowSize + 1
if (self.glowSize == 4): self.glowSize = 0
self.filters.setBloom(blend=(0,0,0,1), desat=-0.5, intensity=3.0, size=self.glowSize)
def toggleDisplay(self):
self.isRunning=not(self.isRunning)
if not(self.isRunning):
camera.setPos(0,-50,0)
self.tron.stop("running")
self.tron.pose("running", 0)
self.interval.loop()
else:
camera.setPos(0,-170,3)
self.interval.finish()
self.tron.setHpr(0,0,0)
self.tron.loop("running")
class ToonMaker(DirectObject):
def __init__(self):
base.disableMouse()
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
# Post the instructions.
self.title = addTitle("Panda3D: Tutorial - Toon Shading with Normals-Based Inking")
self.inst1 = addInstructions(0.95,"ESC: Quit")
self.inst2 = addInstructions(0.90,"Up/Down: Increase/Decrease Line Thickness")
self.inst3 = addInstructions(0.85,"Left/Right: Decrease/Increase Line Darkness")
self.inst4 = addInstructions(0.80,"V: View the render-to-texture results")
# This shader's job is to render the model with discrete lighting
# levels. The lighting calculations built into the shader assume
# a single nonattenuating point light.
tempnode = NodePath(PandaNode("temp node"))
tempnode.setShader(Shader.load(os.path.join(PANDA_SHADER_PATH, \
"samples/cartoon/cartoon_lighting.sha")))
base.cam.node().setInitialState(tempnode.getState())
# This is the object that represents the single "light", as far
# the shader is concerned. It's not a real Panda3D LightNode, but
# the shader doesn't care about that.
light = render.attachNewNode("light")
light.setPos(30,-50,0)
# this call puts the light's nodepath into the render state.
# this enables the shader to access this light by name.
render.setShaderInput("light", light)
# The "normals buffer" will contain a picture of the model colorized
# so that the color of the model is a representation of the model's
# normal at that point.
normalsBuffer=base.win.makeTextureBuffer("normalsBuffer", 0, 0)
normalsBuffer.setClearColor(Vec4(0.5,0.5,0.5,1))
self.normalsBuffer=normalsBuffer
normalsCamera=base.makeCamera(normalsBuffer, lens=base.cam.node().getLens())
normalsCamera.node().setScene(render)
tempnode = NodePath(PandaNode("temp node"))
tempnode.setShader(Shader.load(os.path.join(PANDA_SHADER_PATH, \
"samples/cartoon/cartoon_normal.sha")))
normalsCamera.node().setInitialState(tempnode.getState())
#what we actually do to put edges on screen is apply them as a texture to
#a transparent screen-fitted card
drawnScene=normalsBuffer.getTextureCard()
drawnScene.setTransparency(1)
drawnScene.setColor(1,1,1,0)
drawnScene.reparentTo(render2d)
self.drawnScene = drawnScene
# this shader accepts, as input, the picture from the normals buffer.
# it compares each adjacent pixel, looking for discontinuities.
# wherever a discontinuity exists, it emits black ink.
self.separation = 0.001
self.cutoff = 0.3
inkGen=Shader.load(os.path.join(PANDA_SHADER_PATH, \
"samples/cartoon/cartoon_ink.sha"))
drawnScene.setShader(inkGen)
drawnScene.setShaderInput("separation", Vec4(self.separation,0,self.separation,0));
drawnScene.setShaderInput("cutoff", Vec4(self.cutoff,self.cutoff,self.cutoff,self.cutoff));
# 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")
# Load a dragon model and animate it.
self.character=Actor()
self.character.loadModel('models/samples/cartoon/nik_dragon')
self.character.reparentTo(render)
self.character.loadAnims({'win': 'models/samples/cartoon/nik_dragon'})
self.character.loop('win')
self.character.hprInterval(15, Point3(360, 0,0)).loop()
# 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)
self.accept("arrow_left", self.increaseCutoff)
self.accept("arrow_right", self.decreaseCutoff)
def increaseSeparation(self):
self.separation = self.separation * 1.11111111;
print self.separation
self.drawnScene.setShaderInput("separation", Vec4(self.separation,0,self.separation,0));
def decreaseSeparation(self):
self.separation = self.separation * 0.90000000;
print self.separation
self.drawnScene.setShaderInput("separation", Vec4(self.separation,0,self.separation,0));
def increaseCutoff(self):
self.cutoff = self.cutoff * 1.11111111;
print self.cutoff
self.drawnScene.setShaderInput("cutoff", Vec4(self.cutoff,self.cutoff,self.cutoff,self.cutoff));
def decreaseCutoff(self):
self.cutoff = self.cutoff * 0.90000000;
print self.cutoff
self.drawnScene.setShaderInput("cutoff", Vec4(self.cutoff,self.cutoff,self.cutoff,self.cutoff));
class GlowDemo(DirectObject):
def __init__(self):
base.disableMouse()
base.setBackgroundColor(0,0,0)
camera.setPos(0,-50,0)
# Check video card capabilities.
if (base.win.getGsg().getSupportsBasicShaders() == 0):
addTitle("Glow Filter: Video driver reports that shaders are not supported.")
return
# Post the instructions
self.title = addTitle("Panda3D: Tutorial - Glow Filter")
self.inst1 = addInstructions(0.95,"ESC: Quit")
self.inst2 = addInstructions(0.90,"Space: Toggle Glow Filter On/Off")
self.inst3 = addInstructions(0.85,"Enter: Toggle Running/Spinning")
self.inst4 = addInstructions(0.80,"V: View the render-to-texture results")
#create the shader that will determime what parts of the scene will glow
glowShader=Shader.load(os.path.join(PANDA_SHADER_PATH, \
"samples/glow/glow_shader.sha"))
# load our model
self.tron=Actor()
self.tron.loadModel("models/samples/glow/tron")
self.tron.loadAnims({"running":"models/samples/glow/tron_anim"})
self.tron.reparentTo(render)
self.interval = self.tron.hprInterval(60,Point3(360,0,0))
self.interval.loop()
self.isRunning=False
#put some lighting on the tron model
dlight = DirectionalLight('dlight')
alight = AmbientLight('alight')
dlnp = render.attachNewNode(dlight)
alnp = render.attachNewNode(alight)
dlight.setColor(Vec4(1.0, 0.7, 0.2, 1))
alight.setColor(Vec4(0.2, 0.2, 0.2, 1))
dlnp.setHpr(0, -60, 0)
render.setLight(dlnp)
render.setLight(alnp)
# create the glow buffer. This buffer renders like a normal scene,
# except that only the glowing materials should show up nonblack.
glowBuffer=base.win.makeTextureBuffer("Glow scene", 512, 512)
glowBuffer.setSort(-3)
glowBuffer.setClearColor(Vec4(0,0,0,1))
# We have to attach a camera to the glow buffer. The glow camera
# must have the same frustum as the main camera. As long as the aspect
# ratios match, the rest will take care of itself.
glowCamera=base.makeCamera(glowBuffer, lens=base.cam.node().getLens())
# Tell the glow camera to use the glow shader
tempnode = NodePath(PandaNode("temp node"))
tempnode.setShader(glowShader)
glowCamera.node().setInitialState(tempnode.getState())
# set up the pipeline: from glow scene to blur x to blur y to main window.
blurXBuffer=makeFilterBuffer(glowBuffer, "Blur X", -2, \
os.path.join(PANDA_SHADER_PATH, "samples/glow/glow_xblur.sha"))
blurYBuffer=makeFilterBuffer(blurXBuffer, "Blur Y", -1, \
os.path.join(PANDA_SHADER_PATH, "samples/glow/glow_yblur.sha"))
self.finalcard = blurYBuffer.getTextureCard()
self.finalcard.reparentTo(render2d)
self.finalcard.setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.MAdd))
# 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.toggleGlow)
self.accept("enter", self.toggleDisplay)
self.accept("escape", sys.exit, [0])
self.glowOn=True;
def toggleGlow(self):
if self.glowOn:
self.finalcard.reparentTo(hidden)
else:
self.finalcard.reparentTo(render2d)
self.glowOn= not(self.glowOn)
def toggleDisplay(self):
self.isRunning=not(self.isRunning)
if not(self.isRunning):
camera.setPos(0,-50,0)
self.tron.stop("running")
self.tron.pose("running", 0)
self.interval.loop()
else:
camera.setPos(0,-170,3)
self.interval.finish()
self.tron.setHpr(0,0,0)
self.tron.loop("running")
class GlowDemo(DirectObject):
def __init__(self):
base.disableMouse()
base.setBackgroundColor(0, 0, 0)
camera.setPos(0, -50, 0)
# Check video card capabilities.
if (base.win.getGsg().getSupportsBasicShaders() == 0):
addTitle(
"Glow Filter: Video driver reports that shaders are not supported."
)
return
# Use class 'CommonFilters' to enable a bloom filter.
# The brightness of a pixel is measured using a weighted average
# of R,G,B,A. We put all the weight on Alpha, meaning that for
# us, the framebuffer's alpha channel alpha controls bloom.
self.filters = CommonFilters(base.win, base.cam)
filterok = self.filters.setBloom(blend=(0, 0, 0, 1),
desat=-0.5,
intensity=3.0,
size="small")
if (filterok == False):
addTitle(
"Toon Shader: Video card not powerful enough to do image postprocessing"
)
return
self.glowSize = 1
# Post the instructions
self.title = addTitle("Panda3D: Tutorial - Glow Filter")
self.inst1 = addInstructions(0.95, "ESC: Quit")
self.inst2 = addInstructions(
0.90, "Space: Toggle Glow Filter Small/Med/Large/Off")
self.inst3 = addInstructions(0.85, "Enter: Toggle Running/Spinning")
self.inst4 = addInstructions(0.80,
"V: View the render-to-texture results")
# load our model
self.tron = Actor()
self.tron.loadModel("samples/glow/tron")
self.tron.loadAnims({"running": "samples/glow/models/tron_anim"})
self.tron.reparentTo(render)
self.interval = self.tron.hprInterval(60, Point3(360, 0, 0))
self.interval.loop()
self.isRunning = False
# put some lighting on the model
dlight = DirectionalLight('dlight')
alight = AmbientLight('alight')
dlnp = render.attachNewNode(dlight)
alnp = render.attachNewNode(alight)
dlight.setColor(Vec4(1.0, 0.7, 0.2, 1))
alight.setColor(Vec4(0.2, 0.2, 0.2, 1))
dlnp.setHpr(0, -60, 0)
render.setLight(dlnp)
render.setLight(alnp)
# 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.camLens.setFov(100)
# event handling
self.accept("space", self.toggleGlow)
self.accept("enter", self.toggleDisplay)
self.accept("escape", sys.exit, [0])
def toggleGlow(self):
self.glowSize = self.glowSize + 1
if (self.glowSize == 4): self.glowSize = 0
self.filters.setBloom(blend=(0, 0, 0, 1),
desat=-0.5,
intensity=3.0,
size=self.glowSize)
def toggleDisplay(self):
self.isRunning = not (self.isRunning)
if not (self.isRunning):
camera.setPos(0, -50, 0)
self.tron.stop("running")
self.tron.pose("running", 0)
self.interval.loop()
else:
camera.setPos(0, -170, 3)
self.interval.finish()
self.tron.setHpr(0, 0, 0)
self.tron.loop("running")
