Example #1
0
 def ResetModelPath(self):
     """
     Clears the model path, making sure to restore the current working 
     directory (so editor models can still be found).
     """
     pm.getModelPath().clear()
     pm.getModelPath().prependDirectory('.')
Example #2
0
 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)
Example #3
0
 def ResetModelPath( self ):
     """
     Clears the model path, making sure to restore the current working 
     directory (so editor models can still be found).
     """
     pm.getModelPath().clear()
     pm.getModelPath().prependDirectory( '.' )
 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)
Example #5
0
    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 replaceCollisionPolysWithPlanes(self, model):
        newCollisionNode = PM.CollisionNode('collisions')
        newCollideMask = PM.BitMask32(0)
        planes = []
        collList = model.findAllMatches('**/+CollisionNode')
        if not collList:
            collList = [model]
        for cnp in collList:
            cn = cnp.node()
            if not isinstance(cn, PM.CollisionNode):
                self.notify.warning('Not a collision node: %s' % repr(cnp))
                break
            newCollideMask = newCollideMask | cn.getIntoCollideMask()
            for i in range(cn.getNumSolids()):
                solid = cn.getSolid(i)
                if isinstance(solid, PM.CollisionPolygon):
                    plane = PM.Plane(solid.getPlane())
                    planes.append(plane)
                else:
                    self.notify.warning('Unexpected collision solid: %s' %
                                        repr(solid))
                    newCollisionNode.addSolid(plane)

        newCollisionNode.setIntoCollideMask(newCollideMask)
        threshold = 0.1
        planes.sort(lambda p1, p2: p1.compareTo(p2, threshold))
        lastPlane = None
        for plane in planes:
            if lastPlane == None or plane.compareTo(lastPlane, threshold) != 0:
                cp = PM.CollisionPlane(plane)
                newCollisionNode.addSolid(cp)
                lastPlane = plane

        return PM.NodePath(newCollisionNode)
Example #7
0
    def enterLoaded(self):
        DistCogdoLevelGame.enterLoaded(self)

        self.lightning = loader.loadModel(
            'phase_10/models/cogHQ/CBLightning.bam')
        self.magnet = loader.loadModel('phase_10/models/cogHQ/CBMagnet.bam')
        self.craneArm = loader.loadModel(
            'phase_10/models/cogHQ/CBCraneArm.bam')
        self.controls = loader.loadModel(
            'phase_10/models/cogHQ/CBCraneControls.bam')
        self.stick = loader.loadModel('phase_10/models/cogHQ/CBCraneStick.bam')
        self.cableTex = self.craneArm.findTexture('MagnetControl')

        self.geomRoot = PM.NodePath('geom')

        # Set up a physics manager for the cables and the objects
        # falling around in the room.

        self.physicsMgr = PM.PhysicsManager()
        integrator = PM.LinearEulerIntegrator()
        self.physicsMgr.attachLinearIntegrator(integrator)

        fn = PM.ForceNode('gravity')
        self.fnp = self.geomRoot.attachNewNode(fn)
        gravity = PM.LinearVectorForce(0, 0, -32)
        fn.addForce(gravity)
        self.physicsMgr.addLinearForce(gravity)
 def enterLoaded(self):
     DistCogdoLevelGame.enterLoaded(self)
     self.lightning = loader.loadModel(
         'phase_10/models/cogHQ/CBLightning.bam')
     self.magnet = loader.loadModel('phase_10/models/cogHQ/CBMagnet.bam')
     self.craneArm = loader.loadModel(
         'phase_10/models/cogHQ/CBCraneArm.bam')
     self.controls = loader.loadModel(
         'phase_10/models/cogHQ/CBCraneControls.bam')
     self.stick = loader.loadModel('phase_10/models/cogHQ/CBCraneStick.bam')
     self.cableTex = self.craneArm.findTexture('MagnetControl')
     self.moneyBag = loader.loadModel('phase_10/models/cashbotHQ/MoneyBag')
     self.geomRoot = PM.NodePath('geom')
     self.sceneRoot = self.geomRoot.attachNewNode('sceneRoot')
     self.sceneRoot.setPos(35.84, -115.46, 6.46)
     self.physicsMgr = PM.PhysicsManager()
     integrator = PM.LinearEulerIntegrator()
     self.physicsMgr.attachLinearIntegrator(integrator)
     fn = PM.ForceNode('gravity')
     self.fnp = self.geomRoot.attachNewNode(fn)
     gravity = PM.LinearVectorForce(0, 0, GameConsts.Settings.Gravity.get())
     fn.addForce(gravity)
     self.physicsMgr.addLinearForce(gravity)
     self._gravityForce = gravity
     self._gravityForceNode = fn
Example #9
0
 def __init__(self,
              avatar,
              offset=P.Point3.zero(),
              dist=10,
              rot=20,
              zoom=(30, 400),
              pitch=(-15, 0)):
     # Disable default camera interface.
     base.disableMouse()
     # Set parameters
     self.zoomLvl = dist  #camera starting distance
     self.speed = 1.0 / rot  # Controls speed of camera rotation.
     self.zoomClamp = zoom  #clamp zoom in this range
     self.clampP = pitch  #clamp pitch in this range
     self.target = avatar.attachNewNode('camera target')
     self.target.setPos(offset)  #offset target from avatar.
     #Load the camera
     self.__loadCamera()
     #Enable new camera interface
     self.accept('arrow_up', self.cameraZoom,
                 [0.7])  #Translated. For zooming.
     self.accept('arrow_down', self.cameraZoom, [1.3])
     self.accept('arrow_left', self.rotateCam, [P.Point2(-10, 0)])
     self.accept('arrow_right', self.rotateCam, [P.Point2(10, 0)])
     taskMgr.add(self.mousecamTask,
                 "mousecamTask")  #For edge screen tracking
Example #10
0
def RebuildGeomNodesToColPolys(incomingNodes):
    """
    Converts GeomNodes into CollisionPolys in a straight 1-to-1 conversion 

    Returns a new NodePath containing the CollisionNodes 
    """
    parent = pm.NodePath('cGeomConversionParent')
    for c in incomingNodes:
        gni = 0
        geomNode = c.node()
        for g in range(geomNode.getNumGeoms()):
            geom = geomNode.getGeom(g).decompose()
            vdata = geom.getVertexData()
            vreader = pm.GeomVertexReader(vdata, 'vertex')
            cChild = pm.CollisionNode('cGeom-%s-gni%i' % (c.getName(), gni))
            gni += 1
            for p in range(geom.getNumPrimitives()):
                prim = geom.getPrimitive(p)
                for p2 in range(prim.getNumPrimitives()):
                    s = prim.getPrimitiveStart(p2)
                    e = prim.getPrimitiveEnd(p2)
                    v = []
                    for vi in range(s, e):
                        vreader.setRow(prim.getVertex(vi))
                        v.append(vreader.getData3f())
                    colPoly = pm.CollisionPolygon(*v)
                    cChild.addSolid(colPoly)

            parent.attachNewNode(cChild)

    return parent
Example #11
0
 def Set( self, dirPath ):
     
     # Check project definition file exists
     if not os.path.exists( os.path.join( dirPath, PROJECT_DEF_NAME ) ):
         self.path = None
         return
     
     # Set the project directory
     oldPath = self.path
     self.path = dirPath
     
     # Clear the model search path and add the new project path. Make sure
     # to prepend the new directory or else Panda might search in-built
     # paths first and supply the incorrect model.
     base.ResetModelPath()
     modelPath = pm.Filename.fromOsSpecific( self.path )
     pm.getModelPath().prependDirectory( modelPath )
     
     # Remove the old project path from sys.path and add the new one
     if oldPath in sys.path:
         sys.path.remove( oldPath )
     sys.path.insert( 0, self.path )
     
     # Set paths
     self.SetDirectories()
     
     # Set directory watcher root path and start it
     self.dirWatcher.setDirectory( self.path )
     if not self.dirWatcher.running:
         self.dirWatcher.start()
Example #12
0
 def Set( self, dirPath ):
     
     # Check project definition file exists
     if not os.path.exists( os.path.join( dirPath, PROJECT_DEF_NAME ) ):
         self.path = None
         return
     
     # Set the project directory
     oldPath = self.path
     self.path = dirPath
     
     # Clear the model search path and add the new project path. Make sure
     # to prepend the new directory or else Panda might search in-built
     # paths first and supply the incorrect model.
     base.ResetModelPath()
     modelPath = pm.Filename.fromOsSpecific( self.path )
     pm.getModelPath().prependDirectory( modelPath )
     
     # Remove the old project path from sys.path and add the new one
     if oldPath in sys.path:
         sys.path.remove( oldPath )
     sys.path.insert( 0, self.path )
     
     # Set paths
     self.SetDirectories()
     
     # Set directory watcher root path and start it
     self.dirWatcher.setDirectory( self.path )
     if not self.dirWatcher.running:
         self.dirWatcher.start()
Example #13
0
    def mousecamTask(self, task):
        """Rotate camera when the pointer moves to the edges of the screen.

    Also temporarily zooms in past an obstructing CameraM'ed object."""
        self.setDist(self.zoomLvl)  #preset dist to current zoom level.
        if self.Q.getNumEntries() > 0:  #if there was a collision
            self.Q.sortEntries()  #so we get the closest collision to avatar
            point = self.Q.getEntry(0).getSurfacePoint(
                self.target)  #get the point
            if point.lengthSquared() < camera.getPos().lengthSquared(
            ):  #not out.
                self.setDist(point.length())  #Temporarily zoom to point.
        camera.lookAt(self.target)  # always point camera at target
        if not base.mouseWatcherNode.hasMouse(
        ):  #See if the mouse is available.
            return Task.cont  #if no, just loop again.
        # Get the relative mouse position, its always between 1 and -1
        mpos = base.mouseWatcherNode.getMouse()
        if mpos.getX() > 0.99:
            self.rotateCam(P.Point2(-10, 0))
        elif mpos.getX() < -0.99:
            self.rotateCam(P.Point2(10, 0))
        if mpos.getY() > 0.9:
            self.rotateCam(P.Point2(0, -3))
        elif mpos.getY() < -0.9:
            self.rotateCam(P.Point2(0, 3))
        return Task.cont  #loop again.
Example #14
0
    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)
Example #15
0
def Line(start, end, thickness=1.0):
    """Return a geom node representing a simple line."""
    # Create line segments
    ls = pm.LineSegs()
    ls.setThickness(thickness)
    ls.drawTo(pm.Point3(start))
    ls.drawTo(pm.Point3(end))

    # Return the geom node
    return ls.create()
Example #16
0
def makeQuad(renderVP, collisionVP, bl=None, tr=None, br=None, tl=None):
    """Return a tuple of EggPolygons (renderQuad,collisionQuad): renderable and
  collision geometry for a 4-vertex polygon.

  Keyword arguments:
  renderVP -- EggVertexPool to which vertices will be added for the
        renderable quad
  collisionVP -- EggVertexPool to which vertices will be added for the
           collidable quad
  bl -- bottom-left vertex of quad (Point3D). Default (-10,-10,0)
  tr -- top-right vertex of quad (Point3D). Default (10,10,0)
  br -- bottom-right vertex of quad (Point3D)
  tl -- top-left vertex of quad (Point3D)
  If either of br or tl is None then sensible defaults will be computed
  according to the values of bl and tr.

  """
    if bl is None: bl = P.Point3D(-10, -10, 0)
    if tr is None: tr = P.Point3D(10, 10, 0)
    if br is None:
        l = tr.getX() - bl.getX()
        br = bl + P.Vec3D(l, 0, 0)
    if tl is None:
        w = tr.getY() - bl.getY()
        tl = bl + P.Vec3D(0, w, 0)
    renderQuad = P.EggPolygon()
    collisionQuad = P.EggPolygon()
    for corner in [bl, br, tr, tl]:
        vertex = P.EggVertex()
        vertex.setPos(corner)
        collisionVertex = P.EggVertex()
        collisionVertex.setPos(corner)
        renderQuad.addVertex(renderVP.addVertex(vertex))
        collisionQuad.addVertex(collisionVP.addVertex(collisionVertex))

    # A bug in Panda3D means that auto-triangulation of concave polygons
    # fails for some combinations of vertices (the polygon is not properly
    # transformed into triangles) creating gaps in a model where polygons are
    # missing. We can check for this failure by calling
    # EggPolygon.triangulateInto() and checking its return value. If False is
    # returned we reverse the vertex order of the polygon (so it now faces
    # downward instead of up) and reverse the backface flag so the downside
    # (which is now facing up) is rendered instead of the upside (which is now
    # facing down). The result looks more or less the same as if the polygon
    # had triangulated correctly in the first place (except the shading will be
    # different). Thanks to ynjh_jo for this workaround.
    egn = P.EggGroupNode(
    )  # triangulateInto() stores the resulting polygons in
    # an EggGroupNode, which we discard, we only care
    # about the True or False return value
    if not renderQuad.triangulateInto(egn, 0):
        # Triangulation failed, fix it.
        renderQuad.reverseVertexOrdering()
        renderQuad.setBfaceFlag(1)
        collisionQuad.reverseVertexOrdering()
        collisionQuad.setBfaceFlag(1)

    renderQuad.recomputePolygonNormal()  # Use faceted not smoothed lighting
    return renderQuad, collisionQuad
Example #17
0
 def SetupRenderMask(self):
     """
     Set the draw mask for the render node to be visible to all cameras.
     Since we are adjusting the draw mask of the render node's parent we
     need to manually set this node's mask or it will inherit those 
     properties.
     """
     showMask = pm.BitMask32().allOn()
     hideMask = pm.BitMask32()
     clearMask = pm.BitMask32()
     render.node().adjustDrawMask(showMask, hideMask, clearMask)
Example #18
0
    def GetEditorRenderMasks(self):
        """
        Return the show, hide and clear masks for objects that are to be 
        rendered only in the editor viewport.
        """
        show = pm.BitMask32()
        show.setRangeTo(True, 28, 4)
        hide = pm.BitMask32().allOn()
        hide.setRangeTo(False, 28, 4)
        clear = pm.BitMask32()

        return show, hide, clear
Example #19
0
 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 ) )
Example #20
0
 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
Example #21
0
 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()
Example #22
0
    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')
Example #23
0
    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)
Example #24
0
    def __loadCamera(self):
        """Only seperate for organisation, treat it as is part of __init__() .

    Load the camera & setup segmet & queue for detecting obstructions."""
        #Don't rotate the target with the avatar.
        self.target.node().setEffect(P.CompassEffect.make(render))
        camera.reparentTo(self.target)  # Attach the camera to target.
        camera.setPos(0, -self.zoomLvl, 50)  # Position the camera
        self.rotateCam(P.Point2(0, 0))  # Initialize gimbal clamps.
        self.Q = P.CollisionHandlerQueue()  # New queue for camera.
        self.segment = fromCol(
            self.target, self.Q,
            P.CollisionSegment(P.Point3.zero(), camera.getPos(self.target)),
            P.BitMask32(
                CameraM))  #CameraM into segment between camera & target.
Example #25
0
 def SetupEdRender(self):
     """
     Create editor root node behind render node so we can keep editor only
     nodes out of the scene.
     """
     self.edRender = pm.NodePath('edRender')
     render.reparentTo(self.edRender)
        def __init__(self, name, view, up, res):
            self.name = name

            # A camera, for viewing the world under render.
            self.camNode = pcore.Camera('cam' + self.name)
            self.camNode.setScene(base.render)
            self.cam = cubeCam.attachNewNode(self.camNode)

            # A projector, for projecting the generated image of the world
            # onto our screen.
            self.projNode = pcore.LensNode('proj' + self.name)
            self.proj = screens.attachNewNode(self.projNode)

            # A perspective lens, for both of the above.  The same lens is
            # used both to film the world and to project it onto the
            # screen.
            self.lens = pcore.PerspectiveLens()
            self.lens.setFov(92)
            self.lens.setNear(0.1)
            self.lens.setFar(10000)
            self.lens.setViewVector(view[0], view[1], view[2], up[0], up[1],
                                    up[2])

            self.camNode.setLens(self.lens)
            self.projNode.setLens(self.lens)

            # Now the projection screen itself, which is tied to the
            # projector.
            self.psNode = PandaModules.ProjectionScreen('ps' + self.name)
            self.ps = self.proj.attachNewNode(self.psNode)
            self.psNode.setProjector(self.proj)

            # Generate a flat, rectilinear mesh to project the image onto.
            self.psNode.regenerateScreen(self.proj, "screen", res[0], res[1],
                                         10, 0.97)
Example #27
0
    def create_lights(self):
        # function for converting cylindrical coordinates to cartesian
        # coordinates
        rtz2xyz = lambda r, t, z: (r * np.cos(t), r * np.sin(t), z)

        # positions for point lights
        plight_pos = [
            rtz2xyz(1.5, 4 * np.pi / 12., 0),
            rtz2xyz(1.5, 12 * np.pi / 12., 0),
            rtz2xyz(1.5, 20 * np.pi / 12., 0),
            (0, 0, 1.3),
        ]

        # create point lights
        self.plights = p3d.NodePath("plights")
        for i, pos in enumerate(plight_pos):
            plight = pm.PointLight('plight%d' % i)
            plight.setColor((0.5, 0.5, 0.5, 1.0))
            plight.setAttenuation((0, 0, 0.5))
            plnp = self.plights.attachNewNode(plight)
            plnp.setPos(pos)
            self.render.setLight(plnp)
        self.plights.reparentTo(self.lights)
        self.plights.setPos(0, 0, 4 / 3.)

        # update the position and color of the spotlight
        slnp = self.lights.find('slight')
        slnp.setPos((8, 6, 20))
        slnp.lookAt(self.look_at)
        slnp.node().setColor((1, 1, 1, 1))

        # update the color of the ambient light
        alnp = self.lights.find('alight')
        alnp.node().setColor((0.2, 0.2, 0.2, 1))
Example #28
0
 def CreateArrow( self, vec, colour ):
     
     # Create the geometry and collision
     vec.normalize()
     line = pm.NodePath( Line( (0, 0, 0), vec ) )
     cone = pm.NodePath( Cone( 0.05, 0.25, axis=vec, origin=vec * 0.125 ) )
     collTube = pm.CollisionTube( (0,0,0), pm.Point3( vec ) * 0.95, 0.05 )
     
     # Create the axis, add the geometry and collision
     axis = Axis( self.name, vec, colour )
     axis.AddGeometry( line, sizeStyle=SCALE )
     axis.AddGeometry( cone, vec, colour )
     axis.AddCollisionSolid( collTube, sizeStyle=TRANSLATE_POINT_B )
     axis.reparentTo( self )
     
     return axis
Example #29
0
def start_new_thread(function, args, kwargs={}, name=None):
    def threadFunc(threadId, function=function, args=args, kwargs=kwargs):
        try:
            try:
                function(*args, **kwargs)
            except SystemExit:
                pass

        finally:
            _remove_thread_id(threadId)

    global _nextThreadId
    _threadsLock.acquire()
    try:
        threadId = _nextThreadId
        _nextThreadId += 1

        if name is None:
            name = 'PythonThread-%s' % (threadId)

        thread = pm.PythonThread(threadFunc, [threadId], name, name)
        thread.setPythonData(threadId)
        _threads[threadId] = (thread, {}, None)

        thread.start(pm.TPNormal, False)
        return threadId

    finally:
        _threadsLock.release()
Example #30
0
    def __init__(self, *args, **kwargs):
        PrimitiveNPO.__init__(self, *args, **kwargs)

        self._width = 1
        self._depth = 1
        self._height = 1
        self._origin = pm.Point3(0, 0, 0)
Example #31
0
    def __init__(self, size=(256, 256), lbase=None, output=None):
        """ Prepares graphics context in which to render synthetic
        images."""

        if lbase is None:
            # Create the renderer
            window_type = "texture"
            self.lbase, self.output = gr.setup_renderer(window_type, size=size)
        else:
            # Use the supplied lbase instance
            self.lbase = lbase
            if output is None:
                # Default to last output in lbase.output_list
                self.output = self.lbase.output_list[-1]
        # Get the RTT target
        self.tex = self.output.getTexture()
        # Initialization
        self.models = {}
        self.bgs = {}
        # Make the scene and attach it to lbase's rootnode
        self.scene = pm.NodePath("scene")
        self.scene.reparentTo(self.lbase.rootnode)
        # Initialize local copies of all of the models and bgs
        self.init_models()
        self.init_bgs()
Example #32
0
 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 )
Example #33
0
 def GetRelModelPath( self, pandaPath ):
     """
     Attempt to find the indicated file path on one of the model search 
     paths. If found then return a path relative to it. Also make sure to 
     remove all extensions so we can load  both egg and bam files.
     """
     relPath = pm.Filename( pandaPath )
     index = relPath.findOnSearchpath( pm.getModelPath().getValue() )
     if index >= 0:
         basePath = pm.getModelPath().getDirectories()[index]
         relPath.makeRelativeTo( basePath )
         
     # Remove all extensions
     modelPath = str( relPath )
     while True:
         modelPath, ext = os.path.splitext( modelPath )
         if not ext:
             break
     
     return modelPath
    def setP3DFilename(self, p3dFilename, tokens, argv, instanceId,
                       interactiveConsole, p3dOffset = 0):
        """ Called by the browser to specify the p3d file that
        contains the application itself, along with the web tokens
        and/or command-line arguments.  Once this method has been
        called, the application is effectively started. """

        # One day we will have support for multiple instances within a
        # Python session.  Against that day, we save the instance ID
        # for this instance.
        self.instanceId = instanceId

        self.tokens = tokens
        self.argv = argv

        # We build up a token dictionary with care, so that if a given
        # token appears twice in the token list, we record only the
        # first value, not the second or later.  This is consistent
        # with the internal behavior of the core API.
        self.tokenDict = {}
        for token, keyword in tokens:
            self.tokenDict.setdefault(token, keyword)

        # Also store the arguments on sys, for applications that
        # aren't instance-ready.
        sys.argv = argv

        # That means we now know the altHost in effect.
        self.altHost = self.tokenDict.get('alt_host', None)

        # Tell the browser that Python is up and running, and ready to
        # respond to queries.
        self.notifyRequest('onpythonload')

        # Now go load the applet.
        fname = Filename.fromOsSpecific(p3dFilename)
        vfs = VirtualFileSystem.getGlobalPtr()

        if not vfs.exists(fname):
            raise ArgumentError, "No such file: %s" % (p3dFilename)

        fname.makeAbsolute()
        mf = Multifile()
        if p3dOffset == 0:
            if not mf.openRead(fname):
                raise ArgumentError, "Not a Panda3D application: %s" % (p3dFilename)
        else:
            if not mf.openRead(fname, p3dOffset):
                raise ArgumentError, "Not a Panda3D application: %s at offset: %s" % (p3dFilename, p3dOffset)

        # Now load the p3dInfo file.
        self.p3dInfo = None
        self.p3dPackage = None
        self.p3dConfig = None
        self.allowPythonDev = False

        i = mf.findSubfile('p3d_info.xml')
        if i >= 0 and hasattr(PandaModules, 'readXmlStream'):
            stream = mf.openReadSubfile(i)
            self.p3dInfo = PandaModules.readXmlStream(stream)
            mf.closeReadSubfile(stream)
        if self.p3dInfo:
            self.p3dPackage = self.p3dInfo.FirstChildElement('package')
        if self.p3dPackage:
            self.p3dConfig = self.p3dPackage.FirstChildElement('config')

            xhost = self.p3dPackage.FirstChildElement('host')
            while xhost:
                self.__readHostXml(xhost)
                xhost = xhost.NextSiblingElement('host')

        if self.p3dConfig:
            allowPythonDev = self.p3dConfig.Attribute('allow_python_dev')
            if allowPythonDev:
                self.allowPythonDev = int(allowPythonDev)
            guiApp = self.p3dConfig.Attribute('gui_app')
            if guiApp:
                self.guiApp = int(guiApp)

            trueFileIO = self.p3dConfig.Attribute('true_file_io')
            if trueFileIO:
                self.trueFileIO = int(trueFileIO)

        # The interactiveConsole flag can only be set true if the
        # application has allow_python_dev set.
        if not self.allowPythonDev and interactiveConsole:
            raise StandardError, "Impossible, interactive_console set without allow_python_dev."
        self.interactiveConsole = interactiveConsole

        if self.allowPythonDev:
            # Set the fps text to remind the user that
            # allow_python_dev is enabled.
            ConfigVariableString('frame-rate-meter-text-pattern').setValue('allow_python_dev %0.1f fps')

        if self.guiApp:
            initAppForGui()

        self.initPackedAppEnvironment()

        # Mount the Multifile under self.multifileRoot.
        vfs.mount(mf, self.multifileRoot, vfs.MFReadOnly)
        VFSImporter.reloadSharedPackages()

        self.loadMultifilePrcFiles(mf, self.multifileRoot)
        self.gotP3DFilename = True

        # Send this call to the main thread; don't call it directly.
        messenger.send('AppRunner_startIfReady', taskChain = 'default')
Example #35
0
def makeTerrainFromHeightMap(heightmap):
  """Return a tuple of NodePaths (renderNodePath,collisionNodePath) to
  renderable and collision geometry for a chainable terrain model built from
  the given heightmap.

  collisionNodePath is parented to renderNodePath. renderNodePath is not
  parented to anything by this function.

  Every 3x3 group of quads in the collision geometry is collected under a
  PandaNode for efficient collision detection. This could be improved on by
  building both the renderable and collision geometry as octrees.

  Keyword arguments:
  heightmap -- a 2D list of height values.

  """
  size = len(heightmap)
  renderNodePath = P.NodePath('')
  renderEggData = P.EggData()
  renderVertexPool = P.EggVertexPool('')
  collisionNodePath = renderNodePath.attachNewNode('')
  # Supply the EggGroup & EggVertexPool for the first node.
  collisionVertexPool = P.EggVertexPool('')
  collisionEggGroup = P.EggGroup('')
  collisionEggGroup.addObjectType('barrier')
  # We group every (numQuadGrid x numQuadGrid) quads under 1 collision node.
  numQuadGrid=3
  # The modulo of (size-2)/numQuadGrid marks when the quads must be grouped
  # into 1 geom.
  edgeMod=(size-2)%numQuadGrid
  for i in range(0,len(heightmap)-1,numQuadGrid):
    # Limit nextIrange to avoid it from jump over the edge.
    nextIrange=min(numQuadGrid,len(heightmap)-1-i)
    for j in range(0,len(heightmap)-1):
      for nextI in range(0,nextIrange):
        bl = P.Point3D(i+nextI,j,heightmap[i+nextI][j])
        tr = P.Point3D(i+nextI+1,j+1,heightmap[i+nextI+1][j+1])
        br = P.Point3D(i+nextI+1,j,heightmap[i+nextI+1][j])
        tl = P.Point3D(i+nextI,j+1,heightmap[i+nextI][j+1])
        # Construct polygons (quads) with makeQuads.
        renderQuad,collisionQuad = makeQuad(renderVertexPool,
                          collisionVertexPool,
                          bl,tr,br,tl)
        renderEggData.addChild(renderQuad)
        collisionEggGroup.addChild(collisionQuad)
        if j%numQuadGrid==edgeMod and nextI==nextIrange-1:
           # Group the previous (numQuadGrid x numQuadGrid) quads under
           # collision node.
           collisionEggData = P.EggData()
           collisionEggData.addChild(collisionEggGroup)
           pandaNode = P.loadEggData(collisionEggData)
           nodePath = collisionNodePath.attachNewNode(
                      pandaNode.getChild(0).getChild(0))
           # Uncomment the next line to see the collision geom.
           #nodePath.show()
           # Supply the EggGroup & EggVertexPool for the next node.
           collisionEggGroup = P.EggGroup('')
           collisionEggGroup.addObjectType('barrier')
           collisionVertexPool = P.EggVertexPool('')
  pandaNode = P.loadEggData(renderEggData)
  renderNodePath.attachNewNode(pandaNode)
  return renderNodePath,collisionNodePath
Example #36
0
import os
import os.path
from panda3d.core import Filename
from pandac import PandaModules as PM

#set up some loading constants
DIR = str(Filename.fromOsSpecific(os.path.dirname(os.path.abspath(__file__))))
#convert back to base string from panda type
ASSET_DIR = DIR + "/assets/"
PM.getModelPath().appendPath(ASSET_DIR)


class TextureManager(object):
    def __init__(self, app):
        self.rocks = app.loader.loadTexture('rocks.png')

        for icon in ['arrow_out', 'asterisk_orange', 'bug', 'user']:
            setattr(self, icon,
                app.loader.loadTexture('icons/' + icon + '.png'))

TEXTURES = None


def init(app):
    global TEXTURES
    TEXTURES = TextureManager(app)