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 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)