def __init__(self, fulcrum, terrain):
TerrainCamera.__init__(self)
self.terrain = terrain
self.fulcrum = fulcrum
# in behind Ralph regardless of ralph's movement.
self.camNode.reparentTo(fulcrum)
# How far should the camera be from Ralph
self.cameraDistance = 30
# Initialize the pitch of the camera
self.cameraPitch = 10
self.focus = self.fulcrum.attachNewNode("focus")
self.maxDistance = 500.0
self.minDistance = 2
self.maxPitch = 80
self.minPitch = -70
# We will detect the height of the terrain by creating a collision
# ray and casting it downward toward the terrain. One ray will
# start above ralph's head.
# A ray may hit the terrain, or it may hit a rock or a tree. If it
# hits the terrain, we can detect the height. If it hits anything
# else, we rule that the move is illegal.
self.cTrav = CollisionTraverser()
self.cameraRay = CollisionSegment(self.fulcrum.getPos(), (0, 5, 5))
self.cameraCol = CollisionNode('cameraRay')
self.cameraCol.addSolid(self.cameraRay)
self.cameraCol.setFromCollideMask(BitMask32.bit(0))
self.cameraCol.setIntoCollideMask(BitMask32.allOff())
self.cameraColNp = self.fulcrum.attachNewNode(self.cameraCol)
self.cameraColHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.cameraColNp, self.cameraColHandler)
def __init__(self):
self.initialize()
self.WALLS = self.MAZE.find("**/Wall.004")
self.WALLS.node().setIntoCollideMask(BitMask32.bit(0))
# collision with the ground. different bit mask
#self.mazeGround = self.maze.find("**/ground_collide")
#self.mazeGround.node().setIntoCollideMask(BitMask32.bit(1))
self.MAZEGROUND = self.MAZE.find("**/Cube.004")
self.MAZEGROUND.node().setIntoCollideMask(BitMask32.bit(1))
# add collision to the rock
cs = CollisionSphere(0, 0, 0, 0.5)
self.cnodePath = self.rock.attachNewNode(CollisionNode('cnode'))
self.cnodePath.node().addSolid(cs)
self.cnodePath.show()
self.cnodePath.node().setIntoCollideMask(BitMask32.bit(0))
# load the ball and attach it to the scene.
# it is on a dummy node so that we can rotate the ball
# without rotating the ray that will be attached to it
# CollisionTraversers calculate collisions
self.cTrav = CollisionTraverser()
#self.cTrav.showCollisions(render)
#self.cTrav.showCollisions(render)
# A list collision handler queue
self.cHandler = CollisionHandlerQueue()
# add collision nodes to the traverse.
# maximum nodes per traverser: 32
self.cTrav.addCollider(self.ballSphere,self.cHandler)
self.cTrav.addCollider(self.ballGroundColNp,self.cHandler)
self.cTrav.addCollider(self.cnodePath, self.cHandler)
# collision traversers have a built-in tool to visualize collisons
#self.cTrav.showCollisions(render)
self.start()
def __init__(self, render, objid, start_pos, gameclient):
self.client = gameclient
self.id = objid
self.motion_controller = None
self.is_player = False
# state management
self.isAnimating = False
self.state = state.IDLE
self.render = render # scene graph root
# create the panda3d actor: just load a default model for now
self.actor = Actor("models/ralph",
{"run":"models/ralph-run",
"walk":"models/ralph-walk"})
self.actor.reparentTo(render)
self.actor.setScale(.2)
self.actor.setPos(start_pos)
# prepare collision handling
self.cTrav = CollisionTraverser()
self.GroundRay = CollisionRay()
self.GroundRay.setOrigin(0,0,1000)
self.GroundRay.setDirection(0,0,-1)
self.GroundCol = CollisionNode('actorRay')
self.GroundCol.addSolid(self.GroundRay)
self.GroundCol.setFromCollideMask(BitMask32.bit(0))
self.GroundCol.setIntoCollideMask(BitMask32.allOff())
self.GroundColNp = self.actor.attachNewNode(self.GroundCol)
self.GroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.GroundColNp, self.GroundHandler)
def addRalph(self, pos):
ralphStartPos = pos
self.ralph = Actor("models/ralph",
{"run":"models/ralph-run",
"walk":"models/ralph-walk"})
self.ralph.reparentTo(render)
self.ralph.setScale(.2)
self.ralph.setPos(ralphStartPos)
self.cTrav = CollisionTraverser()
self.ralphGroundRay = CollisionRay()
self.ralphGroundRay.setOrigin(0,0,1000)
self.ralphGroundRay.setDirection(0,0,-1)
self.ralphGroundCol = CollisionNode('ralphRay')
self.ralphGroundCol.addSolid(self.ralphGroundRay)
self.ralphGroundCol.setFromCollideMask(BitMask32.bit(0))
self.ralphGroundCol.setIntoCollideMask(BitMask32.allOff())
self.ralphGroundColNp = self.ralph.attachNewNode(self.ralphGroundCol)
self.ralphGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.ralphGroundColNp, self.ralphGroundHandler)
self.camGroundRay = CollisionRay()
self.camGroundRay.setOrigin(0,0,1000)
self.camGroundRay.setDirection(0,0,-1)
self.camGroundCol = CollisionNode('camRay')
self.camGroundCol.addSolid(self.camGroundRay)
self.camGroundCol.setFromCollideMask(BitMask32.bit(0))
self.camGroundCol.setIntoCollideMask(BitMask32.allOff())
self.camGroundColNp = base.camera.attachNewNode(self.camGroundCol)
self.camGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler)
def CreateCollisionGeoms(self):
self.collisionNode = self.pNode.attachNewNode('CollisionNode')
collisionGeom = self.collisionNode.attachNewNode(CollisionNode("legsPlayer"))
collisionGeom.node().addSolid(CollisionSphere(0, 0, 0.35, 0.3))
collisionGeom.node().setFromCollideMask(Globals.ITEM_BITMASK)
collisionGeom.node().setIntoCollideMask(Globals.PLAYER_BITMASK)
#collisionGeom.show()
collisionGeom.setPythonTag(Globals.TAG_COLLISION, Globals.COLLISION_LEG)
collisionGeom.setPythonTag(Globals.TAG_PLAYER, self)
collisionGeom = self.collisionNode.attachNewNode(CollisionNode("bodyPlayer"))
collisionGeom.node().addSolid(CollisionSphere(0, 0, 0.9, 0.3))
collisionGeom.node().setFromCollideMask(BitMask32.allOff())
collisionGeom.node().setIntoCollideMask(Globals.PLAYER_BITMASK)
#collisionGeom.show()
collisionGeom.setPythonTag(Globals.TAG_COLLISION, Globals.COLLISION_BODY)
collisionGeom.setPythonTag(Globals.TAG_PLAYER, self)
collisionGeom = self.collisionNode.attachNewNode(CollisionNode("headPlayer"))
collisionGeom.node().addSolid(CollisionSphere(0, 0, 1.45, 0.35))
collisionGeom.node().setFromCollideMask(BitMask32.allOff())
collisionGeom.node().setIntoCollideMask(Globals.PLAYER_BITMASK)
collisionGeom.setPythonTag(Globals.TAG_COLLISION, Globals.COLLISION_HEAD)
collisionGeom.setPythonTag(Globals.TAG_PLAYER, self)
def placeItem(self, item):
# Add ground collision detector to the health item
self.collectGroundRay = CollisionRay()
self.collectGroundRay.setOrigin(0,0,300)
self.collectGroundRay.setDirection(0,0,-1)
self.collectGroundCol = CollisionNode('colRay')
self.collectGroundCol.addSolid(self.collectGroundRay)
self.collectGroundCol.setFromCollideMask(BitMask32.bit(0))
self.collectGroundCol.setIntoCollideMask(BitMask32.allOff())
self.collectGroundColNp = item.attachNewNode(self.collectGroundCol)
self.collectGroundHandler = CollisionHandlerQueue()
base.cTrav.addCollider(self.collectGroundColNp, self.collectGroundHandler)
placed = False;
while placed == False:
# re-randomize position
item.setPos(-random.randint(0,140),-random.randint(0,40),0)
base.cTrav.traverse(render)
# Get Z position from terrain collision
entries = []
for j in range(self.collectGroundHandler.getNumEntries()):
entry = self.collectGroundHandler.getEntry(j)
entries.append(entry)
entries.sort(lambda x,y: cmp(y.getSurfacePoint(render).getZ(),
x.getSurfacePoint(render).getZ()))
if (len(entries)>0) and (entries[0].getIntoNode().getName() == "terrain"):
item.setZ(entries[0].getSurfacePoint(render).getZ()+1)
placed = True
# remove placement collider
self.collectGroundColNp.removeNode()
def placeCollectibles(self):
self.placeCol = render.attachNewNode("Collectible-Placeholder")
self.placeCol.setPos(0,0,0)
# Add the health items to the placeCol node
for i in range(self.numObjects):
# Load in the health item model
self.collect = loader.loadModel("models/trex")
self.collect.setPos(0,0,0)
self.collect.reparentTo(self.placeCol)
self.collect.setScale(0.1)
self.tex3= loader.loadTexture("models/Face.jpg")
self.collect.setTexture(self.tex3,1)
self.placeItem(self.collect)
# Add spherical collision detection
colSphere = CollisionSphere(0,0,0,1)
sphereNode = CollisionNode('colSphere')
sphereNode.addSolid(colSphere)
sphereNode.setFromCollideMask(BitMask32.allOff())
sphereNode.setIntoCollideMask(BitMask32.bit(0))
sphereNp = self.collect.attachNewNode(sphereNode)
sphereColHandler = CollisionHandlerQueue()
def createPlayerCollisions(self):
""" create a collision solid and ray for the player """
cn = CollisionNode('player')
cn.setFromCollideMask(COLLISIONMASKS['geometry'])
cn.setIntoCollideMask(COLLISIONMASKS['portals'] | COLLISIONMASKS['exit'] | COLLISIONMASKS['lava'])
cn.addSolid(CollisionSphere(0,0,0,3))
solid = self.node.attachNewNode(cn)
# TODO : find a way to remove that, it's the cause of the little
# "push me left" effect we see sometime when exiting a portal
self.base.cTrav.addCollider(solid,self.base.pusher)
self.base.pusher.addCollider(solid,self.node, self.base.drive.node())
# init players floor collisions
ray = CollisionRay()
ray.setOrigin(0,0,-.2)
ray.setDirection(0,0,-1)
cn = CollisionNode('playerRay')
cn.setFromCollideMask(COLLISIONMASKS['player'])
cn.setIntoCollideMask(BitMask32.allOff())
cn.addSolid(ray)
solid = self.node.attachNewNode(cn)
self.nodeGroundHandler = CollisionHandlerQueue()
self.base.cTrav.addCollider(solid, self.nodeGroundHandler)
# init players ceil collisions
ray = CollisionRay()
ray.setOrigin(0,0,.2)
ray.setDirection(0,0,1)
cn = CollisionNode('playerUpRay')
cn.setFromCollideMask(COLLISIONMASKS['player'])
cn.setIntoCollideMask(BitMask32.allOff())
cn.addSolid(ray)
solid = self.node.attachNewNode(cn)
self.ceilGroundHandler = CollisionHandlerQueue()
self.base.cTrav.addCollider(solid, self.ceilGroundHandler)
def __init__(self, render, player):
self.username = player.getUsername()
self.isMoving = False
self.render = render
self.keyMap = {"left":0, "right":0, "forward":0, "cam-left":0, "cam-right":0}
#self.actor = Actor("models/ralph", {"run":"models/ralph-run", "walk":"models/ralph-walk"})
self.actor = Actor("models/panda-model",
{"walk": "models/panda-walk4"})
self.actor.reparentTo(render)
self.actor.setScale(0.002, 0.002, 0.002)
self.actor.setPos(player.getX(), player.getY(), player.getZ())
self.actor.setH(player.getH())
#self.actor.loop("walk")
self.cTrav = CollisionTraverser()
self.GroundRay = CollisionRay()
self.GroundRay.setOrigin(0,0,1000)
self.GroundRay.setDirection(0,0,-1)
self.GroundCol = CollisionNode('actorRay')
self.GroundCol.addSolid(self.GroundRay)
self.GroundCol.setFromCollideMask(BitMask32.bit(0))
self.GroundCol.setIntoCollideMask(BitMask32.allOff())
self.GroundColNp = self.actor.attachNewNode(self.GroundCol)
self.GroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.GroundColNp, self.GroundHandler)
def __addElements(self):
# Walk Capsule
self.__walkCapsule = BulletCapsuleShape(self.__walkCapsuleR, self.__walkCapsuleH)
self.__walkCapsuleNP = self.movementParent.attachNewNode(BulletRigidBodyNode('Capsule'))
self.__walkCapsuleNP.node().addShape(self.__walkCapsule)
self.__walkCapsuleNP.node().setKinematic(True)
self.__walkCapsuleNP.setCollideMask(BitMask32.allOn())
self.__world.attachRigidBody(self.__walkCapsuleNP.node())
# Crouch Capsule
self.__crouchCapsule = BulletCapsuleShape(self.__crouchCapsuleR, self.__crouchCapsuleH)
self.__crouchCapsuleNP = self.movementParent.attachNewNode(BulletRigidBodyNode('crouchCapsule'))
self.__crouchCapsuleNP.node().addShape(self.__crouchCapsule)
self.__crouchCapsuleNP.node().setKinematic(True)
self.__crouchCapsuleNP.setCollideMask(BitMask32.allOn())
# Set default
self.capsule = self.__walkCapsule
self.capsuleNP = self.__walkCapsuleNP
# Init
self.__updateCapsule()
def __init__(self, cr):
DistributedObject.__init__(self, cr)
#self.model = loader.loadModel('environment')
#self.model.setZ(0)
#self.builder = Builder(self, "map.txt", "development")
plane = CollisionPlane(Plane(Vec3(0, 0, 1), Point3(0, 0, 0)))
cnode = CollisionNode('cnode')
cnode.setIntoCollideMask(BitMask32.bit(1))
cnode.setFromCollideMask(BitMask32.bit(1))
cnode.addSolid(plane)
self.planeNP = self.model.attachNewNode(cnode)
self.planeNP.show()
# Setup a traverser for the picking collisions
self.picker = CollisionTraverser()
# Setup mouse ray
self.pq = CollisionHandlerQueue()
# Create a collision Node
pickerNode = CollisionNode('MouseRay')
# set the nodes collision bitmask
pickerNode.setFromCollideMask(BitMask32.bit(1))
# create a collision ray
self.pickerRay = CollisionRay()
# add the ray as a solid to the picker node
pickerNode.addSolid(self.pickerRay)
# create a nodepath with the camera to the picker node
self.pickerNP = base.camera.attachNewNode(pickerNode)
# add the nodepath to the base traverser
self.picker.addCollider(self.pickerNP, self.pq)
print "model loaded"
#TODO: check how to load multiple levels and set players in specific levels!
self.accept("mouse1", self.mouseClick)
def placeHealthItems(self):
self.placeholder = render.attachNewNode("HealthItem-Placeholder")
self.placeholder.setPos(0,0,0)
# Add the health items to the placeholder node
for i in range(5):
# Load in the health item model
self.foodchick = loader.loadModel("models/chicken2")
self.foodchick.setPos(0,0,0)
self.foodchick.reparentTo(self.placeholder)
#self.tex2=self.setTexture("models/orange.jpg")
#self.foodchick.setTexture(self.tex2,1)
#self.tex2= loader.loadTexture("models/orange.jpg")
#self.foodchick.setTexture(self.tex1,1)
self.placeItem(self.foodchick)
# Add spherical collision detection
healthSphere = CollisionSphere(0,0,0,1)
sphereNode = CollisionNode('healthSphere')
sphereNode.addSolid(healthSphere)
sphereNode.setFromCollideMask(BitMask32.allOff())
sphereNode.setIntoCollideMask(BitMask32.bit(0))
sphereNp = self.foodchick.attachNewNode(sphereNode)
sphereColHandler = CollisionHandlerQueue()
def setupCollisions(self):
#make a collision traverser, set it to default
base.cTrav = CollisionTraverser()
#self.cHandler = CollisionHandlerEvent()
self.cHandler = CollisionHandlerPusher()
#set the pattern for the event sent on collision
# "%in" is substituted with the name of the into object
#self.cHandler.setInPattern("hit-%in")
cSphere = CollisionSphere((0,0,0), 10) #panda is scaled way down!
cNode = CollisionNode("vtol")
cNode.addSolid(cSphere)
#panda is *only* a from object
cNode.setFromCollideMask(BitMask32.bit(0))
cNode.setIntoCollideMask(BitMask32.allOff())
cNodePath = self.vtol.attachNewNode(cNode)
# cNodePath.show()
base.cTrav.addCollider(cNodePath, self.cHandler)
self.cHandler.addCollider(cNodePath, self.vtol)
#for b1 in self.house2:
cTube1 = CollisionTube((-0.4,3,3), (-0.4,3,20), 6.8)
cTube2 = CollisionTube((-0.4,-3,3), (-0.4,-3,20), 6.8)
cNode = CollisionNode("models/houses/building")
cNode.addSolid(cTube1)
cNode.addSolid(cTube2)
cNodePath = self.house2.attachNewNode(cNode)
cTube1 = CollisionTube((-0.4,3,3), (-0.4,3,20), 6.8)
cTube2 = CollisionTube((-0.4,-3,3), (-0.4,-3,20), 6.8)
cNode = CollisionNode("models/houses/church")
cNode.addSolid(cTube1)
cNode.addSolid(cTube2)
cNodePath = self.house1.attachNewNode(cNode)
def setup(self):
self.worldNP = render.attachNewNode('World')
# World
self.debugNP = self.worldNP.attachNewNode(BulletDebugNode('Debug'))
self.debugNP.show()
self.debugNP.node().showWireframe(True)
self.debugNP.node().showConstraints(True)
self.debugNP.node().showBoundingBoxes(False)
self.debugNP.node().showNormals(False)
self.world = BulletWorld()
self.world.setGravity(Vec3(0, 0, -9.81))
self.world.setDebugNode(self.debugNP.node())
# Box A
shape = BulletBoxShape(Vec3(0.5, 0.5, 0.5))
bodyA = BulletRigidBodyNode('Box A')
bodyNP = self.worldNP.attachNewNode(bodyA)
bodyNP.node().addShape(shape)
bodyNP.setCollideMask(BitMask32.allOn())
bodyNP.setPos(-3, 0, 4)
visNP = loader.loadModel('models/box.egg')
visNP.clearModelNodes()
visNP.reparentTo(bodyNP)
self.world.attachRigidBody(bodyA)
# Box B
shape = BulletBoxShape(Vec3(0.5, 0.5, 0.5))
bodyB = BulletRigidBodyNode('Box B')
bodyNP = self.worldNP.attachNewNode(bodyB)
bodyNP.node().addShape(shape)
bodyNP.node().setMass(1.0)
bodyNP.node().setDeactivationEnabled(False)
bodyNP.setCollideMask(BitMask32.allOn())
bodyNP.setPos(0, 0, 0)
visNP = loader.loadModel('models/box.egg')
visNP.clearModelNodes()
visNP.reparentTo(bodyNP)
self.world.attachRigidBody(bodyB)
# Slider
frameA = TransformState.makePosHpr(Point3(2, 0, 0), Vec3(0, 0, 45))
frameB = TransformState.makePosHpr(Point3(0, -3, 0), Vec3(0, 0, 0))
slider = BulletSliderConstraint(bodyA, bodyB, frameA, frameB, True)
slider.setDebugDrawSize(2.0)
slider.setLowerLinearLimit(0)
slider.setUpperLinearLimit(6)
slider.setLowerAngularLimit(-60)
slider.setUpperAngularLimit(60)
self.world.attachConstraint(slider)
def setUpCamera(self):
""" puts camera behind the player in third person """
# Set up the camera
# Adding the camera to actor is a simple way to keep the camera locked
# in behind actor regardless of actor's movement.
base.camera.reparentTo(self.actor)
# We don't actually want to point the camera at actors's feet.
# This value will serve as a vertical offset so we can look over the actor
self.cameraTargetHeight = 0.5
# How far should the camera be from the actor
self.cameraDistance = 10
# Initialize the pitch of the camera
self.cameraPitch = 45
# The mouse moves rotates the camera so lets get rid of the cursor
props = WindowProperties()
props.setCursorHidden(True)
base.win.requestProperties(props)
#set up FOV
pl = base.cam.node().getLens()
pl.setFov(70)
base.cam.node().setLens(pl)
# A CollisionRay beginning above the camera and going down toward the
# ground is used to detect camera collisions and the height of the
# camera above the ground. A ray may hit the terrain, or it may hit a
# rock or a tree. If it hits the terrain, we detect the camera's
# height. If it hits anything else, the camera is in an illegal
# position.
"""
TODO:: This will need to be changed to bullet
"""
self.cTrav = CollisionTraverser()
self.groundRay = CollisionRay()
self.groundRay.setOrigin(0,0,1000)
self.groundRay.setDirection(0,0,-1)
self.groundCol = CollisionNode('camRay')
self.groundCol.addSolid(self.groundRay)
self.groundCol.setFromCollideMask(BitMask32.bit(1))
self.groundCol.setIntoCollideMask(BitMask32.allOff())
self.groundColNp = base.camera.attachNewNode(self.groundCol)
self.groundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.groundColNp, self.groundHandler)
# We will detect anything obstructing the camera's view of the player
self.cameraRay = CollisionSegment((0,0,self.cameraTargetHeight),(0,5,5))
self.cameraCol = CollisionNode('cameraRay')
self.cameraCol.addSolid(self.cameraRay)
self.cameraCol.setFromCollideMask(BitMask32.bit(0))
self.cameraCol.setIntoCollideMask(BitMask32.allOff())
self.cameraColNp = self.actor.attachNewNode(self.cameraCol)
self.cameraColHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.cameraColNp, self.cameraColHandler)
def _treeMe(level2Root, positions, uuids, geomCollide, center = None, side = None, radius = None, request_hash = b'Fake'): # TODO in theory this could be multiprocessed
""" Divide the space covered by all the objects into an oct tree and then
replace cubes with 512 objects with spheres radius = (side**2 / 2)**.5
for some reason this massively improves performance even w/o the code
for mouse over adding and removing subsets of nodes.
"""
num_points = len(positions)
if center == None: # branch predictor should take care of this?
center = np.mean(positions, axis=0)
radius = np.max(np.linalg.norm(positions - center))
side = ((4/3) * radius**2) ** .5
radius += 2
if num_points <= 0:
return False
def nextLevel():
bitmasks = [ np.zeros_like(uuids,dtype=np.bool_) for _ in range(8) ] # ICK there must be a better way of creating bitmasks
partition = positions > center
#the 8 conbinatorial cases
for i in range(num_points):
index = octit(partition[i])
bitmasks[index][i] = True
output = []
for i in range(8):
branch = bitmasks[i] # this is where we can multiprocess
new_center = center + TREE_LOGIC[i] * side * .5 #FIXME we pay a price here when we calculate the center of an empty node
subSet = positions[branch]
zap = treeMe(level2Root, subSet, uuids[branch], geomCollide[branch], new_center, side * .5, radius * .5)
output.append(zap)
return output
#This method can also greatly accelerate the neighbor traversal because it reduces the total number of nodes needed
if num_points < TREE_MAX_POINTS: # this generates fewer nodes (faster) and the other vairant doesnt help w/ selection :(
l2Node = level2Root.attachNewNode(CollisionNode("%s.%s"%(request_hash,center)))
l2Node.node().addSolid(CollisionSphere(center[0],center[1],center[2],radius*2))
l2Node.node().setIntoCollideMask(BitMask32.bit(BITMASK_COLL_MOUSE))
#l2Node.show()
for p,uuid,geom in zip(positions,uuids,geomCollide):
childNode = l2Node.attachNewNode(CollisionNode("%s"%uuid)) #XXX TODO
childNode.node().addSolid(CollisionSphere(p[0],p[1],p[2],geom)) # we do it this way because it keeps framerates WAY higher dont know why
childNode.node().setIntoCollideMask(BitMask32.bit(BITMASK_COLL_CLICK))
childNode.setPythonTag('uuid',uuid)
#childNode.show()
return True
if num_points < 3: # FIXME NOPE STILL get too deep recursion >_< and got it with a larger cutoff >_<
#print("detect a branch with 1")
return nextLevel()
return nextLevel()
def initCollisionRay(self, originZ, dirZ):
ray = CollisionRay(0,0,originZ,0,0,dirZ)
collNode = CollisionNode('playerRay')
collNode.addSolid(ray)
collNode.setFromCollideMask(BitMask32.bit(1))
collNode.setIntoCollideMask(BitMask32.allOff())
collRayNP = self.playerNode.attachNewNode(collNode)
collRayNP.show()
return collRayNP
def setup(self):
self.worldNP = render.attachNewNode('World')
# World
self.debugNP = self.worldNP.attachNewNode(BulletDebugNode('Debug'))
self.debugNP.show()
self.debugNP.node().showWireframe(True)
self.debugNP.node().showConstraints(True)
self.debugNP.node().showBoundingBoxes(False)
self.debugNP.node().showNormals(False)
self.world = BulletWorld()
self.world.setGravity(Vec3(0, 0, -9.81))
self.world.setDebugNode(self.debugNP.node())
# Box A
shape = BulletBoxShape(Vec3(0.5, 0.5, 0.5))
bodyA = BulletRigidBodyNode('Box A')
bodyNP = self.worldNP.attachNewNode(bodyA)
bodyNP.node().addShape(shape)
bodyNP.setCollideMask(BitMask32.allOn())
bodyNP.setPos(-2, 0, 1)
visNP = loader.loadModel('models/box.egg')
visNP.clearModelNodes()
visNP.reparentTo(bodyNP)
self.world.attachRigidBody(bodyA)
# Box B
shape = BulletBoxShape(Vec3(0.5, 0.5, 0.5))
bodyB = BulletRigidBodyNode('Box B')
bodyNP = self.worldNP.attachNewNode(bodyB)
bodyNP.node().addShape(shape)
bodyNP.node().setMass(1.0)
bodyNP.node().setDeactivationEnabled(False)
bodyNP.setCollideMask(BitMask32.allOn())
bodyNP.setPos(2, 0, 1)
visNP = loader.loadModel('models/box.egg')
visNP.clearModelNodes()
visNP.reparentTo(bodyNP)
self.world.attachRigidBody(bodyB)
# Hinge
pivotA = Point3(2, 0, 0)
pivotB = Point3(-4, 0, 0)
axisA = Vec3(0, 0, 1)
axisB = Vec3(0, 0, 1)
hinge = BulletHingeConstraint(bodyA, bodyB, pivotA, pivotB, axisA, axisB, True)
hinge.setDebugDrawSize(2.0)
hinge.setLimit(-90, 120, softness=0.9, bias=0.3, relaxation=1.0)
self.world.attachConstraint(hinge)
def setup(self):
self.worldNP = render.attachNewNode('World')
# World
self.debugNP = self.worldNP.attachNewNode(BulletDebugNode('Debug'))
self.debugNP.show()
self.debugNP.node().showWireframe(True)
self.debugNP.node().showConstraints(True)
self.debugNP.node().showBoundingBoxes(False)
self.debugNP.node().showNormals(False)
self.world = BulletWorld()
self.world.setGravity(Vec3(0, 0, -9.81))
self.world.setDebugNode(self.debugNP.node())
# Box A
shape = BulletBoxShape(Vec3(0.5, 0.5, 0.5))
bodyA = BulletRigidBodyNode('Box A')
bodyNP = self.worldNP.attachNewNode(bodyA)
bodyNP.node().addShape(shape)
bodyNP.setCollideMask(BitMask32.allOn())
bodyNP.setPos(-1, 0, 4)
visNP = loader.loadModel('models/box.egg')
visNP.clearModelNodes()
visNP.reparentTo(bodyNP)
self.world.attachRigidBody(bodyA)
# Box B
shape = BulletBoxShape(Vec3(0.5, 0.5, 0.5))
bodyB = BulletRigidBodyNode('Box B')
bodyNP = self.worldNP.attachNewNode(bodyB)
bodyNP.node().addShape(shape)
bodyNP.node().setMass(1.0)
bodyNP.node().setDeactivationEnabled(False)
bodyNP.node().setLinearDamping(0.6)
bodyNP.node().setAngularDamping(0.6)
bodyNP.setCollideMask(BitMask32.allOn())
bodyNP.setPos(2, 0, 0)
visNP = loader.loadModel('models/box.egg')
visNP.clearModelNodes()
visNP.reparentTo(bodyNP)
self.world.attachRigidBody(bodyB)
# Spherical Constraint
pivotA = Point3(2, 0, 0)
pivotB = Point3(0, 0, 4)
joint = BulletSphericalConstraint(bodyA, bodyB, pivotA, pivotB)
joint.setDebugDrawSize(2.0)
self.world.attachConstraint(joint)
def setup(self):
self.worldNP = render.attachNewNode('World')
# World
self.debugNP = self.worldNP.attachNewNode(BulletDebugNode('Debug'))
self.debugNP.show()
self.debugNP.node().showWireframe(True)
self.debugNP.node().showConstraints(True)
self.debugNP.node().showBoundingBoxes(False)
self.debugNP.node().showNormals(False)
self.world = BulletWorld()
self.world.setGravity(Vec3(0, 0, -9.81))
self.world.setDebugNode(self.debugNP.node())
# Box A
shape = BulletBoxShape(Vec3(0.5, 0.5, 0.5))
bodyA = BulletRigidBodyNode('Box A')
bodyNP = self.worldNP.attachNewNode(bodyA)
bodyNP.node().addShape(shape)
bodyNP.setCollideMask(BitMask32.allOn())
bodyNP.setPos(-2, 0, 4)
visNP = loader.loadModel('models/box.egg')
visNP.clearModelNodes()
visNP.reparentTo(bodyNP)
self.world.attachRigidBody(bodyA)
# Box B
shape = BulletBoxShape(Vec3(0.5, 0.5, 0.5))
bodyB = BulletRigidBodyNode('Box B')
bodyNP = self.worldNP.attachNewNode(bodyB)
bodyNP.node().addShape(shape)
bodyNP.node().setMass(1.0)
bodyNP.node().setDeactivationEnabled(False)
bodyNP.setCollideMask(BitMask32.allOn())
bodyNP.setPos(0, 0, 0)
visNP = loader.loadModel('models/box.egg')
visNP.clearModelNodes()
visNP.reparentTo(bodyNP)
self.world.attachRigidBody(bodyB)
# Cone
frameA = TransformState.makePosHpr(Point3(0, 0, -2), Vec3(0, 0, 90))
frameB = TransformState.makePosHpr(Point3(-5, 0, 0), Vec3(0, 0, 0))
cone = BulletConeTwistConstraint(bodyA, bodyB, frameA, frameB)
cone.setDebugDrawSize(2.0)
cone.setLimit(30, 45, 170, softness=1.0, bias=0.3, relaxation=8.0)
self.world.attachConstraint(cone)
def setupVehicle(self, bulletWorld):
# Chassis
shape = BulletBoxShape(Vec3(1, 2.2, 0.5))
ts = TransformState.makePos(Point3(0, 0, .7))
self.chassisNode = BulletRigidBodyNode('Vehicle')
self.chassisNP = render.attachNewNode(self.chassisNode)
self.chassisNP.node().addShape(shape, ts)
self.chassisNP.node().notifyCollisions(True)
self.chassisNP.setPosHpr(self.pos[0], self.pos[1], self.pos[2], self.pos[3], self.pos[4], self.pos[5])
# self.chassisNP.setPos(-5.34744, 114.773, 6)
# self.chassisNP.setPos(49.2167, 64.7968, 10)
self.chassisNP.node().setMass(800.0)
self.chassisNP.node().setDeactivationEnabled(False)
bulletWorld.attachRigidBody(self.chassisNP.node())
# np.node().setCcdSweptSphereRadius(1.0)
# np.node().setCcdMotionThreshold(1e-7)
# Vehicle
self.vehicle = BulletVehicle(bulletWorld, self.chassisNP.node())
self.vehicle.setCoordinateSystem(ZUp)
bulletWorld.attachVehicle(self.vehicle)
self.carNP = loader.loadModel('models/swiftstar-chassis')
tex = loader.loadTexture("models/tex/Futuristic_Car_C.jpg")
self.carNP.setTexture(tex)
self.carNP.setScale(1, 1, .9)
self.carNP.setCollideMask(BitMask32.allOn())
self.carNP.reparentTo(self.chassisNP)
# Right front wheel
np = loader.loadModel('models/swiftstar-fr-tire')
np.setCollideMask(BitMask32.allOff())
np.reparentTo(render)
self.addWheel(Point3(1, 1.1, 1), True, np)
# Left front wheel
np = loader.loadModel('models/swiftstar-fl-tire')
np.setCollideMask(BitMask32.allOff())
np.reparentTo(render)
self.addWheel(Point3(-1, 1.1, 1), True, np)
# Right rear wheel
np = loader.loadModel('models/swiftstar-rr-tire')
np.setCollideMask(BitMask32.allOff())
np.reparentTo(render)
self.addWheel(Point3(1.2, -2, .8), False, np)
# Left rear wheel
np = loader.loadModel('models/swiftstar-rl-tire')
np.setCollideMask(BitMask32.allOff())
np.reparentTo(render)
self.addWheel(Point3(-1.2, -2, .8), False, np)
def addCollisionOnMainChar(self):
self.mainCharGroundRay = CollisionRay()
self.mainCharGroundRay.setOrigin(0,0,1000)
self.mainCharGroundRay.setDirection(0,0,-1)
self.mainCharGroundCol = CollisionNode('mainChar')
self.mainCharGroundCol.addSolid(self.mainCharGroundRay)
self.mainCharGroundCol.setFromCollideMask(BitMask32.bit(0))
self.mainCharGroundCol.setIntoCollideMask(BitMask32.allOff())
self.mainCharGroundColNp = self.mainChar.attachNewNode(self.mainCharGroundCol)
self.mainCharGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.mainCharGroundColNp, self.mainCharGroundHandler)
def addCollisionOnCam(self):
self.camGroundRay = CollisionRay()
self.camGroundRay.setOrigin(0,0,1000)
self.camGroundRay.setDirection(0,0,-1)
self.camGroundCol = CollisionNode('camRay')
self.camGroundCol.addSolid(self.camGroundRay)
self.camGroundCol.setFromCollideMask(BitMask32.bit(0))
self.camGroundCol.setIntoCollideMask(BitMask32.allOff())
self.camGroundColNp = base.camera.attachNewNode(self.camGroundCol)
self.camGroundHandler = CollisionHandlerQueue()
self.cTrav.addCollider(self.camGroundColNp, self.camGroundHandler)
def setup(self):
self.worldNP = render.attachNewNode('World')
# World
self.debugNP = self.worldNP.attachNewNode(BulletDebugNode('Debug'))
self.debugNP.show()
self.world = BulletWorld()
self.world.setGravity(Vec3(0, 0, -9.81))
self.world.setDebugNode(self.debugNP.node())
# Plane
shape = BulletPlaneShape(Vec3(0, 0, 1), 0)
np = self.worldNP.attachNewNode(BulletRigidBodyNode('Ground'))
np.node().addShape(shape)
np.setPos(0, 0, -1)
np.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(np.node())
# Box
shape = BulletBoxShape(Vec3(0.5, 0.5, 0.5))
np = self.worldNP.attachNewNode(BulletRigidBodyNode('Box'))
np.node().setMass(1.0)
np.node().addShape(shape)
np.node().addShape(shape, TransformState.makePos(Point3(0, 1, 0)))
np.node().setDeactivationEnabled(False)
np.setPos(2, 0, 4)
np.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(np.node())
visualNP = loader.loadModel('models/box.egg')
visualNP.reparentTo(np)
self.box = np.node()
# Sphere
shape = BulletSphereShape(0.6)
np = self.worldNP.attachNewNode(BulletRigidBodyNode('Sphere'))
np.node().setMass(1.0)
np.node().addShape(shape)
np.node().addShape(shape, TransformState.makePos(Point3(0, 1, 0)))
np.setPos(-2, 0, 4)
np.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(np.node())
self.sphere = np.node()
def createWallCollider(self):
self.__colliderSideWalls = self.__board.attachNewNode(CollisionNode('boardSideWallsCNode'))
point1, point2, point3, point4 = self.getWallVertices('left')
self.__colliderSideWalls.node().addSolid(CollisionPolygon(point1, point2, point3, point4))
point1, point2, point3, point4 = self.getWallVertices('right')
self.__colliderSideWalls.node().addSolid(CollisionPolygon(point1, point2, point3, point4))
self.__colliderSideWalls.node().setIntoCollideMask(self.WALL_MASK)
self.__colliderSideWalls.node().setFromCollideMask(BitMask32.allOff())
self.__colliderBackWall = self.__board.attachNewNode(CollisionNode('boardBackWallCNode'))
point1, point2, point3, point4 = self.getWallVertices('back')
self.__colliderBackWall.node().addSolid(CollisionPolygon(point1, point2, point3, point4))
self.__colliderBackWall.node().setIntoCollideMask(self.WALL_MASK)
self.__colliderBackWall.node().setFromCollideMask(BitMask32.allOff())
def __setup_collision(self):
#Colisao
self.ralphGroundRay = CollisionRay()
self.ralphGroundRay.setOrigin(0,0,5)
self.ralphGroundRay.setDirection(0,0,-1)
self.ralphGroundCol = CollisionNode('ralphRay')
self.ralphGroundCol.addSolid(self.ralphGroundRay)
self.ralphGroundCol.setFromCollideMask(BitMask32.bit(0))
self.ralphGroundCol.setIntoCollideMask(BitMask32.allOff())
self.ralphGroundColNp = self.__modelo.attachNewNode(self.ralphGroundCol)
self.ralphGroundHandler = CollisionHandlerQueue()
base.cTrav.addCollider(self.ralphGroundColNp, self.ralphGroundHandler)
def __init__(self, _main):
self.main = _main
self.name = ""
self.points = 0
self.health = 100.0
self.runSpeed = 1.8
self.keyMap = {
"left":False,
"right":False,
"up":False,
"down":False
}
base.camera.setPos(0,0,0)
self.model = loader.loadModel("Player")
self.model.find('**/+SequenceNode').node().stop()
self.model.find('**/+SequenceNode').node().pose(0)
base.camera.setP(-90)
self.playerHud = Hud()
self.playerHud.hide()
self.model.hide()
# Weapons: size=2, 0=main, 1=offhand
self.mountSlot = []
self.activeWeapon = None
self.isAutoActive = False
self.trigger = False
self.lastShot = 0.0
self.fireRate = 0.0
self.playerTraverser = CollisionTraverser()
self.playerEH = CollisionHandlerEvent()
## INTO PATTERNS
self.playerEH.addInPattern('intoPlayer-%in')
#self.playerEH.addInPattern('colIn-%fn')
self.playerEH.addInPattern('intoHeal-%in')
self.playerEH.addInPattern('intoWeapon-%in')
## OUT PATTERNS
self.playerEH.addOutPattern('outOfPlayer-%in')
playerCNode = CollisionNode('playerSphere')
playerCNode.setFromCollideMask(BitMask32.bit(1))
playerCNode.setIntoCollideMask(BitMask32.bit(1))
self.playerSphere = CollisionSphere(0, 0, 0, 0.6)
playerCNode.addSolid(self.playerSphere)
self.playerNP = self.model.attachNewNode(playerCNode)
self.playerTraverser.addCollider(self.playerNP, self.playerEH)
#self.playerNP.show()
self.playerPusher = CollisionHandlerPusher()
self.playerPusher.addCollider(self.playerNP, self.model)
self.playerPushTraverser = CollisionTraverser()
self.playerPushTraverser.addCollider(self.playerNP, self.playerPusher)
def setup(self):
self.worldNP = render.attachNewNode("World")
# World
self.debugNP = self.worldNP.attachNewNode(BulletDebugNode("Debug"))
self.debugNP.show()
self.world = BulletWorld()
self.world.setGravity(Vec3(0, 0, -9.81))
self.world.setDebugNode(self.debugNP.node())
# Ground
shape = BulletPlaneShape(Vec3(0, 0, 1), 0)
# img = PNMImage(Filename('models/elevation2.png'))
# shape = BulletHeightfieldShape(img, 1.0, ZUp)
np = self.worldNP.attachNewNode(BulletRigidBodyNode("Ground"))
np.node().addShape(shape)
np.setPos(0, 0, -1)
np.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(np.node())
# Box
shape = BulletBoxShape(Vec3(1.0, 3.0, 0.3))
np = self.worldNP.attachNewNode(BulletRigidBodyNode("Box"))
np.node().setMass(50.0)
np.node().addShape(shape)
np.setPos(3, 0, 4)
np.setH(0)
np.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(np.node())
# Character
h = 1.75
w = 0.4
shape = BulletCapsuleShape(w, h - 2 * w, ZUp)
self.player = BulletCharacterNode(shape, 0.4, "Player")
self.player.setMass(20.0)
self.player.setMaxSlope(45.0)
self.player.setGravity(9.81)
self.playerNP = self.worldNP.attachNewNode(self.player)
self.playerNP.setPos(-2, 0, 10)
self.playerNP.setH(-90)
self.playerNP.setCollideMask(BitMask32.allOn())
self.world.attachCharacter(self.player)
def createCollider(self):
self.__wallCollider = self.__ball.attachNewNode(CollisionNode('ballWallCNode'))
radius = self.getBallRadius()
self.__wallCollider.node().addSolid(CollisionSphere(0, 0, 0, radius))
self.__wallCollider.node().setFromCollideMask(Board.WALL_MASK)
self.__wallCollider.node().setIntoCollideMask(BitMask32.allOff())
self.__blockCollider = self.__ball.attachNewNode(CollisionNode('ballBlockCNode'))
self.__blockCollider.node().addSolid(CollisionSphere(0, 0, 0, radius))
self.__blockCollider.node().setFromCollideMask(Block.BLOCK_MASK)
self.__blockCollider.node().setIntoCollideMask(BitMask32.allOff())
self.__paddleCollider = self.__ball.attachNewNode(CollisionNode('ballPaddleCNode'))
self.__paddleCollider.node().addSolid(CollisionSphere(0, 0, 0, radius))
self.__paddleCollider.node().setFromCollideMask(Paddle.PADDLE_MASK)
self.__paddleCollider.node().setIntoCollideMask(BitMask32.allOff())
def handLoader(self):
self.palm_R = self.loader.loadModel("%s/palm_R" % LOAD_HAND_FROM) # @UndefinedVariable
self.palm_R_collider = self.palm_R.find("**/palm_R_collider")
self.palm_R_collider.node().setIntoCollideMask(BitMask32.bit(0))
self.fing_R = [self.loader.loadModel("%s/fing%i_R" % (LOAD_HAND_FROM, i+1)) for i in range(5)] # @UndefinedVariable
self.midd_R = [self.loader.loadModel("%s/m%i_R" % (LOAD_HAND_FROM, i+1)) for i in range(5)] # @UndefinedVariable
self.base_R = [self.loader.loadModel("%s/b%i_R" % (LOAD_HAND_FROM, i+1)) for i in range(5)] # @UndefinedVariable
self.fing_R_collider = [self.fing_R[i].find("**/fing%i_R_collider" % (i+1)) for i in range(5)] # @UndefinedVariable
self.midd_R_collider = [self.midd_R[i].find("**/m%i_R_collider" % (i+1)) for i in range(5)] # @UndefinedVariable
self.base_R_collider = [self.base_R[i].find("**/b%i_R_collider" % (i+1)) for i in range(5)] # @UndefinedVariable
self.palm_L = self.loader.loadModel("%s/palm_L" % LOAD_HAND_FROM) # @UndefinedVariable
self.palm_R_collider = self.palm_L.find("**/palm_L_collider")
self.palm_R_collider.node().setIntoCollideMask(BitMask32.bit(0))
self.fing_L = [self.loader.loadModel("%s/fing%i_L" % (LOAD_HAND_FROM, i+1)) for i in range(5)] # @UndefinedVariable
self.midd_L = [self.loader.loadModel("%s/m%i_L" % (LOAD_HAND_FROM, i+1)) for i in range(5)] # @UndefinedVariable
self.base_L = [self.loader.loadModel("%s/b%i_L" % (LOAD_HAND_FROM, i+1)) for i in range(5)] # @UndefinedVariable
self.fing_L_collider = [self.fing_L[i].find("**/fing%i_L_collider" % (i+1)) for i in range(5)] # @UndefinedVariable
self.midd_L_collider = [self.midd_L[i].find("**/m%i_L_collider" % (i+1)) for i in range(5)] # @UndefinedVariable
self.base_L_collider = [self.base_L[i].find("**/b%i_L_collider" % (i+1)) for i in range(5)] # @UndefinedVariable
self.palm_R.setScale(self.handScale, self.handScale, self.handScale*1.5)
self.palm_L.setScale(self.handScale, self.handScale, self.handScale*1.5)
for f in self.fing_R: f.setScale(self.handScale, self.handScale*1.5, self.handScale*1.5)
for f in self.midd_R: f.setScale(self.handScale, self.handScale*1.5, self.handScale*1.5)
for f in self.base_R: f.setScale(self.handScale, self.handScale*1.5, self.handScale*1.5)
for f in self.fing_L: f.setScale(self.handScale, self.handScale*1.5, self.handScale*1.5)
for f in self.midd_L: f.setScale(self.handScale, self.handScale*1.5, self.handScale*1.5)
for f in self.base_L: f.setScale(self.handScale, self.handScale*1.5, self.handScale*1.5)
for f in self.fing_R_collider: f.node().setIntoCollideMask(BitMask32.bit(0))
for f in self.midd_R_collider: f.node().setIntoCollideMask(BitMask32.bit(0))
for f in self.base_R_collider: f.node().setIntoCollideMask(BitMask32.bit(0))
for f in self.fing_L_collider: f.node().setIntoCollideMask(BitMask32.bit(0))
for f in self.midd_L_collider: f.node().setIntoCollideMask(BitMask32.bit(0))
for f in self.base_L_collider: f.node().setIntoCollideMask(BitMask32.bit(0))
def generate(self):
data = CIGlobals.SuitBodyData[self.SUIT]
type = data[0]
team = data[1]
self.generateSuit(type, self.SUIT, team, self.MAX_HP, 0, False)
base.taskMgr.add(self.__viewDistance, self.viewDistanceTaskName)
self.setPythonTag('guard', self)
self.eyeLight = Spotlight('eyes')
self.eyeLens = PerspectiveLens()
self.eyeLens.setMinFov(90.0 / (4. / 3.))
self.eyeLight.setLens(self.eyeLens)
self.eyeNode = self.headModel.attachNewNode(self.eyeLight)
self.eyeNode.setZ(-5)
self.eyeNode.setY(-4.5)
self.trav = CollisionTraverser(self.uniqueName('eyeTrav'))
ray = CollisionRay(0, 0, 0, 0, 1, 0)
rayNode = CollisionNode('ToonFPS.rayNode')
rayNode.addSolid(ray)
rayNode.setFromCollideMask(CGG.GuardBitmask | CIGlobals.WallBitmask)
rayNode.setIntoCollideMask(BitMask32.allOff())
self.rayNP = base.camera.attachNewNode(rayNode)
self.rayNP.setZ(3)
self.queue = CollisionHandlerQueue()
self.trav.addCollider(self.rayNP, self.queue)
self.trav.addCollider(self.gameWorld.mg.avatarBody, self.queue)
self.request('Guard')
def __init__(self, location, player, cmap, world):
super(Catcher, self).__init__(location)
self.player = player
self.cmap = cmap
self.obj = utilities.loadObject("robot", depth=20)
self.world = world
self.health = 100
self.depth = self.obj.getPos().y
self.location = location
self.velocity = Vec3(0)
self.shape = BulletBoxShape(Vec3(0.5, 1.0, 0.5))
self.bnode = BulletRigidBodyNode('Box')
self.bnode.setMass(0.1)
self.bnode.setAngularVelocity(Vec3(0))
self.bnode.setAngularFactor(Vec3(0))
self.bnode.addShape(self.shape)
self.bnode.setLinearDamping(0.75)
self.bnode.setLinearSleepThreshold(0)
world.bw.attachRigidBody(self.bnode)
self.bnode.setPythonTag("entity", self)
self.bnode.setIntoCollideMask(BitMask32.bit(0))
self.node = utilities.app.render.attachNewNode(self.bnode)
self.node.setPos(self.obj.getPos())
self.obj.setPos(0, 0, 0)
self.obj.setScale(1)
self.obj.reparentTo(self.node)
self.node.setPos(self.location.x, self.depth, self.location.y)
def __init__(self, render, world, x, y, z, type):
self.type = type
h = 1.5
w = 0.4
shape = BulletCapsuleShape(w + 0.3, h - 2 * w, ZUp)
self.badCharacter = BulletCharacterControllerNode(shape, 0.4, 'Lego')
self.badCharacterNP = render.attachNewNode(self.badCharacter)
self.badCharacterNP.setPos(x, y, z)
self.startPositionX = self.badCharacterNP.getX()
self.startPositionY = self.badCharacterNP.getY()
self.startPositionZ = self.badCharacterNP.getZ()
# self.badCharacterNP.setH(45)
self.badCharacterNP.setCollideMask(BitMask32.allOn())
world.attachCharacter(self.badCharacter)
# self.world.attachRigidBody(self.badCharacter.node())
self.badActorNP = Actor(
'../models/lego/' + self.type + '/' + self.type + '.egg', {
'walk':
'../models/lego/' + self.type + '/' + self.type + '-walk.egg',
'attack':
'../models/lego/' + self.type + '/' + self.type +
'-attack.egg',
})
self.badActorNP.reparentTo(self.badCharacterNP)
self.badActorNP.setScale(0.3)
self.badActorNP.setH(180)
self.badActorNP.setPos(0, 0, 0.5)
# Associates badActorNP with badCharacterNP
self.badCharacterNP.setPythonTag("badActorNP", self.badActorNP)
def createPlayer(self, render, world):
h = 3.38
w = 0.4
shape = BulletCapsuleShape(w + 0.3, h - 2 * w, ZUp)
self.character = BulletCharacterControllerNode(shape, 0.4, 'Robot')
self.characterNP = render.attachNewNode(self.character)
self.characterNP.setPos(2, 0, 18)
self.characterNP.setH(45)
self.characterNP.setCollideMask(BitMask32.allOn())
world.attachCharacter(self.character)
self.actorNP = Actor(
'../models/robot/lack.egg', {
'walk': '../models/robot/lack-run.egg',
'idle': '../models/robot/lack-idle.egg',
'jump': '../models/robot/lack-jump.egg',
'land': '../models/robot/lack-land.egg',
'damage': '../models/robot/lack-damage.egg'
})
self.actorNP.reparentTo(self.characterNP)
self.actorNP.setScale(0.15)
self.actorNP.setH(180)
self.actorNP.setPos(0, 0, -0.06)
def _setup_collision_object(self,
path,
pos=(0.0, 0.0, 0.0),
hpr=(0.0, 0.0, 0.0),
scale=1):
visNP = loader.loadModel(path)
visNP.clearModelNodes()
visNP.reparentTo(render)
visNP.setPos(pos[0], pos[1], pos[2])
visNP.setHpr(hpr[0], hpr[1], hpr[2])
visNP.set_scale(scale, scale, scale)
bodyNPs = BulletHelper.fromCollisionSolids(visNP, True)
for bodyNP in bodyNPs:
bodyNP.reparentTo(render)
if not ('wall' in bodyNP.name or 'ground' in bodyNP.name):
bodyNP.setPos(pos[0], pos[1], pos[2] + 0.3)
else:
bodyNP.setPos(pos[0], pos[1], pos[2])
bodyNP.setHpr(hpr[0], hpr[1], hpr[2])
bodyNP.set_scale(scale, scale, scale)
if isinstance(bodyNP.node(), BulletRigidBodyNode):
bodyNP.node().setMass(0.0)
bodyNP.node().setKinematic(True)
bodyNP.setCollideMask(BitMask32.allOn())
self._world.attachRigidBody(bodyNP.node())
else:
print("Issue")
def start(self):
base.camLens.setNear(0.1)
self.shooterTrav = CollisionTraverser('ToonFPS.shooterTrav')
ray = CollisionRay()
rayNode = CollisionNode('ToonFPS.rayNode')
rayNode.addSolid(ray)
rayNode.setCollideMask(BitMask32(0))
rayNode.setFromCollideMask(CIGlobals.WallBitmask | CIGlobals.FloorBitmask)
self.shooterRay = ray
self.shooterRayNode = base.camera.attachNewNode(rayNode)
self.shooterHandler = CollisionHandlerQueue()
self.shooterTrav.addCollider(self.shooterRayNode, self.shooterHandler)
self.firstPerson.start()
self.v_model_root.reparentTo(base.camera)
self.v_model.reparentTo(self.v_model_root)
if self.weaponName == "pistol":
self.v_model_root.setZ(-1.8)
self.v_model_root.setY(0.3)
self.v_model_root.setX(-0.1)
self.v_model_root.setH(2)
elif self.weaponName == "sniper":
self.v_model_root.setPos(-0.42, -0.81, -1.7)
self.v_model_root.setHpr(359, 352.87, 0.00)
elif self.weaponName == "shotgun":
self.v_model_root.setPos(-0.42, -0.81, -1.7)
self.v_model_root.setHpr(359, 352.87, 0.00)
self.gui.start()
self.firstPerson.disableMouse()
self.aliveFSM.request('draw')
def make(self):
self.body = CubeModel(*self.size)
self.body.geom_node.setIntoCollideMask(BitMask32.bit(2))
self.body.reparentTo(self)
self.body.setTag('Tree', '{0}'.format(self.name))
self.set_body_tex(self.body_tex)
start_leaf = random.randint(2, 4)
if start_leaf > self.size[2] - 1:
start_leaf = self.size[2] - 1
self.leafs = []
i = 0
for z in xrange(start_leaf, self.size[2] - 1):
for ix in xrange(-1, 1):
for iy in xrange(-1, 1):
size_x = random.randint(int((self.size[2] - z + 4) * 0.2),
int((self.size[2] - z + 4) * 0.4))
size_y = random.randint(int((self.size[2] - z + 4) * 0.2),
int((self.size[2] - z + 4) * 0.4))
if size_x == 0 or size_y == 0:
continue
self.leafs.append(CubeModel(size_x, size_y, 1))
x = size_x * ix
y = size_y * iy
self.leafs[i].setPos(x, y, z)
self.leafs[i].reparentTo(self)
i += 1
self.set_leaf_tex(self.leaf_tex)
def __init__(self):
PhysicsNodePath.__init__(self, 'can')
self.shapeGroup = BitMask32.allOn()
sph = BulletBoxShape(Vec3(2, 2, 2))
rbnode = BulletRigidBodyNode('can_body')
rbnode.setMass(100.0)
rbnode.addShape(sph, TransformState.makePos(Point3(0, 0, 1)))
rbnode.setCcdMotionThreshold(1e-7)
rbnode.setCcdSweptSphereRadius(0.5)
self.mdl = loader.loadModel("phase_5/models/props/safe-mod.bam")
self.mdl.setScale(6)
self.mdl.setZ(-1)
self.mdl.reparentTo(self)
self.mdl.showThrough(CIGlobals.ShadowCameraBitmask)
self.setupPhysics(rbnode)
#self.makeShadow(0.2)
self.reparentTo(render)
self.setPos(base.localAvatar.getPos(render) + (0, 0, 20))
self.setQuat(base.localAvatar.getQuat(render))
def __init__(self):
self.shadowBuffer = base.win.makeTextureBuffer('Shadow Buffer', 2048,
2048)
self.shadowBuffer.setClearColorActive(True)
self.shadowBuffer.setClearColor((0, 0, 0, 1))
self.shadowCamera = base.makeCamera(self.shadowBuffer)
self.shadowCamera.reparentTo(render)
self.lens = base.camLens
self.lens.setAspectRatio(1 / 1)
self.shadowCamera.node().setLens(self.lens)
self.shadowCamera.node().setCameraMask(BitMask32.bit(1))
self.initial = NodePath('initial')
self.initial.setColor(0.75, 0.75, 0.75, 1, 1)
self.initial.setTextureOff(2)
self.initial.setMaterialOff(2)
self.initial.setLightOff(2)
self.shadowCamera.node().setInitialState(self.initial.getState())
self.shadowCamera.setPos(-10, 0, 20)
self.shadowCamera.lookAt(0, 0, 0)
self.filters = CommonFilters(self.shadowBuffer, self.shadowCamera)
self.filters.setBlurSharpen(0.1)
self.shadowTexture = self.shadowBuffer.getTexture()
self.imageObject = OnscreenImage(image=self.shadowTexture,
pos=(-0.75, 0, 0.75),
scale=0.2)
def __init__(self):
PhysicsNodePath.__init__(self, 'can')
self.shapeGroup = BitMask32.allOn()
sph = BulletCylinderShape(0.5, 1.2, ZUp)
rbnode = BulletRigidBodyNode('can_body')
rbnode.setMass(10.0)
rbnode.addShape(sph)
rbnode.setCcdMotionThreshold(1e-7)
rbnode.setCcdSweptSphereRadius(0.5)
self.mdl = loader.loadModel("phase_5/models/props/can.bam")
self.mdl.setScale(11.0)
self.mdl.setZ(-0.55)
self.mdl.reparentTo(self)
self.mdl.showThrough(CIGlobals.ShadowCameraBitmask)
self.setupPhysics(rbnode)
#self.makeShadow(0.2)
self.reparentTo(render)
self.setPos(base.localAvatar.getPos(render))
self.setQuat(base.localAvatar.getQuat(render))
dir = self.getQuat(render).xform(Vec3.forward())
amp = 10
self.node().setLinearVelocity(dir * amp)
def __setup_collision(self):
self.cTrav = CollisionTraverser('cameraTraverser')
self.__camSeg = CollisionSegment((0, 0, self.__camRef), (0, 0, 0))
cameraCol = CollisionNode('cameraSeg')
cameraCol.addSolid(self.__camSeg)
cameraCol.setFromCollideMask(BitMask32.bit(0))
cameraCol.setIntoCollideMask(BitMask32.allOff())
cameraColNp = self.ponto.attachNewNode(cameraCol)
self.__camColHandler = CollisionHandlerQueue()
self.cTrav.addCollider(cameraColNp, self.__camColHandler)
def __init__(self, n=9999, bins=9, show=False):
collideRoot = render.attachNewNode('collideRoot')
bases = [
np.cumsum(np.random.randint(-1, 2, (n, 3)), axis=0)
for i in range(bins)
]
type_ = GeomPoints
runs = []
for base in bases:
runs.append(smipleMake(index_counter, base, type_))
r = 0
for nodes in runs:
#pos = np.random.randint(-100,100,3)
print(nodes)
node, _ = nodes()
nd = render.attachNewNode(node)
#nd.setPos(*pos)
#nd.setRenderModeThickness(5)
#XXX TODO XXX collision objects
n = 0
for position in bases[
r]: #FIXME this is hella slow, the correct way to do this is to detach and reattach CollisionNodes as they are needed...
#TODO to change the color of a selected node we will need something a bit more ... sophisticated
cNode = collideRoot.attachNewNode(
CollisionNode('collider obj,vert %s,%s' %
(r, n))) #ultimately used to index??
cNode.node().addSolid(CollisionSphere(0, 0, 0, .5))
cNode.node().setIntoCollideMask(
BitMask32.bit(BITMASK_COLL_CLICK))
cNode.setPos(nd, *position)
if show:
cNode.show()
n += 1
r += 1
embed()
def doShoot(self, ccd):
# Get from/to points from mouse click
pMouse = base.mouseWatcherNode.getMouse()
pFrom = Point3()
pTo = Point3()
base.camLens.extrude(pMouse, pFrom, pTo)
pFrom = render.getRelativePoint(base.cam, pFrom)
pTo = render.getRelativePoint(base.cam, pTo)
# Calculate initial velocity
v = pTo - pFrom
v.normalize()
v *= 10000.0
# Create bullet
shape = BulletBoxShape(Vec3(0.5, 0.5, 0.5))
body = BulletRigidBodyNode('Bullet')
bodyNP = self.worldNP.attachNewNode(body)
bodyNP.node().addShape(shape)
bodyNP.node().setMass(2.0)
bodyNP.node().setLinearVelocity(v)
bodyNP.setPos(pFrom)
bodyNP.setCollideMask(BitMask32.allOn())
if ccd:
bodyNP.node().setCcdMotionThreshold(1e-7);
bodyNP.node().setCcdSweptSphereRadius(0.50);
self.world.attachRigidBody(bodyNP.node())
# Remove the bullet again after 1 second
taskMgr.doMethodLater(1, self.doRemove, 'doRemove',
extraArgs=[bodyNP],
appendTask=True)
def set_clickable(self, clickable):
self.clickable = clickable
if self.use_collision_solid and self.collision_solid is not None:
if clickable:
self.collision_solid.node().setIntoCollideMask(
CollisionNode.getDefaultCollideMask())
else:
self.collision_solid.node().setIntoCollideMask(
BitMask32.all_off())
#The instance itself is not clickable
self.instance.setCollideMask(BitMask32.all_off())
else:
if clickable:
self.instance.setCollideMask(GeomNode.getDefaultCollideMask())
else:
self.instance.setCollideMask(BitMask32.all_off())
def initCollisions(self):
self.collNodePath.setCollideMask(BitMask32(0))
self.collNodePath.node().setFromCollideMask(CIGlobals.WallBitmask)
pusher = CollisionHandlerPusher()
pusher.setInPattern('%in')
pusher.addCollider(self.collNodePath, self)
base.cTrav.addCollider(self.collNodePath, pusher)
def __init__(self):
#selection detection
self.picker = CollisionTraverser()
self.pq = CollisionHandlerQueue()
self.pickerNode = CollisionNode('mouseRay')
self.pickerNP = camera.attachNewNode(self.pickerNode)
#self.pickerNode.setFromCollideMask(GeomNode.getDefaultCollideMask()) #TODO WOW geometry collision is SUPER slow...
self.pickerNode.setFromCollideMask(BitMask32.bit(BITMASK_COLL_CLICK))
#render.find('**selectable').node().setIntoCollideMask(BitMask32.bit(1))
self.pickerRay = CollisionRay()
self.pickerNode.addSolid(self.pickerRay)
self.picker.addCollider(self.pickerNP, self.pq)
#self.picker.showCollisions(render)
#box selection detection HINT: start with drawing the 2d thing yo!
self.__shift__ = False
self.accept("shift", self.shiftOn)
self.accept("shift-up", self.shiftOff)
self.__ctrl__ = False
self.accept("control", self.ctrlOn)
self.accept("control-up", self.ctrlOff)
#mouse handling
self.accept("mouse1", self.clickHandler)
self.accept("shift-mouse1", self.clickHandler)
self.accept("mouse1-up", self.releaseHandler)
#dragging
self.dragTask = taskMgr.add(self.dragTask, 'dragTask')
def make_collision_from_model(input_model, node_number, mass, world,
target_pos, h_adj):
# tristrip generation from static models
# generic tri-strip collision generator begins
geom_nodes = input_model.find_all_matches('**/+GeomNode')
geom_nodes = geom_nodes.get_path(node_number).node()
# print(geom_nodes)
geom_target = geom_nodes.get_geom(0)
# print(geom_target)
output_bullet_mesh = BulletTriangleMesh()
output_bullet_mesh.add_geom(geom_target)
tri_shape = BulletTriangleMeshShape(output_bullet_mesh,
dynamic=False)
print(output_bullet_mesh)
body = BulletRigidBodyNode('input_model_tri_mesh')
np = self.render.attach_new_node(body)
np.node().add_shape(tri_shape)
np.node().set_mass(mass)
np.node().set_friction(0.01)
np.set_pos(target_pos)
np.set_scale(1)
np.set_h(h_adj)
# np.set_p(180)
# np.set_r(180)
np.set_collide_mask(BitMask32.allOn())
world.attach_rigid_body(np.node())
def __init__(self, name, lens):
panda3d.core.Camera.__init__(self, name, lens)
self.name = name
self.path = NodePath(self)
self.height, self.width = 512, 512
self.dataSize = self.height * self.width * NUM_CHANNELS
self.buffer = base.win.makeTextureBuffer(name + 'Buffer', self.height,
self.width)
# Set the sort order to a negative number so this buffer will be rendered before the
# main window.
self.buffer.setSort(-100)
self.tex = self.buffer.getTexture()
self.tex.setRenderToTexture(True)
self.tex.makeRamImage()
# Attach this camera to the buffer.
base.makeCamera(self.buffer, useCamera=self.path)
self.setCameraMask(BitMask32(2))
# Make a PNMImage into which we'll copy screenshots from the buffer.
self.image = PNMImage()
self.stringStream = StringStream()
self.gfxEngine = GraphicsEngine.getGlobalPtr()
self.gsg = base.win.getGsg()
self.currentFrame = 0
# Only initialize IPC and the copy out task if the posix_ipc module
# was loaded successfully.
if POSIX_IPC_LOADED:
self.initializeIpc()
def __init__(self,
scene,
suncgDatasetRoot,
size=(512, 512),
mode='offscreen',
zNear=0.1,
zFar=1000.0,
fov=40.0,
cameraTransform=None):
# Off-screen buffers are not supported in OSX
if sys.platform == 'darwin':
mode = 'onscreen'
super(Panda3dSemanticsRenderer, self).__init__()
self.__dict__.update(scene=scene,
suncgDatasetRoot=suncgDatasetRoot,
size=size,
mode=mode,
zNear=zNear,
zFar=zFar,
fov=fov,
cameraTransform=cameraTransform)
self.categoryMapping = ModelCategoryMapping(
os.path.join(self.suncgDatasetRoot, 'metadata',
'ModelCategoryMapping.csv'))
self.cameraMask = BitMask32.bit(1)
self.graphicsEngine = GraphicsEngine.getGlobalPtr()
self.loader = Loader.getGlobalPtr()
self.graphicsEngine.setDefaultLoader(self.loader)
self._initModels()
selection = GraphicsPipeSelection.getGlobalPtr()
self.pipe = selection.makeDefaultPipe()
logger.debug('Using %s' % (self.pipe.getInterfaceName()))
# Attach a camera to every agent in the scene
self.cameras = []
for agentNp in self.scene.scene.findAllMatches('**/agents/agent*'):
camera = agentNp.attachNewNode(ModelNode('camera-semantics'))
if self.cameraTransform is not None:
camera.setTransform(cameraTransform)
camera.node().setPreserveTransform(ModelNode.PTLocal)
self.cameras.append(camera)
# Reparent node below the existing physic node (if any)
physicsNp = agentNp.find('**/physics')
if not physicsNp.isEmpty():
camera.reparentTo(physicsNp)
self.rgbBuffers = dict()
self.rgbTextures = dict()
self._initRgbCapture()
self.scene.worlds['render-semantics'] = self
def setup(self):
self.worldNP = render.attachNewNode('World')
# World
self.debugNP = self.worldNP.attachNewNode(BulletDebugNode('Debug'))
self.world = BulletWorld()
self.world.setGravity(Vec3(0, 0, -9.81))
self.world.setDebugNode(self.debugNP.node())
# Plane
shape = BulletPlaneShape(Vec3(0, 0, 1), 0)
# collision
visNP = loader.loadModel('../models/coryf2.egg')
visNP.clearModelNodes()
visNP.reparentTo(render)
pos = (7., 60.0, 3.8)
visNP.setPos(pos[0], pos[1], pos[2])
bodyNPs = BulletHelper.fromCollisionSolids(visNP, True)
for bodyNP in bodyNPs:
bodyNP.reparentTo(render)
bodyNP.setPos(pos[0], pos[1], pos[2])
if isinstance(bodyNP.node(), BulletRigidBodyNode):
bodyNP.node().setMass(0.0)
bodyNP.node().setKinematic(True)
bodyNP.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(bodyNP.node())
def getObjectsInBox(self, mins, maxs):
objects = []
# Create a one-off collision box, traverser, and queue to test against all MapObjects
box = CollisionBox(mins, maxs)
node = CollisionNode("selectToolCollBox")
node.addSolid(box)
node.setFromCollideMask(self.Mask)
node.setIntoCollideMask(BitMask32.allOff())
boxNp = self.doc.render.attachNewNode(node)
queue = CollisionHandlerQueue()
base.clickTraverse(boxNp, queue)
queue.sortEntries()
key = self.Key
entries = queue.getEntries()
# Select every MapObject our box intersected with
for entry in entries:
np = entry.getIntoNodePath().findNetPythonTag(key)
if not np.isEmpty():
obj = np.getPythonTag(key)
actual = self.getActualObject(obj, entry)
if isinstance(actual, list):
for a in actual:
if not any(a == x[0] for x in objects):
objects.append((a, entry))
else:
objects.append((actual, entry))
boxNp.removeNode()
return objects
def init_nodes_to_chsess_board(self):
self.squareRoot = self.render_fsm_ref.render.attachNewNode(
"squareRoot")
# For each square
for i in range(64):
# Load, parent, color, and position the model (a single square
# polygon)
self.squares[i] = loader.loadModel(
"ChessRender/data/chess_board/square")
#self.squares[i].setTexture(self.SquareTexture(i))
self.squares[i].reparentTo(self.squareRoot)
self.squares[i].setPos(self.SquareUnderCubePos3D(i))
#self.squares[i].setColor(self.SquareColor(i))
self.cubes[i] = self.objMngr.load_cube()
self.cubes[i].setColor(self.SquareColor(i))
self.cubes[i].reparentTo(self.squareRoot)
self.cubes[i].setPos(self.SquarePos(i))
self.cubes[i].setScale(0.5)
#self.cubes[i].setShaderAuto()
self.cubes[i].setColor(self.SquareColor(i))
self.cubes[i].setTexture(self.SquareTexture(i))
# Set the model itself to be collideable with the ray. If this model was
# any more complex than a single polygon, you should set up a collision
# sphere around it instead. But for single polygons this works
# fine.
self.squares[i].find("**/polygon").node().setIntoCollideMask(
BitMask32.bit(1))
# Set a tag on the square's node so we can look up what square this is
# later during the collision pass
self.squares[i].find("**/polygon").node().setTag('square', str(i))
def __init__(self, track_data, world):
super().__init__()
self.track_data = track_data
self.world = world
self.snode = GeomNode('track')
self.width = track_data["width"]
self.cur_x1 = 0
self.cur_y1 = 0
self.cur_z1 = 0
self.cur_x2 = self.width
self.cur_y2 = 0
self.cur_z2 = 0
self.mesh = BulletTriangleMesh()
self.surfaces = {}
self.load_surfaces()
self.segments = []
self.gen_segments()
shape = BulletTriangleMeshShape(self.mesh, dynamic=False)
self.track = render.attachNewNode(BulletRigidBodyNode('Track'))
self.track.node().addShape(shape)
self.world.attachRigidBody(self.track.node())
self.track.attachNewNode(self.snode)
self.track.setTwoSided(True)
self.track.setCollideMask(BitMask32.allOn())
def createCharacter(self):
charColl = BulletCapsuleShape(0.4, 1.75 - 2 * 0.4, ZUp)
self.diamondChar = BulletCharacterControllerNode(
charColl, 0.4, 'Player')
self.diamondCharNP = self.worldNP.attachNewNode(self.diamondChar)
self.diamondCharNP.setPos(0, 0, 0)
self.diamondCharNP.setH(-90)
self.diamondCharNP.setCollideMask(BitMask32.allOn())
self.world.attachCharacter(self.diamondChar)
# Summon the lord Diamondback
self.diamondbackChar = Actor(
"Resources/models/CHAR/CHRIS", {
"walk": "Resources/models/CHAR/CHRIS-Walk2",
"idle": "Resources/models/CHAR/CHRIS-Idle2",
"jump": "Resources/models/CHAR/CHRIS-Jump"
})
self.diamondbackChar.reparentTo(self.diamondCharNP)
self.diamondbackChar.setPos(0, 0, -.83)
self.diamondbackChar.setScale(1)
self.diamondbackChar.setBlend(animBlend=True, frameBlend=True)
# Set the camera position tracker
self.camPos = NodePath(PandaNode("camTracker"))
self.camPos.reparentTo(self.diamondbackChar)
# Set the camera to track the lord
base.camera.reparentTo(self.camPos)
base.camera.setPosHpr(0, 6, 2.5, 180, -5, 0)
base.camLens.setFov(90)
def create(self):
# Create voxelize camera
self.voxelizeCamera = Camera("VoxelizeCamera")
self.voxelizeCamera.setCameraMask(BitMask32.bit(4))
self.voxelizeCameraNode = Globals.render.attachNewNode(
self.voxelizeCamera)
self.voxelizeLens = OrthographicLens()
self.voxelizeLens.setFilmSize(self.voxelGridSize * 2,
self.voxelGridSize * 2)
self.voxelizeLens.setNearFar(0.0, self.voxelGridSize * 2)
self.voxelizeCamera.setLens(self.voxelizeLens)
self.voxelizeCamera.setTagStateKey("VoxelizePassShader")
Globals.render.setTag("VoxelizePassShader", "Default")
# Create voxelize tareet
self.target = RenderTarget("VoxelizePass")
self.target.setSize(self.voxelGridResolution *
self.gridResolutionMultiplier)
if self.pipeline.settings.useDebugAttachments:
self.target.addColorTexture()
else:
self.target.setColorWrite(False)
self.target.setCreateOverlayQuad(False)
self.target.setSource(self.voxelizeCameraNode, Globals.base.win)
self.target.prepareSceneRender()
self.target.setActive(False)
def __init__(self, position=(0, 0, 0), color=(1, 1, 1, 1)):
# получаем уникальный ключ объекта - текущий индекс
self.key = str(Block.current_index)
# увеличиваем индекс
Block.current_index += 1
# флаг выделенного блока
self.selected = False
# загружаем модель блока
self.block = loader.loadModel('block')
# и текстуру к ней
tex = loader.loadTexture('block.png')
# устанавливаем текстуру на модель
self.block.setTexture(tex)
# устанавливаем учёт прозрачности цвета
self.block.setTransparency(TransparencyAttrib.MAlpha)
# перемещение модели в рендер, смена родителя
self.block.reparentTo(render)
# устанавливаем позицию модели
self.block.setPos(position)
# устанавливаем цвет модели
self.color = color
self.block.setColor(self.color)
# настраиваем объект для определения выделения
# вместе с моделью загружается и геометрия столкновения
# ищем узел геометрии столкновения
collisionNode = self.block.find("*").node()
# устанавливаем такую же маску ДО как и у луча выделения
collisionNode.setIntoCollideMask(BitMask32.bit(1))
# устанавливаем тег, чтобы потом определить что именно мы выделили
collisionNode.setTag('key', self.key)
def __init__(self, widget, axis):
NodePath.__init__(self, "transformWidgetAxis")
self.reparentTo(widget)
self.widget = widget
vec = Vec3(0)
vec[axis] = 1.0
self.direction = vec
self.defaultColor = Vec4(vec[0], vec[1], vec[2], 1.0)
self.rolloverColor = Vec4(vec + 0.5, 1.0)
self.downColor = Vec4(vec - 0.5, 1.0)
self.lookAt(vec)
self.setTransparency(1)
self.axisIdx = axis
box = CollisionBox(*self.getClickBox())
cnode = CollisionNode("pickBox")
cnode.addSolid(box)
cnode.setIntoCollideMask(LEGlobals.ManipulatorMask)
cnode.setFromCollideMask(BitMask32.allOff())
self.pickNp = self.attachNewNode(cnode)
self.pickNp.setPythonTag("widgetAxis", self)
self.state = Ready
self.setState(Ready)
def SetupBulletTerrain(self):
self.worldNP = self.render.attachNewNode('World')
self.world = BulletWorld()
self.world.setGravity(Vec3(0, 0, -9.81))
img = PNMImage(Filename(self.PngDEM))
if self.MeterScale < 1.1:
shape = BulletHeightfieldShape(img, self.HeightRange, ZUp)
else:
shape = BulletHeightfieldShape(img, self.HeightRange, ZUp)
shape.setUseDiamondSubdivision(True)
np = self.worldNP.attachNewNode(BulletRigidBodyNode('Heightfield'))
np.node().addShape(shape)
offset = self.MeterScale * self.PixelNr / 2.0
np.setPos(+offset, +offset,
+(self.HeightRange / 2.0) + self.OffsetHeight)
np.setSx(self.MeterScale)
np.setSy(self.MeterScale)
np.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(np.node())
def testStep(self):
viewer = None
try:
scene = SunCgSceneLoader.loadHouseFromJson(
"0004d52d1aeeb8ae6de39d6bd993e992", TEST_SUNCG_DATA_DIR)
# NOTE: show initial models loaded into the scene
for model in scene.scene.findAllMatches('**/+ModelNode'):
model.show(BitMask32.allOn())
viewer = Viewer(scene, shadowing=True)
# Configure the camera
# NOTE: in Panda3D, the X axis points to the right, the Y axis is forward, and Z is up
mat = np.array([
0.999992, 0.00394238, 0, 0, -0.00295702, 0.750104, -0.661314,
0, -0.00260737, 0.661308, 0.75011, 0, 43.621, -55.7499,
12.9722, 1
])
mat = LMatrix4f(*mat.ravel())
viewer.cam.setMat(mat)
for _ in range(20):
viewer.step()
time.sleep(1.0)
finally:
if viewer is not None:
viewer.destroy()
def showGrab(self):
self.nodePath.hide()
self.collNodePath.hide()
self.collNode.setIntoCollideMask(BitMask32(0))
if self.penalty:
self.track = Parallel(SoundInterval(self.penaltyGrabSound), Sequence(Func(self.kaboom.showThrough), LerpScaleInterval(self.kaboom, duration=0.5, scale=Point3(10, 10, 10), blendType='easeOut'), Func(self.kaboom.hide)))
self.track.start()
