void ScaledMeshCollision (DemoEntityManager* const scene)
{
// load the skybox
scene->CreateSkyBox();
// load the scene from a ngd file format
CreateLevelMesh (scene, "flatPlane.ngd", 1);
//CreateLevelMesh (scene, "flatPlaneDoubleFace.ngd", 1);
//CreateLevelMesh (scene, "sponza.ngd", 0);
//CreateLevelMesh (scene, "cattle.ngd", fileName);
//CreateLevelMesh (scene, "playground.ngd", 0);
//dMatrix camMatrix (dRollMatrix(-20.0f * 3.1416f /180.0f) * dYawMatrix(-45.0f * 3.1416f /180.0f));
dMatrix camMatrix (dGetIdentityMatrix());
dQuaternion rot (camMatrix);
dVector origin (-15.0f, 5.0f, 0.0f, 0.0f);
//origin = origin.Scale (0.25f);
scene->SetCameraMatrix(rot, origin);
NewtonWorld* const world = scene->GetNewton();
int defaultMaterialID = NewtonMaterialGetDefaultGroupID (world);
dVector location (0.0f, 0.0f, 0.0f, 0.0f);
dMatrix matrix (dGetIdentityMatrix());
matrix.m_posit = location;
matrix.m_posit.m_x = 0.0f;
matrix.m_posit.m_y = 0.0f;
matrix.m_posit.m_z = 0.0f;
matrix.m_posit.m_w = 1.0f;
DemoEntity teaPot (dGetIdentityMatrix(), NULL);
teaPot.LoadNGD_mesh("teapot.ngd", world);
//teaPot.LoadNGD_mesh("box.ngd", world);
NewtonCollision* const staticCollision = CreateCollisionTree (world, &teaPot, 0, true);
CreateScaleStaticMesh (&teaPot, staticCollision, scene, matrix, dVector (1.0f, 1.0f, 1.0f, 0.0f));
// CreateScaleStaticMesh (&teaPot, staticCollision, scene, matrix, dVector (0.5f, 0.5f, 2.0f, 0.0f));
matrix.m_posit.m_z = -5.0f;
CreateScaleStaticMesh (&teaPot, staticCollision, scene, matrix, dVector (0.5f, 0.5f, 2.0f, 0.0f));
matrix.m_posit.m_z = 5.0f;
CreateScaleStaticMesh (&teaPot, staticCollision, scene, matrix, dVector (3.0f, 3.0f, 1.5f, 0.0f));
matrix.m_posit.m_z = 0.0f;
matrix.m_posit.m_x = -5.0f;
CreateScaleStaticMesh (&teaPot, staticCollision, scene, matrix, dVector (0.5f, 0.5f, 0.5f, 0.0f));
matrix.m_posit.m_x = 5.0f;
CreateScaleStaticMesh (&teaPot, staticCollision, scene, matrix, dVector (2.0f, 2.0f, 2.0f, 0.0f));
// do not forget to destroy the collision mesh helper
NewtonDestroyCollision(staticCollision);
dVector size0 (1.0f, 1.0f, 1.0f, 0.0f);
dVector size1 (0.5f, 1.0f, 1.0f, 0.0f);
dMatrix shapeOffsetMatrix (dRollMatrix(3.141592f/2.0f));
int count = 3;
AddNonUniformScaledPrimitives(scene, 10.0f, location, size0, count, count, 5.0f, _SPHERE_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddNonUniformScaledPrimitives(scene, 10.0f, location, size0, count, count, 5.0f, _BOX_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddNonUniformScaledPrimitives(scene, 10.0f, location, size0, count, count, 5.0f, _CAPSULE_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddNonUniformScaledPrimitives(scene, 10.0f, location, size1, count, count, 5.0f, _CAPSULE_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddNonUniformScaledPrimitives(scene, 10.0f, location, size1, count, count, 5.0f, _CYLINDER_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddNonUniformScaledPrimitives(scene, 10.0f, location, size0, count, count, 5.0f, _CYLINDER_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddNonUniformScaledPrimitives(scene, 10.0f, location, size0, count, count, 5.0f, _CHAMFER_CYLINDER_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddNonUniformScaledPrimitives(scene, 10.0f, location, size0, count, count, 5.0f, _CONE_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddNonUniformScaledPrimitives(scene, 10.0f, location, size0, count, count, 5.0f, _REGULAR_CONVEX_HULL_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddNonUniformScaledPrimitives(scene, 10.0f, location, size0, count, count, 5.0f, _RANDOM_CONVEX_HULL_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
origin.m_x -= 4.0f;
origin.m_y += 1.0f;
scene->SetCameraMatrix(rot, origin);
}
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);
}
void Physics::setupMaterials()
{
assert( _p_world );
// get the default material ID
int defaultID = NewtonMaterialGetDefaultGroupID( _p_world );
// set default material properties
NewtonMaterialSetDefaultSoftness( _p_world, defaultID, defaultID, 0.05f );
NewtonMaterialSetDefaultElasticity( _p_world, defaultID, defaultID, 0.4f );
NewtonMaterialSetDefaultCollidable( _p_world, defaultID, defaultID, 1 );
NewtonMaterialSetDefaultFriction( _p_world, defaultID, defaultID, 1.0f, 0.5f );
NewtonMaterialSetCollisionCallback( _p_world, defaultID, defaultID, &defaultCollStruct, genericContactBegin, genericContactProcess, genericContactEnd );
// create all predefined materials IDs
int nocolID = NewtonMaterialCreateGroupID( _p_world );
int wallID = NewtonMaterialCreateGroupID( _p_world );
int levelID = NewtonMaterialCreateGroupID( _p_world );
int woodID = NewtonMaterialCreateGroupID( _p_world );
int metalID = NewtonMaterialCreateGroupID( _p_world );
int stoneID = NewtonMaterialCreateGroupID( _p_world );
int grassID = NewtonMaterialCreateGroupID( _p_world );
_materials.insert( std::make_pair( "default", defaultID ) );
_materials.insert( std::make_pair( "wall" , wallID ) );
_materials.insert( std::make_pair( "nocol" , nocolID ) );
_materials.insert( std::make_pair( "level" , levelID ) );
_materials.insert( std::make_pair( "wood" , woodID ) );
_materials.insert( std::make_pair( "metal" , metalID ) );
_materials.insert( std::make_pair( "stone" , stoneID ) );
_materials.insert( std::make_pair( "grass" , grassID ) );
// set non-colliding pairs
NewtonMaterialSetDefaultCollidable( _p_world, nocolID, defaultID, 0 );
NewtonMaterialSetDefaultCollidable( _p_world, nocolID, wallID, 0 );
NewtonMaterialSetDefaultCollidable( _p_world, nocolID, levelID, 0 );
NewtonMaterialSetDefaultCollidable( _p_world, nocolID, woodID, 0 );
NewtonMaterialSetDefaultCollidable( _p_world, nocolID, metalID, 0 );
NewtonMaterialSetDefaultCollidable( _p_world, nocolID, grassID, 0 );
NewtonMaterialSetDefaultCollidable( _p_world, nocolID, stoneID, 0 );
// set the material properties for level on wood
NewtonMaterialSetDefaultElasticity( _p_world, levelID, woodID, 0.5f );
NewtonMaterialSetDefaultFriction ( _p_world, levelID, woodID, 0.7f, 0.6f);
NewtonMaterialSetCollisionCallback( _p_world, levelID, woodID, &level_woodCollStruct, genericContactBegin, levelContactProcess, genericContactEnd );
// set the material properties for level on metal
NewtonMaterialSetDefaultElasticity( _p_world, levelID, metalID, 0.5f );
NewtonMaterialSetDefaultFriction ( _p_world, levelID, metalID, 0.8f, 0.6f );
NewtonMaterialSetCollisionCallback( _p_world, levelID, metalID, &level_metalCollStruct, genericContactBegin, levelContactProcess, genericContactEnd );
// set the material properties for level on grass
NewtonMaterialSetDefaultElasticity( _p_world, levelID, grassID, 0.3f );
NewtonMaterialSetDefaultFriction ( _p_world, levelID, grassID, 0.9f, 0.7f );
NewtonMaterialSetCollisionCallback( _p_world, levelID, grassID, &level_grassCollStruct, genericContactBegin, levelContactProcess, genericContactEnd );
// set the material properties for level on stone
NewtonMaterialSetDefaultElasticity( _p_world, levelID, stoneID, 0.45f );
NewtonMaterialSetDefaultFriction ( _p_world, levelID, stoneID, 0.8f, 0.7f );
NewtonMaterialSetCollisionCallback( _p_world, levelID, stoneID, &level_stoneCollStruct, genericContactBegin, levelContactProcess, genericContactEnd );
//------
// set the material properties for wood on wood
NewtonMaterialSetDefaultElasticity( _p_world, woodID, woodID, 0.3f );
NewtonMaterialSetDefaultFriction ( _p_world, woodID, woodID, 1.1f, 0.7f);
NewtonMaterialSetCollisionCallback( _p_world, woodID, woodID, &wood_woodCollStruct, genericContactBegin, genericContactProcess, genericContactEnd );
// set the material properties for wood on metal
NewtonMaterialSetDefaultElasticity( _p_world, woodID, metalID, 0.5f );
NewtonMaterialSetDefaultFriction ( _p_world, woodID, metalID, 0.8f, 0.6f );
NewtonMaterialSetCollisionCallback( _p_world, woodID, metalID, &wood_metalCollStruct, genericContactBegin, genericContactProcess, genericContactEnd );
// set the material properties for wood on grass
NewtonMaterialSetDefaultElasticity( _p_world, woodID, grassID, 0.2f );
NewtonMaterialSetDefaultFriction ( _p_world, woodID, grassID, 0.9f, 0.7f );
NewtonMaterialSetCollisionCallback( _p_world, woodID, grassID, &wood_grassCollStruct, genericContactBegin, genericContactProcess, genericContactEnd );
// set the material properties for wood on stone
NewtonMaterialSetDefaultElasticity( _p_world, woodID, stoneID, 0.45f );
NewtonMaterialSetDefaultFriction ( _p_world, woodID, stoneID, 0.7f, 0.6f );
NewtonMaterialSetCollisionCallback( _p_world, woodID, stoneID, &wood_stoneCollStruct, genericContactBegin, genericContactProcess, genericContactEnd );
//------
// set the material properties for metal on metal
NewtonMaterialSetDefaultElasticity( _p_world, metalID, metalID, 0.7f );
NewtonMaterialSetDefaultFriction ( _p_world, metalID, metalID, 0.5f, 0.2f );
NewtonMaterialSetCollisionCallback( _p_world, metalID, metalID, &metal_metalCollStruct, genericContactBegin, genericContactProcess, genericContactEnd );
// set the material properties for metal on grass
NewtonMaterialSetDefaultElasticity( _p_world, metalID, grassID, 0.2f );
NewtonMaterialSetDefaultFriction ( _p_world, metalID, grassID, 0.6f, 0.5f );
NewtonMaterialSetCollisionCallback( _p_world, metalID, grassID, &metal_grassCollStruct, genericContactBegin, genericContactProcess, genericContactEnd );
// set the material properties for metal on stone
NewtonMaterialSetDefaultElasticity( _p_world, metalID, stoneID, 0.6f );
NewtonMaterialSetDefaultFriction ( _p_world, metalID, stoneID, 0.5f, 0.4f );
NewtonMaterialSetCollisionCallback( _p_world, metalID, stoneID, &metal_stoneCollStruct, genericContactBegin, genericContactProcess, genericContactEnd );
//------
// set the material properties for stone on stone
NewtonMaterialSetDefaultElasticity( _p_world, stoneID, stoneID, 0.8f );
NewtonMaterialSetDefaultFriction ( _p_world, stoneID, stoneID, 0.5f, 0.2f );
NewtonMaterialSetCollisionCallback( _p_world, stoneID, stoneID, &stone_stoneCollStruct, genericContactBegin, genericContactProcess, genericContactEnd );
// set the material properties for stone on grass
NewtonMaterialSetDefaultElasticity( _p_world, stoneID, grassID, 0.2f );
NewtonMaterialSetDefaultFriction ( _p_world, stoneID, grassID, 0.7f, 0.6f );
NewtonMaterialSetCollisionCallback( _p_world, stoneID, grassID, &stone_grassCollStruct, genericContactBegin, genericContactProcess, genericContactEnd );
//------
// set the material properties for grass on grass ( may we need this!? )
NewtonMaterialSetDefaultElasticity( _p_world, grassID, grassID, 0.1f );
NewtonMaterialSetDefaultFriction ( _p_world, grassID, grassID, 0.9f, 0.8f );
NewtonMaterialSetCollisionCallback( _p_world, grassID, grassID, &grass_grassCollStruct, genericContactBegin, genericContactProcess, genericContactEnd );
}
static void AddStructuredFractured (DemoEntityManager* const scene, const dVector& origin, int materialID, const char* const assetName)
{
// create the shape and visual mesh as a common data to be re used
NewtonWorld* const world = scene->GetNewton();
#if 0
// load the mesh asset
DemoEntity entity(GetIdentityMatrix(), NULL);
entity.LoadNGD_mesh (assetName, world);
DemoMesh____* const mesh = entity.GetMesh();
dAssert (mesh);
// convert the mesh to a newtonMesh
NewtonMesh* const solidMesh = mesh->CreateNewtonMesh (world, entity.GetMeshMatrix() * entity.GetCurrentMatrix());
#else
int externalMaterial = LoadTexture("wood_0.tga");
NewtonCollision* const collision = CreateConvexCollision (world, dGetIdentityMatrix(), dVector (3.0f, 3.0f, 3.0f, 0.0), _BOX_PRIMITIVE, 0);
NewtonMesh* const solidMesh = NewtonMeshCreateFromCollision(collision);
NewtonDestroyCollision(collision);
//NewtonMeshTriangulate(solidMesh);
NewtonMeshApplyBoxMapping (solidMesh, externalMaterial, externalMaterial, externalMaterial);
#endif
// create a random point cloud
dVector points[MAX_POINT_CLOUD_SIZE];
int pointCount = MakeRandomPoisonPointCloud (solidMesh, points);
// int pointCount = MakeRandomGuassianPointCloud (solidMesh, points, MAX_POINT_CLOUD_SIZE);
// create and interiors material for texturing the fractured pieces
//int internalMaterial = LoadTexture("KAMEN-stup.tga");
int internalMaterial = LoadTexture("concreteBrick.tga");
// crate a texture matrix for uv mapping of fractured pieces
dMatrix textureMatrix (dGetIdentityMatrix());
textureMatrix[0][0] = 1.0f / 2.0f;
textureMatrix[1][1] = 1.0f / 2.0f;
/// create the fractured collision and mesh
int debreePhysMaterial = NewtonMaterialGetDefaultGroupID(world);
NewtonCollision* structuredFracturedCollision = NewtonCreateFracturedCompoundCollision (world, solidMesh, 0, debreePhysMaterial, pointCount, &points[0][0], sizeof (dVector), internalMaterial, &textureMatrix[0][0],
OnReconstructMainMeshCallBack, OnEmitFracturedCompound, OnEmitFracturedChunk);
// uncomment this to test serialization
#if 0
FILE* file = fopen ("serialize.bin", "wb");
NewtonCollisionSerialize (world, structuredFracturedCollision, DemoEntityManager::SerializeFile, file);
NewtonDestroyCollision (structuredFracturedCollision);
fclose (file);
file = fopen ("serialize.bin", "rb");
structuredFracturedCollision = NewtonCreateCollisionFromSerialization (world, DemoEntityManager::DeserializeFile, file);
NewtonFracturedCompoundSetCallbacks (structuredFracturedCollision, OnReconstructMainMeshCallBack, OnEmitFracturedCompound, OnEmitFracturedChunk);
fclose (file);
#endif
#if 0
// test the interface
dTree<void*, void*> detachableNodes;
NewtonCompoundCollisionBeginAddRemove(structuredFracturedCollision);
// remove all chunk that can be detached for the first layer
for (void* node = NewtonCompoundCollisionGetFirstNode(structuredFracturedCollision); node; node = NewtonCompoundCollisionGetNextNode(structuredFracturedCollision, node)) {
if (NewtonFracturedCompoundIsNodeFreeToDetach (structuredFracturedCollision, node)) {
detachableNodes.Insert(node, node);
}
// remove any node that can be deched fro the secund layer, this codul; be reusive
void* neighbors[32];
int count = NewtonFracturedCompoundNeighborNodeList (structuredFracturedCollision, node, neighbors, sizeof (neighbors) / sizeof (neighbors[0]));
for (int i = 0; i < count; i ++ ) {
if (NewtonFracturedCompoundIsNodeFreeToDetach (structuredFracturedCollision, neighbors[i])) {
detachableNodes.Insert(node, node);
}
}
}
// now delete the actual nodes
dTree<void*, void*>::Iterator iter (detachableNodes) ;
for (iter.Begin(); iter; iter ++) {
void* const node = iter.GetNode()->GetInfo();
NewtonCompoundCollisionRemoveSubCollision (structuredFracturedCollision, node);
}
NewtonCompoundCollisionEndAddRemove(structuredFracturedCollision);
#endif
#if 1
dVector plane (0.0f, 1.0f, 0.0f, 0.0f);
NewtonCollision* const crack = NewtonFracturedCompoundPlaneClip (structuredFracturedCollision, &plane[0]);
if (crack) {
NewtonDestroyCollision (structuredFracturedCollision);
}
#endif
dVector com(0.0f);
dVector inertia(0.0f);
NewtonConvexCollisionCalculateInertialMatrix (structuredFracturedCollision, &inertia[0], &com[0]);
//dFloat mass = 10.0f;
//int materialId = 0;
//create the rigid body
dMatrix matrix (dGetIdentityMatrix());
matrix.m_posit = origin;
matrix.m_posit.m_y = 20.0;
matrix.m_posit.m_w = 1.0f;
NewtonBody* const rigidBody = NewtonCreateDynamicBody (world, structuredFracturedCollision, &matrix[0][0]);
// set the mass and center of mass
dFloat density = 1.0f;
dFloat mass = density * NewtonConvexCollisionCalculateVolume (structuredFracturedCollision);
NewtonBodySetMassProperties (rigidBody, mass, structuredFracturedCollision);
// set the transform call back function
NewtonBodySetTransformCallback (rigidBody, DemoEntity::TransformCallback);
// set the force and torque call back function
NewtonBodySetForceAndTorqueCallback (rigidBody, PhysicsApplyGravityForce);
// create the entity and visual mesh and attach to the body as user data
CreateVisualEntity (scene, rigidBody);
// assign the wood id
// NewtonBodySetMaterialGroupID (rigidBody, materialId);
// set a destructor for this rigid body
// NewtonBodySetDestructorCallback (rigidBody, PhysicsBodyDestructor);
// release the interior texture
// ReleaseTexture (internalMaterial);
// delete the solid mesh since it no longed needed
NewtonMeshDestroy (solidMesh);
// destroy the fracture collision
NewtonDestroyCollision (structuredFracturedCollision);
}
//static void UnstableStruture (SceneManager& system, dVector location, int high)
static void BreakableStruture (SceneManager& system, dVector location, int high)
{
dFloat plankMass;
dFloat columnMass;
// /////////////////////////////////////////////////////////////////////
//
// Build a parking lot type structure
dVector columnBoxSize (3.0f, 1.0f, 1.0f);
// dVector columnBoxSize (3.0f, 3.0f, 1.0f);
dVector plankBoxSize (6.0f, 1.0f, 6.0f);
// create the stack
dMatrix baseMatrix (GetIdentityMatrix());
// get the floor position in from o the camera
baseMatrix.m_posit = location;
baseMatrix.m_posit.m_y += columnBoxSize.m_x;
// set realistic (extremes in this case for 24 bits precision) masses for the different components
// note how the newton engine handle different masses ratios without compromising stability,
// we recommend the application keep this ration under 100 for contacts and 50 for joints
columnMass = 1.0f;
plankMass = 20.0f;
// plankMass = 1.0f;
// create a material carrier to to cou collision wit ethsi obejted
int defaultMaterialID;
defaultMaterialID = NewtonMaterialGetDefaultGroupID (system.m_world);
dMatrix columAlignment (dRollMatrix(3.1416f * 0.5f));
for (int i = 0; i < high; i ++) {
NewtonBody* body;
RenderPrimitive* primitive;
dMatrix matrix(columAlignment * baseMatrix);
// add the 4 column
matrix.m_posit.m_x -= (columnBoxSize.m_z - plankBoxSize.m_x) * 0.5f;
matrix.m_posit.m_z -= (columnBoxSize.m_z - plankBoxSize.m_z) * 0.5f;
body = CreateGenericSolid (system.m_world, &system, columnMass, matrix, columnBoxSize, _RANDOM_CONVEX_HULL_PRIMITIVE, defaultMaterialID);
primitive = (RenderPrimitive*) NewtonBodyGetUserData (body);
SetBreakValue (body, 50.0f);
ConvexCastPlacement (body);
matrix.m_posit.m_x += columnBoxSize.m_z - plankBoxSize.m_x;
body = CreateGenericSolid (system.m_world, &system, columnMass, matrix, columnBoxSize, _RANDOM_CONVEX_HULL_PRIMITIVE, defaultMaterialID);
primitive = (RenderPrimitive*) NewtonBodyGetUserData (body);
SetBreakValue (body, 30.0f);
ConvexCastPlacement (body);
matrix.m_posit.m_z += columnBoxSize.m_z - plankBoxSize.m_z;
body = CreateGenericSolid (system.m_world, &system, columnMass, matrix, columnBoxSize, _RANDOM_CONVEX_HULL_PRIMITIVE, defaultMaterialID);
primitive = (RenderPrimitive*) NewtonBodyGetUserData (body);
SetBreakValue (body, 30.0f);
ConvexCastPlacement (body);
matrix.m_posit.m_x -= columnBoxSize.m_z - plankBoxSize.m_x;
body = CreateGenericSolid (system.m_world, &system, columnMass, matrix, columnBoxSize, _RANDOM_CONVEX_HULL_PRIMITIVE, defaultMaterialID);
primitive = (RenderPrimitive*) NewtonBodyGetUserData (body);
SetBreakValue (body, 30.0f);
ConvexCastPlacement (body);
// add a plank
dVector size (plankBoxSize);
size.m_x *= 0.85f;
size.m_z *= 0.85f;
body = CreateGenericSolid (system.m_world, &system, plankMass, baseMatrix, size, _BOX_PRIMITIVE, defaultMaterialID);
primitive = (RenderPrimitive*) NewtonBodyGetUserData (body);
SetBreakValue (body, 1.0f);
ConvexCastPlacement (body);
// set up for another level
baseMatrix.m_posit.m_y += (columnBoxSize.m_x + plankBoxSize.m_y);
}
dFloat mass;
NewtonBody* body;
RenderPrimitive* primitive;
PrimitiveType type = _BOX_PRIMITIVE;
dVector size (1.0f, 2.0f, 1.0f);
dMatrix matrix (GetIdentityMatrix());
mass = 10.0f;
matrix.m_posit = location;
matrix.m_posit.m_y = FindFloor (system.m_world, matrix.m_posit.m_x, matrix.m_posit.m_z) + baseMatrix.m_posit.m_y + 35.0f;
body = CreateGenericSolid (system.m_world, &system, mass, matrix, size, type, defaultMaterialID);
primitive = (RenderPrimitive*) NewtonBodyGetUserData (body);
}
static void BuildFloorAndSceneRoot (SceneManager& system)
{
NewtonWorld* world;
RenderPrimitive* floor;
NewtonBody* floorBody;
NewtonCollision* floorCollision;
OGLMesh* meshInstance;
world = system.m_world;
// /////////////////////////////////////////////////////////////////////
//
// create the sky box,
system.AddModel (new SkyBox ());
// create the the floor graphic objects
dVector floorSize (100.0f, 2.0f, 100.0f);
dMatrix location (GetIdentityMatrix());
location.m_posit.m_y = -5.0f;
// create a box for floor
floorCollision = NewtonCreateBox (world, floorSize.m_x, floorSize.m_y, floorSize.m_z, 0, NULL);
// meshInstance = OGLMesh::MakeBox (world, size.m_x, size.m_y, size.m_z, "GrassAndDirt.tga");
meshInstance = new OGLMesh (floorCollision, "GrassAndDirt.tga", "metal_30.tga", "metal_30.tga");
floor = new RenderPrimitive (location, meshInstance);
system.AddModel (floor);
meshInstance->Release();
// create the the floor collision, and body with default values
floorBody = NewtonCreateBody (world, floorCollision);
NewtonReleaseCollision (world, floorCollision);
// set the transformation for this rigid body
NewtonBodySetMatrix (floorBody, &location[0][0]);
// save the pointer to the graphic object with the body.
NewtonBodySetUserData (floorBody, floor);
// set a destructor for this rigid body
NewtonBodySetDestructorCallback (floorBody, PhysicsBodyDestructor);
// get the default material ID
int defaultID;
defaultID = NewtonMaterialGetDefaultGroupID (world);
// set default material properties
NewtonMaterialSetDefaultSoftness (world, defaultID, defaultID, 0.05f);
NewtonMaterialSetDefaultElasticity (world, defaultID, defaultID, 0.4f);
NewtonMaterialSetDefaultCollidable (world, defaultID, defaultID, 1);
NewtonMaterialSetDefaultFriction (world, defaultID, defaultID, 1.0f, 0.5f);
NewtonMaterialSetCollisionCallback (world, defaultID, defaultID, NULL, NULL, GenericContactProcess);
// NewtonMaterialSetSurfaceThickness(world, materialID, materialID, 0.1f);
NewtonMaterialSetSurfaceThickness(world, defaultID, defaultID, 0.0f);
// set the island update callback
NewtonSetIslandUpdateEvent (world, PhysicsIslandUpdate);
// save the callback
SetDemoCallbacks (system);
InitEyePoint (dVector (1.0f, 0.0f, 0.0f), dVector (-40.0f, 10.0f, 0.0f));
}
void SceneCollision (DemoEntityManager* const scene)
{
NewtonWorld* world = scene->GetNewton();
// add the Sky
scene->CreateSkyBox();
// create a body and with a scene collision
NewtonCollision* const sceneCollision = NewtonCreateSceneCollision (scene->GetNewton(), 0);
// create a visual scene empty mesh
ComplexScene* const visualMesh = new ComplexScene(sceneCollision);
scene->Append (visualMesh);
// add some shapes
visualMesh->AddPrimitives(scene);
// this is optional, finish the scene construction, optimize the collision scene
dMatrix matrix (dGetIdentityMatrix());
// create the level body and add it to the world
NewtonBody* const level = NewtonCreateDynamicBody (world, sceneCollision, &matrix[0][0]);
// replace the collision with the newly created one the
visualMesh->m_sceneCollision = NewtonBodyGetCollision(level);
// set the reference to the visual
NewtonBodySetUserData(level, visualMesh);
// do not forget to release the collision
NewtonDestroyCollision (sceneCollision);
// add few objects
int defaultMaterialID = NewtonMaterialGetDefaultGroupID (world);
NewtonMaterialSetCollisionCallback (world, defaultMaterialID, defaultMaterialID, OnBodyAABBOverlap, OnContactCollision);
NewtonMaterialSetCompoundCollisionCallback(world, defaultMaterialID, defaultMaterialID, OnSubShapeAABBOverlapTest);
dVector location (0.0f, 0.0f, 0.0f, 0.0f);
dVector size (0.5f, 0.5f, 0.5f, 0.0f);
dMatrix shapeOffsetMatrix (dGetIdentityMatrix());
int count = 5;
AddPrimitiveArray(scene, 10.0f, location, size, count, count, 1.7f, _SPHERE_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddPrimitiveArray(scene, 10.0f, location, size, count, count, 1.7f, _BOX_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddPrimitiveArray(scene, 10.0f, location, size, count, count, 1.7f, _CYLINDER_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddPrimitiveArray(scene, 10.0f, location, size, count, count, 1.7f, _CHAMFER_CYLINDER_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddPrimitiveArray(scene, 10.0f, location, size, count, count, 1.7f, _CONE_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddPrimitiveArray(scene, 10.0f, location, size, count, count, 1.7f, _CAPSULE_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddPrimitiveArray(scene, 10.0f, location, size, count, count, 1.7f, _RANDOM_CONVEX_HULL_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddPrimitiveArray(scene, 10.0f, location, size, count, count, 1.7f, _COMPOUND_CONVEX_CRUZ_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
dMatrix camMatrix (dRollMatrix(-20.0f * 3.1416f /180.0f) * dYawMatrix(-45.0f * 3.1416f /180.0f));
dQuaternion rot (camMatrix);
dVector origin (-15.0f, 5.0f, 0.0f, 0.0f);
scene->SetCameraMatrix(rot, origin);
}
StupidComplexOfConvexShapes (DemoEntityManager* const scene, int count)
:DemoEntity (dGetIdentityMatrix(), NULL)
,m_rayP0(0.0f, 0.0f, 0.0f, 0.0f)
,m_rayP1(0.0f, 0.0f, 0.0f, 0.0f)
{
scene->Append(this);
count = 40;
//count = 1;
const dFloat size = 0.5f;
DemoMesh* gemetries[32];
NewtonCollision* collisionArray[32];
NewtonWorld* const world = scene->GetNewton();
int materialID = NewtonMaterialGetDefaultGroupID(world);
// create a pool of predefined convex mesh
// PrimitiveType selection[] = {_SPHERE_PRIMITIVE, _BOX_PRIMITIVE, _CAPSULE_PRIMITIVE, _CYLINDER_PRIMITIVE, _CONE_PRIMITIVE, _TAPERED_CAPSULE_PRIMITIVE, _TAPERED_CYLINDER_PRIMITIVE, _CHAMFER_CYLINDER_PRIMITIVE, _RANDOM_CONVEX_HULL_PRIMITIVE, _REGULAR_CONVEX_HULL_PRIMITIVE};
PrimitiveType selection[] = {_SPHERE_PRIMITIVE};
for (int i = 0; i < int (sizeof (collisionArray) / sizeof (collisionArray[0])); i ++) {
int index = dRand() % (sizeof (selection) / sizeof (selection[0]));
dVector shapeSize (size + RandomVariable (size / 2.0f), size + RandomVariable (size / 2.0f), size + RandomVariable (size / 2.0f), 0.0f);
shapeSize = dVector(size, size, size, 0.0f);
collisionArray[i] = CreateConvexCollision (world, dGetIdentityMatrix(), shapeSize, selection[index], materialID);
gemetries[i] = new DemoMesh("geometry", collisionArray[i], "wood_4.tga", "wood_4.tga", "wood_1.tga");
}
// make a large complex of plane by adding lost of these shapes at a random location and oriention;
NewtonCollision* const compound = NewtonCreateCompoundCollision (world, materialID);
NewtonCompoundCollisionBeginAddRemove(compound);
for (int i = 0 ; i < count; i ++) {
for (int j = 0 ; j < count; j ++) {
float pitch = RandomVariable (1.0f) * 2.0f * 3.1416f;
float yaw = RandomVariable (1.0f) * 2.0f * 3.1416f;
float roll = RandomVariable (1.0f) * 2.0f * 3.1416f;
float x = size * (j - count / 2) + RandomVariable (size * 0.5f);
float y = RandomVariable (size * 2.0f);
float z = size * (i - count / 2) + RandomVariable (size * 0.5f);
dMatrix matrix (dPitchMatrix (pitch) * dYawMatrix (yaw) * dRollMatrix (roll));
matrix.m_posit = dVector (x, y, z, 1.0f);
int index = dRand() % (sizeof (selection) / sizeof (selection[0]));
DemoEntity* const entity = new DemoEntity(matrix, this);
entity->SetMesh(gemetries[index], dGetIdentityMatrix());
NewtonCollisionSetMatrix (collisionArray[index], &matrix[0][0]);
NewtonCompoundCollisionAddSubCollision (compound, collisionArray[index]);
}
}
NewtonCompoundCollisionEndAddRemove(compound);
CreateSimpleBody (world, NULL, 0.0f, dGetIdentityMatrix(), compound, 0);
// destroy all collision shapes after they are used
NewtonDestroyCollision(compound);
for (int i = 0; i < int (sizeof (collisionArray) / sizeof (collisionArray[0])); i ++) {
gemetries[i]->Release();
NewtonDestroyCollision(collisionArray[i]);
}
// now make and array of collision shapes for convex casting by mouse point click an drag
CreateCastingShapes(scene, size * 2.0f);
}
void AlchimedesBuoyancy(DemoEntityManager* const scene)
{
// load the sky box
scene->CreateSkyBox();
// load the mesh
CreateLevelMesh (scene, "swimmingPool.ngd", true);
// add a trigger Manager to the world
MyTriggerManager* const triggerManager = new MyTriggerManager(scene->GetNewton());
dMatrix triggerLocation (dGetIdentityMatrix());
triggerLocation.m_posit.m_x = 17.0f;
triggerLocation.m_posit.m_y = -3.5f;
NewtonCollision* const poolBox = NewtonCreateBox (scene->GetNewton(), 30.0f, 6.0f, 20.0f, 0, NULL);
triggerManager->CreateBuoyancyTrigger (triggerLocation, poolBox);
NewtonDestroyCollision (poolBox);
// 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
dMatrix offsetMatrix (dGetIdentityMatrix());
// place camera into position
dMatrix camMatrix (dGetIdentityMatrix());
dQuaternion rot (camMatrix);
dVector origin (-20.0f, 10.0f, 0.0f, 0.0f);
scene->SetCameraMatrix(rot, origin);
int defaultMaterialID = NewtonMaterialGetDefaultGroupID (scene->GetNewton());
/*
//test buoyancy on scaled collisions
dVector plane (0.0f, 1.0f, 0.0f, 0.0f);
dMatrix L1 (dPitchMatrix(30.0f * 3.141692f / 180.0f) * dYawMatrix(0.0f * 3.141692f / 180.0f) * dRollMatrix(0.0f * 3.141692f / 180.0f));
NewtonCollision* xxx0 = NewtonCreateCompoundCollision(scene->GetNewton(), 0);
NewtonCompoundCollisionBeginAddRemove(xxx0);
NewtonCollision* xxxx0 = NewtonCreateBox(scene->GetNewton(), 1.0f, 2.0f, 1.0f, 0, &L1[0][0]);
NewtonCompoundCollisionAddSubCollision(xxx0, xxxx0);
NewtonCompoundCollisionEndAddRemove(xxx0);
NewtonCollision* xxx1 = NewtonCreateCompoundCollision(scene->GetNewton(), 0);
NewtonCollision* xxxx1 = NewtonCreateBox(scene->GetNewton(), 1.0f, 1.0f, 1.0f, 0, &L1[0][0]);
NewtonCompoundCollisionAddSubCollision(xxx1, xxxx1);
NewtonCompoundCollisionEndAddRemove(xxx1);
NewtonCollisionSetScale(xxx1, 1.0f, 2.0f, 1.0f);
//dMatrix m (dPitchMatrix(45.0f * 3.141692f / 180.0f) * dYawMatrix(40.0f * 3.141692f / 180.0f) * dRollMatrix(70.0f * 3.141692f / 180.0f));
dMatrix m (dPitchMatrix(0.0f * 3.141692f / 180.0f) * dYawMatrix(0.0f * 3.141692f / 180.0f) * dRollMatrix(0.0f * 3.141692f / 180.0f));
dVector gravity (0.0f, 0.0f, -9.8f, 0.0f);
dVector cog0 (0.0f, 0.0f, 0.0f, 0.0f);
dVector accelPerUnitMass0;
dVector torquePerUnitMass0;
NewtonConvexCollisionCalculateBuoyancyAcceleration (xxx0, &m[0][0], &cog0[0], &gravity[0], &plane[0], 1.0f, 0.1f, &accelPerUnitMass0[0], &torquePerUnitMass0[0]);
dVector cog1 (0.0f, 0.0f, 0.0f, 0.0f);
dVector accelPerUnitMass1;
dVector torquePerUnitMass1;
NewtonConvexCollisionCalculateBuoyancyAcceleration (xxx1, &m[0][0], &cog1[0], &gravity[0], &plane[0], 1.0f, 0.1f, &accelPerUnitMass1[0], &torquePerUnitMass1[0]);
*/
int count = 5;
dVector size (1.0f, 0.25f, 0.5f);
dVector location (10.0f, 0.0f, 0.0f, 0.0f);
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, _COMPOUND_CONVEX_CRUZ_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
/*
for (NewtonBody* bodyPtr = NewtonWorldGetFirstBody(scene->GetNewton()); bodyPtr; bodyPtr = NewtonWorldGetNextBody(scene->GetNewton(), bodyPtr)) {
NewtonCollision* collision = NewtonBodyGetCollision(bodyPtr);
if (NewtonCollisionGetType(collision) == SERIALIZE_ID_COMPOUND) {
NewtonCollisionSetScale (collision, 0.5f, 0.5f, 0.5f);
}
}
*/
// AddPrimitiveArray(scene, 10.0f, location, size, count, count, 5.0f, _RANDOM_CONVEX_HULL_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
}