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 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 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 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 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 __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 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 __init__(self,world,worldNP):
self.upperLeg = Vec3(0, 0, 0)
self.lowerLeg = Vec3(0, 0, 0)
self.kneeJointX = 0
self.hipJointX = 0
self.hipJointY = 0
self.hipJointZ = 0
self.direction = 0
self.time = 0
shape = BulletBoxShape(Vec3(4, 4, 2))
self.body = BulletRigidBodyNode('body')
bodyNP = worldNP.attachNewNode(self.body)
bodyNP.node().addShape(shape)
#bodyNP.node().setMass(2.0)
bodyNP.setCollideMask(BitMask32.allOn())
bodyNP.node().setDeactivationEnabled(False)
bodyNP.setPos(0, 0, 16)
visNP = loader.loadModel('models/box.egg')
visNP.clearModelNodes()
visNP.setScale(Vec3(4, 8, 4))
visNP.reparentTo(bodyNP)
world.attachRigidBody(self.body)
self.LLeg = Leg(0,0,"LLeg",world,worldNP,self.body,True)
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
p0 = Point3(-20, -20, 0)
p1 = Point3(-20, 20, 0)
p2 = Point3(20, -20, 0)
p3 = Point3(20, 20, 0)
mesh = BulletTriangleMesh()
mesh.addTriangle(p0, p1, p2)
mesh.addTriangle(p1, p2, p3)
shape = BulletTriangleMeshShape(mesh, dynamic=False)
np = self.worldNP.attachNewNode(BulletRigidBodyNode('Mesh'))
np.node().addShape(shape)
np.setPos(0, 0, -2)
np.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(np.node())
# Soft body world information
info = self.world.getWorldInfo()
info.setAirDensity(1.2)
info.setWaterDensity(0)
info.setWaterOffset(0)
info.setWaterNormal(Vec3(0, 0, 0))
# Softbody
for i in range(50):
p00 = Point3(-2, -2, 0)
p10 = Point3( 2, -2, 0)
p01 = Point3(-2, 2, 0)
p11 = Point3( 2, 2, 0)
node = BulletSoftBodyNode.makePatch(info, p00, p10, p01, p11, 6, 6, 0, True)
node.generateBendingConstraints(2)
node.getCfg().setLiftCoefficient(0.004)
node.getCfg().setDynamicFrictionCoefficient(0.0003)
node.getCfg().setAeroModel(BulletSoftBodyConfig.AMVertexTwoSided)
node.setTotalMass(0.1)
node.addForce(Vec3(0, 2, 0), 0)
np = self.worldNP.attachNewNode(node)
np.setPos(self.Vec3Rand() * 10 + Vec3(0, 0, 20))
np.setHpr(self.Vec3Rand() * 16)
self.world.attachSoftBody(node)
fmt = GeomVertexFormat.getV3n3t2()
geom = BulletHelper.makeGeomFromFaces(node, fmt, True)
node.linkGeom(geom)
nodeV = GeomNode('')
nodeV.addGeom(geom)
npV = np.attachNewNode(nodeV)
def buildSubType(self):
"""Build the subType that being either wall or ground"""
if self.subType == "wallType":
"""Build a wall"""
if "col" in self.name or self.isCollisionMesh:
"""Build the collision body for this wall"""
self.bulletBody = LevelPhysics.buildTriangleMesh(self.engine,
self.object, self.levelEgg, 0, self.isDynamic)
self.bulletBody.setCollideMask(self.wallMask)
self.bulletBody.setTag("Test", "TestingTag")
else:
self.object.reparentTo(self.renderObjectsLevel)
elif self.subType == "groundType":
"""Build the ground with either custom Mesh or use the plane"""
if self.useBulletPlane is True:
self.groundPlane = LevelPhysics.buildGroundPlane(self.engine)
self.object.reparentTo(self.renderObjectsLevel)
self.object.setPos(self.position)
self.object.setHpr(self.hpr)
else:
if "col" in self.name or self.isCollisionMesh:
self.bulletBody = LevelPhysics.buildTriangleMesh(self.engine,
self.object, self.levelEgg, 0, self.isDynamic)
self.bulletBody.setCollideMask(BitMask32.allOn())
else:
self.object.reparentTo(self.renderObjectsLevel)
self.object.setPos(self.position)
self.object.setHpr(self.hpr)
def setupPhysics(self, use_default_objs = True):
# setting up physics world and parent node path
self.physics_world_ = BulletWorld()
self.world_node_ = self.render.attachNewNode('world')
self.cam.reparentTo(self.world_node_)
self.cam.setPos(self.world_node_,0, -self.cam_zoom_*6, self.cam_step_*25)
self.physics_world_.setGravity(Vec3(0, 0, -9.81))
self.debug_node_ = self.world_node_.attachNewNode(BulletDebugNode('Debug'))
self.debug_node_.show()
self.debug_node_.node().showWireframe(True)
self.debug_node_.node().showConstraints(True)
self.debug_node_.node().showBoundingBoxes(False)
self.debug_node_.node().showNormals(True)
self.physics_world_.setDebugNode(self.debug_node_.node())
self.debug_node_.hide()
self.object_nodes_ = []
self.controlled_objects_ = []
self.ground_ = None
if use_default_objs:
# setting up ground
self.ground_ = self.world_node_.attachNewNode(BulletRigidBodyNode('Ground'))
self.ground_.node().addShape(BulletPlaneShape(Vec3(0, 0, 1), 0))
self.ground_.setPos(0,0,0)
self.ground_.setCollideMask(BitMask32.allOn())
self.physics_world_.attachRigidBody(self.ground_.node())
self.setupLevel()
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(True)
self.world = BulletWorld()
self.world.setGravity(Vec3(0, 0, -9.81))
self.world.setDebugNode(self.debugNP.node())
self.model = TinyDancer(self.world,self.worldNP)
#floor
shape = BulletBoxShape(Vec3(100, 100, 1))
floor = BulletRigidBodyNode('Floor')
bodyNP = self.worldNP.attachNewNode(floor)
bodyNP.node().addShape(shape)
bodyNP.setCollideMask(BitMask32.allOn())
bodyNP.setPos(0, 0, -12)
visNP = loader.loadModel('models/black.egg')
visNP.setScale(Vec3(200, 200, 2))
visNP.clearModelNodes()
visNP.reparentTo(bodyNP)
self.world.attachRigidBody(floor)
def addMeshConvexRB(self,vertices, faces,ghost=False,**kw):
#step 1) create GeomVertexData and add vertex information
format=GeomVertexFormat.getV3()
vdata=GeomVertexData("vertices", format, Geom.UHStatic)
vertexWriter=GeomVertexWriter(vdata, "vertex")
[vertexWriter.addData3f(v[0],v[1],v[2]) for v in vertices]
#step 2) make primitives and assign vertices to them
tris=GeomTriangles(Geom.UHStatic)
[self.setGeomFaces(tris,face) for face in faces]
#step 3) make a Geom object to hold the primitives
geom=Geom(vdata)
geom.addPrimitive(tris)
#step 4) create the bullet mesh and node
mesh = BulletTriangleMesh()
mesh.addGeom(geom)
shape = BulletConvexHullShape(mesh, dynamic=not ghost)#
if ghost :
inodenp = self.worldNP.attachNewNode(BulletGhostNode('Mesh'))
else :
inodenp = self.worldNP.attachNewNode(BulletRigidBodyNode('Mesh'))
inodenp.node().addShape(shape)
# inodenp.setPos(0, 0, 0.1)
self.setRB(inodenp,**kw)
inodenp.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(inodenp.node())
return inodenp
def attackMode(self,location,heading):
self.state['normal'] = False
self.state['rolling'] = True
(self.init_x,self.init_y,self.init_z) = location
self.__cylinder_shape = BulletCylinderShape(Eve.WIDTH + 2, Eve.HEIGHT - 4, XUp)
# Create bullet character controller
self.character2= BulletCharacterControllerNode(self.__cylinder_shape,0.4,self.name)
self.characterNP2 = self.__render.attachNewNode(self.character2)
self.characterNP2.setPos(self.init_x,self.init_y,self.init_z-2)
self.characterNP2.setH(heading)
self.characterNP2.setCollideMask(BitMask32.allOn())
self.__world.attachCharacter(self.character2)
self.character2.setGravity(70)
self.actorNP2.reparentTo(self.characterNP2)
self.actorNP2.setScale(4.0)
self.actorNP2.setH(180)
self.actorNP2.setPos(0,0,0)
self.currentNode = self.actorNP2
self.currentNP = self.characterNP2
self.currentControllerNode = self.character2
# Set play rate of the rolling animation
self.currentNode.setPlayRate(15,'roll')
def setupObstacles2(self):
# Obstacle
origin = Point3(2, 0, 0)
size = Vec3(2, 2.75, 1.5)
shape = BulletBoxShape(size * 0.55)
randNum1 = random.sample(range(0, 1500, 300), 3)
randNum2 = random.sample(range(0, 1500, 500), 3)
for i in range(2):
randX = random.uniform(-3.5, 3.5)
randY = float(randNum1[i])
pos = origin + size * i
ObstacleNP = self.render.attachNewNode(BulletRigidBodyNode('Obstacle%i' % i))
ObstacleNP.node().addShape(shape)
ObstacleNP.node().setMass(1.0)
ObstacleNP.setPos(randX, randY, 3)
ObstacleNP.setCollideMask(BitMask32.allOn())
modelNP = loader.loadModel('models/box.egg')
modelNP_tex = loader.loadTexture("models/sky/milkyway_tex.jpg")
modelNP.setTexture(modelNP_tex, 1)
modelNP.reparentTo(ObstacleNP)
# modelNP.setPos(0, 0, 0)
modelNP.setPos(-size.x / 2.0, -size.y / 2.0, -size.z / 2.0)
modelNP.setScale(size)
self.world2.attachRigidBody(ObstacleNP.node())
size_2 = Vec3(3, 2.75, 1.5)
shape2 = BulletBoxShape(size_2 * 0.55)
for i in range(2):
randX = random.uniform(-3.5, 3.5)
randY = float(randNum2[i])
pos = origin + size_2 * i
pos.setY(0)
ObstacleNP = self.render.attachNewNode(BulletRigidBodyNode('ObstacleSmall%i' % i))
ObstacleNP.node().addShape(shape2)
ObstacleNP.node().setMass(1.0)
ObstacleNP.setPos(randX, randY, 2)
ObstacleNP.setCollideMask(BitMask32.allOn())
modelNP = loader.loadModel('models/box.egg')
modelNP_tex = loader.loadTexture("models/sky/moon_1k_tex.jpg")
modelNP.setTexture(modelNP_tex, 1)
modelNP.reparentTo(ObstacleNP)
# modelNP.setPos(0, 0, 0)
modelNP.setPos(-size_2.x / 2.0, -size_2.y / 2.0, -size_2.z / 2.0)
modelNP.setScale(size_2)
self.world2.attachRigidBody(ObstacleNP.node())
def attach_physics(self):
# Attach `self.scene` to the physics world.
self.scene.init_tree(tags=("shape",))
bnodes = self.scene.descendants(type_=PSO)
for bnode in bnodes:
bnode.setCollideMask(BitMask32.allOn())
bnode.node().setDeactivationEnabled(False)
self.bbase.attach(bnodes)
def terrainFromHeightMap(self, main):
self.parentNodePath = NodePath("FloorNodePath")
self.parentNodePath.setPos(0, 0, -2)
self.parentNodePath.setScale(5, 5, 0.75)
# Heightfield (static)
height = 8.0
img = PNMImage(Filename('models/elevation.png'))
xdim = img.getXSize()
ydim = img.getYSize()
shape = BulletHeightfieldShape(img, height, ZUp)
shape.setUseDiamondSubdivision(True)
self.rigidNode = BulletRigidBodyNode('Heightfield')
self.rigidNode.notifyCollisions(False)
self.rigidNodePath = self.parentNodePath.attachNewNode(self.rigidNode)
self.rigidNodePath.node().addShape(shape)
self.rigidNodePath.setPos(0, 0, 0)
self.rigidNodePath.setCollideMask(BitMask32.allOn())
self.rigidNodePath.node().notifyCollisions(False)
main.world.attachRigidBody(self.rigidNodePath.node())
self.hf = self.rigidNodePath.node() # To enable/disable debug visualisation
self.terrain = GeoMipTerrain('terrain')
self.terrain.setHeightfield(img)
self.terrain.setBlockSize(32)
self.terrain.setNear(50)
self.terrain.setFar(100)
self.terrain.setFocalPoint(base.camera)
rootNP = self.terrain.getRoot()
rootNP.reparentTo(self.parentNodePath)
rootNP.setSz(8.0)
offset = img.getXSize() / 2.0 - 0.5
rootNP.setPos(-offset, -offset, -height / 2.0)
self.terrain.generate()
# Apply texture
diffuseTexture = loader.loadTexture(Filename('models/diffuseMap.jpg'))
diffuseTexture.setWrapU(Texture.WMRepeat)
diffuseTexture.setWrapV(Texture.WMRepeat)
rootNP.setTexture(diffuseTexture)
# Normal map
texStage = TextureStage('texStageNormal')
texStage.setMode(TextureStage.MNormal)
normalTexture = loader.loadTexture(Filename('models/normalMap.jpg'))
rootNP.setTexture(texStage, normalTexture)
# Glow map
texStage = TextureStage('texStageNormal')
texStage.setMode(TextureStage.MGlow)
glowTexture = loader.loadTexture(Filename('models/glowMap.jpg'))
rootNP.setTexture(texStage, glowTexture)
def doShoot(self, ccd):
if(self.fire and self.attempts > 0 and self.gameState == 'PLAY'):
self.cameraState = 'LOOK'
self.fire = False
self.candleThrow.play()
self.attempts -= 1
#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 = self.pTo - self.pFrom
ratio = v.length() / 40
v.normalize()
v *= 70.0 * ratio
torqueOffset = random.random() * 10
#create bullet
shape = BulletSphereShape(0.5)
shape01 = BulletSphereShape(0.5)
shape02 = BulletSphereShape(0.5)
shape03 = BulletSphereShape(0.5)
body = BulletRigidBodyNode('Candle')
bodyNP = self.worldNP.attachNewNode(body)
bodyNP.node().addShape(shape, TransformState.makePos(Point3(0,0,0)))
bodyNP.node().addShape(shape01, TransformState.makePos(Point3(0,0.5,-0.5)))
bodyNP.node().addShape(shape02,TransformState.makePos(Point3(0,1,-1)))
bodyNP.node().addShape(shape03,TransformState.makePos(Point3(0,1.5,-1.5)))
bodyNP.node().setMass(100)
bodyNP.node().setFriction(1.0)
bodyNP.node().setLinearVelocity(v)
bodyNP.node().applyTorque(v*torqueOffset)
bodyNP.setPos(self.pFrom)
bodyNP.setCollideMask(BitMask32.allOn())
visNP = loader.loadModel('models/projectile.X')
visNP.setScale(0.7)
visNP.clearModelNodes()
visNP.reparentTo(bodyNP)
#self.bird = bodyNP.node()
if ccd:
bodyNP.node().setCcdMotionThreshold(1e-7)
bodyNP.node().setCcdSweptSphereRadius(0.5)
self.world.attachRigidBody(bodyNP.node())
#remove the bullet again after 1 sec
self.bullets = bodyNP
taskMgr.doMethodLater(5, self.removeBullet, 'removeBullet', extraArgs=[bodyNP],
appendTask = True)
def addMultiSphereGhost(self,rads,centT,**kw):
inodenp = self.worldNP.attachNewNode(BulletGhostNode("Sphere"))
for radc, posc in zip(rads, centT):
shape = BulletSphereShape(radc)
inodenp.node().addShape(shape, TransformState.makePos(Point3(posc[0],posc[1],posc[2])))#
self.setRB(inodenp,**kw)
inodenp.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(inodenp.node())
return inodenp
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(True)
#self.debugNP.showTightBounds()
#self.debugNP.showBounds()
self.world = BulletWorld()
self.world.setGravity(Vec3(0, 0, -9.81))
self.world.setDebugNode(self.debugNP.node())
# Ground (static)
shape = BulletPlaneShape(Vec3(0, 0, 1), 1)
self.groundNP = self.worldNP.attachNewNode(BulletRigidBodyNode('Ground'))
self.groundNP.node().addShape(shape)
self.groundNP.setPos(0, 0, -2)
self.groundNP.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(self.groundNP.node())
# Box (dynamic)
shape = BulletBoxShape(Vec3(0.5, 0.5, 0.5))
self.boxNP = self.worldNP.attachNewNode(BulletRigidBodyNode('Box'))
self.boxNP.node().setMass(1.0)
self.boxNP.node().addShape(shape)
self.boxNP.setPos(0, 0, 2)
#self.boxNP.setScale(2, 1, 0.5)
self.boxNP.setCollideMask(BitMask32.allOn())
#self.boxNP.node().setDeactivationEnabled(False)
self.world.attachRigidBody(self.boxNP.node())
visualNP = loader.loadModel('models/box.egg')
visualNP.clearModelNodes()
visualNP.reparentTo(self.boxNP)
def buildGroundPlane(self):
"""Build a BulletPlane"""
shape = BulletPlaneShape(Vec3(0, 0, 1), 0)
np = self.engine.BulletObjects["level"].attachNewNode(
BulletRigidBodyNode('Ground_plane'))
np.node().addShape(shape)
np.setPos(0, 0, 0) # This thing is usually infinite
np.setCollideMask(BitMask32.allOn())
self.engine.bulletWorld.attachRigidBody(np.node())
def addRBSphere(world,pos, worldNP):
shape = BulletSphereShape(0.6)
inodenp = worldNP.attachNewNode(BulletRigidBodyNode("Sphere"))
inodenp.node().setMass(0.0)
# inodenp.node().addShape(shape)
inodenp.node().addShape(shape, TransformState.makePos(pos))
# spherenp.setPos(-2, 0, 4)
inodenp.setCollideMask(BitMask32.allOn())
world.attachRigidBody(inodenp.node())
return inodenp.node()
def addRBCube(world,pos, worldNP):
shape = BulletBoxShape(Vec3(12.5, 12.5, 12.5))
inodenp = worldNP.attachNewNode(BulletRigidBodyNode("Box"))
inodenp.node().setMass(1.0)
# inodenp.node().addShape(shape)
inodenp.node().addShape(shape, TransformState.makePos(pos))
# spherenp.setPos(-2, 0, 4)
inodenp.setCollideMask(BitMask32.allOn())
world.attachRigidBody(inodenp.node())
return inodenp.node()
def addMultiSphereRB(self,rads,centT,**kw):
inodenp = self.worldNP.attachNewNode(BulletRigidBodyNode("Sphere"))
inodenp.node().setMass(1.0)
for radc, posc in zip(rads, centT):
shape = BulletSphereShape(radc)#if radis the same can use the same shape for each node
inodenp.node().addShape(shape, TransformState.makePos(Point3(posc[0],posc[1],posc[2])))#
self.setRB(inodenp,**kw)
inodenp.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(inodenp.node())
return inodenp
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)
body = BulletRigidBodyNode('Ground')
bodyNP = self.worldNP.attachNewNode(body)
bodyNP.node().addShape(shape)
bodyNP.setPos(0, 0, -1)
bodyNP.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(bodyNP.node())
# Some boxes
shape = BulletBoxShape(Vec3(0.5, 0.5, 0.5))
for i in range(10):
for j in range(10):
x = i - 5.0
y = 0.0
z = j - 0.5
body = BulletRigidBodyNode('Box-%i-%i' % (i, j))
bodyNP = self.worldNP.attachNewNode(body)
bodyNP.node().addShape(shape)
bodyNP.node().setMass(1.0)
bodyNP.node().setDeactivationEnabled(False)
bodyNP.setPos(x, y, z)
bodyNP.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(bodyNP.node())
visNP = loader.loadModel('models/box.egg')
visNP.clearModelNodes()
visNP.reparentTo(bodyNP)
def addBox(self,name,size,pos):
# Box (dynamic)
box = self.world_node_.attachNewNode(BulletRigidBodyNode(name))
box.node().setMass(1.0)
box.node().addShape(BulletBoxShape(size))
box.setPos(pos)
box.setCollideMask(BitMask32.allOn())
self.physics_world_.attachRigidBody(box.node())
self.boxes_.append(box)
def addSingleCubeRB(self,halfextents,**kw):
shape = BulletBoxShape(Vec3(halfextents[0], halfextents[1], halfextents[2]))#halfExtents
inodenp = self.worldNP.attachNewNode(BulletRigidBodyNode("Box"))
# inodenp.node().setMass(1.0)
# inodenp.node().addShape(shape)
inodenp.node().addShape(shape,TransformState.makePos(Point3(0, 0, 0)))#, pMat)#TransformState.makePos(Point3(jtrans[0],jtrans[1],jtrans[2])))#rotation ?
# spherenp.setPos(-2, 0, 4)
self.setRB(inodenp,**kw)
inodenp.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(inodenp.node())
return inodenp
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 doShoot(self):
# 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 *= 100.0
# Create bullet
shape = BulletSphereShape(0.3)
body = BulletRigidBodyNode('Bullet')
bodyNP = self.worldNP.attachNewNode(body)
bodyNP.node().addShape(shape)
bodyNP.node().setMass(1.0)
bodyNP.node().setLinearVelocity(v)
bodyNP.node().setCcdMotionThreshold(1e-7)
bodyNP.node().setCcdSweptSphereRadius(0.50)
bodyNP.setCollideMask(BitMask32.allOn())
bodyNP.setPos(pFrom)
visNP = loader.loadModel('models/ball.egg')
visNP.setScale(0.8)
visNP.reparentTo(bodyNP)
self.world.attachRigidBody(bodyNP.node())
# Remove the bullet again after 2 seconds
taskMgr.doMethodLater(2,
self.doRemove,
'doRemove',
extraArgs=[bodyNP],
appendTask=True)
def __init__(self, scene, agentId, agentRadius=0.25):
self.scene = scene
self.agentId = agentId
agentsNp = self.scene.scene.find('**/agents')
agentNp = agentsNp.attachNewNode(agentId)
agentNp.setTag('agent-id', agentId)
scene.agents.append(agentNp)
# Define a simple sphere model
modelId = 'sphere-0'
modelFilename = os.path.join(CDIR, 'sphere.egg')
agentNp.setTag('model-id', modelId)
model = loadModel(modelFilename)
model.setColor(
LVector4f(np.random.uniform(), np.random.uniform(),
np.random.uniform(), 1.0))
model.setName('model-' + os.path.basename(modelFilename))
model.setTransform(TransformState.makeScale(agentRadius))
model.reparentTo(agentNp)
model.hide(BitMask32.allOn())
# Calculate the center of this object
minBounds, maxBounds = model.getTightBounds()
centerPos = minBounds + (maxBounds - minBounds) / 2.0
# Add offset transform to make position relative to the center
agentNp.setTransform(TransformState.makePos(centerPos))
model.setTransform(model.getTransform().compose(
TransformState.makePos(-centerPos)))
self.agentNp = agentNp
self.model = model
self.agentRbNp = None
self.rotationStepCounter = -1
self.rotationsStepDuration = 40
def setupWorld(self):
# Set the background to be black
base.win.setClearColor((0, 0, 0 ,1))
# Load Chris's Room
self.chrisRoom = loader.loadModel("Resources/models/ROOMS/ChrisRoom.egg")
self.chrisRoom.reparentTo(render)
self.chrisRoom.setPos(0, 0, -0.1)
self.chrisRoom.setScale(0.4)
# Load his laptop onto the desk
self.chrisLaptop = loader.loadModel("Resources/models/OBJ/ChrisLaptop.egg")
self.chrisLaptop.reparentTo(render)
self.chrisLaptop.setPosHpr(-5.5, 1.5, 1.0, 90, 0, 0)
self.chrisLaptop.setScale(0.8)
# TODO: Set the screen texture
#screenTexture = loader.loadTexture("Resources/maps/skypeChat.png")
#self.chrisLaptopScreen = self.chrisLaptop.find("**/screen")
#self.chrisLaptopScreen.setTexture(screenTexture, 1)
self.world = BulletWorld()
self.world.setGravity(Vec3(0, 0, -9.81))
self.worldNP = render.attachNewNode('World')
self.terrain_np = render.attach_new_node("terrain")
# Ground
ground = 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(ground)
np.setPos(0, 0, 0)
np.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(np.node())
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())
self.vehicles=dict()
def __init__(self, **kwargs):
super(gameMechanics, self).__init__()
self.joy = joystick()
self.world = BulletWorld()
self.world.setGravity(Vec3(0, 0, -9.81))
self.arena = kwargs['environment']
self.worldNp = render.attachNewNode('world')
self.worldNp.setScale(3)
self.arena.setupPhysics(world=self.worldNp, mask=BitMask32.allOn())
self.world.setDebugNode(self.arena.debugNP.node())
self.world.setDebugNode(self.arena.debugNP.node())
self.listOfPlayers = kwargs['playerslist']
self.setupCollisions(playerslist=self.listOfPlayers)
self.world.attachRigidBody(self.arena.mainNp.node())
for model in self.arena.modelList:
self.world.attachRigidBody(model.nodePath.node())
self.numofjoy = 0
taskMgr.add(self.mech_update, 'mechupdate')
self.listOfPlayers[1].characterNP.setY(self.listOfPlayers[0], -5)
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 buildTriangleMesh(self, _obj, _levelEgg, _mass=0, _isDynamic=False):
"""Build a bullet TriangleMesh for objects"""
mesh = BulletTriangleMesh()
node = _obj.node()
if node.isGeomNode():
mesh.addGeom(node.getGeom(0))
else:
return
body = BulletRigidBodyNode(_obj.getTag("level"))
body.addShape(BulletTriangleMeshShape(mesh, dynamic=_isDynamic))
body.setMass(_mass)
np = self.engine.BulletObjects["level"].attachNewNode(body)
np.setCollideMask(BitMask32.allOn())
np.setScale(_obj.getScale(_levelEgg))
np.setPos(_obj.getPos(_levelEgg))
np.setHpr(_obj.getHpr(_levelEgg))
self.engine.bulletWorld.attachRigidBody(body)
return np
def setupPhysics(self, **kwargs):
self.worldNp = kwargs['worldnp']
self.world = kwargs['world']
h = .2
w = .1
shape = BulletCapsuleShape(w, h, ZUp)
self.character = BulletCharacterControllerNode(
shape, .5, 'Player_{}'.format(self.name))
self.characterNP = self.worldNp.attachNewNode(self.character)
self.characterNP.setH(45)
self.characterNP.setCollideMask(BitMask32.allOn())
self.world.attachCharacter(self.character)
self.floater = NodePath(PandaNode('floater'))
self.floater.reparentTo(self.characterNP)
self.floater.setZ(self.characterNP, .52)
self.floater.setY(self.characterNP.getY() + .25)
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)
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 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())
# Box
shape = BulletBoxShape(Vec3(0.5, 0.5, 0.5) * 2.0)
boxNP = self.worldNP.attachNewNode(BulletRigidBodyNode('Box'))
boxNP.node().setMass(150.0)
boxNP.node().addShape(shape)
boxNP.setPos(0, 0, 2)
boxNP.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(boxNP.node())
visualNP = loader.loadModel('models/box.egg')
visualNP.clearModelNodes()
visualNP.setScale(2.0)
visualNP.reparentTo(boxNP)
# Soft body world information
info = self.world.getWorldInfo()
info.setAirDensity(1.2)
info.setWaterDensity(0)
info.setWaterOffset(0)
info.setWaterNormal(Vec3(0, 0, 0))
# Softbody
nx = 31
ny = 31
p00 = Point3(-8, -8, 0)
p10 = Point3(8, -8, 0)
p01 = Point3(-8, 8, 0)
p11 = Point3(8, 8, 0)
bodyNode = BulletSoftBodyNode.makePatch(info, p00, p10, p01, p11, nx,
ny, 1 + 2 + 4 + 8, True)
material = bodyNode.appendMaterial()
material.setLinearStiffness(0.4)
bodyNode.generateBendingConstraints(2, material)
bodyNode.setTotalMass(50.0)
bodyNode.getShape(0).setMargin(0.5)
bodyNP = self.worldNP.attachNewNode(bodyNode)
self.world.attachSoftBody(bodyNode)
# Rendering with Geom:
fmt = GeomVertexFormat.getV3n3t2()
geom = BulletHelper.makeGeomFromFaces(bodyNode, fmt, True)
bodyNode.linkGeom(geom)
visNode = GeomNode('')
visNode.addGeom(geom)
visNP = bodyNP.attachNewNode(visNode)
# Now we want to have a texture and texture coordinates.
# The geom's format has already a column for texcoords, so we just need
# to write texcoords using a GeomVertexRewriter.
tex = loader.loadTexture('models/panda.jpg')
visNP.setTexture(tex)
BulletHelper.makeTexcoordsForPatch(geom, nx, ny)
def loadHouseFromJson(houseId, datasetRoot):
filename = SunCgSceneLoader.getHouseJsonPath(datasetRoot, houseId)
with open(filename) as f:
data = json.load(f)
assert houseId == data['id']
houseId = str(data['id'])
# Create new node for house instance
houseNp = NodePath('house-' + str(houseId))
houseNp.setTag('house-id', str(houseId))
objectIds = {}
for levelId, level in enumerate(data['levels']):
logger.debug('Loading Level %s to scene' % (str(levelId)))
# Create new node for level instance
levelNp = houseNp.attachNewNode('level-' + str(levelId))
levelNp.setTag('level-id', str(levelId))
levelObjectsNp = levelNp.attachNewNode('objects')
roomNpByNodeIndex = {}
for nodeIndex, node in enumerate(level['nodes']):
if not node['valid'] == 1:
continue
if node['type'] == 'Box':
pass
elif node['type'] == 'Room':
modelId = str(node['modelId'])
logger.debug('Loading Room %s to scene' % (modelId))
# Create new nodes for room instance
instanceId = str(modelId) + '-0'
roomNp = levelNp.attachNewNode('room-' + instanceId)
roomNp.setTag('model-id', modelId)
roomNp.setTag('instance-id', instanceId)
roomNp.setTag('room-id', instanceId)
roomLayoutsNp = roomNp.attachNewNode('layouts')
roomObjectsNp = roomNp.attachNewNode('objects')
# Include some semantic information
roomTypes = []
for roomType in node['roomTypes']:
roomType = roomType.lower().strip()
if len(roomType) > 0:
roomTypes.append(roomType)
roomNp.setTag('room-types', ','.join(roomTypes))
# Load models defined for this room
for roomObjFilename in reglob(os.path.join(datasetRoot, 'room', houseId),
modelId + '[a-z].bam'):
# NOTE: loading the BAM format is faster and more efficient
# Convert extension from OBJ + MTL to BAM format
f, _ = os.path.splitext(roomObjFilename)
bamModelFilename = f + ".bam"
eggModelFilename = f + ".egg"
if os.path.exists(bamModelFilename):
modelFilename = bamModelFilename
elif os.path.exists(eggModelFilename):
modelFilename = eggModelFilename
else:
raise Exception(
'The SUNCG dataset object models need to be convert to Panda3D EGG or BAM format!')
# Create new node for object instance
objectModelId = os.path.splitext(
os.path.basename(roomObjFilename))[0]
model = loadModel(modelFilename)
instanceId = str(objectModelId) + '-0'
objectNp = NodePath('object-' + instanceId)
objectNp.setTag('model-id', objectModelId)
objectNp.setTag('instance-id', instanceId)
model.setName('model-' + os.path.basename(f))
model.reparentTo(objectNp)
model.hide(BitMask32.allOn())
for subObjectNp in subdiviseLayoutObject(objectNp):
subObjectNp.reparentTo(roomLayoutsNp)
if 'nodeIndices' in node:
for childNodeIndex in node['nodeIndices']:
roomNpByNodeIndex[childNodeIndex] = roomObjectsNp
elif node['type'] == 'Object':
modelId = str(node['modelId'])
logger.debug('Loading Object %s to scene' % (modelId))
# Instance identification
if modelId in objectIds:
objectIds[modelId] = objectIds[modelId] + 1
else:
objectIds[modelId] = 0
# Create new node for object instance
instanceId = str(modelId) + '-' + str(objectIds[modelId])
objectNp = NodePath('object-' + instanceId)
objectNp.setTag('model-id', modelId)
objectNp.setTag('instance-id', instanceId)
# NOTE: loading the BAM format is faster and more efficient
# Convert extension from OBJ + MTL to BAM format
objFilename = os.path.join(
datasetRoot, 'object', node['modelId'], node['modelId'] + '.bam')
assert os.path.exists(objFilename)
f, _ = os.path.splitext(objFilename)
bamModelFilename = f + ".bam"
eggModelFilename = f + ".egg"
if os.path.exists(bamModelFilename):
modelFilename = bamModelFilename
elif os.path.exists(eggModelFilename):
modelFilename = eggModelFilename
else:
raise Exception(
'The SUNCG dataset object models need to be convert to Panda3D EGG or BAM format!')
model = loadModel(modelFilename)
model.setName('model-' + os.path.basename(f))
model.reparentTo(objectNp)
model.hide(BitMask32.allOn())
# 4x4 column-major transformation matrix from object
# coordinates to scene coordinates
transform = np.array(node['transform']).reshape((4, 4))
# Transform from Y-UP to Z-UP coordinate systems
# TODO: use Mat4.convertMat(CS_zup_right, CS_yup_right)
yupTransform = np.array([[1, 0, 0, 0],
[0, 0, -1, 0],
[0, 1, 0, 0],
[0, 0, 0, 1]])
zupTransform = np.array([[1, 0, 0, 0],
[0, 0, 1, 0],
[0, -1, 0, 0],
[0, 0, 0, 1]])
transform = np.dot(
np.dot(yupTransform, transform), zupTransform)
transform = TransformState.makeMat(
LMatrix4f(*transform.ravel()))
# Calculate the center of this object
minBounds, maxBounds = model.getTightBounds()
centerPos = minBounds + (maxBounds - minBounds) / 2.0
# Add offset transform to make position relative to the
# center
objectNp.setTransform(transform.compose(
TransformState.makePos(centerPos)))
model.setTransform(TransformState.makePos(-centerPos))
# Get the parent nodepath for the object (room or level)
if nodeIndex in roomNpByNodeIndex:
objectNp.reparentTo(roomNpByNodeIndex[nodeIndex])
else:
objectNp.reparentTo(levelObjectsNp)
# Validation
assert np.allclose(mat4ToNumpyArray(model.getNetTransform().getMat()),
mat4ToNumpyArray(transform.getMat()), atol=1e-6)
elif node['type'] == 'Ground':
modelId = str(node['modelId'])
logger.debug('Loading Ground %s to scene' % (modelId))
# Create new nodes for ground instance
instanceId = str(modelId) + '-0'
groundNp = levelNp.attachNewNode('ground-' + instanceId)
groundNp.setTag('instance-id', instanceId)
groundNp.setTag('model-id', modelId)
groundNp.setTag('ground-id', instanceId)
groundLayoutsNp = groundNp.attachNewNode('layouts')
# Load model defined for this ground
for groundObjFilename in reglob(os.path.join(datasetRoot, 'room', houseId),
modelId + '[a-z].bam'):
# NOTE: loading the BAM format is faster and more efficient
# Convert extension from OBJ + MTL to BAM format
f, _ = os.path.splitext(groundObjFilename)
bamModelFilename = f + ".bam"
eggModelFilename = f + ".egg"
if os.path.exists(bamModelFilename):
modelFilename = bamModelFilename
elif os.path.exists(eggModelFilename):
modelFilename = eggModelFilename
else:
raise Exception(
'The SUNCG dataset object models need to be convert to Panda3D EGG or BAM format!')
objectModelId = os.path.splitext(
os.path.basename(groundObjFilename))[0]
instanceId = str(objectModelId) + '-0'
objectNp = NodePath('object-' + instanceId)
objectNp.reparentTo(groundLayoutsNp)
objectNp.setTag('model-id', objectModelId)
objectNp.setTag('instance-id', instanceId)
model = loadModel(modelFilename)
model.setName('model-' + os.path.basename(f))
model.reparentTo(objectNp)
model.hide(BitMask32.allOn())
else:
raise Exception('Unsupported node type: %s' %
(node['type']))
scene = Scene('house-' + houseId)
houseNp.reparentTo(scene.scene)
# Recenter objects in rooms
for room in scene.scene.findAllMatches('**/room*'):
# Calculate the center of this room
bounds = room.getTightBounds()
if bounds is not None:
minBounds, maxBounds = room.getTightBounds()
centerPos = minBounds + (maxBounds - minBounds) / 2.0
# Add offset transform to room node
room.setTransform(TransformState.makePos(centerPos))
# Add recentering transform to all children nodes
for childNp in room.getChildren():
childNp.setTransform(TransformState.makePos(-centerPos))
else:
# This usually means the room has no layout or objects
pass
# Recenter objects in grounds
for ground in scene.scene.findAllMatches('**/ground*'):
# Calculate the center of this ground
minBounds, maxBounds = ground.getTightBounds()
centerPos = minBounds + (maxBounds - minBounds) / 2.0
# Add offset transform to ground node
ground.setTransform(TransformState.makePos(centerPos))
# Add recentering transform to all children nodes
for childNp in ground.getChildren():
childNp.setTransform(TransformState.makePos(-centerPos))
return scene
def load_scene(self):
# ground
sandbox = loader.loadModel('maps/practice/sandbox')
np = self.root_node.attachNewNode(BulletRigidBodyNode('Mesh'))
np.node().addShape(bullet_shape_from(sandbox))
np.setPos(0, 0, 0)
np.setCollideMask(BitMask32.allOn())
self.physics.world.attachRigidBody(np.node())
sandbox.reparentTo(np)
moon = DirectionalLight('moon')
moon.setColor(hex_to_rgb('ffffff'))
moon.setShadowCaster(True, 2048, 2048)
moon_np = self.root_node.attachNewNode(moon)
moon_np.setPos(-5, -5, 10)
moon_np.lookAt(0, 0, 0)
self.root_node.setLight(moon_np)
moon = DirectionalLight('sun')
moon.setColor(hex_to_rgb('666666'))
moon.setShadowCaster(True, 2048, 2048)
moon_np = self.root_node.attachNewNode(moon)
moon_np.setPos(5, 5, 10)
moon_np.lookAt(0, 0, 0)
self.root_node.setLight(moon_np)
# dynamic sphere
np = self.root_node.attachNewNode(BulletRigidBodyNode('Sphere'))
np.node().addShape(BulletSphereShape(1))
np.node().setMass(3.0)
np.setPos(5, 5, 2)
self.physics.world.attachRigidBody(np.node())
ball = loader.loadModel('geometry/ball')
ball.reparentTo(np)
self.char_marks.add('ball', ball, OnscreenText(text='sphere', scale=0.07), 1)
# dynamic box
np = self.root_node.attachNewNode(BulletRigidBodyNode('Box'))
np.node().addShape(BulletBoxShape(Vec3(0.5, 0.5, 0.5)))
np.node().setMass(1.0)
np.setPos(-1, -2, 2)
self.physics.world.attachRigidBody(np.node())
np.node().applyCentralImpulse((0, 2, 7))
box = loader.loadModel('geometry/box')
box.reparentTo(np)
self.char_marks.add('box', box, OnscreenText(text='cube', scale=0.06), 0.5)
# static
np = self.root_node.attachNewNode(BulletRigidBodyNode('Static'))
np.node().addShape(BulletBoxShape(Vec3(0.5, 0.5, 0.5)))
np.setPos(1, 2, 0.8)
self.physics.world.attachRigidBody(np.node())
box = loader.loadModel('geometry/box')
box.reparentTo(np)
def move_box(task):
angle_degrees = task.time * 12.0
if angle_degrees > 360:
angle_degrees -= 360
angle_radians = angle_degrees * (pi / 180)
np.setPos(5 * sin(angle_radians), -5 * cos(angle_radians), .5)
np.setHpr(angle_degrees, 4, 0)
return task.cont
base.taskMgr.add(move_box, 'move_box')
self.char_marks.add('static', box, OnscreenText(text='static', scale=0.08), 0.5)
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(np.random.randn()*3, np.random.randn()*3, 0))
self.world.setDebugNode(self.debugNP.node())
# Ground
p0 = Point3(-20, -20, 0)
p1 = Point3(-20, 20, 0)
p2 = Point3(20, -20, 0)
p3 = Point3(20, 20, 0)
mesh = BulletTriangleMesh()
mesh.addTriangle(p0, p1, p2)
mesh.addTriangle(p1, p2, p3)
shape = BulletTriangleMeshShape(mesh, dynamic=False)
npp = self.worldNP.attachNewNode(BulletRigidBodyNode('Mesh'))
npp.node().addShape(shape)
npp.setPos(0, 0, -2)
npp.setCollideMask(BitMask32.allOn())
self.ground = npp
self.world.attachRigidBody(npp.node())
# Soft body world information
info = self.world.getWorldInfo()
info.setAirDensity(1.2)
info.setWaterDensity(0)
info.setWaterOffset(0)
info.setWaterNormal(Vec3(0, 0, 0))
# Softbody
def makeSB(pos, hpr):
model = loader.loadModel('moleculemesh/smoothed/clathrinfixsmth%02d.obj' % np.random.randint(1,21))
geom = model.findAllMatches('**/+GeomNode').getPath(0).node().modifyGeom(0)
geomNode = GeomNode('')
geomNode.addGeom(geom)
node = BulletSoftBodyNode.makeTriMesh(info, geom)
node.linkGeom(geomNode.modifyGeom(0))
node.generateBendingConstraints(2)
node.getCfg().setPositionsSolverIterations(6)
node.getCfg().setCollisionFlag(BulletSoftBodyConfig.CFVertexFaceSoftSoft, True)
node.randomizeConstraints()
node.setTotalMass(50, True)
node.getMaterial(0).setLinearStiffness(0.2)
#node.getCfg().setDynamicFrictionCoefficient(1)
#node.getCfg().setDampingCoefficient(0.001)
node.getCfg().setPressureCoefficient(1500)
softNP = self.worldNP.attachNewNode(node)
softNP.setPos(pos)
softNP.setHpr(hpr)
self.world.attachSoftBody(node)
geomNP = softNP.attachNewNode(geomNode)
#softNP.node().appendAnchor(1, self.ground.node())
softNP.node().appendAnchor(1217, self.ground.node())
softNP.node().appendAnchor(1157, self.ground.node())
softNP.node().appendAnchor(2052, self.ground.node())
#softNP.node().appendAnchor(1800, self.ground.node())
softNP.reparentTo(self.mybase)
#makeSB(Point3(-3, 0, 4), (0, 0, 0))
#makeSB(Point3(0, 0, 4), (0, 90, 90))
makeSB(Point3(4+np.random.randn(), 2+np.random.randn(), 4), (0, 0, 0))
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(True)
self.world = BulletWorld()
self.world.setGravity(Vec3(0, 0, -9.81))
self.world.setDebugNode(self.debugNP.node())
# Plane (static)
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 (dynamic)
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.setPos(0, 0, 4)
np.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(np.node())
self.boxNP = np # For applying force & torque
#np.node().notifyCollisions(True)
#self.accept('bullet-contact-added', self.doAdded)
#self.accept('bullet-contact-destroyed', self.doRemoved)
# Sphere (dynamic)
shape = BulletSphereShape(0.6)
np = self.worldNP.attachNewNode(BulletRigidBodyNode('Sphere'))
np.node().setMass(1.0)
np.node().addShape(shape)
np.setPos(-4, 0, 4)
np.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(np.node())
# Cone (dynamic)
shape = BulletConeShape(0.6, 1.2, ZUp)
np = self.worldNP.attachNewNode(BulletRigidBodyNode('Cone'))
np.node().setMass(1.0)
np.node().addShape(shape)
np.setPos(4, 0, 4)
np.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(np.node())
# Capsule (dynamic)
shape = BulletCapsuleShape(0.5, 1.0, ZUp)
np = self.worldNP.attachNewNode(BulletRigidBodyNode('Capsule'))
np.node().setMass(1.0)
np.node().addShape(shape)
np.setPos(0, 4, 4)
np.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(np.node())
# Cyliner (dynamic)
shape = BulletCylinderShape(0.7, 1.5, ZUp)
np = self.worldNP.attachNewNode(BulletRigidBodyNode('Cylinder'))
np.node().setMass(1.0)
np.node().addShape(shape)
np.setPos(4, 4, 4)
np.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(np.node())
# Convex (dynamic)
shape = BulletConvexHullShape()
shape.addPoint(Point3(1, 1, 2))
shape.addPoint(Point3(0, 0, 0))
shape.addPoint(Point3(2, 0, 0))
shape.addPoint(Point3(0, 2, 0))
shape.addPoint(Point3(2, 2, 0))
# Another way to create the convex hull shape:
#shape = BulletConvexHullShape()
#shape.addArray([
# Point3(1, 1, 2),
# Point3(0, 0, 0),
# Point3(2, 0, 0),
# Point3(0, 2, 0),
# Point3(2, 2, 0),
#])
# Yet another way to create the convex hull shape:
#geom = loader.loadModel('models/box.egg')\
# .findAllMatches('**/+GeomNode')\
# .getPath(0)\
# .node()\
# .getGeom(0)
#shape = BulletConvexHullShape()
#shape.addGeom(geom)
np = self.worldNP.attachNewNode(BulletRigidBodyNode('Convex'))
np.node().setMass(1.0)
np.node().addShape(shape)
np.setPos(-4, 4, 4)
np.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(np.node())
# Mesh (static)
p0 = Point3(-10, -10, 0)
p1 = Point3(-10, 10, 0)
p2 = Point3(10, -10, 0)
p3 = Point3(10, 10, 0)
mesh = BulletTriangleMesh()
mesh.addTriangle(p0, p1, p2)
mesh.addTriangle(p1, p2, p3)
shape = BulletTriangleMeshShape(mesh, dynamic=False)
# Another way to create the triangle mesh shape:
#geom = loader.loadModel('models/box.egg')\
# .findAllMatches('**/+GeomNode')\
# .getPath(0)\
# .node()\
# .getGeom(0)
#mesh = BulletTriangleMesh()
#mesh.addGeom(geom)
#shape = BulletTriangleMeshShape(mesh, dynamic=False)
np = self.worldNP.attachNewNode(BulletRigidBodyNode('Mesh'))
np.node().addShape(shape)
np.setPos(0, 0, 0.1)
np.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(np.node())
# MutiSphere
points = [Point3(-1, 0, 0), Point3(0, 0, 0), Point3(1, 0, 0)]
radii = [.4, .8, .6]
shape = BulletMultiSphereShape(points, radii)
np = self.worldNP.attachNewNode(BulletRigidBodyNode('MultiSphere'))
np.node().setMass(1.0)
np.node().addShape(shape)
np.setPos(8, 0, 4)
np.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(np.node())
def setup(self):
self.worldNP = render.attachNewNode('World')
# World
self.debugNP = self.worldNP.attachNewNode(BulletDebugNode('Debug'))
self.debugNP.show()
self.debugNP.node().showNormals(True)
self.world = BulletWorld()
self.world.setGravity(Vec3(0, 0, -9.81))
self.world.setDebugNode(self.debugNP.node())
# Box (dynamic)
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.setPos(0, 0, 4)
np.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(np.node())
self.boxNP = np # For applying force & torque
visualNP = loader.loadModel('models/box.egg')
visualNP.clearModelNodes()
visualNP.reparentTo(self.boxNP)
# Heightfield (static)
height = 8.0
img = PNMImage(Filename('models/elevation.png'))
shape = BulletHeightfieldShape(img, height, ZUp)
shape.setUseDiamondSubdivision(True)
np = self.worldNP.attachNewNode(BulletRigidBodyNode('Heightfield'))
np.node().addShape(shape)
np.setPos(0, 0, 0)
np.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(np.node())
self.hf = np.node() # To enable/disable debug visualisation
self.terrain = GeoMipTerrain('terrain')
self.terrain.setHeightfield(img)
self.terrain.setBlockSize(32)
self.terrain.setNear(50)
self.terrain.setFar(100)
self.terrain.setFocalPoint(base.camera)
rootNP = self.terrain.getRoot()
rootNP.reparentTo(render)
rootNP.setSz(8.0)
offset = img.getXSize() / 2.0 - 0.5
rootNP.setPos(-offset, -offset, -height / 2.0)
self.terrain.generate()
def setup(self):
self.targetAlt = r.randrange(100,300)
self.Valves = np.array([0.15,0.2,0.15])
self.EngObs = self.vulcain.predict_data_point(np.array(self.Valves).reshape(1,-1))
if self.VISUALIZE is True:
self.worldNP = self.render.attachNewNode('World')
else:
self.root = NodePath(PandaNode("world root"))
self.worldNP = self.root.attachNewNode('World')
self.world = BulletWorld()
self.world.setGravity(Vec3(0, 0, -9.80665))
# World
self.debugNP = self.worldNP.attachNewNode(BulletDebugNode('Debug'))
self.debugNP.node().showWireframe(True)
self.debugNP.node().showConstraints(True)
self.debugNP.node().showBoundingBoxes(False)
self.debugNP.node().showNormals(True)
self.debugNP.show()
self.world.setDebugNode(self.debugNP.node())
# self.debugNP.showTightBounds()
# self.debugNP.showBounds()
# Ground (static)
shape = BulletPlaneShape(Vec3(0, 0, 1), 1)
self.groundNP = self.worldNP.attachNewNode(BulletRigidBodyNode('Ground'))
self.groundNP.node().addShape(shape)
self.groundNP.setPos(0, 0, 0)
self.groundNP.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(self.groundNP.node())
# Rocket
shape = BulletCylinderShape(self.radius, self.length, ZUp)
self.rocketNP = self.worldNP.attachNewNode(BulletRigidBodyNode('Cylinder'))
self.rocketNP.node().setMass(27200 * self.scale)
self.rocketNP.node().addShape(shape)
#self.rocketNP.setPos(20,20,250)
self.rocketNP.setPos(20, 20, r.randrange(100, 300)+200)
#self.rocketNP.setPos(r.randrange(-self.lateralError, self.lateralError, 1), r.randrange(-self.lateralError, self.lateralError, 1), self.height)
# self.rocketNP.setPos(0, 0, self.length*10)
self.rocketNP.setCollideMask(BitMask32.allOn())
# self.rocketNP.node().setCollisionResponse(0)
self.rocketNP.node().notifyCollisions(True)
self.world.attachRigidBody(self.rocketNP.node())
for i in range(4):
leg = BulletCylinderShape(0.1 * self.radius, 0.5 * self.length, XUp)
self.rocketNP.node().addShape(leg, TransformState.makePosHpr(
Vec3(6 * self.radius * math.cos(i * math.pi / 2), 6 * self.radius * math.sin(i * math.pi / 2),
-0.6 * self.length), Vec3(i * 90, 0, 30)))
shape = BulletConeShape(0.75 * self.radius, 0.5 * self.radius, ZUp)
self.rocketNP.node().addShape(shape, TransformState.makePosHpr(Vec3(0, 0, -1 / 2 * self.length), Vec3(0, 0, 0)))
# Fuel
self.fuelRadius = 0.9 * self.radius
shape = BulletCylinderShape(self.fuelRadius, 0.01 * self.length, ZUp)
self.fuelNP = self.worldNP.attachNewNode(BulletRigidBodyNode('Cone'))
self.fuelNP.node().setMass(self.fuelMass_full * self.fuelMass_init)
self.fuelNP.node().addShape(shape)
self.fuelNP.setPos(0, 0, self.rocketNP.getPos().getZ() - self.length * 0.5 * (1 - self.fuelMass_init))
self.fuelNP.setCollideMask(BitMask32.allOn())
self.fuelNP.node().setCollisionResponse(0)
self.world.attachRigidBody(self.fuelNP.node())
frameA = TransformState.makePosHpr(Point3(0, 0, 0), Vec3(0, 0, 90))
frameB = TransformState.makePosHpr(Point3(0, 0, 0), Vec3(0, 0, 90))
self.fuelSlider = BulletSliderConstraint(self.rocketNP.node(), self.fuelNP.node(), frameA, frameB, 1)
self.fuelSlider.setTargetLinearMotorVelocity(0)
self.fuelSlider.setDebugDrawSize(2.0)
self.fuelSlider.set_lower_linear_limit(0)
self.fuelSlider.set_upper_linear_limit(0)
self.world.attachConstraint(self.fuelSlider)
self.npThrustForce = LineNodePath(self.rocketNP, 'Thrust', thickness=4, colorVec=Vec4(1, 0.5, 0, 1))
self.npDragForce = LineNodePath(self.rocketNP, 'Drag', thickness=4, colorVec=Vec4(1, 0, 0, 1))
self.npLiftForce = LineNodePath(self.rocketNP, 'Lift', thickness=4, colorVec=Vec4(0, 0, 1, 1))
self.npFuelState = LineNodePath(self.fuelNP, 'Fuel', thickness=20, colorVec=Vec4(0, 1, 0, 1))
self.rocketCSLon = self.radius ** 2 * math.pi
self.rocketCSLat = self.length * 2 * self.radius
if self.VISUALIZE is True:
self.terrain = loader.loadModel("LZGrid2.egg")
self.terrain.setScale(10)
self.terrain.reparentTo(self.render)
self.terrain.setColor(Vec4(0.1, 0.2, 0.1, 1))
self.toggleTexture()
#self.fuelNP.setPos(0, 0, self.rocketNP.getPos().getZ() - self.length * 0.4 * (1 - self.fuelMass_init))
for i in range(5):
self.world.doPhysics(self.dt, 5, 1.0 / 180.0)
self.fuelSlider.set_lower_linear_limit(-self.length * 0.5 * (1 - self.fuelMass_init))
self.fuelSlider.set_upper_linear_limit(self.length * 0.5 * (1 - self.fuelMass_init))
for i in range(100):
self.world.doPhysics(self.dt, 5, 1.0 / 180.0)
self.rocketNP.node().applyForce(Vec3(0,0,300000), Vec3(0, 0, 0))
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())
# Ground
shape = BulletPlaneShape(Vec3(0, 0, 1), 0)
body = BulletRigidBodyNode('Ground')
bodyNP = self.worldNP.attachNewNode(body)
bodyNP.node().addShape(shape)
bodyNP.setPos(0, 0, 0)
bodyNP.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(bodyNP.node())
# Bowl
visNP = loader.loadModel('models/bowl.egg')
geom = visNP.findAllMatches('**/+GeomNode').getPath(0).node().getGeom(
0)
mesh = BulletTriangleMesh()
mesh.addGeom(geom)
shape = BulletTriangleMeshShape(mesh, dynamic=True)
body = BulletRigidBodyNode('Bowl')
bodyNP = self.worldNP.attachNewNode(body)
bodyNP.node().addShape(shape)
bodyNP.node().setMass(10.0)
bodyNP.setPos(0, 0, 0)
bodyNP.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(bodyNP.node())
visNP.reparentTo(bodyNP)
self.bowlNP = bodyNP
self.bowlNP.setScale(2)
# Eggs
self.eggNPs = []
for i in range(5):
x = random.gauss(0, 0.1)
y = random.gauss(0, 0.1)
z = random.gauss(0, 0.1) + 1
h = random.random() * 360
p = random.random() * 360
r = random.random() * 360
visNP = loader.loadModel('models/egg.egg')
geom = visNP.findAllMatches('**/+GeomNode').getPath(
0).node().getGeom(0)
shape = BulletConvexHullShape()
shape.addGeom(geom)
body = BulletRigidBodyNode('Egg-%i' % i)
bodyNP = self.worldNP.attachNewNode(body)
bodyNP.node().setMass(1.0)
bodyNP.node().addShape(shape)
bodyNP.node().setDeactivationEnabled(False)
bodyNP.setCollideMask(BitMask32.allOn())
bodyNP.setPosHpr(x, y, z, h, p, r)
#bodyNP.setScale(1.5)
self.world.attachRigidBody(bodyNP.node())
visNP.reparentTo(bodyNP)
self.eggNPs.append(bodyNP)
def hideViewModel(self):
self.viewModel.hide(BitMask32.allOn())
def __init__(self,
pg_world,
show_navi_mark: bool = False,
random_navi_mark_color=False,
show_dest_mark=False,
show_line_to_dest=False):
"""
This class define a helper for localizing vehicles and retrieving navigation information.
It now only support from first block start to the end node, but can be extended easily.
"""
self.map = None
self.final_road = None
self.checkpoints = None
self.final_lane = None
self.current_ref_lanes = None
self.current_road = None
self._target_checkpoints_index = None
self._navi_info = np.zeros(
(self.navigation_info_dim, )) # navi information res
self.navi_mark_color = (
0.6, 0.8,
0.5) if not random_navi_mark_color else get_np_random().rand(3)
# Vis
self._is_showing = True # store the state of navigation mark
self._show_navi_info = (
pg_world.mode == RENDER_MODE_ONSCREEN
and not pg_world.world_config["debug_physics_world"])
self._dest_node_path = None
self._goal_node_path = None
self._arrow_node_path = None
self._line_to_dest = None
self._show_line_to_dest = show_line_to_dest
if self._show_navi_info:
# nodepath
self._line_to_dest = pg_world.render.attachNewNode("line")
self._goal_node_path = pg_world.render.attachNewNode("target")
self._dest_node_path = pg_world.render.attachNewNode("dest")
self._arrow_node_path = pg_world.aspect2d.attachNewNode("arrow")
navi_arrow_model = AssetLoader.loader.loadModel(
AssetLoader.file_path("models", "navi_arrow.gltf"))
navi_arrow_model.setScale(0.1, 0.12, 0.2)
navi_arrow_model.setPos(2, 1.15, -0.221)
self._left_arrow = self._arrow_node_path.attachNewNode(
"left arrow")
self._left_arrow.setP(180)
self._right_arrow = self._arrow_node_path.attachNewNode(
"right arrow")
self._left_arrow.setColor(self.MARK_COLOR)
self._right_arrow.setColor(self.MARK_COLOR)
navi_arrow_model.instanceTo(self._left_arrow)
navi_arrow_model.instanceTo(self._right_arrow)
self._arrow_node_path.setPos(0, 0, 0.08)
self._arrow_node_path.hide(BitMask32.allOn())
self._arrow_node_path.show(CamMask.MainCam)
self._arrow_node_path.setQuat(
LQuaternionf(np.cos(-np.pi / 4), 0, 0, np.sin(-np.pi / 4)))
# the transparency attribute of gltf model is invalid on windows
# self._arrow_node_path.setTransparency(TransparencyAttrib.M_alpha)
if show_navi_mark:
navi_point_model = AssetLoader.loader.loadModel(
AssetLoader.file_path("models", "box.bam"))
navi_point_model.reparentTo(self._goal_node_path)
if show_dest_mark:
dest_point_model = AssetLoader.loader.loadModel(
AssetLoader.file_path("models", "box.bam"))
dest_point_model.reparentTo(self._dest_node_path)
if show_line_to_dest:
line_seg = LineSegs("line_to_dest")
line_seg.setColor(self.navi_mark_color[0],
self.navi_mark_color[1],
self.navi_mark_color[2], 0.7)
line_seg.setThickness(2)
self._dynamic_line_np = NodePath(line_seg.create(True))
self._dynamic_line_np.reparentTo(pg_world.render)
self._line_to_dest = line_seg
self._goal_node_path.setTransparency(TransparencyAttrib.M_alpha)
self._dest_node_path.setTransparency(TransparencyAttrib.M_alpha)
self._goal_node_path.setColor(self.navi_mark_color[0],
self.navi_mark_color[1],
self.navi_mark_color[2], 0.7)
self._dest_node_path.setColor(self.navi_mark_color[0],
self.navi_mark_color[1],
self.navi_mark_color[2], 0.7)
self._goal_node_path.hide(BitMask32.allOn())
self._dest_node_path.hide(BitMask32.allOn())
self._goal_node_path.show(CamMask.MainCam)
self._dest_node_path.show(CamMask.MainCam)
logging.debug("Load Vehicle Module: {}".format(
self.__class__.__name__))
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(-4, 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(1, 0, 0)
visNP = loader.loadModel('models/box.egg')
visNP.clearModelNodes()
visNP.reparentTo(bodyNP)
self.world.attachRigidBody(bodyB)
# Generic
frameA = TransformState.makePosHpr(Point3(4, 0, 0), Vec3(0, 0, 0))
frameB = TransformState.makePosHpr(Point3(2, 0, 0), Vec3(0, 0, 0))
generic = BulletGenericConstraint(bodyA, bodyB, frameA, frameB, True)
generic.setDebugDrawSize(2.0)
generic.setLinearLimit(0, 0, 0)
generic.setLinearLimit(1, 0, 3)
generic.setLinearLimit(2, 0, 1)
generic.setAngularLimit(0, -60, 60)
generic.setAngularLimit(1, -30, 30)
generic.setAngularLimit(2, -120, 120)
self.world.attachConstraint(generic)
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())
#terrain = GeoMipTerrain("mySimpleTerrain")
#terrain.setHeightfield("./models/heightfield_2.png")
#terrain.getRoot().reparentTo(self.worldNP)#render)
#terrain.generate()
# 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())
np = self.worldNP.attachNewNode(BulletRigidBodyNode('Track'))
np.node().setMass(5000.0)
np.setPos(3, 0, 10)
np.setCollideMask(BitMask32.allOn()) #(0x0f))
#self.track = BulletVehicle(self.world, np.node())
#self.track.setCoordinateSystem(ZUp)
self.track_np = loader.loadModel('models/race_track.egg')
self.track_np.setScale(100)
self.track_np.reparentTo(np)
self.track_np.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(np.node())
self.track_np = np
#self.track_np.show()
# Chassis
shape = BulletBoxShape(Vec3(0.6, 1.4, 0.5))
ts = TransformState.makePos(Point3(0, 0, 0.5))
np = self.worldNP.attachNewNode(BulletRigidBodyNode('Vehicle'))
np.node().addShape(shape, ts)
np.setPos(0, 0, 1)
np.node().setMass(800.0)
np.node().setDeactivationEnabled(False)
self.world.attachRigidBody(np.node())
#np.node().setCcdSweptSphereRadius(1.0)
#np.node().setCcdMotionThreshold(1e-7)
self.cTrav = CollisionTraverser()
# Vehicle
self.vehicle = BulletVehicle(self.world, np.node())
self.vehicle.setCoordinateSystem(ZUp)
self.yugoNP = loader.loadModel('models/yugo/yugo.egg')
self.yugoNP.reparentTo(np)
self.colHandler = CollisionHandlerQueue()
self.ray_col_np = {}
self.ray_col_vec_dict = {}
for ray_dir in range(-1, 2): # populate collision rays
self.ray = CollisionRay()
self.ray.setOrigin(ray_dir, 0.5, 0.5)
self.ray.setDirection(ray_dir, 1, 0)
self.ray_col = CollisionNode('ray%d' % (ray_dir + 1))
self.ray_col.addSolid(self.ray)
self.ray_col.setFromCollideMask(
BitMask32.allOn()) #(0x0f))#CollideMask.bit(0)
#self.ray_col.setIntoCollideMask(CollideMask.allOff())
self.ray_col_np['ray%d' %
(ray_dir + 1)] = self.yugoNP.attachNewNode(
self.ray_col)
self.cTrav.addCollider(self.ray_col_np['ray%d' % (ray_dir + 1)],
self.colHandler)
self.ray_col_np['ray%d' % (ray_dir + 1)].show()
self.ray_col_vec_dict['ray%d' % (ray_dir + 1)] = []
self.world.attachVehicle(self.vehicle)
self.cTrav.showCollisions(render)
# FIXME
base.camera.reparentTo(self.yugoNP)
# Right front wheel
np = loader.loadModel('models/yugo/yugotireR.egg')
np.reparentTo(self.worldNP)
self.addWheel(Point3(0.70, 1.05, 0.3), True, np)
# Left front wheel
np = loader.loadModel('models/yugo/yugotireL.egg')
np.reparentTo(self.worldNP)
self.addWheel(Point3(-0.70, 1.05, 0.3), True, np)
# Right rear wheel
np = loader.loadModel('models/yugo/yugotireR.egg')
np.reparentTo(self.worldNP)
self.addWheel(Point3(0.70, -1.05, 0.3), False, np)
# Left rear wheel
np = loader.loadModel('models/yugo/yugotireL.egg')
np.reparentTo(self.worldNP)
self.addWheel(Point3(-0.70, -1.05, 0.3), False, np)
# Steering info
self.steering = 0.0 # degree
self.steeringClamp = 45.0 # degree
self.steeringIncrement = 120.0 # degree per second
# Box
for i, j in [(0, 8), (-3, 5), (6, -5), (8, 3), (-4, -4)]:
shape = BulletBoxShape(Vec3(0.5, 0.5, 0.5))
# https://discourse.panda3d.org/t/wall-collision-help/23606
np = self.worldNP.attachNewNode(BulletRigidBodyNode('Box'))
np.node().setMass(1.0)
np.node().addShape(shape)
np.setPos(i, j, 2)
np.setCollideMask(BitMask32.allOn()) #(0x0f))
self.world.attachRigidBody(np.node())
self.boxNP = np
#self.colHandler2 = CollisionHandlerQueue()
visualNP = loader.loadModel('models/box.egg')
visualNP.reparentTo(self.boxNP)
#self.cTrav.addCollider(self.boxNP,self.colHandler)
"""
aNode = CollisionNode("TheRay")
self.ray = CollisionRay()
self.ray.setOrigin( self.yugoNP.getPos() )
self.ray.setDirection( Vec3(0, 10, 0) )
#self.ray.show()
aNodePath = self.yugoNP.attachNewNode( CollisionNode("TheRay") )
aNodePath.node().addSolid(self.ray)
aNodePath.show()
"""
#aNode.addSolid(self.ray)
#self.ray = CollisionRay(0,0,0,10,0,0)
#self.ray.reparentTo(self.yugoNP)
#self.rayColl = CollisionNode('PlayerRay')
#self.rayColl.addSolid(self.ray)
#self.playerRayNode = self.yugoNP.attachNewNode( self.rayColl )
#self.playerRayNode.show()
#base.myTraverser.addCollider (self.playerRayNode, base.floor)
#base.floor.addCollider( self.playerRayNode, self.yugoNP)
"""
def setup(self):
#self.targetAlt = r.randrange(100,300)
self.Valves = np.array([0.15, 0.2, 0.15])
self.EngObs = self.vulcain.predict_data_point(
np.array(self.Valves).reshape(1, -1))
if self.VISUALIZE is True:
self.worldNP = self.render.attachNewNode('World')
else:
self.root = NodePath(PandaNode("world root"))
self.worldNP = self.root.attachNewNode('World')
self.world = BulletWorld()
self.world.setGravity(Vec3(0, 0, -9.80665))
# World
self.debugNP = self.worldNP.attachNewNode(BulletDebugNode('Debug'))
self.debugNP.node().showWireframe(True)
self.debugNP.node().showConstraints(True)
self.debugNP.node().showBoundingBoxes(False)
self.debugNP.node().showNormals(True)
self.debugNP.show()
self.world.setDebugNode(self.debugNP.node())
# self.debugNP.showTightBounds()
# self.debugNP.showBounds()
# Ground (static)
shape = BulletPlaneShape(Vec3(0, 0, 1), 1)
self.groundNP = self.worldNP.attachNewNode(
BulletRigidBodyNode('Ground'))
self.groundNP.node().addShape(shape)
self.groundNP.setPos(0, 0, 0)
self.groundNP.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(self.groundNP.node())
# Rocket
shape = BulletCylinderShape(self.radius, self.length, ZUp)
self.rocketNP = self.worldNP.attachNewNode(
BulletRigidBodyNode('Cylinder'))
self.rocketNP.node().setMass(self.drymass + self.fuelAmount_LH2 +
self.fuelAmount_LOX)
self.rocketNP.node().addShape(shape)
#self.rocketNP.setPos(20,20,250)
self.rocketNP.setPos(r.randrange(-200, 200), 20,
350) #r.randrange(300, 500))
#self.rocketNP.setPos(r.randrange(-self.lateralError, self.lateralError, 1), r.randrange(-self.lateralError, self.lateralError, 1), self.height)
# self.rocketNP.setPos(0, 0, self.length*10)
self.rocketNP.setCollideMask(BitMask32.allOn())
# self.rocketNP.node().setCollisionResponse(0)
self.rocketNP.node().notifyCollisions(True)
self.world.attachRigidBody(self.rocketNP.node())
for i in range(4):
leg = BulletCylinderShape(0.1 * self.radius, 0.5 * self.length,
XUp)
self.rocketNP.node().addShape(
leg,
TransformState.makePosHpr(
Vec3(6 * self.radius * math.cos(i * math.pi / 2),
6 * self.radius * math.sin(i * math.pi / 2),
-0.6 * self.length), Vec3(i * 90, 0, 30)))
shape = BulletConeShape(0.75 * self.radius, 0.5 * self.radius, ZUp)
self.rocketNP.node().addShape(
shape,
TransformState.makePosHpr(Vec3(0, 0, -1 / 2 * self.length),
Vec3(0, 0, 0)))
self.npThrustForce = LineNodePath(self.rocketNP,
'Thrust',
thickness=4,
colorVec=Vec4(1, 0.5, 0, 1))
self.npDragForce = LineNodePath(self.rocketNP,
'Drag',
thickness=4,
colorVec=Vec4(1, 0, 0, 1))
self.npLiftForce = LineNodePath(self.rocketNP,
'Lift',
thickness=4,
colorVec=Vec4(0, 0, 1, 1))
self.rocketCSLon = self.radius**2 * math.pi
self.rocketCSLat = self.length * 2 * self.radius
if self.VISUALIZE is True:
self.terrain = loader.loadModel("../LZGrid2.egg")
self.terrain.setScale(10)
self.terrain.reparentTo(self.render)
self.terrain.setColor(Vec4(0.1, 0.2, 0.1, 1))
self.toggleTexture()
def __init__(self):
"""Start the app."""
self.base = ShowBase()
self.base.disableMouse()
filters = CommonFilters(self.base.win, self.base.cam)
filters.setBloom(blend=(0, 0, 0, 1))
self.base.render.setShaderAuto(
BitMask32.allOn() & ~BitMask32.bit(Shader.BitAutoShaderGlow))
ts = TextureStage('ts')
ts.setMode(TextureStage.MGlow)
tex = self.base.loader.loadTexture('models/black.png')
self.base.render.setTexture(ts, tex)
self.terrain = Terrain(self.base.render, self.base.loader)
minimap_size = 200
self.minimap = Minimap(
self.base.win.makeDisplayRegion(
1 - minimap_size / self.base.win.getProperties().getXSize(), 1,
1 - minimap_size / self.base.win.getProperties().getYSize(),
1))
self.minimap.node_path.reparentTo(self.base.render)
# self.light_nodes =
self.set_lights()
self.set_fog()
self.key_state = dict.fromkeys(Object.values(config.key_map.character),
False)
self.set_key_state_handler()
self.game_state = "pause"
self.toggle_pause()
self.selection = Selection(self.base.loader, self.terrain.geom_node)
self.selection_text = OnscreenText(
mayChange=True,
scale=0.07,
align=TextNode.ALeft,
pos=(0.02 - self.base.getAspectRatio(), 1 - 0.07))
self.timer_text = OnscreenText(mayChange=True,
scale=0.07,
align=TextNode.ALeft,
pos=(0.02 - self.base.getAspectRatio(),
-1 + 0.02 + 0.07))
self.enemies = set()
self.base.accept(config.key_map.utility.pause, self.toggle_pause)
self.base.accept(
"q", lambda: self.selection.advance_tower(self.base.loader))
self.base.accept("mouse1", self.player_click)
self.base.cam.node().setCameraMask(BitMask32.bit(0))
self.base.setBackgroundColor(*config.map_params.colors.sky)
self.player = Player()
self.base.taskMgr.add(lambda task: self.terrain.start_up(), "start up")
self.mouse_pos = (0.0, 0.0)
self.base.taskMgr.add(self.move_player_task, "move_player_task")
self.base.taskMgr.add(self.move_enemies_task, "move_enemies_task")
self.base.taskMgr.add(self.player_select_task, "player_select_task")
self.base.taskMgr.add(self.tower_task, "tower_task")
self.base.taskMgr.add(self.check_end_game, "check_end_game_task")
rand = Random()
rand.seed(config.map_params.seed)
self.base.taskMgr.doMethodLater(1,
self.clock_task,
'clock_task',
extraArgs=[rand])
self.rounds = 0
self.coin = 40
def testRenderHouseWithAcousticsPath(self):
scene = SunCgSceneLoader.loadHouseFromJson(
"0004d52d1aeeb8ae6de39d6bd993e992", TEST_SUNCG_DATA_DIR)
agentNp = scene.agents[0]
agentNp.setPos(LVecBase3f(45, -42.5, 1.6))
agentNp.setHpr(45, 0, 0)
# Define a sound source
sourceSize = 0.25
modelId = 'source-0'
modelFilename = os.path.join(TEST_DATA_DIR, 'models', 'sphere.egg')
objectsNp = scene.scene.attachNewNode('objects')
objectsNp.setTag('acoustics-mode', 'source')
objectNp = objectsNp.attachNewNode('object-' + modelId)
model = loadModel(modelFilename)
model.setName('model-' + modelId)
model.setTransform(TransformState.makeScale(sourceSize))
model.reparentTo(objectNp)
objectNp.setPos(LVecBase3f(39, -40.5, 1.5))
samplingRate = 16000.0
hrtf = CipicHRTF(os.path.join(TEST_DATA_DIR, 'hrtf', 'cipic_hrir.mat'),
samplingRate)
acoustics = EvertAcoustics(scene,
hrtf,
samplingRate,
maximumOrder=2,
debug=True)
# Attach sound to object
filename = os.path.join(TEST_DATA_DIR, 'audio', 'toilet.ogg')
sound = EvertAudioSound(filename)
acoustics.attachSoundToObject(sound, objectNp)
sound.play()
acoustics.step(0.0)
# Hide ceilings
for nodePath in scene.scene.findAllMatches(
'**/layouts/*/acoustics/*c'):
nodePath.hide(BitMask32.allOn())
viewer = Viewer(scene, interactive=False)
# Configure the camera
# NOTE: in Panda3D, the X axis points to the right, the Y axis is forward, and Z is up
center = agentNp.getNetTransform().getPos()
mat = np.array([[1.0, 0.0, 0.0, 0.0], [0.0, 0.0, -1.0, 0.0],
[0.0, 1.0, 0.0, 0.0], [center.x, center.y, 20, 1]])
mat = LMatrix4f(*mat.ravel())
viewer.cam.setMat(mat)
for _ in range(20):
viewer.step()
time.sleep(1.0)
viewer.destroy()
viewer.graphicsEngine.removeAllWindows()
# Calculate and show impulse responses
impulse = acoustics.calculateImpulseResponse(objectNp.getName(),
agentNp.getName())
fig = plt.figure()
plt.plot(impulse.impulse[0], color='b', label='Left channel')
plt.plot(impulse.impulse[1], color='g', label='Right channel')
plt.legend()
plt.show(block=False)
time.sleep(1.0)
plt.close(fig)
acoustics.destroy()
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)
np = self.ground = self.worldNP.attachNewNode(
BulletRigidBodyNode('Ground'))
np.node().addShape(shape)
np.setPos(0, 0, -1)
np.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(np.node())
# collision
self.maze = []
for pos in [(0.0, 72.0, 0.0), (-11.0, 60.0, 0.0), (11.0, 60.0, 0.0),
(-11.0, 48.0, 0.0), (11.0, 48.0, 0.0), (-11.0, 36.0, 0.0),
(11.0, 36.0, 0.0), (-11.0, 24.0, 0.0), (11.0, 24.0, 0.0),
(-11.0, 12.0, 0.0), (11.0, 12.0, 0.0), (-11.0, 0.0, 0.0),
(11.0, 0.0, 0.0), (0.0, -12.0, 0.0), (0.5, 12.0, 1.0),
(-0.5, 12.0, 1.0)]:
translate = False
if (abs(pos[0]) == 0.5):
translate = True
visNP = loader.loadModel('../models/ball.egg')
else:
visNP = loader.loadModel('../models/maze.egg')
visNP.clearModelNodes()
visNP.reparentTo(self.ground)
visNP.setPos(pos[0], pos[1], pos[2])
bodyNPs = BulletHelper.fromCollisionSolids(visNP, True)
for bodyNP in bodyNPs:
bodyNP.reparentTo(render)
if translate:
bodyNP.setPos(pos[0], pos[1], pos[2] - 1)
else:
bodyNP.setPos(pos[0], pos[1], pos[2])
if isinstance(bodyNP.node(), BulletRigidBodyNode):
bodyNP.node().setMass(0.0)
bodyNP.node().setKinematic(True)
self.maze.append(bodyNP)
for bodyNP in self.maze:
self.world.attachRigidBody(bodyNP.node())
# Chassis
mass = rospy.get_param('~mass')
#chassis_shape = rospy.get_param('~chassis_shape')
shape = BulletBoxShape(Vec3(0.6, 1.4, 0.5))
ts = TransformState.makePos(Point3(0, 0, 0.5))
np = self.worldNP.attachNewNode(BulletRigidBodyNode('Vehicle'))
np.node().addShape(shape, ts)
rand_vals = numpy.random.random(2) * 8 - 4.0
np.setPos(rand_vals[0], 0.0, -0.6)
np.node().setMass(mass)
np.node().setDeactivationEnabled(False)
first_person = rospy.get_param('~first_person')
self.camera_sensor = Panda3dCameraSensor(base,
color=True,
depth=True,
size=(160, 90))
self.camera_node = self.camera_sensor.cam
if first_person:
self.camera_node.reparentTo(np)
self.camera_node.setPos(0.0, 1.0, 1.0)
self.camera_node.lookAt(0.0, 6.0, 0.0)
else:
self.camera_node.reparentTo(np)
self.camera_node.setPos(0.0, -10.0, 5.0)
self.camera_node.lookAt(0.0, 5.0, 0.0)
base.cam.reparentTo(np)
base.cam.setPos(0.0, -10.0, 5.0)
base.cam.lookAt(0.0, 5.0, 0.0)
self.world.attachRigidBody(np.node())
np.node().setCcdSweptSphereRadius(1.0)
np.node().setCcdMotionThreshold(1e-7)
# Vehicle
self.vehicle_node = np.node()
self.vehicle = BulletVehicle(self.world, np.node())
self.vehicle.setCoordinateSystem(ZUp)
self.world.attachVehicle(self.vehicle)
self.yugoNP = loader.loadModel('../models/yugo/yugo.egg')
self.yugoNP.reparentTo(np)
# Right front wheel
np = loader.loadModel('../models/yugo/yugotireR.egg')
np.reparentTo(self.worldNP)
self.addWheel(Point3(0.70, 1.05, 0.3), True, np)
# Left front wheel
np = loader.loadModel('../models/yugo/yugotireL.egg')
np.reparentTo(self.worldNP)
self.addWheel(Point3(-0.70, 1.05, 0.3), True, np)
# Right rear wheel
np = loader.loadModel('../models/yugo/yugotireR.egg')
np.reparentTo(self.worldNP)
self.addWheel(Point3(0.70, -1.05, 0.3), False, np)
# Left rear wheel
np = loader.loadModel('../models/yugo/yugotireL.egg')
np.reparentTo(self.worldNP)
self.addWheel(Point3(-0.70, -1.05, 0.3), False, np)
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
p0 = Point3(-20, -20, 0)
p1 = Point3(-20, 20, 0)
p2 = Point3(20, -20, 0)
p3 = Point3(20, 20, 0)
mesh = BulletTriangleMesh()
mesh.addTriangle(p0, p1, p2)
mesh.addTriangle(p1, p2, p3)
shape = BulletTriangleMeshShape(mesh, dynamic=False)
np = self.worldNP.attachNewNode(BulletRigidBodyNode('Mesh'))
np.node().addShape(shape)
np.setPos(0, 0, -2)
np.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(np.node())
# Soft body world information
info = self.world.getWorldInfo()
info.setAirDensity(1.2)
info.setWaterDensity(0)
info.setWaterOffset(0)
info.setWaterNormal(Vec3(0, 0, 0))
# Softbody
def makeSB(pos, hpr):
import torus
geom = torus.makeGeom()
#geom = loader.loadModel('models/torus.egg') \
# .findAllMatches('**/+GeomNode').getPath(0).node() \
# .modifyGeom(0)
geomNode = GeomNode('')
geomNode.addGeom(geom)
node = BulletSoftBodyNode.makeTriMesh(info, geom)
node.linkGeom(geomNode.modifyGeom(0))
node.generateBendingConstraints(2)
node.getCfg().setPositionsSolverIterations(2)
node.getCfg().setCollisionFlag(
BulletSoftBodyConfig.CFVertexFaceSoftSoft, True)
node.randomizeConstraints()
node.setTotalMass(50, True)
softNP = self.worldNP.attachNewNode(node)
softNP.setPos(pos)
softNP.setHpr(hpr)
self.world.attachSoftBody(node)
geomNP = softNP.attachNewNode(geomNode)
makeSB(Point3(-3, 0, 4), (0, 0, 0))
makeSB(Point3(0, 0, 4), (0, 90, 90))
makeSB(Point3(3, 0, 4), (0, 0, 0))
def _initObjects(self):
# Load objects
for model in self.scene.scene.findAllMatches(
'**/objects/object*/model*'):
modelId = model.getParent().getTag('model-id')
# XXX: we could create BulletGhostNode instance for non-collidable objects, but we would need to filter out the collisions later on
if not modelId in self.openedDoorModelIds:
shape, transform = getCollisionShapeFromModel(
model, self.objectMode, defaultCentered=True)
node = BulletRigidBodyNode('physics')
node.addShape(shape)
node.setFriction(self.defaultMaterialFriction)
node.setRestitution(self.defaultMaterialRestitution)
node.setIntoCollideMask(BitMask32.allOn())
node.setDeactivationEnabled(True)
if self.suncgDatasetRoot is not None:
# Check if it is a movable object
category = self.modelCatMapping.getCoarseGrainedCategoryForModelId(
modelId)
if category in self.movableObjectCategories:
# Estimate mass of object based on volumetric data and default material density
objVoxFilename = os.path.join(self.suncgDatasetRoot,
'object_vox',
'object_vox_data',
modelId,
modelId + '.binvox')
voxelData = ObjectVoxelData.fromFile(objVoxFilename)
mass = Panda3dBulletPhysics.defaultDensity * voxelData.getFilledVolume(
)
node.setMass(mass)
else:
node.setMass(0.0)
node.setStatic(True)
else:
node.setMass(0.0)
node.setStatic(True)
if node.isStatic():
model.getParent().setTag('physics-mode', 'static')
else:
model.getParent().setTag('physics-mode', 'dynamic')
# Attach the physic-related node to the scene graph
physicsNp = model.getParent().attachNewNode(node)
physicsNp.setTransform(transform)
# Reparent render and acoustics nodes (if any) below the new physic node
#XXX: should be less error prone to just reparent all children (except the hidden model)
renderNp = model.getParent().find('**/render')
if not renderNp.isEmpty():
renderNp.reparentTo(physicsNp)
acousticsNp = model.getParent().find('**/acoustics')
if not acousticsNp.isEmpty():
acousticsNp.reparentTo(physicsNp)
# NOTE: we need this to update the transform state of the internal bullet node
node.setTransformDirty()
# NOTE: we need to add the node to the bullet engine only after setting all attributes
self.bulletWorld.attach(node)
# Validation
assert np.allclose(
mat4ToNumpyArray(physicsNp.getNetTransform().getMat()),
mat4ToNumpyArray(
model.getParent().getNetTransform().getMat()),
atol=1e-6)
else:
logger.debug('Object %s ignored from physics' % (modelId))
def setup(self):
#World
self.world = BulletWorld()
self.world.setGravity(Vec3(0, 0, -9.81))
#Ground
shape = BulletPlaneShape(Vec3(0, 0, 1), 1)
self.ground = BulletRigidBodyNode('Ground')
self.ground.addShape(shape)
self.groundNp = render.attachNewNode(self.ground)
self.groundNp.setPos(0, 0, 0)
self.groundNp.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(self.ground)
#BoxPyramid1
self.pyramid1 = loader.loadModel("models/pyramid/Pyramid")
self.pyramid1.reparentTo(render)
self.pyramid1.setScale(.5)
self.pyramid1.setPos(0,-400,0)
mesh = BulletTriangleMesh()
for geomNP in self.pyramid1.findAllMatches('**/+GeomNode'):
geomNode = geomNP.node()
ts = geomNP.getTransform(self.pyramid1)
for geom in geomNode.getGeoms():
mesh.addGeom(geom, ts)
shape2 = BulletTriangleMeshShape(mesh, dynamic=False)
self.node = BulletRigidBodyNode('BoxPyramid1')
self.node.setMass(0)
self.node.addShape(shape2)
self.np = render.attachNewNode(self.node)
self.np.setPos(0, -400, 0)
self.np.setScale(1.65)
self.np.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(self.node)
#BoxPyramid2
self.pyramid2 = loader.loadModel("models/pyramid/Pyramid")
self.pyramid2.reparentTo(render)
self.pyramid2.setScale(.25)
self.pyramid2.setPos(180,-400,0)
mesh2 = BulletTriangleMesh()
for geomNP in self.pyramid2.findAllMatches('**/+GeomNode'):
geomNode = geomNP.node()
ts = geomNP.getTransform(self.pyramid2)
for geom in geomNode.getGeoms():
mesh2.addGeom(geom, ts)
shape3 = BulletTriangleMeshShape(mesh2, dynamic=False)
self.node3 = BulletRigidBodyNode('BoxPyramid2')
self.node3.setMass(0)
self.node3.addShape(shape3)
self.np3 = render.attachNewNode(self.node3)
self.np3.setPos(180, -400, 0)
self.np3.setScale(0.85)
self.np3.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(self.node3)
#BoxPyramid3
self.pyramid3 = loader.loadModel("models/pyramid/Pyramid")
self.pyramid3.reparentTo(render)
self.pyramid3.setScale(.25)
self.pyramid3.setPos(-180,-400,0)
mesh3 = BulletTriangleMesh()
for geomNP in self.pyramid3.findAllMatches('**/+GeomNode'):
geomNode = geomNP.node()
ts = geomNP.getTransform(self.pyramid3)
for geom in geomNode.getGeoms():
mesh3.addGeom(geom, ts)
shape4 = BulletTriangleMeshShape(mesh2, dynamic=False)
self.node4 = BulletRigidBodyNode('BoxPyramid3')
self.node4.setMass(0)
self.node4.addShape(shape4)
self.np4 = render.attachNewNode(self.node4)
self.np4.setPos(-180, -400, 0)
self.np4.setScale(0.85)
self.np4.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(self.node4)
#BoxSphinx
self.sphinx = loader.loadModel("models/sphinx/Sphinx")
self.sphinx.reparentTo(render)
self.sphinx.setScale(.08)
self.sphinx.setPos(100,-50,20)
shape5 = BulletBoxShape(Vec3(18, 55, 30))
self.node5 = BulletRigidBodyNode('BoxSphinx')
self.node5.setMass(0)
self.node5.addShape(shape5)
self.np5 = render.attachNewNode(self.node5)
self.np5.setPos(100, -50, 10)
self.np5.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(self.node5)
#start
blocks_tex6 = loader.loadTexture("models/blocks_tex6.jpg")
self.box1= loader.loadModel("models/box/box3")
self.box1.reparentTo(render)
self.box1.setScale(10,400,10)
self.box1.setPos(-300,850,0)
shape8 = BulletBoxShape(Vec3(8, 315, 13.5))
self.node8 = BulletRigidBodyNode('Box1')
self.node8.setMass(0)
self.node8.addShape(shape8)
self.np8 = render.attachNewNode(self.node8)
self.np8.setPos(-300, 850, 10)
self.np8.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(self.node8)
self.box2= loader.loadModel("models/box/box3")
self.box2.reparentTo(render)
self.box2.setScale(10,400,10)
self.box2.setPos(-350,850,0)
shape9 = BulletBoxShape(Vec3(8, 315, 13.5))
self.node9 = BulletRigidBodyNode('Box2')
self.node9.setMass(0)
self.node9.addShape(shape9)
self.np9 = render.attachNewNode(self.node9)
self.np9.setPos(-350, 850, 10)
self.np9.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(self.node9)
self.box3= loader.loadModel("models/box/box4")
self.box3.reparentTo(render)
self.box3.setScale(40,10,10)
self.box3.setPos(-325,543,0)
shape10 = BulletBoxShape(Vec3(30, 8, 13.5))
self.node10 = BulletRigidBodyNode('Box3')
self.node10.setMass(0)
self.node10.addShape(shape10)
self.np10 = render.attachNewNode(self.node10)
self.np10.setPos(-325, 543, 10)
self.np10.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(self.node10)
self.box4= loader.loadModel("models/box/box4")
self.box4.reparentTo(render)
self.box4.setScale(40,10,10)
self.box4.setPos(-325,1157,0)
shape11 = BulletBoxShape(Vec3(30, 8, 13.5))
self.node11 = BulletRigidBodyNode('Box4')
self.node11.setMass(0)
self.node11.addShape(shape11)
self.np11 = render.attachNewNode(self.node11)
self.np11.setPos(-325, 1157, 10)
self.np11.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(self.node11)
#Stars 1
self.stairsList = [0] * 10
self.stairsListNp = [0] * 10
n5 = 0
for i in range(10):
n5 += 2
self.stairsList[i]= loader.loadModel("models/box/box1")
self.stairsList[i].reparentTo(render)
self.stairsList[i].setScale(1.3)
self.stairsList[i].setPos(-325,925-(n5*1.2),n5)
self.stairsList[i].setHpr(0,0,90)
shape6 = BulletBoxShape(Vec3(3.2, 1.1, 1.1))
node6 = BulletRigidBodyNode('Box5 '+str(i))
node6.setMass(0)
node6.addShape(shape6)
self.stairsListNp[i] = render.attachNewNode(node6)
self.stairsListNp[i].setPos(-325, 925-(n5*1.2), n5)
self.stairsListNp[i].setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(node6)
self.n5Upstairs = n5
self.box6= loader.loadModel("models/box/box1")
self.box6.reparentTo(render)
self.box6.setScale(10,87,0.2)
self.box6.setPos(-325,829,n5)
self.shape12 = BulletBoxShape(Vec3(8, 70, 0.75))
self.node12 = BulletRigidBodyNode('Box6')
self.node12.setMass(0)
self.node12.addShape(self.shape12)
self.np12 = render.attachNewNode(self.node12)
self.np12.setPos(-325, 829, n5)
self.np12.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(self.node12)
self.box7= loader.loadModel("models/box/box2")
self.box7.reparentTo(render)
self.box7.setScale(5,12,0.25)
self.box7.setPos(-325,749,n5)
shape13 = BulletBoxShape(Vec3(4, 10, 0.8))
self.node13 = BulletRigidBodyNode('Box7')
self.node13.setMass(0)
self.node13.addShape(shape13)
self.np13 = render.attachNewNode(self.node13)
self.np13.setPos(-325, 749, n5)
self.np13.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(self.node13)
box7Interval1 = self.box7.posInterval(3.3, Point3(-325, 749, n5+5),
startPos=Point3(-325, 749, n5-5))
np13Interval1 = self.np13.posInterval(3, Point3(-325, 749, n5+5),
startPos=Point3(-325, 749, n5-5))
box7Interval2 = self.box7.posInterval(3.3, Point3(-325, 749, n5-5),
startPos=Point3(-325, 749, n5+5))
np13Interval2 = self.np13.posInterval(3, Point3(-325, 749, n5-5),
startPos=Point3(-325, 749, n5+5))
self.box7Pace = Sequence(Parallel(box7Interval1,np13Interval1),
Parallel(box7Interval2,np13Interval2),
name="box7Pace")
self.box7Pace.loop()
self.box8= loader.loadModel("models/box/box2")
self.box8.reparentTo(render)
self.box8.setScale(5,12,0.25)
self.box8.setPos(-325,725,n5)
shape14 = BulletBoxShape(Vec3(4, 10, 0.8))
node14 = BulletRigidBodyNode('Box8')
node14.setMass(0)
node14.addShape(shape14)
self.np14 = render.attachNewNode(node14)
self.np14.setPos(-325, 725, n5)
self.np14.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(node14)
box8Interval1 = self.box8.posInterval(3.3, Point3(-325, 725, n5-5),
startPos=Point3(-325, 725, n5+5))
np14Interval1 = self.np14.posInterval(3, Point3(-325, 725, n5-5),
startPos=Point3(-325, 725, n5+5))
box8Interval2 = self.box8.posInterval(3.3, Point3(-325, 725, n5+5),
startPos=Point3(-325, 725, n5-5))
np14Interval2 = self.np14.posInterval(3, Point3(-325, 725, n5+5),
startPos=Point3(-325, 725, n5-5))
self.box8Pace = Sequence(Parallel(box8Interval1,np14Interval1),
Parallel(box8Interval2,np14Interval2),
name="box8Pace")
self.box8Pace.loop()
self.Cylinder1= loader.loadModel("models/Cylinder/Cylinder")
self.Cylinder1.reparentTo(render)
self.Cylinder1.setScale(8,8,0.2)
self.Cylinder1.setPos(-322,700,n5)
self.Cylinder1.setTexture(blocks_tex6, 1)
radius = 8
height = 1
shape16 = BulletCylinderShape(radius, height, ZUp)
self.node16 = BulletRigidBodyNode('Cylinder1')
self.node16.setMass(0)
self.node16.addShape(shape16)
self.np16 = render.attachNewNode(self.node16)
self.np16.setPos(-322, 700, n5)
self.np16.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(self.node16)
self.Cylinder2= loader.loadModel("models/Cylinder/Cylinder")
self.Cylinder2.reparentTo(render)
self.Cylinder2.setScale(8,8,0.2)
self.Cylinder2.setPos(-327,680,n5)
self.Cylinder2.setTexture(blocks_tex6, 1)
radius = 8
height = 1
shape17 = BulletCylinderShape(radius, height, ZUp)
self.node17 = BulletRigidBodyNode('Cylinder2')
self.node17.setMass(0)
self.node17.addShape(shape17)
self.np17 = render.attachNewNode(self.node17)
self.np17.setPos(-327, 680, n5)
self.np17.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(self.node17)
self.Cylinder3= loader.loadModel("models/Cylinder/Cylinder")
self.Cylinder3.reparentTo(render)
self.Cylinder3.setScale(8,8,0.2)
self.Cylinder3.setPos(-322,660,n5)
self.Cylinder3.setTexture(blocks_tex6, 1)
radius = 8
height = 1
shape18 = BulletCylinderShape(radius, height, ZUp)
self.node18 = BulletRigidBodyNode('Cylinder3')
self.node18.setMass(0)
self.node18.addShape(shape18)
self.np18 = render.attachNewNode(self.node18)
self.np18.setPos(-322, 660, n5)
self.np18.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(self.node18)
self.Cylinder4= loader.loadModel("models/Cylinder/Cylinder")
self.Cylinder4.reparentTo(render)
self.Cylinder4.setScale(8,8,0.2)
self.Cylinder4.setPos(-327,640,n5)
self.Cylinder4.setTexture(blocks_tex6, 1)
radius = 8
height = 1
shape19 = BulletCylinderShape(radius, height, ZUp)
self.node19 = BulletRigidBodyNode('Cylinder4')
self.node19.setMass(0)
self.node19.addShape(shape19)
self.np19 = render.attachNewNode(self.node19)
self.np19.setPos(-327, 640, n5)
self.np19.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(self.node19)
self.fire= loader.loadModel("models/stop_sign/stop_sign")
self.fire.setScale(0.01)
self.fire.reparentTo(render)
self.fire.setPos(-327,640,n5+5)
#setup the items to be collected
self.setupItems()
self.setupEndPoint()
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())
# Chassis
shape = BulletBoxShape(Vec3(0.6, 1.4, 0.5))
ts = TransformState.makePos(Point3(0, 0, 0.5))
np = self.worldNP.attachNewNode(BulletRigidBodyNode('Vehicle'))
np.node().addShape(shape, ts)
np.setPos(0, 0, 1)
np.node().setMass(800.0)
np.node().setDeactivationEnabled(False)
self.world.attachRigidBody(np.node())
#np.node().setCcdSweptSphereRadius(1.0)
#np.node().setCcdMotionThreshold(1e-7)
# Vehicle
self.vehicle = BulletVehicle(self.world, np.node())
self.vehicle.setCoordinateSystem(ZUp)
self.world.attachVehicle(self.vehicle)
self.yugoNP = loader.loadModel('car/yugo.egg')
self.yugoNP.reparentTo(np)
# Right front wheel
np = loader.loadModel('car/yugotireR.egg')
np.reparentTo(self.worldNP)
self.addWheel(Point3(0.70, 1.05, 0.3), True, np)
# Left front wheel
np = loader.loadModel('car/yugotireL.egg')
np.reparentTo(self.worldNP)
self.addWheel(Point3(-0.70, 1.05, 0.3), True, np)
# Right rear wheel
np = loader.loadModel('car/yugotireR.egg')
np.reparentTo(self.worldNP)
self.addWheel(Point3(0.70, -1.05, 0.3), False, np)
# Left rear wheel
np = loader.loadModel('car/yugotireL.egg')
np.reparentTo(self.worldNP)
self.addWheel(Point3(-0.70, -1.05, 0.3), False, np)
# Steering info
self.steering = 0.0 # degree
self.steeringClamp = 45.0 # degree
self.steeringIncrement = 120.0 # degree per second
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())
# Soft body world information
info = self.world.getWorldInfo()
info.setAirDensity(1.2)
info.setWaterDensity(0)
info.setWaterOffset(0)
info.setWaterNormal(Vec3(0, 0, 0))
# Softbody
def make(p1):
n = 8
p2 = p1 + Vec3(10, 0, 0)
bodyNode = BulletSoftBodyNode.makeRope(info, p1, p2, n, 1)
bodyNode.setTotalMass(50.0)
bodyNP = self.worldNP.attachNewNode(bodyNode)
self.world.attachSoftBody(bodyNode)
# Render option 1: Line geom
#geom = BulletSoftBodyNode.makeGeomFromLinks(bodyNode)
#bodyNode.linkGeom(geom)
#visNode = GeomNode('')
#visNode.addGeom(geom)
#visNP = bodyNP.attachNewNode(visNode)
# Render option 2: NURBS curve
curve = NurbsCurveEvaluator()
curve.reset(n + 2)
bodyNode.linkCurve(curve)
visNode = RopeNode('')
visNode.setCurve(curve)
visNode.setRenderMode(RopeNode.RMTube)
visNode.setUvMode(RopeNode.UVParametric)
visNode.setNumSubdiv(4)
visNode.setNumSlices(8)
visNode.setThickness(0.4)
visNP = self.worldNP.attachNewNode(visNode)
#visNP = bodyNP.attachNewNode(visNode) # --> renders with offset!!!
visNP.setTexture(loader.loadTexture('models/iron.jpg'))
#bodyNP.showBounds()
#visNP.showBounds()
return bodyNP
np1 = make(Point3(-2, -1, 8))
np2 = make(Point3(-2, 1, 8))
# Box
shape = BulletBoxShape(Vec3(2, 2, 6))
boxNP = self.worldNP.attachNewNode(BulletRigidBodyNode('Box'))
boxNP.node().setMass(50.0)
boxNP.node().addShape(shape)
boxNP.setPos(10, 0, 8)
boxNP.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(boxNP.node())
np1.node().appendAnchor(np1.node().getNumNodes() - 1, boxNP.node())
np2.node().appendAnchor(np1.node().getNumNodes() - 1, boxNP.node())
visNP = loader.loadModel('models/box.egg')
visNP.clearModelNodes()
visNP.setScale(4, 4, 12)
visNP.reparentTo(boxNP)
