def fire(self, shooterPosition, targetPosition): print("fire balls") # create bullet rigid body node sphereBRBN = BulletRigidBodyNode('Ball') # set physics properties sphereBRBN.setMass(1.0) sphereBRBN.addShape(BulletSphereShape(0.2)) # attach to render and get a nodePath in render hierarchic sphere = self.render.attachNewNode(sphereBRBN) # set starting position of fire ball pos = shooterPosition pos.setZ(pos.getZ() + 1) sphere.setPos(pos) # load texture of fireball and set size then add to nodePath smileyFace = self.loader.loadModel("models/smiley") smileyFace.setScale(0.2) smileyFace.reparentTo(sphere) # add rigid body to physics world self.world.attachRigidBody(sphereBRBN) # apply the force so it moves shootingDirection = targetPosition - pos shootingDirection.normalize() sphereBRBN.applyCentralForce(shootingDirection * 1000) self.fireballs.append(sphereBRBN) self.cleanUp()
class Modulo(object): def __init__(self, world, x, y, w, h, parent_node): self._model = None self._initPhysics(world, x, y, w, h, parent_node) self._loadModel(x, y, h) def remove(self): if self._model is not None: self._model.remove() def _loadModel(self, x, y, h): self._model = loader.loadModel("../data/models/modulo.egg") self._model.setPos(0, 0, 0) self._model.reparentTo(self._modulo_node) def _initPhysics(self, world, x, y, w, h, parent_node): shape = BulletBoxShape(Vec3(w * 0.5, w * 0.5, h * 0.5)) self._rb_node = BulletRigidBodyNode('Box') self._rb_node.setMass(0) self._rb_node.addShape(shape) #self._rb_node.setAngularFactor(Vec3(0,0,0)) #self._rb_node.setDeactivationEnabled(False, True) world.attachRigidBody(self._rb_node) self._modulo_node = parent_node.attachNewNode(self._rb_node) self._modulo_node.setPos(x, y, h / 2.0)
def newGame(self): # Instantiates dabba in the world. # Makes it rigid too. boxmodel = loader.loadModel("models/misc/rgbCube.egg") boxmodel.setPos(-0.5, -0.5, -0.5) boxmodel.flattenLight() shape3 = BulletBoxShape(Vec3(0.5,0.5,0.5)) playerNode = BulletRigidBodyNode('Player') playerNode.addShape(shape3) playerNode.setMass(1.0) playerNP = render.attachNewNode(playerNode) playerNP.setPos(0, 0, 10) playerNP.node().notifyCollisions(True) self.playerNP = playerNP self.world.attachRigidBody(playerNP.node()) self.playerNode = playerNode boxmodel.copyTo(playerNP) # Connects cam to dabba self.cam1.reparentTo(playerNP) self.cam2.reparentTo(playerNP) self.cam1.setPos(1-0.7,-12,0) self.cam2.setPos( 1+0.7,-12,0) base.accept('u',self.up) base.accept('j',self.down) base.accept('w',self.forward) base.accept('s',self.back) base.accept('a',self.rotLeft) base.accept('d',self.rotRight) base.accept('t',self.rotUp) base.accept('g',self.rotDown) base.acceptOnce('bullet-contact-added', self.onContactAdded)
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 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
class RocketPhys(Phys): def __init__(self, mdt, parent): Phys.__init__(self, mdt) self.parent = parent def fire(self): self.node = BulletRigidBodyNode('Box') self.node.setMass(10000) self.node.addShape(BulletSphereShape(.5)) self.np = self.parent.attachNewNode(self.node) self.np.setPos(0, 0, 1.5) eng.attach_rigid_body(self.node) self.mdt.gfx.gfx_np.reparentTo(self.np) self.mdt.gfx.gfx_np.setPos(0, 0, 0) rot_mat = Mat4() rot_mat.setRotateMat(self.parent.get_h(), (0, 0, 1)) self.node.setLinearVelocity(rot_mat.xformVec((0, 30, 0))) # continue to apply after firing def destroy(self): if hasattr(self, 'node'): # has not been fired eng.remove_rigid_body(self.node) self.np = self.np.remove_node() self.parent = None Phys.destroy(self)
def create_object(self): from panda3d.core import Filename, NodePath, BitMask32 from direct.actor.Actor import Actor from panda3d.bullet import BulletRigidBodyNode, BulletCapsuleShape from game_system.resources import ResourceManager f = Filename.fromOsSpecific(ResourceManager.get_absolute_path(ResourceManager["TestAI"]["lp_char_bs.egg"])) model = Actor(f) bullet_node = BulletRigidBodyNode("TestAIBulletNode") bullet_nodepath = NodePath(bullet_node) bullet_node.set_angular_factor((0, 0, 1)) shape = BulletCapsuleShape(0.3, 1.4, 2) bullet_node.addShape(shape) bullet_node.setMass(1.0) model.reparentTo(bullet_nodepath) model.set_hpr(180, 0, 0) model.set_pos(0, 0, -1) bullet_nodepath.set_collide_mask(BitMask32.bit(0)) bullet_nodepath.set_python_tag("actor", model) return bullet_nodepath
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
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 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 init_objects(self): # Make Playfer Box shape = BulletBoxShape(Vec3(0.25, 0.25, 0.25)) node = BulletRigidBodyNode('Playfer Box') node.setMass(110.0) node.setFriction(1.0) node.addShape(shape) node.setAngularDamping(0.0) np = render.attachNewNode(node) np.setPos(-1.4, 1.7, -1.7) self.world.attachRigidBody(node) playferboxmodel = loader.loadModel('../data/mod/playferbox.egg') playferboxmodel.reparentTo(np) # Make Pendlepot shape = BulletBoxShape(Vec3(0.2, 0.15, 0.1)) node = BulletRigidBodyNode('Pendlepot') node.setMass(5.0) node.setFriction(1.0) node.addShape(shape) node.setAngularDamping(0.0) np = render.attachNewNode(node) np.setPos(-1.4, 1.7, -1.5) self.world.attachRigidBody(node) pendlepotmodel = loader.loadModel('../data/mod/pendlepot.egg') pendlepotmodel.reparentTo(np)
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)
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 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 createBody(self, _count, _type, _pos=(0, 0, 0)): radius = 0.4 shape = BulletSphereShape(radius) name = _type + "Dude" + str(_count) node = BulletRigidBodyNode(name) node.setMass(2.0) node.addShape(shape) #node.setDeactivationEnabled(False) np = render.attachNewNode(node) np.setCollideMask(BitMask32.allOn()) self.parent.physics_world.attachRigidBody(node) np.setPos(_pos) #model = loader.loadModel("assets/dude") #model.reparentTo(np) #model.setScale(0.4) dudeID = [1, 2, 3] tex = loader.loadTexture("dudes/dude{}_good.png".format( choice(dudeID))) cm = CardMaker('spritesMaker') sprite = NodePath(cm.generate()) sprite.setTexture(tex) sprite.reparentTo(np) sprite.setPos(-0.4, 0, -0.4) sprite.setCompass(render) sprite.setTransparency(1) sprite.setScale(0.8) return name, np
def getPhysBody(self): from panda3d.bullet import BulletRigidBodyNode, BulletBoxShape from panda3d.core import TransformState bnode = BulletRigidBodyNode('entity-phys') bnode.setMass(self.mass) bnode.setCcdMotionThreshold(1e-7) bnode.setCcdSweptSphereRadius(0.5) if self.solidType == self.SOLID_MESH: convexHull = PhysicsUtils.makeBulletConvexHullFromCollisionSolids( self.model.find("**/+CollisionNode").node()) bnode.addShape(convexHull) elif self.solidType == self.SOLID_BBOX: mins = Point3() maxs = Point3() self.calcTightBounds(mins, maxs) extents = PhysicsUtils.extentsFromMinMax(mins, maxs) tsCenter = TransformState.makePos( PhysicsUtils.centerFromMinMax(mins, maxs)) shape = BulletBoxShape(extents) bnode.addShape(shape, tsCenter) return bnode
def newGame(self): boxmodel = loader.loadModel("models/box.egg") boxmodel.setPos(-0.5, -0.5, -0.5) boxmodel.flattenLight() shape3 = BulletBoxShape(Vec3(0.5,0.5,0.5)) playerNode = BulletRigidBodyNode('Player') playerNode.addShape(shape3) playerNode.setMass(1.0) playerNP = render.attachNewNode(playerNode) playerNP.setPos(0, 0, 10) playerNP.node().notifyCollisions(True) self.playerNP = playerNP self.world.attachRigidBody(playerNP.node()) self.playerNode = playerNode boxmodel.copyTo(playerNP) # self.base.cam.reparentTo(playerNP) # base.cam.setPos(0,-10,0) self.cam1.reparentTo(playerNP) self.cam2.reparentTo(playerNP) self.cam1.setPos(-1,-10,0) self.cam2.setPos( 1,-10,0) base.accept('u',self.up) base.accept('w',self.forward) base.accept('s',self.back) base.accept('a',self.rotLeft) base.accept('d',self.rotRight) base.accept('t',self.rotUp) base.accept('g',self.rotDown) base.acceptOnce('bullet-contact-added', self.onContactAdded)
def makeVPPhysics(multipart=False): from panda3d.core import TransformState from panda3d.bullet import BulletBoxShape, BulletRigidBodyNode carriage = BulletBoxShape((4.40625, 7.125, 2.75)) tread = BulletBoxShape((1.9, 10.34, 2.75)) legs = BulletBoxShape((3.375, 3.375, 2.1875)) gear = BulletBoxShape((6.72, 6.72, 1.1)) torso = BulletBoxShape((4.44, 3.625, 4.125)) head = BulletBoxShape((2, 2, 2.22)) torsoTrans = TransformState.makePos((0, 0, 13.93)) headTrans = TransformState.makePos((0, 0, 20.28)) bodyNode = BulletRigidBodyNode("VPPhysics") bodyNode.addShape(carriage, TransformState.makePos((0, 0, 2.75))) bodyNode.addShape(tread, TransformState.makePos((6.3, 0, 2.75))) bodyNode.addShape(tread, TransformState.makePos((-6.3, 0, 2.75))) bodyNode.addShape(legs, TransformState.makePos((0, 0, 7.75))) bodyNode.addShape(gear, TransformState.makePos((0, 0, 10.94))) if not multipart: bodyNode.addShape(torso, torsoTrans) bodyNode.addShape(head, headTrans) bodyNode.setKinematic(True) bodyNode.setMass(0.0) if multipart: upperNode = BulletRigidBodyNode("VPPhysics-upper") upperNode.addShape(torso, torsoTrans) upperNode.addShape(head, headTrans) upperNode.setKinematic(True) upperNode.setMass(0.0) if multipart: return [bodyNode, upperNode] return bodyNode
class HLodDynamicObject(NodePath): def __init__(self, name, scene, visibleLODsDict={"eggfileName":("maxFar","minNear")}, collisionEgg=None, x0=0, y0=0, z0=0, parent=None, margin=0.02, mass=0, directRender=True, convex=True): self.name = name self.scene = scene NodePath.__init__(self,LODNode(name+"_LODNode")) ###LOD### for k in visibleLODsDict.keys(): v=base.loader.loadModel(k) v.reparentTo(self) self.node().addSwitch(visibleLODsDict[k][0],visibleLODsDict[k][1]) ######### self.body = BulletRigidBodyNode(self.name + "_RigidBody") self.attachNewNode(self.body) if collisionEgg != None: m = self.scene.Base.loader.loadModel(collisionEgg) if convex: sTuple = modelToConvex(m) else: sTuple = modelToShape(m) sTuple[0].setMargin(margin) self.body.addShape(sTuple[0], sTuple[1]) self.body.setMass(mass) self.body.setPythonTag("name", self.name + "_RigidBody") self.scene.world.attachRigidBody(self.body) self.setPos(x0, y0, z0) if directRender: self.reparentTo(self.scene.Base.render) elif parent != None: self.reparentTo(parent)
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 _initAgents(self): # Load agents for agent in self.scene.scene.findAllMatches('**/agents/agent*'): transform = TransformState.makeIdentity() if self.agentMode == 'capsule': shape = BulletCapsuleShape( self.agentRadius, self.agentHeight - 2 * self.agentRadius) elif self.agentMode == 'sphere': shape = BulletCapsuleShape(self.agentRadius, 2 * self.agentRadius) # XXX: use BulletCharacterControllerNode class, which already handles local transform? node = BulletRigidBodyNode('physics') node.setMass(self.agentMass) node.setStatic(False) node.setFriction(self.defaultMaterialFriction) node.setRestitution(self.defaultMaterialRestitution) node.addShape(shape) self.bulletWorld.attach(node) # Constrain the agent to have fixed position on the Z-axis node.setLinearFactor(Vec3(1.0, 1.0, 0.0)) # Constrain the agent not to be affected by rotations node.setAngularFactor(Vec3(0.0, 0.0, 0.0)) node.setIntoCollideMask(BitMask32.allOn()) node.setDeactivationEnabled(True) # Enable continuous collision detection (CCD) node.setCcdMotionThreshold(1e-7) node.setCcdSweptSphereRadius(0.50) if node.isStatic(): agent.setTag('physics-mode', 'static') else: agent.setTag('physics-mode', 'dynamic') # Attach the physic-related node to the scene graph physicsNp = NodePath(node) physicsNp.setTransform(transform) # Reparent all child nodes below the new physic node for child in agent.getChildren(): child.reparentTo(physicsNp) physicsNp.reparentTo(agent) # NOTE: we need this to update the transform state of the internal bullet node physicsNp.node().setTransformDirty() # Validation assert np.allclose( mat4ToNumpyArray(physicsNp.getNetTransform().getMat()), mat4ToNumpyArray(agent.getNetTransform().getMat()), atol=1e-6)
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
class BoxBody(Entity): def __init__(self, world, **kwargs): super().__init__(**kwargs) self.shape = BulletBoxShape(Vec3(0.5, 0.5, 0.5)) self.node = BulletRigidBodyNode('cube') self.node.setMass(1.0) self.np = render.attachNewNode(self.node) self.np.setY(4) self.parent = self.np world.attachRigidBody(self.node)
def getPhysBody(self): shape = BulletCylinderShape(0.3925, 1.4, ZUp) body = BulletRigidBodyNode('tntBody') body.addShape(shape) body.setCcdMotionThreshold(1e-7) body.setCcdSweptSphereRadius(0.3925) body.setKinematic(False) body.setMass(5.0) body.setAngularDamping(0.3) body.setLinearDamping(0.8) return body
def _initLayoutModels(self): # Load layout objects as meshes for model in self.scene.scene.findAllMatches('**/layouts/object*/model*'): # NOTE: ignore models that have no geometry defined if model.getTightBounds() is None: logger.warning('Object %s has no geometry defined and will be ignored for physics!' % (str(model))) continue shape, transform = getCollisionShapeFromModel( model, mode='mesh', defaultCentered=False) node = BulletRigidBodyNode('physics') node.setMass(0.0) node.setFriction(self.defaultMaterialFriction) node.setRestitution(self.defaultMaterialRestitution) node.setStatic(True) node.addShape(shape) node.setDeactivationEnabled(True) node.setIntoCollideMask(BitMask32.allOn()) self.bulletWorld.attach(node) # Attach the physic-related node to the scene graph physicsNp = model.getParent().attachNewNode(node) physicsNp.setTransform(transform) if node.isStatic(): model.getParent().setTag('physics-mode', 'static') else: model.getParent().setTag('physics-mode', 'dynamic') # Reparent render and acoustics nodes (if any) below the new physic node # XXX: should be less error prone to just reparent all children # (except the hidden model) renderNp = model.getParent().find('**/render') if not renderNp.isEmpty(): renderNp.reparentTo(physicsNp) acousticsNp = model.getParent().find('**/acoustics') if not acousticsNp.isEmpty(): acousticsNp.reparentTo(physicsNp) semanticsNp = model.getParent().find('**/semantics') if not semanticsNp.isEmpty(): semanticsNp.reparentTo(physicsNp) # NOTE: we need this to update the transform state of the internal # bullet node physicsNp.node().setTransformDirty() # Validation assert np.allclose(mat4ToNumpyArray(physicsNp.getNetTransform().getMat()), mat4ToNumpyArray(model.getNetTransform().getMat()), atol=1e-6)
class DynamicBox(DynamicObject): def __init__(self, name, game, pos): self.name = name self.game = game self.shape = BulletBoxShape(Vec3(0.5, 0.5, 0.5)) self.node = BulletRigidBodyNode(name) self.node.setMass(10.0) self.node.addShape(self.shape) self.setFriction(20) self.np = self.game.render.attachNewNode(self.node) self.np.setPos(pos) self.game.world.attachRigidBody(self.node) self.model = self.game.loader.loadModel("models/crate.egg") self.model.reparentTo(self.np) self.node.setCcdMotionThreshold(1e-7) self.node.setCcdSweptSphereRadius(0.5) self.debugOff() self.slice_able = True def update(self, dt): #self.activate() #if self.node.isActive(): # return contact = self.checkFeet() contacts = self.getContacts() if contact in self.game.objects and contact in contacts: obj = self.game.objects[contact] if type(obj) is KinematicPlatform: self.activate() self.setAngularVelocity(self.getAngularVelocity() * 0.9) self.setFriction(0.1) #print "%s is a box sliding on %s" % (self.name, obj.name) #self.addSpeedVec(self.game.objects[contact].getSpeedVec()) #self.setForce(obj.getSpeedVec()*self.node.getMass() * 100) platform_speed = obj.getSpeedVec() force = platform_speed * self.node.getMass() * 50 #self.setSpeedXY(platform_speed[0], platform_speed[1]) self.setSpeedVec(platform_speed) #self.setAngularVelocity(0) #self.node.addLin(obj.getSpeedVec()*self.node.getMass() * 100) #self.node.applyCentralForce(force) #self.setForce(force) #self.setFriction(20) #self.setPos(self.getPos() + obj.getSpeedVec()) #self.node.setActive(False) else: self.setFriction(20)
class DynamicBox(DynamicObject): def __init__(self, name, game, pos): self.name = name self.game = game self.shape = BulletBoxShape(Vec3(0.5, 0.5, 0.5)) self.node = BulletRigidBodyNode(name) self.node.setMass(10.0) self.node.addShape(self.shape) self.setFriction(20) self.np = self.game.render.attachNewNode(self.node) self.np.setPos(pos) self.game.world.attachRigidBody(self.node) self.model = self.game.loader.loadModel("models/crate.egg") self.model.reparentTo(self.np) self.node.setCcdMotionThreshold(1e-7) self.node.setCcdSweptSphereRadius(0.5) self.debugOff() self.slice_able = True def update(self, dt): #self.activate() #if self.node.isActive(): # return contact = self.checkFeet() contacts = self.getContacts() if contact in self.game.objects and contact in contacts: obj = self.game.objects[contact] if type(obj) is KinematicPlatform: self.activate() self.setAngularVelocity(self.getAngularVelocity()*0.9) self.setFriction(0.1) #print "%s is a box sliding on %s" % (self.name, obj.name) #self.addSpeedVec(self.game.objects[contact].getSpeedVec()) #self.setForce(obj.getSpeedVec()*self.node.getMass() * 100) platform_speed = obj.getSpeedVec() force = platform_speed * self.node.getMass() * 50 #self.setSpeedXY(platform_speed[0], platform_speed[1]) self.setSpeedVec(platform_speed) #self.setAngularVelocity(0) #self.node.addLin(obj.getSpeedVec()*self.node.getMass() * 100) #self.node.applyCentralForce(force) #self.setForce(force) #self.setFriction(20) #self.setPos(self.getPos() + obj.getSpeedVec()) #self.node.setActive(False) else: self.setFriction(20)
def __emitShell(self): def __shellThink(shell, task): if task.time > 3.0: base.physicsWorld.remove(shell.node()) shell.removeNode() return task.done if not hasattr(task, 'didHitNoise'): task.didHitNoise = False if not task.didHitNoise: contact = base.physicsWorld.contactTest(shell.node()) if contact.getNumContacts() > 0: task.didHitNoise = True hitNoise = base.loadSfxOnNode( self.ShellContactSoundPath.format( random.randint(*self.ShellContactSoundRange)), shell) hitNoise.play() return task.cont from panda3d.bullet import BulletCylinderShape, BulletRigidBodyNode, ZUp scale = 0.75 shape = BulletCylinderShape(0.07 * scale, 0.47 * scale, ZUp) rbnode = BulletRigidBodyNode('shellrbnode') rbnode.setMass(1.0) rbnode.addShape(shape) rbnode.setCcdMotionThreshold(1e-7) rbnode.setCcdSweptSphereRadius(0.1) rbnp = render.attachNewNode(rbnode) mdl = loader.loadModel(self.ShellPath) mdl.reparentTo(rbnp) mdl.setScale(0.3 * scale, 0.7 * scale, 0.3 * scale) mdl.setP(90) mdl.setTransparency(True, 1) rbnp.setPos(camera, (1, 2, -0.5)) rbnp.setHpr(camera, (0, -90, 0)) localEjectDir = Vec3(1, 0, 0.3) rbnode.applyCentralImpulse( camera.getQuat(render).xform(localEjectDir) * 7) base.physicsWorld.attach(rbnode) taskMgr.add(__shellThink, 'shellThink', extraArgs=[rbnp], appendTask=True)
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)
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 create_cube(): entity = loader.loadModel("panda_project/cube.egg") from panda3d.bullet import BulletBoxShape, BulletRigidBodyNode from panda3d.core import NodePath shape = BulletBoxShape((0.5, 0.5, 0.5)) node = BulletRigidBodyNode('Box') node.setMass(1.0) node.addShape(shape) nodepath = NodePath(node) entity.wrt_reparent_to(nodepath) return nodepath
def createSphere(self, world, mass=1, scale=1): shape = BulletSphereShape(scale) node = BulletRigidBodyNode('Sphere') node.setMass(mass) node.addShape(shape) #np = render.attachNewNode(node) #np.setPos(0, 0, 4) world.attachRigidBody(node) model = loader.loadModel('models/smiley.egg') model.setScale(scale) #model.setPos(-scale[0],-scale[1],-scale[2]) model.flattenLight() #model.reparentTo(np) return BasePhysicalObject(model, node)
def makeBall(self, num, pos = (0, 0, 0)): shape = BulletSphereShape(0.5) node = BulletRigidBodyNode('ball_' + str(num)) node.setMass(1.0) node.setRestitution(.9) node.setDeactivationEnabled(False) node.addShape(shape) physics = render.attachNewNode(node) physics.setPos(*pos) self.world.attachRigidBody(node) model = loader.loadModel('models/ball') color = self.makeColor() model.setColor(color) self.ballColors['ball_' + str(num)] = color model.reparentTo(physics)
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 createSphere(self, world, mass=1, scale=1): shape = BulletSphereShape(scale) node = BulletRigidBodyNode('Sphere') node.setMass(mass) node.addShape(shape) #np = render.attachNewNode(node) #np.setPos(0, 0, 4) world.attachRigidBody(node) model = loader.loadModel('models/smiley.egg') model.setScale(scale) #model.setPos(-scale[0],-scale[1],-scale[2]) model.flattenLight() #model.reparentTo(np) return BasePhysicalObject(model,node)
def _add_chassis(self, pg_physics_world: PGPhysicsWorld): para = self.get_config() chassis = BulletRigidBodyNode(BodyName.Ego_vehicle_top) chassis.setIntoCollideMask(BitMask32.bit(self.COLLISION_MASK)) chassis_shape = BulletBoxShape( Vec3(para[Parameter.vehicle_width] / 2, para[Parameter.vehicle_length] / 2, para[Parameter.vehicle_height] / 2)) ts = TransformState.makePos( Vec3(0, 0, para[Parameter.chassis_height] * 2)) chassis.addShape(chassis_shape, ts) heading = np.deg2rad(-para[Parameter.heading] - 90) chassis.setMass(para[Parameter.mass]) self.chassis_np = self.node_path.attachNewNode(chassis) # not random born now self.chassis_np.setPos(Vec3(*self.born_place, 1)) self.chassis_np.setQuat( LQuaternionf(np.cos(heading / 2), 0, 0, np.sin(heading / 2))) chassis.setDeactivationEnabled(False) chassis.notifyCollisions(True) # advance collision check self.pg_world.physics_world.dynamic_world.setContactAddedCallback( PythonCallbackObject(self._collision_check)) self.dynamic_nodes.append(chassis) chassis_beneath = BulletGhostNode(BodyName.Ego_vehicle) chassis_beneath.setIntoCollideMask(BitMask32.bit(self.COLLISION_MASK)) chassis_beneath.addShape(chassis_shape) self.chassis_beneath_np = self.chassis_np.attachNewNode( chassis_beneath) self.dynamic_nodes.append(chassis_beneath) self.system = BulletVehicle(pg_physics_world.dynamic_world, chassis) self.system.setCoordinateSystem(ZUp) self.dynamic_nodes.append( self.system ) # detach chassis will also detach system, so a waring will generate self.LENGTH = para[Parameter.vehicle_length] self.WIDTH = para[Parameter.vehicle_width] if self.render: model_path = 'models/ferra/scene.gltf' self.chassis_vis = self.loader.loadModel( AssetLoader.file_path(model_path)) self.chassis_vis.setZ(para[Parameter.vehicle_vis_z]) self.chassis_vis.setY(para[Parameter.vehicle_vis_y]) self.chassis_vis.setH(para[Parameter.vehicle_vis_h]) self.chassis_vis.set_scale(para[Parameter.vehicle_vis_scale]) self.chassis_vis.reparentTo(self.chassis_np)
class Shoot(): def __init__(self, showbase): self.showbase = showbase self.actor = showbase.actor print('Press "q" to shoot') showbase.accept('q', self.createBall) def createBall(self): self.actor.play("launch") # Sphere self.shape = BulletSphereShape(0.15) self.node = BulletRigidBodyNode('Sphere') self.node.setMass(1) self.node.addShape(self.shape) self.np = self.showbase.render.attachNewNode(self.node) self.np.setPos(self.actor.getX(), self.actor.getY(), self.actor.getZ() + 2.5) # Smiley self.model = self.showbase.loader.loadModel("./models/smiley") self.model.setTexture( self.showbase.loader.loadTexture(imagePath + 'metal1.jpg'), 1) self.model.flattenLight() self.model.setScale(0.15, 0.15, 0.15) self.model.reparentTo(self.np) # Set speed h = self.actor.getH() if (h == 0): x = 0 y = 8 if (h == 90): x = -7 y = 0 if (h == 180): x = 0 y = -8 if (h == -90): x = 8 y = 0 self.node.setLinearVelocity(Vec3(x, y, 6.2)) #self.actor.getX()/3, 11, 6.2) self.showbase.world.attachRigidBody(self.node)
def setupFloor2(self): size = Vec3(7.5, 3000, 1.81818) shape = BulletBoxShape(size * 0.55) # shape = BulletPlaneShape(Vec3(0, 0, 1), 0) node = BulletRigidBodyNode('Box-Floor') node.addShape(shape) node.setMass(0) stairNP = self.render.attachNewNode(node) stairNP.setPos(0, 0, 0) stairNP.setCollideMask(BitMask32.allOn()) self.world2.attachRigidBody(stairNP.node()) modelNP = loader.loadModel('models/box.egg') modelNP.reparentTo(stairNP) modelNP.setPos(-size.x / 2.0, -size.y / 2.0, -size.z / 2.0) modelNP.setScale(size)
def shoot(self): self.ammoUsed = 0 self.ammoUsed += 1 #nodes node = BulletRigidBodyNode('Box') node.setMass(.1) ammoNode = render.attachNewNode(node) #shapes shape = BulletSphereShape(.2) model = Sphere(.2) model.reparentTo(ammoNode) model.setPos(0, 0, 0) #nodes node.addShape(shape) material = Material() material.setAmbient(VBase4(random.random(), random.random(), random.random(), random.random())) material.setDiffuse(VBase4(random.random(), random.random(), random.random(), random.random())) material.setEmission(VBase4(random.random(), random.random(), random.random(), random.random())) material.setShininess(random.random()) #myTexture = loader.loadTexture("player.png") #ammoNode.setTexture(myTexture) ammoNode.setMaterial(material) ammoNode.setX(self.enemyNp.getX()) ammoNode.setY(self.enemyNp.getY()) ammoNode.setZ(self.enemyNp.getZ() + 1) force = Vec3(0, 0, 0) force.setY(5) force.setZ(1) force*=50 force = render.getRelativeVector(self.player, force) ammoNode.node().applyCentralForce(force) print(force) #bullet world self.world.attachRigidBody(node) #taskMgr.remove('ammoDestroy') task = Task(self.destroyAmmoNode) taskMgr.add(task, 'ammoDestroy', extraArgs = [task, ammoNode, node, self.world])
def createBox(self, mass=5, scale=(1, 1, 1)): shape = BulletBoxShape(Vec3(*scale)) node = BulletRigidBodyNode('Box') node.setMass(mass) node.addShape(shape) #np = render.attachNewNode(node) #np.setPos(0, 0, 2) self.world.attachRigidBody(node) model = loader.loadModel('models/box.egg') scalex2 = [] for item in scale: scalex2.append(item * 2) model.setScale(*scalex2) model.setPos(-scale[0], -scale[1], -scale[2]) model.flattenLight() #model.reparentTo(np) return BasePhysicalObject(model, node)
def createBox(self, mass=5, scale=(1, 1, 1)): shape = BulletBoxShape(Vec3(*scale)) node = BulletRigidBodyNode('Box') node.setMass(mass) node.addShape(shape) #np = render.attachNewNode(node) #np.setPos(0, 0, 2) self.world.attachRigidBody(node) model = loader.loadModel('models/box.egg') scalex2 = [] for item in scale: scalex2.append(item * 2) model.setScale(*scalex2) model.setPos(-scale[0], -scale[1], -scale[2]) model.flattenLight() #model.reparentTo(np) return BasePhysicalObject(model,node)
class Shoot( ) : def __init__(self, showbase) : self.showbase = showbase self.actor = showbase.actor print('Press "q" to shoot') showbase.accept('q', self.createBall) def createBall(self) : self.actor.play("launch") # Sphere self.shape = BulletSphereShape(0.15) self.node = BulletRigidBodyNode('Sphere') self.node.setMass(1) self.node.addShape(self.shape) self.np = self.showbase.render.attachNewNode(self.node) self.np.setPos(self.actor.getX(), self.actor.getY(), self.actor.getZ() + 2.5) # Smiley self.model = self.showbase.loader.loadModel("./models/smiley") self.model.setTexture(self.showbase.loader.loadTexture(imagePath + 'metal1.jpg'), 1) self.model.flattenLight() self.model.setScale(0.15, 0.15, 0.15) self.model.reparentTo(self.np) # Set speed h = self.actor.getH() if(h == 0) : x = 0 y = 8 if(h == 90) : x = -7 y = 0 if(h == 180) : x = 0 y = -8 if(h == -90) : x = 8 y = 0 self.node.setLinearVelocity(Vec3(x, y, 6.2)) #self.actor.getX()/3, 11, 6.2) self.showbase.world.attachRigidBody(self.node)
def setupWalls(self, _obj, _eggFile): tmpMesh = BulletTriangleMesh() node = _obj.node() if node.isGeomNode(): tmpMesh.addGeom(node.getGeom(0)) else: return body = BulletRigidBodyNode("wall") body.addShape(BulletTriangleMeshShape(tmpMesh, dynamic=False)) body.setMass(0) np = self.rootNode.attachNewNode(body) np.setCollideMask(BitMask32.bit(1)) self.parent.physics_world.attachRigidBody(body)
def addLinkedPhysicsObject(self, model, objectDescription): """Associate a phyiscal body with a model in this level """ splitDescription = objectDescription.split() try: objectType = splitDescription[0] parameters = splitDescription[1:] except IndexError: raise ValueError("Empty physics object description") if objectType == "cylinder": try: radius, height = map(float, parameters) except ValueError: raise ValueError("Invalid cylinder parameters: %s" % " ".join(parameters)) shape = BulletCylinderShape(radius, height, ZUp) else: raise ValueError("Invalid physics object type: %s" % objectType) # Create rigid body node and add to render and physics world rigidBodyNode = BulletRigidBodyNode(model.getName() + "_shape") rigidBodyNode.addShape(shape) rigidBodyNodePath = self.worldRender.attachNewNode(rigidBodyNode) # If mass is assigned, then this is a dynamic rigid body, # otherwise it's static if model.hasTag("mass"): mass = float(model.getTag("mass")) rigidBodyNode.setMass(mass) # Set it's position and orientation to match the model rigidBodyNodePath.setPos(model.getPos()) rigidBodyNodePath.setHpr(model.getHpr()) self.physicsWorld.attachRigidBody(rigidBodyNode) # Reparent graphical model so it follows physical object model.reparentTo(rigidBodyNodePath) model.setPos(0, 0, 0) model.setHpr(0, 0, 0) # Define sounds to play when this object is hit if model.hasTag("collisionSounds"): soundDescription = model.getTag("collisionSounds") self.addCollisionSounds(rigidBodyNodePath, soundDescription)
def create_object(self): from panda3d.core import Filename, NodePath, BitMask32 from panda3d.bullet import BulletRigidBodyNode, BulletPlaneShape from game_system.resources import ResourceManager f = Filename.fromOsSpecific(ResourceManager.get_absolute_path(ResourceManager["Plane"]["Plane.egg"])) model = loader.loadModel(f) bullet_node = BulletRigidBodyNode("BulletPlane") bullet_nodepath = NodePath(bullet_node) shape = BulletPlaneShape((0, 0, 1), 0) bullet_node.addShape(shape) bullet_node.setMass(1.0) bullet_nodepath.set_collide_mask(BitMask32.bit(0)) model.reparentTo(bullet_nodepath) return bullet_nodepath
def createPlatform(self, x, y, z): self.platform = loader.loadModel('../models/disk/disk.egg') geomnodes = self.platform.findAllMatches('**/+GeomNode') gn = geomnodes.getPath(0).node() geom = gn.getGeom(0) mesh = BulletTriangleMesh() mesh.addGeom(geom) shape = BulletTriangleMeshShape(mesh, dynamic=False) node = BulletRigidBodyNode('Platform') node.setMass(0) node.addShape(shape) platformnn = render.attachNewNode(node) platformnn.setPos(x, y, z) platformnn.setScale(3) self.world.attachRigidBody(node) self.platform.reparentTo(platformnn)
def createWall(self, x, y, z, h): self.wall = loader.loadModel('../models/wall/wall.egg') geomnodes = self.wall.findAllMatches('**/+GeomNode') gn = geomnodes.getPath(0).node() geom = gn.getGeom(0) mesh = BulletTriangleMesh() mesh.addGeom(geom) shape = BulletTriangleMeshShape(mesh, dynamic=False) wallNode = BulletRigidBodyNode('Wall') wallNode.setMass(0) wallNode.addShape(shape) wallnn = render.attachNewNode(wallNode) wallnn.setPos(x, y, z) wallnn.setH(h) wallnn.setScale(0.5, 50.5, 4.5) self.world.attachRigidBody(wallNode) self.wall.reparentTo(wallnn)
class SMCollide: # ------------------------------------------------------------------------------------------------------------------------------------------------------------ # Creates a new collision-enabled gameObject. # Args: model - Model path # world - bulletWorld instance # worldNP - world's NodePath # pos - Point3 position # scale - int scale # hpr - Vec3(Heading, Pitch, Rotation) # ------------------------------------------------------------------------------------------------------------------------------------------------------------ def __init__(self, model, world, worldNP, pos, scale, hpr): self.worldNP = worldNP bulletWorld = world # Initialize the model. self.AIModel = loader.loadModel(model) self.AINode = BulletRigidBodyNode("AIChar") self.AIModel.setScale(scale) self.AIModel.flattenLight() # Combines all geom nodes into one geom node. # Build the triangle mesh shape and attach it with the transform. geom = self.AIModel.findAllMatches("**/+GeomNode").getPath(0).node().getGeom(0) mesh = BulletTriangleMesh() mesh.addGeom(geom) shape = BulletTriangleMeshShape(mesh, dynamic=False) self.AINode.addShape(shape, TransformState.makePosHprScale(Point3(0, 0, 0), hpr, scale)) self.AINode.setMass(0) bulletWorld.attachRigidBody(self.AINode) # Apply the same transforms on the model being rendered. self.AIModel.reparentTo(render) self.AIModel.setH(hpr.getX()) self.AIModel.setP(hpr.getY()) self.AIModel.setR(hpr.getZ()) self.AINode.setAngularFactor(Vec3(0, 0, 0)) # Attach it to the world. self.AIChar = self.worldNP.attachNewNode(self.AINode) self.AIModel.reparentTo(self.AIChar) self.AIChar.setPos(pos)
def create_object(self): from panda3d.core import Filename, NodePath, BitMask32 from direct.actor.Actor import Actor from panda3d.bullet import BulletRigidBodyNode, BulletBoxShape from game_system.resources import ResourceManager f = Filename.fromOsSpecific(ResourceManager.get_absolute_path(ResourceManager["Zombie"]["Zombie.egg"])) model = Actor(f) bullet_node = BulletRigidBodyNode("BulletPlane") bullet_nodepath = NodePath(bullet_node) shape = BulletBoxShape((1, 1, 1)) bullet_node.addShape(shape) bullet_node.setMass(1.0) model.reparentTo(bullet_nodepath) bullet_nodepath.set_python_tag("actor", model) bullet_nodepath.set_collide_mask(BitMask32.bit(0)) return bullet_nodepath
def createMap(self): height = 10.0 img = PNMImage(Filename('resources/map1.bmp')) shape = BulletHeightfieldShape(img, height, ZUp) node = BulletRigidBodyNode('Map') node.setMass(99999999) node.addShape(shape) self.world.attachRigidBody(node) offset = img.getXSize() / 2.0 - 0.5 terrain = GeoMipTerrain('terrain') terrain.setHeightfield(img) terrainNP = terrain.getRoot() terrainNP.setSz(height) terrainNP.setPos(-offset, -offset, -height / 2.0) #terrain.setColorMap('resources/map1color.bmp') terrain.setAutoFlatten(GeoMipTerrain.AFMOff) terrain.generate() return Map(terrainNP,node)
def createBox(self, mass, pos, scale, color): rb = BulletRigidBodyNode('box') rb.addShape(BulletBoxShape(scale)) rb.setMass(mass) rb.setLinearDamping(0.2) rb.setAngularDamping(0.9) rb.setFriction(1.0) rb.setAnisotropicFriction(1.0) rb.setRestitution(0.0) self.world.attachRigidBody(rb) np = self.render.attachNewNode(rb) np.setPos(pos) np.setCollideMask(BitMask32.bit(1)) cube = self.loader.loadModel('cube') cube.setScale(scale) cube.setColor(color) cube.reparentTo(np) return np
class MovingPlatform(DirectObject): def __init__(self, render, world, x, y, z): self.movingPlatform = loader.loadModel('../models/square-flat/square.egg') geomnodes = self.movingPlatform.findAllMatches('**/+GeomNode') gn = geomnodes.getPath(0).node() geom = gn.getGeom(0) mesh = BulletTriangleMesh() mesh.addGeom(geom) shape = BulletTriangleMeshShape(mesh, dynamic=False) self.node = BulletRigidBodyNode('MovingPlatform') self.node.setMass(0) self.node.addShape(shape) self.movingPlatformnn = render.attachNewNode(self.node) self.movingPlatformnn.setPos(x, y, z) self.movingPlatformnn.setScale(9, 7, 0.5) world.attachRigidBody(self.node) self.movingPlatform.reparentTo(self.movingPlatformnn) # Associates movingPlatformnn with movingPlatform self.movingPlatformnn.setPythonTag("movingPlatformNP", self.movingPlatform) # Create a sequence of intervals and play them together using parallel downInterval = self.movingPlatformnn.posInterval(3, Point3(x, y, z), startPos=Point3(x, y, z + 15)) upInterval = self.movingPlatformnn.posInterval(3, Point3(x, y, z + 15), startPos=Point3(x, y, z)) # To randomize a little, take x position of platform. If it's even move downward. If it's odd, upward if x % 2 == 0: elevate = Sequence(downInterval, upInterval, name="elevate") else: elevate = Sequence(upInterval, downInterval, name="elevateOpposite") elevateParallel = Parallel() elevateParallel.append(elevate) elevateParallel.loop()
def makeSB(): body = BulletRigidBodyNode('...') geomNodeCollection = loader.loadModel('out2.egg').findAllMatches('**/+GeomNode') for geomNP in geomNodeCollection: geomNode = geomNP.node() ts = geomNode.getTransform() mesh = BulletTriangleMesh() for geom in geomNode.getGeoms(): mesh.addGeom(geom) shape = BulletTriangleMeshShape(mesh, dynamic=True) body.addShape(shape, ts) body.addChild(geomNode) #world.attachRigidBody(node) #body.copyTo(np) body.setMass(100.0) world.attachRigidBody(body) np1 = render.attachNewNode(body) np1.setPos(0, 0, 10) np1.setHpr(0,0,90) np1.setScale(0.5,0.5,0.5) print(body.getNumChildren()) return body #body = makeSB() # Update #taskMgr.add(update, 'update') #run()
def buildTriangleMesh(cls, _engine, _obj, _levelEgg, _mass=0, _isDynamic=False): """Build a bullet TriangleMesh for objects""" mesh = BulletTriangleMesh() node = _obj.node() if node.isGeomNode(): mesh.addGeom(node.getGeom(0)) else: return body = BulletRigidBodyNode(_obj.getTag("level"))#+str(_obj.getTag("id"))) body.addShape(BulletTriangleMeshShape(mesh, dynamic=_isDynamic)) body.setMass(_mass) np = _engine.BulletObjects["level"].attachNewNode(body) #np.setCollideMask(BitMask32.allOn()) np.setScale(_obj.getScale(_levelEgg)) np.setPos(_obj.getPos(_levelEgg)) np.setHpr(_obj.getHpr(_levelEgg)) _engine.bulletWorld.attachRigidBody(body) return np
# 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')