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)); }