def test_euler(self):
self.q = bullet.btQuaternion(0, 0, 0)
q1 = bullet.btQuaternion()
q1.set_euler(0, 0, 0)
self.assertEqual(self.q, q1)
q1.set_euler_zyx(0, 0, 0)
self.assertEqual(self.q, q1)
def test_set_rotation(self):
self.q = bullet.btQuaternion(bullet.btVector3(0, 0, -1),
bullet.btRadians(90))
q1 = bullet.btQuaternion()
q1.set_rotation(bullet.btVector3(0, 0, -1),
bullet.btRadians(90))
self.assertEqual(self.q, q1)
def test_mul(self):
self.q = bullet.btQuaternion(0, 0, 0, 1)
self.q *= 10.0
self.assertEqual(self.q, bullet.btQuaternion(0, 0, 0, 10.0))
self.q *= bullet.btQuaternion(0, 0, 0, 0.5)
self.assertEqual(self.q, bullet.btQuaternion(0, 0, 0, 5.0))
q1 = self.q * 2.0
self.assertEqual(q1, bullet.btQuaternion(0, 0, 0, 10))
def test_normalize(self):
self.q = bullet.btQuaternion(0, 10, 20, 0)
q1 = self.q.normalize()
self.assertEqual(q1.length, q1.length2)
self.assertAlmostEqual(self.q.length, 1)
self.q = bullet.btQuaternion(0, 10, 20, 0)
q1 = self.q.normalized()
self.assertAlmostEqual(q1.length, 1.0)
def test_slerp(self):
self.q = bullet.btQuaternion(bullet.btVector3(0, 0, -1),
bullet.btRadians(90))
q1 = bullet.btQuaternion(bullet.btVector3(0, 0, -1), 0)
q2 = self.q.slerp(q1, 0.5)
expected = bullet.btQuaternion(bullet.btVector3(0, 0, -1),
bullet.btRadians(45))
self.assertAlmostEqual(q2.angle(expected), 0)
def test_sub(self):
self.q = bullet.btQuaternion(0, 0, 0, 1)
q1 = bullet.btQuaternion(0, 0, 0, 1)
self.q -= q1
self.assertEqual(self.q, bullet.btQuaternion(0, 0, 0, 0))
self.q = bullet.btQuaternion(0, 0, 0, 2)
q1 = bullet.btQuaternion(0, 0, 0, 1)
q2 = self.q - q1
self.assertEqual(q2, q1)
def test_angle(self):
self.q = bullet.btQuaternion(bullet.btVector3(0, 0, -1),
bullet.btRadians(90))
q1 = bullet.btQuaternion(bullet.btVector3(0, 0, -1),
bullet.btRadians(0))
angle = self.q.angle(q1)
expected = bullet.btRadians(45)
self.assertAlmostEqual(angle, expected)
angle = self.q.angle_shortest_path(q1)
expected = bullet.btRadians(90)
self.assertAlmostEqual(angle, expected)
angle = self.q.get_angle()
self.assertAlmostEqual(angle, bullet.btRadians(90))
angle = self.q.get_angle_shortest_path()
self.assertAlmostEqual(angle, bullet.btRadians(270))
def shootBox(self, destination):
if not self.m_dynamicsWorld:
return
print 'shootBox'
mass = 1.0
startTransform = bullet.btTransform()
startTransform.setIdentity()
camPos = self.getCameraPosition()
startTransform.setOrigin(camPos)
self.setShootBoxShape()
body = self.localCreateRigidBody(mass, startTransform,
self.m_shootBoxShape)
body.setLinearFactor((1, 1, 1))
linVel = vector3.normalize(
(destination[0] - camPos[0], destination[1] - camPos[1],
destination[2] - camPos[2]))
linVel = vector3.mul(linVel, self.m_ShootBoxInitialSpeed)
body.getWorldTransform().setOrigin(camPos)
body.getWorldTransform().setRotation(bullet.btQuaternion(0, 0, 0, 1))
body.setLinearVelocity(linVel)
body.setAngularVelocity((0, 0, 0))
body.setCcdMotionThreshold(0.5)
body.setCcdSweptSphereRadius(0.9)
def shootBox(self, destination):
if not self.m_dynamicsWorld:
return
print 'shootBox'
mass = 1.0;
startTransform=bullet.btTransform();
startTransform.setIdentity();
camPos = self.getCameraPosition();
startTransform.setOrigin(camPos);
self.setShootBoxShape ();
body = self.localCreateRigidBody(mass, startTransform, self.m_shootBoxShape);
body.setLinearFactor((1,1,1));
linVel= vector3.normalize(
(destination[0]-camPos[0],destination[1]-camPos[1],destination[2]-camPos[2]));
linVel=vector3.mul(linVel, self.m_ShootBoxInitialSpeed);
body.getWorldTransform().setOrigin(camPos);
body.getWorldTransform().setRotation(bullet.btQuaternion(0,0,0,1));
body.setLinearVelocity(linVel);
body.setAngularVelocity((0,0,0));
body.setCcdMotionThreshold(0.5);
body.setCcdSweptSphereRadius(0.9);
def test_rotation(self):
self.a = bullet.btTransform(self.q)
self.assertEqual(self.a.get_rotation(), self.q)
self.q = bullet.btQuaternion(0, 1, 1, 0)
self.assertNotEqual(self.q, self.a.get_rotation())
self.a.set_rotation(self.q)
print(self.q.normalized(), self.a.get_rotation())
# Hack to bypass numeric imprecision
# TODO: Extend test case to implement assertAlmostEqual with matrices
self.assertTrue(str(self.q.normalized()) == str(self.a.get_rotation()))
def updateCamera(self):
rele = self.m_ele * 0.01745329251994329547
# rads per deg
razi = self.m_azi * 0.01745329251994329547
# rads per deg
rot = bullet.btQuaternion(self.m_cameraUp, razi)
eyePos = [0, 0, 0]
eyePos[self.m_forwardAxis] = -self.m_cameraDistance
eyePos = tuple(eyePos)
forward = (eyePos[0], eyePos[1], eyePos[2])
if (vector3.length2(forward) < bullet.SIMD_EPSILON):
forward = (1.0, 0.0, 0.0)
right = vector3.cross(self.m_cameraUp, forward)
roll = bullet.btQuaternion(right, -rele)
m = bullet.btMatrix3x3(rot) * bullet.btMatrix3x3(roll)
eyePos = m.apply(eyePos)
self.m_cameraPosition = vector3.add(eyePos,
self.m_cameraTargetPosition)
if (self.m_glutScreenWidth == 0 and self.m_glutScreenHeight == 0):
return
aspect = float(self.m_glutScreenWidth) / float(self.m_glutScreenHeight)
assert (aspect != 0.0)
extents = (aspect * 1.0, 1.0, 0.0)
if (self.m_ortho):
# reset matrix
extents *= self.m_cameraDistance
lower = self.m_cameraTargetPosition - extents
upper = self.m_cameraTargetPosition + extents
else:
pass
def test_identit(self):
self.a = bullet.btTransform.identity
self.b = bullet.btTransform(bullet.btQuaternion(1, 0, 0, 0),
bullet.btVector3(0, 1, 0))
self.assertEqual(self.a.get_rotation(), bullet.btQuaternion.identity)
self.assertEqual(self.a.get_origin(), self.vec)
print(self.b.get_origin(), self.vec)
self.assertFalse(self.b.get_origin() == self.vec)
self.b.set_identity()
self.assertEqual(self.a, self.b)
self.assertEqual(bullet.btTransform.identity, self.a)
def test_calculate_diff_axis_angle(self):
self.v1 = bullet.btVector3(0, 0, -1)
self.q1 = bullet.btQuaternion(self.v1,
bullet.btRadians(90))
self.t2.set_rotation(self.q1)
angle = bullet.btTransformUtil.calculate_diff_axis_angle(
self.t1, self.t2,
self.v2 # out val
)
self.assertEqual(angle, bullet.btRadians(90))
self.assertEqual(self.v1, self.v2)
def test_calculate_diff_axis_angle(self):
self.v1 = bullet.btVector3(0, 0, -1)
self.q1 = bullet.btQuaternion(self.v1, bullet.btRadians(90))
self.t2.set_rotation(self.q1)
angle = bullet.btTransformUtil.calculate_diff_axis_angle(
self.t1,
self.t2,
self.v2 # out val
)
self.assertEqual(angle, bullet.btRadians(90))
self.assertEqual(self.v1, self.v2)
def updateCamera(self):
rele = self.m_ele * 0.01745329251994329547;# rads per deg
razi = self.m_azi * 0.01745329251994329547;# rads per deg
rot=bullet.btQuaternion(self.m_cameraUp, razi);
eyePos=[0, 0, 0];
eyePos[self.m_forwardAxis] = -self.m_cameraDistance;
eyePos=tuple(eyePos)
forward=(eyePos[0], eyePos[1], eyePos[2]);
if (vector3.length2(forward) < bullet.SIMD_EPSILON):
forward=(1.0, 0.0, 0.0);
right = vector3.cross(self.m_cameraUp, forward);
roll=bullet.btQuaternion(right,-rele);
m=bullet.btMatrix3x3(rot) * bullet.btMatrix3x3(roll)
eyePos =m.apply(eyePos);
self.m_cameraPosition=vector3.add(eyePos, self.m_cameraTargetPosition);
if (self.m_glutScreenWidth == 0 and self.m_glutScreenHeight == 0):
return;
aspect = float(self.m_glutScreenWidth) / float(self.m_glutScreenHeight);
assert(aspect!=0.0)
extents=(aspect * 1.0, 1.0, 0.0);
if (self.m_ortho):
# reset matrix
extents *= self.m_cameraDistance;
lower = self.m_cameraTargetPosition - extents;
upper = self.m_cameraTargetPosition + extents;
else:
pass
def test_add(self):
self.q = bullet.btQuaternion(0, 0, 0, 1)
q1 = bullet.btQuaternion(0, 0, 0, 1)
self.q += q1
self.assertEqual(self.q, bullet.btQuaternion(0, 0, 0, 2))
self.q = bullet.btQuaternion(0, 0, 0, 1)
q1 = bullet.btQuaternion(0, 0, 0, 1)
q2 = self.q + q1
self.assertEqual(q2, bullet.btQuaternion(0, 0, 0, 2))
def test_dot(self):
self.q = bullet.btQuaternion(0, 0, 20, 0)
self.assertEqual(self.q.dot(bullet.btQuaternion(0, 0, 10, 0)),
200.0)
collisionConfiguration = bullet.btDefaultCollisionConfiguration();
dispatcher = bullet.btCollisionDispatcher(collisionConfiguration);
solver = bullet.btSequentialImpulseConstraintSolver();
dynamicsWorld = bullet.btDiscreteDynamicsWorld(
dispatcher, broadphase, solver, collisionConfiguration);
dynamicsWorld.setGravity((0,-10,0));
groundShape = bullet.btStaticPlaneShape((0,1,0), 1);
fallShape = bullet.btSphereShape(1);
groundMotionState = bullet.btDefaultMotionState(
bullet.btTransform(
bullet.btQuaternion(0,0,0,1),
(0,-1,0)
)
);
groundRigidBodyCI=bullet.btRigidBodyConstructionInfo(0,
groundMotionState, groundShape, (0,0,0));
groundRigidBody = bullet.btRigidBody(groundRigidBodyCI);
dynamicsWorld.addRigidBody(groundRigidBody);
fallMotionState = bullet.btDefaultMotionState(
bullet.btTransform(
bullet.btQuaternion(0,0,0,1),
(0,50,0)
)
);
def test_repr(self):
self.q = bullet.btQuaternion(0, 0, 0)
s = repr(self.q)
self.assertEqual(s, "(0, 0, 0, 1)")
def test_ctors(self):
self.q = bullet.btQuaternion(0, 0, 0, 1)
self.q = bullet.btQuaternion(bullet.btVector3(0, 0, -1),
bullet.btRadians(90))
self.q = bullet.btQuaternion(0, 0, 0)
def test_length(self):
self.q = bullet.btQuaternion(0, 0, 2, 0)
self.assertEqual(self.q.length, 2)
self.assertEqual(self.q.length2, 4)
def test_mult(self):
self.a = bullet.btTransform(self.q)
self.b = bullet.btTransform(bullet.btQuaternion(1, 1, 0, 0))
self.c = bullet.btTransform(self.q)
self.c.mult(self.a, self.b)
self.assertFalse(self.c == self.a)
def test_nearest_farthest(self):
self.q = bullet.btQuaternion(0, 0, 0, 1)
q1 = bullet.btQuaternion(0, 0, 0, 2)
nearest = self.q.nearest(q1)
farthest = self.q.farthest(q1)
def test_identity(self):
self.q = bullet.btQuaternion(0, 0, 0, 1)
self.assertEqual(self.q, bullet.btQuaternion.get_identity())
self.assertEqual(self.q, bullet.btQuaternion.identity)
def test_axis(self):
self.q = bullet.btQuaternion(bullet.btVector3(0, 0, -1),
bullet.btRadians(90))
axis = self.q.get_axis()
self.assertEqual(self.q.get_axis(), bullet.btVector3(0, 0, -1))
def test_inverse(self):
self.q = bullet.btQuaternion(bullet.btVector3(0, 0, 1),
bullet.btRadians(90))
q1 = bullet.btQuaternion(bullet.btVector3(0, 0, -1),
bullet.btRadians(90))
self.assertEqual(self.q, q1.inverse())
def test_neg(self):
self.q = bullet.btQuaternion(0, 0, 0, 1)
self.q -= bullet.btQuaternion(0, 0, 0, 2)
self.assertEqual(self.q, -bullet.btQuaternion(0, 0, 0, 1))
def setUp(self):
self.q = bullet.btQuaternion()
def test_div(self):
self.q = bullet.btQuaternion(0, 0, 0, 1)
self.q /= 0.5
self.assertEqual(self.q, bullet.btQuaternion(0, 0, 0, 2))
q1 = self.q / 0.5
self.assertEqual(q1, bullet.btQuaternion(0, 0, 0, 4))
collisionConfiguration = bullet.btDefaultCollisionConfiguration()
dispatcher = bullet.btCollisionDispatcher(collisionConfiguration)
solver = bullet.btSequentialImpulseConstraintSolver()
dynamicsWorld = bullet.btDiscreteDynamicsWorld(dispatcher, broadphase,
solver,
collisionConfiguration)
dynamicsWorld.setGravity((0, -10, 0))
groundShape = bullet.btStaticPlaneShape((0, 1, 0), 1)
fallShape = bullet.btSphereShape(1)
groundMotionState = bullet.btDefaultMotionState(
bullet.btTransform(bullet.btQuaternion(0, 0, 0, 1), (0, -1, 0)))
groundRigidBodyCI = bullet.btRigidBodyConstructionInfo(
0, groundMotionState, groundShape, (0, 0, 0))
groundRigidBody = bullet.btRigidBody(groundRigidBodyCI)
dynamicsWorld.addRigidBody(groundRigidBody)
fallMotionState = bullet.btDefaultMotionState(
bullet.btTransform(bullet.btQuaternion(0, 0, 0, 1), (0, 50, 0)))
mass = 1
fallInertia = (0, 0, 0)
fallShape.calculateLocalInertia(mass, fallInertia)
fallRigidBodyCI = bullet.btRigidBodyConstructionInfo(
mass, fallMotionState, fallShape, fallInertia)
fallRigidBody = bullet.btRigidBody(fallRigidBodyCI)
