def _startMoveIval(self, entranceId, startT): self._stopMoveIval() unitVecs = (PM.Vec3(1, 0, 0), PM.Vec3(0, 1, 0), PM.Vec3(-1, 0, 0), PM.Vec3(0, -1, 0)) machineDistance = 4 entranceDistance = 60 startPos = unitVecs[entranceId] * entranceDistance endPos = unitVecs[entranceId] * machineDistance walkDur = (endPos - startPos ).length() / GameConsts.CogSettings.CogWalkSpeed.get() sceneRoot = self.getGame().getSceneRoot() moveIval = IG.Sequence( IG.Func(self.reparentTo, sceneRoot), IG.Func(self.setPos, startPos), IG.Func(self.lookAt, sceneRoot), IG.Func(self.loop, 'walk'), IG.LerpPosInterval(self, walkDur, endPos, startPos=startPos)) interactIval = IG.Sequence( IG.Func(self.loop, 'neutral'), IG.Wait(GameConsts.CogSettings.CogMachineInteractDuration.get())) flyIval = IG.Sequence( IG.Func(self.pose, 'landing', 0), IG.LerpPosInterval(self, GameConsts.CogSettings.CogFlyAwayDuration.get(), self._getFlyAwayDest, blendType='easeIn')) self._moveIval = IG.Sequence(moveIval, interactIval, flyIval) self._moveIval.start(globalClock.getFrameTime() - startT)
def Cone(radius=1.0, height=2.0, numSegs=16, degrees=360, axis=pm.Vec3(0, 0, 1), origin=pm.Point3(0, 0, 0)): """Return a geom node representing a cone.""" # Create vetex data format gvf = pm.GeomVertexFormat.getV3n3() gvd = pm.GeomVertexData('vertexData', gvf, pm.Geom.UHStatic) # Create vetex writers for each type of data we are going to store gvwV = pm.GeomVertexWriter(gvd, 'vertex') gvwN = pm.GeomVertexWriter(gvd, 'normal') # Get the points for an arc axis2 = pm.Vec3(axis) axis2.normalize() offset = axis2 * height / 2.0 points = GetPointsForArc(degrees, numSegs, True) for i in range(len(points) - 1): # Rotate the points around the desired axis p1 = pm.Point3(points[i][0], points[i][1], 0) * radius p1 = RotatePoint3(p1, pm.Vec3(0, 0, 1), axis) - origin p2 = pm.Point3(points[i + 1][0], points[i + 1][1], 0) * radius p2 = RotatePoint3(p2, pm.Vec3(0, 0, 1), axis) - origin cross = (p2 - axis).cross(p1 - axis) cross.normalize() # Facet gvwV.addData3f(p1 - offset) gvwV.addData3f(offset - origin) gvwV.addData3f(p2 - offset) for i in range(3): gvwN.addData3f(cross) # Base gvwV.addData3f(p2 - offset) gvwV.addData3f(-offset - origin) gvwV.addData3f(p1 - offset) for i in range(3): gvwN.addData3f(-axis) geom = pm.Geom(gvd) for i in range(0, gvwV.getWriteRow(), 3): # Create and add triangle geom.addPrimitive(GetGeomTriangle(i, i + 1, i + 2)) # Return the cone GeomNode geomNode = pm.GeomNode('cone') geomNode.addGeom(geom) return geomNode
def __init__( self, *args, **kwargs ): Base.__init__( self, *args, **kwargs ) self._snp = False self._snpAmt = 0.5 # Create x, y, z and camera normal axes self.axes.append( self.CreateArrow( pm.Vec3(1, 0, 0), RED ) ) self.axes.append( self.CreateArrow( pm.Vec3(0, 1, 0), GREEN ) ) self.axes.append( self.CreateArrow( pm.Vec3(0, 0, 1), BLUE ) ) #self.axes.append( self.CreateArrow( pm.Vec3(1, 1, 0), YELLOW ) ) #self.axes.append( self.CreateArrow( pm.Vec3(-2, 1, 0), TEAL ) ) self.axes.append( self.CreateSquare( pm.Vec3(0, 0, 0), TEAL ) )
def OnNodeMouse1Down( self, planar, collEntry ): Base.OnNodeMouse1Down( self, planar, collEntry ) self._s = pm.Vec3( 0 ) # If in planar mode, clear the billboard effect on the center square # and make it face the selected axis axis = self.GetSelectedAxis() if self.planar and not axis.planar: self.square.clearBillboard() self.square.lookAt( self, pm.Point3( axis.vector ) ) else: self.square.setHpr( pm.Vec3(0, 0, 0) ) self.square.setBillboardPointEye()
def _Snap( self, vec ): if vec.length(): snpLen = ROUND_TO( vec.length(), self._snpAmt ) snapVec = vec / vec.length() * snpLen return snapVec else: return pm.Vec3( 0 )
def privGotSpec(self, levelSpec): DistCogdoLevelGame.privGotSpec(self, levelSpec) levelMgr = self.getEntity(LevelConstants.LevelMgrEntId) self.endVault = levelMgr.geom self.endVault.reparentTo(self.geomRoot) self.endVault.findAllMatches('**/MagnetArms').detach() self.endVault.findAllMatches('**/Safes').detach() self.endVault.findAllMatches('**/MagnetControlsAll').detach() cn = self.endVault.find('**/wallsCollision').node() cn.setIntoCollideMask(OTPGlobals.WallBitmask | ToontownGlobals.PieBitmask | PM.BitMask32.lowerOn(3) << 21) walls = self.endVault.find('**/RollUpFrameCillison') walls.detachNode() self.evWalls = self.replaceCollisionPolysWithPlanes(walls) self.evWalls.reparentTo(self.endVault) self.evWalls.stash() floor = self.endVault.find('**/EndVaultFloorCollision') floor.detachNode() self.evFloor = self.replaceCollisionPolysWithPlanes(floor) self.evFloor.reparentTo(self.endVault) self.evFloor.setName('floor') plane = PM.CollisionPlane( PM.Plane(PM.Vec3(0, 0, 1), PM.Point3(0, 0, -50))) planeNode = PM.CollisionNode('dropPlane') planeNode.addSolid(plane) planeNode.setCollideMask(ToontownGlobals.PieBitmask) self.geomRoot.attachNewNode(planeNode)
def Frame(self, nps): # Get a list of bounding spheres for each NodePath in world space. allBnds = [] allCntr = pm.Vec3() for np in nps: bnds = np.getBounds() if bnds.isInfinite(): continue mat = np.getParent().getMat(self.rootNp) bnds.xform(mat) allBnds.append(bnds) allCntr += bnds.getCenter() # Now create a bounding sphere at the center point of all the # NodePaths and extend it to encapsulate each one. bnds = pm.BoundingSphere(pm.Point3(allCntr / len(nps)), 0) for bnd in allBnds: bnds.extendBy(bnd) # Move the camera and the target the the bounding sphere's center. self.target.setPos(bnds.getCenter()) self.setPos(bnds.getCenter()) # Now move the camera back so the view accomodates all NodePaths. # Default the bounding radius to something reasonable if the object # has no size. fov = self.GetLens().getFov() radius = bnds.getRadius() or 0.5 dist = radius / math.tan(math.radians(min(fov[0], fov[1]) * 0.5)) self.setY(self, -dist)
def SnapPoint(pnt, amt): """ Return a new point based on the indicated point but snapped to the nearest indicated amount. """ return pm.Vec3(ROUND_TO(pnt[0], amt), ROUND_TO(pnt[1], amt), ROUND_TO(pnt[2], amt))
def __init__(self, *args, **kwargs): Base.__init__(self, *args, **kwargs) self.AddAttributes(Attr('Half Extents', pm.Vec3, BBS.getHalfExtentsWithMargin, initDefault=pm.Vec3(0.5, 0.5, 0.5)), parent='BulletBoxShape')
def __init__(self, *args, **kwargs): Base.__init__(self, *args, **kwargs) self.AddAttributes(Attr('Normal', pm.Vec3, initDefault=pm.Vec3(0, 0, 1)), Attr('Constant', int, initDefault=0), parent='BulletBoxShape')
def __init__(self, *args, **kwargs): PrimitiveNPO.__init__(self, *args, **kwargs) self._radius = 1 self._height = 2 self._numSegs = 16 self._degrees = 360 self._axis = pm.Vec3(0, 0, 1) self._origin = pm.Point3(0, 0, 0)
def RotatePoint3(p, v1, v2): """ Return the input point rotated around the cross of the input vectors. The amount to rotate is the angle between the two vectors. """ v1 = pm.Vec3(v1) v2 = pm.Vec3(v2) v1.normalize() v2.normalize() cross = v1.cross(v2) cross.normalize() if cross.length(): a = v1.angleDeg(v2) quat = pm.Quat() quat.setFromAxisAngle(a, cross) p = quat.xform(p) return p
def Circle(radius=1.0, numSegs=16, axis=pm.Vec3(1, 0, 0), thickness=1.0, origin=pm.Point3(0, 0, 0)): # Create line segments ls = pm.LineSegs() ls.setThickness(thickness) # Get the points for an arc for p in GetPointsForArc(360, numSegs): # Draw the point rotated around the desired axis p = pm.Point3(p[0], p[1], 0) - origin p = RotatePoint3(p, pm.Vec3(0, 0, 1), pm.Vec3(axis)) ls.drawTo(p * radius) return ls.create()
def __init__(self, pos=None, color=(0.6, 0.8, 0.5, 1), scale=12, h=8, size=33, trees=0.7): # Initialise primary NodePath which everything else is parented to if pos is None: pos = P.Vec3(0, 0, 0) self.pos = pos self.prime = P.NodePath('Terrain primary NodePath') self.prime.setPos(self.pos) # Create terrain models (rendering and collision) self.tnp, self.collnp = makeTerrain(size=size, h=h) self.tnp.reparentTo(self.prime) self.tnp.setColor(*color) self.tnp.setScale(scale) # Shift the collision terrain a bit so rays from trees hit self.collnp.setPos(self.collnp, .0001, .0001, 0) self.collnp.setCollideMask(C.floorMASK) # All trees in the scene are parented to one NodePath for flattening self.trees = self.prime.attachNewNode(P.PandaNode('trees')) self.treesColl = self.prime.attachNewNode(P.CollisionNode('treesColl')) self.treesColl.node().setIntoCollideMask(offMASK) self.treesColl.node().setFromCollideMask(obstacleMASK) #self.treesColl.show() vehicleCTrav.addCollider(self.treesColl, obstacleHandler) # Initialise trees img = greenNoise(imgSize=(size, size), scale=0.25) for x in range(0, size - 1): for y in range(0, size - 1): if img.getGreen(x, y) > trees: treepos = P.Vec3(x * scale + 0.5 * scale, y * scale + 0.5 * scale, 50) tree = Tree(pos=treepos) tree.prime.reparentTo(self.trees) taskMgr.add(self.flatten, "Terrain flatten task")
def Square(width=1, height=1, axis=pm.Vec3(1, 0, 0), thickness=1.0, origin=pm.Point3(0, 0, 0)): """Return a geom node representing a wire square.""" # Create line segments ls = pm.LineSegs() ls.setThickness(thickness) # Get the points for a square points = GetPointsForSquare(width, height) points.append(points[0]) for p in points: # Draw the point rotated around the desired axis p = pm.Point3(p[0], p[1], 0) - origin p = RotatePoint3(p, pm.Vec3(0, 0, 1), axis) ls.drawTo(p) # Return the geom node return ls.create()
def rotateCam(self, arc): """Setup a lerp interval to rotate the camera about the target.""" newP = clampScalar(self.target.getP() - arc.getY(), *self.clampP) #Clamped. newH = self.target.getH() + arc.getX() #Not clamped, just added. LERP.LerpHprInterval( self.target, self.speed, #Setup the interval\ P.Vec3( newH, newP, self.target.getR(), ), ).start() #and start it.
def CreateSquare( self, vec, colour ): # Create the geometry and collision self.square = pm.NodePath( Square( 0.2, 0.2, pm.Vec3(0, 1, 0) ) ) self.square.setBillboardPointEye() collSphere = pm.CollisionSphere( 0, 0.125 ) # Create the axis, add the geometry and collision axis = Axis( self.name, CAMERA_VECTOR, colour, planar=True, default=True ) axis.AddGeometry( self.square, sizeStyle=NONE ) axis.AddCollisionSolid( collSphere, sizeStyle=NONE ) axis.reparentTo( self ) return axis
def __init__(self, radius=1.0, numSegs=16, degrees=360, axis=pm.Vec3(1, 0, 0), thickness=1.0, origin=pm.Point3(0, 0, 0)): # Create line segments self.ls = pm.LineSegs() self.ls.setThickness(thickness) # Get the points for an arc for p in GetPointsForArc(degrees, numSegs): # Draw the point rotated around the desired axis p = pm.Point3(p[0], p[1], 0) - origin p = RotatePoint3(p, pm.Vec3(0, 0, 1), pm.Vec3(axis)) self.ls.drawTo(p * radius) # Init the node path, wrapping the lines node = self.ls.create() pm.NodePath.__init__(self, node)
def __init__(self, *args, **kwargs): Base.__init__(self, *args, **kwargs) self.AddAttributes(Attr('Origin', pm.Point3, CR.getOrigin, CR.setOrigin, initDefault=pm.Point3(0)), Attr('Direction', pm.Vec3, CR.getDirection, CR.setDirection, initDefault=pm.Vec3(0, 0, 1)), parent='CollisionRay')
def privGotSpec(self, levelSpec): DistCogdoLevelGame.privGotSpec(self, levelSpec) levelMgr = self.getEntity(LevelConstants.LevelMgrEntId) self.endVault = levelMgr.geom self.endVault.reparentTo(self.geomRoot) # Clear out unneeded backstage models from the EndVault, if # they're in the file. self.endVault.findAllMatches('**/MagnetArms').detach() self.endVault.findAllMatches('**/Safes').detach() self.endVault.findAllMatches('**/MagnetControlsAll').detach() # Flag the collisions in the end vault so safes and magnets # don't try to go through the wall. cn = self.endVault.find('**/wallsCollision').node() cn.setIntoCollideMask(OTPGlobals.WallBitmask | ToontownGlobals.PieBitmask | (PM.BitMask32.lowerOn(3) << 21)) # Find all the wall polygons and replace them with planes, # which are solid, so there will be zero chance of safes or # toons slipping through a wall. walls = self.endVault.find('**/RollUpFrameCillison') walls.detachNode() self.evWalls = self.replaceCollisionPolysWithPlanes(walls) self.evWalls.reparentTo(self.endVault) # Initially, these new planar walls are stashed, so they don't # cause us trouble in the intro movie or in battle one. We # will unstash them when we move to battle three. self.evWalls.stash() # Also replace the floor polygon with a plane, and rename it # so we can detect a collision with it. floor = self.endVault.find('**/EndVaultFloorCollision') floor.detachNode() self.evFloor = self.replaceCollisionPolysWithPlanes(floor) self.evFloor.reparentTo(self.endVault) self.evFloor.setName('floor') # Also, put a big plane across the universe a few feet below # the floor, to catch things that fall out of the world. plane = PM.CollisionPlane( PM.Plane(PM.Vec3(0, 0, 1), PM.Point3(0, 0, -50))) planeNode = PM.CollisionNode('dropPlane') planeNode.addSolid(plane) planeNode.setCollideMask(ToontownGlobals.PieBitmask) self.geomRoot.attachNewNode(planeNode)
def __init__(self, pos=None): """Initialise the tree.""" # Models and CollisionSolids are parented to one prime NodePath if pos is None: pos = P.Vec3(0, 0, 0) self.pos = pos self.prime = P.NodePath('tree') self.prime.setPos(self.pos) dir = "models/trees" # FIXME: hardcoded models dir # Choose a random model from dir and load it. trees = [ f for f in os.listdir(dir) if os.path.isfile(os.path.join(dir, f)) and f.endswith('.egg') ] tree = random.choice(trees) self.np = loadModel(os.path.join(dir, tree), self.prime) # TODO: Give each tree a random orientation # Initialise the Tree's CollisionRay which is used with a # CollisionHandlerQueue to find the height of the terrain below the # tree and move the tree to that height (see self.step) self.raynp = self.prime.attachNewNode(P.CollisionNode('colNode')) self.raynp.node().addSolid(P.CollisionRay(0, 0, 3, 0, 0, -1)) self.handler = P.CollisionHandlerQueue() cTrav.addCollider(self.raynp, self.handler) #self.raynp.show() # We only want our CollisionRay to collide with the collision # geometry of the terrain, se we set a mask here. self.raynp.node().setFromCollideMask(C.floorMASK) self.raynp.node().setIntoCollideMask(C.offMASK) # Add a task for this Tree to the global task manager. taskMgr.add(self.step, "Tree step task")
def _getFlyAwayDest(self): return self.getPos() + PM.Vec3( 0, 0, GameConsts.CogSettings.CogFlyAwayHeight.get())
def Sphere(radius=1.0, numSegs=16, degrees=360, axis=pm.Vec3(0, 0, 1), origin=pm.Point3(0, 0, 0)): """Return a geom node representing a cylinder.""" # Create vetex data format gvf = pm.GeomVertexFormat.getV3n3() gvd = pm.GeomVertexData('vertexData', gvf, pm.Geom.UHStatic) # Create vetex writers for each type of data we are going to store gvwV = pm.GeomVertexWriter(gvd, 'vertex') gvwN = pm.GeomVertexWriter(gvd, 'normal') # Get the points for an arc axis = pm.Vec3(axis) axis.normalize() points = GetPointsForArc(degrees, numSegs, True) zPoints = GetPointsForArc(180, numSegs / 2, True) for z in range(1, len(zPoints) - 2): rad1 = zPoints[z][1] * radius rad2 = zPoints[z + 1][1] * radius offset1 = axis * zPoints[z][0] * radius offset2 = axis * zPoints[z + 1][0] * radius for i in range(len(points) - 1): # Get points p1 = pm.Point3(points[i][0], points[i][1], 0) * rad1 p2 = pm.Point3(points[i + 1][0], points[i + 1][1], 0) * rad1 p3 = pm.Point3(points[i + 1][0], points[i + 1][1], 0) * rad2 p4 = pm.Point3(points[i][0], points[i][1], 0) * rad2 # Rotate the points around the desired axis p1, p2, p3, p4 = [ RotatePoint3(p, pm.Vec3(0, 0, 1), axis) for p in [p1, p2, p3, p4] ] a = p1 + offset1 - origin b = p2 + offset1 - origin c = p3 + offset2 - origin d = p4 + offset2 - origin # Quad gvwV.addData3f(d) gvwV.addData3f(b) gvwV.addData3f(a) gvwV.addData3f(d) gvwV.addData3f(c) gvwV.addData3f(b) # Normals cross = (b - c).cross(a - c) for i in range(6): gvwN.addData3f(cross) # Get points rad1 = zPoints[1][1] * radius for m in [1, -2]: offset1 = axis * zPoints[m][0] * radius clampedM = max(-1, min(m, 1)) * radius for i in range(len(points) - 1): p1 = pm.Point3(points[i][0], points[i][1], 0) * rad1 p2 = pm.Point3(points[i + 1][0], points[i + 1][1], 0) * rad1 # Rotate the points around the desired axis p1, p2 = [ RotatePoint3(p, pm.Vec3(0, 0, 1), axis) for p in [p1, p2] ] a = p1 + offset1 - origin b = p2 + offset1 - origin c = -axis * clampedM # Quad if clampedM > 0: gvwV.addData3f(a) gvwV.addData3f(b) gvwV.addData3f(c) else: gvwV.addData3f(c) gvwV.addData3f(b) gvwV.addData3f(a) # Normals cross = (b - c).cross(a - c) for i in range(3): gvwN.addData3f(cross * -m) geom = pm.Geom(gvd) for i in range(0, gvwV.getWriteRow(), 3): # Create and add triangle geom.addPrimitive(GetGeomTriangle(i, i + 1, i + 2)) # Return the cylinder GeomNode geomNode = pm.GeomNode('cylinder') geomNode.addGeom(geom) return geomNode
import pandac.PandaModules as pm X_AXIS = pm.Vec3(1, 0, 0) Y_AXIS = pm.Vec3(0, 1, 0) Z_AXIS = pm.Vec3(0, 0, 1)
def Str2Vec3(string): buffer = string.split(' ') return pm.Vec3(*[float(buffer[i]) for i in range(3)])
def Transform( self ): axis = self.GetSelectedAxis() axisPoint = self.GetAxisPoint( axis ) # Calculate delta and snapping. d = axisPoint - self.lastAxisPoint lastSnap = self._Snap( self._s ) self._s += d thisSnap = self._Snap( self._s ) if self._snp: # If snapping in planar mode or using the camera axis, snap to a # point on the ground plane. if axis.vector == CAMERA_VECTOR or self.planar: pnt = self.GetMousePlaneCollisionPoint( pm.Point3( 0 ), pm.Vec3( 0, 0, 1 ) ) pnt = utils.SnapPoint( pnt, self._snpAmt ) self.setPos( render, pnt ) for np in self.attachedNps: np.setPos( render, pnt ) return # If snapping in world space, construct a plane where the mouse # clicked the axis and move all NodePaths so they intersect it. elif not self.local: pnt = utils.SnapPoint( self.startAxisPoint + d, self._snpAmt ) pl = pm.Plane( axis.vector, pm.Point3( pnt ) ) self.setPos( render, pl.project( self.getPos( render ) ) ) for np in self.attachedNps: np.setPos( render, pl.project( np.getPos( render ) ) ) return # Gone over the snap threshold - set the delta to the snap amount. elif thisSnap.compareTo( lastSnap, TOL ): d.normalize() d *= self._snpAmt # BUG - need to resize to compensate for cam dist? # In snapping mode but haven't gone past the snap threshold. else: d = pm.Vec3( 0 ) d = self.getRelativeVector( self.rootNp, d ) self.setMat( pm.Mat4().translateMat( d ) * self.getMat() ) # Adjust the size of delta by the gizmo size to get real world units. d = utils.ScalePoint( d, self.getScale() ) # Hack for fixing camera vector xforming in local mode. if self.local and axis.vector == CAMERA_VECTOR: d = self.rootNp.getRelativeVector( self, d ) d = utils.ScalePoint( d, self.getScale(), True ) # Xform attached NodePaths. for np in ( self.attachedNps ): if self.local and axis.vector != CAMERA_VECTOR: sclD = utils.ScalePoint( d, np.getScale( self.rootNp ), True ) np.setMat( pm.Mat4().translateMat( sclD ) * np.getMat() ) else: np.setMat( self.rootNp, np.getMat( self.rootNp ) * pm.Mat4().translateMat( d ) ) self.lastAxisPoint = axisPoint
def __init__(self): """Initialise the test scene.""" # Show the framerate base.setFrameRateMeter(True) # Make 4 terrain nodepath objects with different hilliness values # and arrange them side-by-side in a 2x2 grid, giving a big terrain # with variable hilly and flat areas. color = (0.6, 0.8, 0.5, 1) # Bright green-ish scale = 12 t1 = Terrain(color=color, scale=scale, trees=0.7) t1.prime.reparentTo(render) t2 = Terrain(color=color, scale=scale, h=24, pos=P.Vec3(32 * scale, 0, 0), trees=0.5) t2.prime.reparentTo(render) t3 = Terrain(color=color, scale=scale, h=16, pos=P.Vec3(32 * scale, 32 * scale, 0), trees=0.3) t3.prime.reparentTo(render) t4 = Terrain(color=color, scale=scale, h=2, pos=P.Vec3(0, 32 * scale, 0), trees=0.9) t4.prime.reparentTo(render) # Setup a camera. base.disableMouse() self.camera = Camera(P.Vec3(0, 0, 100)) self.camera.lookAt(320, 320, 0) # Setup keyboard controls. # Accept some keys to move the camera. self.accept("a", self.camera.setControl, ["left", 1]) self.accept("a-up", self.camera.setControl, ["left", 0]) self.accept("d", self.camera.setControl, ["right", 1]) self.accept("d-up", self.camera.setControl, ["right", 0]) self.accept("w", self.camera.setControl, ["up", 1]) self.accept("w-up", self.camera.setControl, ["up", 0]) self.accept("s", self.camera.setControl, ["down", 1]) self.accept("s-up", self.camera.setControl, ["down", 0]) self.accept("arrow_up", self.camera.setControl, ["forward", 1]) self.accept("arrow_up-up", self.camera.setControl, ["forward", 0]) self.accept("arrow_down", self.camera.setControl, ["backward", 1]) self.accept("arrow_down-up", self.camera.setControl, ["backward", 0]) self.accept("arrow_left", self.camera.setControl, ["strafe-left", 1]) self.accept("arrow_left-up", self.camera.setControl, ["strafe-left", 0]) self.accept("arrow_right", self.camera.setControl, ["strafe-right", 1]) self.accept("arrow_right-up", self.camera.setControl, ["strafe-right", 0]) # Accept the Esc key to exit. self.accept("escape", sys.exit) # Setup lighting. self.alight = P.AmbientLight('alight') self.alight.setColor(P.VBase4(0.35, 0.35, 0.35, 1)) self.alnp = render.attachNewNode(self.alight) render.setLight(self.alnp) self.dlight = P.DirectionalLight('dlight') self.dlight.setColor(P.VBase4(0.4, 0.4, 0.4, 1)) self.dlnp = render.attachNewNode(self.dlight) self.dlnp.setHpr(45, -45, 0) render.setLight(self.dlnp) self.plight = P.PointLight('plight') self.plight.setColor(P.VBase4(0.8, 0.8, 0.5, 1)) self.plnp = render.attachNewNode(self.plight) self.plnp.setPos(160, 160, 50) self.slight = P.Spotlight('slight') self.slight.setColor(P.VBase4(1, 1, 1, 1)) lens = P.PerspectiveLens() self.slight.setLens(lens) self.slnp = render.attachNewNode(self.slight) self.slnp.setPos(-20, -20, 20) self.slnp.lookAt(50, 50, 0) # Setup some scene-wide exponential fog. colour = (0.5, 0.8, 0.8) self.expfog = P.Fog("Scene-wide exponential Fog object") self.expfog.setColor(*colour) self.expfog.setExpDensity(0.0005) render.setFog(self.expfog) base.setBackgroundColor(*colour)
def OnMouse2Down( self ): Base.OnMouse2Down( self ) self._s = pm.Vec3( 0 )