def __preventPenetration(self):
if self.noClip:
return
prevPeneCollector.start()
maxIter = 10
fraction = 1.0
#if self.__spam:
# lines = LineSegs()
# lines.setColor(1, 0, 0, 1)
# lines.setThickness(2)
collisions = Vec3(0)
offset = Point3(0, 0, self.__capsuleOffset)
while (fraction > 0.01 and maxIter > 0):
currentTarget = self.__targetPos + collisions
tsFrom = TransformState.makePos(self.__currentPos + offset)
tsTo = TransformState.makePos(currentTarget + offset)
sweepCollector.start()
result = self.__world.sweepTestClosest(
self.capsuleNP.node().getShape(0), tsFrom, tsTo,
CIGlobals.WallGroup, 1e-7)
sweepCollector.stop()
if result.hasHit() and (type(result.getNode())
is not BulletGhostNode):
if result.getNode().getCollisionResponse():
fraction -= result.getHitFraction()
normal = result.getHitNormal()
direction = result.getToPos() - result.getFromPos()
distance = direction.length()
direction.normalize()
if distance != 0:
reflDir = self.__computeReflectionDirection(
direction, normal)
reflDir.normalize()
collDir = self.__parallelComponent(reflDir, normal)
#if self.__spam:
# lines.moveTo(result.getFromPos())
# lines.drawTo(result.getHitPos())
collisions += collDir * distance
maxIter -= 1
collisions.z = 0.0
#if collisions.length() != 0 and self.__spam:
# if self.currLineSegsGeom:
# self.currLineSegsGeom.removeNode()
# self.currLineSegsGeom = None
# self.currLineSegsGeom = render.attachNewNode(lines.create())
self.__targetPos += collisions
prevPeneCollector.stop()
def doCollisionSweepTestZ(self,col_mask = CollisionMasks.PLATFORM_RIGID_BODY,from_z = 0, to_z = 0):
'''
doCollisionSweepTestZ(double from_z = 0, double to_z = 0)
Performs a collision sweep test along z in order to determine the height
at which the character's active rigid body comes into contact with an obstacle. This is useful during
landing actions.
@param col_mask: [optional] collision mask of the object(s) to check for collisions with.
@param from_z: [optional] z value for the start position
@param to_z: [optional] z value for the end position
'''
pos = self.getPos()
if abs(from_z - to_z) < 1e-5:
height = self.getHeight()
from_z = pos.getZ() + 0.5* height
to_z = pos.getZ() - 0.5* height
t0 = TransformState.makePos(Vec3(pos.getX(),pos.getY(),from_z))
t1 = TransformState.makePos(Vec3(pos.getX(),pos.getY(),to_z))
rigid_body = self.getRigidBody()
if rigid_body.node().getNumShapes() <= 0:
logging.warn("Rigid body contains no shapes, collision sweep test canceled")
return
aabb_shape = rigid_body.node().getShape(0)
result = self.physics_world_.sweepTestClosest(aabb_shape,t0,t1,col_mask,0.0)
if not result.hasHit():
logging.warn("No collision from collision sweep closest test from %s to %s "%(t0.getPos(),t1.getPos()))
else:
logging.debug("Found collision at point %s between p0: %s to p1 %s"%(result.getHitPos(),t0.getPos(),t1.getPos()))
return result
def circle_region_detection(engine: EngineCore,
position: Tuple,
radius: float,
detection_group: int,
height=10,
in_static_world=False):
"""
:param engine: BaseEngine class
:param position: position in PGDrive
:param radius: radius of the region to be detected
:param detection_group: which group to detect
:param height: the detect will be executed from this height to 0
:param in_static_world: execute detection in static world
:return: detection result
"""
region_detect_start = panda_position(position, z=height)
region_detect_end = panda_position(position, z=-1)
tsFrom = TransformState.makePos(region_detect_start)
tsTo = TransformState.makePos(region_detect_end)
shape = BulletCylinderShape(radius, 5, ZUp)
penetration = 0.0
physics_world = engine.physics_world.dynamic_world if not in_static_world else engine.physics_world.static_world
result = physics_world.sweep_test_closest(shape, tsFrom, tsTo,
detection_group, penetration)
return result
def sweepRay(self, startp,endp):
tsFrom = TransformState.makePos(Point3(0, 0, 0))
tsTo = TransformState.makePos(Point3(10, 0, 0))
shape = BulletSphereShape(0.5)
penetration = 0.0
result = self.world.sweepTestClosest(shape, tsFrom, tsTo, penetration)
return result
def getCollisionShapeFromModel(model, mode='box', defaultCentered=False):
#NOTE: make sure the position is relative to the center of the object
minBounds, maxBounds = model.getTightBounds()
offset = minBounds + (maxBounds - minBounds) / 2.0
transform = TransformState.makeIdentity()
if mode == 'mesh':
# Use exact triangle mesh approximation
mesh = BulletTriangleMesh()
geomNodes = model.findAllMatches('**/+GeomNode')
for nodePath in geomNodes:
geomNode = nodePath.node()
for n in range(geomNode.getNumGeoms()):
geom = geomNode.getGeom(n)
mesh.addGeom(geom)
shape = BulletTriangleMeshShape(mesh, dynamic=False)
transform = model.getTransform()
elif mode == "sphere":
minBounds, maxBounds = model.getTightBounds()
dims = maxBounds - minBounds
radius = np.sqrt(np.square(dims[0]) + np.square(dims[1])) / 2.0
height = dims[2]
shape = BulletCapsuleShape(radius, 2 * radius)
if not defaultCentered:
transform = TransformState.makePos(offset)
elif mode == "hull":
shape = BulletConvexHullShape()
geomNodes = model.findAllMatches('**/+GeomNode')
for nodePath in geomNodes:
geomNode = nodePath.node()
for n in range(geomNode.getNumGeoms()):
geom = geomNode.getGeom(n)
shape.addGeom(geom)
elif mode == 'box':
# Bounding box approximation
minBounds, maxBounds = model.getTightBounds()
dims = maxBounds - minBounds
shape = BulletBoxShape(Vec3(dims.x / 2, dims.y / 2, dims.z / 2))
if not defaultCentered:
transform = TransformState.makePos(offset)
elif mode == 'capsule':
minBounds, maxBounds = model.getTightBounds()
dims = maxBounds - minBounds
radius = np.sqrt(np.square(dims[0]) + np.square(dims[1])) / 2.0
height = dims[2]
shape = BulletCapsuleShape(radius, height - 2 * radius)
if not defaultCentered:
transform = TransformState.makePos(offset)
else:
raise Exception(
'Unknown mode type for physic object collision shape: %s' % (mode))
return shape, transform
def doShoot(self, ccd):
if(self.fire and self.attempts > 0 and self.gameState == 'PLAY'):
self.cameraState = 'LOOK'
self.fire = False
self.candleThrow.play()
self.attempts -= 1
#get from/to points from mouse click
## pMouse = base.mouseWatcherNode.getMouse()
## pFrom = Point3()
## pTo = Point3()
## base.camLens.extrude(pMouse, pFrom, pTo)
## pFrom = render.getRelativePoint(base.cam, pFrom)
## pTo = render.getRelativePoint(base.cam, pTo)
# calculate initial velocity
v = self.pTo - self.pFrom
ratio = v.length() / 40
v.normalize()
v *= 70.0 * ratio
torqueOffset = random.random() * 10
#create bullet
shape = BulletSphereShape(0.5)
shape01 = BulletSphereShape(0.5)
shape02 = BulletSphereShape(0.5)
shape03 = BulletSphereShape(0.5)
body = BulletRigidBodyNode('Candle')
bodyNP = self.worldNP.attachNewNode(body)
bodyNP.node().addShape(shape, TransformState.makePos(Point3(0,0,0)))
bodyNP.node().addShape(shape01, TransformState.makePos(Point3(0,0.5,-0.5)))
bodyNP.node().addShape(shape02,TransformState.makePos(Point3(0,1,-1)))
bodyNP.node().addShape(shape03,TransformState.makePos(Point3(0,1.5,-1.5)))
bodyNP.node().setMass(100)
bodyNP.node().setFriction(1.0)
bodyNP.node().setLinearVelocity(v)
bodyNP.node().applyTorque(v*torqueOffset)
bodyNP.setPos(self.pFrom)
bodyNP.setCollideMask(BitMask32.allOn())
visNP = loader.loadModel('models/projectile.X')
visNP.setScale(0.7)
visNP.clearModelNodes()
visNP.reparentTo(bodyNP)
#self.bird = bodyNP.node()
if ccd:
bodyNP.node().setCcdMotionThreshold(1e-7)
bodyNP.node().setCcdSweptSphereRadius(0.5)
self.world.attachRigidBody(bodyNP.node())
#remove the bullet again after 1 sec
self.bullets = bodyNP
taskMgr.doMethodLater(5, self.removeBullet, 'removeBullet', extraArgs=[bodyNP],
appendTask = True)
def doInverseRelativeSweepTest(self, relativePoint, bitMask=None, height=0.1):
globalPoint = self.scene.Base.render.getRelativePoint(self.bodyNP, relativePoint)
fromT = TransformState.makePos(self.bodyNP.getPos(self.scene.Base.render) + VBase3(0, 0, height))
toT = TransformState.makePos(globalPoint + VBase3(0, 0, height))
if bitMask != None:
r = self.scene.world.sweepTestClosest(self.shape, toT, fromT, bitMask)
else:
r = self.scene.world.sweepTestClosest(self.shape, toT, fromT)
if r.getNode() == self.body:
return BulletClosestHitSweepResult.empty()
else:
return r
def setup(self):
self.worldNP = render.attachNewNode('World')
# World
self.debugNP = self.worldNP.attachNewNode(BulletDebugNode('Debug'))
self.debugNP.show()
self.world = BulletWorld()
self.world.setGravity(Vec3(0, 0, -9.81))
self.world.setDebugNode(self.debugNP.node())
# Plane
shape = BulletPlaneShape(Vec3(0, 0, 1), 0)
np = self.worldNP.attachNewNode(BulletRigidBodyNode('Ground'))
np.node().addShape(shape)
np.setPos(0, 0, -1)
np.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(np.node())
# Box
shape = BulletBoxShape(Vec3(0.5, 0.5, 0.5))
np = self.worldNP.attachNewNode(BulletRigidBodyNode('Box'))
np.node().setMass(1.0)
np.node().addShape(shape)
np.node().addShape(shape, TransformState.makePos(Point3(0, 1, 0)))
np.node().setDeactivationEnabled(False)
np.setPos(2, 0, 4)
np.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(np.node())
visualNP = loader.loadModel('models/box.egg')
visualNP.reparentTo(np)
self.box = np.node()
# Sphere
shape = BulletSphereShape(0.6)
np = self.worldNP.attachNewNode(BulletRigidBodyNode('Sphere'))
np.node().setMass(1.0)
np.node().addShape(shape)
np.node().addShape(shape, TransformState.makePos(Point3(0, 1, 0)))
np.setPos(-2, 0, 4)
np.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(np.node())
self.sphere = np.node()
def setup(self):
self.worldNP = render.attachNewNode('World')
# World
self.debugNP = self.worldNP.attachNewNode(BulletDebugNode('Debug'))
self.debugNP.show()
self.world = BulletWorld()
self.world.setGravity(Vec3(0, 0, -9.81))
self.world.setDebugNode(self.debugNP.node())
# Plane
shape = BulletPlaneShape(Vec3(0, 0, 1), 0)
np = self.worldNP.attachNewNode(BulletRigidBodyNode('Ground'))
np.node().addShape(shape)
np.setPos(0, 0, -1)
np.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(np.node())
# Box
shape = BulletBoxShape(Vec3(0.5, 0.5, 0.5))
np = self.worldNP.attachNewNode(BulletRigidBodyNode('Box'))
np.node().setMass(1.0)
np.node().addShape(shape)
np.node().addShape(shape, TransformState.makePos(Point3(0, 1, 0)))
np.node().setDeactivationEnabled(False)
np.setPos(2, 0, 4)
np.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(np.node())
visualNP = loader.loadModel('models/box.egg')
visualNP.reparentTo(np)
self.box = np.node()
# Sphere
shape = BulletSphereShape(0.6)
np = self.worldNP.attachNewNode(BulletRigidBodyNode('Sphere'))
np.node().setMass(1.0)
np.node().addShape(shape)
np.node().addShape(shape, TransformState.makePos(Point3(0, 1, 0)))
np.setPos(-2, 0, 4)
np.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(np.node())
self.sphere = np.node()
def testRenderWithModelLights(self):
filename = os.path.join(TEST_SUNCG_DATA_DIR, 'metadata',
'suncgModelLights.json')
info = SunCgModelLights(filename)
scene = Scene()
modelId = 's__1296'
modelFilename = os.path.join(TEST_SUNCG_DATA_DIR, "object",
str(modelId),
str(modelId) + ".egg")
assert os.path.exists(modelFilename)
model = loadModel(modelFilename)
model.setName('model-' + str(modelId))
model.show(BitMask32.allOn())
objectsNp = scene.scene.attachNewNode('objects')
objNp = objectsNp.attachNewNode('object-' + str(modelId))
model.reparentTo(objNp)
# Calculate the center of this object
minBounds, maxBounds = model.getTightBounds()
centerPos = minBounds + (maxBounds - minBounds) / 2.0
# Add offset transform to make position relative to the center
model.setTransform(TransformState.makePos(-centerPos))
# Add lights to model
for lightNp in info.getLightsForModel(modelId):
lightNp.node().setShadowCaster(True, 512, 512)
lightNp.reparentTo(model)
scene.scene.setLight(lightNp)
viewer = None
try:
viewer = Viewer(scene, interactive=False, shadowing=True)
viewer.cam.setTransform(
TransformState.makePos(LVector3f(0.5, 0.5, 3.0)))
viewer.cam.lookAt(lightNp)
for _ in range(20):
viewer.step()
time.sleep(1.0)
finally:
if viewer is not None:
viewer.destroy()
viewer.graphicsEngine.removeAllWindows()
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 __init__(self, houseId, suncgDatasetRoot=None, size=(256, 256), debug=False, depth=False, realtime=False, dt=0.1, cameraTransform=None):
self.__dict__.update(houseId=houseId, suncgDatasetRoot=suncgDatasetRoot, size=size,
debug=debug, depth=depth, realtime=realtime, dt=dt, cameraTransform=cameraTransform)
self.scene = SunCgSceneLoader.loadHouseFromJson(houseId, suncgDatasetRoot)
agentRadius = 0.1
agentHeight = 1.6
if self.cameraTransform is None:
self.cameraTransform = TransformState.makePos(LVector3f(0.0, 0.0, agentHeight/2.0 - agentRadius))
self.renderWorld = Panda3dRenderer(self.scene, size, shadowing=False, depth=depth, cameraTransform=self.cameraTransform)
self.physicWorld = Panda3dBulletPhysics(self.scene, suncgDatasetRoot, debug=debug, objectMode='box',
agentRadius=agentRadius, agentHeight=agentHeight, agentMass=60.0, agentMode='capsule')
self.clock = ClockObject.getGlobalClock()
self.worlds = {
"physics": self.physicWorld,
"render": self.renderWorld,
}
self.agent = self.scene.agents[0]
self.agentRbNp = self.agent.find('**/+BulletRigidBodyNode')
self.labeledNavMap = None
self.occupancyMapCoord = None
def setupPhysics(self, radius=None, height=None):
if not radius:
radius = self.getWidth()
if not height:
height = self.getHeight()
self.notify.debug("setupPhysics(r{0}, h{1}) hitboxData: {2}".format(
radius, height, self.hitboxData))
# When the height is passed into BulletCapsuleShape, it's
# talking about the height only of the cylinder part.
# But what we want is the height of the entire capsule.
#height -= (radius * 2)
# The middle of the capsule is the origin by default. Push the capsule shape up
# so the very bottom of the capsule is the origin.
zOfs = (height / 2.0) + radius
capsule = BulletCapsuleShape(radius, height)
bodyNode = BulletRigidBodyNode('avatarBodyNode')
bodyNode.addShape(capsule, TransformState.makePos(Point3(0, 0, zOfs)))
bodyNode.setKinematic(True)
bodyNode.setPythonTag("avatar", self)
BasePhysicsObject.setupPhysics(self, bodyNode, True)
self.stopWaterCheck()
def __set_collision_mesh(self):
fpath = self.cprops.race_props.coll_path % self.cprops.name
try:
self.coll_mesh = self.eng.load_model(fpath)
except OSError: # new cars don't have collision meshes
self.coll_mesh = self.eng.load_model(
fpath.replace('capsule', 'car'))
# chassis_shape = BulletConvexHullShape()
# for geom in self.eng.lib.find_geoms(
# self.coll_mesh, self.cprops.race_props.coll_name):
# chassis_shape.add_geom(geom.node().get_geom(0),
# geom.get_transform())
# self.mediator.gfx.nodepath.get_node().add_shape(chassis_shape)
chassis_shape = BulletBoxShape(tuple(self.cfg['box_size']))
boxpos = self.cfg['box_pos']
boxpos[2] += self.cfg['center_mass_offset']
pos = TransformState.makePos(tuple(boxpos))
self.mediator.gfx.nodepath.p3dnode.add_shape(chassis_shape, pos)
car_names = [player.car for player in self._players]
car_idx = car_names.index(self.cprops.name)
car_bit = BitMask32.bit(BitMasks.car(car_idx))
ghost_bit = BitMask32.bit(BitMasks.ghost)
track_bit = BitMask32.bit(BitMasks.track_merged)
mask = car_bit | ghost_bit | track_bit
self.mediator.gfx.nodepath.set_collide_mask(mask)
def __init__(self, world, attach, name = '', position = Vec3(0,0,0), orientation = Vec3(0,0,0),
turretPitch = 0):
#Constant Relevant Instatiation Parameters
self._tankSize = Vec3(1, 1.5, .5) # Actually a half-size
self._tankSideLength = max(self._tankSize)
friction = .3
tankMass = 800.0
# Rewrite constructor to include these?
self._maxVel = 4
self._maxRotVel = 1
self._maxThrusterAccel = 5000
self._breakForce = 1000
turretRelPos = (0, 0, 0) #Relative to tank
self._shape = BulletBoxShape(Vec3(1,1.5,.5)) #chassis
self._transformState = TransformState.makePos(Point3(0, 0, 0)) #offset
DynamicWorldObject.__init__(self, world, attach, name, position, self._shape, orientation, Vec3(0,0,0), mass = tankMass) #Initial velocity must be 0
self.__createVehicle(self._tankWorld.getPhysics())
self._collisionCounter = 0
self._taskTimer = 0
self._nodePath.node().setFriction(friction)
self._nodePath.setPos(position)
# Set up turret nodepath
# (Nodepaths are how objects are managed in Panda3d)
self.onTask = 0
# Make collide mask (What collides with what)
self._nodePath.setCollideMask(0xFFFF0000)
#self._nodePath.setCollideMask(BitMask32.allOff())
self.movementPoint = Point3(10,10,0)
def __set_ai_meshes(self):
return
# if we attach these meshes (or even only one mesh, box, sphere,
# whatever) then the collision between the goal and the vehicle doesn't
# work properly
h = .5
boxsz = self.cfg['box_size']
hs = []
hs += [
h / 2 + boxsz[2] * 2 + self.cfg['box_pos'][2] +
self.cfg['center_mass_offset']
]
hs += [
-h / 2 - boxsz[2] * 2 + self.cfg['box_pos'][2] +
self.cfg['center_mass_offset']
]
for _h in hs:
shape = BulletBoxShape((boxsz[0], boxsz[1], h))
ghost = GhostNode('Vehicle')
pos = TransformState.makePos((0, 0, _h))
ghost.node.addShape(shape, pos)
self.ai_meshes += [self.eng.attach_node(ghost.node)]
car_names = self.cprops.race_props.season_props.car_names
car_idx = car_names.index(self.cprops.name)
car_bit = BitMask32.bit(BitMasks.car(car_idx))
ghost_bit = BitMask32.bit(BitMasks.ghost)
mask = car_bit | ghost_bit
self.ai_meshes[-1].set_collide_mask(mask)
self.eng.phys_mgr.attach_ghost(ghost.node)
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 __init__(self, world, parent, params):
self.params = params
self.__world = world
self.__g = world.getGravity().z # negative value
self.__events = Events()
self.__shape_stand = BulletCapsuleShape(params['radius'], params['height'] - 2 * params['radius'], ZUp)
self.__shape_crouch = BulletCapsuleShape(params['radius'], params['crouch_height'] - 2 * params['radius'], ZUp)
self.__ghost = BulletGhostNode('Capsule for ' + params['name'])
self.__ghost.addShape(self.__shape_stand, TransformState.makePos((0, 0, params['height'] / 2)))
self.node = parent.attachNewNode(self.__ghost)
self.node.setCollideMask(BitMask32.allOn())
world.attachGhost(self.__ghost)
self.__foot_contact = self.__head_contact = None
self.velocity = Vec3()
self.__outer_motion = Vec3()
self.__motion_time_ival = 0
self.__ignore_player_motion = False
self.__outer_rotation = self.__rotation_time_ival = 0
self.__ignore_player_rotation = False
self.__falling = False
self.__crouches = False
# controls
self.__want_crouch = False
self.__want_fly = False
def raycast(self):
# Raycast for closest hit
tsFrom = TransformState.makePos(Point3(0,0,0))
tsTo = TransformState.makePos(Point3(10,0,0))
shape = BulletSphereShape(0.5)
penetration = 1.0
result = self.world.sweepTestClosest(shape, tsFrom, tsTo, penetration)
if result.hasHit():
torque = Vec3(10,0,0)
force = Vec3(0,0,100)
## for hit in result.getHits():
## hit.getNode().applyTorque(torque)
## hit.getNode().applyCentralForce(force)
result.getNode().applyTorque(torque)
result.getNode().applyCentralForce(force)
def testObjectWithViewer(self):
scene = Scene()
modelId = '83'
modelFilename = os.path.join(TEST_SUNCG_DATA_DIR, "object",
str(modelId),
str(modelId) + ".egg")
assert os.path.exists(modelFilename)
model = loadModel(modelFilename)
model.setName('model-' + str(modelId))
model.show(BitMask32.allOn())
objectsNp = scene.scene.attachNewNode('objects')
objNp = objectsNp.attachNewNode('object-' + str(modelId))
model.reparentTo(objNp)
# Calculate the center of this object
minBounds, maxBounds = model.getTightBounds()
centerPos = minBounds + (maxBounds - minBounds) / 2.0
# Add offset transform to make position relative to the center
model.setTransform(TransformState.makePos(-centerPos))
renderer = None
viewer = None
try:
renderer = Panda3dRenderer(scene, shadowing=False)
viewer = Viewer(scene, interactive=False)
viewer.disableMouse()
viewer.cam.setTransform(
TransformState.makePos(LVecBase3(5.0, 0.0, 0.0)))
viewer.cam.lookAt(model)
for _ in range(20):
viewer.step()
time.sleep(1.0)
finally:
if renderer is not None:
renderer.destroy()
if viewer is not None:
viewer.destroy()
viewer.graphicsEngine.removeAllWindows()
def setupVehicle(self, main):
scale = 0.5
# Chassis
shape = BulletBoxShape(Vec3(0.6, 1.4, 0.5))
ts = TransformState.makePos(Point3(0, 0, 0.5 * scale))
name = self.username
self.chassisNode = BulletRigidBodyNode(name)
self.chassisNode.setTag('username', str(name))
self.chassisNP = main.worldNP.attachNewNode(self.chassisNode)
self.chassisNP.setName(str(name))
self.chassisNP.node().addShape(shape, ts)
self.chassisNP.setScale(scale)
self.chassisNP.setPos(self.pos)
if self.isCurrentPlayer:
self.chassisNP.node().notifyCollisions(True)
self.chassisNP.node().setMass(800.0)
else:
self.chassisNP.node().notifyCollisions(True)
self.chassisNP.node().setMass(400.0)
self.chassisNP.node().setDeactivationEnabled(False)
main.world.attachRigidBody(self.chassisNP.node())
#np.node().setCcdSweptSphereRadius(1.0)
#np.node().setCcdMotionThreshold(1e-7)
# Vehicle
self.vehicle = BulletVehicle(main.world, self.chassisNP.node())
self.vehicle.setCoordinateSystem(ZUp)
main.world.attachVehicle(self.vehicle)
self.yugoNP = loader.loadModel('models/yugo/yugo.egg')
self.yugoNP.reparentTo(self.chassisNP)
#self.carNP = loader.loadModel('models/batmobile-chassis.egg')
#self.yugoNP.setScale(.7)
#self.carNP.reparentTo(self.chassisNP)
# Right front wheel
np = loader.loadModel('models/yugo/yugotireR.egg')
np.reparentTo(main.worldNP)
self.addWheel(Point3( 0.70 * scale, 1.05 * scale, 0.3), True, np)
# Left front wheel
np = loader.loadModel('models/yugo/yugotireL.egg')
np.reparentTo(main.worldNP)
self.addWheel(Point3(-0.70 * scale, 1.05 * scale, 0.3), True, np)
# Right rear wheel
np = loader.loadModel('models/yugo/yugotireR.egg')
np.reparentTo(main.worldNP)
self.addWheel(Point3( 0.70 * scale, -1.05 * scale, 0.3), False, np)
# Left rear wheel
np = loader.loadModel('models/yugo/yugotireL.egg')
np.reparentTo(main.worldNP)
self.addWheel(Point3(-0.70 * scale, -1.05 * scale, 0.3), False, np)
def rebuild(self, chunk, diff=Point2(0.0, 0.0)):
self.pos -= diff
self.chunk = chunk
self.chunk.bnode.addShape(
self.shape,
TransformState.makePos(Point3(self.pos.x, 0, self.pos.y)))
self.obj.reparentTo(self.chunk.np)
self.obj.setPos(self.pos.x, 0, self.pos.y)
def __init__(self,info):
# animation base setup
self.character_info_ = info
size = Vec3(info.width, AnimationActor.DEFAULT_WIDTH , info.height)
AnimatableObject.__init__(self,info.name,size,info.mass)
self.animation_root_np_.setPos(Vec3(0,0,0))
# constraints
self.left_constraint_ = None
self.right_constraint_ = None
self.selected_constraint_ = None
# removing default shapes from rigid body
shapes = self.node().getShapes()
for shape in shapes:
self.node().removeShape(shape)
# adding capsule shape
radius = 0.5*size.getX()
height = size.getZ() - 2.0*radius # height of cylindrical part only
height = height if height >= 0 else 0.0
bullet_shape = BulletCapsuleShape(radius, height, ZUp)
bullet_shape.setMargin(GameObject.DEFAULT_COLLISION_MARGIN)
self.node().addShape(bullet_shape,TransformState.makePos(Vec3(0,0,0.5*size.getZ()))) # box bottom center coincident with the origin
self.node().setMass(self.character_info_.mass)
self.node().setLinearFactor((1,1,1))
self.node().setAngularFactor((0,0,0))
self.setCollideMask(CollisionMasks.NO_COLLISION)
# setting bounding volume
min = LPoint3(-0.5*size.getX(),-0.5*size.getY(),0)
max = LPoint3(0.5*size.getX(),0.5*size.getY(),size.getZ())
self.node().setBoundsType(BoundingVolume.BT_box)
self.node().setBounds(BoundingBox(min,max))
# setting origin ghost nodes
rel_pos = Vec3(-GameObject.ORIGIN_XOFFSET,0,info.height/2)
self.left_origin_gn_ = self.attachNewNode(BulletGhostNode(self.getName() + '-left-origin'))
self.left_origin_gn_.node().addShape(BulletSphereShape(GameObject.ORIGIN_SPHERE_RADIUS),TransformState.makePosHpr(rel_pos,Vec3.zero()))
self.left_origin_gn_.node().setIntoCollideMask(CollisionMasks.ACTION_TRIGGER_0 if not self.isFacingRight() else CollisionMasks.NO_COLLISION)
rel_pos = Vec3(GameObject.ORIGIN_XOFFSET,0,info.height/2)
self.right_origin_gn_ = self.attachNewNode(BulletGhostNode(self.getName() + '-right-origin'))
self.right_origin_gn_.node().addShape(BulletSphereShape(GameObject.ORIGIN_SPHERE_RADIUS),TransformState.makePosHpr(rel_pos,Vec3.zero()))
self.right_origin_gn_.node().setIntoCollideMask(CollisionMasks.ACTION_TRIGGER_0 if self.isFacingRight() else CollisionMasks.NO_COLLISION)
# character status
self.state_data_ = CharacterStateData()
# state machine
self.sm_ = StateMachine()
# motion commander
self.motion_commander_ = MotionCommander(self)
# set id
self.setObjectID(self.getName())
def testDebugObjectWithRender(self):
scene = Scene()
modelId = '83'
modelFilename = os.path.join(TEST_SUNCG_DATA_DIR, "object",
str(modelId),
str(modelId) + ".egg")
assert os.path.exists(modelFilename)
model = loadModel(modelFilename)
model.setName('model-' + str(modelId))
model.hide()
objectsNp = scene.scene.attachNewNode('objects')
objNp = objectsNp.attachNewNode('object-' + str(modelId))
model.reparentTo(objNp)
# Calculate the center of this object
minBounds, maxBounds = model.getTightBounds()
centerPos = minBounds + (maxBounds - minBounds) / 2.0
# Add offset transform to make position relative to the center
model.setTransform(TransformState.makePos(-centerPos))
renderer = None
physics = None
viewer = None
try:
renderer = Panda3dRenderer(scene, shadowing=False)
physics = Panda3dBulletPhysics(scene, debug=True)
viewer = Viewer(scene, interactive=False)
viewer.disableMouse()
viewer.cam.setTransform(
TransformState.makePos(LVecBase3(5.0, 0.0, 0.0)))
viewer.cam.lookAt(model)
for _ in range(20):
viewer.step()
time.sleep(1.0)
finally:
self.hulkSmash(renderer, physics, viewer)
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
def addMultiSphereGhost(self,rads,centT,**kw):
inodenp = self.worldNP.attachNewNode(BulletGhostNode("Sphere"))
for radc, posc in zip(rads, centT):
shape = BulletSphereShape(radc)
inodenp.node().addShape(shape, TransformState.makePos(Point3(posc[0],posc[1],posc[2])))#
self.setRB(inodenp,**kw)
inodenp.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(inodenp.node())
return inodenp
def _create_ground(self, plane_friction):
# Plane
logging.debug("Ground plane added to physics engine")
plane_shape = panda3d.bullet.BulletPlaneShape(Vec3(0, 0, 10), 1)
self.ground_node = panda3d.bullet.BulletRigidBodyNode('Ground')
self.ground_node.addShape(plane_shape)
self.ground_node.setTransform(TransformState.makePos(Vec3(0, 0, -1)))
self.ground_node.setFriction(plane_friction)
self.world.attachRigidBody(self.ground_node)
def setupVehicle(self, bulletWorld):
# Chassis
shape = BulletBoxShape(Vec3(1, 2.2, 0.5))
ts = TransformState.makePos(Point3(0, 0, .7))
if self.isMainChar:
self.chassisNode = BulletRigidBodyNode(self.username)
else:
self.chassisNode = BulletRigidBodyNode('vehicle')
self.chassisNode.setTag("username", str(self.username))
self.chassisNP = render.attachNewNode(self.chassisNode)
self.chassisNP.node().addShape(shape, ts)
if self.isMainChar:
self.chassisNP.node().notifyCollisions(True)
else:
self.chassisNP.node().notifyCollisions(False)
self.setVehiclePos(self.pos[0], self.pos[1], self.pos[2], self.pos[3],
self.pos[4], self.pos[5])
# self.chassisNP.setPos(-5.34744, 114.773, 6)
#self.chassisNP.setPos(49.2167, 64.7968, 10)
self.chassisNP.node().setMass(800.0)
self.chassisNP.node().setDeactivationEnabled(False)
bulletWorld.attachRigidBody(self.chassisNP.node())
#np.node().setCcdSweptSphereRadius(1.0)
#np.node().setCcdMotionThreshold(1e-7)
# Vehicle
self.vehicle = BulletVehicle(bulletWorld, self.chassisNP.node())
self.vehicle.setCoordinateSystem(ZUp)
bulletWorld.attachVehicle(self.vehicle)
self.carNP = loader.loadModel('models/batmobile-chassis.egg')
#self.yugoNP.setScale(.7)
self.carNP.reparentTo(self.chassisNP)
# Right front wheel
np = loader.loadModel('models/batmobile-wheel-right.egg')
np.reparentTo(render)
self.addWheel(Point3(1, 1.1, .7), True, np)
# Left front wheel
np = loader.loadModel('models/batmobile-wheel-left.egg')
np.reparentTo(render)
self.addWheel(Point3(-1, 1.1, .7), True, np)
# Right rear wheel
np = loader.loadModel('models/batmobile-wheel-right.egg')
np.reparentTo(render)
self.addWheel(Point3(1, -2, .7), False, np)
# Left rear wheel
np = loader.loadModel('models/batmobile-wheel-left.egg')
np.reparentTo(render)
self.addWheel(Point3(-1, -2, .7), False, np)
def addMultiSphereRB(self,rads,centT,**kw):
inodenp = self.worldNP.attachNewNode(BulletRigidBodyNode("Sphere"))
inodenp.node().setMass(1.0)
for radc, posc in zip(rads, centT):
shape = BulletSphereShape(radc)#if radis the same can use the same shape for each node
inodenp.node().addShape(shape, TransformState.makePos(Point3(posc[0],posc[1],posc[2])))#
self.setRB(inodenp,**kw)
inodenp.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(inodenp.node())
return inodenp
def createHShapedRigidBody(self,name,side_length):
visual = loader.loadModel(RESOURCES_DIR + '/models/box.egg')
visual.setTexture(loader.loadTexture(RESOURCES_DIR + '/models/limba.jpg'))
bounds = visual.getTightBounds()
extents = Vec3(bounds[1] - bounds[0])
scale_factor = 1/max([extents.getX(),extents.getY(),extents.getZ()])
#visual.setScale(side_length*scale_factor,side_length*scale_factor,side_length*scale_factor)
half_side_length = 0.5 * side_length/4
box_size = Vec3(half_side_length,half_side_length,half_side_length)
rigid_body = NodePath(BulletRigidBodyNode(name))
transforms = [
TransformState.makePos(Vec3(0.5*side_length + 3*half_side_length,0,half_side_length)), # bottom
TransformState.makePos(Vec3(0.5*side_length + 3*half_side_length,0,3*half_side_length)), # center 1
TransformState.makePos(Vec3(0.5*side_length + 3*half_side_length,0,5*half_side_length)) , # center 2
TransformState.makePos(Vec3(0.5*side_length + 3*half_side_length,0,7*half_side_length)) , # top
TransformState.makePos(Vec3(0.5*side_length + -3*half_side_length,0,half_side_length)) , # bottom
TransformState.makePos(Vec3(0.5*side_length + -3*half_side_length,0,3*half_side_length)), # center 1
TransformState.makePos(Vec3(0.5*side_length + -3*half_side_length,0,5*half_side_length)), # center 2
TransformState.makePos(Vec3(0.5*side_length + -3*half_side_length,0,7*half_side_length)), # top
TransformState.makePos(Vec3(0.5*side_length + -half_side_length,0,4*half_side_length)), # left
TransformState.makePos(Vec3(0.5*side_length + half_side_length,0,4*half_side_length)) # right
]
count = 0
for t in transforms:
rigid_body.node().addShape(BulletBoxShape(box_size),t)
vnp = visual.instanceUnderNode(rigid_body,'box-visual' + str(count))
vnp.setTransform(t)
vnp.setScale(2*half_side_length*scale_factor,
2*half_side_length*scale_factor,
2*half_side_length*scale_factor)
vnp.setTexture(loader.loadTexture(RESOURCES_DIR + '/models/limba.jpg'))
count+=1
rigid_body.node().setMass(1)
rigid_body.node().setLinearFactor((1,0,1))
rigid_body.node().setAngularFactor((0,0,0))
rigid_body.node().setIntoCollideMask(BitMask32.allOn())
return rigid_body
def addRBCube(world,pos, worldNP):
shape = BulletBoxShape(Vec3(12.5, 12.5, 12.5))
inodenp = worldNP.attachNewNode(BulletRigidBodyNode("Box"))
inodenp.node().setMass(1.0)
# inodenp.node().addShape(shape)
inodenp.node().addShape(shape, TransformState.makePos(pos))
# spherenp.setPos(-2, 0, 4)
inodenp.setCollideMask(BitMask32.allOn())
world.attachRigidBody(inodenp.node())
return inodenp.node()
def addRBSphere(world,pos, worldNP):
shape = BulletSphereShape(0.6)
inodenp = worldNP.attachNewNode(BulletRigidBodyNode("Sphere"))
inodenp.node().setMass(0.0)
# inodenp.node().addShape(shape)
inodenp.node().addShape(shape, TransformState.makePos(pos))
# spherenp.setPos(-2, 0, 4)
inodenp.setCollideMask(BitMask32.allOn())
world.attachRigidBody(inodenp.node())
return inodenp.node()
def addRBSphere(world, pos, worldNP):
shape = BulletSphereShape(0.6)
inodenp = worldNP.attachNewNode(BulletRigidBodyNode("Sphere"))
inodenp.node().setMass(0.0)
# inodenp.node().addShape(shape)
inodenp.node().addShape(shape, TransformState.makePos(pos))
# spherenp.setPos(-2, 0, 4)
inodenp.setCollideMask(BitMask32.allOn())
world.attachRigidBody(inodenp.node())
return inodenp.node()
def addRBCube(world, pos, worldNP):
shape = BulletBoxShape(Vec3(12.5, 12.5, 12.5))
inodenp = worldNP.attachNewNode(BulletRigidBodyNode("Box"))
inodenp.node().setMass(1.0)
# inodenp.node().addShape(shape)
inodenp.node().addShape(shape, TransformState.makePos(pos))
# spherenp.setPos(-2, 0, 4)
inodenp.setCollideMask(BitMask32.allOn())
world.attachRigidBody(inodenp.node())
return inodenp.node()
def __init__(self, tempworld, bulletWorld, type, playerId):
self.world = tempworld
self.speed = 0
self.acceleration = 1.5
self.brakes = .7
self.min_speed = 0
self.max_speed = 150
self.reverse_speed = 20
self.reverse_limit = -40
self.armor = 100
self.health = 100
self.a_timer_start = time.time()
self.a_timer_end = time.time()
self.power_ups = [0, 0, 0]
self.playerId = playerId
if type == 0:
self.actor = Actor("models/batmobile-chassis")
self.actor.setScale(0.7)
carRadius = 3
elif type == 1:
self.actor = Actor("models/policecarpainted", {})
self.actor.setScale(0.30)
self.actor.setH(180) # elif type == 2:
# self.actor = loader.loadModel("knucklehead.egg")
# self.tex = loader.loadTexture("knucklehead.jpg")
# self.actor.setTexture(self.car_tex, 1)
shape = BulletBoxShape(Vec3(1.0, 1.5, 0.4))
ts = TransformState.makePos(Point3(0, 0, 0.6))
self.chassisNP = render.attachNewNode(BulletRigidBodyNode('Vehicle'))
self.chassisNP.node().addShape(shape, ts)
self.chassisNP.setPos(50 * random.random(), 50 * random.random(), 1)
self.chassisNP.setH(180)
self.chassisNP.node().setMass(800.0)
self.chassisNP.node().setDeactivationEnabled(False)
bulletWorld.attachRigidBody(self.chassisNP.node())
self.actor.reparentTo(self.chassisNP)
self.actor.setH(180)
# Vehicle
self.vehicle = BulletVehicle(bulletWorld, self.chassisNP.node())
self.vehicle.setCoordinateSystem(ZUp)
bulletWorld.attachVehicle(self.vehicle)
for fb, y in (("F", 1.1), ("B", -1.1)):
for side, x in (("R", 0.75), ("L", -0.75)):
np = loader.loadModel("models/tire%s.egg" % side)
np.reparentTo(render)
isFront = fb == "F"
self.addWheel(Point3(x, y, 0.55), isFront, np)
def setupVehicle(self, bulletWorld):
# Chassis
shape = BulletBoxShape(Vec3(1, 2.2, 0.5))
ts = TransformState.makePos(Point3(0, 0, .7))
if self.isMainChar:
self.chassisNode = BulletRigidBodyNode(self.username)
else:
self.chassisNode = BulletRigidBodyNode('vehicle')
self.chassisNode.setTag("username", str(self.username))
self.chassisNP = render.attachNewNode(self.chassisNode)
self.chassisNP.node().addShape(shape, ts)
if self.isMainChar:
self.chassisNP.node().notifyCollisions(True)
else:
self.chassisNP.node().notifyCollisions(False)
self.setVehiclePos(self.pos[0], self.pos[1], self.pos[2], self.pos[3], self.pos[4], self.pos[5])
# self.chassisNP.setPos(-5.34744, 114.773, 6)
#self.chassisNP.setPos(49.2167, 64.7968, 10)
self.chassisNP.node().setMass(800.0)
self.chassisNP.node().setDeactivationEnabled(False)
bulletWorld.attachRigidBody(self.chassisNP.node())
#np.node().setCcdSweptSphereRadius(1.0)
#np.node().setCcdMotionThreshold(1e-7)
# Vehicle
self.vehicle = BulletVehicle(bulletWorld, self.chassisNP.node())
self.vehicle.setCoordinateSystem(ZUp)
bulletWorld.attachVehicle(self.vehicle)
self.carNP = loader.loadModel('models/batmobile-chassis.egg')
#self.yugoNP.setScale(.7)
self.carNP.reparentTo(self.chassisNP)
# Right front wheel
np = loader.loadModel('models/batmobile-wheel-right.egg')
np.reparentTo(render)
self.addWheel(Point3(1, 1.1, .7), True, np)
# Left front wheel
np = loader.loadModel('models/batmobile-wheel-left.egg')
np.reparentTo(render)
self.addWheel(Point3(-1, 1.1, .7), True, np)
# Right rear wheel
np = loader.loadModel('models/batmobile-wheel-right.egg')
np.reparentTo(render)
self.addWheel(Point3(1, -2, .7), False, np)
# Left rear wheel
np = loader.loadModel('models/batmobile-wheel-left.egg')
np.reparentTo(render)
self.addWheel(Point3(-1, -2, .7), False, np)
def addSingleCubeRB(self,halfextents,**kw):
shape = BulletBoxShape(Vec3(halfextents[0], halfextents[1], halfextents[2]))#halfExtents
inodenp = self.worldNP.attachNewNode(BulletRigidBodyNode("Box"))
# inodenp.node().setMass(1.0)
# inodenp.node().addShape(shape)
inodenp.node().addShape(shape,TransformState.makePos(Point3(0, 0, 0)))#, pMat)#TransformState.makePos(Point3(jtrans[0],jtrans[1],jtrans[2])))#rotation ?
# spherenp.setPos(-2, 0, 4)
self.setRB(inodenp,**kw)
inodenp.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(inodenp.node())
return inodenp
def createSnowman(self, size, pos, mass):
shape = BulletBoxShape(Vec3(size,size,size))
shape01 = BulletSphereShape(size/2)
body = BulletRigidBodyNode('Snowman')
np = self.worldNP.attachNewNode(body)
np.node().setMass(mass)
np.node().addShape(shape, TransformState.makePos(Point3(0,0,-1)))
np.node().addShape(shape01, TransformState.makePos(Point3(0,0,1)))
np.node().setFriction(10.0)
np.node().setDeactivationEnabled(False)
np.setPos(pos)
np.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(np.node())
visualNP = loader.loadModel('models/snowman.X')
visualNP.setScale(size)
visualNP.clearModelNodes()
visualNP.reparentTo(np)
self.snowmans.append(np)
def setupVehicle(self, bulletWorld):
# Chassis
shape = BulletBoxShape(Vec3(1, 2.2, 0.5))
ts = TransformState.makePos(Point3(0, 0, .7))
self.chassisNode = BulletRigidBodyNode('Vehicle')
self.chassisNP = render.attachNewNode(self.chassisNode)
self.chassisNP.node().addShape(shape, ts)
self.chassisNP.node().notifyCollisions(True)
self.chassisNP.setPosHpr(self.pos[0], self.pos[1], self.pos[2], self.pos[3], self.pos[4], self.pos[5])
# self.chassisNP.setPos(-5.34744, 114.773, 6)
# self.chassisNP.setPos(49.2167, 64.7968, 10)
self.chassisNP.node().setMass(800.0)
self.chassisNP.node().setDeactivationEnabled(False)
bulletWorld.attachRigidBody(self.chassisNP.node())
# np.node().setCcdSweptSphereRadius(1.0)
# np.node().setCcdMotionThreshold(1e-7)
# Vehicle
self.vehicle = BulletVehicle(bulletWorld, self.chassisNP.node())
self.vehicle.setCoordinateSystem(ZUp)
bulletWorld.attachVehicle(self.vehicle)
self.carNP = loader.loadModel('models/swiftstar-chassis')
tex = loader.loadTexture("models/tex/Futuristic_Car_C.jpg")
self.carNP.setTexture(tex)
self.carNP.setScale(1, 1, .9)
self.carNP.setCollideMask(BitMask32.allOn())
self.carNP.reparentTo(self.chassisNP)
# Right front wheel
np = loader.loadModel('models/swiftstar-fr-tire')
np.setCollideMask(BitMask32.allOff())
np.reparentTo(render)
self.addWheel(Point3(1, 1.1, 1), True, np)
# Left front wheel
np = loader.loadModel('models/swiftstar-fl-tire')
np.setCollideMask(BitMask32.allOff())
np.reparentTo(render)
self.addWheel(Point3(-1, 1.1, 1), True, np)
# Right rear wheel
np = loader.loadModel('models/swiftstar-rr-tire')
np.setCollideMask(BitMask32.allOff())
np.reparentTo(render)
self.addWheel(Point3(1.2, -2, .8), False, np)
# Left rear wheel
np = loader.loadModel('models/swiftstar-rl-tire')
np.setCollideMask(BitMask32.allOff())
np.reparentTo(render)
self.addWheel(Point3(-1.2, -2, .8), False, np)
def __init__(self, posx, posy, posz, color, worldNP, world):
# Chassis
shape = BulletBoxShape(Vec3(0.45, 0.98, 0.25))
ts = TransformState.makePos(Point3(0, 0, 0.06))
np = worldNP.attachNewNode(BulletRigidBodyNode('Vehicle'))
np.node().addShape(shape, ts)
np.setPos(posx, posy, posz)
np.node().setMass(700.0)
np.node().setDeactivationEnabled(False)
world.attachRigidBody(np.node())
# np.node().setCcdSweptSphereRadius(1.0)
# np.node().setCcdMotionThreshold(1e-7)
# Vehicle
super(Vehicle, self).__init__(world, np.node())
self.setCoordinateSystem(ZUp)
world.attachVehicle(self)
if (color == "B"):
yugoNP = loader.loadModel('../Models/ChassisB.egg')
elif (color == "G"):
yugoNP = loader.loadModel('../Models/ChassisG.egg')
else:
yugoNP = loader.loadModel('../Models/ChassisR.egg')
yugoNP.reparentTo(np)
# Right front wheel
np = loader.loadModel('../Models/wheel.egg')
np.reparentTo(worldNP)
self.addWheel(Point3(0.60, 0.95, 0.3), True, np)
# Left front wheel
np = loader.loadModel('../Models/wheel.egg')
np.reparentTo(worldNP)
self.addWheel(Point3(-0.60, 0.95, 0.3), True, np)
# Right rear wheel
np = loader.loadModel('../Models/wheel.egg')
np.reparentTo(worldNP)
self.addWheel(Point3(0.60, -0.95, 0.3), False, np)
# Left rear wheel
np = loader.loadModel('../Models/wheel.egg')
np.reparentTo(worldNP)
self.addWheel(Point3(-0.60, -0.95, 0.3), False, np)
# Steering info
self.steering = 0.0 # degree
self.steeringClamp = 45.0 # degree
self.steeringIncrement = 120.0 # degree per second
def __init__(self, main):
# Chassis
shape = BulletBoxShape(Vec3(0.6, 1.4, 0.5))
ts = TransformState.makePos(Point3(0, 0, 0.5))
self.chassisNode = BulletRigidBodyNode('Obstruction')
self.chassisNP = main.worldNP.attachNewNode(self.chassisNode)
self.chassisNP.setName("Obstruction")
self.chassisNP.node().addShape(shape, ts)
self.chassisNP.node().notifyCollisions(True)
self.chassisNP.setPos(0, 5, 1)
self.chassisNP.node().setMass(8000.0)
self.chassisNP.node().setDeactivationEnabled(False)
main.world.attachRigidBody(self.chassisNP.node())
def setChassis(game,position,velocity):
shape = BulletBoxShape(Vec3(0.6, 1.4, 0.5))
ts = TransformState.makePos(Point3(0, 0, 0.5))
np = game.worldNP.attachNewNode(BulletRigidBodyNode('Vehicle'))
np.node().addShape(shape, ts)
np.setPos(position)
np.node().setLinearVelocity(Vec3(0,velocity,0))
np.node().setMass(1000.0)
np.node().setDeactivationEnabled(False)
game.world.attachRigidBody(np.node())
return np
def setChassis(game, position, velocity):
shape = BulletBoxShape(Vec3(0.6, 1.4, 0.5))
ts = TransformState.makePos(Point3(0, 0, 0.5))
np = game.worldNP.attachNewNode(BulletRigidBodyNode('Vehicle'))
np.node().addShape(shape, ts)
np.setPos(position)
np.node().setLinearVelocity(Vec3(0, velocity, 0))
np.node().setMass(1000.0)
np.node().setDeactivationEnabled(False)
game.world.attachRigidBody(np.node())
return np
def __init__(self,
name,
radius,
collideEvent=None,
mask=CIGlobals.WorldGroup,
offset=Point3(0),
needSelfInArgs=False,
startNow=True,
myMask=CIGlobals.EventGroup,
exclusions=[],
resultInArgs=False,
useSweep=False,
world=None,
initNp=True,
useGhost=True):
if self.WantNPInit:
NodePath.__init__(self)
if useGhost:
node = BulletGhostNode(name)
else:
node = BulletRigidBodyNode(name)
self.assign(NodePath(node))
self.needSelfInArgs = needSelfInArgs
self.resultInArgs = resultInArgs
self.event = collideEvent
self.mask = mask
self.__exclusions = []
self.useSweep = useSweep
if not world and hasattr(base, 'physicsWorld') and not self.IsAI:
world = base.physicsWorld
self.world = world
self.initialPos = Point3(0)
self.lastPos = Point3(0)
self.lastPosTime = 0.0
self.hitCallbacks = []
sphere = BulletSphereShape(radius)
self.node().addShape(sphere, TransformState.makePos(offset))
self.node().setKinematic(True)
if useSweep:
self.node().setCcdMotionThreshold(1e-7)
self.node().setCcdSweptSphereRadius(radius * 1.05)
self.setCollideMask(myMask)
if startNow:
self.start()
def __init__(self, scene, agentId, agentRadius=0.25):
self.scene = scene
self.agentId = agentId
agentsNp = self.scene.scene.find('**/agents')
agentNp = agentsNp.attachNewNode(agentId)
agentNp.setTag('agent-id', agentId)
scene.agents.append(agentNp)
# Define a simple sphere model
modelId = 'sphere-0'
modelFilename = os.path.join(CDIR, 'sphere.egg')
agentNp.setTag('model-id', modelId)
model = loadModel(modelFilename)
model.setColor(
LVector4f(np.random.uniform(), np.random.uniform(),
np.random.uniform(), 1.0))
model.setName('model-' + os.path.basename(modelFilename))
model.setTransform(TransformState.makeScale(agentRadius))
model.reparentTo(agentNp)
model.hide(BitMask32.allOn())
# Calculate the center of this object
minBounds, maxBounds = model.getTightBounds()
centerPos = minBounds + (maxBounds - minBounds) / 2.0
# Add offset transform to make position relative to the center
agentNp.setTransform(TransformState.makePos(centerPos))
model.setTransform(model.getTransform().compose(
TransformState.makePos(-centerPos)))
self.agentNp = agentNp
self.model = model
self.agentRbNp = None
self.rotationStepCounter = -1
self.rotationsStepDuration = 40
def addSingleSphereRB(self,rad,**kw):
shape = BulletSphereShape(rad)
name = "sphere"
if "name" in kw :
name = kw["name"]
inodenp = self.worldNP.attachNewNode(BulletRigidBodyNode(name))
inodenp.node().setMass(1.0)
# inodenp.node().addShape(shape)
inodenp.node().addShape(shape,TransformState.makePos(Point3(0, 0, 0)))#rotation ?
# spherenp.setPos(-2, 0, 4)
self.setRB(inodenp,**kw)
inodenp.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(inodenp.node())
return inodenp
def doSweepTest(cls, _engine, _player, _wallMask, _extras):
print "####> doSweepTest()\n"
#mpoint = _node.getManifoldPoint()
playerPos = _player.bulletBody.getPos()
tsFrom = TransformState.makePos(Point3(playerPos + (0, 0.2, _player.height + 5.0)))
tsTo = TransformState.makePos(Point3(playerPos + (0, 0.2, 0)))
#print "THIS IS THE PLAYER Z:", playerPos.getZ()
rad = 1.5
height = 4.0
mask = BitMask32(0x8) #_wallMask
#shape = BulletCylinderShape(rad, height, ZUp)
penetration = 0.0
shape = BulletSphereShape(rad)
result = _engine.bulletWorld.sweepTestClosest(shape, tsFrom, tsTo, mask, penetration)
#print "Sweep Node: ", result.getNode()
#print "Sweep HitPos: ", result.getHitPos()
#print "Sweep Normal: ", result.getHitNormal()
#print "Sweep Fraction: ", result.getHitFraction()
hitPos = result.getHitPos()
hitNode = result.getNode()
hitNormal = result.getHitNormal()
hitFraction = result.getHitFraction()
# Create a node to attach to
# if flying then be able to right click to attach/grab
avoidList = ["player_ghost", "Capsule"]
#print "THIS IS THE FKING HIT NODE!!! : ", hitNode.getName()
if hitNode.getName() not in avoidList:
return hitPos, hitNode, hitNormal, hitFraction
else:
return None
def __init__(self, positionHpr, render, world, base):
self.base = base
loader = base.loader
position, hpr = positionHpr
vehicleType = "yugo"
self.vehicleDir = "data/vehicles/" + vehicleType + "/"
# Load vehicle description and specs
with open(self.vehicleDir + "vehicle.json") as vehicleData:
data = json.load(vehicleData)
self.specs = data["specs"]
# Chassis for collisions and mass uses a simple box shape
halfExtents = (0.5 * dim for dim in self.specs["dimensions"])
shape = BulletBoxShape(Vec3(*halfExtents))
ts = TransformState.makePos(Point3(0, 0, 0.5))
self.rigidNode = BulletRigidBodyNode("vehicle")
self.rigidNode.addShape(shape, ts)
self.rigidNode.setMass(self.specs["mass"])
self.rigidNode.setDeactivationEnabled(False)
self.np = render.attachNewNode(self.rigidNode)
self.np.setPos(position)
self.np.setHpr(hpr)
world.attachRigidBody(self.rigidNode)
# Vehicle physics model
self.vehicle = BulletVehicle(world, self.rigidNode)
self.vehicle.setCoordinateSystem(ZUp)
world.attachVehicle(self.vehicle)
# Vehicle graphical model
self.vehicleNP = loader.loadModel(self.vehicleDir + "car.egg")
self.vehicleNP.reparentTo(self.np)
# Create wheels
wheelPos = self.specs["wheelPositions"]
for fb, y in (("F", wheelPos[1]), ("B", -wheelPos[1])):
for side, x in (("R", wheelPos[0]), ("L", -wheelPos[0])):
np = loader.loadModel(self.vehicleDir + "tire%s.egg" % side)
np.reparentTo(render)
isFront = fb == "F"
self.addWheel(Point3(x, y, wheelPos[2]), isFront, np)
def setupPhysics(self):
TestApplication.setupPhysics(self)
# resources
visual = loader.loadModel(RESOURCES_DIR + '/models/box.egg')
visual.setTexture(loader.loadTexture(RESOURCES_DIR + '/models/limba.jpg'))
bounds = visual.getTightBounds()
extents = Vec3(bounds[1] - bounds[0])
scale_factor = 1/max([extents.getX(),extents.getY(),extents.getZ()])
logging.debug("Box visual scale factor %f"%(scale_factor))
# create box rigid body
box_rigid_body = self.world_node_.attachNewNode(BulletRigidBodyNode("Box"))
#box_rigid_body = NodePath(BulletRigidBodyNode("Box"))
box_rigid_body.node().addShape(BulletBoxShape(Vec3(0.5 * BOX_SIDE_LENGTH,0.5 * BOX_SIDE_LENGTH,0.5 * BOX_SIDE_LENGTH)),
TransformState.makePos(Vec3(0,0,0.5 * BOX_SIDE_LENGTH)))
box_rigid_body.node().setMass(1)
box_rigid_body.node().setLinearFactor((1,0,1))
box_rigid_body.node().setAngularFactor((0,0,0))
box_rigid_body.setCollideMask(BitMask32.allOff())
vnp = visual.instanceTo(box_rigid_body)
vnp.setPos(Vec3(0,0,0.5*BOX_SIDE_LENGTH))
vnp.setScale(BOX_SIDE_LENGTH*scale_factor,BOX_SIDE_LENGTH*scale_factor,BOX_SIDE_LENGTH*scale_factor)
box_rigid_body.setPos(Vec3(1.5,0,2))
# create h_shaped rigid body
h_shaped_body = self.createHShapedRigidBody("HBody", 1.5*BOX_SIDE_LENGTH)
h_shaped_body.reparentTo(self.world_node_)
h_shaped_body.setPos(box_rigid_body,Vec3(0,0,0))
h_shaped_body.setH(box_rigid_body,180)
# create constraints
self.right_constraint_, self.left_constraint_ = self.createConstraints(box_rigid_body.node(),h_shaped_body.node())
self.active_constraint_ = self.left_constraint_
self.active_constraint_.setEnabled(True)
self.parent_rigid_body_ = box_rigid_body
self.child_rigid_body_ = h_shaped_body
self.physics_world_.attach(box_rigid_body.node())
self.physics_world_.attach(h_shaped_body.node())
self.physics_world_.attach(self.active_constraint_)
self.object_nodes_.append(box_rigid_body)
self.object_nodes_.append(h_shaped_body)
def __init__(self, tankWorld, attach, name = '', position = Point3(0,0,0), shape = BulletBoxShape(Vec3(.1, .1, .1)), orientation = Vec3(0,0,0), velocity = Vec3(0,0,0), mass = 0.1):
#@param world: A BulletWorld for this to be simulated in
#@param attach: a NodePath to attach this WorldObject to. By default send some ShowBase.render
self._nodePath = attach.attachNewNode(BulletRigidBodyNode(name)) #Bullet node for rendering and physics - this is what this class manipulates
self._tankWorld = tankWorld
self._nodePath.node().setMass(mass) #Only static objects should have 0 mass
#The NodePath holds rendering state variables
self._nodePath.setPos(position[0], position[1], position[2])
self._nodePath.setHpr(orientation[0], orientation[1], orientation[2])
#Bullet's Node holds other physics-based state variables
self._nodePath.node().setLinearVelocity(velocity)
self._transformState = getattr(self, '_transformState',TransformState.makePos(Point3(0, 0, 0)))
self._nodePath.node().addShape(shape,self._transformState)
self._tankWorld.attachRigidBody(self._nodePath.node())
def setupCheckpoint(self, main, pos, h):
# Chassis
shape = BulletBoxShape(Vec3(1, 5, 1))
ts = TransformState.makePos(Point3(0, 0, 0))
self.cpnode = BulletGhostNode('CheckPoint')
self.cpnode = render.attachNewNode(self.cpnode)
self.cpnode.node().addShape(shape, ts)
self.cpnode.setCollideMask(BitMask32(0x0f))
# self.cpnode.node().notifyCollisions(True)
self.cpnode.setPos(pos.x, pos.y, pos.z)
self.cpnode.setH(h)
main.bulletWorld.attachGhost(self.cpnode.node())
def update(self, dt):
self.t += dt
trans = TransformState.makePos((self.t, -self.t, 0))
self.model.setTexTransform(self._texStage, trans)
trans = TransformState.makePos((self.t * 2.0, -self.t * 2.0, 0))
def setup(self):
self.worldNP = render.attachNewNode('World')
# World
self.debugNP = self.worldNP.attachNewNode(BulletDebugNode('Debug'))
self.debugNP.show()
self.world = BulletWorld()
self.world.setGravity(Vec3(0, 0, -9.81))
self.world.setDebugNode(self.debugNP.node())
# Plane
shape = BulletPlaneShape(Vec3(0, 0, 1), 0)
np = self.worldNP.attachNewNode(BulletRigidBodyNode('Ground'))
np.node().addShape(shape)
np.setPos(0, 0, -1)
np.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(np.node())
# Chassis
shape = BulletBoxShape(Vec3(0.6, 1.4, 0.5))
ts = TransformState.makePos(Point3(0, 0, 0.5))
np = self.worldNP.attachNewNode(BulletRigidBodyNode('Vehicle'))
np.node().addShape(shape, ts)
np.setPos(0, 0, 1)
np.node().setMass(800.0)
np.node().setDeactivationEnabled(False)
self.world.attachRigidBody(np.node())
#np.node().setCcdSweptSphereRadius(1.0)
#np.node().setCcdMotionThreshold(1e-7)
# Vehicle
self.vehicle = BulletVehicle(self.world, np.node())
self.vehicle.setCoordinateSystem(ZUp)
self.world.attachVehicle(self.vehicle)
self.yugoNP = loader.loadModel('models/yugo/yugo.egg')
self.yugoNP.reparentTo(np)
# Right front wheel
np = loader.loadModel('models/yugo/yugotireR.egg')
np.reparentTo(self.worldNP)
self.addWheel(Point3( 0.70, 1.05, 0.3), True, np)
# Left front wheel
np = loader.loadModel('models/yugo/yugotireL.egg')
np.reparentTo(self.worldNP)
self.addWheel(Point3(-0.70, 1.05, 0.3), True, np)
# Right rear wheel
np = loader.loadModel('models/yugo/yugotireR.egg')
np.reparentTo(self.worldNP)
self.addWheel(Point3( 0.70, -1.05, 0.3), False, np)
# Left rear wheel
np = loader.loadModel('models/yugo/yugotireL.egg')
np.reparentTo(self.worldNP)
self.addWheel(Point3(-0.70, -1.05, 0.3), False, np)
# Steering info
self.steering = 0.0 # degree
self.steeringClamp = 45.0 # degree
self.steeringIncrement = 120.0 # degree per second
def setup(self):
# Steering info
self.steering = 0.0 # degree
self.steeringClamp = 30.0 # degree
self.steeringIncrement = 80.0 # degree per second
self.worldNP = render.attachNewNode('World')
# World
self.debugNP = self.worldNP.attachNewNode(BulletDebugNode('Debug'))
#self.debugNP.show()
self.world = BulletWorld()
self.world.setGravity(Vec3(0, 0, -9.81))
self.world.setDebugNode(self.debugNP.node())
if(self.gameLevel == 1):
#set score
print('GameLevel')
self.score = 1000
self.distanceTravelled = 0
self.time = 0
# Plane
img = PNMImage(Filename('media/terrain/SIMP_Assignment_2_Terrain_1.png'))
shape = BulletHeightfieldShape(img, 50.0, ZUp)
np = self.worldNP.attachNewNode(BulletRigidBodyNode('Ground'))
np.node().addShape(shape)
np.setPos(0, 0, 0)
np.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(np.node())
#skybox
skybox = loader.loadModel('media/models/skybox/skybox_01.X')
skybox.reparentTo(render)
# Chassis
shape = BulletBoxShape(Vec3(0.6, 1.4, 0.5))
ts = TransformState.makePos(Point3(0, 0, 1.0))
self.vehicleNP = self.worldNP.attachNewNode(BulletRigidBodyNode('Vehicle'))
self.vehicleNP.node().addShape(shape, ts)
self.vehicleNP.setPos(-93, -88, -7)#-93, -88, -7) #(-82,65.8,-8) #(55,8.38,-6)#(45, -19, -8)#(-93, -88, -7)
self.vehicleNP.setHpr(-90,0,0)
self.vehicleNP.node().setMass(5.0)
self.vehicleNP.node().setDeactivationEnabled(False)
base.cam.setPos(self.vehicleNP.getPos().getX()+2,self.vehicleNP.getPos().getY()+2,self.vehicleNP.getPos().getZ()+2)
self.world.attachRigidBody(self.vehicleNP.node())
# Vehicle
self.vehicle = BulletVehicle(self.world, self.vehicleNP.node())
self.vehicle.setCoordinateSystem(ZUp)
self.world.attachVehicle(self.vehicle)
self.hummerNP = loader.loadModel('media/models/vehicle/body.X')
self.hummerNP.reparentTo(self.vehicleNP)
# Right front wheel
np = loader.loadModel('media/models/vehicle/front_right.X')
np.reparentTo(self.worldNP)
self.addWheel(Point3( 0.8, 0.9, 0.8), True, np)
# Left front wheel
np = loader.loadModel('media/models/vehicle/front_left.X')
np.reparentTo(self.worldNP)
self.addWheel(Point3(-0.8, 0.9, 0.8), True, np)
# Right rear wheel
np = loader.loadModel('media/models/vehicle/back_right.X')
np.reparentTo(self.worldNP)
self.addWheel(Point3( 0.8, -0.7, 0.8), False, np)
# Left rear wheel
np = loader.loadModel('media/models/vehicle/back_left.X')
np.reparentTo(self.worldNP)
self.addWheel(Point3(-0.8, -0.7, 0.8), False, np)
#Obstacles
self.setupObstacleOne(Vec3(50, -5, -4), 1.8, Vec3(60, 0, 0))
self.setupObstacleFour(Vec3(63.3, 59.2, -10), 1.5, Vec3(0,0,0))
self.setupObstacleFour(Vec3(41, 57, -10), 1.5, Vec3(0,0,0))
self.setupObstacleFour(Vec3(7.5, 53.8, -10), 1.5, Vec3(0,0,0))
self.setupObstacleFour(Vec3(-28, 81.4, -10), 1.5, Vec3(0,0,0))
self.setupObstacleSix(Vec3(-91, 81 , -6), 1, Vec3(60,0,0))
#Goal
self.setupGoal(Vec3(-101,90.6,-6.5))
#self.vehicleNP.setPos(Vec3(6,52,-6))
self.setupTerrain()
elif(self.gameLevel == 2):
self.distanceTravelled = 0
self.time = 0
# Plane
img = PNMImage(Filename('media/terrain/SIMP_Assignment_2_Terrain_2.png'))
shape = BulletHeightfieldShape(img, 50.0, ZUp)
np = self.worldNP.attachNewNode(BulletRigidBodyNode('Ground'))
np.node().addShape(shape)
np.setPos(0, 0, 0)
np.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(np.node())
#skybox
skybox = loader.loadModel('media/models/skybox/skybox_01.X')
skybox.reparentTo(render)
# Chassis
shape = BulletBoxShape(Vec3(0.6, 1.4, 0.5))
ts = TransformState.makePos(Point3(0, 0, 1.0))
self.vehicleNP = self.worldNP.attachNewNode(BulletRigidBodyNode('Vehicle'))
self.vehicleNP.node().addShape(shape, ts)
self.vehicleNP.setPos(-99.6,105,-11.8)#(88, 21, -11)#(34.3,8.4,-11.8)#(-99.6,105,-11.8)#(86.4,41.2,-12)
self.vehicleNP.setHpr(-130,0,0)
self.vehicleNP.node().setMass(5.0)
self.vehicleNP.node().setDeactivationEnabled(False)
base.cam.setPos(self.vehicleNP.getPos().getX()+2,self.vehicleNP.getPos().getY()+2,self.vehicleNP.getPos().getZ()+2)
self.world.attachRigidBody(self.vehicleNP.node())
# Vehicle
self.vehicle = BulletVehicle(self.world, self.vehicleNP.node())
self.vehicle.setCoordinateSystem(ZUp)
self.world.attachVehicle(self.vehicle)
self.hummerNP = loader.loadModel('media/models/vehicle/body.X')
self.hummerNP.reparentTo(self.vehicleNP)
# Right front wheel
np = loader.loadModel('media/models/vehicle/front_right.X')
np.reparentTo(self.worldNP)
self.addWheel(Point3( 0.8, 0.9, 0.8), True, np)
# Left front wheel
np = loader.loadModel('media/models/vehicle/front_left.X')
np.reparentTo(self.worldNP)
self.addWheel(Point3(-0.8, 0.9, 0.8), True, np)
# Right rear wheel
np = loader.loadModel('media/models/vehicle/back_right.X')
np.reparentTo(self.worldNP)
self.addWheel(Point3( 0.8, -0.7, 0.8), False, np)
# Left rear wheel
np = loader.loadModel('media/models/vehicle/back_left.X')
np.reparentTo(self.worldNP)
self.addWheel(Point3(-0.8, -0.7, 0.8), False, np)
self.setupObstacleFive(Vec3(91, 3, -9),1,Vec3(90,0,0))
self.setupObstacleFive(Vec3(94,-19, -10),0.9,Vec3(90,0,0))
self.setupObstacleFive(Vec3(85,-40, -10),1,Vec3(90,0,0))
self.setupObstacleFour(Vec3(-33.5, 23.4,-14.5),1,Vec3(0,0,0))
self.setupObstacleFour(Vec3(-43.3, 24.2,-14.5),1,Vec3(0,0,0))
self.setupObstacleTwo(Vec3(34.7,20.9,-8.5),1,Vec3(90,0,0))
self.setupObstacleTwo(Vec3(26.8,20.3,-8.5),1,Vec3(90,0,0))
self.setupObstacleTwo(Vec3(42.1,22.5,-8.5),1,Vec3(90,0,0))
#self.setupObstacleFive(Vec3(91,0.2, -8),2.1,Vec3(90,0,0))
#Goal
self.setupGoal(Vec3(94,-89.7,-10))
self.setupTerrain()
elif(self.gameLevel == 3):
self.distanceTravelled = 0
self.time = 0
# Plane
img = PNMImage(Filename('media/terrain/SIMP_Assignment_2_Terrain_3.png'))
shape = BulletHeightfieldShape(img, 50.0, ZUp)
np = self.worldNP.attachNewNode(BulletRigidBodyNode('Ground'))
np.node().addShape(shape)
np.setPos(0, 0, 0)
np.setCollideMask(BitMask32.allOn())
self.world.attachRigidBody(np.node())
#skybox
skybox = loader.loadModel('media/models/skybox/skybox_01.X')
skybox.reparentTo(render)
# Chassis
shape = BulletBoxShape(Vec3(0.6, 1.4, 0.5))
ts = TransformState.makePos(Point3(0, 0, 1.0))
self.vehicleNP = self.worldNP.attachNewNode(BulletRigidBodyNode('Vehicle'))
self.vehicleNP.node().addShape(shape, ts)
self.vehicleNP.setPos(-110, -110, 0)
self.vehicleNP.setHpr(-40,0,0)
self.vehicleNP.node().setMass(5.0)
self.vehicleNP.node().setDeactivationEnabled(False)
base.cam.setPos(self.vehicleNP.getPos().getX()+2,self.vehicleNP.getPos().getY()+2,self.vehicleNP.getPos().getZ()+2)
self.world.attachRigidBody(self.vehicleNP.node())
# Vehicle
self.vehicle = BulletVehicle(self.world, self.vehicleNP.node())
self.vehicle.setCoordinateSystem(ZUp)
self.world.attachVehicle(self.vehicle)
self.hummerNP = loader.loadModel('media/models/vehicle/body.X')
self.hummerNP.reparentTo(self.vehicleNP)
# Right front wheel
np = loader.loadModel('media/models/vehicle/front_right.X')
np.reparentTo(self.worldNP)
self.addWheel(Point3( 0.8, 0.9, 0.8), True, np)
# Left front wheel
np = loader.loadModel('media/models/vehicle/front_left.X')
np.reparentTo(self.worldNP)
self.addWheel(Point3(-0.8, 0.9, 0.8), True, np)
# Right rear wheel
np = loader.loadModel('media/models/vehicle/back_right.X')
np.reparentTo(self.worldNP)
self.addWheel(Point3( 0.8, -0.7, 0.8), False, np)
# Left rear wheel
np = loader.loadModel('media/models/vehicle/back_left.X')
np.reparentTo(self.worldNP)
self.addWheel(Point3(-0.8, -0.7, 0.8), False, np)
self.setupTerrain()
#Goal
self.setupGoal(Vec3(114,100,-13))
#Obstacles
self.setupObstacleFour(Vec3(-60, -73, -9), 1, Vec3(0, 0, 0))
self.setupObstacleFour(Vec3(-63, -77, -9), 1, Vec3(0, 0, 0))
self.setupObstacleTwo(Vec3(-15, -40, -3), 1, Vec3(0, 0, 0))
self.setupObstacleFour(Vec3(-60, 12, -11), 1, Vec3(0, 0, 0))
self.setupObstacleSix(Vec3(-15, 90, -6), 1.5, Vec3(-30, 0, 0))
self.setupObstacleFour(Vec3(28, 87, -11), 1, Vec3(0, 0, 0))
self.setupObstacleFour(Vec3(32, 90, -11), 1, Vec3(0, 0, 0))
def rebuild(self, chunk, diff=Point2(0.0, 0.0)):
self.pos -= diff
self.chunk = chunk
self.chunk.bnode.addShape(self.shape, TransformState.makePos(Point3(self.pos.x, 0, self.pos.y)))
self.obj.reparentTo(self.chunk.np)
self.obj.setPos(self.pos.x, 0, self.pos.y)
