def genHand(self, handz=100.0):
# fgr0
boxx = 5.0
boxy = 2.0
boxz = 20.0
boxpx = 0.0
boxpy = 10.0
boxpz = handz
shape = BulletBoxShape(Vec3(boxx, boxy, boxz)) # the parameters are half extends
node = BulletRigidBodyNode('fgr0')
node.addShape(shape)
node.setTransform(TransformState.makePos(VBase3(boxpx, boxpy, boxpz)))
self.bltWorld.attachRigidBody(node)
pg.plotBox(self.base.render, pos=[boxpx, boxpy, boxpz], x=boxx * 2.0, y=boxy * 2.0, z=boxz * 2.0, rgba=None)
# fgr1
boxx = 5.0
boxy = 2.0
boxz = 20.0
boxpx = 0.0
boxpy = -10.0
boxpz = handz
shape = BulletBoxShape(Vec3(boxx, boxy, boxz)) # the parameters are half extends
node = BulletRigidBodyNode('fgr1')
node.addShape(shape)
node.setTransform(TransformState.makePos(VBase3(boxpx, boxpy, boxpz)))
self.bltWorld.attachRigidBody(node)
pg.plotBox(self.base.render, pos=[boxpx, boxpy, boxpz], x=boxx * 2.0, y=boxy * 2.0, z=boxz * 2.0, rgba=None)
class Akis(Enemy):
def createCharacter(self):
self.shape = BulletBoxShape(Vec3(0.4, 0.4, 0.85))
self.actor = BulletRigidBodyNode('Akis')
self.actor.setMass(5.0)
self.np = self.render.attachNewNode(self.actor)
self.np.node().addShape(self.shape)
self.np.setPos(self.x, self.y, self.z)
self.np.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(self.np.node())
self.actorModelNP = Actor('models/SecurityGuard/SecurityGuard.egg', {
'run': 'models/SecurityGuard/SecurityGuard-run.egg'})
self.actorModelNP.reparentTo(self.np)
self.actorModelNP.setScale(0.3048)
self.actorModelNP.setH(180)
self.actorModelNP.setPos(0, 0, 0.27)
self.actorModelNP.loop('run')
def move(self, player):
playerNP = player.getCharacterNP()
self.np.lookAt(playerNP.getX(), playerNP.getY(), self.np.getZ())
vec = playerNP.getPos() - self.np.getPos()
vec.setZ(0)
dist = vec.length()
vec.normalize()
self.np.setPos(self.np.getPos() + vec * dist * 0.01)
class Desktop:
def __init__(self, base):
self.model = base.loader.load_model("models/desk3.egg", )
# self.model.setPos(0, 2000, -1500)
# self.model.reparent_to(base.render)
# collider_node = CollisionNode("desktop")
# collider_node.addSolid(CollisionBox(LPoint3(-925, -435, 0), LPoint3(925, 435, 770)))
# self.collider = self.model.attachNewNode(collider_node)
# self.collider.show()
# Physics and collisions
self.shape = BulletBoxShape(Vec3(925, 435, 385))
self.phy_node = BulletRigidBodyNode('desk')
self.phy_node.addShape(self.shape)
self.node = base.render.attachNewNode(self.phy_node)
self.model.reparentTo(self.node)
self.model.setPos(0, 0, -385)
base.world.attachRigidBody(self.phy_node)
self.node.setPos(0, 0, -770)
self.node.setCollideMask(BitMask32.bit(1))
def loop(self):
self.model.setPos(0, 2000, -1500)
def add_collider(self, traverser, pusher):
pass
class StaticTerrain(BulletObject):
def __init__(self, game, imgPath, height):
self.game = game
self.img = PNMImage(Filename(imgPath))
self.shape = BulletHeightfieldShape(self.img, height, 2)
self.node = BulletRigidBodyNode('Ground')
self.node.addShape(self.shape)
self.np = self.game.render.attachNewNode(self.node)
self.np.setPos(0, 0, 0)
self.np.setScale(1, 1, 1)
self.game.world.attachRigidBody(self.node)
self.terrain = GeoMipTerrain('terrain')
self.terrain.setHeightfield(self.img)
self.terrain.generate()
self.terrainNP = self.terrain.getRoot()
self.offset = self.img.getXSize() / 2.0 - 0.5
self.terrainNP.setSz(height)
self.terrainNP.setPos(-self.offset,-self.offset,-height/2.0)
#self.terrainNP.flattenStrong()
self.terrainNP.reparentTo(self.np)
self.terrainNP.show()
self.debugOff()
self.slice_able = False
self.terrain.setBlockSize(32)
self.terrain.setNear(100)
self.terrain.setFar(400)
self.terrain.setFocalPoint(self.game.playerNp)
def update(self, dt=0.1):
self.terrain.update()
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), -1)
np = self.worldNP.attachNewNode(BulletRigidBodyNode('Ground'))
np.node().addShape(shape)
np.setPos(0, 0, -1)
np.setCollideMask(BitMask32.bit(0))
self.world.attachRigidBody(np.node())
# Boxes
self.boxes = [None,]*6
for i in range(6):
shape = BulletBoxShape(Vec3(0.5, 0.5, 0.5))
np = self.worldNP.attachNewNode(BulletRigidBodyNode('Box-1'))
np.node().setMass(1.0)
np.node().addShape(shape)
self.world.attachRigidBody(np.node())
self.boxes[i] = np
visualNP = loader.loadModel('models/box.egg')
visualNP.reparentTo(np)
self.boxes[0].setPos(-3, -3, 0)
self.boxes[1].setPos( 0, -3, 0)
self.boxes[2].setPos( 3, -3, 0)
self.boxes[3].setPos(-3, 3, 0)
self.boxes[4].setPos( 0, 3, 0)
self.boxes[5].setPos( 3, 3, 0)
self.boxes[0].setCollideMask(BitMask32.bit(1))
self.boxes[1].setCollideMask(BitMask32.bit(2))
self.boxes[2].setCollideMask(BitMask32.bit(3))
self.boxes[3].setCollideMask(BitMask32.bit(1))
self.boxes[4].setCollideMask(BitMask32.bit(2))
self.boxes[5].setCollideMask(BitMask32.bit(3))
self.boxNP = self.boxes[0]
self.world.setGroupCollisionFlag(0, 1, True)
self.world.setGroupCollisionFlag(0, 2, True)
self.world.setGroupCollisionFlag(0, 3, True)
self.world.setGroupCollisionFlag(1, 1, False)
self.world.setGroupCollisionFlag(1, 2, True)
def makeMapBorders(self, offset):
plane1 = BulletPlaneShape(Vec3(1, 0, 0), 0)
np = self.worldNP.attachNewNode(BulletRigidBodyNode('border1'))
np.node().addShape(plane1)
np.setPos(-offset, -offset, -self.height / 2.0)
np.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(np.node())
plane2 = BulletPlaneShape(Vec3(0, 1, 0), 0)
np = self.worldNP.attachNewNode(BulletRigidBodyNode('border2'))
np.node().addShape(plane2)
np.setPos(-offset, -offset, -self.height / 2.0)
np.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(np.node())
plane3 = BulletPlaneShape(Vec3(0, -1, 0), 0)
np = self.worldNP.attachNewNode(BulletRigidBodyNode('border3'))
np.node().addShape(plane3)
np.setPos(offset, offset, self.height / 2.0)
np.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(np.node())
plane4 = BulletPlaneShape(Vec3(-1, 0, 0), 0)
np = self.worldNP.attachNewNode(BulletRigidBodyNode('border4'))
np.node().addShape(plane4)
np.setPos(offset, offset, self.height / 2.0)
np.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(np.node())
def __init__(self, location, player, cmap, world):
super(Catcher, self).__init__(location)
self.player = player
self.cmap = cmap
self.obj = utilities.loadObject("robot", depth=20)
self.world = world
self.health = 100
self.depth = self.obj.getPos().y
self.location = location
self.velocity = Vec3(0)
self.shape = BulletBoxShape(Vec3(0.5, 1.0, 0.5))
self.bnode = BulletRigidBodyNode('Box')
self.bnode.setMass(0.1)
self.bnode.setAngularVelocity(Vec3(0))
self.bnode.setAngularFactor(Vec3(0))
self.bnode.addShape(self.shape)
self.bnode.setLinearDamping(0.75)
self.bnode.setLinearSleepThreshold(0)
world.bw.attachRigidBody(self.bnode)
self.bnode.setPythonTag("entity", self)
self.bnode.setIntoCollideMask(BitMask32.bit(0))
self.node = utilities.app.render.attachNewNode(self.bnode)
self.node.setPos(self.obj.getPos())
self.obj.setPos(0, 0, 0)
self.obj.setScale(1)
self.obj.reparentTo(self.node)
self.node.setPos(self.location.x, self.depth, self.location.y)
class StaticModel(BulletObject):
def __init__(self, name, modelPath, displayModelPath, game, pos):
self.name = name
self.modelPath = modelPath
self.game = game
self.model = self.game.loader.loadModel(self.modelPath)
geomNodes = self.model.findAllMatches('**/+GeomNode')
self.geomNode = geomNodes.getPath(0).node()
self.geom = self.geomNode.getGeom(0)
#self.shape = BulletConvexHullShape()
#self.shape.addGeom(self.geom)
mesh = BulletTriangleMesh()
mesh.addGeom(self.geom)
self.shape = BulletTriangleMeshShape(mesh, dynamic=False)
self.node = BulletRigidBodyNode(self.name)
self.node.addShape(self.shape)
self.np = self.game.render.attachNewNode(self.node)
self.np.setPos(pos)
self.game.world.attachRigidBody(self.node)
#self.model.reparentTo(self.np)
self.displayModel = self.game.loader.loadModel(displayModelPath)
self.displayModel.reparentTo(self.np)
self.displayModel.setTwoSided(True)
self.slice_able = False
def genBulletBoxes(env,world):
boxes = list()
for np in listNodes(env,"Collision_box_"):
geom = np.node().getGeom(0)
# get the minimum and maximum points
vdata = geom.getVertexData()
vertices = GeomVertexReader(vdata,'vertex')
vmin = LPoint3()
vmax = LPoint3()
np.calcTightBounds(vmin,vmax)
#Create the bullet box with center at (0,0)
norm = vmax-vmin
hnorm = LVecBase3(norm[0]*.5,norm[1]*.5,norm[2]*.5)
shape = BulletBoxShape(hnorm)
# create the surrounding nodes
node = BulletRigidBodyNode('env')
node.addShape(shape)
enp = env.attachNewNode(node)
enp.setPos(vmin+hnorm)
# attach it to the world and save it for later
world.attachRigidBody(node)
boxes.append(enp.node())
# clean up the environment higherarchy
np.removeNode()
return boxes
def __init__(self, window_id, rect):
print("Creating window ID={}".format(window_id))
self.rect = rect
self.window_id = window_id
self.box = WindowBox(globals.front_texture, globals.back_texture)
self.box.update_vertices(rect, globals.desk_rect)
x0 = int(rect[0] * 1.1) - 2000 + int(0.7 * rect[2])
y0 = 1980
z0 = int(rect[1] * 1.1) - 500
self.default_position = Point3(x0, y0, z0)
self.box.node.setTag('wid', str(window_id))
size = [0.5 * (a - b) for a, b in zip(self.box.mx, self.box.mn)]
self.shape = BulletBoxShape(Vec3(size[0], size[1], size[2] + 10))
self.phy_node = BulletRigidBodyNode('window')
volume = size[0] * size[1] * size[2]
self.phy_node.setMass(0.001 * volume)
self.phy_node.addShape(self.shape)
self.node = globals.gui.render.attachNewNode(self.phy_node)
self.phy_node.setLinearDamping(0.6)
self.phy_node.setAngularDamping(0.6)
globals.gui.world.attachRigidBody(self.phy_node)
self.node.setCollideMask(BitMask32.bit(1))
self.box.node.reparentTo(self.node)
self.box.node.setPos(0, 0, size[2] - 10)
self.node.setPos(x0, y0, z0)
self.set_physics(False)
def setup(self):
self.worldNP = render.attach_new_node('World')
# World
self.debugNP = self.worldNP.attach_new_node(BulletDebugNode('Debug'))
self.debugNP.show()
self.debugNP.node().show_wireframe(True)
self.debugNP.node().show_constraints(True)
self.debugNP.node().show_bounding_boxes(False)
self.debugNP.node().show_normals(False)
self.world = BulletWorld()
self.world.set_gravity(LVector3(0, 0, -9.81))
self.world.set_debug_node(self.debugNP.node())
# Box A
shape = BulletBoxShape(LVector3(0.5, 0.5, 0.5))
bodyA = BulletRigidBodyNode('Box A')
bodyNP = self.worldNP.attach_new_node(bodyA)
bodyNP.node().add_shape(shape)
bodyNP.set_collide_mask(BitMask32.all_on())
bodyNP.set_pos(-3, 0, 4)
visNP = loader.load_model('models/box.egg')
visNP.clear_model_nodes()
visNP.reparent_to(bodyNP)
self.world.attach(bodyA)
# Box B
shape = BulletBoxShape(LVector3(0.5, 0.5, 0.5))
bodyB = BulletRigidBodyNode('Box B')
bodyNP = self.worldNP.attach_new_node(bodyB)
bodyNP.node().add_shape(shape)
bodyNP.node().set_mass(1.0)
bodyNP.node().set_deactivation_enabled(False)
bodyNP.set_collide_mask(BitMask32.all_on())
bodyNP.set_pos(0, 0, 0)
visNP = loader.load_model('models/box.egg')
visNP.clear_model_nodes()
visNP.reparent_to(bodyNP)
self.world.attach(bodyB)
# Slider
frameA = TransformState.make_pos_hpr(LPoint3(2, 0, 0),
LVector3(0, 0, 45))
frameB = TransformState.make_pos_hpr(LPoint3(0, -3, 0),
LVector3(0, 0, 0))
slider = BulletSliderConstraint(bodyA, bodyB, frameA, frameB, True)
slider.set_debug_draw_size(2.0)
slider.set_lower_linear_limit(0)
slider.set_upper_linear_limit(6)
slider.set_lower_angular_limit(-60)
slider.set_upper_angular_limit(60)
self.world.attach(slider)
def genCollisionMeshMultiNp(nodepath, basenodepath=None, name='autogen'):
"""
generate the collision mesh of a nodepath using nodepath
this function suppose the nodepath has multiple models with many geomnodes
use genCollisionMeshMultiNp instead of genCollisionMeshNp for generality
:param nodepath: the panda3d nodepath of the object
:param basenodepath: the nodepath to compute relative transform, identity if none
:param name: the name of the rigidbody
:return: bulletrigidbody
author: weiwei
date: 20161212, tsukuba
"""
gndcollection = nodepath.findAllMatches("**/+GeomNode")
geombullnode = BulletRigidBodyNode(name)
for gnd in gndcollection:
geom = gnd.node().getGeom(0)
geomtf = gnd.getTransform(base.render)
if basenodepath is not None:
geomtf = gnd.getTransform(basenodepath)
geombullmesh = BulletTriangleMesh()
geombullmesh.addGeom(geom)
bullettmshape = BulletTriangleMeshShape(geombullmesh, dynamic=True)
bullettmshape.setMargin(0)
geombullnode.addShape(bullettmshape, geomtf)
return geombullnode
def rayHit(pfrom, pto, geom):
"""
NOTE: this function is quite slow
find the nearest collision point between vec(pto-pfrom) and the mesh of nodepath
:param pfrom: starting point of the ray, Point3
:param pto: ending point of the ray, Point3
:param geom: meshmodel, a panda3d datatype
:return: None or Point3
author: weiwei
date: 20161201
"""
bulletworld = BulletWorld()
facetmesh = BulletTriangleMesh()
facetmesh.addGeom(geom)
facetmeshnode = BulletRigidBodyNode('facet')
bullettmshape = BulletTriangleMeshShape(facetmesh, dynamic=True)
bullettmshape.setMargin(0)
facetmeshnode.addShape(bullettmshape)
bulletworld.attachRigidBody(facetmeshnode)
result = bulletworld.rayTestClosest(pfrom, pto)
if result.hasHit():
return result.getHitPos()
else:
return None
def demoContinue(self):
if self.newObjects < self.NrObjectToDrop:
node = BulletRigidBodyNode('Box')
node.setMass(1.0)
node.addShape(self.shape)
np = self.rbcnp.attachNewNode(node)
np.setPos(self.spawnNP.getPos(render))
np.setHpr(randint(-45, 45), randint(-45, 45), randint(-45, 45))
self.world.attachRigidBody(node)
bNP = self.model.copyTo(np)
#bNP.setPos(self.spawnNP.getPos())
#bNP.setColor(random(), random(), random(), 1)
#bNP.setHpr(randint(-45, 45), randint(-45, 45), randint(-45, 45))
#self.setUntextured(bNP)
#bNP.setTexureOff()
#np.setScale(10)
np.flattenStrong()
self.objects.append(np)
self.newObjects += 1
self.rbcnp.node().collect()
if self.newObjects < self.NrObjectToDrop:
return False
else:
self.running = False
return True
def __addElements(self):
# Walk Capsule
self.__walkCapsule = BulletCapsuleShape(self.__walkCapsuleR,
self.__walkCapsuleH)
self.__walkCapsuleNP = self.movementParent.attachNewNode(
BulletRigidBodyNode('Capsule'))
self.__walkCapsuleNP.node().addShape(self.__walkCapsule)
self.__walkCapsuleNP.node().setKinematic(True)
self.__walkCapsuleNP.setCollideMask(BitMask32.allOn())
self.__world.attachRigidBody(self.__walkCapsuleNP.node())
# Crouch Capsule
self.__crouchCapsule = BulletCapsuleShape(self.__crouchCapsuleR,
self.__crouchCapsuleH)
self.__crouchCapsuleNP = self.movementParent.attachNewNode(
BulletRigidBodyNode('crouchCapsule'))
self.__crouchCapsuleNP.node().addShape(self.__crouchCapsule)
self.__crouchCapsuleNP.node().setKinematic(True)
self.__crouchCapsuleNP.setCollideMask(BitMask32.allOn())
# Set default
self.capsule = self.__walkCapsule
self.capsuleNP = self.__walkCapsuleNP
# Init
self.__updateCapsule()
def __init__(self):
PhysicsNodePath.__init__(self, 'can')
self.shapeGroup = BitMask32.allOn()
sph = BulletCylinderShape(0.5, 1.2, ZUp)
rbnode = BulletRigidBodyNode('can_body')
rbnode.setMass(10.0)
rbnode.addShape(sph)
rbnode.setCcdMotionThreshold(1e-7)
rbnode.setCcdSweptSphereRadius(0.5)
self.mdl = loader.loadModel("phase_5/models/props/can.bam")
self.mdl.setScale(11.0)
self.mdl.setZ(-0.55)
self.mdl.reparentTo(self)
self.mdl.showThrough(CIGlobals.ShadowCameraBitmask)
self.setupPhysics(rbnode)
#self.makeShadow(0.2)
self.reparentTo(render)
self.setPos(base.localAvatar.getPos(render))
self.setQuat(base.localAvatar.getQuat(render))
dir = self.getQuat(render).xform(Vec3.forward())
amp = 10
self.node().setLinearVelocity(dir * amp)
def __init__(self):
PhysicsNodePath.__init__(self, 'can')
self.shapeGroup = BitMask32.allOn()
sph = BulletBoxShape(Vec3(2, 2, 2))
rbnode = BulletRigidBodyNode('can_body')
rbnode.setMass(100.0)
rbnode.addShape(sph, TransformState.makePos(Point3(0, 0, 1)))
rbnode.setCcdMotionThreshold(1e-7)
rbnode.setCcdSweptSphereRadius(0.5)
self.mdl = loader.loadModel("phase_5/models/props/safe-mod.bam")
self.mdl.setScale(6)
self.mdl.setZ(-1)
self.mdl.reparentTo(self)
self.mdl.showThrough(CIGlobals.ShadowCameraBitmask)
self.setupPhysics(rbnode)
#self.makeShadow(0.2)
self.reparentTo(render)
self.setPos(base.localAvatar.getPos(render) + (0, 0, 20))
self.setQuat(base.localAvatar.getQuat(render))
def load_block_physics(self):
"""Create collision geometry and a physical body for the block."""
self.block_body = BulletRigidBodyNode('block-physics')
self.block_body.add_shape(BulletBoxShape((0.2, 0.6, 0.2)))
self.block_body.set_mass(1.0)
self.world.attach_rigid_body(self.block_body)
class Ball(object):
def __init__(self, render, world, loader, player):
self.render = render
self.world = world
self.loader = loader
self.player = player
self.dropHeight = 5
self.createItem()
def createItem(self):
self.collisionShape = BulletSphereShape(0.5)
self.actor = BulletRigidBodyNode('Ball')
self.actor.setMass(5.0)
self.actor.addShape(self.collisionShape)
self.np = self.render.attachNewNode(self.actor)
self.np.setCollideMask(BitMask32.allOff())
self.x = self.player.getCharacterNP().getX()
self.y = self.player.getCharacterNP().getY()
self.z = self.player.getCharacterNP().getZ() + self.dropHeight
self.np.setPos(self.x, self.y, self.z)
self.world.attachRigidBody(self.actor)
self.actorModelNP = self.loader.loadModel('models/sphere/ball.egg')
self.actorModelNP.reparentTo(self.np)
self.actorModelNP.setScale(0.5)
self.actorModelNP.setPos(0, 0, 0)
def getActor(self):
return self.actor
def getNP(self):
return self.np
def __init__(self, name, modelPath, game, pos):
self.name = name
self.modelPath = modelPath
self.game = game
self.model = self.game.loader.loadModel(self.modelPath)
geomNodes = self.model.findAllMatches('**/+GeomNode')
self.geomNode = geomNodes.getPath(0).node()
self.geom = self.geomNode.getGeom(0)
self.shape = BulletConvexHullShape()
self.shape.addGeom(self.geom)
self.node = BulletRigidBodyNode(self.name)
self.node.setMass(10.0)
self.node.addShape(self.shape)
self.np = self.game.render.attachNewNode(self.node)
self.np.setPos(pos)
self.game.world.attachRigidBody(self.node)
self.model.reparentTo(self.np)
self.node.setCcdMotionThreshold(1e-7)
self.node.setCcdSweptSphereRadius(0.5)
self.slice_able = True
def start(self):
for component in self.node.data:
if isinstance(component, Rigidbody):
# Check if parent has rigidbody, and use that node if it does
for p_component in self.node.parent.data:
if isinstance(p_component, Rigidbody):
self.parent_path = p_component.body_path
self.update_parent = False
if self.parent_path is None:
parent_node = BulletRigidBodyNode(self.node.parent.name + "_node")
parent_node.set_mass(0)
self.parent_path = EComponent.panda_root_node.attach_new_node(parent_node)
self.parent_path.setPos(helper.np_vec3_to_panda(self.node.parent.transform.get_world_translation()))
rot = np.degrees(self.node.parent.transform.get_world_rotation())
self.parent_path.setHpr(LVector3f(rot[1],
rot[0],
rot[2]))
self.parent_path.setScale(helper.np_vec3_to_panda(self.node.parent.transform.get_world_scale()))
# Create constraint
child_transform = TransformState.make_pos(LVector3f(0, 0, 0))
node_pos = self.node.transform.get_translation() * self.node.transform.get_world_scale()
parent_transform = TransformState.make_pos(helper.np_vec3_to_panda(node_pos))
constraint = BulletConeTwistConstraint(component.body_path.node(),
self.parent_path.node(),
child_transform,
parent_transform)
constraint.set_limit(float(self.property_vals["swing_1"]),
float(self.property_vals["swing_2"]),
float(self.property_vals["max_twist"]))
EComponent.physics_world.attachConstraint(constraint)
def __init__(self, name, model, game, pos):
self.name = name
self.game = game
self.model = model
self.geomNode = self.model.node()
self.geom = self.geomNode.getGeom(0)
# with triangle mesh it crashes
#mesh = BulletTriangleMesh()
#mesh.addGeom(self.geom)
#self.shape = BulletTriangleMeshShape(mesh, dynamic=True)
# with convex hull
self.shape = BulletConvexHullShape()
self.shape.addGeom(self.geom)
self.node = BulletRigidBodyNode(self.name)
self.node.setMass(10.0)
self.node.addShape(self.shape)
self.np = self.game.render.attachNewNode(self.node)
self.np.setPos(pos)
self.game.world.attachRigidBody(self.node)
self.model.reparentTo(self.np)
self.node.setCcdMotionThreshold(1e-7)
self.node.setCcdSweptSphereRadius(0.5)
self.slice_able = True
def __init__(self, world):
super(Player, self).__init__()
self.obj = utilities.loadObject("tdplayer", depth=20)
self.world = world
self.health = 100
self.inventory = list()
self.depth = self.obj.getPos().y
self.location = Point2(10, 0)
self.velocity = Vec3(0)
self.shape = BulletBoxShape(Vec3(0.3, 1.0, 0.49))
self.bnode = BulletRigidBodyNode('Box')
self.bnode.setMass(0.1)
self.bnode.setAngularVelocity(Vec3(0))
self.bnode.setAngularFactor(Vec3(0))
self.bnode.addShape(self.shape)
self.bnode.setLinearDamping(0.95)
self.bnode.setLinearSleepThreshold(0)
world.bw.attachRigidBody(self.bnode)
self.bnode.setPythonTag("entity", self)
self.bnode.setIntoCollideMask(BitMask32.bit(0))
self.node = utilities.app.render.attachNewNode(self.bnode)
self.node.setPos(self.obj.getPos())
self.obj.setPos(0, 0, 0)
self.obj.setScale(1)
self.obj.reparentTo(self.node)
self.node.setPos(self.location.x, self.depth, self.location.y)
def __init__(self, game, imgPath, height):
self.game = game
self.img = PNMImage(Filename(imgPath))
self.shape = BulletHeightfieldShape(self.img, height, 2)
self.node = BulletRigidBodyNode('Ground')
self.node.addShape(self.shape)
self.np = self.game.render.attachNewNode(self.node)
self.np.setPos(0, 0, 0)
self.np.setScale(1, 1, 1)
self.game.world.attachRigidBody(self.node)
self.terrain = GeoMipTerrain('terrain')
self.terrain.setHeightfield(self.img)
self.terrain.generate()
self.terrainNP = self.terrain.getRoot()
self.offset = self.img.getXSize() / 2.0 - 0.5
self.terrainNP.setSz(height)
self.terrainNP.setPos(-self.offset, -self.offset, -height / 2.0)
#self.terrainNP.flattenStrong()
self.terrainNP.reparentTo(self.np)
self.terrainNP.show()
self.debugOff()
self.slice_able = False
self.terrain.setBlockSize(32)
self.terrain.setNear(100)
self.terrain.setFar(400)
self.terrain.setFocalPoint(self.game.playerNp)
def __add_elements(self):
# Walk Capsule
self.__walk_capsule = BulletCapsuleShape(self.__walk_capsule_r,
self.__walk_capsule_h)
self.__walk_capsule_node = self.node.attachNewNode(
BulletRigidBodyNode('Capsule'))
self.__walk_capsule_node.node().addShape(self.__walk_capsule)
self.__walk_capsule_node.node().setKinematic(True)
self.__walk_capsule_node.setCollideMask(BitMask32.allOn())
self.__world.attachRigidBody(self.__walk_capsule_node.node())
# Crouch Capsule
self.__crouch_capsule = BulletCapsuleShape(self.__crouch_capsule_r,
self.__crouch_capsule_h)
self.__crouch_capsule_node = self.node.attachNewNode(
BulletRigidBodyNode('crouchCapsule'))
self.__crouch_capsule_node.node().addShape(self.__crouch_capsule)
self.__crouch_capsule_node.node().setKinematic(True)
self.__crouch_capsule_node.setCollideMask(BitMask32.allOn())
# Set default
self.capsule = self.__walk_capsule
self.capsule_node = self.__walk_capsule_node
# Init
self.__update_capsule()
def setupPlayer(self, x, y, z):
yetiHeight = 7
yetiRadius = 2
yetiShape = BulletCapsuleShape(yetiRadius, yetiHeight - 2 * yetiRadius, ZUp)
modelPrefix = "../res/models/yeti_"
self.yetiModel = Actor("../res/models/yeti.egg", {"idle":"../res/models/yeti_idle.egg", "walk":"../res/models/yeti_walking.egg"})
self.yetiModel.setH(90)
self.yetiModel.setPos(0, 0, SNOW_HEIGHT)
playerNode = BulletRigidBodyNode("Player")
playerNode.setMass(MASS)
playerNode.addShape(yetiShape)
# Without this set to 0,0,0, the Yeti would wobble like a Weeble but not fall down.
playerNode.setAngularFactor(Vec3(0,0,0))
# Without this disabled, things will weld together after a certain amount of time. It's really annoying.
playerNode.setDeactivationEnabled(False)
playerNP = self.worldNP.attachNewNode(playerNode)
playerNP.setPos(x, y, z)
playerNP.setH(270)
self.yetiModel.reparentTo(playerNP)
self.bulletWorld.attachRigidBody(playerNP.node())
# Hopefully Brandon will get those animation files to me so I can convert them.
# self.setAnimation('idle')
return playerNP
def __init__(self):
ShowBase.__init__(self)
# Bullet Physics Setup
self.world = BulletWorld()
self.world.setGravity(Vec3(0, 0, -9.81))
shape = BulletPlaneShape(Vec3(0, 0, 1), 1)
node = BulletRigidBodyNode('Ground')
node.addShape(shape)
ground_np = self.render.attachNewNode(node)
ground_np.setPos(0, 0, -60)
# noinspection PyArgumentList
self.world.attach(node)
# Mouse and Camera Setup
self.disable_mouse()
self.camera.set_pos(20, -150, 5)
self.follow_np = self.render.attach_new_node('Follow')
# Instructions
self.add_instruction('(p) to generate a Plane', 0.06)
self.add_instruction('(b) to generate a Cuboid/Box', 0.12)
self.add_instruction('(s) to generate a Spheroid', 0.18)
self.add_instruction('(c) to generate a Cylinder', 0.24)
self.add_instruction('(f1) to toggle wireframe', 0.30)
self.add_instruction('(esc) to exit', 0.36)
# Input
self.accept('escape', sys.exit, [0])
self.accept('p', self.generate_plane)
self.accept('b', self.generate_cuboid)
self.accept('s', self.generate_spheroid)
self.accept('c', self.generate_cylinder)
self.accept('f1', self.toggle_wireframe)
self.task_mgr.add(self.update, 'update')
def __init__(self):
base.accept('f1', self.toggleDebug)
self.debugNode = BulletDebugNode('Debug')
self.debugNode.showWireframe(True)
self.debugNode.showConstraints(True)
self.debugNode.showBoundingBoxes(False)
self.debugNode.showNormals(False)
self.debugNP = base.render.attachNewNode(self.debugNode)
# self.debugNP.show()
# World
self.world = BulletWorld()
self.world.setGravity(Vec3(0, 0, -9.81))
self.world.setDebugNode(self.debugNP.node())
# Terrain
visNP = base.loader.loadModel('models/terrain.egg')
mesh = BulletTriangleMesh()
for x in visNP.findAllMatches('**/+GeomNode'):
geom = x.node().getGeom(0)
mesh.addGeom(geom)
shape = BulletTriangleMeshShape(mesh, dynamic=True)
body = BulletRigidBodyNode('Bowl')
bodyNP = base.render.attachNewNode(body)
bodyNP.node().addShape(shape)
bodyNP.setPos(0, 0, 1)
bodyNP.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(bodyNP.node())
visNP.reparentTo(bodyNP)
shapex = BulletBoxShape(5)
bodyx = BulletRigidBodyNode('Egg')
bodyNPx = base.render.attachNewNode(bodyx)
bodyNPx.setPos(0, 0, 3)
bodyNPx.node().setMass(100.0)
bodyNPx.node().addShape(shapex)
self.world.attachRigidBody(bodyNPx.node())
# visNP.reparentTo(bodyNPx)
# Player
self.players = []
self.myId = -1
self.speed = Vec3(0, 0, 0)
self.walk_speed = 2.5
# Camera
base.disableMouse()
props = WindowProperties()
props.setCursorHidden(True)
base.win.requestProperties(props)
# SkySphere
Sky()
self.initCam()
def __init__(self,mainReference):
super(Player, self).__init__(mainReference)
# setting player HP
self.healthPoints = 100
# fine tuning the camera properties
self.mainRef.camLens.setFov(50)
self.mainRef.camLens.setNear(0.02)
self.mainRef.camLens.setFar(80.0)
self.currentRegionID = 1
# dummy nodepath for our player; we will attach everything to it
# player bullet node - NOTE: for detecting collision with attacks, only
playerNode = BulletRigidBodyNode('Player_NP')
playerNode.addShape( BulletCapsuleShape(0.3, 1, ZUp) ) # adicionar node no lugar da string
self.mainRef.world.attachRigidBody(playerNode)
self.playerNP = self.mainRef.render.attachNewNode(playerNode)
# this collision mask will only avoid CharacterBody collision on itself
self.playerNP.setCollideMask(BitMask32(0x7FFFFFFF))
# notify collision contacts
self.playerNP.node().notifyCollisions(True)
self.playerHeadNP = NodePath("empty") # This node is intended to be a placeholder for the camera (maintainability only)
self.playerHeadNP.reparentTo( self.playerNP )
self.playerHeadNP.setPos(0, 0, 1.35)
# self.mainRef.camera.setPos(0, -4, 0)
self.mainRef.camera.reparentTo( self.playerHeadNP )
# NodePath position
self.playerNP.setPos(0,0,1.0)
# setting player's character body
self.playerBody = CharacterBody(self.mainRef, self.playerNP.getPos(), 0.38, 0.5)
self.playerBody.charBodyNP.reparentTo(self.playerNP)
# setting our movementHandler
self.movementHandler = MovementHandler(self.mainRef)
self.movementHandler.registerFPSMovementInput()
# attach default weapon
self.activeWeapon = Glock(self.mainRef.camera)
# adding the shoot event
self.mainRef.accept("mouse1", self.shootBullet)
# adding the reload event
self.mainRef.accept("mouse3", self.reloadWeapon)
# player boolean to authorize player HP decrease when zombie contact happens
self.canLoseHP = 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
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(10.0)
np.node().addShape(shape)
np.setPos(3, 0, 4)
np.setH(20.0)
np.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(np.node())
# Character
self.crouching = False
h = 1.75
w = 0.4
shape = BulletCapsuleShape(w, h - 2 * w, ZUp)
self.character = BulletCharacterControllerNode(shape, 0.4, 'Player')
# self.character.setMass(1.0)
self.characterNP = self.worldNP.attachNewNode(self.character)
self.characterNP.setPos(-2, 0, 14)
self.characterNP.setH(45)
self.characterNP.setCollideMask(BitMask32.allOn())
self.world.attachCharacter(self.character)
self.actorNP = Actor('models/ralph/ralph.egg', {
'run' : 'models/ralph/ralph-run.egg',
'walk' : 'models/ralph/ralph-walk.egg',
'jump' : 'models/ralph/ralph-jump.egg'})
self.actorNP.reparentTo(self.characterNP)
self.actorNP.setScale(0.3048) # 1ft = 0.3048m
self.actorNP.setH(180)
self.actorNP.setPos(0, 0, -1)
def setupDeathzone(self, height):
planeShape = BulletPlaneShape(Vec3(0, 0, 1), 1)
planeNode = BulletRigidBodyNode('DeathZone')
planeNode.addShape(planeShape)
planeNP = render.attachNewNode(planeNode)
planeNP.setPos(0, 0, height)
self.worldBullet.attachRigidBody(planeNode)
return planeNP
def __init__(self, world, **kwargs):
super().__init__(**kwargs)
self.shape = BulletPlaneShape(Vec3(0, 1, 0), 0)
self.node = BulletRigidBodyNode('plane')
self.node.addShape(self.shape)
self.np = render.attachNewNode(self.node)
self.np.setPos(0, -2, 0)
world.attachRigidBody(self.node)
def setupDeathzone(self, height):
planeShape = BulletPlaneShape(Vec3(0, 0, 1), 1)
planeNode = BulletRigidBodyNode('DeathZone')
planeNode.addShape(planeShape)
planeNP = render.attachNewNode(planeNode)
planeNP.setPos(0, 0, height)
self.worldBullet.attachRigidBody(planeNode)
return planeNP
def getPhysBody(self):
shape = BulletCylinderShape(0.3925, 1.4, ZUp)
body = BulletRigidBodyNode('tntBody')
body.addShape(shape)
body.setKinematic(True)
body.setCcdMotionThreshold(1e-7)
body.setCcdSweptSphereRadius(0.3925)
return body
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.attach_new_node('World')
# World
self.debugNP = self.worldNP.attach_new_node(BulletDebugNode('Debug'))
self.debugNP.show()
self.world = BulletWorld()
self.world.set_gravity(LVector3(0, 0, -9.81))
self.world.set_debug_node(self.debugNP.node())
# Ground
shape = BulletPlaneShape(LVector3(0, 0, 1), 0)
#img = PNMImage(Filename('models/elevation.png'))
#shape = BulletHeightfieldShape(img, 1.0, ZUp)
np = self.worldNP.attach_new_node(BulletRigidBodyNode('Ground'))
np.node().add_shape(shape)
np.set_pos(0, 0, -1)
np.set_collide_mask(BitMask32.all_on())
self.world.attach(np.node())
# Box
shape = BulletBoxShape(LVector3(1.0, 3.0, 0.3))
np = self.worldNP.attach_new_node(BulletRigidBodyNode('Box'))
np.node().set_mass(10.0)
np.node().add_shape(shape)
np.set_pos(3, 0, 4)
np.setH(20.0)
np.set_collide_mask(BitMask32.all_on())
self.world.attach(np.node())
# Character
self.crouching = False
h = 1.75
w = 0.4
shape = BulletCapsuleShape(w, h - 2 * w, ZUp)
self.character = BulletCharacterControllerNode(shape, 0.4, 'Player')
self.characterNP = self.worldNP.attach_new_node(self.character)
self.characterNP.set_pos(-2, 0, 14)
self.characterNP.set_h(45)
self.characterNP.set_collide_mask(BitMask32.all_on())
self.world.attach(self.character)
self.actorNP = Actor(
'samples/roaming-ralph/models/ralph.egg.pz', {
'run': 'samples/roaming-ralph/models/ralph-run.egg.pz',
'walk': 'samples/roaming-ralph/models/ralph-walk.egg.pz'
})
self.actorNP.reparent_to(self.characterNP)
self.actorNP.set_scale(0.3048) # 1ft = 0.3048m
self.actorNP.setH(180)
self.actorNP.set_pos(0, 0, -1)
def task_1_Bullet_Hello_World():
strOf_FuncName = "task_1_Bullet_Hello_World"
'''###################
step : 1
opening, vars
###################'''
print()
print ("[%s:%d] starting : %s (time=%s)" % (
os.path.basename(os.path.basename(libs.thisfile()))
, libs.linenum()
, strOf_FuncName
, libs.get_TimeLabel_Now()
)
)
'''###################
step : 2
###################'''
base.cam.setPos(0, -10, 0)
base.cam.lookAt(0, 0, 0)
# World
world = BulletWorld()
world.setGravity(Vec3(0, 0, -9.81))
# Plane
shape = BulletPlaneShape(Vec3(0, 0, 1), 1)
node = BulletRigidBodyNode('Ground')
node.addShape(shape)
np = render.attachNewNode(node)
np.setPos(0, 0, -2)
world.attachRigidBody(node)
# Box
shape = BulletBoxShape(Vec3(0.5, 0.5, 0.5))
node = BulletRigidBodyNode('Box')
node.setMass(1.0)
node.addShape(shape)
np = render.attachNewNode(node)
np.setPos(0, 0, 2)
world.attachRigidBody(node)
model = loader.loadModel('models/box.egg')
model.flattenLight()
model.reparentTo(np)
# Update
def update(task):
dt = globalClock.getDt()
world.doPhysics(dt)
return task.cont
taskMgr.add(update, 'update')
base.run()
'''###################
def setup(self):
self.worldNP = render.attach_new_node('World')
# World
self.debugNP = self.worldNP.attach_new_node(BulletDebugNode('Debug'))
self.debugNP.show()
self.debugNP.node().show_wireframe(True)
self.debugNP.node().show_constraints(True)
self.debugNP.node().show_bounding_boxes(False)
self.debugNP.node().show_normals(False)
self.world = BulletWorld()
self.world.set_gravity(LVector3(0, 0, -9.81))
self.world.set_debug_node(self.debugNP.node())
# Box A
shape = BulletBoxShape(LVector3(0.5, 0.5, 0.5))
bodyA = BulletRigidBodyNode('Box A')
bodyNP = self.worldNP.attach_new_node(bodyA)
bodyNP.node().add_shape(shape)
bodyNP.set_collide_mask(BitMask32.all_on())
bodyNP.set_pos(-2, 0, 1)
visNP = loader.load_model('models/box.egg')
visNP.clear_model_nodes()
visNP.reparent_to(bodyNP)
self.world.attach(bodyA)
# Box B
shape = BulletBoxShape(LVector3(0.5, 0.5, 0.5))
bodyB = BulletRigidBodyNode('Box B')
bodyNP = self.worldNP.attach_new_node(bodyB)
bodyNP.node().add_shape(shape)
bodyNP.node().set_mass(1.0)
bodyNP.node().set_deactivation_enabled(False)
bodyNP.set_collide_mask(BitMask32.all_on())
bodyNP.set_pos(2, 0, 1)
visNP = loader.load_model('models/box.egg')
visNP.clear_model_nodes()
visNP.reparent_to(bodyNP)
self.world.attach(bodyB)
# Hinge
pivotA = LPoint3(2, 0, 0)
pivotB = LPoint3(-4, 0, 0)
axisA = LVector3(0, 0, 1)
axisB = LVector3(0, 0, 1)
hinge = BulletHingeConstraint(bodyA, bodyB, pivotA, pivotB, axisA,
axisB, True)
hinge.set_debug_draw_size(2.0)
hinge.set_limit(-90, 120, softness=0.9, bias=0.3, relaxation=1.0)
self.world.attach(hinge)
def initBullet(self):
self.world = BulletWorld()
#self.world.setGravity(Vec3(0, 0, -9.81))
self.world.setGravity(Vec3(0, 0, -1.62))
groundShape = BulletPlaneShape(Vec3(0, 0, 1), 0)
groundNode = BulletRigidBodyNode('Ground')
groundNode.addShape(groundShape)
self.world.attachRigidBody(groundNode)
def addGround(self):
boxx = 500.0
boxy = 500.0
boxz = 1.0
shape = BulletBoxShape(Vec3(boxx, boxy, boxz)) # the parameters are half extends
node = BulletRigidBodyNode('Ground')
node.addShape(shape)
self.bltWorld.attachRigidBody(node)
pg.plotBox(self.base.render, pos = [0,0,-1.0], x = boxx*2.0, y = boxy*2.0, z = boxz*2.0, rgba=None)
def create_colliders(root, pose_rig, joints_config):
for node, parent in pose_rig.exposed_joints:
if node.getName() not in joints_config:
continue
joint_config = joints_config[node.getName()]
if "joints" not in joint_config:
continue
joints = joint_config["joints"]
if len(joints) == 0:
continue
mass = joint_config["mass"] if "mass" in joint_config else 1
box_rb = BulletRigidBodyNode(node.getName())
box_rb.setMass(1.0)
# box_rb.setLinearDamping(0.2)
# box_rb.setAngularDamping(0.9)
# box_rb.setFriction(1.0)
# box_rb.setAnisotropicFriction(1.0)
# box_rb.setRestitution(0.0)
for joint in joints:
child_node, child_parent = next(
(child_node, child_parent)
for child_node, child_parent in pose_rig.exposed_joints
if child_node.getName() == joint
)
pos = child_node.getPos(child_parent)
width = pos.length() / 2.0
scale = Vec3(3, width, 3)
shape = BulletBoxShape(scale)
quat = Quat()
lookAt(quat, child_node.getPos(child_parent), Vec3.up())
if len(joints) > 1:
transform = TransformState.makePosHpr(child_node.getPos(child_parent) / 2.0, quat.getHpr())
else:
transform = TransformState.makeHpr(quat.getHpr())
box_rb.addShape(shape, transform)
box_np = root.attachNewNode(box_rb)
if len(joints) > 1:
pos = node.getPos(pose_rig.actor)
hpr = node.getHpr(pose_rig.actor)
box_np.setPosHpr(root, pos, hpr)
else:
box_np.setPos(child_parent, child_node.getPos(child_parent) / 2.0)
box_np.lookAt(child_parent, child_node.getPos(child_parent))
yield box_np
def createGround(self, terrainData):
"""Create ground using a heightmap"""
# Create heightfield for physics
heightRange = terrainData["heightRange"]
# Image needs to have dimensions that are a power of 2 + 1
heightMap = PNMImage(self.basePath + terrainData["elevation"])
xdim = heightMap.getXSize()
ydim = heightMap.getYSize()
shape = BulletHeightfieldShape(heightMap, heightRange, ZUp)
shape.setUseDiamondSubdivision(True)
np = self.outsideWorldRender.attachNewNode(BulletRigidBodyNode("terrain"))
np.node().addShape(shape)
np.setPos(0, 0, 0)
self.physicsWorld.attachRigidBody(np.node())
# Create graphical terrain from same height map
terrain = GeoMipTerrain("terrain")
terrain.setHeightfield(heightMap)
terrain.setBlockSize(32)
terrain.setBruteforce(True)
rootNP = terrain.getRoot()
rootNP.reparentTo(self.worldRender)
rootNP.setSz(heightRange)
offset = xdim / 2.0 - 0.5
rootNP.setPos(-offset, -offset, -heightRange / 2.0)
terrain.generate()
# Apply texture
diffuse = self.loader.loadTexture(Filename(self.basePath + terrainData["texture"]))
diffuse.setWrapU(Texture.WMRepeat)
diffuse.setWrapV(Texture.WMRepeat)
rootNP.setTexture(diffuse)
textureSize = 6.0
ts = TextureStage.getDefault()
rootNP.setTexScale(ts, xdim / textureSize, ydim / textureSize)
# Create planes around area to prevent player flying off the edge
# Levels can define barriers around them but it's probably a good
# idea to leave this here just in case
sides = (
(Vec3(1, 0, 0), -xdim / 2.0),
(Vec3(-1, 0, 0), -xdim / 2.0),
(Vec3(0, 1, 0), -ydim / 2.0),
(Vec3(0, -1, 0), -ydim / 2.0),
)
for sideNum, side in enumerate(sides):
normal, offset = side
sideShape = BulletPlaneShape(normal, offset)
sideNode = BulletRigidBodyNode("side%d" % sideNum)
sideNode.addShape(sideShape)
self.physicsWorld.attachRigidBody(sideNode)
class Track2(object):
def __init__(self, bulletWorld):
self.env = loader.loadModel("models/env")
self.env.reparentTo(render)
self.env.setPos(0,0,-6)
self.env.setScale(400)
self.environ_tex = loader.loadTexture("models/tex/env_sky.jpg")
self.env.setTexture(self.environ_tex, 1)
self.period_cloud = self.env.hprInterval(400, (360, 0, 0))
self.period_cloud.loop()
self.ground = loader.loadModel("models/Ground2")
self.ground.reparentTo(render)
self.ground.setPos(0,0,-5)
self.ground.setScale(0.5,0.5,0)
self.ground_tex = loader.loadTexture("models/tex/ground.tif")
self.ground.setTexture(self.ground_tex, 1)
# model used as collision mesh
collisionModel = loader.loadModel('models/Track2')
# model used as display model
model = loader.loadModel('models/Track2')
tex = loader.loadTexture("models/tex/Main.png")
model.setTexture(tex)
# renders track from two camera views
model.setTwoSided(True)
collisionModel.setScale(1, 1, 100)
mesh = BulletTriangleMesh()
for geomNP in collisionModel.findAllMatches('**/+GeomNode'):
geomNode = geomNP.node()
ts = geomNP.getTransform(collisionModel)
for geom in geomNode.getGeoms():
mesh.addGeom(geom, ts)
shape = BulletTriangleMeshShape(mesh, dynamic=False)
self.rigidNode = BulletRigidBodyNode('Heightfield')
self.rigidNode.notifyCollisions(False)
np = render.attachNewNode(self.rigidNode)
np.node().addShape(shape)
model.setScale(1, 1, .1)
model.reparentTo(np)
np.setScale(.7)
np.setPos(0, 0, -5)
np.setCollideMask(BitMask32(0xf0))
np.node().notifyCollisions(False)
bulletWorld.attachRigidBody(np.node())
self.hf = np.node() # To enable/disable debug visualisation
def setupVehicle(self, bulletWorld):
# Chassis
shape = BulletBoxShape(Vec3(1, 2.2, 0.5))
ts = TransformState.makePos(Point3(0, 0, .7))
if self.isMainChar:
self.chassisNode = BulletRigidBodyNode(self.username)
else:
self.chassisNode = BulletRigidBodyNode('vehicle')
self.chassisNode.setTag("username", str(self.username))
self.chassisNP = render.attachNewNode(self.chassisNode)
self.chassisNP.node().addShape(shape, ts)
if self.isMainChar:
self.chassisNP.node().notifyCollisions(True)
else:
self.chassisNP.node().notifyCollisions(False)
self.setVehiclePos(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/batmobile-chassis.egg')
#self.yugoNP.setScale(.7)
self.carNP.reparentTo(self.chassisNP)
# Right front wheel
np = loader.loadModel('models/batmobile-wheel-right.egg')
np.reparentTo(render)
self.addWheel(Point3(1, 1.1, .7), True, np)
# Left front wheel
np = loader.loadModel('models/batmobile-wheel-left.egg')
np.reparentTo(render)
self.addWheel(Point3(-1, 1.1, .7), True, np)
# Right rear wheel
np = loader.loadModel('models/batmobile-wheel-right.egg')
np.reparentTo(render)
self.addWheel(Point3(1, -2, .7), False, np)
# Left rear wheel
np = loader.loadModel('models/batmobile-wheel-left.egg')
np.reparentTo(render)
self.addWheel(Point3(-1, -2, .7), False, np)
def __init__(self, player_tag):
ShowBase.__init__(self)
self.__player_tag = player_tag
self.__rotations = {}
# Panda pollutes the global namespace. Some of the extra globals can be referred to in nicer ways
# (for example self.render instead of render). The globalClock object, though, is only a global! We
# create a reference to it here, in a way that won't upset PyFlakes.
self.globalClock = __builtins__["globalClock"]
# Turn off the debugging system which allows the camera to be adjusted directly by the mouse.
self.disableMouse()
# Set up physics: the ground plane and the capsule which represents the player.
self.world = BulletWorld()
# The ground first:
shape = BulletPlaneShape(Vec3(0, 0, 1), 0)
node = BulletRigidBodyNode('Ground')
node.addShape(shape)
np = self.render.attachNewNode(node)
np.setPos(0, 0, 0)
self.world.attachRigidBody(node)
# Load the 3dWarehouse model.
cathedral = self.loader.loadModel("3dWarehouse_Reykjavik_Cathedral.egg")
cathedral.reparentTo(self.render)
cathedral.setScale(0.5)
# Load the Blender model.
self.humanoid = Actor("player.egg")
self.humanoid.setScale(0.5)
self.humanoid.reparentTo(self.render)
self.humanoid.loop("Walk")
humanoidPosInterval1 = self.humanoid.posInterval(58, Point3(13, -10, 0), startPos=Point3(13, 10, 0))
humanoidPosInterval2 = self.humanoid.posInterval(58, Point3(13, 10, 0), startPos=Point3(13, -10, 0))
humanoidHprInterval1 = self.humanoid.hprInterval(3, Point3(180, 0, 0), startHpr=Point3(0, 0, 0))
humanoidHprInterval2 = self.humanoid.hprInterval(3, Point3(0, 0, 0), startHpr=Point3(180, 0, 0))
# Make the Blender model walk up and down.
self.humanoidPace = Sequence(humanoidPosInterval1, humanoidHprInterval1, humanoidPosInterval2,
humanoidHprInterval2, name="humanoidPace")
self.humanoidPace.loop()
# Create a light so we can see the scene.
dlight = DirectionalLight('dlight')
dlight.setColor(VBase4(2, 2, 2, 0))
dlnp = self.render.attachNewNode(dlight)
dlnp.setHpr(0, -60, 0)
self.render.setLight(dlnp)
# Create a task to update the scene regularly.
self.taskMgr.add(self.update, "UpdateTask")
def createPlane(self):
rb = BulletRigidBodyNode('Ground')
rb.addShape(BulletPlaneShape(Vec3(0, 0, 1), 1))
rb.setFriction(1.0)
np = self.render.attachNewNode(rb)
np.setPos(Vec3(0, 0, -100))
np.setCollideMask(BitMask32.bit(0))
self.world.attachRigidBody(rb)
return np
def makePlane(self, num, norm, pos, hpr):
shape = BulletPlaneShape(norm, 0)
node = BulletRigidBodyNode('plane_' + str(num))
node.addShape(shape)
physics = render.attachNewNode(node)
physics.setPos(*pos)
self.world.attachRigidBody(node)
model = loader.loadModel('models/square')
model.setScale(10, 10, 10)
model.setHpr(*hpr)
model.setTransparency(TransparencyAttrib.MAlpha)
model.setColor(1, 1, 1, 0.25)
model.reparentTo(physics)
def buildConeShape(self, _height, _radius, _pos, _hpr):
"""Build a basic cone shape for the _obj"""
shape = BulletConeShape(_radius, _height, ZUp)
body = BulletRigidBodyNode("flashLight")
body.addShape(shape)
np = self.engine.BulletObjects["player"].attachNewNode(body)
np.setPos(_pos)
np.setHpr(_hpr)
np.setCollideMask(BitMask32.allOff())
self.engine.bulletWorld.attachRigidBody(np.node())
return np
class DynamicNp(DynamicObject): def __init__(self, name, model, game, pos): self.name = name self.game = game self.model = model self.geomNode = self.model.node() self.geom = self.geomNode.getGeom(0) # with triangle mesh it crashes #mesh = BulletTriangleMesh() #mesh.addGeom(self.geom) #self.shape = BulletTriangleMeshShape(mesh, dynamic=True) # with convex hull self.shape = BulletConvexHullShape() self.shape.addGeom(self.geom) self.node = BulletRigidBodyNode(self.name) self.node.setMass(10.0) self.node.addShape(self.shape) self.np = self.game.render.attachNewNode(self.node) self.np.setPos(pos) self.game.world.attachRigidBody(self.node) self.model.reparentTo(self.np) self.node.setCcdMotionThreshold(1e-7) self.node.setCcdSweptSphereRadius(0.5) self.slice_able = True
class DynamicModel(DynamicObject):
def __init__(self, name, modelPath, game, pos):
self.name = name
self.modelPath = modelPath
self.game = game
self.model = self.game.loader.loadModel(self.modelPath)
geomNodes = self.model.findAllMatches('**/+GeomNode')
self.geomNode = geomNodes.getPath(0).node()
self.geom = self.geomNode.getGeom(0)
self.shape = BulletConvexHullShape()
self.shape.addGeom(self.geom)
self.node = BulletRigidBodyNode(self.name)
self.node.setMass(10.0)
self.node.addShape(self.shape)
self.np = self.game.render.attachNewNode(self.node)
self.np.setPos(pos)
self.game.world.attachRigidBody(self.node)
self.model.reparentTo(self.np)
self.node.setCcdMotionThreshold(1e-7)
self.node.setCcdSweptSphereRadius(0.5)
self.slice_able = True
def setupFloaters2(self):
size = Vec3(3.5, 5.5, 0.3)
randNum = random.sample(range(10, 1500, 500), 3)
for i in range(3):
randX = random.randrange(-2, 3, 10)
randY = float(randNum[i])
# randY = random.randint(1000, 1500)
shape = BulletBoxShape(size * 0.55)
node = BulletRigidBodyNode('Floater')
node.setMass(0)
node.addShape(shape)
np = self.render.attachNewNode(node)
# np.setPos(9, 30, 3)
np.setPos(randX, randY, 6)
np.setR(0)
self.world2.attachRigidBody(node)
dummyNp = self.render.attachNewNode('milkyway')
dummyNp.setPos(randX, randY, 6)
modelNP = loader.loadModel('models/box.egg')
modelNP_tex = loader.loadTexture("models/sky/moon_tex.jpg")
modelNP.setTexture(modelNP_tex, 1)
modelNP.reparentTo(dummyNp)
modelNP.setPos(-1, 0, -1)
modelNP.setPos(-size.x / 2.0, -size.y / 2.0, -size.z / 2.0)
modelNP.setScale(size)
dummyNp.hprInterval(2.5, Vec3(360, 0, 0)).loop()
# Put A Coin On the Floater
shape = BulletSphereShape(0.75)
coinNode = BulletGhostNode('FloaterCoin-' + str(i))
coinNode.addShape(shape)
np = self.render.attachNewNode(coinNode)
np.setCollideMask(BitMask32.allOff())
# np.setPos(randX, randY, 2)
np.setPos(randX, randY, 7.0)
# Adding sphere model
sphereNp = loader.loadModel('models/smiley.egg')
sphereNp_tex = loader.loadTexture("models/sky/coin_2_tex.jpg")
sphereNp.setTexture(sphereNp_tex, 1)
sphereNp.reparentTo(np)
sphereNp.setScale(0.85)
sphereNp.hprInterval(1.5, Vec3(360, 0, 0)).loop()
self.world2.attachGhost(coinNode)
self.coins2.append(coinNode)
print "node name:" + str(coinNode.getName())
def renderObject(self,scale,hpr,collisionOn=False):
(x_scale,y_scale,z_scale) = scale
(h,p,r) = hpr
if collisionOn is True:
if self.name is 'wide_ramp':
(x_c,y_c,z_c) = (x_scale + .2,y_scale+2.5,z_scale+1.75)
if self.name is 'tree1':
(x_c,y_c,z_c) = (x_scale,y_scale,z_scale)
if self.name is 'tree2':
(x_c,y_c,z_c) = (x_scale,y_scale,z_scale)
if self.name is 'rock1':
(x_c,y_c,z_c) = (x_scale * 2,y_scale * 2,z_scale*2)
if self.name is 'rock2':
(x_c,y_c,z_c) = (x_scale*100,y_scale*100,z_scale*100)
if self.name is 'gate':
(x_c,y_c,z_c) = (x_scale * 10,y_scale,z_scale*3.5)
if self.name is 'statue':
(x_c,y_c,z_c) = (x_scale,y_scale,z_scale)
mesh = BulletTriangleMesh()
for geomNP in self.model.findAllMatches('**/+GeomNode'):
geomNode = geomNP.node()
ts = geomNP.getTransform(self.model)
for geom in geomNode.getGeoms():
mesh.addGeom(geom, ts)
shape = BulletTriangleMeshShape(mesh, dynamic=False)
node = BulletRigidBodyNode(self.name)
node.setMass(0)
node.addShape(shape)
np = self.__game.render.attachNewNode(node)
np.setPos(self.x,self.y,self.z)
np.setHpr(h,p,r)
np.setScale(x_c,y_c,z_c)
self.__game.world.attachRigidBody(node)
self.model.setPos(self.x,self.y,self.z)
self.model.setHpr(h,p,r)
self.model.setScale(x_scale,y_scale,z_scale)
self.model.reparentTo(self.__game.render)
if self.name is 'statue':
plat_texture = loader.loadTexture('models/textures/rocky.jpg')
self.model.setTexture(plat_texture,1)
ts = TextureStage.getDefault()
texture = self.model.getTexture()
self.model.setTexScale(ts, 1, 1)
class MagicBox(Item):
def createItem(self):
self.collisionShape = BulletBoxShape(Vec3(0.5, 0.6, 0.5))
self.actor = BulletRigidBodyNode('MagicBox')
self.actor.addShape(self.collisionShape)
self.np = self.render.attachNewNode(self.actor)
self.np.setCollideMask(BitMask32.allOff())
self.np.setPos(self.x, self.y, self.z)
self.world.attachRigidBody(self.actor)
self.actorModelNP = self.loader.loadModel('models/magicbox/ToyBox.egg')
self.actorModelNP.reparentTo(self.np)
self.actorModelNP.setScale(0.35)
self.actorModelNP.setH(180)
self.actorModelNP.setPos(0, 0, -0.5)
def createGround(self):
shape = BulletPlaneShape(Vec3(0, 0, 1), 1)
node = BulletRigidBodyNode('Ground')
node.addShape(shape)
np = render.attachNewNode(node)
np.setPos(0, 0, -2)
self.world.attachRigidBody(node)
table = loader.loadModel("tableplane.egg")
table.reparentTo(np)
tableTex = loader.loadTexture("tree-bark-89a.jpg")
tableTex.setMinfilter(Texture.FTLinearMipmapLinear) # Enable texture mipmapping
table.setTexture(tableTex)
table.setPos(0,0,-0.1)
table.setScale(2) # f***s the shadows
def start(self):
# Boxes
model = loader.loadModel('models/box.egg')
model.setPos(-0.5, -0.5, -0.5)
model.flattenLight()
shape = BulletBoxShape(Vec3(0.5, 0.5, 0.5))
for i in range(10):
node = BulletRigidBodyNode('Box')
node.setMass(1.0)
node.addShape(shape)
np = render.attachNewNode(node)
np.setPos(self.spawnNP.getPos(render) + Vec3(0, 0, 2 + i * 2))
self.world.attachRigidBody(node)
model.copyTo(np)
logging.info("Box test placed at " + str(self.spawnNP.getPos()))
def makeCameraCollision(self):
#nodes
node = BulletRigidBodyNode('Box')
#node.setMass(0)
self.ccnp = render.attachNewNode(node)
self.ccnp.reparentTo(base.camera)
#shapes
shape = BulletSphereShape(.5)
#nodes
node.addShape(shape)
#bullet world
self.world.attachRigidBody(node)
