416 lines
17 KiB
Python
416 lines
17 KiB
Python
#!/usr/bin/env python
|
|
|
|
# Author: Josh Yelon
|
|
# Date: 7/11/2005
|
|
#
|
|
# See the associated manual page for an explanation.
|
|
#
|
|
from direct.showbase.ShowBase import ShowBase
|
|
from panda3d.core import FrameBufferProperties, WindowProperties
|
|
from panda3d.core import GraphicsPipe, GraphicsOutput
|
|
from panda3d.core import Filename, Texture, Shader
|
|
from panda3d.core import RenderState, CardMaker
|
|
from panda3d.core import PandaNode, TextNode, NodePath
|
|
from panda3d.core import RenderAttrib, AlphaTestAttrib, ColorBlendAttrib
|
|
from panda3d.core import CullFaceAttrib, DepthTestAttrib, DepthWriteAttrib
|
|
from panda3d.core import LPoint3, LVector3, BitMask32
|
|
from direct.gui.OnscreenText import OnscreenText
|
|
from direct.showbase.DirectObject import DirectObject
|
|
from direct.interval.MetaInterval import Sequence
|
|
from direct.task.Task import Task
|
|
from direct.actor.Actor import Actor
|
|
import sys
|
|
import os
|
|
import random
|
|
|
|
# Function to put instructions on the screen.
|
|
def addInstructions(pos, msg):
|
|
return OnscreenText(text=msg, style=1, fg=(1, 1, 1, 1), shadow=(0, 0, 0, 1),
|
|
parent=base.a2dTopLeft, align=TextNode.ALeft,
|
|
pos=(0.08, -pos - 0.04), scale=.05)
|
|
|
|
# Function to put title on the screen.
|
|
def addTitle(text):
|
|
return OnscreenText(text=text, style=1, pos=(-0.1, 0.09), scale=.08,
|
|
parent=base.a2dBottomRight, align=TextNode.ARight,
|
|
fg=(1, 1, 1, 1), shadow=(0, 0, 0, 1))
|
|
|
|
|
|
class FireflyDemo(ShowBase):
|
|
def __init__(self):
|
|
# Initialize the ShowBase class from which we inherit, which will
|
|
# create a window and set up everything we need for rendering into it.
|
|
ShowBase.__init__(self)
|
|
self.setBackgroundColor((0, 0, 0, 0))
|
|
|
|
# Preliminary capabilities check.
|
|
|
|
if not self.win.getGsg().getSupportsBasicShaders():
|
|
self.t = addTitle("Firefly Demo: Video driver reports that Cg "
|
|
"shaders are not supported.")
|
|
return
|
|
if not self.win.getGsg().getSupportsDepthTexture():
|
|
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 is None or self.lightbuffer is 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.
|
|
|
|
self.cam.node().getLens().setNear(50.0)
|
|
self.cam.node().getLens().setFar(500.0)
|
|
lens = self.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 = self.makeCamera(self.modelbuffer,
|
|
lens=lens, scene=render, mask=self.modelMask)
|
|
self.lightcam = self.makeCamera(self.lightbuffer,
|
|
lens=lens, scene=render, mask=self.lightMask)
|
|
self.plaincam = self.makeCamera(self.lightbuffer,
|
|
lens=lens, scene=render, mask=self.plainMask)
|
|
|
|
# Panda's main camera is not used.
|
|
|
|
self.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)
|
|
self.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()
|
|
self.cam.node().getDisplayRegion(0).disableClears()
|
|
self.cam2d.node().getDisplayRegion(0).disableClears()
|
|
self.modelbuffer.disableClears()
|
|
self.win.disableClears()
|
|
|
|
self.modelbuffer.setClearColorActive(1)
|
|
self.modelbuffer.setClearDepthActive(1)
|
|
self.lightbuffer.setClearColorActive(1)
|
|
self.lightbuffer.setClearColor((0, 0, 0, 1))
|
|
|
|
# Miscellaneous stuff.
|
|
|
|
self.disableMouse()
|
|
self.camera.setPos(-9.112, -211.077, 46.951)
|
|
self.camera.setHpr(0, -7.5, 2.4)
|
|
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 = self.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(loader.loadShader("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(loader.loadShader("light.sha"))
|
|
tempnode.setShaderInput("texnormal", self.texNormal)
|
|
tempnode.setShaderInput("texalbedo", self.texAlbedo)
|
|
tempnode.setShaderInput("texdepth", self.texDepth)
|
|
tempnode.setShaderInput("proj", (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/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.
|
|
# This is a big model, so we load it asynchronously while showing a
|
|
# load text. We do this by passing in a callback function.
|
|
self.loading = addTitle("Loading models...")
|
|
|
|
self.forest = NodePath(PandaNode("Forest Root"))
|
|
self.forest.reparentTo(render)
|
|
self.forest.hide(BitMask32(self.lightMask | self.plainMask))
|
|
loader.loadModel([
|
|
"models/background",
|
|
"models/foliage01",
|
|
"models/foliage02",
|
|
"models/foliage03",
|
|
"models/foliage04",
|
|
"models/foliage05",
|
|
"models/foliage06",
|
|
"models/foliage07",
|
|
"models/foliage08",
|
|
"models/foliage09"],
|
|
callback=self.finishLoading)
|
|
|
|
# Cause the final results to be rendered into the main window on a
|
|
# card.
|
|
|
|
self.card = self.lightbuffer.getTextureCard()
|
|
self.card.setTexture(self.texFinal)
|
|
self.card.reparentTo(render2d)
|
|
|
|
# Panda contains a built-in viewer that lets you view the results of
|
|
# your render-to-texture operations. This code configures the viewer.
|
|
|
|
self.bufferViewer.setPosition("llcorner")
|
|
self.bufferViewer.setCardSize(0, 0.40)
|
|
self.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("misc/sphere")
|
|
|
|
# Create the firefly model, a fuzzy dot
|
|
dotSize = 1.0
|
|
cm = CardMaker("firefly")
|
|
cm.setFrame(-dotSize, dotSize, -dotSize, dotSize)
|
|
self.firefly = NodePath(cm.generate())
|
|
self.firefly.setTexture(loader.loadTexture("models/firefly.png"))
|
|
self.firefly.setAttrib(ColorBlendAttrib.make(ColorBlendAttrib.M_add,
|
|
ColorBlendAttrib.O_incoming_alpha, ColorBlendAttrib.O_one))
|
|
|
|
# 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)
|
|
|
|
def finishLoading(self, models):
|
|
# This function is used as callback to loader.loadModel, and called
|
|
# when all of the models have finished loading.
|
|
|
|
# Attach the models to the scene graph.
|
|
for model in models:
|
|
model.reparentTo(self.forest)
|
|
|
|
# Show the instructions.
|
|
self.loading.destroy()
|
|
self.title = addTitle("Panda3D: Tutorial - Fireflies using Deferred Shading")
|
|
self.inst1 = addInstructions(0.06, "ESC: Quit")
|
|
self.inst2 = addInstructions(0.12, "Up/Down: More / Fewer Fireflies (Count: unknown)")
|
|
self.inst3 = addInstructions(0.18, "Right/Left: Bigger / Smaller Fireflies (Radius: unknown)")
|
|
self.inst4 = addInstructions(0.24, "V: View the render-to-texture results")
|
|
|
|
self.setFireflySize(25.0)
|
|
while len(self.fireflies) < 5:
|
|
self.addFirefly()
|
|
self.updateReadout()
|
|
|
|
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(True)
|
|
props.setRgbaBits(8, 8, 8, 8)
|
|
props.setDepthBits(1)
|
|
props.setAuxRgba(auxrgba)
|
|
return self.graphicsEngine.makeOutput(
|
|
self.pipe, "model buffer", -2,
|
|
props, winprops,
|
|
GraphicsPipe.BFSizeTrackHost | GraphicsPipe.BFCanBindEvery |
|
|
GraphicsPipe.BFRttCumulative | GraphicsPipe.BFRefuseWindow,
|
|
self.win.getGsg(), self.win)
|
|
|
|
def addFirefly(self):
|
|
pos1 = LPoint3(random.uniform(-50, 50), random.uniform(-100, 150), random.uniform(-10, 80))
|
|
dir = LVector3(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 = 1.0
|
|
color_g = random.uniform(0.8, 1.0)
|
|
color_b = min(color_g, random.uniform(0.5, 1.0))
|
|
fly.setColor(color_r, color_g, color_b, 1.0)
|
|
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),
|
|
LPoint3(0.2, 0.2, 0.2), LPoint3(0.2, 0.2, 0.2))
|
|
si2 = fly.scaleInterval(random.uniform(1.5, 0.8),
|
|
LPoint3(1.0, 1.0, 1.0), LPoint3(0.2, 0.2, 0.2))
|
|
si3 = fly.scaleInterval(random.uniform(1.0, 2.0),
|
|
LPoint3(0.2, 0.2, 0.2), LPoint3(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.firefly.instanceTo(dot)
|
|
glow.setScale(self.fireflysize * 1.1)
|
|
glow.hide(BitMask32(self.modelMask | self.plainMask))
|
|
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.12,
|
|
"Up/Down: More / Fewer Fireflies (Currently: %d)" % len(self.fireflies))
|
|
self.inst3.destroy()
|
|
self.inst3 = addInstructions(0.18,
|
|
"Right/Left: Bigger / Smaller Fireflies (Radius: %d ft)" % self.fireflysize)
|
|
|
|
def toggleCards(self):
|
|
self.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 (self.bufferViewer.isEnabled()):
|
|
self.modelbuffer.setClearColorActive(True)
|
|
else:
|
|
self.modelbuffer.setClearColorActive(False)
|
|
|
|
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
|
|
|
|
demo = FireflyDemo()
|
|
demo.run()
|