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