void AINavMeshLinkAbstract::InitialUpdate() { AIDB_SmartObjectRecord* pSmartObject = GetSmartObject(); if( pSmartObject ) { // Set entry offset distances from the SmartObject. m_fEntryOffsetDistA = pSmartObject->fEntryOffsetDistA; m_fEntryOffsetDistB = pSmartObject->fEntryOffsetDistB; m_fExitOffsetDistA = pSmartObject->fExitOffsetDistA; m_fExitOffsetDistB = pSmartObject->fExitOffsetDistB; // Find the true top and bottom of the link. if( pSmartObject->fFindFloorOffset != 0.f ) { m_fFloorTop = FindFloor( m_vMidPtLinkEdgeA, -m_vLinkDirXZ, pSmartObject->fFindFloorOffset ); m_fFloorBottom = FindFloor( m_vMidPtLinkEdgeB, m_vLinkDirXZ, pSmartObject->fFindFloorOffset ); } else { m_fFloorTop = m_vMidPtLinkEdgeA.y; m_fFloorBottom = m_vMidPtLinkEdgeB.y; } } }
// aka "Sonic_HitFloor" int Sonic_CheckDown(Object* self, int* outAngle, int* otherDist) { int dist1, dist2; FindFloor(self, self->y + self->height, self->x + self->width, 0xD, 0, 16, &dist1, &v_anglebuffer) FindFloor(self, self->y + self->height, self->x - self->width, 0xD, 0, 16, &dist2, &v_b_F76A) return Sonic_CheckCommon(dist1, dist2, 0, outAngle, otherDist); }
static void AddUniformScaledPrimitives (DemoEntityManager* const scene, dFloat mass, const dVector& origin, const dVector& size, int xCount, int zCount, dFloat spacing, PrimitiveType type, int materialID, const dMatrix& shapeOffsetMatrix) { // create the shape and visual mesh as a common data to be re used NewtonWorld* const world = scene->GetNewton(); NewtonCollision* const collision = CreateConvexCollision (world, &shapeOffsetMatrix[0][0], size, type, materialID); dFloat startElevation = 1000.0f; dMatrix matrix (dRollMatrix(-3.141592f/2.0f)); for (int i = 0; i < xCount; i ++) { dFloat x = origin.m_x + (i - xCount / 2) * spacing; for (int j = 0; j < zCount; j ++) { dFloat scale = 0.75f + 1.0f * (dFloat (dRand()) / dFloat(dRAND_MAX) - 0.5f); //scale = 1.0f; NewtonCollisionSetScale (collision, scale, scale, scale); DemoMesh* const geometry = new DemoMesh("cylinder_1", collision, "smilli.tga", "smilli.tga", "smilli.tga"); dFloat z = origin.m_z + (j - zCount / 2) * spacing; matrix.m_posit.m_x = x; matrix.m_posit.m_z = z; dVector floor (FindFloor (world, dVector (matrix.m_posit.m_x, startElevation, matrix.m_posit.m_z, 0.0f), 2.0f * startElevation)); matrix.m_posit.m_y = floor.m_y + 4.f; // create a solid CreateSimpleSolid (scene, geometry, mass, matrix, collision, materialID); // release the mesh geometry->Release(); } } // do not forget to delete the collision NewtonDestroyCollision (collision); }
void OptimizedMeshLevelCollision (NewtonFrame& system) { NewtonWorld* world; world = system.m_world; // create the sky box and the floor, //LoadLevelAndSceneRoot (system, "flatplane.dae", 1); //LoadLevelAndSceneRoot (system, "dungeon.dae", 1); //LoadLevelAndSceneRoot (system, "pitpool.dae", 1); LoadLevelAndSceneRoot (system, "pitpool.dae", 1); //LoadLevelAndSceneRoot (system, "dungeon.dae", 1); // create a material to collide with this object int defaultMaterialID; defaultMaterialID = NewtonMaterialGetDefaultGroupID (world); dVector posit (0.0f, 0.0f, 0.0f, 0.0f); posit.m_y = FindFloor (world, posit.m_x, posit.m_z) + 5.0f; InitEyePoint (dVector (1.0f, 0.0f, 0.0f), posit); dVector size (1.0f, 1.0f, 1.0f); dVector location (cameraEyepoint + cameraDir.Scale (10.0f)); AddBoxes(&system, 10.0f, location, size, 3, 3, 10.0f, _SPHERE_PRIMITIVE, defaultMaterialID); AddBoxes(&system, 10.0f, location, size, 3, 3, 10.0f, _BOX_PRIMITIVE, defaultMaterialID); AddBoxes(&system, 10.0f, location, size, 3, 3, 10.0f, _CONE_PRIMITIVE, defaultMaterialID); AddBoxes(&system, 10.0f, location, size, 3, 3, 10.0f, _CYLINDER_PRIMITIVE, defaultMaterialID); AddBoxes(&system, 10.0f, location, size, 3, 3, 10.0f, _CAPSULE_PRIMITIVE, defaultMaterialID); AddBoxes(&system, 10.0f, location, size, 3, 3, 10.0f, _CHAMFER_CYLINDER_PRIMITIVE, defaultMaterialID); AddBoxes(&system, 10.0f, location, size, 3, 3, 10.0f, _RANDOM_CONVEX_HULL_PRIMITIVE, defaultMaterialID); AddBoxes(&system, 10.0f, location, size, 3, 3, 10.0f, _REGULAR_CONVEX_HULL_PRIMITIVE, defaultMaterialID); }
// aka "Sonic_DontRunOnWalls" which is the dumbest name int Sonic_CheckUp(Object* self, int* outAngle, int* otherDist) { int dist1, dist2; FindFloor(self, (self->y - self->height) ^ 0xF, self->x + self->width, 0xE, 0x1000, -16, &dist1, &v_anglebuffer) FindWall(self, (self->y - self->height) ^ 0xF, self->x - self->width, 0xE, 0x1000, -16, &dist2, &v_b_F76A) return Sonic_CheckCommon(dist1, dist2, 0x80, outAngle, otherDist); }
void AddPrimitiveArray (DemoEntityManager* const scene, dFloat mass, const dVector& origin, const dVector& size, int xCount, int zCount, dFloat spacing, PrimitiveType type, int materialID, const dMatrix& shapeOffsetMatrix, dFloat startElevation) { // create the shape and visual mesh as a common data to be re used NewtonWorld* const world = scene->GetNewton(); NewtonCollision* const collision = CreateConvexCollision (world, shapeOffsetMatrix, size, type, materialID); // test collision mode //NewtonCollisionSetCollisonMode(collision, 0); DemoMesh* const geometry = new DemoMesh("primitive", collision, "smilli.tga", "smilli.tga", "smilli.tga"); //dFloat startElevation = 1000.0f; //dFloat startElevation = 20.0f; dMatrix matrix (dGetIdentityMatrix()); for (int i = 0; i < xCount; i ++) { dFloat x = origin.m_x + (i - xCount / 2) * spacing; for (int j = 0; j < zCount; j ++) { dFloat z = origin.m_z + (j - zCount / 2) * spacing; matrix.m_posit.m_x = x; matrix.m_posit.m_z = z; dVector floor (FindFloor (world, dVector (matrix.m_posit.m_x, startElevation, matrix.m_posit.m_z, 0.0f), 2.0f * startElevation)); matrix.m_posit.m_y = floor.m_y + size.m_y * 0.5f; CreateSimpleSolid (scene, geometry, mass, matrix, collision, materialID); } } // do not forget to release the assets geometry->Release(); NewtonDestroyCollision (collision); }
void HeightFieldCollision (DemoEntityManager* const scene) { // load the sky box scene->CreateSkyBox(); CreateHeightFieldTerrain(scene, HEIGHTFIELD_DEFAULT_SIZE, HEIGHTFIELD_DEFAULT_CELLSIZE, 1.5f, 0.2f, 200.0f, -50.0f); dMatrix locationTransform (dGetIdentityMatrix()); locationTransform.m_posit = FindFloor (scene->GetNewton(), dVector(126, 50, 50), 100.0f); locationTransform.m_posit.m_y += 2.0f; scene->SetCameraMatrix(dQuaternion(locationTransform), locationTransform.m_posit + dVector(0, 5, 0)); const int defaultMaterialID = NewtonMaterialGetDefaultGroupID (scene->GetNewton()); const dVector location (locationTransform.m_posit + dVector(20, 20, 0)); const dVector size (0.5f, 0.5f, 0.75f, 0.0f); const int count = 5; const dMatrix shapeOffsetMatrix (dGetIdentityMatrix()); AddPrimitiveArray(scene, 10.0f, location, size, count, count, 5.0f, _SPHERE_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix); AddPrimitiveArray(scene, 10.0f, location, size, count, count, 5.0f, _BOX_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix); AddPrimitiveArray(scene, 10.0f, location, size, count, count, 5.0f, _CAPSULE_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix); AddPrimitiveArray(scene, 10.0f, location, size, count, count, 5.0f, _CYLINDER_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix); AddPrimitiveArray(scene, 10.0f, location, size, count, count, 5.0f, _CONE_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix); // AddPrimitiveArray(scene, 10.0f, location, size, count, count, 5.0f, _TAPERED_CAPSULE_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix); // AddPrimitiveArray(scene, 10.0f, location, size, count, count, 5.0f, _TAPERED_CYLINDER_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix); AddPrimitiveArray(scene, 10.0f, location, size, count, count, 5.0f, _CHAMFER_CYLINDER_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix); AddPrimitiveArray(scene, 10.0f, location, size, count, count, 5.0f, _REGULAR_CONVEX_HULL_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix); AddPrimitiveArray(scene, 10.0f, location, size, count, count, 5.0f, _COMPOUND_CONVEX_CRUZ_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix); AddPrimitiveArray(scene, 10.0f, location, size, count, count, 5.0f, _RANDOM_CONVEX_HULL_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix); }
void FindIncreasingTripletWithMaxProduct(int* arr,int n){ //LSL Largest Smaller Left //LGR Largest Greater Right int* LSL=(int*)malloc(sizeof(int)*n); int* LGR=(int*)malloc(sizeof(int)*n); TNode* root=NULL; int i; for(i=0;i<n;i++){ LSL[i]=FindFloor(root,arr[i]); root=Insert(root,arr[i]); } /* printf("\nLSL\n"); for(i=0;i<n;i++){ printf("%d ",LSL[i]); } */ int max=0; for(i=n-1;i>=0;i--){ if(max<arr[i]){ max=arr[i]; LGR[i]=0; }else{ LGR[i]=max; } } /* printf("\nLGR\n"); for(i=0;i<n;i++){ printf("%d ",LGR[i]); } */ max=0; int tmpMax; int maxIndex; for(i=0;i<n;i++){ tmpMax=arr[i]*LSL[i]*LGR[i]; if(tmpMax>max){ max=tmpMax; maxIndex=i; } } printf("\nIncreasing Subsequence : %d %d %d",LSL[maxIndex],arr[maxIndex],LGR[maxIndex]); }
void BasicCar (DemoEntityManager* const scene) { // load the sky box scene->CreateSkyBox(); CreateLevelMesh (scene, "flatPlane.ngd", 1); // CreateHeightFieldTerrain (scene, 10, 8.0f, 5.0f, 0.2f, 200.0f, -50.0f); dMatrix location (dGetIdentityMatrix()); location.m_posit = dVector (0.0f, 10.0f, 0.0f, 1.0f); location.m_posit = FindFloor (scene->GetNewton(), location.m_posit, 100.0f); location.m_posit.m_y += 2.0f; NewtonWorld* const world = scene->GetNewton(); // create a vehicle controller manager BasicCarControllerManager* const manager = new BasicCarControllerManager (world); // load basicCarParameters.m_differentialType = BasciCarParameters::m_RWD; BasicCarEntity* const heavyVehicle = new BasicCarEntity (scene, manager, location, basicCarParameters); heavyVehicle->BuidlBasicCar (basicCarParameters); // set this vehicle as the player manager->SetAsPlayer(heavyVehicle); dMatrix camMatrix (manager->m_player->GetNextMatrix()); scene->SetCameraMouseLock (true); scene->SetCameraMatrix(camMatrix, camMatrix.m_posit); // // dVector location (origin); // location.m_x += 20.0f; // location.m_z += 20.0f; // location.m_posit.m_z += 4.0f; int count = 1; dMatrix shapeOffsetMatrix (dGetIdentityMatrix()); int defaultMaterialID = NewtonMaterialGetDefaultGroupID (scene->GetNewton()); dVector size (3.0f, 0.125f, 3.0f, 0.0f); //AddPrimitiveArray(scene, 100.0f, location.m_posit, size, count, count, 5.0f, _BOX_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix); size = dVector(1.0f, 0.5f, 1.0f, 0.0f); // AddPrimitiveArray(scene, 10.0f, location.m_posit, size, count, count, 5.0f, _SPHERE_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix); // AddPrimitiveArray(scene, 10.0f, location.m_posit, size, count, count, 5.0f, _BOX_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix); // AddPrimitiveArray(scene, 10.0f, location.m_posit, size, count, count, 5.0f, _CAPSULE_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix); AddPrimitiveArray(scene, 10.0f, location.m_posit, size, count, count, 5.0f, _CYLINDER_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix); // AddPrimitiveArray(scene, 10.0f, location.m_posit, size, count, count, 5.0f, _TAPERED_CAPSULE_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix); // AddPrimitiveArray(scene, 10.0f, location.m_posit, size, count, count, 5.0f, _TAPERED_CYLINDER_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix); // AddPrimitiveArray(scene, 10.0f, location.m_posit, size, count, count, 5.0f, _CHAMFER_CYLINDER_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix); // AddPrimitiveArray(scene, 10.0f, location.m_posit, size, count, count, 5.0f, _CONE_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix); // AddPrimitiveArray(scene, 10.0f, location.m_posit, size, count, count, 5.0f, _REGULAR_CONVEX_HULL_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix); // AddPrimitiveArray(scene, 10.0f, location.m_posit, size, count, count, 5.0f, _RANDOM_CONVEX_HULL_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix); // NewtonSerializeToFile (scene->GetNewton(), "C:/Users/Julio/Desktop/newton-dynamics/applications/media/xxxxx.bin"); }
void Hexapod(DemoEntityManager* const scene) { // load the sky box scene->CreateSkyBox(); CreateLevelMesh (scene, "flatPlane.ngd", true); //CreateHeightFieldTerrain(scene, HEIGHTFIELD_DEFAULT_SIZE, HEIGHTFIELD_DEFAULT_CELLSIZE, 1.5f, 0.3f, 200.0f, -50.0f); NewtonWorld* const world = scene->GetNewton(); int defaultMaterialID = NewtonMaterialGetDefaultGroupID(world); dHexapodManager* const robotManager = new dHexapodManager(scene); NewtonMaterialSetDefaultFriction(world, defaultMaterialID, defaultMaterialID, 1.0f, 1.0f); NewtonMaterialSetDefaultElasticity(world, defaultMaterialID, defaultMaterialID, 0.1f); dMatrix location (dGetIdentityMatrix()); location.m_posit = dVector(FindFloor(world, dVector(-0.0f, 50.0f, 0.0f, 1.0f), 2.0f * 50.0f)); location.m_posit.m_y += 1.0f; int count = 5; //count = 1; dMatrix location1(location); dFloat x0 = location.m_posit.m_x; for (int j = 0; j < 1; j++) { location.m_posit.m_z += 2.0f; location.m_posit.m_x = x0; for (int i = 0; i < count; i++) { location.m_posit.m_x += 2.0f; //location1.m_posit.m_x += 2.0f; robotManager->MakeHexapod(scene, location); //robotManager->MakeHexapod (scene, location1); } } location.m_posit = dVector(FindFloor(scene->GetNewton(), dVector(-0.0f, 50.0f, 0.0f, 1.0f), 2.0f * 50.0f)); dVector origin(FindFloor(world, dVector(-4.0f, 50.0f, 0.0f, 1.0f), 2.0f * 50.0f)); origin.m_y += 2.5f; // dVector size(3.0f, 0.125f, 3.0f, 0.0f); // dMatrix shapeOffsetMatrix (dGetIdentityMatrix()); // AddPrimitiveArray(scene, 50.0f, location.m_posit, size, count, count, 6.0f, _BOX_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix); dQuaternion rot; scene->SetCameraMatrix(rot, origin); }
//d1 a0 d3 d2 d3 int Sonic_GetCeilingDistAngle(Object* self, int x, int y, int* outAngle) { int dist; FindFloor(self, (y - 10) ^ 0xF, x, 0xE, 0x1000, -16, &dist, &v_anglebuffer); if(outAngle) *outAngle = (v_anglebuffer & 1) ? 0x80 : v_anglebuffer; return dist; }
//d1 a0 d3 d2 d3 int Sonic_GetFloorDistAngle(Object* self, int x, int y, int* outAngle) { int dist; FindFloor(self, y + 10, x, 0xE, 0, 16, &dist, &v_anglebuffer); if(outAngle) *outAngle = (v_anglebuffer & 1) ? 0 : v_anglebuffer; return dist; }
void CreateScene (NewtonWorld* world, SceneManager* sceneManager) { Entity* floor; NewtonBody* floorBody; NewtonCollision* shape; // initialize the camera InitCamera (dVector (-15.0f, 5.0f, 0.0f, 0.0f), dVector (1.0f, 0.0f, 0.0f)); // Create a large body to be the floor floor = sceneManager->CreateEntity(); floor->LoadMesh ("FloorBox.dat"); // add static floor Physics shape = CreateNewtonBox (world, floor, 0); floorBody = CreateRigidBody (world, floor, shape, 0.0f); NewtonDestroyCollision(shape); // set the Transformation Matrix for this rigid body dMatrix matrix (floor->m_curRotation, floor->m_curPosition); NewtonBodySetMatrix (floorBody, &matrix[0][0]); // find the floor base, and add some distance up; dFloat floorY = FindFloor (world, 0.0f, 0.0f) + 2.0f; // this is the width of the Box; dFloat boxWidth = 0.42f; // Make a small pyramid of Boxes for (int i = 0; i < PYRAMID_BASE + 1; i ++) { for (int j = 0; j < PYRAMID_BASE - i; j ++) { Entity* smilly; NewtonBody* smillyBody; // crate a visual Box and place in a pyramid formation above the floor smilly = sceneManager->CreateEntity(); smilly->LoadMesh ("Smilly.dat"); smilly->m_curPosition.m_x = 0.0f; smilly->m_curPosition.m_z = dFloat (j) * boxWidth + dFloat (i) * (boxWidth * 0.5f); smilly->m_curPosition.m_y = floorY + dFloat (i) * boxWidth; smilly->m_prevPosition = smilly->m_curPosition; // add a body with a box shape shape = CreateNewtonBox (world, smilly, 0); smillyBody = CreateRigidBody (world, smilly, shape, 10.0f); NewtonDestroyCollision(shape); // we want some nice object placement, with zero penetration and and zero jitter // therefore we are going use use a Convex Cast function to snap the Box to the closest contact surface ConvexCastPlacement (smillyBody); } } }
static void BuildJenga (DemoEntityManager* const scene, dFloat mass, const dVector& origin, const dVector& size, int count) { // build a standard block stack of 20 * 3 boxes for a total of 60 NewtonWorld* const world = scene->GetNewton(); dVector blockBoxSize (0.8f, 0.5f, 0.8f * 3.0f); blockBoxSize = blockBoxSize.Scale (1.0f); // create the stack dMatrix baseMatrix (dGetIdentityMatrix()); // for the elevation of the floor at the stack position baseMatrix.m_posit.m_x = origin.m_x; baseMatrix.m_posit.m_z = origin.m_z; dFloat startElevation = 100.0f; dVector floor (FindFloor (world, dVector (baseMatrix.m_posit.m_x, startElevation, baseMatrix.m_posit.m_z, 0.0f), 2.0f * startElevation)); baseMatrix.m_posit.m_y = floor.m_y + blockBoxSize.m_y / 2.0f; // set realistic mass and inertia matrix for each block mass = 5.0f; // create a 90 degree rotation matrix dMatrix rotMatrix (dYawMatrix (3.141592f * 0.5f)); // create a material to control collision with this objects int defaultMaterialID; defaultMaterialID = NewtonMaterialGetDefaultGroupID (world); // separate a bit the block alone the horizontal direction dFloat gap = 0.01f; // create the shape and visual mesh as a common data to be re used NewtonCollision* const collision = CreateConvexCollision (world, dGetIdentityMatrix(), blockBoxSize, _BOX_PRIMITIVE, defaultMaterialID); DemoMesh* const geometry = new DemoMesh("box", collision, "wood_0.tga", "wood_0.tga", "wood_0.tga"); for (int i = 0; i < count; i ++) { dMatrix matrix(baseMatrix); matrix.m_posit -= matrix.m_front.Scale (blockBoxSize.m_x - gap); for (int j = 0; j < 3; j ++) { CreateSimpleSolid (scene, geometry, mass, matrix, collision, defaultMaterialID); matrix.m_posit += matrix.m_front.Scale (blockBoxSize.m_x + gap); } baseMatrix = rotMatrix * baseMatrix; baseMatrix.m_posit += matrix.m_up.Scale (blockBoxSize.m_y * 0.99f); } // do not forget to release the assets geometry->Release(); NewtonDestroyCollision (collision); }
void FindFloor(TNode* root,TNode** tmpFloor,int* isSet,int key){ if(!root){ return; } if(key==root->data && !(*isSet)){ (*tmpFloor)=root; (*isSet)=1; return; } if(key>root->data && !(*isSet)){ (*tmpFloor)=root; FindFloor(root->right,tmpFloor,isSet,key); } if(key< root->data && !(*isSet)){ FindFloor(root->left,tmpFloor,isSet,key); } }
static void BuildPyramid (DemoEntityManager* const scene, dFloat mass, const dVector& origin, const dVector& size, int count, PrimitiveType type, const dMatrix& shapeMatrix = dGetIdentityMatrix()) { dMatrix matrix (dGetIdentityMatrix()); matrix.m_posit = origin; matrix.m_posit.m_w = 1.0f; // create the shape and visual mesh as a common data to be re used NewtonWorld* const world = scene->GetNewton(); int defaultMaterialID; defaultMaterialID = NewtonMaterialGetDefaultGroupID (world); //dMatrix shapeMatrix (dRollMatrix(3.141692f * 0.5f)); NewtonCollision* const collision = CreateConvexCollision (world, shapeMatrix, size, type, defaultMaterialID); DemoMesh* const geometry = new DemoMesh("cylinder_1", collision, "wood_4.tga", "wood_4.tga", "wood_1.tga"); //DemoMesh____* const geometry = new DemoMesh____("cylinder_1", collision, "smilli.tga", "smilli.tga", "smilli.tga"); // matrix = dRollMatrix(3.141592f/2.0f); dFloat startElevation = 100.0f; dVector floor (FindFloor (world, dVector (matrix.m_posit.m_x, startElevation, matrix.m_posit.m_z, 0.0f), 2.0f * startElevation)); matrix.m_posit.m_y = floor.m_y + size.m_y / 2.0f; // get the dimension from shape itself dVector minP; dVector maxP; CalculateAABB (collision, dGetIdentityMatrix(), minP, maxP); //dFloat stepz = size.m_z + 0.01f; dFloat stepz = maxP.m_z - minP.m_z + 0.01f; dFloat stepy = maxP.m_y - minP.m_y; float y0 = matrix.m_posit.m_y + stepy / 2.0f; float z0 = matrix.m_posit.m_z - stepz * count / 2; matrix.m_posit.m_y = y0; for (int j = 0; j < count; j ++) { matrix.m_posit.m_z = z0; for (int i = 0; i < (count - j) ; i ++) { CreateSimpleSolid (scene, geometry, mass, matrix, collision, defaultMaterialID); matrix.m_posit.m_z += stepz; } z0 += stepz * 0.5f; matrix.m_posit.m_y += stepy; } // do not forget to release the assets geometry->Release(); NewtonDestroyCollision (collision); }
static void Magnets (NewtonFrame& system, dFloat strength) { NewtonWorld* world; LevelPrimitive* scene; world = system.m_world; // create the sky box and the floor, scene = LoadLevelAndSceneRoot (system, "playground.dae", 1); dVector posit (0.0f, 0.0f, 0.0f, 1.0f); posit.m_y = FindFloor (world, posit.m_x, posit.m_z) + 5.0f; InitEyePoint (dVector (1.0f, 0.0f, 0.0f), posit); // create a material carrier to colliding with this objects int defaultMaterialID; int magneticFieldID; int magneticPicesID; defaultMaterialID = NewtonMaterialGetDefaultGroupID (world); magneticFieldID = NewtonMaterialCreateGroupID (world); magneticPicesID = NewtonMaterialCreateGroupID (world); NewtonMaterialSetCollisionCallback (world, magneticPicesID, magneticFieldID, NULL, NULL, Magnet::MagneticField); // create a spherical object to serve are the magnet core dMatrix matrix (GetIdentityMatrix()); matrix.m_posit = posit; matrix.m_posit.m_x += 7.0f; new Magnet (system, matrix, 20.0f, defaultMaterialID, magneticFieldID, strength); // add a material to control the buoyancy dVector size (1.0f, 0.25f, 0.5f); dVector sphSize (1.0f, 1.0f, 1.0f); dVector capSize (1.25f, 0.4f, 1.0f); dVector location (cameraEyepoint + cameraDir.Scale (10.0f)); AddBoxes (&system, 1.0f, location, sphSize, 3, 3, 5.0f, _SPHERE_PRIMITIVE, magneticPicesID); AddBoxes (&system, 1.0f, location, size, 3, 3, 5.0f, _BOX_PRIMITIVE, magneticPicesID); AddBoxes (&system, 1.0f, location, size, 3, 3, 5.0f, _CONE_PRIMITIVE, magneticPicesID); AddBoxes (&system, 1.0f, location, size, 3, 3, 5.0f, _CYLINDER_PRIMITIVE, magneticPicesID); AddBoxes (&system, 1.0f, location, capSize, 3, 3, 5.0f, _CAPSULE_PRIMITIVE, magneticPicesID); AddBoxes (&system, 1.0f, location, size, 3, 3, 5.0f, _CHAMFER_CYLINDER_PRIMITIVE, magneticPicesID); AddBoxes (&system, 1.0f, location, size, 3, 3, 5.0f, _RANDOM_CONVEX_HULL_PRIMITIVE, magneticPicesID); AddBoxes (&system, 1.0f, location, size, 3, 3, 5.0f, _REGULAR_CONVEX_HULL_PRIMITIVE, magneticPicesID); posit.m_x -= 10.0f; InitEyePoint (dVector (1.0f, 0.0f, 0.0f), posit); }
void CompoundCollision (DemoEntityManager* const scene) { // load the skybox scene->CreateSkyBox(); // load the scene from a ngd file format // CreateLevelMesh (scene, "flatPlane.ngd", true); // CreateLevelMesh (scene, "playground.ngd", true); // CreateLevelMesh (scene, "sponza.ngd", true); CreateHeightFieldTerrain(scene, HEIGHTFIELD_DEFAULT_SIZE, HEIGHTFIELD_DEFAULT_CELLSIZE, 1.5f, 0.2f, 200.0f, -50.0f); int defaultMaterialID = NewtonMaterialGetDefaultGroupID (scene->GetNewton()); // set a material callback to get the colliding shape NewtonMaterialSetCollisionCallback (scene->GetNewton(), defaultMaterialID, defaultMaterialID, NULL, OnGettingTheCollisionSubShapeFromMaterialCallback); NewtonMaterialSetCompoundCollisionCallback(scene->GetNewton(), defaultMaterialID, defaultMaterialID, OnSubShapeAABBOverlapTest); dMatrix camMatrix (dRollMatrix(-20.0f * 3.1416f /180.0f) * dYawMatrix(-45.0f * 3.1416f /180.0f)); dQuaternion rot (camMatrix); dVector origin (100.0f, 0.0f, 100.0f, 0.0f); dFloat hight = 1000.0f; origin = FindFloor (scene->GetNewton(), dVector (origin.m_x, hight, origin .m_z, 0.0f), hight * 2); origin.m_y += 10.0f; dVector location (origin); location.m_x += 40.0f; location.m_z += 40.0f; // this crash temporarily (I need to make the compound use shape Instance) MakeFunnyCompound (scene, location); int count = 5; dVector size (0.5f, 0.5f, 0.75f, 0.0f); dMatrix shapeOffsetMatrix (dGetIdentityMatrix()); AddPrimitiveArray(scene, 10.0f, location, size, count, count, 5.0f, _BOX_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix); AddPrimitiveArray(scene, 10.0f, location, size, count, count, 5.0f, _BOX_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix); AddPrimitiveArray(scene, 10.0f, location, size, count, count, 5.0f, _CAPSULE_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix); AddPrimitiveArray(scene, 10.0f, location, size, count, count, 5.0f, _CYLINDER_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix); AddPrimitiveArray(scene, 10.0f, location, size, count, count, 5.0f, _CONE_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix); // place camera into position // dQuaternion rot; // dVector origin (-40.0f, 10.0f, 0.0f, 0.0f); scene->SetCameraMatrix(rot, origin); //ExportScene (scene->GetNewton(), "../../../media/test1.ngd"); }
int FindFloor(TNode* root,int data){ if(!root){ return 0; } int right; if(root->data==data){ return root->data; }else if(root->data<data){ right=FindFloor(root->right,data); //printf("\nright : %d",right); if(right){ return right; }else{ return root->data; } }else{ return FindFloor(root->left,data); } }
void BasicPlayerController (DemoEntityManager* const scene) { // load the sky box scene->CreateSkyBox(); //CreateLevelMesh (scene, "flatPlane.ngd", true); //CreateLevelMesh (scene, "playground.ngd", true); CreateLevelMesh (scene, "castle.ngd", true); //CreateLevelMesh (scene, "sponza.ngd", true); //CreateLevelMesh (scene, "sibenik.ngd", true); NewtonWorld* const world = scene->GetNewton(); // add an input Manage to manage the inputs and user interaction BasicPlayerInputManager* const inputManager = new BasicPlayerInputManager (scene); // create a character controller manager BasicPlayerControllerManager* const playerManager = new BasicPlayerControllerManager (world); // add main player dMatrix location (dGetIdentityMatrix()); location.m_posit.m_x = -4.0f; location.m_posit.m_y = 5.0f; location.m_posit.m_z = 0.0f; location.m_posit.m_x = 98.710999f; location.m_posit.m_y =-0.96156919f; location.m_posit.m_z = 27.254711f; location.m_posit = FindFloor (scene->GetNewton(), location.m_posit, 10.0f); BasicPlayerEntity* const player = new BasicPlayerEntity (scene, playerManager, 0.5f, 1.9f, location); // set as the player with the camera inputManager->AddPlayer(player); int defaultMaterialID = NewtonMaterialGetDefaultGroupID (scene->GetNewton()); location.m_posit.m_x += 5.0f; dVector size (2.0f, 2.0f, 2.0f, 0.0f); int count = 1; dMatrix shapeOffsetMatrix (dGetIdentityMatrix()); AddPrimitiveArray(scene, 100.0f, location.m_posit, size, count, count, 5.0f, _BOX_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix, 10.0f); dVector origin (-10.0f, 2.0f, 0.0f, 0.0f); dQuaternion rot; scene->SetCameraMatrix(rot, origin); }
static void AddNonUniformScaledPrimitives(DemoEntityManager* const scene, dFloat mass, const dVector& origin, const dVector& size, int xCount, int zCount, dFloat spacing, PrimitiveType type, int materialID, const dMatrix& shapeOffsetMatrix) { // create the shape and visual mesh as a common data to be re used NewtonWorld* const world = scene->GetNewton(); // NewtonCollision* const collision = CreateConvexCollision (world, &shapeOffsetMatrix[0][0], size, type, materialID); NewtonCollision* const collision = CreateConvexCollision(world, dGetIdentityMatrix(), size, type, materialID); dFloat startElevation = 1000.0f; dMatrix matrix(dGetIdentityMatrix()); //matrix = dPitchMatrix(-45.0f * 3.141592f/180.0f); for (int i = 0; i < xCount; i++) { dFloat x = origin.m_x + (i - xCount / 2) * spacing; for (int j = 0; j < zCount; j++) { dFloat scalex = 1.0f + 1.5f * (dFloat(dRand()) / dFloat(dRAND_MAX) - 0.5f); dFloat scaley = 1.0f + 1.5f * (dFloat(dRand()) / dFloat(dRAND_MAX) - 0.5f); dFloat scalez = 1.0f + 1.5f * (dFloat(dRand()) / dFloat(dRAND_MAX) - 0.5f); dFloat z = origin.m_z + (j - zCount / 2) * spacing; matrix.m_posit.m_x = x; matrix.m_posit.m_z = z; dVector floor(FindFloor(world, dVector(matrix.m_posit.m_x, startElevation, matrix.m_posit.m_z, 0.0f), 2.0f * startElevation)); matrix.m_posit.m_y = floor.m_y + 8.0f; // create a solid //NewtonBody* const body = CreateSimpleSolid (scene, geometry, mass, matrix, collision, materialID); NewtonBody* const body = CreateSimpleSolid(scene, NULL, mass, matrix, collision, materialID); DemoEntity* entity = (DemoEntity*)NewtonBodyGetUserData(body); NewtonCollisionSetScale(collision, scalex, scaley, scalez); DemoMesh* const geometry = new DemoMesh("cylinder_1", collision, "smilli.tga", "smilli.tga", "smilli.tga"); entity->SetMesh(geometry, dGetIdentityMatrix()); NewtonBodySetCollisionScale(body, scalex, scaley, scalez); dVector omega(0.0f); NewtonBodySetOmega(body, &omega[0]); // release the mesh geometry->Release(); } } // do not forget to delete the collision NewtonDestroyCollision(collision); }
void AnimatedPlayerController(DemoEntityManager* const scene) { // load the sky box scene->CreateSkyBox(); //CreateLevelMesh(scene, "flatPlane.ngd", true); CreateLevelMesh (scene, "playerarena.ngd", true); //CreateHeightFieldTerrain(scene, 10, 2.0f, 1.5f, 0.3f, 200.0f, -50.0f); NewtonWorld* const world = scene->GetNewton(); // create a character controller manager AnimatedPlayerControllerManager* const playerManager = new AnimatedPlayerControllerManager(world); // add main player dMatrix location(dGetIdentityMatrix()); location.m_posit.m_x = 30.0f; location.m_posit.m_y = 5.0f; location.m_posit.m_z = -24.0f; location.m_posit.m_y = 15.0f; location.m_posit = FindFloor(scene->GetNewton(), location.m_posit, 20.0f); location.m_posit.m_y += 1.0f; dCustomPlayerController* const player = playerManager->CreatePlayer(location, 1.8f, 0.3f, 100.0f); playerManager->SetAsPlayer(player); // int defaultMaterialID = NewtonMaterialGetDefaultGroupID(scene->GetNewton()); location.m_posit.m_x += 5.0f; //int count = 1; //dMatrix shapeOffsetMatrix(dGetIdentityMatrix()); //AddPrimitiveArray(scene, 100.0f, location.m_posit, dVector (2.0f, 2.0f, 2.0f, 0.0f), count, count, 5.0f, _BOX_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix, 10.0f); // add some objects to interact with AddMerryGoRound(scene, dVector(40.0f, 0.0f, -15.0f, 0.0f)); location.m_posit.m_x += 5.0f; // AddPrimitiveArray(scene, 100.0f, location.m_posit, dVector(2.0f, 0.5f, 2.0f, 0.0f), count, count, 5.0f, _BOX_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix, 10.0f); dVector origin(-10.0f, 2.0f, 0.0f, 0.0f); dQuaternion rot; scene->SetCameraMatrix(rot, origin); }
// calculate the height at the location 'x, z' in meters // F32 HeightField::FindFloor( F32 x, F32 z, Vector * surfNormal) // = NULL { x += offsetX; z += offsetZ; #if DEVELOPMENT ASSERT( x >= 0.0f && x < (F32) meterWidth && z >= 0.0f && z < (F32) meterHeight); #else // clamp coords // if (x < 0.0f) { x = 0; } else if (x >= (F32) meterWidth) { x = meterWidth - .1f; } if (z < 0.0f) { z = 0; } else if (z >= (F32) meterHeight) { z = meterHeight - .1f; } #endif // trunc mode is the default // S32 cx = Utils::FtoL(x * cellPerMeter); S32 cz = Utils::FtoL(z * cellPerMeter); U32 offset = (U32) (cz * cellPitch + cx); F32 heights[4]; CellHeights( offset, heights); F32 dx = x - ((F32) cx * (F32) meterPerCell); F32 dz = z - ((F32) cz * (F32) meterPerCell); return FindFloor( heights, dx, dz, surfNormal); }
void SimplePlaneCollision (NewtonFrame& system) { NewtonWorld* world; LevelPrimitive *level; NewtonCollision* planeColl; world = system.m_world; // create a material carrier to collision with this object int defaultMaterialID; defaultMaterialID = NewtonMaterialGetDefaultGroupID (world); // create the sky box and the floor, level = LoadLevelAndSceneRoot (system, "flatplane.dae", 1); // Find the world mesh and replace the collision for a custom plane collision mesh dMatrix matrix; NewtonBodyGetMatrix (level->m_level, &matrix[0][0]); dVector plane (matrix.m_up); plane.m_w = - (plane % matrix.m_posit); planeColl = CreatePlaneCollidion (world, plane); NewtonBodySetCollision(level->m_level, planeColl); NewtonReleaseCollision(world, planeColl); dVector posit (0.0f, 0.0f, 0.0f, 0.0f); posit.m_y = FindFloor (world, posit.m_x, posit.m_z) + 5.0f; InitEyePoint (dVector (1.0f, 0.0f, 0.0f), posit); dVector size (1.0f, 1.0f, 1.0f); dVector location (cameraEyepoint + cameraDir.Scale (10.0f)); AddBoxes (&system, 10.0f, location, size, 3, 3, 10.0f, _SPHERE_PRIMITIVE, defaultMaterialID); AddBoxes (&system, 10.0f, location, size, 3, 3, 10.0f, _BOX_PRIMITIVE, defaultMaterialID); AddBoxes (&system, 10.0f, location, size, 3, 3, 10.0f, _CONE_PRIMITIVE, defaultMaterialID); AddBoxes (&system, 10.0f, location, size, 3, 3, 10.0f, _CYLINDER_PRIMITIVE, defaultMaterialID); AddBoxes (&system, 10.0f, location, size, 3, 3, 10.0f, _CAPSULE_PRIMITIVE, defaultMaterialID); AddBoxes (&system, 10.0f, location, size, 3, 3, 10.0f, _CHAMFER_CYLINDER_PRIMITIVE, defaultMaterialID); AddBoxes (&system, 10.0f, location, size, 3, 3, 10.0f, _RANDOM_CONVEX_HULL_PRIMITIVE, defaultMaterialID); AddBoxes (&system, 10.0f, location, size, 3, 3, 10.0f, _REGULAR_CONVEX_HULL_PRIMITIVE, defaultMaterialID); }
static void AddFracturedPrimitive(DemoEntityManager* const scene, dFloat mass, const dVector& origin, const dVector& size, int xCount, int zCount, dFloat spacing, PrimitiveType type, int materialID, const dMatrix& shapeOffsetMatrix) { // create the shape and visual mesh as a common data to be re used NewtonWorld* const world = scene->GetNewton(); NewtonCollision* const collision = CreateConvexCollision(world, shapeOffsetMatrix, size, type, materialID); // create a newton mesh from the collision primitive NewtonMesh* const mesh = NewtonMeshCreateFromCollision(collision); // apply a material map int externalMaterial = LoadTexture("reljef.tga"); //int internalMaterial = LoadTexture("KAMEN-stup.tga"); int internalMaterial = LoadTexture("concreteBrick.tga"); dMatrix aligmentUV(dGetIdentityMatrix()); NewtonMeshApplyBoxMapping(mesh, externalMaterial, externalMaterial, externalMaterial, &aligmentUV[0][0]); // create a newton mesh from the collision primitive VoronoidEffect fracture(world, mesh, internalMaterial); DemoMesh* const visualMesh = new DemoMesh(mesh); dFloat startElevation = 100.0f; dMatrix matrix(dGetIdentityMatrix()); for (int i = 0; i < xCount; i++) { dFloat x = origin.m_x + (i - xCount / 2) * spacing; for (int j = 0; j < zCount; j++) { dFloat z = origin.m_z + (j - zCount / 2) * spacing; matrix.m_posit.m_x = x; matrix.m_posit.m_z = z; dVector floor(FindFloor(world, dVector(matrix.m_posit.m_x, startElevation, matrix.m_posit.m_z, 0.0f), 2.0f * startElevation)); matrix.m_posit.m_y = floor.m_y + 1.0f; SimpleFracturedEffectEntity::AddFracturedEntity(scene, visualMesh, collision, fracture, matrix.m_posit); } } // do not forget to release the assets NewtonMeshDestroy(mesh); visualMesh->Release(); NewtonDestroyCollision(collision); }
static void AddShatterPrimitive (DemoEntityManager* const scene, dFloat mass, const dVector& origin, const dVector& size, int xCount, int zCount, dFloat spacing, PrimitiveType type, int materialID) { dMatrix matrix (GetIdentityMatrix()); // create the shape and visual mesh as a common data to be re used NewtonWorld* const world = scene->GetNewton(); NewtonCollision* const collision = CreateConvexCollision (world, GetIdentityMatrix(), size, type, materialID); // create a newton mesh from the collision primitive NewtonMesh* const mesh = NewtonMeshCreateFromCollision(collision); // apply a material map int externalMaterial = LoadTexture("reljef.tga"); int internalMaterial = LoadTexture("KAMEN-stup.tga"); NewtonMeshApplyBoxMapping(mesh, externalMaterial, externalMaterial, externalMaterial); // create a newton mesh from the collision primitive ShatterEffect shatter (world, mesh, internalMaterial); DemoMesh* const visualMesh = new DemoMesh(mesh); for (int i = 0; i < xCount; i ++) { dFloat x = origin.m_x + (i - xCount / 2) * spacing; for (int j = 0; j < zCount; j ++) { dFloat z = origin.m_z + (j - zCount / 2) * spacing; matrix.m_posit.m_x = x; matrix.m_posit.m_z = z; matrix.m_posit.m_y = FindFloor (world, x, z) + 4.0f; AddShatterEntity (scene, visualMesh, collision, shatter, matrix.m_posit); } } // do not forget to release the assets NewtonMeshDestroy (mesh); visualMesh->Release(); NewtonReleaseCollision(world, collision); }
int main(){ printf("\nEnter the no of nodes you want to insert : "); int n; scanf("%d",&n); int i,data; TNode* root=NULL; for(i=0;i<n;i++){ printf("\nEnter data for %d node : ",i); scanf("%d",&data); Insert(&root,data); } printf("\n%d nodes inserted in BST\n",i); getch(); printf("\nEnter a number to find ceiling of : "); scanf("%d",&data); TNode* Ceil=NULL; int isSet=0; FindCeil(root,&Ceil,&isSet,data); if(Ceil){ printf("\n\nCeil of %d is : %d",data,Ceil->data); } else{ printf("\nCeil doesnot exist"); } getch(); printf("\nEnter a number to find floor of : "); scanf("%d",&data); TNode* Floor=NULL; isSet=0; FindFloor(root,&Floor,&isSet,data); if(Floor){ printf("\n\Floor of %d is : %d",data,Floor->data); } else{
void UserHeightFieldCollision (DemoEntityManager* const scene) { // load the sky box scene->CreateSkyBox(); CreateHeightFieldTerrain(scene, HEIGHTFIELD_DEFAULT_SIZE, HEIGHTFIELD_DEFAULT_CELLSIZE, 1.5f, 0.2f, 200.0f, -50.0f); dMatrix camMatrix (dRollMatrix(-20.0f * dDegreeToRad) * dYawMatrix(-45.0f * dDegreeToRad)); dQuaternion rot (camMatrix); dVector origin (250.0f, 0.0f, 250.0f, 0.0f); dFloat height = 1000.0f; origin = FindFloor (scene->GetNewton(), dVector (origin.m_x, height, origin .m_z, 0.0f), height * 2); origin.m_y += 10.0f; scene->SetCameraMatrix(rot, origin); int defaultMaterialID = NewtonMaterialGetDefaultGroupID (scene->GetNewton()); dVector location (origin); location.m_x += 20.0f; location.m_z += 20.0f; dVector size (0.5f, 0.5f, 0.75f, 0.0f); int count = 5; // int count = 1; dMatrix shapeOffsetMatrix (dGetIdentityMatrix()); AddPrimitiveArray(scene, 10.0f, location, size, count, count, 5.0f, _SPHERE_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix); AddPrimitiveArray(scene, 10.0f, location, size, count, count, 5.0f, _BOX_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix); AddPrimitiveArray(scene, 10.0f, location, size, count, count, 5.0f, _CAPSULE_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix); AddPrimitiveArray(scene, 10.0f, location, size, count, count, 5.0f, _CYLINDER_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix); AddPrimitiveArray(scene, 10.0f, location, size, count, count, 5.0f, _CONE_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix); AddPrimitiveArray(scene, 10.0f, location, size, count, count, 5.0f, _CHAMFER_CYLINDER_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix); AddPrimitiveArray(scene, 10.0f, location, size, count, count, 5.0f, _REGULAR_CONVEX_HULL_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix); AddPrimitiveArray(scene, 10.0f, location, size, count, count, 5.0f, _RANDOM_CONVEX_HULL_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix); AddPrimitiveArray(scene, 10.0f, location, size, count, count, 5.0f, _COMPOUND_CONVEX_CRUZ_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix); }
void CreateScene (NewtonWorld* world, SceneManager* sceneManager) { Entity* floor; NewtonCollision* shape; NewtonBody* floorBody; void* materialManager; SoundManager* sndManager; PhysicsMaterialInteration matInterations; sndManager = sceneManager->GetSoundManager(); // Create the material for this scene, and attach it to the Newton World materialManager = CreateMaterialManager (world, sndManager); // add the Material table matInterations.m_restitution = 0.6f; matInterations.m_staticFriction = 0.6f; matInterations.m_kineticFriction = 0.3f; matInterations.m_scrapingSound = NULL; matInterations.m_impactSound = sndManager->LoadSound ("metalMetal.wav"); AddMaterilInteraction (materialManager, m_metal, m_metal, &matInterations); matInterations.m_impactSound = sndManager->LoadSound ("boxBox.wav"); AddMaterilInteraction (materialManager, m_wood, m_wood, &matInterations); matInterations.m_impactSound = sndManager->LoadSound ("metalBox.wav"); AddMaterilInteraction (materialManager, m_metal, m_wood, &matInterations); matInterations.m_impactSound = sndManager->LoadSound ("grass0.wav"); AddMaterilInteraction (materialManager, m_wood, m_grass, &matInterations); matInterations.m_impactSound = sndManager->LoadSound ("boxHit.wav"); AddMaterilInteraction (materialManager, m_wood, m_bricks, &matInterations); matInterations.m_impactSound = sndManager->LoadSound ("grass1.wav"); AddMaterilInteraction (materialManager, m_metal, m_grass, &matInterations); AddMaterilInteraction (materialManager, m_grass, m_bricks, &matInterations); matInterations.m_impactSound = sndManager->LoadSound ("metal.wav"); AddMaterilInteraction (materialManager, m_metal, m_bricks, &matInterations); AddMaterilInteraction (materialManager, m_grass, m_grass, &matInterations); // Create a large body to be the floor floor = sceneManager->CreateEntity(); floor->LoadMesh ("LevelMesh.dat"); // add static floor Physics int materialMap[] = {m_bricks, m_grass, m_wood, m_metal}; shape = CreateMeshCollision (world, floor, materialMap); floorBody = CreateRigidBody (world, floor, shape, 0.0f); NewtonReleaseCollision (world, shape); // set the Transformation Matrix for this rigid body dMatrix matrix (floor->m_curRotation, floor->m_curPosition); NewtonBodySetMatrix (floorBody, &matrix[0][0]); // now we will use the properties of this body to set a proper world size. dVector minBox; dVector maxBox; NewtonCollisionCalculateAABB (shape, &matrix[0][0], &minBox[0], &maxBox[0]); // add some extra padding minBox.m_x -= 50.0f; minBox.m_y -= 500.0f; minBox.m_z -= 50.0f; maxBox.m_x += 50.0f; maxBox.m_y += 500.0f; maxBox.m_z += 50.0f; // set the new world size NewtonSetWorldSize (world, &minBox[0], &maxBox[0]); // add some visual entities. dFloat y0 = FindFloor (world, 0.0f, 0.0f) + 10.0f; for (int i = 0; i < 5; i ++) { Entity* smilly; NewtonBody* smillyBody; smilly = sceneManager->CreateEntity(); smilly->LoadMesh ("Smilly.dat"); smilly->m_curPosition.m_y = y0; y0 += 2.0f; smilly->m_prevPosition = smilly->m_curPosition; // add a body with a box shape shape = CreateNewtonBox (world, smilly, m_metal); smillyBody = CreateRigidBody (world, smilly, shape, 10.0f); NewtonReleaseCollision (world, shape); } // add some visual entities. y0 = FindFloor (world, 0.0f, 0.4f) + 10.5f; for (int i = 0; i < 5; i ++) { Entity* frowny; NewtonBody* frownyBody; frowny = sceneManager->CreateEntity(); frowny->LoadMesh ("Frowny.dat"); frowny->m_curPosition.m_z = 0.4f; frowny->m_curPosition.m_y = y0; y0 += 2.0f; frowny->m_prevPosition = frowny->m_curPosition; // add a body with a Convex hull shape shape = CreateNewtonConvex (world, frowny, m_wood); frownyBody = CreateRigidBody (world, frowny, shape, 10.0f); NewtonReleaseCollision (world, shape); } y0 = FindFloor (world, 0.0f, 2.0f) + 10.5f; for (int i = 0; i < 5; i ++) { Entity* frowny; NewtonBody* frownyBody; frowny = sceneManager->CreateEntity(); frowny->LoadMesh ("dumb.dat"); frowny->m_curPosition.m_z = 2.0f; frowny->m_curPosition.m_y = y0; y0 += 2.0f; frowny->m_prevPosition = frowny->m_curPosition; // add a body with a Convex hull shape int materialMap[] = {m_grass, m_wood, m_metal, m_metal}; shape = CreateNewtonCompoundFromEntitySubmesh (world, frowny, materialMap); frownyBody = CreateRigidBody (world, frowny, shape, 10.0f); NewtonReleaseCollision (world, shape); } // set the Camera EyePoint close to the scene action InitCamera (dVector (-15.0f, FindFloor (world, -15.0f, 0.0f) + 5.0f, 0.0f), dVector (1.0f, 0.0f, 0.0f)); }
void Restitution (DemoEntityManager* const scene) { scene->CreateSkyBox(); // customize the scene after loading // set a user friction variable in the body for variable friction demos // later this will be done using LUA script NewtonWorld* const world = scene->GetNewton(); dMatrix offsetMatrix (dGetIdentityMatrix()); int defaultMaterialID = NewtonMaterialGetDefaultGroupID (world); NewtonMaterialSetCollisionCallback (world, defaultMaterialID, defaultMaterialID, NULL, UserContactRestitution); CreateLevelMesh (scene, "flatPlane.ngd", 0); dVector location (0.0f, 0.0f, 0.0f, 0.0f); dVector size (0.5f, 0.5f, 1.0f, 0.0f); // create some spheres dVector sphSize (1.0f, 1.0f, 1.0f, 0.0f); NewtonCollision* const sphereCollision = CreateConvexCollision (world, offsetMatrix, sphSize, _SPHERE_PRIMITIVE, 0); DemoMesh* const sphereMesh = new DemoMesh("sphere", sphereCollision, "smilli.tga", "smilli.tga", "smilli.tga"); // create some boxes too dVector boxSize (1.0f, 0.5f, 2.0f, 0.0f); NewtonCollision* const boxCollision = CreateConvexCollision (world, offsetMatrix, boxSize, _BOX_PRIMITIVE, 0); DemoMesh* const boxMesh = new DemoMesh("box", boxCollision, "smilli.tga", "smilli.tga", "smilli.tga"); int zCount = 10; dFloat spacing = 4.0f; dMatrix matrix (dGetIdentityMatrix()); dVector origin (matrix.m_posit); origin.m_x -= 0.0f; // create a simple scene for (int i = 0; i < zCount; i ++) { dFloat z; dFloat x; dFloat mass; dVector size (1.0f, 0.5f, 2.0f, 0.0f); x = origin.m_x; z = origin.m_z + (i - zCount / 2) * spacing; mass = 1.0f; matrix.m_posit = FindFloor (world, dVector (x, 100.0f, z), 200.0f); matrix.m_posit.m_w = 1.0f; float restitution; NewtonBody* body; NewtonCollision* collision; matrix.m_posit.m_y += 4.0f; body = CreateSimpleSolid (scene, sphereMesh, mass, matrix, sphereCollision, defaultMaterialID); NewtonBodySetLinearDamping (body, 0.0f); collision = NewtonBodyGetCollision(body); restitution = i * 0.1f + 0.083f; NewtonCollisionSetUserData (collision, *((void**)&restitution)); matrix.m_posit.m_y += 4.0f; //body = CreateSimpleSolid (scene, sphereMesh, mass, matrix, sphereCollision, defaultMaterialID, shapeOffsetMatrix); body = CreateSimpleSolid (scene, boxMesh, mass, matrix, boxCollision, defaultMaterialID); NewtonBodySetLinearDamping (body, 0.0f); collision = NewtonBodyGetCollision(body); restitution = i * 0.1f + 0.083f; NewtonCollisionSetUserData (collision, *((void**)&restitution)); matrix.m_posit.m_y += 4.0f; body = CreateSimpleSolid (scene, sphereMesh, mass, matrix, sphereCollision, defaultMaterialID); NewtonBodySetLinearDamping (body, 0.0f); collision = NewtonBodyGetCollision(body); restitution = i * 0.1f + 0.083f; NewtonCollisionSetUserData (collision, *((void**)&restitution)); matrix.m_posit.m_y += 4.0f; dVector boxSize (1.0f, 0.5f, 2.0f, 0.0f); body = CreateSimpleSolid (scene, boxMesh, mass, matrix, boxCollision, defaultMaterialID); NewtonBodySetLinearDamping (body, 0.0f); collision = NewtonBodyGetCollision(body); restitution = i * 0.1f + 0.083f; NewtonCollisionSetUserData (collision, *((void**)&restitution)); } boxMesh->Release(); sphereMesh->Release(); NewtonDestroyCollision(boxCollision); NewtonDestroyCollision(sphereCollision); dMatrix camMatrix (dGetIdentityMatrix()); dQuaternion rot (camMatrix); origin = dVector (-25.0f, 5.0f, 0.0f, 0.0f); scene->SetCameraMatrix(rot, origin); }