// Called to update/change the body and shape for an object.
// The object has some shape and body on it. Here we decide if that is the correct shape
// for the current state of the object (static/dynamic/...).
// If bodyCallback is not null, it is called if either the body or the shape are changed
// so dependencies (like constraints) can be removed before the physical object is dereferenced.
// Return 'true' if either the body or the shape changed.
// Called at taint-time.
public bool GetBodyAndShape(bool forceRebuild, BulletWorld sim, BSPhysObject prim, PhysicalDestructionCallback bodyCallback)
{
m_physicsScene.AssertInTaintTime("BSShapeCollection.GetBodyAndShape");
bool ret = false;
// This lock could probably be pushed down lower but building shouldn't take long
lock (m_collectionActivityLock)
{
// Do we have the correct geometry for this type of object?
// Updates prim.BSShape with information/pointers to shape.
// Returns 'true' of BSShape is changed to a new shape.
bool newGeom = CreateGeom(forceRebuild, prim, bodyCallback);
// If we had to select a new shape geometry for the object,
// rebuild the body around it.
// Updates prim.BSBody with information/pointers to requested body
// Returns 'true' if BSBody was changed.
bool newBody = CreateBody((newGeom || forceRebuild), prim, m_physicsScene.World, bodyCallback);
ret = newGeom || newBody;
}
DetailLog("{0},BSShapeCollection.GetBodyAndShape,taintExit,force={1},ret={2},body={3},shape={4}",
prim.LocalID, forceRebuild, ret, prim.PhysBody, prim.PhysShape);
return ret;
}
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;
}
public BSConstraintConeTwist(BulletWorld world, BulletBody obj1, BulletBody obj2,
Vector3 frameInAloc, Quaternion frameInArot,
Vector3 frameInBloc, Quaternion frameInBrot,
bool disableCollisionsBetweenLinkedBodies)
: base(world)
{
m_body1 = obj1;
m_body2 = obj2;
m_constraint = PhysicsScene.PE.CreateConeTwistConstraint(world, obj1, obj2,
frameInAloc, frameInArot, frameInBloc, frameInBrot,
disableCollisionsBetweenLinkedBodies);
m_enabled = true;
}
public BSConstraintSlider(BulletWorld world, BulletBody obj1, BulletBody obj2,
Vector3 frameInAloc, Quaternion frameInArot,
Vector3 frameInBloc, Quaternion frameInBrot,
bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies)
: base(world)
{
m_body1 = obj1;
m_body2 = obj2;
m_constraint = PhysicsScene.PE.CreateSliderConstraint(world, obj1, obj2,
frameInAloc, frameInArot, frameInBloc, frameInBrot,
useLinearReferenceFrameA, disableCollisionsBetweenLinkedBodies);
m_enabled = true;
}
public BSConstraintSpring(BulletWorld world, BulletBody obj1, BulletBody obj2,
Vector3 frame1Loc, Quaternion frame1Rot,
Vector3 frame2Loc, Quaternion frame2Rot,
bool useLinearReferenceFrameA, bool disableCollisionsBetweenLinkedBodies)
:base(world, obj1, obj2)
{
m_constraint = PhysicsScene.PE.Create6DofSpringConstraint(world, obj1, obj2,
frame1Loc, frame1Rot, frame2Loc, frame2Rot,
useLinearReferenceFrameA, disableCollisionsBetweenLinkedBodies);
m_enabled = true;
PhysicsScene.DetailLog("{0},BSConstraintSpring,create,wID={1}, rID={2}, rBody={3}, cID={4}, cBody={5}",
obj1.ID, world.worldID, obj1.ID, obj1.AddrString, obj2.ID, obj2.AddrString);
PhysicsScene.DetailLog("{0},BSConstraintSpring,create, f1Loc={1},f1Rot={2},f2Loc={3},f2Rot={4},usefA={5},disCol={6}",
m_body1.ID, frame1Loc, frame1Rot, frame2Loc, frame2Rot, useLinearReferenceFrameA, disableCollisionsBetweenLinkedBodies);
}
// 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}",
m_body1.ID, 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;
}
}
}
/// <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 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 bool GetForceUpdateAllAabbs(BulletWorld pWorld) {
DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
return world.GetForceUpdateAllAabbs();
}
public override void UpdateSingleAabb(BulletWorld pWorld, BulletBody pCollisionObject)
{
DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
CollisionObject collisionObject = (pCollisionObject as BulletBodyXNA).body;
world.UpdateSingleAabb(collisionObject);
}
public bool RayCastGround(BulletWorld pWorld, Vector3 _RayOrigin, float pRayHeight, BulletBody NotMe)
{
DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
if (world != null)
{
if (NotMe is BulletBodyXNA && NotMe.HasPhysicalBody)
{
CollisionObject AvoidBody = (NotMe as BulletBodyXNA).body;
IndexedVector3 rOrigin = new IndexedVector3(_RayOrigin.X, _RayOrigin.Y, _RayOrigin.Z);
IndexedVector3 rEnd = new IndexedVector3(_RayOrigin.X, _RayOrigin.Y, _RayOrigin.Z - pRayHeight);
using (
ClosestNotMeRayResultCallback rayCallback =
new ClosestNotMeRayResultCallback(rOrigin, rEnd, AvoidBody)
)
{
world.RayTest(ref rOrigin, ref rEnd, rayCallback);
if (rayCallback.HasHit())
{
IndexedVector3 hitLocation = rayCallback.m_hitPointWorld;
}
return rayCallback.HasHit();
}
}
}
return false;
}
private static EntityProperties GetDebugProperties(BulletWorld pWorld, BulletBody pCollisionObject)
{
EntityProperties ent = new EntityProperties();
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;
}
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 BulletConstraint CreateConeTwistConstraint(BulletWorld pWorld, BulletBody pBody1, BulletBody pBody2,
Vector3 pframe1, Quaternion pframe1rot,
Vector3 pframe2, Quaternion pframe2rot,
bool pdisableCollisionsBetweenLinkedBodies)
{
ConeTwistConstraint 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;
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 ConeTwistConstraint(rb1, rb2, ref frame1, ref frame2);
world.AddConstraint(constrain, pdisableCollisionsBetweenLinkedBodies);
}
return new BulletConstraintXNA(constrain);
}
public BSConstraint6Dof(BulletWorld world, BulletBody obj1, BulletBody obj2) : base(world)
{
m_body1 = obj1;
m_body2 = obj2;
m_enabled = false;
}
public BSConstraint(BulletWorld world)
{
m_world = world;
PhysicsScene = m_world.physicsScene;
}
public override int PhysicsStep(BulletWorld world, float timeStep, int maxSubSteps, float fixedTimeStep,
out int updatedEntityCount, out int collidersCount)
{
/* TODO */
updatedEntityCount = 0;
collidersCount = 0;
int ret = PhysicsStep2(world,timeStep,maxSubSteps,fixedTimeStep,out updatedEntityCount,out world.physicsScene.m_updateArray, out collidersCount, out world.physicsScene.m_collisionArray);
return ret;
}
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);
}
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 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 UpdateParameter(BulletWorld world, uint localID, String parm, float value) { /* TODO */
return false; }
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;
}
public override BulletShape BuildHullShapeFromMesh(BulletWorld world, BulletShape meshShape, HACDParams parms)
{
/* TODO */ return null;
}
public override void UpdateAabbs(BulletWorld pWorld) {
DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
world.UpdateAabbs();
}
public override BulletShape BuildConvexHullShapeFromMesh(BulletWorld world, BulletShape meshShape)
{
/* TODO */ return null;
}
public override void SetForceUpdateAllAabbs(BulletWorld pWorld, bool pForce)
{
DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
world.SetForceUpdateAllAabbs(pForce);
}
public override BulletShape CreateConvexHullShape(BulletWorld pWorld, int pIndicesCount, int[] indices, int pVerticesCount, float[] verticesAsFloats)
{
/* TODO */ return null;
}
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 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);
}
public override bool IsInWorld(BulletWorld pWorld, BulletBody pCollisionObject)
{
DiscreteDynamicsWorld world = (pWorld as BulletWorldXNA).world;
CollisionObject collisionObject = (pCollisionObject as BulletBodyXNA).body;
return world.IsInWorld(collisionObject);
}
public override BulletShape CreateGImpactShape(BulletWorld pWorld, int pIndicesCount, int[] indices, int pVerticesCount, float[] verticesAsFloats)
{
// TODO:
return null;
}
