def getTightBounds(self):
from panda3d.pandac import Point3
if self.getNumPaths() == 0:
return (Point3.Point3(0), Point3.Point3(0))
v1, v2 = self.getPath(0).getTightBounds()
for i in range(1, self.getNumPaths()):
v1x, v2x = self.getPath(i).getTightBounds()
v1 = Point3.Point3(min(v1[0], v1x[0]), min(v1[1], v1x[1]),
min(v1[2], v1x[2]))
v2 = Point3.Point3(max(v2[0], v2x[0]), max(v2[1], v2x[1]),
max(v2[2], v2x[2]))
return v1, v2
def loadObject(tex=None,
pos=Point2(0, 0),
depth=SPRITE_POS,
scale=1,
transparency=True):
obj = loader.loadModel("models/samples/asteroids/plane")
#Every object uses the plane model
obj.reparentTo(camera) #Everything is parented to the camera so
#that it faces the screen
obj.setPos(Point3(pos.getX(), depth, pos.getY())) #Set initial position
obj.setScale(scale) #Set initial scale
obj.setBin("unsorted", 0) #This tells Panda not to worry about the
#order this is drawn in. (it prevents an
#effect known as z-fighting)
obj.setDepthTest(False) #Tells panda not to check if something
#has already drawn in front of it
#(Everything in this game is at the same
#depth anyway)
if transparency:
obj.setTransparency(1) #All of our objects are trasnparent
if tex:
tex = loader.loadTexture("models/samples/asteroids/" + tex + ".png")
#Load the texture
obj.setTexture(tex, 1) #Set the texture
return obj
def toggleLightsUp(self):
global cube
self.LightsOn1 = not (self.LightsOn1)
if self.LightsOn1:
render.setLight(self.slnp1)
self.slnp1.setPos(cube, 10, 0, 400)
self.slnp1.lookAt(Point3(10, 0, 0))
else:
render.setLightOff(self.slnp1)
def toggleLightsSide(self):
global cube
self.LightsOn = not (self.LightsOn)
if self.LightsOn:
render.setLight(self.slnp)
self.slnp.setPos(cube, 10, -400, 0)
self.slnp.lookAt(Point3(10, 0, 0))
else:
render.setLightOff(self.slnp)
def setRelative(self, np, left, right, bottom, top):
"""setRelation(NodePath np, float left, float right,
float bottom, float top)
Sets the region to represnt the indicated rectangle, relative
to the given NodePath. It is assumed that np represents some
node parented within the render2d hierarchy.
"""
from panda3d.pandac import Point3
# Get the relative transform to the node.
mat = np.getMat(render2d)
# Use this matrix to transform the corners of the region.
ll = mat.xformPoint(Point3.Point3(left, 0, bottom))
ur = mat.xformPoint(Point3.Point3(right, 0, top))
# Set the frame to the transformed coordinates.
self.setFrame(ll[0], ur[0], ll[2], ur[2])
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 __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 __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 __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 __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 __init__(self):
# Post the instructions.
self.title = addTitle("Panda3D: Tutorial - Using Render-to-Texture")
self.inst1 = addInstructions(0.95,"ESC: Quit")
self.inst2 = addInstructions(0.90,"Up/Down: Zoom in/out on the Teapot")
self.inst3 = addInstructions(0.85,"Left/Right: Move teapot left/right")
self.inst4 = addInstructions(0.80,"V: View the render-to-texture results")
#we get a handle to the default window
mainWindow=base.win
#we now get buffer thats going to hold the texture of our new scene
altBuffer=mainWindow.makeTextureBuffer("hello", 256, 256)
#now we have to setup a new scene graph to make this scene
altRender=NodePath("new render")
#this takes care of setting up ther camera properly
self.altCam=base.makeCamera(altBuffer)
self.altCam.reparentTo(altRender)
self.altCam.setPos(0,-10,0)
#get the teapot and rotates it for a simple animation
self.teapot=loader.loadModel('models/teapot')
self.teapot.reparentTo(altRender)
self.teapot.setPos(0,0,-1)
self.teapot.hprInterval(1.5,Point3(360,360,360)).loop()
#put some lighting on the teapot
dlight = DirectionalLight('dlight')
alight = AmbientLight('alight')
dlnp = altRender.attachNewNode(dlight)
alnp = altRender.attachNewNode(alight)
dlight.setColor(Vec4(0.8, 0.8, 0.5, 1))
alight.setColor(Vec4(0.2, 0.2, 0.2, 1))
dlnp.setHpr(0, -60, 0)
altRender.setLight(dlnp)
altRender.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.setCardSize(1.0, 0.0)
# Create the tv-men. Each TV-man will display the
# offscreen-texture on his TV screen.
self.tvMen = []
self.makeTvMan(-5,30, 1,altBuffer.getTexture(),0.9)
self.makeTvMan( 5,30, 1,altBuffer.getTexture(),1.4)
self.makeTvMan( 0,23,-3,altBuffer.getTexture(),2.0)
self.makeTvMan(-5,20,-6,altBuffer.getTexture(),1.1)
self.makeTvMan( 5,18,-5,altBuffer.getTexture(),1.7)
self.accept("escape", sys.exit, [0])
self.accept("arrow_up", self.zoomIn)
self.accept("arrow_down", self.zoomOut)
self.accept("arrow_left", self.moveLeft)
self.accept("arrow_right", self.moveRight)
def getTightBounds(self):
from panda3d.pandac import Point3
v1 = Point3.Point3(0)
v2 = Point3.Point3(0)
self.calcTightBounds(v1, v2)
return v1, v2
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 __init__(self):
# Check video card capabilities.
if (base.win.getGsg().getSupportsBasicShaders() == 0):
addTitle("Normal Mapping: Video driver reports that shaders are not supported.")
return
# Post the instructions
self.title = addTitle("Panda3D: Tutorial - Normal Mapping (aka Bump Mapping)")
self.inst1 = addInstructions(0.95, "Press ESC to exit")
self.inst2 = addInstructions(0.90, "Move mouse to rotate camera")
self.inst3 = addInstructions(0.85, "Left mouse button: Move forwards")
self.inst4 = addInstructions(0.80, "Right mouse button: Move backwards")
self.inst5 = addInstructions(0.75, "Enter: Turn normal maps Off")
# Load the 'abstract room' model. This is a model of an
# empty room containing a pillar, a pyramid, and a bunch
# of exaggeratedly bumpy textures.
self.room = loader.loadModel( \
"models/samples/normal_mapping/abstractroom")
self.room.reparentTo(render)
# Make the mouse invisible, turn off normal mouse controls
base.disableMouse()
props = WindowProperties()
props.setCursorHidden(True)
base.win.requestProperties(props)
# Set the current viewing target
self.focus = Vec3(55,-55,20)
self.heading = 180
self.pitch = 0
self.mousex = 0
self.mousey = 0
self.last = 0
self.mousebtn = [0,0,0]
# Start the camera control task:
taskMgr.add(self.controlCamera, "camera-task")
self.accept("escape", sys.exit, [0])
self.accept("mouse1", self.setMouseBtn, [0, 1])
self.accept("mouse1-up", self.setMouseBtn, [0, 0])
self.accept("mouse2", self.setMouseBtn, [1, 1])
self.accept("mouse2-up", self.setMouseBtn, [1, 0])
self.accept("mouse3", self.setMouseBtn, [2, 1])
self.accept("mouse3-up", self.setMouseBtn, [2, 0])
self.accept("enter", self.toggleShader)
self.accept("j", self.rotateLight, [-1])
self.accept("k", self.rotateLight, [1])
self.accept("arrow_left", self.rotateCam, [-1])
self.accept("arrow_right", self.rotateCam, [1])
# Add a light to the scene.
self.lightpivot = render.attachNewNode("lightpivot")
self.lightpivot.setPos(0,0,25)
self.lightpivot.hprInterval(10,Point3(360,0,0)).loop()
plight = PointLight('plight')
plight.setColor(Vec4(1, 1, 1, 1))
plight.setAttenuation(Vec3(0.7,0.05,0))
plnp = self.lightpivot.attachNewNode(plight)
plnp.setPos(45, 0, 0)
self.room.setLight(plnp)
self.room.setShaderInput("light", plnp)
# Add an ambient light
alight = AmbientLight('alight')
alight.setColor(Vec4(0.2, 0.2, 0.2, 1))
alnp = render.attachNewNode(alight)
self.room.setLight(alnp)
# create a sphere to denote the light
sphere = loader.loadModel("models/samples/normal_mapping/sphere")
sphere.reparentTo(plnp)
# load and apply the shader. This is using panda's
# built-in shader generation capabilities to create the
# shader for you. However, if desired, you can supply
# the shader manually. Change this line of code to:
# self.room.setShader(Shader.load("bumpMapper.sha"))
self.room.setShaderAuto()
self.shaderenable = 1
square0 = makeSquare(-1, -1, -1, 1, -1, 1)
square1 = makeSquare(-1, 1, -1, 1, 1, 1)
square2 = makeSquare(-1, 1, 1, 1, -1, 1)
square3 = makeSquare(-1, 1, -1, 1, -1, -1)
square4 = makeSquare(-1, -1, -1, -1, 1, 1)
square5 = makeSquare(1, -1, -1, 1, 1, 1)
snode = GeomNode('square')
snode.addGeom(square0)
snode.addGeom(square1)
snode.addGeom(square2)
snode.addGeom(square3)
snode.addGeom(square4)
snode.addGeom(square5)
cube = render.attachNewNode(snode)
cube.hprInterval(1.5, Point3(360, 360, 360)).loop()
#OpenGl by default only draws "front faces" (polygons whose vertices are specified CCW).
cube.setTwoSided(True)
class MyTapper(DirectObject):
def __init__(self):
self.testTexture = loader.loadTexture("maps/envir_reeds.png")
self.accept("1", self.toggleTex)
self.accept("2", self.toggleLightsSide)
self.accept("3", self.toggleLightsUp)
self.LightsOn = False
self.LightsOn1 = False
slight = Spotlight('slight')
def SquarePos(i): return Point3((i%8) - 3.5, int(i/8) - 3.5, 0)
UNPICKABLE = [
'x-disc-visible', 'y-disc-visible', 'z-disc-visible', 'GridBack',
'unpickable'
]
# For linmath operations
X_AXIS = Vec3(1, 0, 0)
Y_AXIS = Vec3(0, 1, 0)
Z_AXIS = Vec3(0, 0, 1)
NEG_X_AXIS = Vec3(-1, 0, 0)
NEG_Y_AXIS = Vec3(0, -1, 0)
NEG_Z_AXIS = Vec3(0, 0, -1)
ZERO_VEC = ORIGIN = Vec3(0)
UNIT_VEC = Vec3(1)
ZERO_POINT = Point3(0)
DIRECT_FLASH_DURATION = 1.5
MANIPULATION_MOVE_DELAY = 0.65
Q_EPSILON = 1e-10
DIRECT_NO_MOD = 0
DIRECT_SHIFT_MOD = 1
DIRECT_CONTROL_MOD = 2
DIRECT_ALT_MOD = 4
SKIP_NONE = 0
SKIP_HIDDEN = 1
SKIP_BACKFACE = 2
