~ClosestDistanceEntity()
{
NewtonDestroyCollision (m_castingShape);
}
void CustomVehicleController::Init (NewtonBody* const body, const dMatrix& vehicleFrame, const dVector& gravityVector)
{
m_body = body;
m_finalized = false;
m_externalContactStatesCount = 0;
m_sleepCounter = VEHICLE_SLEEP_COUNTER;
m_freeContactList = m_externalContactStatesPool.GetFirst();
CustomVehicleControllerManager* const manager = (CustomVehicleControllerManager*) GetManager();
NewtonWorld* const world = manager->GetWorld();
// create a compound collision
NewtonCollision* const vehShape = NewtonCreateCompoundCollision(world, 0);
NewtonCompoundCollisionBeginAddRemove(vehShape);
// if the shape is a compound collision ass all the pieces one at a time
NewtonCollision* const chassisShape = NewtonBodyGetCollision (m_body);
int shapeType = NewtonCollisionGetType (chassisShape);
if (shapeType == SERIALIZE_ID_COMPOUND) {
for (void* node = NewtonCompoundCollisionGetFirstNode(chassisShape); node; node = NewtonCompoundCollisionGetNextNode (chassisShape, node)) {
NewtonCollision* const subCollision = NewtonCompoundCollisionGetCollisionFromNode(chassisShape, node);
NewtonCompoundCollisionAddSubCollision (vehShape, subCollision);
}
} else {
dAssert ((shapeType == SERIALIZE_ID_CONVEXHULL) || (shapeType == SERIALIZE_ID_BOX));
NewtonCompoundCollisionAddSubCollision (vehShape, chassisShape);
}
NewtonCompoundCollisionEndAddRemove (vehShape);
// replace the collision shape of the vehicle with this new one
NewtonBodySetCollision(m_body, vehShape);
// set linear and angular drag to zero
dVector drag(0.0f, 0.0f, 0.0f, 0.0f);
NewtonBodySetLinearDamping(m_body, 0);
NewtonBodySetAngularDamping(m_body, &drag[0]);
// destroy the collision help shape
NewtonDestroyCollision (vehShape);
// initialize vehicle internal components
NewtonBodyGetCentreOfMass (m_body, &m_chassisState.m_com[0]);
m_chassisState.m_com.m_w = 0.0f;
m_chassisState.m_comOffset = dVector (0.0f, 0.0f, 0.0f, 0.0f);
m_chassisState.m_gravity = gravityVector;
m_chassisState.m_gravityMag = dSqrt (gravityVector % gravityVector);
m_chassisState.Init(this, vehicleFrame);
m_stateList.Append(&m_chassisState);
// create the normalized size tire shape
m_tireCastShape = NewtonCreateChamferCylinder(world, 0.5f, 1.0f, 0, NULL);
// initialize all components to empty
m_engine = NULL;
m_brakes = NULL;
m_steering = NULL;
m_handBrakes = NULL;
m_contactFilter = new CustomVehicleControllerTireCollisionFilter (this);
SetDryRollingFrictionTorque (100.0f/4.0f);
SetAerodynamicsDownforceCoefficient (0.5f * dSqrt (gravityVector % gravityVector), 60.0f * 0.447f);
}
static void CreateConvexAproximation (const char* const name, DemoEntityManager* const scene, const dVector& origin, int instaceCount, const char* const texture)
{
char fileName[2048];
dGetWorkingFileName (name, fileName);
NewtonWorld* const world = scene->GetNewton();
dScene compoundTestMesh (world);
compoundTestMesh.Deserialize(fileName);
// freeze the scale and pivot on the model
compoundTestMesh.FreezeScale();
// compoundTestMesh.FreezeGeometryPivot ();
dMeshNodeInfo* meshInfo = NULL;
dMatrix scale (dGetIdentityMatrix());
for (dScene::dTreeNode* node = compoundTestMesh.GetFirstNode (); node; node = compoundTestMesh.GetNextNode (node)) {
dNodeInfo* info = compoundTestMesh.GetInfoFromNode(node);
if (info->GetTypeId() == dMeshNodeInfo::GetRttiType()) {
for (void* link = compoundTestMesh.GetFirstParentLink(node); link; link = compoundTestMesh.GetNextParentLink (node, link)) {
dScene::dTreeNode* const node = compoundTestMesh.GetNodeFromLink(link);
dNodeInfo* const info = compoundTestMesh.GetInfoFromNode(node);
if (info->GetTypeId() == dSceneNodeInfo::GetRttiType()) {
scale = ((dSceneNodeInfo*)info)->GetGeometryTransform();
break;
}
}
meshInfo = (dMeshNodeInfo*) info;
break;
}
}
NewtonMeshApplyTransform(meshInfo->GetMesh(), &scale[0][0]);
dAssert (meshInfo);
dAssert (meshInfo->GetMesh());
#if 1
NewtonMesh* const mesh = meshInfo->GetMesh();
#else
dGetWorkingFileName ("mesh.off", fileName);
NewtonMesh* const mesh = NewtonMeshLoadOFF(world, fileName);
// dMatrix scale (GetIdentityMatrix());
// //dFloat scaleMag = 0.05f;
// dFloat scaleMag = 1.0f;
// scale[0][0] = scaleMag;
// scale[1][1] = scaleMag;
// scale[2][2] = scaleMag;
// NewtonMesApplyTransform (mesh, &scale[0][0]);
#endif
//NewtonMesh* const newtonMesh = NewtonMeshSimplify(mesh, 500, ReportProgress);
// create a convex approximation form the original mesh, 32 convex max and no more than 100 vertex convex hulls
// NewtonMesh* const convexApproximation = NewtonMeshApproximateConvexDecomposition (mesh, 0.01f, 0.2f, 32, 100, ReportProgress, scene);
NewtonMesh* const convexApproximation = NewtonMeshApproximateConvexDecomposition (mesh, 0.01f, 0.2f, 256, 100, ReportProgress, scene);
// NewtonMesh* const convexApproximation = NewtonMeshApproximateConvexDecomposition (mesh, 0.00001f, 0.0f, 256, 100, ReportProgress, scene);
// create a compound collision by creation a convex hull of each segment of the source mesh
NewtonCollision* const compound = NewtonCreateCompoundCollisionFromMesh (world, convexApproximation, 0.001f, 0, 0);
// test collision mode
// NewtonCollisionSetCollisonMode(compound, 0);
// make a visual Mesh
int tex = LoadTexture(texture);
dMatrix aligmentUV(dGetIdentityMatrix());
NewtonMeshApplyBoxMapping(mesh, tex, tex, tex, &aligmentUV[0][0]);
DemoMesh* const visualMesh = new DemoMesh (mesh);
dMatrix matrix (dGetIdentityMatrix());
matrix.m_posit = origin;
for (int ix = 0; ix < instaceCount; ix ++) {
for (int iz = 0; iz < instaceCount; iz ++) {
dFloat y = origin.m_y;
dFloat x = origin.m_x + (ix - instaceCount/2) * 10.0f;
dFloat z = origin.m_z + (iz - instaceCount/2) * 10.0f;
matrix.m_posit = FindFloor (world, dVector (x, y + 10.0f, z, 0.0f), 20.0f); ;
matrix.m_posit.m_y += 2.0f;
CreateSimpleSolid (scene, visualMesh, 10.0f, matrix, compound, 0);
}
}
visualMesh->Release();
NewtonDestroyCollision(compound);
NewtonMeshDestroy (convexApproximation);
}
void CreateScene (NewtonWorld* world, SceneManager* sceneManager)
{
Entity* floor;
NewtonBody* floorBody;
NewtonCollision* shape;
/*
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);
matInterations.m_impactSound = sndManager->LoadSound ("metal.wav");
AddMaterilInteraction (materialManager, m_metal, m_bricks, &matInterations);
*/
// Create a large body to be the floor
floor = sceneManager->CreateEntity();
int materialMap[] = {m_bricks, m_grass, m_wood, m_metal};
#ifdef USE_HEIGHT_FIELD_LEVEL
// add scene collision from a level m*esh
shape = CreateHeightFieldCollision (world, "h2.raw", materialMap);
floorBody = CreateRigidBody (world, floor, shape, 0.0f);
NewtonDestroyCollision(shape);
// make a visual mesh for the collision data
CreateHeightFieldMesh (shape, floor);
// set the matrix at the origin
dVector boxP0;
dVector boxP1;
dMatrix matrix (floor->m_curRotation, floor->m_curPosition);
NewtonCollisionCalculateAABB (shape, &matrix[0][0], &boxP0.m_x, &boxP1.m_x);
// place the origin of the visual mesh at the center of the height field
matrix.m_posit = (boxP0 + boxP1).Scale (-0.5f);
matrix.m_posit.m_w = 1.0f;
floor->m_curPosition = matrix.m_posit;
floor->m_prevPosition = matrix.m_posit;
// relocate the body;
NewtonBodySetMatrix (floorBody, &matrix[0][0]);
#else
floor->LoadMesh ("LevelMesh.dat");
// add static floor Physics
shape = CreateMeshCollision (world, floor, materialMap);
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]);
#endif
// 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]);
// Create a Body and attach a player controller joint
{
dFloat y0;
Entity* player;
NewtonBody* playerBody;
NewtonCollision* shape;
// find the a floor to place the player
y0 = FindFloor (world, 0.0f, 0.0f) + 1.0f;
// load the player mesh
player = sceneManager->CreateEntity();
player->LoadMesh ("gymnast.dat");
player->m_curPosition.m_y = y0;
player->m_prevPosition = player->m_curPosition;
// get the bounding Box of the player to get the collision shape dimensions
dVector minBox;
dVector maxBox;
player->GetBBox (minBox, maxBox);
// calculate player high and width
dFloat padding = 1.0f / 64.0f; // this si the default padding, for teh palye joint, we must subtract it from the shape
dFloat playerHigh = (maxBox.m_y - minBox.m_y) - padding;
dFloat playerRadius0 = (maxBox.m_z - minBox.m_z) * 0.5f;
dFloat playerRadius1 = (maxBox.m_x - minBox.m_x) * 0.5f;
dFloat playerRadius = (playerRadius0 > playerRadius1 ? playerRadius0 : playerRadius1) - padding;
// No we make and make a upright capsule for the collision mesh
dMatrix orientation;
orientation.m_front = dVector (0.0f, 1.0f, 0.0f, 0.0f); // this is the player up direction
orientation.m_up = dVector (1.0f, 0.0f, 0.0f, 0.0f); // this is the player front direction
orientation.m_right = orientation.m_front * orientation.m_up; // this is the player sideway direction
orientation.m_posit = dVector (0.0f, 0.0f, 0.0f, 1.0f);
// add a body with a box shape
//shape = CreateNewtonCapsule (world, player, playerHigh, playerRadius, m_wood, orientation);
shape = CreateNewtonCylinder (world, player, playerHigh, playerRadius, m_wood, orientation);
playerBody = CreateRigidBody (world, player, shape, 10.0f);
NewtonDestroyCollision(shape);
// make sure the player does not go to sleep
NewtonBodySetAutoSleep (playerBody, 0);
// now we will attach a player controller to the body
NewtonUserJoint* playerController;
// the player can take step up to 0.7 units;
dFloat maxStairStepFactor = 0.7f / playerHigh;
playerController = CreateCustomPlayerController (&orientation[0][0], playerBody, maxStairStepFactor, padding);
// set the Max Slope the player can climb to PLAYER_MAX_SLOPE degree
CustomPlayerControllerSetMaxSlope (playerController, PLAYER_MAX_SLOPE * 3.1416f / 180.0f);
// now we will append some application data for the application to control the player
PlayerController* userControl = (PlayerController*) malloc (sizeof (PlayerController));
userControl->m_isThirdView = 1;
userControl->m_point = dVector (0.0f, playerHigh, 0.0f,0.0f);
// set the user data for the application to control the player
CustomSetUserData (playerController, userControl);
// set the destruction call back so that the application can destroy local used data
CustomSetDestructorCallback (playerController, PlayerController::Destroy);
// set a call back to control the player
CustomSetSubmitContraintCallback (playerController, PlayerController::ApplyPlayerInput);
// we also need to set override the transform call back so the we can set the Camera
userControl->m_setTransformOriginal = NewtonBodyGetTransformCallback(playerBody);
NewtonBodySetTransformCallback (playerBody, PlayerController::SetTransform);
// we will need some ID to fin this joint in the transform Callback
CustomSetJointID (playerController, PLAYER_JOINT_ID);
}
/*
{
// add some visual entities.
dFloat y0;
y0 = FindFloor (world, 0.0f, 0.4f) + 10.5f;
for (int i = 0; i < 5; i ++) {
Entity* frowny;
NewtonBody* frownyBody;
NewtonCollision* shape;
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);
NewtonDestroyCollision(shape);
}
}
*/
// set the Camera EyePoint close to the scene action
SetCameraEyePoint (dVector (-15.0f, FindFloor (world, -15.0f, 0.0f) + 5.0f, 0.0f));
}
void CustomPlayerController::Init(dFloat mass, dFloat outerRadius, dFloat innerRadius, dFloat height, dFloat stairStep, const dMatrix& localAxis)
{
dAssert (stairStep >= 0.0f);
dAssert (innerRadius >= 0.0f);
dAssert (outerRadius >= innerRadius);
dAssert (height >= stairStep);
dAssert (localAxis[0].m_w == dFloat (0.0f));
dAssert (localAxis[1].m_w == dFloat (0.0f));
CustomPlayerControllerManager* const manager = (CustomPlayerControllerManager*) GetManager();
NewtonWorld* const world = manager->GetWorld();
SetRestrainingDistance (0.0f);
m_outerRadio = outerRadius;
m_innerRadio = innerRadius;
m_height = height;
m_stairStep = stairStep;
SetClimbSlope(45.0f * 3.1416f/ 180.0f);
m_upVector = localAxis[0];
m_frontVector = localAxis[1];
m_groundPlane = dVector (0.0f, 0.0f, 0.0f, 0.0f);
m_groundVelocity = dVector (0.0f, 0.0f, 0.0f, 0.0f);
const int steps = 12;
dVector convexPoints[2][steps];
// create an inner thin cylinder
dFloat shapeHigh = height;
dAssert (shapeHigh > 0.0f);
dVector p0 (0.0f, m_innerRadio, 0.0f, 0.0f);
dVector p1 (shapeHigh, m_innerRadio, 0.0f, 0.0f);
for (int i = 0; i < steps; i ++) {
dMatrix rotation (dPitchMatrix (i * 2.0f * 3.141592f / steps));
convexPoints[0][i] = localAxis.RotateVector(rotation.RotateVector(p0));
convexPoints[1][i] = localAxis.RotateVector(rotation.RotateVector(p1));
}
NewtonCollision* const supportShape = NewtonCreateConvexHull(world, steps * 2, &convexPoints[0][0].m_x, sizeof (dVector), 0.0f, 0, NULL);
// create the outer thick cylinder
dMatrix outerShapeMatrix (localAxis);
dFloat capsuleHigh = m_height - stairStep;
dAssert (capsuleHigh > 0.0f);
m_sphereCastOrigin = capsuleHigh * 0.5f + stairStep;
outerShapeMatrix.m_posit = outerShapeMatrix[0].Scale(m_sphereCastOrigin);
outerShapeMatrix.m_posit.m_w = 1.0f;
NewtonCollision* const bodyCapsule = NewtonCreateCapsule(world, 0.25f, 0.25f, 0.5f, 0, &outerShapeMatrix[0][0]);
NewtonCollisionSetScale(bodyCapsule, capsuleHigh, m_outerRadio * 4.0f, m_outerRadio * 4.0f);
// compound collision player controller
NewtonCollision* const playerShape = NewtonCreateCompoundCollision(world, 0);
NewtonCompoundCollisionBeginAddRemove(playerShape);
NewtonCompoundCollisionAddSubCollision (playerShape, supportShape);
NewtonCompoundCollisionAddSubCollision (playerShape, bodyCapsule);
NewtonCompoundCollisionEndAddRemove (playerShape);
// create the kinematic body
dMatrix locationMatrix (dGetIdentityMatrix());
m_body = NewtonCreateKinematicBody(world, playerShape, &locationMatrix[0][0]);
// players must have weight, otherwise they are infinitely strong when they collide
NewtonCollision* const shape = NewtonBodyGetCollision(m_body);
NewtonBodySetMassProperties(m_body, mass, shape);
// make the body collidable with other dynamics bodies, by default
NewtonBodySetCollidable (m_body, true);
dFloat castHigh = capsuleHigh * 0.4f;
dFloat castRadio = (m_innerRadio * 0.5f > 0.05f) ? m_innerRadio * 0.5f : 0.05f;
dVector q0 (0.0f, castRadio, 0.0f, 0.0f);
dVector q1 (castHigh, castRadio, 0.0f, 0.0f);
for (int i = 0; i < steps; i ++) {
dMatrix rotation (dPitchMatrix (i * 2.0f * 3.141592f / steps));
convexPoints[0][i] = localAxis.RotateVector(rotation.RotateVector(q0));
convexPoints[1][i] = localAxis.RotateVector(rotation.RotateVector(q1));
}
m_castingShape = NewtonCreateConvexHull(world, steps * 2, &convexPoints[0][0].m_x, sizeof (dVector), 0.0f, 0, NULL);
m_supportShape = NewtonCompoundCollisionGetCollisionFromNode (shape, NewtonCompoundCollisionGetNodeByIndex (shape, 0));
m_upperBodyShape = NewtonCompoundCollisionGetCollisionFromNode (shape, NewtonCompoundCollisionGetNodeByIndex (shape, 1));
NewtonDestroyCollision (bodyCapsule);
NewtonDestroyCollision (supportShape);
NewtonDestroyCollision (playerShape);
m_isJumping = false;
}
NewtonCollision* CreateCollisionTree (NewtonWorld* world, DemoEntity* const entity, int materialID, bool optimize)
{
// measure the time to build a collision tree
unsigned64 timer0 = dGetTimeInMicrosenconds();
// create the collision tree geometry
NewtonCollision* collision = NewtonCreateTreeCollision(world, materialID);
// set the application level callback
#ifdef USE_STATIC_MESHES_DEBUG_COLLISION
NewtonStaticCollisionSetDebugCallback (collision, ShowMeshCollidingFaces);
#endif
// prepare to create collision geometry
NewtonTreeCollisionBeginBuild(collision);
// iterate the entire geometry an build the collision
for (DemoEntity* model = entity->GetFirst(); model; model = model->GetNext()) {
dMatrix matrix (model->GetMeshMatrix() * model->CalculateGlobalMatrix(entity));
DemoMesh* const mesh = (DemoMesh*)model->GetMesh();
dAssert (mesh->IsType(DemoMesh::GetRttiType()));
dFloat* const vertex = mesh->m_vertex;
for (DemoMesh::dListNode* nodes = mesh->GetFirst(); nodes; nodes = nodes->GetNext()) {
DemoSubMesh& segment = nodes->GetInfo();
int matID = segment.m_textureHandle;
for (int i = 0; i < segment.m_indexCount; i += 3) {
dFloat face[3][3];
for (int j = 0; j < 3; j ++) {
int index = segment.m_indexes[i + j] * 3;
face[j][0] = vertex[index + 0];
face[j][1] = vertex[index + 1];
face[j][2] = vertex[index + 2];
}
matrix.TransformTriplex (&face[0][0], 3 * sizeof (dFloat), &face[0][0], 3 * sizeof (dFloat), 3);
// use material ids as physics materials
NewtonTreeCollisionAddFace(collision, 3, &face[0][0], 3 * sizeof (dFloat), matID);
}
}
}
NewtonTreeCollisionEndBuild(collision, optimize ? 1 : 0);
// test Serialization
#if 0
FILE* file = fopen ("serialize.bin", "wb");
NewtonCollisionSerialize (world, collision, DemoEntityManager::SerializeFile, file);
fclose (file);
NewtonDestroyCollision (collision);
file = fopen ("serialize.bin", "rb");
collision = NewtonCreateCollisionFromSerialization (world, DemoEntityManager::DeserializeFile, file);
fclose (file);
#endif
// measure the time to build a collision tree
timer0 = (dGetTimeInMicrosenconds() - timer0) / 1000;
return collision;
}
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 CreateScene (NewtonWorld* world, SceneManager* sceneManager)
{
Entity* floor;
Entity* smilly;
Entity* frowny;
NewtonBody* floorBody;
NewtonBody* smillyBody;
NewtonBody* frownyBody;
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]);
// add some visual entities.
smilly = sceneManager->CreateEntity();
smilly->LoadMesh ("Smilly.dat");
smilly->m_curPosition.m_y = 10.0f;
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);
// add some visual entities.
frowny = sceneManager->CreateEntity();
frowny->LoadMesh ("Frowny.dat");
frowny->m_curPosition.m_z = 0.4f;
frowny->m_curPosition.m_y = 10.0f + 0.4f;
frowny->m_prevPosition = frowny->m_curPosition;
// add a body with a Convex hull shape
shape = CreateNewtonConvex (world, frowny, 0);
frownyBody = CreateRigidBody (world, frowny, shape, 10.0f);
NewtonDestroyCollision(shape);
// we will Link the Frowny Body to the world with Hinge regenerated from a Generic 6DOF joint.
matrix = GetIdentityMatrix();
matrix.m_posit = frowny->m_curPosition;
matrix.m_posit.m_z += 0.2f;
matrix.m_posit.m_y += 0.4f;
// specify the limits for defining a Hinge around the x axis
dVector minLinearLimits (0.0f, 0.0f, 0.0f, 0.0f);
dVector maxLinearLimits (0.0f, 0.0f, 0.0f, 0.0f);
dVector minAngulaLimits (-0.5f * 3.1416f, 0.0f, 0.0f, 0.0f);
dVector maxAngulaLimits ( 0.5f * 3.1416f, 0.0f, 0.0f, 0.0f);
NewtonUserJoint* frownyHinge;
// Create a 6DOF joint
frownyHinge = CreateCustomJoint6DOF (&matrix[0][0], &matrix[0][0], frownyBody, NULL);
// set the hinge Limits
CustomJoint6DOF_SetLinearLimits (frownyHinge, &minLinearLimits[0], &maxLinearLimits[0]);
CustomJoint6DOF_SetAngularLimits (frownyHinge, &minAngulaLimits[0], &maxAngulaLimits[0]);
// now we will link the body of Smilly and Frowny with a specialize Hinge Joint
NewtonUserJoint* smillyFrownyHinge;
matrix.m_posit = smilly->m_curPosition;
matrix.m_posit.m_z += 0.2f;
matrix.m_posit.m_y += 0.4f;
smillyFrownyHinge = CreateCustomHinge (&matrix[0][0], smillyBody, frownyBody);
HingeEnableLimits (smillyFrownyHinge, 1);
HingeSetLimits (smillyFrownyHinge, -0.5f * 3.1416f, 0.5f * 3.1416f);
// smillyFrownyHinge = CreateCustomBallAndSocket (&matrix[0][0], smillyBody, frownyBody);
// BallAndSocketSetConeAngle (smillyFrownyHinge, 0.5f * 3.1416f);
// BallAndSocketSetTwistAngle (smillyFrownyHinge, -0.5f * 3.1416f, 0.5f * 3.1416f);
// smillyFrownyHinge = CreateCustomSlider (&matrix[0][0], smillyBody, frownyBody);
// SliderEnableLimits (smillyFrownyHinge, 1);
// SliderSetLimis (smillyFrownyHinge, -0.5f * 3.1416f, 0.5f * 3.1416f);
{
// adding two Kinematic controlled object
frowny = sceneManager->CreateEntity();
frowny->LoadMesh ("Frowny.dat");
frowny->m_curPosition.m_z = 4.0f;
frowny->m_curPosition.m_y = 7.0f;
frowny->m_prevPosition = frowny->m_curPosition;
shape = CreateNewtonConvex (world, frowny, 0);
frownyBody = CreateRigidBody (world, frowny, shape, 10.0f);
NewtonDestroyCollision(shape);
FollowPath* path;
NewtonUserJoint* g_pathFollow;
path = (FollowPath*) malloc (sizeof (FollowPath));
NewtonBodyGetMatrix (frownyBody, &matrix[0][0]);
path->m_origin = matrix.m_posit;
path->m_angle = 0.0f;
path->radius = 3.0f;
g_pathFollow = CreateCustomKinematicController (frownyBody, &matrix.m_posit[0]);
CustomKinematicControllerSetPickMode (g_pathFollow, 1);
CustomKinematicControllerSetMaxAngularFriction (g_pathFollow, 200.0f);
CustomKinematicControllerSetMaxLinearFriction (g_pathFollow, 1000.0f);
CustomSetUserData(g_pathFollow, path);
CustomSetDestructorCallback(g_pathFollow, FollowPath::Destroy);
CustomSetSubmitContraintCallback (g_pathFollow, FollowPath::EvaluatePath);
matrix = path->BuildMatrix (0.0f);
NewtonBodySetMatrix(frownyBody, &matrix[0][0]);
}
{
// adding two Kinematic controlled object
frowny = sceneManager->CreateEntity();
frowny->LoadMesh ("Frowny.dat");
frowny->m_curPosition.m_z = -4.0f;
frowny->m_curPosition.m_y = 6.0f;
frowny->m_prevPosition = frowny->m_curPosition;
shape = CreateNewtonConvex (world, frowny, 0);
frownyBody = CreateRigidBody (world, frowny, shape, 10.0f);
NewtonDestroyCollision(shape);
FollowPath* path;
NewtonUserJoint* g_pathFollow;
path = (FollowPath*) malloc (sizeof (FollowPath));
NewtonBodyGetMatrix (frownyBody, &matrix[0][0]);
path->m_origin = matrix.m_posit;
path->m_angle = 3.1416f;
path->radius = 3.0f;
g_pathFollow = CreateCustomKinematicController (frownyBody, &matrix.m_posit[0]);
CustomKinematicControllerSetPickMode (g_pathFollow, 1);
CustomKinematicControllerSetMaxAngularFriction (g_pathFollow, 200.0f);
CustomKinematicControllerSetMaxLinearFriction (g_pathFollow, 1000.0f);
CustomSetUserData(g_pathFollow, path);
CustomSetDestructorCallback(g_pathFollow, FollowPath::Destroy);
CustomSetSubmitContraintCallback (g_pathFollow, FollowPath::EvaluatePath);
matrix = path->BuildMatrix (0.0f);
NewtonBodySetMatrix(frownyBody, &matrix[0][0]);
}
}
static void MakeFunnyCompound (DemoEntityManager* const scene, const dVector& origin)
{
NewtonWorld* const world = scene->GetNewton();
// create an empty compound collision
NewtonCollision* const compound = NewtonCreateCompoundCollision (world, 0);
#if 1
NewtonCompoundCollisionBeginAddRemove(compound);
// add a bunch of convex collision at random position and orientation over the surface of a big sphere
float radio = 5.0f;
for (int i = 0 ; i < 300; i ++) {
NewtonCollision* collision = NULL;
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 = RandomVariable (0.5f);
float y = RandomVariable (0.5f);
float z = RandomVariable (0.5f);
if ((x == 0.0f) && (y == 0.0f) && (z == 0.0f)){
x = 0.1f;
}
dVector p (x, y, z, 1.0f) ;
p = p.Scale (radio / dSqrt (p % p));
dMatrix matrix (dPitchMatrix (pitch) * dYawMatrix (yaw) * dRollMatrix (roll));
matrix.m_posit = p;
int r = dRand();
switch ((r >>2) & 3)
{
case 0:
{
collision = NewtonCreateSphere(world, 0.5, 0, &matrix[0][0]) ;
break;
}
case 1:
{
collision = NewtonCreateCapsule(world, 0.3f, 0.2f, 0.5f, 0, &matrix[0][0]) ;
break;
}
case 2:
{
collision = NewtonCreateCylinder(world, 0.25, 0.5, 0.25, 0, &matrix[0][0]) ;
break;
}
case 3:
{
collision = NewtonCreateCone(world, 0.25, 0.25, 0, &matrix[0][0]) ;
break;
}
}
dAssert (collision);
// we can set a collision id, and use data per sub collision
NewtonCollisionSetUserID(collision, i);
NewtonCollisionSetUserData(collision, (void*) i);
// add this new collision
NewtonCompoundCollisionAddSubCollision (compound, collision);
NewtonDestroyCollision(collision);
}
// finish adding shapes
NewtonCompoundCollisionEndAddRemove(compound);
{
// remove the first 10 shapes
// test remove shape form a compound
NewtonCompoundCollisionBeginAddRemove(compound);
void* node = NewtonCompoundCollisionGetFirstNode(compound);
for (int i = 0; i < 10; i ++) {
//NewtonCollision* const collision = NewtonCompoundCollisionGetCollisionFromNode(compound, node);
void* const nextNode = NewtonCompoundCollisionGetNextNode(compound, node);
NewtonCompoundCollisionRemoveSubCollision(compound, node);
node = nextNode;
}
// finish remove
void* handle1 = NewtonCompoundCollisionGetNodeByIndex (compound, 30);
void* handle2 = NewtonCompoundCollisionGetNodeByIndex (compound, 100);
NewtonCollision* const shape1 = NewtonCompoundCollisionGetCollisionFromNode (compound, handle1);
NewtonCollision* const shape2 = NewtonCompoundCollisionGetCollisionFromNode (compound, handle2);
NewtonCollision* const copyShape1 = NewtonCollisionCreateInstance (shape1);
NewtonCollision* const copyShape2 = NewtonCollisionCreateInstance (shape2);
// you can also remove shape by their index
NewtonCompoundCollisionRemoveSubCollisionByIndex (compound, 30);
NewtonCompoundCollisionRemoveSubCollisionByIndex (compound, 100);
handle1 = NewtonCompoundCollisionAddSubCollision (compound, copyShape1);
handle2 = NewtonCompoundCollisionAddSubCollision (compound, copyShape2);
NewtonDestroyCollision(copyShape1);
NewtonDestroyCollision(copyShape2);
NewtonCompoundCollisionEndAddRemove(compound);
}
{
// show how to modify the children of a compound collision
NewtonCompoundCollisionBeginAddRemove(compound);
for (void* node = NewtonCompoundCollisionGetFirstNode(compound); node; node = NewtonCompoundCollisionGetNextNode(compound, node)) {
NewtonCollision* const collision = NewtonCompoundCollisionGetCollisionFromNode(compound, node);
// you can scale, change the matrix, change the inertia, do anything you want with the change
NewtonCollisionSetUserData(collision, NULL);
}
NewtonCompoundCollisionEndAddRemove(compound);
}
// NewtonCollisionSetScale(compound, 0.5f, 0.25f, 0.125f);
#else
//test Yeside compound shape shape
// - Rotation="1.5708 -0 0" Translation="0 0 0.024399" Size="0.021 0.096" Pos="0 0 0.115947"
// - Rotation="1.5708 -0 0" Translation="0 0 0.056366" Size="0.195 0.024" Pos="0 0 0.147914"
// - Rotation="1.5708 -0 0" Translation="0 0 -0.056366" Size="0.0065 0.07 Pos="0 0 0.035182"
NewtonCompoundCollisionBeginAddRemove(compound);
NewtonCollision* collision;
dMatrix offsetMatrix (dPitchMatrix(1.5708f));
offsetMatrix.m_posit.m_z = 0.115947f;
collision = NewtonCreateCylinder (world, 0.021f, 0.096f, 0, &offsetMatrix[0][0]) ;
NewtonCompoundCollisionAddSubCollision (compound, collision);
NewtonDestroyCollision(collision);
offsetMatrix.m_posit.m_z = 0.035182f;
collision = NewtonCreateCylinder (world, 0.0065f, 0.07f, 0, &offsetMatrix[0][0]) ;
NewtonCompoundCollisionAddSubCollision (compound, collision);
NewtonDestroyCollision(collision);
offsetMatrix.m_posit.m_z = 0.147914f;
collision = NewtonCreateCylinder (world, 0.195f, 0.024f, 0, &offsetMatrix[0][0]) ;
NewtonCompoundCollisionAddSubCollision (compound, collision);
NewtonDestroyCollision(collision);
NewtonCompoundCollisionEndAddRemove(compound);
#endif
// for now we will simple make simple Box, make a visual Mesh
DemoMesh* const visualMesh = new DemoMesh ("big ball", compound, "metal_30.tga", "metal_30.tga", "metal_30.tga");
int instaceCount = 2;
dMatrix matrix (dGetIdentityMatrix());
matrix.m_posit = origin;
for (int ix = 0; ix < instaceCount; ix ++) {
for (int iz = 0; iz < instaceCount; iz ++) {
dFloat y = origin.m_y;
dFloat x = origin.m_x + (ix - instaceCount/2) * 15.0f;
dFloat z = origin.m_z + (iz - instaceCount/2) * 15.0f;
matrix.m_posit = FindFloor (world, dVector (x, y + 10.0f, z, 0.0f), 20.0f); ;
matrix.m_posit.m_y += 15.0f;
CreateSimpleSolid (scene, visualMesh, 10.0f, matrix, compound, 0);
}
}
visualMesh->Release();
NewtonDestroyCollision(compound);
}
VoronoidEffect(NewtonWorld* const world, NewtonMesh* const mesh, int interiorMaterial)
:FractureEffect(world)
{
// first we populate the bounding Box area with few random point to get some interior subdivisions.
// the subdivision are local to the point placement, by placing these points visual ally with a 3d tool
// and have precise control of how the debris are created.
// the number of pieces is equal to the number of point inside the Mesh plus the number of point on the mesh
dVector size(0.0f);
dMatrix matrix(dGetIdentityMatrix());
NewtonMeshCalculateOOBB(mesh, &matrix[0][0], &size.m_x, &size.m_y, &size.m_z);
dVector points[NUMBER_OF_INTERNAL_PARTS + 8];
int count = 0;
// pepper the inside of the BBox box of the mesh with random points
while (count < NUMBER_OF_INTERNAL_PARTS) {
dFloat x = dGaussianRandom (size.m_x);
dFloat y = dGaussianRandom (size.m_y);
dFloat z = dGaussianRandom (size.m_z);
if ((x <= size.m_x) && (x >= -size.m_x) && (y <= size.m_y) && (y >= -size.m_y) && (z <= size.m_z) && (z >= -size.m_z)) {
points[count] = dVector(x, y, z);
count++;
}
}
// add the bounding box as a safeguard area
points[count + 0] = dVector(size.m_x, size.m_y, size.m_z, 0.0f);
points[count + 1] = dVector(size.m_x, size.m_y, -size.m_z, 0.0f);
points[count + 2] = dVector(size.m_x, -size.m_y, size.m_z, 0.0f);
points[count + 3] = dVector(size.m_x, -size.m_y, -size.m_z, 0.0f);
points[count + 4] = dVector(-size.m_x, size.m_y, size.m_z, 0.0f);
points[count + 5] = dVector(-size.m_x, size.m_y, -size.m_z, 0.0f);
points[count + 6] = dVector(-size.m_x, -size.m_y, size.m_z, 0.0f);
points[count + 7] = dVector(-size.m_x, -size.m_y, -size.m_z, 0.0f);
count += 8;
// create a texture matrix, for applying the material's UV to all internal faces
dMatrix textureMatrix(dGetIdentityMatrix());
textureMatrix[0][0] = 1.0f / size.m_x;
textureMatrix[1][1] = 1.0f / size.m_y;
// Get the volume of the original mesh
NewtonCollision* const collision1 = NewtonCreateConvexHullFromMesh(m_world, mesh, 0.0f, 0);
dFloat volume = NewtonConvexCollisionCalculateVolume(collision1);
NewtonDestroyCollision(collision1);
// now we call create we decompose the mesh into several convex pieces
NewtonMesh* const debriMeshPieces = NewtonMeshCreateVoronoiConvexDecomposition(m_world, count, &points[0].m_x, sizeof (dVector), interiorMaterial, &textureMatrix[0][0]);
dAssert(debriMeshPieces);
// now we iterate over each pieces and for each one we create a visual entity and a rigid body
NewtonMesh* nextDebri;
for (NewtonMesh* debri = NewtonMeshCreateFirstLayer(debriMeshPieces); debri; debri = nextDebri) {
// get next segment piece
nextDebri = NewtonMeshCreateNextLayer(debriMeshPieces, debri);
//clip the voronoi convexes against the mesh
NewtonMesh* const fracturePiece = NewtonMeshConvexMeshIntersection(mesh, debri);
if (fracturePiece) {
// make a convex hull collision shape
NewtonCollision* const collision = NewtonCreateConvexHullFromMesh(m_world, fracturePiece, 0.0f, 0);
if (collision) {
// we have a piece which has a convex collision representation, add that to the list
FractureAtom& atom = Append()->GetInfo();
atom.m_mesh = new DemoMesh(fracturePiece);
atom.m_collision = collision;
NewtonConvexCollisionCalculateInertialMatrix(atom.m_collision, &atom.m_momentOfInirtia[0], &atom.m_centerOfMass[0]);
dFloat debriVolume = NewtonConvexCollisionCalculateVolume(atom.m_collision);
atom.m_massFraction = debriVolume / volume;
}
NewtonMeshDestroy(fracturePiece);
}
NewtonMeshDestroy(debri);
}
NewtonMeshDestroy(debriMeshPieces);
}
static void LoadHangingBridge (DemoEntityManager* const scene, TriggerManager* const triggerManager, NewtonCollision* const sceneCollision, const char* const name, const dMatrix& location, NewtonBody* const playGroundBody)
{
NewtonWorld* const world = scene->GetNewton();
DemoEntityManager::dListNode* const bridgeNodes = scene->GetLast();
LoadScene(scene, name, location);
// add bridge foundations
for (DemoEntityManager::dListNode* node = bridgeNodes->GetNext(); node; node = node->GetNext()) {
DemoEntity* const entity = node->GetInfo();
if (entity->GetName().Find("ramp") != -1) {
DemoMesh* const mesh = (DemoMesh*)entity->GetMesh();
dAssert (mesh->IsType(DemoMesh::GetRttiType()));
NewtonCollision* const collision = NewtonCreateConvexHull(world, mesh->m_vertexCount, mesh->m_vertex, 3 * sizeof (dFloat), 0, 0, NULL);
void* const proxy = NewtonSceneCollisionAddSubCollision (sceneCollision, collision);
NewtonDestroyCollision (collision);
// get the location of this tire relative to the car chassis
dMatrix matrix (entity->GetNextMatrix());
NewtonCollision* const bridgeCollision = NewtonSceneCollisionGetCollisionFromNode (sceneCollision, proxy);
NewtonSceneCollisionSetSubCollisionMatrix (sceneCollision, proxy, &matrix[0][0]);
NewtonCollisionSetUserData(bridgeCollision, entity);
}
}
// add all the planks that form the bridge
dTree<NewtonBody*, dString> planks;
dFloat plankMass = 30.0f;
for (DemoEntityManager::dListNode* node = bridgeNodes->GetNext(); node; node = node->GetNext()) {
DemoEntity* const entity = node->GetInfo();
if (entity->GetName().Find("plank") != -1) {
DemoMesh* const mesh = (DemoMesh*)entity->GetMesh();
dAssert (mesh->IsType(DemoMesh::GetRttiType()));
// note: because the mesh matrix can have scale, for simplicity just apply the local mesh matrix to the vertex cloud
dVector pool[128];
const dMatrix& meshMatrix = entity->GetMeshMatrix();
meshMatrix.TransformTriplex(&pool[0].m_x, sizeof (dVector), mesh->m_vertex, 3 * sizeof (dFloat), mesh->m_vertexCount);
NewtonCollision* const collision = NewtonCreateConvexHull(world, mesh->m_vertexCount, &pool[0].m_x, sizeof (dVector), 0, 0, NULL);
NewtonBody* const body = CreateSimpleBody (world, entity, plankMass, entity->GetNextMatrix(), collision, 0);
NewtonDestroyCollision (collision);
planks.Insert(body, entity->GetName());
}
}
// connect each plant with a hinge
// calculate the with of a plank
dFloat plankwidth = 0.0f;
dVector planksideDir (1.0f, 0.0f, 0.0f, 0.0f);
{
NewtonBody* const body0 = planks.Find("plank01")->GetInfo();
NewtonBody* const body1 = planks.Find("plank02")->GetInfo();
dMatrix matrix0;
dMatrix matrix1;
NewtonBodyGetMatrix(body0, &matrix0[0][0]);
NewtonBodyGetMatrix(body1, &matrix1[0][0]);
planksideDir = matrix1.m_posit - matrix0.m_posit;
planksideDir = planksideDir.Scale (1.0f / dSqrt (planksideDir % planksideDir));
dVector dir (matrix0.UnrotateVector(planksideDir));
NewtonCollision* const shape = NewtonBodyGetCollision(body0);
dVector p0;
dVector p1;
NewtonCollisionSupportVertex(shape, &dir[0], &p0[0]);
dVector dir1 (dir.Scale (-1.0f));
NewtonCollisionSupportVertex(shape, &dir1[0], &p1[0]);
plankwidth = dAbs (0.5f * ((p1 - p0) % dir));
}
dTree<NewtonBody*, dString>::Iterator iter (planks);
iter.Begin();
dMatrix matrix0;
NewtonBody* body0 = iter.GetNode()->GetInfo();
NewtonBodyGetMatrix(body0, &matrix0[0][0]);
for (iter ++; iter; iter ++) {
NewtonBody* const body1 = iter.GetNode()->GetInfo();
dMatrix matrix1;
NewtonBodyGetMatrix(body1, &matrix1[0][0]);
// calculate the hinge parameter form the matrix location of each plank
dMatrix pinMatrix0 (dGetIdentityMatrix());
pinMatrix0[0] = pinMatrix0[1] * planksideDir;
pinMatrix0[0] = pinMatrix0[0].Scale (1.0f / dSqrt (pinMatrix0[0] % pinMatrix0[0]));
pinMatrix0[2] = pinMatrix0[0] * pinMatrix0[1];
pinMatrix0[0][3] = 0.0f;
pinMatrix0[1][3] = 0.0f;
pinMatrix0[2][3] = 0.0f;
// calculate the pivot
pinMatrix0[3] = matrix0.m_posit + pinMatrix0[2].Scale (plankwidth);
pinMatrix0[3][3] = 1.0f;
dMatrix pinMatrix1 (pinMatrix0);
pinMatrix1[3] = matrix1.m_posit - pinMatrix1[2].Scale (plankwidth);
pinMatrix1[3][3] = 1.0f;
// connect these two plank by a hinge, there a wiggle space between eh hinge that give therefore use the alternate hinge constructor
new CustomHinge (pinMatrix0, pinMatrix1, body0, body1);
body0 = body1;
matrix0 = matrix1;
}
// connect the last and first plank to the bridge base
{
iter.Begin();
body0 = iter.GetNode()->GetInfo();
NewtonBodyGetMatrix(body0, &matrix0[0][0]);
dMatrix pinMatrix0 (dGetIdentityMatrix());
pinMatrix0[0] = pinMatrix0[1] * planksideDir;
pinMatrix0[0] = pinMatrix0[0].Scale (1.0f / dSqrt (pinMatrix0[0] % pinMatrix0[0]));
pinMatrix0[2] = pinMatrix0[0] * pinMatrix0[1];
pinMatrix0[0][3] = 0.0f;
pinMatrix0[1][3] = 0.0f;
pinMatrix0[2][3] = 0.0f;
pinMatrix0[3] = matrix0.m_posit - pinMatrix0[2].Scale (plankwidth);
new CustomHinge (pinMatrix0, body0, playGroundBody);
}
{
iter.End();
body0 = iter.GetNode()->GetInfo();
NewtonBodyGetMatrix(body0, &matrix0[0][0]);
dMatrix pinMatrix0 (dGetIdentityMatrix());
pinMatrix0[0] = pinMatrix0[1] * planksideDir;
pinMatrix0[0] = pinMatrix0[0].Scale (1.0f / dSqrt (pinMatrix0[0] % pinMatrix0[0]));
pinMatrix0[2] = pinMatrix0[0] * pinMatrix0[1];
pinMatrix0[0][3] = 0.0f;
pinMatrix0[1][3] = 0.0f;
pinMatrix0[2][3] = 0.0f;
pinMatrix0[3] = matrix0.m_posit + pinMatrix0[2].Scale (plankwidth);
new CustomHinge (pinMatrix0, body0, playGroundBody);
}
}
static void LoadSlide (DemoEntityManager* const scene, TriggerManager* const triggerManager, NewtonCollision* const sceneCollision, const char* const name, const dMatrix& location, NewtonBody* const playGroundBody)
{
NewtonWorld* const world = scene->GetNewton();
DemoEntityManager::dListNode* const bridgeNodes = scene->GetLast();
LoadScene(scene, name, location);
// add bridge foundations
for (DemoEntityManager::dListNode* node = bridgeNodes->GetNext(); node; node = node->GetNext()) {
DemoEntity* const entity = node->GetInfo();
if (entity->GetName().Find("ramp") != -1) {
DemoMesh* const mesh = (DemoMesh*)entity->GetMesh();
dAssert (mesh->IsType(DemoMesh::GetRttiType()));
NewtonCollision* const collision = NewtonCreateConvexHull(world, mesh->m_vertexCount, mesh->m_vertex, 3 * sizeof (dFloat), 0, 0, NULL);
void* const proxy = NewtonSceneCollisionAddSubCollision (sceneCollision, collision);
NewtonDestroyCollision (collision);
// get the location of this tire relative to the car chassis
dMatrix matrix (entity->GetNextMatrix());
NewtonCollision* const bridgeCollision = NewtonSceneCollisionGetCollisionFromNode (sceneCollision, proxy);
NewtonSceneCollisionSetSubCollisionMatrix (sceneCollision, proxy, &matrix[0][0]);
NewtonCollisionSetUserData(bridgeCollision, entity);
}
}
// add start triggers
CustomTriggerController* trigger0 = NULL;
CustomTriggerController* trigger1 = NULL;
for (DemoEntityManager::dListNode* node = bridgeNodes->GetNext(); node;) {
DemoEntity* const entity = node->GetInfo();
node = node->GetNext() ;
if (entity->GetName().Find("startTrigger") != -1) {
DemoMesh* const mesh = (DemoMesh*)entity->GetMesh();
dAssert (mesh->IsType(DemoMesh::GetRttiType()));
// create a trigger to match his mesh
NewtonCollision* const collision = NewtonCreateConvexHull(world, mesh->m_vertexCount, mesh->m_vertex, 3 * sizeof (dFloat), 0, 0, NULL);
dMatrix matrix (entity->GetNextMatrix());
CustomTriggerController* const controller = triggerManager->CreateTrigger(matrix, collision, NULL);
NewtonDestroyCollision (collision);
if (!trigger0) {
trigger0 = controller;
} else {
trigger1 = controller;
}
// remove this entity from the scene, since we do not wan the trigger to be visible
// to see triggers click "show collision mesh, and or "show contact points" in the main menu.
scene->RemoveEntity(entity);
}
}
// add the platform object
for (DemoEntityManager::dListNode* node = bridgeNodes->GetNext(); node;) {
DemoEntity* const entity = node->GetInfo();
node = node->GetNext() ;
if (entity->GetName().Find("platform") != -1) {
// make a platform object
PlaformEntityEntity* const platformEntity = new PlaformEntityEntity (scene, entity, trigger0->GetBody(), trigger1->GetBody());
// store the platform in the trigger use data
trigger0->SetUserData(platformEntity);
trigger1->SetUserData(platformEntity);
// remove this entity from the scene
scene->RemoveEntity(entity);
}
}
}
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();
dMatrix aligmentUV (dGetIdentityMatrix());
#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, &aligmentUV[0][0]);
#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 NewtonBody* CreateBackgroundWallsAndCellingBody(NewtonWorld* world)
{
// make a flat quad
dFloat floor[4][3] =
{
{ -100.0f, 0.0f, 100.0f },
{ 100.0f, 0.0f, 100.0f },
{ 100.0f, 0.0f, -100.0f },
{ -100.0f, 0.0f, -100.0f },
};
dFloat wall_N[4][3] =
{
{ -100.0f, 0.0f, 100.0f },
{ -100.0f, 100.0f, 100.0f },
{ 100.0f, 100.0f, 100.0f },
{ 100.0f, 0.0f, 100.0f },
};
dFloat wall_W[4][3] =
{
{ 100.0f, 0.0f, 100.0f },
{ 100.0f, 100.0f, 100.0f },
{ 100.0f, 100.0f, -100.0f },
{ 100.0f, 0.0f, -100.0f },
};
dFloat wall_S[4][3] =
{
{ 100.0f, 0.0f, -100.0f },
{ 100.0f, 100.0f, -100.0f },
{ -100.0f, 100.0f, -100.0f },
{ -100.0f, 0.0f, -100.0f },
};
dFloat wall_E[4][3] =
{
{ -100.0f, 0.0f, -100.0f },
{ -100.0f, 100.0f, -100.0f },
{ -100.0f, 100.0f, 100.0f },
{ -100.0f, 0.0f, 100.0f },
};
dFloat celling[4][3] =
{
{ -100.0f, 100.0f, -100.0f },
{ 100.0f, 100.0f, -100.0f },
{ 100.0f, 100.0f, 100.0f },
{ -100.0f, 100.0f, 100.0f },
};
// crate a collision tree
NewtonCollision* const collision = NewtonCreateTreeCollision(world, 0);
// start building the collision mesh
NewtonTreeCollisionBeginBuild(collision);
// add the face one at a time
NewtonTreeCollisionAddFace(collision, 4, &floor[0][0], 3 * sizeof (dFloat), 0);
NewtonTreeCollisionAddFace(collision, 4, &wall_N[0][0], 3 * sizeof (dFloat), 0);
NewtonTreeCollisionAddFace(collision, 4, &wall_W[0][0], 3 * sizeof (dFloat), 0);
NewtonTreeCollisionAddFace(collision, 4, &wall_S[0][0], 3 * sizeof (dFloat), 0);
NewtonTreeCollisionAddFace(collision, 4, &wall_E[0][0], 3 * sizeof (dFloat), 0);
NewtonTreeCollisionAddFace(collision, 4, &celling[0][0], 3 * sizeof (dFloat), 0);
// finish building the collision
NewtonTreeCollisionEndBuild(collision, 1);
// create a body with a collision and locate at the identity matrix position
dMatrix matrix(dGetIdentityMatrix());
NewtonBody* const body = NewtonCreateDynamicBody(world, collision, &matrix[0][0]);
// do no forget to destroy the collision after you not longer need it
NewtonDestroyCollision(collision);
return body;
}
// create a mesh using the dNewtonMesh wrapper
static NewtonBody* CreateSimpledBox_dNetwonMesh(DemoEntityManager* const scene, const dVector& origin, const dVector& scale, dFloat mass)
{
dVector array[8];
dVector scale1(scale);
for (int i = 0; i < 8; i++) {
dVector p(&BoxPoints[i * 4]);
array[i] = scale1 * p;
}
dNewtonMesh buildMesh(scene->GetNewton());
// start build a mesh
buildMesh.BeginBuild();
// add faces one at a time
int index = 0;
const int faceCount = sizeof (faceIndexList)/sizeof (faceIndexList[0]);
for (int i = 0; i < faceCount; i ++) {
const int indexCount = faceIndexList[i];
const int faceMaterail = faceMateriaIndexList[i];
buildMesh.BeginPolygon();
for (int j = 0; j < indexCount; j ++) {
// add a mesh point
int k = BoxIndices[index + j];
buildMesh.AddPoint(array[k].m_x, array[k].m_y, array[k].m_z);
// add vertex normal
int n = faceNormalIndex[index + j];
buildMesh.AddNormal (dFloat32 (normal[n * 3 + 0]), dFloat32 (normal[n * 3 + 1]), dFloat32 (normal[n * 3 + 2]));
// add face material index
buildMesh.AddMaterial(faceMaterail);
// continue adding more vertex attributes of you want, uv, binormal, weights, etc
}
buildMesh.EndPolygon();
index += indexCount;
}
buildMesh.EndBuild();
// get the newtonMesh from the dNewtonMesh class and use it to build a render mesh, collision or anything
NewtonMesh* const newtonMesh = buildMesh.GetMesh();
// test collision tree
//NewtonCollision* const collisionTree = NewtonCreateTreeCollisionFromMesh (scene->GetNewton(), newtonMesh, 0);
//NewtonDestroyCollision(collisionTree);
// now we can use this mesh for lot of stuff, we can apply UV, we can decompose into convex,
NewtonCollision* const collision = NewtonCreateConvexHullFromMesh(scene->GetNewton(), newtonMesh, 0.001f, 0);
// for now we will simple make simple Box, make a visual Mesh
DemoMesh* const visualMesh = new DemoMesh(newtonMesh);
dMatrix matrix(dGetIdentityMatrix());
matrix.m_posit = origin;
matrix.m_posit.m_w = 1.0f;
NewtonBody* const body = CreateSimpleSolid(scene, visualMesh, mass, matrix, collision, 0);
dVector veloc (1, 0, 2, 0);
NewtonBodySetVelocity(body, &veloc[0]);
visualMesh->Release();
NewtonDestroyCollision(collision);
return body;
}
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", 1);
dVector location (0.0f, 0.0f, 0.0f, 0.0f);
// create some spheres
dVector sphSize (2.0f, 2.0f, 2.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 (2.0f, 2.0f, 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 restitution = 0.1f * (i + 1);
dFloat z;
dFloat x;
dFloat mass;
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;
matrix.m_posit.m_y += 6.0f;
CreateResititionBody(scene, sphereMesh, mass, matrix, sphereCollision, defaultMaterialID, restitution);
matrix.m_posit.m_y += 6.0f;
CreateResititionBody(scene, sphereMesh, mass, matrix, sphereCollision, defaultMaterialID, restitution);
matrix.m_posit.m_y += 6.0f;
CreateResititionBody(scene, sphereMesh, mass, matrix, sphereCollision, defaultMaterialID, restitution);
matrix.m_posit.m_y += 6.0f;
CreateResititionBody(scene, boxMesh, mass, matrix, boxCollision, defaultMaterialID, 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);
}
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);
}
CustomPlayerController::~CustomPlayerController()
{
NewtonDestroyBody(m_body);
NewtonDestroyCollision (m_castingShape);
}
static NewtonBody* CreateHeightFieldTerrain (DemoEntityManager* const scene, int sizeInPowerOfTwos, dFloat cellSize, dFloat elevationScale, dFloat roughness, dFloat maxElevation, dFloat minElevation)
{
int size = (1 << sizeInPowerOfTwos) + 1 ;
dFloat* const elevation = new dFloat [size * size];
//MakeFractalTerrain (elevation, sizeInPowerOfTwos, elevationScale, roughness, maxElevation, minElevation);
MakeFractalTerrain (elevation, sizeInPowerOfTwos, elevationScale, roughness, maxElevation, minElevation);
for (int i = 0; i < 4; i ++) {
ApplySmoothFilter (elevation, size);
}
//memset (elevation, 0, size * size * sizeof (dFloat));
//SetBaseHeight (elevation, size);
// apply simple calderas
// MakeCalderas (elevation, size, maxElevation * 0.7f, maxElevation * 0.1f);
// // create the visual mesh
DemoMesh* const mesh = new DemoMesh ("terrain", elevation, size, cellSize, 1.0f/4.0f, TILE_SIZE);
DemoEntity* const entity = new DemoEntity(dGetIdentityMatrix(), NULL);
scene->Append (entity);
entity->SetMesh(mesh, dGetIdentityMatrix());
mesh->Release();
// create the height field collision and rigid body
// create the attribute map
int width = size;
int height = size;
char* const attibutes = new char [size * size];
memset (attibutes, 0, width * height * sizeof (char));
NewtonCollision* collision = NewtonCreateHeightFieldCollision (scene->GetNewton(), width, height, 1, 0, elevation, attibutes, 1.0f, cellSize, 0);
#ifdef USE_STATIC_MESHES_DEBUG_COLLISION
NewtonStaticCollisionSetDebugCallback (collision, ShowMeshCollidingFaces);
#endif
NewtonCollisionInfoRecord collisionInfo;
// keep the compiler happy
memset (&collisionInfo, 0, sizeof (NewtonCollisionInfoRecord));
NewtonCollisionGetInfo (collision, &collisionInfo);
width = collisionInfo.m_heightField.m_width;
height = collisionInfo.m_heightField.m_height;
//elevations = collisionInfo.m_heightField.m_elevation;
dVector boxP0;
dVector boxP1;
// get the position of the aabb of this geometry
dMatrix matrix (entity->GetCurrentMatrix());
NewtonCollisionCalculateAABB (collision, &matrix[0][0], &boxP0.m_x, &boxP1.m_x);
matrix.m_posit = (boxP0 + boxP1).Scale (-0.5f);
matrix.m_posit.m_w = 1.0f;
//SetMatrix (matrix);
entity->ResetMatrix (*scene, matrix);
// create the terrainBody rigid body
NewtonBody* const terrainBody = NewtonCreateDynamicBody(scene->GetNewton(), collision, &matrix[0][0]);
// release the collision tree (this way the application does not have to do book keeping of Newton objects
NewtonDestroyCollision (collision);
// in newton 300 collision are instance, you need to ready it after you create a body, if you want to male call on the instance
collision = NewtonBodyGetCollision(terrainBody);
#if 0
// uncomment this to test horizontal displacement
unsigned short* const horizontalDisplacemnet = new unsigned short[size * size];
for (int i = 0; i < size * size; i++) {
horizontalDisplacemnet[i] = dRand();
}
NewtonHeightFieldSetHorizontalDisplacement(collision, horizontalDisplacemnet, 0.02f);
delete horizontalDisplacemnet;
#endif
// save the pointer to the graphic object with the body.
NewtonBodySetUserData (terrainBody, entity);
// set the global position of this body
// NewtonBodySetMatrix (m_terrainBody, &matrix[0][0]);
// set the destructor for this object
//NewtonBodySetDestructorCallback (terrainBody, Destructor);
// get the position of the aabb of this geometry
//NewtonCollisionCalculateAABB (collision, &matrix[0][0], &boxP0.m_x, &boxP1.m_x);
#ifdef USE_TEST_ALL_FACE_USER_RAYCAST_CALLBACK
// set a ray cast callback for all face ray cast
NewtonTreeCollisionSetUserRayCastCallback (collision, AllRayHitCallback);
dVector p0 (0, 100, 0, 0);
dVector p1 (0, -100, 0, 0);
dVector normal;
dLong id;
dFloat parameter;
parameter = NewtonCollisionRayCast (collision, &p0[0], &p1[0], &normal[0], &id);
#endif
delete[] attibutes;
delete[] elevation;
return terrainBody;
}
NewtonCollision* CreateConvexCollision (NewtonWorld* world, const dMatrix& srcMatrix, const dVector& originalSize, PrimitiveType type, int materialID__)
{
dVector size (originalSize);
NewtonCollision* collision = NULL;
switch (type)
{
case _NULL_PRIMITIVE:
{
collision = NewtonCreateNull (world);
break;
}
case _SPHERE_PRIMITIVE:
{
// create the collision
collision = NewtonCreateSphere (world, size.m_x * 0.5f, 0, NULL);
break;
}
case _BOX_PRIMITIVE:
{
// create the collision
collision = NewtonCreateBox (world, size.m_x, size.m_y, size.m_z, 0, NULL);
break;
}
case _CONE_PRIMITIVE:
{
dFloat r = size.m_x * 0.5f;
dFloat h = size.m_y;
// create the collision
collision = NewtonCreateCone (world, r, h, 0, NULL);
break;
}
case _CYLINDER_PRIMITIVE:
{
// create the collision
collision = NewtonCreateCylinder (world, size.m_x * 0.5f, size.m_z * 0.5f, size.m_y, 0, NULL);
break;
}
case _CAPSULE_PRIMITIVE:
{
// create the collision
collision = NewtonCreateCapsule (world, size.m_x * 0.5f, size.m_z * 0.5f, size.m_y, 0, NULL);
break;
}
case _CHAMFER_CYLINDER_PRIMITIVE:
{
// create the collision
collision = NewtonCreateChamferCylinder (world, size.m_x * 0.5f, size.m_y, 0, NULL);
break;
}
case _RANDOM_CONVEX_HULL_PRIMITIVE:
{
// Create a clouds of random point around the origin
#define SAMPLE_COUNT 200
dVector cloud [SAMPLE_COUNT];
// make sure that at least the top and bottom are present
cloud [0] = dVector ( size.m_x * 0.5f, 0.0f, 0.0f, 0.0f);
cloud [1] = dVector (-size.m_x * 0.5f, 0.0f, 0.0f, 0.0f);
cloud [2] = dVector ( 0.0f, size.m_y * 0.5f, 0.0f, 0.0f);
cloud [3] = dVector ( 0.0f, -size.m_y * 0.5f, 0.0f, 0.0f);
cloud [4] = dVector (0.0f, 0.0f, size.m_z * 0.5f, 0.0f);
cloud [5] = dVector (0.0f, 0.0f, -size.m_z * 0.5f, 0.0f);
int count = 6;
// populate the cloud with pseudo Gaussian random points
for (int i = 6; i < SAMPLE_COUNT; i ++) {
cloud [i].m_x = RandomVariable(size.m_x);
cloud [i].m_y = RandomVariable(size.m_y);
cloud [i].m_z = RandomVariable(size.m_z);
count ++;
}
collision = NewtonCreateConvexHull (world, count, &cloud[0].m_x, sizeof (dVector), 0.01f, 0, NULL);
break;
}
case _REGULAR_CONVEX_HULL_PRIMITIVE:
{
// Create a clouds of random point around the origin
#define STEPS_HULL 6
//#define STEPS_HULL 3
//dVector cloud [STEPS_HULL * 4 + 256];
dFloat cloud [STEPS_HULL * 4 + 256][3];
int count = 0;
dFloat radius = size.m_y;
dFloat height = size.m_x * 0.999f;
dFloat x = - height * 0.5f;
dMatrix rotation (dPitchMatrix(2.0f * 3.141592f / STEPS_HULL));
for (int i = 0; i < 4; i ++) {
dFloat pad = ((i == 1) || (i == 2)) * 0.25f * radius;
dVector p (x, 0.0f, radius + pad);
x += 0.3333f * height;
dMatrix acc (dGetIdentityMatrix());
for (int j = 0; j < STEPS_HULL; j ++) {
dVector tmp (acc.RotateVector(p));
cloud[count][0] = tmp.m_x;
cloud[count][1] = tmp.m_y;
cloud[count][2] = tmp.m_z;
acc = acc * rotation;
count ++;
}
}
collision = NewtonCreateConvexHull (world, count, &cloud[0][0], 3 * sizeof (dFloat), 0.02f, 0, NULL);
break;
}
case _COMPOUND_CONVEX_CRUZ_PRIMITIVE:
{
//dMatrix matrix (GetIdentityMatrix());
dMatrix matrix (dPitchMatrix(15.0f * 3.1416f / 180.0f) * dYawMatrix(15.0f * 3.1416f / 180.0f) * dRollMatrix(15.0f * 3.1416f / 180.0f));
// NewtonCollision* const collisionA = NewtonCreateBox (world, size.m_x, size.m_x * 0.25f, size.m_x * 0.25f, 0, &matrix[0][0]);
// NewtonCollision* const collisionB = NewtonCreateBox (world, size.m_x * 0.25f, size.m_x, size.m_x * 0.25f, 0, &matrix[0][0]);
// NewtonCollision* const collisionC = NewtonCreateBox (world, size.m_x * 0.25f, size.m_x * 0.25f, size.m_x, 0, &matrix[0][0]);
matrix.m_posit = dVector (size.m_x * 0.5f, 0.0f, 0.0f, 1.0f);
NewtonCollision* const collisionA = NewtonCreateBox (world, size.m_x, size.m_x * 0.25f, size.m_x * 0.25f, 0, &matrix[0][0]);
matrix.m_posit = dVector (0.0f, size.m_x * 0.5f, 0.0f, 1.0f);
NewtonCollision* const collisionB = NewtonCreateBox (world, size.m_x * 0.25f, size.m_x, size.m_x * 0.25f, 0, &matrix[0][0]);
matrix.m_posit = dVector (0.0f, 0.0f, size.m_x * 0.5f, 1.0f);
NewtonCollision* const collisionC = NewtonCreateBox (world, size.m_x * 0.25f, size.m_x * 0.25f, size.m_x, 0, &matrix[0][0]);
collision = NewtonCreateCompoundCollision (world, 0);
NewtonCompoundCollisionBeginAddRemove(collision);
NewtonCompoundCollisionAddSubCollision (collision, collisionA);
NewtonCompoundCollisionAddSubCollision (collision, collisionB);
NewtonCompoundCollisionAddSubCollision (collision, collisionC);
NewtonCompoundCollisionEndAddRemove(collision);
NewtonDestroyCollision(collisionA);
NewtonDestroyCollision(collisionB);
NewtonDestroyCollision(collisionC);
break;
}
default: dAssert (0);
}
dMatrix matrix (srcMatrix);
matrix.m_front = matrix.m_front.Scale (1.0f / dSqrt (matrix.m_front % matrix.m_front));
matrix.m_right = matrix.m_front * matrix.m_up;
matrix.m_right = matrix.m_right.Scale (1.0f / dSqrt (matrix.m_right % matrix.m_right));
matrix.m_up = matrix.m_right * matrix.m_front;
NewtonCollisionSetMatrix(collision, &matrix[0][0]);
return collision;
}
// create physics scene
void PuckSlide (DemoEntityManager* const scene)
{
scene->CreateSkyBox();
NewtonWorld* const world = scene->GetNewton();
int materialGroupIDs[SB_NUM_MATERIALS];
// Create groups
for (int i = 0; i < SB_NUM_MATERIALS; i++)
{
materialGroupIDs[i] = NewtonMaterialCreateGroupID(world);
}
// Setup the material data
NewtonMaterialSetDefaultSoftness(world, materialGroupIDs[SBMaterial_WEIGHT], materialGroupIDs[SBMaterial_SURFACE], 0.15f);
NewtonMaterialSetDefaultElasticity(world, materialGroupIDs[SBMaterial_WEIGHT], materialGroupIDs[SBMaterial_SURFACE], 0.30f);
NewtonMaterialSetDefaultFriction(world, materialGroupIDs[SBMaterial_WEIGHT], materialGroupIDs[SBMaterial_SURFACE], 0.05f, 0.04f);
// setup callbacks for collisions between two material groups
NewtonMaterialSetCollisionCallback(world,materialGroupIDs[SBMaterial_WEIGHT],materialGroupIDs[SBMaterial_SURFACE],NULL,PhysicsNewton_CollisionPuckSurfaceCB);
///////
// Add table
{
dVector tableSize(TABLE_LENGTH, TABLE_HEIGHT, TABLE_WIDTH, 0.0f);
// create the shape and visual mesh as a common data to be re used
NewtonCollision* const collision = CreateConvexCollision (world, dGetIdentityMatrix(), tableSize, _BOX_PRIMITIVE, materialGroupIDs[SBMaterial_SURFACE]);
DemoMesh* const geometry = new DemoMesh("cylinder_1", collision, "wood_3.tga", "wood_3.tga", "wood_3.tga");
dMatrix matrix = dGetIdentityMatrix();
matrix.m_posit.m_x = 0.0f;
matrix.m_posit.m_z = 0.0f;
matrix.m_posit.m_y = 0.0f;
NewtonBody* const tableBody = CreateSimpleSolid (scene, geometry, 0.0, matrix, collision, materialGroupIDs[SBMaterial_SURFACE]);
// this is deprecated, use NewtonBodySetMassProperties
//NewtonBodySetMassMatrix(tableBody, 0.0f, 1.0f, 1.0f, 1.0f);
NewtonBodySetMassProperties(tableBody, 0.0f, NewtonBodyGetCollision(tableBody));
NewtonBodySetMaterialGroupID(tableBody, materialGroupIDs[SBMaterial_SURFACE]);
// it is not wise to se static body to continuous collision mode
//NewtonBodySetContinuousCollisionMode(tableBody, 1);
// do not forget to release the assets
geometry->Release();
// the collision need to be destroy, the body is using an instance no a reference
NewtonDestroyCollision (collision);
}
///////
// Add puck
{
new PuckEntity (scene, materialGroupIDs[SBMaterial_WEIGHT]);
}
// place camera into position
dMatrix camMatrix (dPitchMatrix(20.0f * 3.1416f /180.0f));
dQuaternion rot (camMatrix);
dVector origin (CAMERA_Z, CAMERA_Y, CAMERA_X, 0.0f);
scene->SetCameraMatrix(rot, origin);
}
Collider3D::~Collider3D()
{
for (auto& pair : m_handles)
NewtonDestroyCollision(pair.second);
}
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);
}
