def start(self): self.resetCamera() self.loadPlanet() self.loadShips() self.loadPlayers() self.loadStars() self.loadHUD() light = DirectionalLight('light') light.setDirection(Vec3(-1, .1, -.5)) light.setColor(Vec4(.7, .6, .6, 0)) light.setSpecularColor(Vec4(.3, .5, .7, 0)) lightnode = render.attachNewNode(light) render.setLight(lightnode) render.setShaderAuto() render.setShaderInput('light', lightnode) render.setAntialias(AntialiasAttrib.MAuto) # TODO: it might be necessary here to check that the task # does not already exist in the task manager because the # unit tests at the moment call the start method # continuously. taskMgr.add(self.tick, "gameloop") self.time = self.getTime() self.registerListeners() self.state = Game.STATE_RUNNING # Load music self.music = loader.loadSfx('MVi - Ilwrath Are Watching.mp3') self.music.setLoop(True) self.music.setVolume(0.5) self.music.play()
def start(self): self.resetCamera() self.loadPlanet() self.loadShips() self.loadPlayers() self.loadStars() self.loadHUD() light = DirectionalLight('light') light.setDirection( Vec3(-1, .1, -.5) ) light.setColor( Vec4(.7, .6, .6, 0) ) light.setSpecularColor( Vec4(.3, .5, .7, 0) ) lightnode = render.attachNewNode(light) render.setLight(lightnode) render.setShaderAuto() render.setShaderInput('light', lightnode) render.setAntialias(AntialiasAttrib.MAuto) # TODO: it might be necessary here to check that the task # does not already exist in the task manager because the # unit tests at the moment call the start method # continuously. taskMgr.add(self.tick, "gameloop") self.time = self.getTime() self.registerListeners() self.state = Game.STATE_RUNNING # Load music self.music = loader.loadSfx('MVi - Ilwrath Are Watching.mp3') self.music.setLoop(True) self.music.setVolume(0.5) self.music.play()
def create( self, lightAttrib ): #create directional light directionalLight = DirectionalLight( self.name ) directionalLight.setDirection( self.direction ) directionalLight.setColor( self.color * self.intensity ) directionalLight.setSpecularColor( Vec4(0.5,0.5,0.5,0.5) ) lightAttrib = lightAttrib.addLight( directionalLight ) #attach lights to scene graph render.attachNewNode( directionalLight ) self.directionalLight = directionalLight return lightAttrib
def create(self, lightAttrib): #create directional light directionalLight = DirectionalLight(self.name) directionalLight.setDirection(self.direction) directionalLight.setColor(self.color * self.intensity) directionalLight.setSpecularColor(Vec4(0.5, 0.5, 0.5, 0.5)) lightAttrib = lightAttrib.addLight(directionalLight) #attach lights to scene graph render.attachNewNode(directionalLight) self.directionalLight = directionalLight return 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