static void LoadPlayGroundScene(DemoEntityManager* const scene, TriggerManager* const triggerManager)
{
NewtonWorld* const world = scene->GetNewton();
// CreateLevelMesh (scene, "flatPlane.ngd", true);
// return;
// make the body with a dummy null collision, so that we can use for attaching world objects
dMatrix matrix (dGetIdentityMatrix());
NewtonCollision* const dommyCollision = NewtonCreateNull(world);
NewtonBody* const playGroundBody = NewtonCreateDynamicBody (world, dommyCollision, &matrix[0][0]);
NewtonDestroyCollision (dommyCollision);
// use a multi shape static scene collision
NewtonCollision* const sceneCollision = NewtonCreateSceneCollision (world, 0);
// start adding shapes to this scene collisions
NewtonSceneCollisionBeginAddRemove (sceneCollision);
// populate the scene collision
{
// load a flat floor
LoadFloor(scene, sceneCollision);
// load a slide platform
dMatrix slideMatrix(dGetIdentityMatrix());
slideMatrix.m_posit.m_x += 80.0f;
slideMatrix.m_posit.m_z = -20.0f;
//LoadSlide(scene, triggerManager, sceneCollision, "slide.ngd", slideMatrix, playGroundBody);
LoadFerryBridge(scene, triggerManager, sceneCollision, "platformBridge.ngd", slideMatrix, playGroundBody);
// load another hanging bridge
dMatrix bridgeMatrix(dGetIdentityMatrix());
bridgeMatrix.m_posit.m_x += 40.0f;
LoadHangingBridge(scene, triggerManager, sceneCollision, "hangingBridge.ngd", bridgeMatrix, playGroundBody);
// load another ferry bridge
bridgeMatrix.m_posit.m_z += 20.0f;
LoadFerryBridge(scene, triggerManager, sceneCollision, "platformBridge.ngd", bridgeMatrix, playGroundBody);
}
// finalize adding shapes to this scene collisions
NewtonSceneCollisionEndAddRemove (sceneCollision);
// attach this collision to the playground Body
NewtonBodySetCollision(playGroundBody, sceneCollision);
// set the reference to the visual
//NewtonBodySetUserData(level, visualMesh);
// do not forget to release the collision
NewtonDestroyCollision (sceneCollision);
}
NewtonCollision* NullCollider3D::CreateHandle(PhysWorld3D* world) const
{
return NewtonCreateNull(world->GetHandle());
}
NewtonCollision* CreateConvexCollision (NewtonWorld* world, const dMatrix& srcMatrix, const dVector& originalSize, PrimitiveType type, int materialID__)
{
dVector size (originalSize);
NewtonCollision* collision = NULL;
switch (type)
{
case _NULL_PRIMITIVE:
{
collision = NewtonCreateNull (world);
break;
}
case _SPHERE_PRIMITIVE:
{
// create the collision
collision = NewtonCreateSphere (world, size.m_x * 0.5f, 0, NULL);
break;
}
case _BOX_PRIMITIVE:
{
// create the collision
collision = NewtonCreateBox (world, size.m_x, size.m_y, size.m_z, 0, NULL);
break;
}
case _CONE_PRIMITIVE:
{
dFloat r = size.m_x * 0.5f;
dFloat h = size.m_y;
// create the collision
collision = NewtonCreateCone (world, r, h, 0, NULL);
break;
}
case _CYLINDER_PRIMITIVE:
{
// create the collision
collision = NewtonCreateCylinder (world, size.m_x * 0.5f, size.m_y, 0, NULL);
break;
}
case _CAPSULE_PRIMITIVE:
{
// create the collision
collision = NewtonCreateCapsule (world, size.m_x * 0.5f, size.m_y, 0, NULL);
break;
}
case _TAPERED_CAPSULE_PRIMITIVE:
{
// create the collision
collision = NewtonCreateTaperedCapsule (world, size.m_x * 0.5f, size.m_z * 0.5f, size.m_y, 0, NULL);
break;
}
case _CHAMFER_CYLINDER_PRIMITIVE:
{
// create the collision
collision = NewtonCreateChamferCylinder (world, size.m_x * 0.5f, size.m_y, 0, NULL);
break;
}
case _TAPERED_CYLINDER_PRIMITIVE:
{
// create the collision
collision = NewtonCreateTaperedCylinder (world, size.m_x * 0.5f, size.m_z * 0.5f, size.m_y, 0, NULL);
break;
}
case _RANDOM_CONVEX_HULL_PRIMITIVE:
{
// Create a clouds of random point around the origin
#define SAMPLE_COUNT 200
dVector cloud [SAMPLE_COUNT];
// make sure that at least the top and bottom are present
cloud [0] = dVector ( size.m_x * 0.5f, 0.0f, 0.0f, 0.0f);
cloud [1] = dVector (-size.m_x * 0.5f, 0.0f, 0.0f, 0.0f);
cloud [2] = dVector ( 0.0f, size.m_y * 0.5f, 0.0f, 0.0f);
cloud [3] = dVector ( 0.0f, -size.m_y * 0.5f, 0.0f, 0.0f);
cloud [4] = dVector (0.0f, 0.0f, size.m_z * 0.5f, 0.0f);
cloud [5] = dVector (0.0f, 0.0f, -size.m_z * 0.5f, 0.0f);
int count = 6;
// populate the cloud with pseudo Gaussian random points
for (int i = 6; i < SAMPLE_COUNT; i ++) {
cloud [i].m_x = RandomVariable(size.m_x);
cloud [i].m_y = RandomVariable(size.m_y);
cloud [i].m_z = RandomVariable(size.m_z);
count ++;
}
collision = NewtonCreateConvexHull (world, count, &cloud[0].m_x, sizeof (dVector), 0.01f, 0, NULL);
break;
}
case _REGULAR_CONVEX_HULL_PRIMITIVE:
{
// Create a clouds of random point around the origin
#define STEPS_HULL 6
//#define STEPS_HULL 3
dVector cloud [STEPS_HULL * 4 + 256];
int count = 0;
dFloat radius = size.m_y;
dFloat height = size.m_x * 0.999f;
dFloat x = - height * 0.5f;
dMatrix rotation (dPitchMatrix(2.0f * 3.141592f / STEPS_HULL));
for (int i = 0; i < 4; i ++) {
dFloat pad = ((i == 1) || (i == 2)) * 0.25f * radius;
dVector p (x, 0.0f, radius + pad);
x += 0.3333f * height;
dMatrix acc (dGetIdentityMatrix());
for (int j = 0; j < STEPS_HULL; j ++) {
cloud[count] = acc.RotateVector(p);
acc = acc * rotation;
count ++;
}
}
collision = NewtonCreateConvexHull (world, count, &cloud[0].m_x, sizeof (dVector), 0.02f, 0, NULL);
break;
}
case _COMPOUND_CONVEX_CRUZ_PRIMITIVE:
{
//dMatrix matrix (GetIdentityMatrix());
dMatrix matrix (dPitchMatrix(15.0f * 3.1416f / 180.0f) * dYawMatrix(15.0f * 3.1416f / 180.0f) * dRollMatrix(15.0f * 3.1416f / 180.0f));
// NewtonCollision* const collisionA = NewtonCreateBox (world, size.m_x, size.m_x * 0.25f, size.m_x * 0.25f, 0, &matrix[0][0]);
// NewtonCollision* const collisionB = NewtonCreateBox (world, size.m_x * 0.25f, size.m_x, size.m_x * 0.25f, 0, &matrix[0][0]);
// NewtonCollision* const collisionC = NewtonCreateBox (world, size.m_x * 0.25f, size.m_x * 0.25f, size.m_x, 0, &matrix[0][0]);
matrix.m_posit = dVector (size.m_x * 0.5f, 0.0f, 0.0f, 1.0f);
NewtonCollision* const collisionA = NewtonCreateBox (world, size.m_x, size.m_x * 0.25f, size.m_x * 0.25f, 0, &matrix[0][0]);
matrix.m_posit = dVector (0.0f, size.m_x * 0.5f, 0.0f, 1.0f);
NewtonCollision* const collisionB = NewtonCreateBox (world, size.m_x * 0.25f, size.m_x, size.m_x * 0.25f, 0, &matrix[0][0]);
matrix.m_posit = dVector (0.0f, 0.0f, size.m_x * 0.5f, 1.0f);
NewtonCollision* const collisionC = NewtonCreateBox (world, size.m_x * 0.25f, size.m_x * 0.25f, size.m_x, 0, &matrix[0][0]);
collision = NewtonCreateCompoundCollision (world, 0);
NewtonCompoundCollisionBeginAddRemove(collision);
NewtonCompoundCollisionAddSubCollision (collision, collisionA);
NewtonCompoundCollisionAddSubCollision (collision, collisionB);
NewtonCompoundCollisionAddSubCollision (collision, collisionC);
NewtonCompoundCollisionEndAddRemove(collision);
NewtonDestroyCollision(collisionA);
NewtonDestroyCollision(collisionB);
NewtonDestroyCollision(collisionC);
break;
}
default: dAssert (0);
}
dMatrix matrix (srcMatrix);
matrix.m_front = matrix.m_front.Scale (1.0f / dSqrt (matrix.m_front % matrix.m_front));
matrix.m_right = matrix.m_front * matrix.m_up;
matrix.m_right = matrix.m_right.Scale (1.0f / dSqrt (matrix.m_right % matrix.m_right));
matrix.m_up = matrix.m_right * matrix.m_front;
NewtonCollisionSetMatrix(collision, &matrix[0][0]);
return collision;
}
NzNullGeom::NzNullGeom(NzPhysWorld* physWorld) :
NzBaseGeom(physWorld)
{
m_collision = NewtonCreateNull(physWorld->GetHandle());
}
export double GmnCreateNull(double dWorld){
NewtonWorld* nWorld = recastDoubleWorld(dWorld);
NewtonCollision* nCollision = NewtonCreateNull(nWorld);
return( recastCollisionDouble(nCollision) );
}
cCollideShapeNewton::cCollideShapeNewton(eCollideShapeType aType, const cVector3f &avSize,
cMatrixf* apOffsetMtx, NewtonWorld* apNewtonWorld,
iPhysicsWorld *apWorld)
: iCollideShape(apWorld)
{
mpNewtonCollision = NULL;
mpNewtonWorld = apNewtonWorld;
mvSize = avSize;
mType = aType;
mfVolume = 0;
float *pMtx = NULL;
cMatrixf mtxTranspose;
if(apOffsetMtx)
{
m_mtxOffset = *apOffsetMtx;
mtxTranspose = m_mtxOffset.GetTranspose();
pMtx = &(mtxTranspose.m[0][0]);
}
else
m_mtxOffset = cMatrixf::Identity;
////////////////////////////////////////////
// Create Newton collision
switch(aType)
{
case eCollideShapeType_Null: mpNewtonCollision = NewtonCreateNull(apNewtonWorld); break;
case eCollideShapeType_Box: mpNewtonCollision = NewtonCreateBox(apNewtonWorld,
mvSize.x, mvSize.y, mvSize.z,
pMtx); break;
case eCollideShapeType_Sphere: mpNewtonCollision = NewtonCreateSphere(apNewtonWorld,
mvSize.x, mvSize.y, mvSize.z,
pMtx); break;
case eCollideShapeType_Cylinder: mpNewtonCollision = NewtonCreateCylinder(apNewtonWorld,
mvSize.x, mvSize.y,
pMtx); break;
case eCollideShapeType_Capsule: mpNewtonCollision = NewtonCreateCapsule(apNewtonWorld,
mvSize.x, mvSize.y,
pMtx); break;
}
////////////////////////////////////////////
// Calculate Bounding volume and volume.
if(mType == eCollideShapeType_Box)
{
mBoundingVolume.SetSize(mvSize);
mfVolume = mvSize.x * mvSize.y *mvSize.z;
}
else if(mType == eCollideShapeType_Sphere)
{
mBoundingVolume.SetSize(mvSize*2);
mfVolume = (4.0f / 3.0f) * kPif * (mvSize.x*mvSize.x*mvSize.x);
}
else if(mType == eCollideShapeType_Cylinder ||
mType == eCollideShapeType_Capsule)
{
mBoundingVolume.SetSize(cVector3f(mvSize.y,mvSize.x*2,mvSize.x*2));
//Not gonna be correct for capsule...
if(mType == eCollideShapeType_Cylinder)
mfVolume = kPif * (mvSize.x*mvSize.x)*mvSize.y;
else
{
//Height of the cylinder part.
float fCylHeight = mvSize.y - (mvSize.x*2);
mfVolume =0;
//The volume of the cylinder part.
if(fCylHeight>0)
mfVolume += kPif * (mvSize.x*mvSize.x)*fCylHeight;
//The volume of the sphere part.
mfVolume += (4.0f / 3.0f) * kPif * (mvSize.x*mvSize.x*mvSize.x);
}
}
mBoundingVolume.SetTransform(m_mtxOffset);
}
dNewtonCollisionNull::dNewtonCollisionNull(dNewtonWorld* const world)
:dNewtonCollision(world, 0)
{
NewtonWaitForUpdateToFinish(m_myWorld->m_world);
SetShape(NewtonCreateNull(m_myWorld->m_world));
}
