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