def create( self ):
lightAttrib = LightAttrib.makeAllOff()
#create ambient light
ambientLight = AmbientLight( "ambientLight" )
ambientLight.setColor( self.ambientColor )
lightAttrib = lightAttrib.addLight( ambientLight )
render.attachNewNode( ambientLight.upcastToPandaNode() )
self.ambientLight = ambientLight
#default light settings
"""colors = [ Vec4(1,0,0,0), Vec4(0,1,0,0), Vec4(0,0,1,0), Vec4(1,1,0,0) ]
directions = [ Vec3(1,0,0), Vec3(0,1,0), Vec3(-1,0,0), Vec3(0,-1,0) ]
intensities = [ 3.0, 0.1, 3.0, 0.1 ]"""
colors = [ Vec4(1,1,1,0), Vec4(0,1,0,0), Vec4(0,0,1,0), Vec4(1,1,0,0) ]
# basic 3+1 point lighting
directions = [ Vec3(0,1,-0.2), Vec3(0,1,0), Vec3(-1,0.3,0), Vec3(0,-1,0) ]
intensities = [ 1.0, 0.0, 0.5, 0.0 ]
#add directional lights
self.directionalLights = []
for i in range(4):
self.directionalLights.append( ShaderDirectionalLight( colors[i], directions[i], intensities[i], i ) )
lightAttrib = self.directionalLights[i].create( lightAttrib )
#set light attributes
render.node().setAttrib( lightAttrib )
def setupLights(self):
lAttrib = LightAttrib.makeAllOff()
ambientLight = AmbientLight( "ambientLight" )
ambientLight.setColor( Vec4(.4, .4, .35, 1) )
lAttrib = lAttrib.addLight( ambientLight )
directionalLight = DirectionalLight( "directionalLight" )
directionalLight.setDirection( Vec3( 0, 8, -2.5 ) )
directionalLight.setColor( Vec4( 0.9, 0.8, 0.9, 1 ) )
lAttrib = lAttrib.addLight( directionalLight )
render.attachNewNode( directionalLight.upcastToPandaNode() )
render.attachNewNode( ambientLight.upcastToPandaNode() )
render.node().setAttrib( lAttrib )
def setupLights(self): lAttrib = LightAttrib.makeAllOff() ambientLight = AmbientLight( "ambientLight" ) ambientLight.setColor( Vec4(.6, .6, .55, 1) ) lAttrib = lAttrib.addLight( ambientLight ) directionalLight = DirectionalLight( "directionalLight" ) directionalLight.setDirection( Vec3( 0, 8, -2.5 ) ) directionalLight.setColor( Vec4( 0.9, 0.8, 0.9, 1 ) ) lAttrib = lAttrib.addLight( directionalLight ) #set lighting on teapot so steam doesn't get affected #self.t.attachNewNode( directionalLight.upcastToPandaNode() ) self.t.attachNewNode( directionalLight ) #self.t.attachNewNode( ambientLight.upcastToPandaNode() ) self.t.attachNewNode( ambientLight) self.t.node().setAttrib( lAttrib )
def create(self):
lightAttrib = LightAttrib.makeAllOff()
#create ambient light
ambientLight = AmbientLight("ambientLight")
ambientLight.setColor(self.ambientColor)
lightAttrib = lightAttrib.addLight(ambientLight)
render.attachNewNode(ambientLight.upcastToPandaNode())
self.ambientLight = ambientLight
#default light settings
"""colors = [ Vec4(1,0,0,0), Vec4(0,1,0,0), Vec4(0,0,1,0), Vec4(1,1,0,0) ]
directions = [ Vec3(1,0,0), Vec3(0,1,0), Vec3(-1,0,0), Vec3(0,-1,0) ]
intensities = [ 3.0, 0.1, 3.0, 0.1 ]"""
colors = [
Vec4(1, 1, 1, 0),
Vec4(0, 1, 0, 0),
Vec4(0, 0, 1, 0),
Vec4(1, 1, 0, 0)
]
# basic 3+1 point lighting
directions = [
Vec3(0, 1, -0.2),
Vec3(0, 1, 0),
Vec3(-1, 0.3, 0),
Vec3(0, -1, 0)
]
intensities = [1.0, 0.0, 0.5, 0.0]
#add directional lights
self.directionalLights = []
for i in range(4):
self.directionalLights.append(
ShaderDirectionalLight(colors[i], directions[i],
intensities[i], i))
lightAttrib = self.directionalLights[i].create(lightAttrib)
#set light attributes
render.node().setAttrib(lightAttrib)
def __init_kepler_scene(self):
self.hud_count_down = 0
self.alpha = 0.
self.beta = 0.
self._set_title("Hugomatic 3D sim")
self.alpha_rot_speed = 0.
self.beta_rot_speed = 0.
#This code puts the standard title and instruction text on screen
self.title = OnscreenText(text="Kepler simulation tool 1",
style=1, fg=(1,1,1,1),
pos=(0.7,-0.95), scale = .07, font = font)
self.instructions = OnscreenText(text="alpha: 0.000\nbeta: 0.000",
pos = (-1.3, .95), fg=(1,1,1,1), font = font,
align = TextNode.ALeft, scale = .05)
if DISABLE_MOUSE:
base.disableMouse() #Disable mouse-based camera control
camera.setPosHpr(-10, -10, 25, 0, -90, 0) #Place the camera
#Load the maze and place it in the scene
self.maze = loader.loadModel("models/maze")
process_model(self.maze)
self.maze.reparentTo(render)
#Most times, you want collisions to be tested against invisible geometry
#rather than every polygon. This is because testing against every polygon
#in the scene is usually too slow. You can have simplified or approximate
#geometry for the solids and still get good results.
#
#Sometimes you'll want to create and position your own collision solids in
#code, but it's often easier to have them built automatically. This can be
#done by adding special tags into an egg file. Check maze.egg and ball.egg
#and look for lines starting with <Collide>. The part is brackets tells
#Panda exactly what to do. Polyset means to use the polygons in that group
#as solids, while Sphere tells panda to make a collision sphere around them
#Keep means to keep the polygons in the group as visable geometry (good
#for the ball, not for the triggers), and descend means to make sure that
#the settings are applied to any subgroups.
#
#Once we have the collision tags in the models, we can get to them using
#NodePath's find command
#Find the collision node named wall_collide
self.walls = self.maze.find("**/wall_collide")
#Collision objects are sorted using BitMasks. BitMasks are ordinary numbers
#with extra methods for working with them as binary bits. Every collision
#solid has both a from mask and an into mask. Before Panda tests two
#objects, it checks to make sure that the from and into collision masks
#have at least one bit in common. That way things that shouldn't interact
#won't. Normal model nodes have collision masks as well. By default they
#are set to bit 20. If you want to collide against actual visible polygons,
#set a from collide mask to include bit 20
#
#For this example, we will make everything we want the ball to collide with
#include bit 0
self.walls.node().setIntoCollideMask(BitMask32.bit(0))
#CollisionNodes are usually invisible but can be shown. Uncomment the next
#line to see the collision walls
if VISIBLE_WALLS:
self.walls.show()
#Ground_collide is a single polygon on the same plane as the ground in the
#maze. We will use a ray to collide with it so that we will know exactly
#what height to put the ball at every frame. Since this is not something
#that we want the ball itself to collide with, it has a different
#bitmask.
self.mazeGround = self.maze.find("**/ground_collide")
self.mazeGround.node().setIntoCollideMask(BitMask32.bit(1))
#Load the ball and attach it to the scene
#It is on a root dummy node so that we can rotate the ball itself without
#rotating the ray that will be attached to it
self.ballRoot = render.attachNewNode("ballRoot")
self.ball = loader.loadModel("models/ball")
self.ball.reparentTo(self.ballRoot)
#Find the collison sphere for the ball which was created in the egg file
#Notice that it has a from collision mask of bit 0, and an into collison
#mask of no bits. This means that the ball can only cause collisions, not
#be collided into
self.ballSphere = self.ball.find("**/ball")
self.ballSphere.node().setFromCollideMask(BitMask32.bit(0))
self.ballSphere.node().setIntoCollideMask(BitMask32.allOff())
#No we create a ray to start above the ball and cast down. This is to
#Determine the height the ball should be at and the angle the floor is
#tilting. We could have used the sphere around the ball itself, but it
#would not be as reliable
self.ballGroundRay = CollisionRay() #Create the ray
self.ballGroundRay.setOrigin(0,0,10) #Set its origin
self.ballGroundRay.setDirection(0,0,-1) #And its direction
#Collision solids go in CollisionNode
self.ballGroundCol = CollisionNode('groundRay') #Create and name the node
self.ballGroundCol.addSolid(self.ballGroundRay) #Add the ray
self.ballGroundCol.setFromCollideMask(BitMask32.bit(1)) #Set its bitmasks
self.ballGroundCol.setIntoCollideMask(BitMask32.allOff())
#Attach the node to the ballRoot so that the ray is relative to the ball
#(it will always be 10 feet over the ball and point down)
self.ballGroundColNp = self.ballRoot.attachNewNode(self.ballGroundCol)
#Uncomment this line to see the ray
self.ballGroundColNp.show()
#Finally, we create a CollisionTraverser. CollisionTraversers are what
#do the job of calculating collisions
self.cTrav = CollisionTraverser()
#Collision traverservs tell collision handlers about collisions, and then
#the handler decides what to do with the information. We are using a
#CollisionHandlerQueue, which simply creates a list of all of the
#collisions in a given pass. There are more sophisticated handlers like
#one that sends events and another that tries to keep collided objects
#apart, but the results are often better with a simple queue
self.cHandler = CollisionHandlerQueue()
#Now we add the collision nodes that can create a collision to the
#traverser. The traverser will compare these to all others nodes in the
#scene. There is a limit of 32 CollisionNodes per traverser
#We add the collider, and the handler to use as a pair
self.cTrav.addCollider(self.ballSphere, self.cHandler)
self.cTrav.addCollider(self.ballGroundColNp, self.cHandler)
#Collision traversers have a built in tool to help visualize collisions.
#Uncomment the next line to see it.
if VISIBLE_WALLS:
self.cTrav.showCollisions(render)
#This section deals with lighting for the ball. Only the ball was lit
#because the maze has static lighting pregenerated by the modeler
lAttrib = LightAttrib.makeAllOff()
ambientLight = AmbientLight( "ambientLight" )
ambientLight.setColor( Vec4(.55, .55, .55, 1) )
lAttrib = lAttrib.addLight( ambientLight )
directionalLight = DirectionalLight( "directionalLight" )
directionalLight.setDirection( Vec3( 0, 0, -1 ) )
directionalLight.setColor( Vec4( 0.375, 0.375, 0.375, 1 ) )
directionalLight.setSpecularColor(Vec4(1,1,1,1))
lAttrib = lAttrib.addLight( directionalLight )
self.ballRoot.node().setAttrib( lAttrib )
#This section deals with adding a specular highlight to the ball to make
#it look shiny
m = Material()
m.setSpecular(Vec4(1,1,1,1))
m.setShininess(96)
self.ball.setMaterial(m, 1)
#Finally, we call start for more initialization
# self.start()
#def start(self):
#The maze model also has a locator in it for where to start the ball
#To access it we use the find command
startPos = (0,0,0)#= self.maze.find("**/start").getPos()
self.ballRoot.setPos(startPos) #Set the ball in the starting position
self.ballV = Vec3(0,0,0) #Initial velocity is 0
self.accelV = Vec3(0,0,0) #Initial acceleration is 0
#For a traverser to actually do collisions, you need to call
#traverser.traverse() on a part of the scene. Fortunatly, base has a
#task that does this for the entire scene once a frame. This sets up our
#traverser as the one to be called automatically
base.cTrav = self.cTrav