public BSConstraintHinge(BulletWorld world, BulletBody obj1, BulletBody obj2,
Vector3 pivotInA, Vector3 pivotInB,
Vector3 axisInA, Vector3 axisInB,
bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies)
: base(world)
{
m_body1 = obj1;
m_body2 = obj2;
m_constraint = PhysicsScene.PE.CreateHingeConstraint(world, obj1, obj2,
pivotInA, pivotInB, axisInA, axisInB,
useLinearReferenceFrameA, disableCollisionsBetweenLinkedBodies);
m_enabled = true;
}
// Create a btGeneric6DofConstraint
public BSConstraint6Dof(BulletWorld world, BulletBody obj1, BulletBody obj2,
Vector3 frame1, Quaternion frame1rot,
Vector3 frame2, Quaternion frame2rot,
bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies)
: base(world)
{
m_body1 = obj1;
m_body2 = obj2;
m_constraint = PhysicsScene.PE.Create6DofConstraint(m_world, m_body1, m_body2,
frame1, frame1rot,
frame2, frame2rot,
useLinearReferenceFrameA, disableCollisionsBetweenLinkedBodies);
m_enabled = true;
world.physicsScene.DetailLog("{0},BS6DofConstraint,createFrame,wID={1}, rID={2}, rBody={3}, cID={4}, cBody={5}",
BSScene.DetailLogZero, world.worldID,
obj1.ID, obj1.AddrString, obj2.ID, obj2.AddrString);
}
// 6 Dof constraint based on a midpoint between the two constrained bodies
public BSConstraint6Dof(BulletWorld world, BulletBody obj1, BulletBody obj2,
Vector3 joinPoint,
bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies)
: base(world)
{
m_body1 = obj1;
m_body2 = obj2;
if (!obj1.HasPhysicalBody || !obj2.HasPhysicalBody)
{
world.physicsScene.DetailLog(
"{0},BS6DOFConstraint,badBodyPtr,wID={1}, rID={2}, rBody={3}, cID={4}, cBody={5}",
BSScene.DetailLogZero, world.worldID,
obj1.ID, obj1.AddrString, obj2.ID, obj2.AddrString);
world.physicsScene.Logger.ErrorFormat(
"{0} Attempt to build 6DOF constraint with missing bodies: wID={1}, rID={2}, rBody={3}, cID={4}, cBody={5}",
LogHeader, world.worldID, obj1.ID, obj1.AddrString, obj2.ID, obj2.AddrString);
m_enabled = false;
}
else
{
m_constraint = PhysicsScene.PE.Create6DofConstraintToPoint(m_world, m_body1, m_body2,
joinPoint,
useLinearReferenceFrameA, disableCollisionsBetweenLinkedBodies);
PhysicsScene.DetailLog(
"{0},BS6DofConstraint,createMidPoint,wID={1}, csrt={2}, rID={3}, rBody={4}, cID={5}, cBody={6}",
BSScene.DetailLogZero, world.worldID, m_constraint.AddrString,
obj1.ID, obj1.AddrString, obj2.ID, obj2.AddrString);
if (!m_constraint.HasPhysicalConstraint)
{
world.physicsScene.Logger.ErrorFormat(
"{0} Failed creation of 6Dof constraint. rootID={1}, childID={2}",
LogHeader, obj1.ID, obj2.ID);
m_enabled = false;
}
else
{
m_enabled = true;
}
}
}
public override bool UpdateParameter(BulletWorld world, uint localID, String parm, float value)
{
/* TODO */
return false;
}
//PhysicsScene.World.ptr, false
public override BulletShape CreateCompoundShape(BulletWorld pWorld, bool enableDynamicAabbTree)
{
return new BulletShapeXNA(new CompoundShape(enableDynamicAabbTree), BSPhysicsShapeType.SHAPE_COMPOUND);
}
public override void DestroyObject(BulletWorld pWorld, BulletBody pBody)
{
DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
CollisionObject co = (pBody as BulletBodyXNA).rigidBody;
RigidBody bo = co as RigidBody;
if (bo == null)
{
if (world.IsInWorld(co))
{
world.RemoveCollisionObject(co);
}
}
else
{
if (world.IsInWorld(bo))
{
world.RemoveRigidBody(bo);
}
}
if (co != null)
{
if (co.GetUserPointer() != null)
{
uint localId = (uint)co.GetUserPointer();
if (specialCollisionObjects.ContainsKey(localId))
{
specialCollisionObjects.Remove(localId);
}
}
}
}
// A 6 Dof constraint that is fixed in the world and constrained to a on-the-fly created static object
public BSConstraint6Dof(BulletWorld world, BulletBody obj1, Vector3 frameInBloc, Quaternion frameInBrot,
bool useLinearReferenceFrameB, bool disableCollisionsBetweenLinkedBodies)
: base(world)
{
m_body1 = obj1;
m_body2 = obj1; // Look out for confusion down the road
m_constraint = PhysicsScene.PE.Create6DofConstraintFixed(m_world, m_body1,
frameInBloc, frameInBrot,
useLinearReferenceFrameB, disableCollisionsBetweenLinkedBodies);
m_enabled = true;
world.physicsScene.DetailLog("{0},BS6DofConstraint,createFixed,wID={1},rID={2},rBody={3}",
BSScene.DetailLogZero, world.worldID, obj1.ID, obj1.AddrString);
}
public override BulletConstraint CreatePoint2PointConstraint(BulletWorld pWorld, BulletBody pBody1,
BulletBody pBody2,
Vector3 ppivotInA, Vector3 ppivotInB,
bool pdisableCollisionsBetweenLinkedBodies)
{
Point2PointConstraint constrain = null;
DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
RigidBody rb1 = (pBody1 as BulletBodyXNA).rigidBody;
RigidBody rb2 = (pBody2 as BulletBodyXNA).rigidBody;
if (rb1 != null && rb2 != null)
{
IndexedVector3 pivotInA = new IndexedVector3(ppivotInA.X, ppivotInA.Y, ppivotInA.Z);
IndexedVector3 pivotInB = new IndexedVector3(ppivotInB.X, ppivotInB.Y, ppivotInB.Z);
constrain = new Point2PointConstraint(rb1, rb2, ref pivotInA, ref pivotInB);
world.AddConstraint(constrain, pdisableCollisionsBetweenLinkedBodies);
}
return new BulletConstraintXNA(constrain);
}
public override bool DeleteCollisionShape(BulletWorld pWorld, BulletShape pShape)
{
//TODO:
return false;
}
private int PhysicsStepint(BulletWorld pWorld, float timeStep, int m_maxSubSteps, float m_fixedTimeStep,
out int updatedEntityCount,
out EntityProperties[] updatedEntities, out int collidersCount, out CollisionDesc[] colliders,
int maxCollisions, int maxUpdates)
{
int numSimSteps = 0;
Array.Clear(UpdatedObjects, 0, UpdatedObjects.Length);
Array.Clear(UpdatedCollisions, 0, UpdatedCollisions.Length);
LastEntityProperty = 0;
LastCollisionDesc = 0;
updatedEntityCount = 0;
collidersCount = 0;
if (pWorld is BulletWorldXNA)
{
DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
world.LastCollisionDesc = 0;
world.LastEntityProperty = 0;
numSimSteps = world.StepSimulation(timeStep, m_maxSubSteps, m_fixedTimeStep);
PersistentManifold contactManifold;
CollisionObject objA;
CollisionObject objB;
ManifoldPoint manifoldPoint;
PairCachingGhostObject pairCachingGhostObject;
m_collisionsThisFrame = 0;
int numManifolds = world.GetDispatcher().GetNumManifolds();
for (int j = 0; j < numManifolds; j++)
{
contactManifold = world.GetDispatcher().GetManifoldByIndexInternal(j);
int numContacts = contactManifold.GetNumContacts();
if (numContacts == 0)
continue;
objA = contactManifold.GetBody0() as CollisionObject;
objB = contactManifold.GetBody1() as CollisionObject;
manifoldPoint = contactManifold.GetContactPoint(0);
//IndexedVector3 contactPoint = manifoldPoint.GetPositionWorldOnB();
// IndexedVector3 contactNormal = -manifoldPoint.m_normalWorldOnB; // make relative to A
RecordCollision(this, objA, objB, manifoldPoint.GetPositionWorldOnB(),
-manifoldPoint.m_normalWorldOnB, manifoldPoint.GetDistance());
m_collisionsThisFrame++;
if (m_collisionsThisFrame >= 9999999)
break;
}
foreach (GhostObject ghostObject in specialCollisionObjects.Values)
{
pairCachingGhostObject = ghostObject as PairCachingGhostObject;
if (pairCachingGhostObject != null)
{
RecordGhostCollisions(pairCachingGhostObject);
}
}
updatedEntityCount = LastEntityProperty;
updatedEntities = UpdatedObjects;
collidersCount = LastCollisionDesc;
colliders = UpdatedCollisions;
}
else
{
//if (updatedEntities is null)
//updatedEntities = new List<BulletXNA.EntityProperties>();
//updatedEntityCount = 0;
//collidersCount = 0;
updatedEntities = new EntityProperties[0];
colliders = new CollisionDesc[0];
}
return numSimSteps;
}
public override BulletShape CreateHullShape(BulletWorld pWorld, int pHullCount, float[] pConvHulls)
{
DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
CompoundShape compoundshape = new CompoundShape(false);
compoundshape.SetMargin(world.WorldSettings.Params.collisionMargin);
int ii = 1;
for (int i = 0; i < pHullCount; i++)
{
int vertexCount = (int)pConvHulls[ii];
IndexedVector3 centroid = new IndexedVector3(pConvHulls[ii + 1], pConvHulls[ii + 2], pConvHulls[ii + 3]);
IndexedMatrix childTrans = IndexedMatrix.Identity;
childTrans._origin = centroid;
List<IndexedVector3> virts = new List<IndexedVector3>();
int ender = ((ii + 4) + (vertexCount * 3));
for (int iii = ii + 4; iii < ender; iii += 3)
{
virts.Add(new IndexedVector3(pConvHulls[iii], pConvHulls[iii + 1], pConvHulls[iii + 2]));
}
ConvexHullShape convexShape = new ConvexHullShape(virts, vertexCount);
convexShape.SetMargin(world.WorldSettings.Params.collisionMargin);
compoundshape.AddChildShape(ref childTrans, convexShape);
ii += (vertexCount * 3 + 4);
}
return new BulletShapeXNA(compoundshape, BSPhysicsShapeType.SHAPE_HULL);
}
public override bool AddObjectToWorld(BulletWorld pWorld, BulletBody pBody)
{
DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
CollisionObject cbody = (pBody as BulletBodyXNA).body;
RigidBody rbody = cbody as RigidBody;
// Bullet resets several variables when an object is added to the world. In particular,
// BulletXNA resets position and rotation. Gravity is also reset depending on the static/dynamic
// type. Of course, the collision flags in the broadphase proxy are initialized to default.
IndexedMatrix origPos = cbody.GetWorldTransform();
if (rbody != null)
{
IndexedVector3 origGrav = rbody.GetGravity();
world.AddRigidBody(rbody);
rbody.SetGravity(origGrav);
}
else
{
world.AddCollisionObject(cbody);
}
cbody.SetWorldTransform(origPos);
pBody.ApplyCollisionMask(pWorld.physicsScene);
//if (body.GetBroadphaseHandle() != null)
// world.UpdateSingleAabb(body);
return true;
}
private int PhysicsStep2(BulletWorld pWorld, float timeStep, int m_maxSubSteps, float m_fixedTimeStep,
out int updatedEntityCount, out EntityProperties[] updatedEntities,
out int collidersCount, out CollisionDesc[] colliders)
{
int epic = PhysicsStepint(pWorld, timeStep, m_maxSubSteps, m_fixedTimeStep, out updatedEntityCount,
out updatedEntities,
out collidersCount, out colliders, m_maxCollisions, m_maxUpdatesPerFrame);
return epic;
}
public override bool AddConstraintToWorld(BulletWorld pWorld, BulletConstraint pConstraint,
bool pDisableCollisionsBetweenLinkedObjects)
{
DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
TypedConstraint constraint = (pConstraint as BulletConstraintXNA).constrain;
world.AddConstraint(constraint, pDisableCollisionsBetweenLinkedObjects);
return true;
}
private static EntityProperties GetDebugProperties(BulletWorld pWorld, BulletBody pCollisionObject)
{
EntityProperties ent = new EntityProperties();
// 20131224 not used DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
CollisionObject collisionObject = (pCollisionObject as BulletBodyXNA).rigidBody;
IndexedMatrix transform = collisionObject.GetWorldTransform();
IndexedVector3 LinearVelocity = collisionObject.GetInterpolationLinearVelocity();
IndexedVector3 AngularVelocity = collisionObject.GetInterpolationAngularVelocity();
IndexedQuaternion rotation = transform.GetRotation();
ent.Acceleration = Vector3.Zero;
ent.ID = (uint)collisionObject.GetUserPointer();
ent.Position = new Vector3(transform._origin.X, transform._origin.Y, transform._origin.Z);
ent.Rotation = new Quaternion(rotation.X, rotation.Y, rotation.Z, rotation.W);
ent.Velocity = new Vector3(LinearVelocity.X, LinearVelocity.Y, LinearVelocity.Z);
ent.RotationalVelocity = new Vector3(AngularVelocity.X, AngularVelocity.Y, AngularVelocity.Z);
return ent;
}
public override void UpdateSingleAabb(BulletWorld pWorld, BulletBody pCollisionObject)
{
DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
CollisionObject collisionObject = (pCollisionObject as BulletBodyXNA).body;
world.UpdateSingleAabb(collisionObject);
}
public override BulletConstraint CreateGearConstraint(BulletWorld pWorld, BulletBody pBody1, BulletBody pBody2,
Vector3 paxisInA, Vector3 paxisInB,
float pratio, bool pdisableCollisionsBetweenLinkedBodies)
{
Generic6DofConstraint constrain = null;
/* BulletXNA does not have a gear constraint
GearConstraint constrain = null;
DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
RigidBody rb1 = (pBody1 as BulletBodyXNA).rigidBody;
RigidBody rb2 = (pBody2 as BulletBodyXNA).rigidBody;
if (rb1 != null && rb2 != null)
{
IndexedVector3 axis1 = new IndexedVector3(paxisInA.X, paxisInA.Y, paxisInA.Z);
IndexedVector3 axis2 = new IndexedVector3(paxisInB.X, paxisInB.Y, paxisInB.Z);
constrain = new GearConstraint(rb1, rb2, ref axis1, ref axis2, pratio);
world.AddConstraint(constrain, pdisableCollisionsBetweenLinkedBodies);
}
*/
return new BulletConstraintXNA(constrain);
}
//BuildCapsuleShape(physicsScene.World.ptr, 1f, 1f, prim.Scale);
public override BulletShape BuildCapsuleShape(BulletWorld pWorld, float pRadius, float pHeight, Vector3 pScale)
{
DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
IndexedVector3 scale = new IndexedVector3(pScale.X, pScale.Y, pScale.Z);
CapsuleShapeZ capsuleShapeZ = new CapsuleShapeZ(pRadius, pHeight);
capsuleShapeZ.SetMargin(world.WorldSettings.Params.collisionMargin);
capsuleShapeZ.SetLocalScaling(ref scale);
return new BulletShapeXNA(capsuleShapeZ, BSPhysicsShapeType.SHAPE_CAPSULE);
;
}
//sim.ptr, shape.ptr,prim.LocalID, prim.RawPosition, prim.RawOrientation
public override BulletBody CreateGhostFromShape(BulletWorld pWorld, BulletShape pShape, uint pLocalID,
Vector3 pRawPosition, Quaternion pRawOrientation)
{
// 20131224 not used DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
IndexedMatrix bodyTransform = new IndexedMatrix();
bodyTransform._origin = new IndexedVector3(pRawPosition.X, pRawPosition.Y, pRawPosition.Z);
bodyTransform.SetRotation(new IndexedQuaternion(pRawOrientation.X, pRawOrientation.Y, pRawOrientation.Z,
pRawOrientation.W));
GhostObject gObj = new PairCachingGhostObject();
gObj.SetWorldTransform(bodyTransform);
CollisionShape shape = (pShape as BulletShapeXNA).shape;
gObj.SetCollisionShape(shape);
gObj.SetUserPointer(pLocalID);
if (specialCollisionObjects.ContainsKey(pLocalID))
specialCollisionObjects[pLocalID] = gObj;
else
specialCollisionObjects.Add(pLocalID, gObj);
// TODO: Add to Special CollisionObjects!
return new BulletBodyXNA(pLocalID, gObj);
}
public override BulletShape BuildHullShapeFromMesh(BulletWorld world, BulletShape meshShape, HACDParams parms)
{
/* TODO */
return null;
}
public override BulletShape CreateMeshShape(BulletWorld pWorld, int pIndicesCount, int[] indices,
int pVerticesCount, float[] verticesAsFloats)
{
//DumpRaw(indices,verticesAsFloats,pIndicesCount,pVerticesCount);
for (int iter = 0; iter < pVerticesCount; iter++)
{
if (verticesAsFloats[iter] > 0 && verticesAsFloats[iter] < 0.0001) verticesAsFloats[iter] = 0;
if (verticesAsFloats[iter] < 0 && verticesAsFloats[iter] > -0.0001) verticesAsFloats[iter] = 0;
}
ObjectArray<int> indicesarr = new ObjectArray<int>(indices);
ObjectArray<float> vertices = new ObjectArray<float>(verticesAsFloats);
DumpRaw(indicesarr, vertices, pIndicesCount, pVerticesCount);
DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
IndexedMesh mesh = new IndexedMesh();
mesh.m_indexType = PHY_ScalarType.PHY_INTEGER;
mesh.m_numTriangles = pIndicesCount / 3;
mesh.m_numVertices = pVerticesCount;
mesh.m_triangleIndexBase = indicesarr;
mesh.m_vertexBase = vertices;
mesh.m_vertexStride = 3;
mesh.m_vertexType = PHY_ScalarType.PHY_FLOAT;
mesh.m_triangleIndexStride = 3;
TriangleIndexVertexArray tribuilder = new TriangleIndexVertexArray();
tribuilder.AddIndexedMesh(mesh, PHY_ScalarType.PHY_INTEGER);
BvhTriangleMeshShape meshShape = new BvhTriangleMeshShape(tribuilder, true, true);
meshShape.SetMargin(world.WorldSettings.Params.collisionMargin);
// world.UpdateSingleAabb(meshShape);
return new BulletShapeXNA(meshShape, BSPhysicsShapeType.SHAPE_MESH);
}
//(PhysicsScene.World.ptr, nativeShapeData)
public override BulletShape BuildNativeShape(BulletWorld pWorld, ShapeData pShapeData)
{
DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
CollisionShape shape = null;
switch (pShapeData.Type)
{
case BSPhysicsShapeType.SHAPE_BOX:
shape = new BoxShape(new IndexedVector3(0.5f, 0.5f, 0.5f));
break;
case BSPhysicsShapeType.SHAPE_CONE:
shape = new ConeShapeZ(0.5f, 1.0f);
break;
case BSPhysicsShapeType.SHAPE_CYLINDER:
shape = new CylinderShapeZ(new IndexedVector3(0.5f, 0.5f, 0.5f));
break;
case BSPhysicsShapeType.SHAPE_SPHERE:
shape = new SphereShape(0.5f);
break;
}
if (shape != null)
{
IndexedVector3 scaling = new IndexedVector3(pShapeData.Scale.X, pShapeData.Scale.Y, pShapeData.Scale.Z);
shape.SetMargin(world.WorldSettings.Params.collisionMargin);
shape.SetLocalScaling(ref scaling);
}
return new BulletShapeXNA(shape, pShapeData.Type);
}
public override BulletConstraint CreateSliderConstraint(BulletWorld pWorld, BulletBody pBody1, BulletBody pBody2,
Vector3 pframe1, Quaternion pframe1rot,
Vector3 pframe2, Quaternion pframe2rot,
bool puseLinearReferenceFrameA, bool pdisableCollisionsBetweenLinkedBodies)
{
SliderConstraint constrain = null;
DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
RigidBody rb1 = (pBody1 as BulletBodyXNA).rigidBody;
RigidBody rb2 = (pBody2 as BulletBodyXNA).rigidBody;
if (rb1 != null && rb2 != null)
{
IndexedVector3 frame1v = new IndexedVector3(pframe1.X, pframe1.Y, pframe1.Z);
IndexedQuaternion frame1rot = new IndexedQuaternion(pframe1rot.X, pframe1rot.Y, pframe1rot.Z,
pframe1rot.W);
IndexedMatrix frame1 = IndexedMatrix.CreateFromQuaternion(frame1rot);
frame1._origin = frame1v;
// 20131224 not used IndexedVector3 frame2v = new IndexedVector3(pframe2.X, pframe2.Y, pframe2.Z);
IndexedQuaternion frame2rot = new IndexedQuaternion(pframe2rot.X, pframe2rot.Y, pframe2rot.Z,
pframe2rot.W);
IndexedMatrix frame2 = IndexedMatrix.CreateFromQuaternion(frame2rot);
frame2._origin = frame1v;
constrain = new SliderConstraint(rb1, rb2, ref frame1, ref frame2, puseLinearReferenceFrameA);
world.AddConstraint(constrain, pdisableCollisionsBetweenLinkedBodies);
}
return new BulletConstraintXNA(constrain);
}
public override BulletConstraint Create6DofConstraintFixed(BulletWorld pWorld, BulletBody pBody1,
Vector3 pframe1, Quaternion pframe1rot,
bool pUseLinearReferenceFrameB, bool pdisableCollisionsBetweenLinkedBodies)
{
DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
RigidBody body1 = (pBody1 as BulletBodyXNA).rigidBody;
IndexedVector3 frame1v = new IndexedVector3(pframe1.X, pframe1.Y, pframe1.Z);
IndexedQuaternion frame1rot = new IndexedQuaternion(pframe1rot.X, pframe1rot.Y, pframe1rot.Z, pframe1rot.W);
IndexedMatrix frame1 = IndexedMatrix.CreateFromQuaternion(frame1rot);
frame1._origin = frame1v;
Generic6DofConstraint consttr = new Generic6DofConstraint(body1, ref frame1, pUseLinearReferenceFrameB);
consttr.CalculateTransforms();
world.AddConstraint(consttr, pdisableCollisionsBetweenLinkedBodies);
return new BulletConstraintXNA(consttr);
}
public override bool DestroyConstraint(BulletWorld pWorld, BulletConstraint pConstraint)
{
DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
TypedConstraint constraint = (pConstraint as BulletConstraintXNA).constrain;
world.RemoveConstraint(constraint);
return true;
}
public override void Shutdown(BulletWorld pWorld)
{
DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
world.Cleanup();
}
public override BulletShape DuplicateCollisionShape(BulletWorld pWorld, BulletShape pShape, uint id)
{
CollisionShape shape1 = (pShape as BulletShapeXNA).shape;
// TODO: Turn this from a reference copy to a Value Copy.
BulletShapeXNA shape2 = new BulletShapeXNA(shape1,
BSShapeTypeFromBroadPhaseNativeType(shape1.GetShapeType()));
return shape2;
}
//(sim.ptr, shape.ptr, prim.LocalID, prim.RawPosition, prim.RawOrientation);
public override BulletBody CreateBodyFromShape(BulletWorld pWorld, BulletShape pShape, uint pLocalID,
Vector3 pRawPosition, Quaternion pRawOrientation)
{
// 20131224 not used CollisionWorld world = (pWorld as BulletWorldXNA).world;
IndexedMatrix mat =
IndexedMatrix.CreateFromQuaternion(new IndexedQuaternion(pRawOrientation.X, pRawOrientation.Y,
pRawOrientation.Z, pRawOrientation.W));
mat._origin = new IndexedVector3(pRawPosition.X, pRawPosition.Y, pRawPosition.Z);
CollisionShape shape = (pShape as BulletShapeXNA).shape;
//UpdateSingleAabb(world, shape);
// TODO: Feed Update array into null
SimMotionState motionState = new SimMotionState(this, pLocalID, mat, null);
RigidBody body = new RigidBody(0, motionState, shape, IndexedVector3.Zero);
// 20131224 not used RigidBodyConstructionInfo constructionInfo = new RigidBodyConstructionInfo(0, motionState, shape, IndexedVector3.Zero)
// 20131224 not used {
// 20131224 not used m_mass = 0
// 20131224 not used };
/*
m_mass = mass;
m_motionState =motionState;
m_collisionShape = collisionShape;
m_localInertia = localInertia;
m_linearDamping = 0f;
m_angularDamping = 0f;
m_friction = 0.5f;
m_restitution = 0f;
m_linearSleepingThreshold = 0.8f;
m_angularSleepingThreshold = 1f;
m_additionalDamping = false;
m_additionalDampingFactor = 0.005f;
m_additionalLinearDampingThresholdSqr = 0.01f;
m_additionalAngularDampingThresholdSqr = 0.01f;
m_additionalAngularDampingFactor = 0.01f;
m_startWorldTransform = IndexedMatrix.Identity;
*/
body.SetUserPointer(pLocalID);
return new BulletBodyXNA(pLocalID, body);
}
/// <summary>
///
/// </summary>
/// <param name="pWorld"></param>
/// <param name="pBody1"></param>
/// <param name="pBody2"></param>
/// <param name="pjoinPoint"></param>
/// <param name="puseLinearReferenceFrameA"></param>
/// <param name="pdisableCollisionsBetweenLinkedBodies"></param>
/// <returns></returns>
public override BulletConstraint Create6DofConstraintToPoint(BulletWorld pWorld, BulletBody pBody1,
BulletBody pBody2, Vector3 pjoinPoint, bool puseLinearReferenceFrameA,
bool pdisableCollisionsBetweenLinkedBodies)
{
DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
RigidBody body1 = (pBody1 as BulletBodyXNA).rigidBody;
RigidBody body2 = (pBody2 as BulletBodyXNA).rigidBody;
IndexedMatrix frame1 = new IndexedMatrix(IndexedBasisMatrix.Identity, new IndexedVector3(0, 0, 0));
IndexedMatrix frame2 = new IndexedMatrix(IndexedBasisMatrix.Identity, new IndexedVector3(0, 0, 0));
IndexedVector3 joinPoint = new IndexedVector3(pjoinPoint.X, pjoinPoint.Y, pjoinPoint.Z);
IndexedMatrix mat = IndexedMatrix.Identity;
mat._origin = new IndexedVector3(pjoinPoint.X, pjoinPoint.Y, pjoinPoint.Z);
frame1._origin = body1.GetWorldTransform().Inverse() * joinPoint;
frame2._origin = body2.GetWorldTransform().Inverse() * joinPoint;
Generic6DofConstraint consttr = new Generic6DofConstraint(body1, body2, ref frame1, ref frame2,
puseLinearReferenceFrameA);
consttr.CalculateTransforms();
world.AddConstraint(consttr, pdisableCollisionsBetweenLinkedBodies);
return new BulletConstraintXNA(consttr);
}
public override void UpdateAabbs(BulletWorld pWorld)
{
DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
world.UpdateAabbs();
}