class MyApp(ShowBase):
def __init__(self):
ShowBase.__init__(self)
dlight = DirectionalLight('dlight')
dlight.setColor(VBase4(0.8, 0.8, 0.5, 1))
dlnp = self.render.attachNewNode(dlight)
dlnp.setHpr(0, -60, 0)
self.render.setLight(dlnp)
self.balls = [Ball(self) for x in range(NUMBALLS)]
# Setup our physics world and the body
self.world = OdeWorld()
self.world.setGravity(0, 0, -9.81)
if 0:
self.body = OdeBody(self.world)
M = OdeMass()
M.setSphere(7874, 1.0)
self.body.setMass(M)
self.body.setPosition(self.sphere.getPos(self.render))
self.body.setQuaternion(self.sphere.getQuat(self.render))
## Set the camera position
self.disableMouse()
self.angle = 0.0
self.camera.setPos(1000, 1000, 1000)
self.camera.lookAt(0, 0, 0)
#self.enableMouse()
# Create an accumulator to track the time since the sim
# has been running
self.deltaTimeAccumulator = 0.0
# This stepSize makes the simulation run at 60 frames per second
self.stepSize = 1.0 / 60.0
taskMgr.doMethodLater(1.0, self.simulationTask, "Physics Simulation")
def simulationTask(self, task):
if 0:
# Add the deltaTime for the task to the accumulator
self.deltaTimeAccumulator += globalClock.getDt()
while self.deltaTimeAccumulator > self.stepSize:
# Remove a stepSize from the accumulator until
# the accumulated time is less than the stepsize
self.deltaTimeAccumulator -= self.stepSize
# Step the simulation
self.world.quickStep(self.stepSize)
for ball in self.balls:
ball.evolve()
deltas = [ball.getdelta(self.balls) for ball in self.balls]
for i, ball in enumerate(self.balls):
dx, dy, dz = deltas[i]
ball.move(dx, dy, dz)
ball.update()
#print "moved"
self.camera.setPos(CX + 2500 * math.sin(self.angle),
CY + 2500 * math.cos(self.angle), CZ)
self.camera.lookAt(CX, CY, CZ)
self.angle += 0.01
return task.cont
class MyApp(ShowBase):
def __init__(self):
ShowBase.__init__(self)
dlight = DirectionalLight("dlight")
dlight.setColor(VBase4(0.8, 0.8, 0.5, 1))
dlnp = self.render.attachNewNode(dlight)
dlnp.setHpr(0, -60, 0)
self.render.setLight(dlnp)
self.balls = [Ball(self) for x in range(NUMBALLS)]
# Setup our physics world and the body
self.world = OdeWorld()
self.world.setGravity(0, 0, -9.81)
if 0:
self.body = OdeBody(self.world)
M = OdeMass()
M.setSphere(7874, 1.0)
self.body.setMass(M)
self.body.setPosition(self.sphere.getPos(self.render))
self.body.setQuaternion(self.sphere.getQuat(self.render))
## Set the camera position
self.disableMouse()
self.angle = 0.0
self.camera.setPos(1000, 1000, 1000)
self.camera.lookAt(0, 0, 0)
# self.enableMouse()
# Create an accumulator to track the time since the sim
# has been running
self.deltaTimeAccumulator = 0.0
# This stepSize makes the simulation run at 60 frames per second
self.stepSize = 1.0 / 60.0
taskMgr.doMethodLater(1.0, self.simulationTask, "Physics Simulation")
def simulationTask(self, task):
if 0:
# Add the deltaTime for the task to the accumulator
self.deltaTimeAccumulator += globalClock.getDt()
while self.deltaTimeAccumulator > self.stepSize:
# Remove a stepSize from the accumulator until
# the accumulated time is less than the stepsize
self.deltaTimeAccumulator -= self.stepSize
# Step the simulation
self.world.quickStep(self.stepSize)
for ball in self.balls:
ball.evolve()
deltas = [ball.getdelta(self.balls) for ball in self.balls]
for i, ball in enumerate(self.balls):
dx, dy, dz = deltas[i]
ball.move(dx, dy, dz)
ball.update()
# print "moved"
self.camera.setPos(CX + 2500 * math.sin(self.angle), CY + 2500 * math.cos(self.angle), CZ)
self.camera.lookAt(CX, CY, CZ)
self.angle += 0.01
return task.cont
# Add a random amount of boxes boxes = [] # Setup the geometry boxNP = box.copyTo(render) boxNP.setPos(randint(-10, 10), randint(-10, 10), 10 + random()) boxNP.setColor(random(), random(), random(), 1) boxNP.setHpr(0, 45, 0) # Create the body and set the mass boxBody = OdeBody(world) M = OdeMass() M.setBox(20, 1, 1, 1) boxBody.setMass(M) boxBody.setPosition(boxNP.getPos(render)) boxBody.setQuaternion(boxNP.getQuat(render)) # Create a BoxGeom boxGeom = OdeBoxGeom(space, 4, 4, 1) boxGeom.setCollideBits(BitMask32(0x00000002)) boxGeom.setCategoryBits(BitMask32(0x00000001)) boxGeom.setBody(boxBody) boxes.append((boxNP, boxBody)) boxNP2 = box.copyTo(render) boxNP2.reparentTo(boxNP) boxNP2.setPos(0.5, 0.5, 0) boxNP2.setScale(0.1, 0.1, 4) boxBody2 = OdeBody(world) M2 = OdeMass()
class Physical(Touchable):
"""
The Physical class is the base class for anything that responds to physics
"""
def __init__(self, world, mass, geom, model, loc = Point3(), rot = True):
super(Physical, self).__init__(world, geom, model, loc)
self.toRevert['rot'] = self.setRot
self.toSave['rot'] = self.getRot
self.toRevert['vel'] = self.setVel
self.toSave['vel'] = self.getVel
self.toRevert['angVel'] = self.setAngVel
self.toSave['angVel'] = self.getAngVel
self.setRevertable(True)
self.body = OdeBody(world.world)
self.mass = mass
self.body.setMass(self.mass)
self.body.setPosition(self.model.getPos())
self.body.setQuaternion(self.model.getQuat())
self.geom.setBody(self.body)
self.rot = rot
def constrainQuat(self):
"""keep the object rotating in the correct plane"""
#FIXME is there a better way than fixing at every instant?
if not self.rot:
self.body.setQuaternion(Quat.identQuat())
return
q = self.body.getQuaternion()
q[1] = 0
q[2] = 0
q.normalize()
self.body.setQuaternion(Quat(q))
def getPos(self):
return self.body.getPosition()
def setPos(self, pos):
return self.body.setPosition(pos)
def setRot(self, rot):
self.body.setQuaternion(Quat(rot))
def getRot(self):
return self.body.getQuaternion()
def setVel(self, vel):
self.body.setLinearVel(vel)
def getVel(self):
return self.body.getLinearVel()
def setAngVel(self, angVel):
self.body.setAngularVel(angVel)
def getAngVel(self):
return self.body.getAngularVel()
# Add a random amount of boxes
boxes = []
for i in range(randint(5, 10)):
# Setup the geometry
boxNP = box.copyTo(render)
# boxNP.setPos(randint(-10, 10), randint(-10, 10), 10 + random())
boxNP.setPos(random() * 10, random() * 10, 10 + random())
boxNP.setColor(random(), random(), random(), 1)
boxNP.setHpr(randint(-45, 45), randint(-45, 45), randint(-45, 45))
# Create the body and set the mass
boxBody = OdeBody(world)
M = OdeMass()
M.setBox(5, 1, 1, 1)
boxBody.setMass(M)
boxBody.setPosition(boxNP.getPos(render))
boxBody.setQuaternion(boxNP.getQuat(render))
# Create a BoxGeom
boxGeom = OdeBoxGeom(space, 1, 1, 1)
# boxGeom = OdeTriMeshGeom(space, OdeTriMeshData(boxNP, True))
boxGeom.setCollideBits(BitMask32(0x00000002))
boxGeom.setCategoryBits(BitMask32(0x00000001))
boxGeom.setBody(boxBody)
boxes.append((boxNP, boxBody))
# Add a plane to collide with
cm = CardMaker("ground")
cm.setFrame(-20, 20, -20, 20)
ground = render.attachNewNode(cm.generate())
ground.setPos(0, 0, 0)
ground.lookAt(0, 0, -1)
groundGeom = OdePlaneGeom(space, Vec4(0, 0, 1, 0))
# Load the smiley model which will act as our iron ball
sphere = loader.loadModel("smiley.egg")
sphere.reparentTo(render)
sphere.setPos(10, 1, 21)
sphere.setColor(0.7, 0.4, 0.4)
# Setup our physics world and the body
world = OdeWorld()
world.setGravity(0, 0, -9.81)
body = OdeBody(world)
M = OdeMass()
M.setSphere(7874, 1.0)
body.setMass(M)
body.setPosition(sphere.getPos())
body.setQuaternion(sphere.getQuat())
# Set the camera position
base.disableMouse()
base.camera.setPos(80, -20, 40)
base.camera.lookAt(0, 0, 10)
# Create an accumulator to track the time since the sim
# has been running
deltaTimeAccumulator = 0.0
# This stepSize makes the simulation run at 90 frames per second
stepSize = 1.0 / 90.0
# The task for our simulation
def simulationTask(task):
global deltaTimeAccumulator
new_box.set_pos(
np.array([random() * 10 - 5,
random() * 10 - 5, 1 + random()]))
new_box.set_rgba([random(), random(), random(), 1])
new_box.set_rotmat(
rm.rotmat_from_euler(random() * math.pi / 4,
random() * math.pi / 4,
random() * math.pi / 4))
new_box.attach_to(base)
# Create the body and set the mass
boxBody = OdeBody(world)
M = OdeMass()
M.setBox(3, .3, .3, .3)
boxBody.setMass(M)
boxBody.setPosition(da.npv3_to_pdv3(new_box.get_pos()))
boxBody.setQuaternion(da.npmat3_to_pdquat(new_box.get_rotmat()))
# Create a BoxGeom
boxGeom = OdeBoxGeom(space, .3, .3, .3)
# boxGeom = OdeTriMeshGeom(space, OdeTriMeshData(new_box.objpdnp, True))
boxGeom.setCollideBits(BitMask32(0x00000002))
boxGeom.setCategoryBits(BitMask32(0x00000001))
boxGeom.setBody(boxBody)
boxes.append((new_box, boxBody))
# Add a plane to collide with
ground = cm.gen_box(extent=[20, 20, 1], rgba=[.3, .3, .3, 1])
ground.set_pos(np.array([0, 0, -1.5]))
ground.attach_to(base)
# groundGeom = OdeTriMeshGeom(space, OdeTriMeshData(ground.objpdnp, True))
groundGeom = OdePlaneGeom(space, Vec4(0, 0, 1, -1))
groundGeom.setCollideBits(BitMask32(0x00000001))