dMatrix::dMatrix (dFloat pitch, dFloat yaw, dFloat roll, const dVector & location)
{
dMatrix & me = *this;
me = dPitchMatrix (pitch) * dYawMatrix (yaw) * dRollMatrix (roll);
me.m_posit = location;
me.m_posit.m_w = 1.0f;
}
void pyScene::Save (const char* name)
{
dMatrix globalRotation (dPitchMatrix(3.14159265f * 0.5f) * dRollMatrix(3.14159265f * 0.5f));
globalRotation = globalRotation.Inverse();
m_scene->BakeTransform (globalRotation);
m_scene->Serialize (name);
}
XXXX ()
{
dMatrix s;
dFloat m = 2.0f;
for (int i = 0; i < 3; i ++)
{
for (int j = 0; j < 3; j ++)
{
s[i][j] = m;
m += (i + 1) + j;
}
}
s.m_posit = dVector (1, 2, 3, 1);
dMatrix matrix;
dVector scale;
dMatrix stretch;
s.PolarDecomposition (matrix, scale, stretch);
dMatrix s1 (matrix, scale, stretch);
dMatrix xxx (dPitchMatrix (30.0f * 3.14159f / 180.0f) * dRollMatrix (30.0f * 3.14159f / 180.0f));
dMatrix xxxx (GetIdentityMatrix());
xxx[0] = xxx[0].Scale (-1.0f);
dFloat mmm = (xxx[0] * xxx[1]) % xxx[2];
xxxx[0][0] = 3.0f;
xxxx[1][1] = 3.0f;
xxxx[2][2] = 4.0f;
dMatrix xxx2 (xxx * xxxx);
mmm = (xxx2[0] * xxx2[1]) % xxx2[2];
xxx2.PolarDecomposition (matrix, scale, stretch);
s1 = dMatrix (matrix, scale, stretch);
s1 = dMatrix (matrix, scale, stretch);
}
static void AddUniformScaledPrimitives (DemoEntityManager* const scene, dFloat mass, const dVector& origin, const dVector& size, int xCount, int zCount, dFloat spacing, PrimitiveType type, int materialID, const dMatrix& shapeOffsetMatrix)
{
// create the shape and visual mesh as a common data to be re used
NewtonWorld* const world = scene->GetNewton();
NewtonCollision* const collision = CreateConvexCollision (world, &shapeOffsetMatrix[0][0], size, type, materialID);
dFloat startElevation = 1000.0f;
dMatrix matrix (dRollMatrix(-3.141592f/2.0f));
for (int i = 0; i < xCount; i ++) {
dFloat x = origin.m_x + (i - xCount / 2) * spacing;
for (int j = 0; j < zCount; j ++) {
dFloat scale = 0.75f + 1.0f * (dFloat (dRand()) / dFloat(dRAND_MAX) - 0.5f);
//scale = 1.0f;
NewtonCollisionSetScale (collision, scale, scale, scale);
DemoMesh* const geometry = new DemoMesh("cylinder_1", collision, "smilli.tga", "smilli.tga", "smilli.tga");
dFloat z = origin.m_z + (j - zCount / 2) * spacing;
matrix.m_posit.m_x = x;
matrix.m_posit.m_z = z;
dVector floor (FindFloor (world, dVector (matrix.m_posit.m_x, startElevation, matrix.m_posit.m_z, 0.0f), 2.0f * startElevation));
matrix.m_posit.m_y = floor.m_y + 4.f;
// create a solid
CreateSimpleSolid (scene, geometry, mass, matrix, collision, materialID);
// release the mesh
geometry->Release();
}
}
// do not forget to delete the collision
NewtonDestroyCollision (collision);
}
void CreatCasterBody(dFloat location_x, dFloat location_z, PrimitiveType shapeType, int materialID)
{
NewtonWorld* const world = ((CustomControllerManager<dClosestDistanceRecord>*)GetManager())->GetWorld();
DemoEntityManager* const scene = (DemoEntityManager*)NewtonWorldGetUserData(world);
//dMatrix matrix (GetIdentityMatrix());
dMatrix matrix (dRollMatrix(3.141592f/2.0f));
matrix.m_posit.m_x = location_x;
matrix.m_posit.m_y = 2.0f;
matrix.m_posit.m_z = location_z;
// create the shape and visual mesh as a common data to be re used
dVector size(0.5f, 0.5f, 0.75f, 0.0f);
NewtonCollision* const collision = CreateConvexCollision (world, dGetIdentityMatrix(), size, shapeType, materialID);
// DemoMesh____* const geometry = new DemoMesh____("cylinder_1", collision, "wood_0.tga", "wood_0.tga", "wood_1.tga");
DemoMesh* const geometry = new DemoMesh("convexShape", collision, "smilli.tga", "smilli.tga", "smilli.tga");
m_body = CreateSimpleSolid (scene, geometry, 1.0f, matrix, collision, materialID);
// disable gravity and apply a force that only spin the body
//NewtonBodySetForceAndTorqueCallback(m_myBody, PhysicsSpinBody);
//NewtonBodySetAutoSleep (m_myBody, 0);
geometry->Release();
NewtonDestroyCollision (collision);
}
// this calculate the desired position and orientation in the path
dMatrix BuildMatrix (dFloat timestep)
{
dMatrix matrix (dPitchMatrix(-m_angle) * dRollMatrix(-m_angle));
matrix.m_posit = m_origin;
matrix.m_posit.m_z += radius * dSin (m_angle);
matrix.m_posit.m_y += radius * dCos (m_angle);
return matrix;
}
static void SimpleMeshLevel (DemoEntityManager* const scene, bool optimization)
{
// load the skybox
scene->CreateSkyBox();
//float xxx[] = {2.3257, -3.6253, -2.7155, 2.7075, -3.6253, -2.7155, 2.7075, -3.6253, -2.3337, 2.3257, -3.6253, -2.3337};
//NewtonCollision* aaa = NewtonCreateConvexHull(scene->GetNewton(), sizeof (xxx) /(3 * sizeof (float)), xxx, 3 * sizeof (float), 0, 0, 0);
// load the scene from a ngd file format
// CreateLevelMesh (scene, "flatPlane.ngd", optimization);
CreateLevelMesh (scene, "sponza.ngd", optimization);
// CreateLevelMesh (scene, "cattle.ngd", fileName);
// CreateLevelMesh (scene, "playground.ngd", optimization);
// place camera into position
// dQuaternion rot;
// dVector posit (0.0f, 1.0f, 0.0f, 0.0f);
// scene->SetCameraMatrix(rot, posit);
dMatrix camMatrix (dRollMatrix(-20.0f * 3.1416f /180.0f) * dYawMatrix(-45.0f * 3.1416f /180.0f));
dQuaternion rot (camMatrix);
dVector origin (-30.0f, 40.0f, -15.0f, 0.0f);
scene->SetCameraMatrix(rot, origin);
NewtonWorld* const world = scene->GetNewton();
int defaultMaterialID = NewtonMaterialGetDefaultGroupID (world);
dVector location (0.0f, 0.0f, 0.0f, 0.0f);
dVector size (0.5f, 0.5f, 1.0f, 0.0f);
// int count = 1;
int count = 6;
dMatrix shapeOffsetMatrix (dGetIdentityMatrix());
for (int i = 0; i < 3; i ++) {
AddPrimitiveArray(scene, 10.0f, location, size, count, count, 3.0f, _SPHERE_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddPrimitiveArray(scene, 10.0f, location, size, count, count, 3.0f, _BOX_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddPrimitiveArray(scene, 10.0f, location, size, count, count, 3.0f, _CAPSULE_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddPrimitiveArray(scene, 10.0f, location, size, count, count, 3.0f, _CYLINDER_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddPrimitiveArray(scene, 10.0f, location, size, count, count, 3.0f, _TAPERED_CAPSULE_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddPrimitiveArray(scene, 10.0f, location, size, count, count, 3.0f, _TAPERED_CYLINDER_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddPrimitiveArray(scene, 10.0f, location, size, count, count, 3.0f, _CHAMFER_CYLINDER_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddPrimitiveArray(scene, 10.0f, location, size, count, count, 3.0f, _CONE_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddPrimitiveArray(scene, 10.0f, location, size, count, count, 3.0f, _REGULAR_CONVEX_HULL_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddPrimitiveArray(scene, 10.0f, location, size, count, count, 3.0f, _RANDOM_CONVEX_HULL_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddPrimitiveArray(scene, 10.0f, location, size, count, count, 3.0f, _COMPOUND_CONVEX_CRUZ_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
}
count = 8;
for (int i = 0; i < 50; i ++){
//AddPrimitiveArray(scene, 10.0f, location, size, count, count, 1.7f, _REGULAR_CONVEX_HULL_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
//AddPrimitiveArray(scene, 10.0f, location, size, count, count, 1.0f, _SPHERE_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
}
}
void BasicBoxStacks (DemoEntityManager* const scene)
{
// load the skybox
scene->CreateSkyBox();
CreateLevelMesh (scene, "flatPlane.ngd", 1);
// load the scene from a ngd file format
#if 0
char fileName[2048];
//GetWorkingFileName ("boxStacks_1.ngd", fileName);
//GetWorkingFileName ("boxStacks_3.ngd", fileName);
//GetWorkingFileName ("boxStacks.ngd", fileName);
//GetWorkingFileName ("pyramid20x20.ngd", fileName);
GetWorkingFileName ("pyramid40x40.ngd", fileName);
scene->LoadScene (fileName);
#else
int high = 30;
PrimitiveType selection[] = {_BOX_PRIMITIVE, _CYLINDER_PRIMITIVE, _TAPERED_CYLINDER_PRIMITIVE, _REGULAR_CONVEX_HULL_PRIMITIVE};
for (int i = 0; i < 1; i ++) {
int index = i % (sizeof (selection) / sizeof (selection[0]));
//index = 0;
dMatrix shapeMatrix (dRollMatrix(0.5f * 3.14159f));
if (selection[index] == _BOX_PRIMITIVE) {
shapeMatrix = dGetIdentityMatrix();
}
// BuildPyramid (scene, 10.0f, dVector(-10.0f + i * 4.0f, 0.0f, 0.0f, 0.0f), dVector (0.5f, 0.25f, 1.62f/2.0f, 0.0), high, selection[index], shapeMatrix);
BuildPyramid (scene, 10.0f, dVector( 0.0f + i * 4.0f, 0.0f, 0.0f, 0.0f), dVector (0.5f, 0.25f, 1.62f/2.0f, 0.0), high, _BOX_PRIMITIVE);
// BuildPyramid (scene, 10.0f, dVector( 10.0f + i * 4.0f, 0.0f, 0.0f, 0.0f), dVector (0.5f, 0.25f, 1.62f/2.0f, 0.0), high, _CYLINDER_PRIMITIVE, dRollMatrix(0.5f * 3.14159f));
// BuildPyramid (scene, 10.0f, dVector( 20.0f + i * 4.0f, 0.0f, 0.0f, 0.0f), dVector (0.5f, 0.25f, 1.62f/2.0f, 0.0), high, _TAPERED_CYLINDER_PRIMITIVE, dRollMatrix(0.5f * 3.14159f));
// BuildPyramid (scene, 10.0f, dVector( 30.0f + i * 4.0f, 0.0f, 0.0f, 0.0f), dVector (0.5f, 0.25f, 1.62f/2.0f, 0.0), high, _REGULAR_CONVEX_HULL_PRIMITIVE, dRollMatrix(0.5f * 3.14159f));
}
high = 20;
for (int i = 0; i < 1; i ++) {
for (int j = 0; j < 1; j ++) {
// BuildJenga (scene, 5.0f, dVector(-15.0f + j * 8, 0.0f, 10.0f + i * 8, 0.0f), dVector (0.5f, 0.25f, 1.62f/2.0f, 0.0), high);
}
}
#endif
// place camera into position
dQuaternion rot;
dVector origin (-40.0f, 10.0f, 0.0f, 0.0f);
//origin.m_x = -10.0f;
origin.m_x = -20.0f;
origin.m_y = 8.0f;
scene->SetCameraMatrix(rot, origin);
// ExportScene (scene->GetNewton(), "../../../media/test1.ngd");
}
Import::Import(const char* pathName, Interface* ip, ImpInterface* impip)
{
// set the path for textures
char* ptr = NULL;
sprintf (m_path, "%s", pathName);
for (int i = 0; m_path[i]; i ++) {
if ((m_path[i] == '\\') || (m_path[i] == '/') ) {
ptr = &m_path[i];
}
}
*ptr = 0;
m_ip = ip;
m_impip = impip;
m_succes = TRUE;
MaterialCache materialCache (NewDefaultMultiMtl());
SetSceneParameters();
dFloat scale;
scale = float (GetMasterScale(UNITS_METERS));
dMatrix scaleMatrix (GetIdentityMatrix());
scaleMatrix[0][0] = 1.0f / scale;
scaleMatrix[1][1] = 1.0f / scale;
scaleMatrix[2][2] = 1.0f / scale;
dMatrix globalRotation (scaleMatrix * dPitchMatrix(3.14159265f * 0.5f) * dRollMatrix(3.14159265f * 0.5f));
NewtonWorld* newton = NewtonCreate();
dScene scene (newton);
scene.Deserialize (pathName);
// dScene::Iterator iter (scene);
// for (iter.Begin(); iter; iter ++) {
// dScene::dTreeNode* node = iter.GetNode();
// dNodeInfo* info = scene.GetInfoFromNode(node);
// if (info->GetTypeId() == dMeshNodeInfo::GetRttiType()) {
// dMeshNodeInfo* mesh = (dMeshNodeInfo*) scene.GetInfoFromNode(node);
// mesh->ConvertToTriangles();
// }
// }
scene.BakeTransform (globalRotation);
GeometryCache geometryCache;
MaxNodeChache maxNodeCache;
LoadMaterials (scene, materialCache);
LoadGeometries (scene, geometryCache, materialCache);
LoadNodes (scene, geometryCache, materialCache.m_multiMat, maxNodeCache);
ApplyModifiers (scene, maxNodeCache);
scene.CleanUp();
NewtonDestroy(newton);
}
virtual void Evaluate(dEffectorPose& output, dFloat timestep)
{
m_poseGenerator->Evaluate(output, timestep);
dQuaternion rotation (dPitchMatrix(m_euler.m_x) * dYawMatrix(m_euler.m_y) * dRollMatrix(m_euler.m_z));
for (dEffectorPose::dListNode* node = output.GetFirst(); node; node = node->GetNext()) {
dEffectorTransform& transform = node->GetInfo();
transform.m_rotation = transform.m_rotation * rotation;
transform.m_posit = m_position + rotation.RotateVector(transform.m_posit);
}
}
PuckEntity (DemoEntityManager* const scene, int materialID)
:DemoEntity (dGetIdentityMatrix(), NULL)
,m_launched(false)
{
scene->Append(this);
NewtonWorld* const world = scene->GetNewton();
dVector puckSize(WEIGHT_DIAMETER, WEIGHT_HEIGHT, 0.0f, 0.0f);
// create the shape and visual mesh as a common data to be re used
NewtonCollision* const collision = CreateConvexCollision (world, dGetIdentityMatrix(), puckSize, _CYLINDER_PRIMITIVE, materialID);
// correction: make the puck an upright cylinder, this makes everything simpler
dMatrix collisionAligmentMatrix (dRollMatrix(3.141592f/2.0f));
NewtonCollisionSetMatrix(collision, &collisionAligmentMatrix[0][0]);
DemoMesh* const geometry = new DemoMesh("cylinder_1", collision, "smilli.tga", "smilli.tga", "smilli.tga");
//dMatrix matrix = dRollMatrix(3.141592f/2.0f);
dMatrix matrix (dGetIdentityMatrix());
matrix.m_posit.m_x = -TABLE_LENGTH*0.5f+WEIGHT_DIAMETER;
matrix.m_posit.m_z = -11.8f;
//matrix.m_posit.m_z += 4.0f;
matrix.m_posit.m_y = 5.0f;
m_puckBody = CreateSimpleSolid (scene, geometry, WEIGHT_MASS, matrix, collision, materialID);
// Set moment of inertia
// correction: this is deprecated, NewtonBodySetMassProperties produce the exact result
//dVector I;
//dFloat Mass = WEIGHT_MASS;
//dFloat Radius = WEIGHT_RADIUS;
//dFloat Height = WEIGHT_HEIGHT;
//I.m_x = I.m_z = Mass*(3.0f*Radius*Radius+Height*Height)/12.0f;
//I.m_y = Mass*Radius*Radius/2.0f;
//NewtonBodySetMassMatrix(gPuckBody,Mass, I.m_x, I.m_y, I.m_z);
NewtonBodySetMassProperties(m_puckBody, WEIGHT_MASS, NewtonBodyGetCollision(m_puckBody));
NewtonBodySetMaterialGroupID(m_puckBody, materialID);
// remember to make continuous collision work with auto sleep mode, right now this is no working
NewtonBodySetContinuousCollisionMode(m_puckBody, 1);
NewtonBodySetAutoSleep(m_puckBody, 1);
// Set callbacks
NewtonBodySetForceAndTorqueCallback(m_puckBody, NewtonRigidBodySetForceCB);
// do not forget to release the assets
geometry->Release();
NewtonDestroyCollision (collision);
}
void NonUniformScaledCollision(DemoEntityManager* const scene)
{
// load the skybox
scene->CreateSkyBox();
// load the scene from a ngd file format
CreateLevelMesh(scene, "flatPlane.ngd", 1);
// CreateLevelMesh (scene, "sponza.ngd", 1);
// CreateLevelMesh (scene, "cattle.ngd", fileName);
// CreateLevelMesh (scene, "playground.ngd", 1);
dMatrix camMatrix(dRollMatrix(-20.0f * 3.1416f / 180.0f) * dYawMatrix(-45.0f * 3.1416f / 180.0f));
dQuaternion rot(camMatrix);
// dVector origin (-30.0f, 40.0f, -15.0f, 0.0f);
dVector origin(-10.0f, 5.0f, -15.0f, 0.0f);
scene->SetCameraMatrix(rot, origin);
NewtonWorld* const world = scene->GetNewton();
int defaultMaterialID = NewtonMaterialGetDefaultGroupID(world);
dVector location(0.0f, 0.0f, 0.0f, 0.0f);
dVector size0(0.5f, 0.5f, 1.0f, 0.0f);
dVector size1(0.5f, 0.5f, 0.5f, 0.0f);
int count = 5;
dMatrix shapeOffsetMatrix(dRollMatrix(3.141592f / 2.0f));
shapeOffsetMatrix.m_posit.m_y = 0.0f;
AddNonUniformScaledPrimitives(scene, 10.0f, location, size0, count, count, 4.0f, _SPHERE_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddNonUniformScaledPrimitives(scene, 10.0f, location, size0, count, count, 4.0f, _BOX_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddNonUniformScaledPrimitives(scene, 10.0f, location, size0, count, count, 4.0f, _CAPSULE_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddNonUniformScaledPrimitives(scene, 10.0f, location, size1, count, count, 4.0f, _CAPSULE_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddNonUniformScaledPrimitives(scene, 10.0f, location, size1, count, count, 4.0f, _CYLINDER_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddNonUniformScaledPrimitives(scene, 10.0f, location, size0, count, count, 4.0f, _CYLINDER_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddNonUniformScaledPrimitives(scene, 10.0f, location, size0, count, count, 4.0f, _CHAMFER_CYLINDER_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddNonUniformScaledPrimitives(scene, 10.0f, location, size0, count, count, 4.0f, _CONE_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddNonUniformScaledPrimitives(scene, 10.0f, location, size0, count, count, 4.0f, _REGULAR_CONVEX_HULL_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddNonUniformScaledPrimitives(scene, 10.0f, location, size0, count, count, 4.0f, _RANDOM_CONVEX_HULL_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddNonUniformScaledPrimitives(scene, 10.0f, location, size0, count, count, 4.0f, _COMPOUND_CONVEX_CRUZ_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
}
void AddHinge (DemoEntityManager* const scene, const dVector& origin)
{
dVector size (1.5f, 4.0f, 0.125f);
NewtonBody* const box0 = CreateBox (scene, origin + dVector (0.0f, 4.0f, 0.0f, 0.0f), size);
NewtonBody* const box1 = CreateBox (scene, origin + dVector (1.5f, 4.0f, 0.0f, 0.0f), size);
NewtonBody* const box2 = CreateBox (scene, origin + dVector (3.0f, 4.0f, 0.0f, 0.0f), size);
//the joint pin is the first row of the matrix, to make a upright pin we
//take the x axis and rotate by 90 degree around the y axis
dMatrix localPin (dRollMatrix(90.0f * 3.141592f / 180.0f));
// connect first box to the world
dMatrix matrix;
NewtonBodyGetMatrix (box0, & matrix[0][0]);
matrix.m_posit += dVector (-size.m_x * 0.5f, 0.0f, 0.0f);
matrix = localPin * matrix;
// add hinge with limit and friction
CustomHinge* const hinge0 = new CustomHinge (matrix, box0, NULL);
hinge0->EnableLimits (true);
hinge0->SetLimis(-45.0f * 3.141592f / 180.0f, 45.0f * 3.141592f / 180.0f);
hinge0->SetFriction (20.0f);
// link the two boxes
NewtonBodyGetMatrix (box1, &matrix[0][0]);
matrix.m_posit += dVector (-size.m_x * 0.5f, 0.0f, 0.0f);
matrix = localPin * matrix;
CustomHinge* const hinge1 = new CustomHinge (matrix, box1, box0);
hinge1->EnableLimits (true);
hinge1->SetLimis (-45.0f * 3.141592f / 180.0f, 45.0f * 3.141592f / 180.0f);
hinge1->SetFriction (20.0f);
// link the two boxes
NewtonBodyGetMatrix (box2, &matrix[0][0]);
matrix.m_posit += dVector (-size.m_x * 0.5f, 0.0f, 0.0f);
matrix = localPin * matrix;
CustomHinge* const hinge2 = new CustomHinge (matrix, box2, box1);
hinge2->EnableLimits (true);
hinge2->SetLimis (-45.0f * 3.141592f / 180.0f, 45.0f * 3.141592f / 180.0f);
hinge2->SetFriction (20.0f);
#ifdef _USE_HARD_JOINTS
NewtonSkeletonContainer* const skeleton = NewtonSkeletonContainerCreate (scene->GetNewton(), NULL, NULL);
// NewtonSkeletonContainer* const skeleton = NewtonSkeletonContainerCreate (scene->GetNewton(), box0, NULL);
NewtonSkeletonContainerAttachBone (skeleton, box0, NULL);
NewtonSkeletonContainerAttachBone (skeleton, box1, box0);
NewtonSkeletonContainerAttachBone (skeleton, box2, box1);
NewtonSkeletonContainerFinalize (skeleton);
#endif
}
void AddCollisionSingleShape(DemoEntityManager* const scene)
{
dMatrix offsetMatrix (dGetIdentityMatrix());
NewtonCollision* const box = NewtonCreateBox (scene->GetNewton(), 4.0f, 0.1f, 4.0f, 0, &offsetMatrix[0][0]) ;
DemoMesh* const mesh = new DemoMesh (" box", box, "metal_30.tga", "metal_30.tga", "metal_30.tga");
// add compound to the scene collision
dMatrix matrix;
void* proxy;
NewtonCollision* shape;
matrix = dRollMatrix(15.0f * 3.1416f / 180.0f);
matrix.m_posit.m_y = 4.0f;
matrix.m_posit.m_x = 3.0f;
matrix.m_posit.m_z = 0.0f;
proxy = NewtonSceneCollisionAddSubCollision (m_sceneCollision, box);
shape = NewtonSceneCollisionGetCollisionFromNode (m_sceneCollision, proxy);
NewtonSceneCollisionSetSubCollisionMatrix (m_sceneCollision, proxy, &matrix[0][0]);
NewtonCollisionSetUserData(shape, mesh);
mesh->AddRef();
matrix = dRollMatrix(-15.0f * 3.1416f / 180.0f);
matrix.m_posit.m_y = 8.0f;
matrix.m_posit.m_x = -3.0f;
matrix.m_posit.m_z = 0.0f;
proxy = NewtonSceneCollisionAddSubCollision (m_sceneCollision, box);
shape = NewtonSceneCollisionGetCollisionFromNode (m_sceneCollision, proxy);
NewtonSceneCollisionSetSubCollisionMatrix (m_sceneCollision, proxy, &matrix[0][0]);
NewtonCollisionSetUserData(shape, mesh);
mesh->AddRef();
NewtonDestroyCollision(box);
mesh->Release();
}
dCustomInverseDynamicsEffector* AddLeg(DemoEntityManager* const scene, void* const rootNode, const dMatrix& matrix, dFloat partMass, dFloat limbLenght)
{
NewtonBody* const parent = NewtonInverseDynamicsGetBody(m_kinematicSolver, rootNode);
dFloat inertiaScale = 4.0f;
// make limb base
dMatrix baseMatrix(dRollMatrix(dPi * 0.5f));
dMatrix cylinderMatrix(baseMatrix * matrix);
NewtonBody* const base = CreateCylinder(scene, cylinderMatrix, partMass, inertiaScale, 0.2f, 0.1f);
dCustomInverseDynamics* const baseHinge = new dCustomInverseDynamics(cylinderMatrix, base, parent);
baseHinge->SetJointTorque(1000.0f);
baseHinge->SetTwistAngle(-0.5f * dPi, 0.5f * dPi);
void* const baseHingeNode = NewtonInverseDynamicsAddChildNode(m_kinematicSolver, rootNode, baseHinge->GetJoint());
//make limb forward arm
dMatrix forwardArmMatrix(dPitchMatrix(-30.0f * dDegreeToRad));
dVector forwardArmSize(limbLenght * 0.25f, limbLenght * 0.25f, limbLenght, 0.0f);
forwardArmMatrix.m_posit += forwardArmMatrix.m_right.Scale(forwardArmSize.m_z * 0.5f);
NewtonBody* const forwardArm = CreateBox(scene, forwardArmMatrix * matrix, forwardArmSize, partMass, inertiaScale);
dMatrix forwardArmPivot(forwardArmMatrix);
forwardArmPivot.m_posit -= forwardArmMatrix.m_right.Scale(forwardArmSize.m_z * 0.5f);
dCustomInverseDynamics* const forwardArmHinge = new dCustomInverseDynamics(forwardArmPivot * matrix, forwardArm, base);
forwardArmHinge->SetJointTorque(1000.0f);
forwardArmHinge->SetTwistAngle(-0.5f * dPi, 0.5f * dPi);
void* const forwardArmHingeNode = NewtonInverseDynamicsAddChildNode(m_kinematicSolver, baseHingeNode, forwardArmHinge->GetJoint());
//make limb forward arm
dMatrix armMatrix(dPitchMatrix(-90.0f * dDegreeToRad));
dFloat armSize = limbLenght * 1.25f;
armMatrix.m_posit += forwardArmMatrix.m_right.Scale(limbLenght);
armMatrix.m_posit.m_y -= armSize * 0.5f;
NewtonBody* const arm = CreateCapsule(scene, armMatrix * matrix, partMass, inertiaScale, armSize * 0.2f, armSize);
dMatrix armPivot(armMatrix);
armPivot.m_posit.m_y += armSize * 0.5f;
dCustomInverseDynamics* const armHinge = new dCustomInverseDynamics(armPivot * matrix, arm, forwardArm);
armHinge->SetJointTorque(1000.0f);
armHinge->SetTwistAngle(-0.5f * dPi, 0.5f * dPi);
void* const armHingeNode = NewtonInverseDynamicsAddChildNode(m_kinematicSolver, forwardArmHingeNode, armHinge->GetJoint());
dMatrix effectorMatrix(dGetIdentityMatrix());
effectorMatrix.m_posit = armPivot.m_posit;
effectorMatrix.m_posit.m_y -= armSize;
dHexapodEffector* const effector = new dHexapodEffector(m_kinematicSolver, armHingeNode, parent, effectorMatrix * matrix);
effector->SetAsThreedof();
effector->SetMaxLinearFriction(partMass * DEMO_GRAVITY * 10.0f);
effector->SetMaxAngularFriction(partMass * DEMO_GRAVITY * 10.0f);
return effector;
}
static void SimpleMeshLevel (DemoEntityManager* const scene, bool optimization)
{
// suspend simulation before making changes to the physics world
scene->StopsExecution ();
// load the skybox
scene->Append(new SkyBox());
// load the scene from and alchemedia file format
// CreateLevelMesh (scene, "flatPlane.ngd", optimization);
CreateLevelMesh (scene, "sponza.ngd", optimization);
// CreateLevelMesh (scene, "cattle.ngd", fileName);
// CreateLevelMesh (scene, "playground.ngd", fileName);
// place camera into position
// dQuaternion rot;
// dVector posit (0.0f, 1.0f, 0.0f, 0.0f);
// scene->SetCameraMatrix(rot, posit);
dMatrix camMatrix (dRollMatrix(-20.0f * 3.1416f /180.0f) * dYawMatrix(-45.0f * 3.1416f /180.0f));
dQuaternion rot (camMatrix);
//dQuaternion rot;
dVector origin (-30.0f, 40.0f, -15.0f, 0.0f);
// dVector origin (-10.0f, 1.0f, 0.0f, 0.0f);
scene->SetCameraMatrix(rot, origin);
NewtonWorld* const world = scene->GetNewton();
int defaultMaterialID = NewtonMaterialGetDefaultGroupID (world);
dVector location (0.0f, 0.0f, 0.0f, 0.0f);
dVector size (0.5f, 0.5f, 0.5f, 0.0f);
int count = 8;
AddPrimitiveArray(scene, 10.0f, location, size, count, count, 1.7f, _SPHERE_PRIMITIVE, defaultMaterialID);
AddPrimitiveArray(scene, 10.0f, location, size, count, count, 1.7f, _BOX_PRIMITIVE, defaultMaterialID);
AddPrimitiveArray(scene, 10.0f, location, size, count, count, 1.7f, _CAPSULE_PRIMITIVE, defaultMaterialID);
AddPrimitiveArray(scene, 10.0f, location, size, count, count, 1.7f, _CYLINDER_PRIMITIVE, defaultMaterialID);
AddPrimitiveArray(scene, 10.0f, location, size, count, count, 1.7f, _CHAMFER_CYLINDER_PRIMITIVE, defaultMaterialID);
AddPrimitiveArray(scene, 10.0f, location, size, count, count, 1.7f, _BOX_PRIMITIVE, defaultMaterialID);
AddPrimitiveArray(scene, 10.0f, location, size, count, count, 1.7f, _CONE_PRIMITIVE, defaultMaterialID);
AddPrimitiveArray(scene, 10.0f, location, size, count, count, 1.7f, _CAPSULE_PRIMITIVE, defaultMaterialID);
AddPrimitiveArray(scene, 10.0f, location, size, count, count, 1.7f, _REGULAR_CONVEX_HULL_PRIMITIVE, defaultMaterialID);
AddPrimitiveArray(scene, 10.0f, location, size, count, count, 1.7f, _RANDOM_CONVEX_HULL_PRIMITIVE, defaultMaterialID);
//for (int i = 0; i < 20; i ++)
//AddPrimitiveArray(scene, 10.0f, location, size, count, count, 1.7f, _SPHERE_PRIMITIVE, defaultMaterialID);
// resume the simulation
scene->ContinueExecution();
}
void CompoundCollision (DemoEntityManager* const scene)
{
// load the skybox
scene->CreateSkyBox();
// load the scene from a ngd file format
// CreateLevelMesh (scene, "flatPlane.ngd", true);
// CreateLevelMesh (scene, "playground.ngd", true);
// CreateLevelMesh (scene, "sponza.ngd", true);
CreateHeightFieldTerrain(scene, HEIGHTFIELD_DEFAULT_SIZE, HEIGHTFIELD_DEFAULT_CELLSIZE,
1.5f, 0.2f, 200.0f, -50.0f);
int defaultMaterialID = NewtonMaterialGetDefaultGroupID (scene->GetNewton());
// set a material callback to get the colliding shape
NewtonMaterialSetCollisionCallback (scene->GetNewton(), defaultMaterialID, defaultMaterialID, NULL, OnGettingTheCollisionSubShapeFromMaterialCallback);
NewtonMaterialSetCompoundCollisionCallback(scene->GetNewton(), defaultMaterialID, defaultMaterialID, OnSubShapeAABBOverlapTest);
dMatrix camMatrix (dRollMatrix(-20.0f * 3.1416f /180.0f) * dYawMatrix(-45.0f * 3.1416f /180.0f));
dQuaternion rot (camMatrix);
dVector origin (100.0f, 0.0f, 100.0f, 0.0f);
dFloat hight = 1000.0f;
origin = FindFloor (scene->GetNewton(), dVector (origin.m_x, hight, origin .m_z, 0.0f), hight * 2);
origin.m_y += 10.0f;
dVector location (origin);
location.m_x += 40.0f;
location.m_z += 40.0f;
// this crash temporarily (I need to make the compound use shape Instance)
MakeFunnyCompound (scene, location);
int count = 5;
dVector size (0.5f, 0.5f, 0.75f, 0.0f);
dMatrix shapeOffsetMatrix (dGetIdentityMatrix());
AddPrimitiveArray(scene, 10.0f, location, size, count, count, 5.0f, _BOX_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddPrimitiveArray(scene, 10.0f, location, size, count, count, 5.0f, _BOX_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddPrimitiveArray(scene, 10.0f, location, size, count, count, 5.0f, _CAPSULE_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddPrimitiveArray(scene, 10.0f, location, size, count, count, 5.0f, _CYLINDER_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddPrimitiveArray(scene, 10.0f, location, size, count, count, 5.0f, _CONE_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
// place camera into position
// dQuaternion rot;
// dVector origin (-40.0f, 10.0f, 0.0f, 0.0f);
scene->SetCameraMatrix(rot, origin);
//ExportScene (scene->GetNewton(), "../../../media/test1.ngd");
}
// this function update the interpolated position of the Camera
void UpdateCamera (dFloat interpolationParam)
{
dFloat rollAngle;
dFloat yawAngle;
yawAngle = gPrevYawAngle + (gYawAngle - gPrevYawAngle) * interpolationParam;
rollAngle = gPrevRollAngle + (gRollAngle - gPrevRollAngle) * interpolationParam;
dMatrix cameraDirMat (dRollMatrix(rollAngle) * dYawMatrix(yawAngle));
dVector eye (gPrevCameraEyepoint + (gCameraEyepoint - gPrevCameraEyepoint).Scale (interpolationParam));
dVector target (eye + cameraDirMat.m_front);
// set up the view orientation looking at the origin from slightly above
SetCamera (eye, target);
}
void dPluginCamera::SetMatrix (dFloat yaw, dFloat roll, dFloat distance)
{
// dMatrix yawMatrix_ (dYawMatrix(yaw));
// dMatrix rollMatrix_ (dRollMatrix(roll));
// m_matrix = rollMatrix_ * yawMatrix_;
// m_matrix.m_posit = dVector (-10.0f, 5.0f, 10.0f, 1.0f);
m_cameraRoll = dClamp(roll, -85.0f * 3.141692f / 180.0f, 85.0f * 3.141692f / 180.0f);
m_cameraYaw = dMod (yaw, 2.0f * 3.141592f);
m_distance = (distance < 0.5f) ? 0.5f : distance;
dMatrix yawMatrix (dYawMatrix(m_cameraYaw));
dMatrix rollMatrix (dRollMatrix(m_cameraRoll));
m_matrix = rollMatrix * yawMatrix;
m_matrix.m_posit = m_matrix.RotateVector(dVector (-distance, 0.0f, 0.0f, 1.0f)) + m_pointOfInterest;
m_matrix.m_posit.m_w = 1.0f;
}
static NewtonBody* CreateCylinder(DemoEntityManager* const scene, const dVector& location, dFloat mass, dFloat radius, dFloat height)
{
NewtonWorld* const world = scene->GetNewton();
int materialID = NewtonMaterialGetDefaultGroupID(world);
dVector size(radius, height, radius, 0.0f);
NewtonCollision* const collision = CreateConvexCollision(world, dGetIdentityMatrix(), size, _CYLINDER_PRIMITIVE, 0);
DemoMesh* const geometry = new DemoMesh("primitive", scene->GetShaderCache(), collision, "smilli.tga", "smilli.tga", "smilli.tga");
dMatrix matrix(dRollMatrix (90.0f * dDegreeToRad));
matrix.m_posit = location;
matrix.m_posit.m_w = 1.0f;
NewtonBody* const body = CreateSimpleSolid(scene, geometry, mass, matrix, collision, materialID);
geometry->Release();
NewtonDestroyCollision(collision);
return body;
}
static NewtonBody* CreateCapule (DemoEntityManager* const scene, const dVector& location, const dVector& size)
{
NewtonWorld* const world = scene->GetNewton();
int materialID = NewtonMaterialGetDefaultGroupID (world);
dMatrix uprightAligment (dRollMatrix(3.141592f * 90.0f / 180.0f));
NewtonCollision* const collision = CreateConvexCollision (world, &uprightAligment[0][0], size, _CAPSULE_PRIMITIVE, 0);
DemoMesh* const geometry = new DemoMesh("primitive", collision, "smilli.tga", "smilli.tga", "smilli.tga");
dFloat mass = 1.0f;
dMatrix matrix (dGetIdentityMatrix());
matrix.m_posit = location;
matrix.m_posit.m_w = 1.0f;
NewtonBody* const body = CreateSimpleSolid (scene, geometry, mass, matrix, collision, materialID);
geometry->Release();
NewtonDestroyCollision(collision);
return body;
}
void pyScene::Load (const char* name)
{
m_scene->CleanUp();
m_scene->Deserialize(name);
dScene::Iterator iter (*m_scene);
for (iter.Begin(); iter; iter ++) {
dScene::dTreeNode* node = iter.GetNode();
dNodeInfo* info = m_scene->GetInfoFromNode(node);
if (info->GetTypeId() == dMeshNodeInfo::GetRttiType()) {
dMeshNodeInfo* mesh = (dMeshNodeInfo*) m_scene->GetInfoFromNode(node);
mesh->ConvertToTriangles();
}
}
dMatrix globalRotation (dPitchMatrix(3.14159265f * 0.5f) * dRollMatrix(3.14159265f * 0.5f));
m_scene->BakeTransform (globalRotation);
}
static void SimpleMeshLevel (DemoEntityManager* const scene, bool optimization)
{
// load the skybox
scene->CreateSkyBox();
// load the scene from a ngd file format
// CreateLevelMesh (scene, "flatPlane.ngd", optimization);
CreateLevelMesh (scene, "sponza.ngd", optimization);
// CreateLevelMesh (scene, "cattle.ngd", fileName);
// CreateLevelMesh (scene, "playground.ngd", optimization);
dMatrix camMatrix (dRollMatrix(-20.0f * 3.1416f /180.0f) * dYawMatrix(-45.0f * 3.1416f /180.0f));
dQuaternion rot (camMatrix);
dVector origin (-30.0f, 40.0f, -15.0f, 0.0f);
scene->SetCameraMatrix(rot, origin);
NewtonWorld* const world = scene->GetNewton();
int defaultMaterialID = NewtonMaterialGetDefaultGroupID (world);
dVector location (0.0f, 0.0f, 0.0f, 0.0f);
dVector size (0.25f, 0.25f, 0.5f, 0.0f);
int count = 6;
dMatrix shapeOffsetMatrix (dGetIdentityMatrix());
for (int i = 0; i < 3; i ++) {
AddPrimitiveArray(scene, 10.0f, location, size, count, count, 3.0f, _SPHERE_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddPrimitiveArray(scene, 10.0f, location, size, count, count, 3.0f, _BOX_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddPrimitiveArray(scene, 10.0f, location, size, count, count, 3.0f, _CAPSULE_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddPrimitiveArray(scene, 10.0f, location, size, count, count, 3.0f, _CYLINDER_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddPrimitiveArray(scene, 10.0f, location, size, count, count, 3.0f, _CHAMFER_CYLINDER_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddPrimitiveArray(scene, 10.0f, location, size, count, count, 3.0f, _CONE_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddPrimitiveArray(scene, 10.0f, location, size, count, count, 3.0f, _REGULAR_CONVEX_HULL_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddPrimitiveArray(scene, 10.0f, location, size, count, count, 3.0f, _RANDOM_CONVEX_HULL_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddPrimitiveArray(scene, 10.0f, location, size, count, count, 3.0f, _COMPOUND_CONVEX_CRUZ_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
}
count = 8;
for (int i = 0; i < 50; i ++){
//AddPrimitiveArray(scene, 10.0f, location, size, count, count, 1.7f, _REGULAR_CONVEX_HULL_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
//AddPrimitiveArray(scene, 10.0f, location, size, count, count, 1.0f, _SPHERE_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
}
}
void CreatCasterBody(dFloat location_x, dFloat location_z, PrimitiveType shapeType, int materialID)
{
NewtonWorld* const world = ((dCustomControllerManager<dClosestDistanceRecord>*)GetManager())->GetWorld();
DemoEntityManager* const scene = (DemoEntityManager*)NewtonWorldGetUserData(world);
//dMatrix matrix (GetIdentityMatrix());
dMatrix matrix (dRollMatrix(3.141592f/2.0f));
matrix.m_posit.m_x = location_x;
matrix.m_posit.m_y = 2.0f;
matrix.m_posit.m_z = location_z;
// create the shape and visual mesh as a common data to be re used
dVector size(0.5f, 0.5f, 0.75f, 0.0f);
NewtonCollision* const collision = CreateConvexCollision (world, dGetIdentityMatrix(), size, shapeType, materialID);
DemoMesh* const geometry = new DemoMesh("convexShape", collision, "smilli.tga", "smilli.tga", "smilli.tga");
m_body = CreateSimpleSolid (scene, geometry, 1.0f, matrix, collision, materialID);
geometry->Release();
NewtonDestroyCollision (collision);
}
void UserPlaneCollision (DemoEntityManager* const scene)
{
// load the sky box
scene->CreateSkyBox();
// create a user define infinite plane collision, and use it as a floor
CreatePlaneCollision (scene, dVector (0.0f, 1.0f, 0.0f, 0.0f));
dMatrix camMatrix (dRollMatrix(-20.0f * dDegreeToRad) * dYawMatrix(-45.0f * dDegreeToRad));
dQuaternion rot (camMatrix);
dVector origin (0.0f, 0.0f, 0.0f, 0.0f);
// dFloat hight = 1000.0f;
// origin = FindFloor (scene->GetNewton(), dVector (origin.m_x, hight, origin .m_z, 0.0f), hight * 2);
origin.m_y += 10.0f;
scene->SetCameraMatrix(rot, origin);
int defaultMaterialID = NewtonMaterialGetDefaultGroupID (scene->GetNewton());
dVector location (origin);
location.m_x += 20.0f;
location.m_z += 20.0f;
// dVector size (0.5f, 0.5f, 0.75f, 0.0f);
dVector size (1.0f, 1.0f, 1.0f, 0.0f);
int count = 1;
dMatrix shapeOffsetMatrix (dGetIdentityMatrix());
AddUniformScaledPrimitives(scene, 10.0f, location, size, count, count, 4.0f, _BOX_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
// AddPrimitiveArray(scene, 10.0f, location, size, count, count, 5.0f, _SPHERE_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
// AddPrimitiveArray(scene, 10.0f, location, size, count, count, 5.0f, _BOX_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
// AddPrimitiveArray(scene, 10.0f, location, size, count, count, 5.0f, _CAPSULE_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
// AddPrimitiveArray(scene, 10.0f, location, size, count, count, 5.0f, _CYLINDER_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
// AddPrimitiveArray(scene, 10.0f, location, size, count, count, 5.0f, _CONE_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
// AddPrimitiveArray(scene, 10.0f, location, size, count, count, 5.0f, _CHAMFER_CYLINDER_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
// AddPrimitiveArray(scene, 10.0f, location, size, count, count, 5.0f, _REGULAR_CONVEX_HULL_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
// AddPrimitiveArray(scene, 10.0f, location, size, count, count, 5.0f, _RANDOM_CONVEX_HULL_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
// AddPrimitiveArray(scene, 10.0f, location, size, count, count, 5.0f, _COMPOUND_CONVEX_CRUZ_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
}
void PostUpdate(dFloat timestep, int threadIndex)
{
dMatrix matrixA;
NewtonBodyGetMatrix(m_body, &matrixA[0][0]);
dFloat speed = m_step * timestep * 60.0f;
m_pith = dMod (m_pith + speed, 3.1416f * 2.0f);
m_yaw = dMod (m_yaw + speed, 3.1416f * 2.0f);
m_roll = dMod (m_roll + speed, 3.1416f * 2.0f);
dMatrix matrixB(dPitchMatrix(m_pith) * dYawMatrix(m_yaw) * dRollMatrix(m_roll));
matrixB.m_posit = matrixA.m_posit;
matrixB.m_posit.m_y = 5.0f;
NewtonWorld* const world = NewtonBodyGetWorld(m_body);
DemoEntityManager* const scene = (DemoEntityManager*) NewtonWorldGetUserData (world);
m_castingVisualEntity->ResetMatrix(*scene, matrixB);
NewtonCollision* const collisionA = NewtonBodyGetCollision(m_body);
NewtonCollisionClosestPoint(world, collisionA, &matrixA[0][0], m_castingVisualEntity->m_castingShape, &matrixB[0][0], &m_castingVisualEntity->m_contact0[0], &m_castingVisualEntity->m_contact1[0], &m_castingVisualEntity->m_normal[0], 0);
}
void CreateCastingShapes(DemoEntityManager* const scene, dFloat size)
{
NewtonWorld* const world = scene->GetNewton();
int materialID = NewtonMaterialGetDefaultGroupID(world);
dSetRandSeed (0);
dVector shapeSize (size, size, size, 0.0f);
PrimitiveType castSelection[] = {_SPHERE_PRIMITIVE, _CAPSULE_PRIMITIVE, _BOX_PRIMITIVE, _CYLINDER_PRIMITIVE, _REGULAR_CONVEX_HULL_PRIMITIVE, _CHAMFER_CYLINDER_PRIMITIVE};
m_count = sizeof (castSelection) / sizeof (castSelection[0]);
m_castingGeometries = new DemoMesh*[m_count];
m_castingShapeArray = new NewtonCollision*[m_count];
dMatrix alignMatrix (dRollMatrix(3.141592f * 90.0f / 180.0f));
for (int i = 0; i < m_count; i ++) {
dVector shapeSize (size + RandomVariable (size / 2.0f), size + RandomVariable (size / 2.0f), size + RandomVariable (size / 2.0f), 0.0f);
#if 1
m_castingShapeArray[i] = CreateConvexCollision (world, &alignMatrix[0][0], shapeSize, castSelection[i], materialID);
#else
m_castingShapeArray[i] = NewtonCreateCompoundCollision (world, materialID);
NewtonCompoundCollisionBeginAddRemove(m_castingShapeArray[i]);
NewtonCollision* const collision = CreateConvexCollision (world, &alignMatrix[0][0], shapeSize, castSelection[i], materialID);
NewtonCompoundCollisionAddSubCollision (m_castingShapeArray[i], collision);
NewtonDestroyCollision(collision);
NewtonCompoundCollisionEndAddRemove(m_castingShapeArray[i]);
#endif
m_castingGeometries[i] = new DemoMesh("geometry", m_castingShapeArray[i], "smilli.tga", "smilli.tga", "smilli.tga");
}
// make and entity for showing the result of the convex cast
dMatrix matrix (dGetIdentityMatrix());
matrix.m_posit.m_y = 2.0f;
m_currentCastingShape = 0;
m_castingEntity = new DemoEntity (matrix, NULL);
m_castingEntity->SetMesh(m_castingGeometries[m_currentCastingShape], dGetIdentityMatrix());
}
void PostUpdate(dFloat timestep, int threadIndex)
{
dMatrix matrixA;
NewtonBodyGetMatrix(m_body, &matrixA[0][0]);
dFloat speed = m_step * timestep * 60.0f;
m_pith = dMod (m_pith + speed, dPi * 2.0f);
m_yaw = dMod (m_yaw + speed, dPi * 2.0f);
m_roll = dMod (m_roll + speed, dPi * 2.0f);
dMatrix matrixB(dPitchMatrix(m_pith) * dYawMatrix(m_yaw) * dRollMatrix(m_roll));
matrixB.m_posit = matrixA.m_posit;
matrixB.m_posit.m_y = 5.0f;
//matrixB.m_posit.m_y = 1.5f;
NewtonWorld* const world = NewtonBodyGetWorld(m_body);
DemoEntityManager* const scene = (DemoEntityManager*) NewtonWorldGetUserData (world);
m_castingVisualEntity->ResetMatrix(*scene, matrixB);
NewtonCollision* const collisionA = NewtonBodyGetCollision(m_body);
int res = NewtonCollisionClosestPoint(world, collisionA, &matrixA[0][0], m_castingVisualEntity->m_castingShape, &matrixB[0][0], &m_castingVisualEntity->m_contact0[0], &m_castingVisualEntity->m_contact1[0], &m_castingVisualEntity->m_normal[0], 0);
//just test the center of collisionB against collisionA to see if the point is inside or not:
//int res = NewtonCollisionPointDistance(world, &matrixA.m_posit[0], collisionA, &matrixA[0][0], &m_castingVisualEntity->m_contact0[0], &m_castingVisualEntity->m_normal[0], 0);
if (res == 0) {
printf("Point Inside Body!\n");
//dTrace(("Point Inside Body!\n"));
}
else
{
//printf("Point point outside Body!\n");
}
}
void UserHeightFieldCollision (DemoEntityManager* const scene)
{
// load the sky box
scene->CreateSkyBox();
CreateHeightFieldTerrain(scene, HEIGHTFIELD_DEFAULT_SIZE, HEIGHTFIELD_DEFAULT_CELLSIZE, 1.5f, 0.2f, 200.0f, -50.0f);
dMatrix camMatrix (dRollMatrix(-20.0f * dDegreeToRad) * dYawMatrix(-45.0f * dDegreeToRad));
dQuaternion rot (camMatrix);
dVector origin (250.0f, 0.0f, 250.0f, 0.0f);
dFloat height = 1000.0f;
origin = FindFloor (scene->GetNewton(), dVector (origin.m_x, height, origin .m_z, 0.0f), height * 2);
origin.m_y += 10.0f;
scene->SetCameraMatrix(rot, origin);
int defaultMaterialID = NewtonMaterialGetDefaultGroupID (scene->GetNewton());
dVector location (origin);
location.m_x += 20.0f;
location.m_z += 20.0f;
dVector size (0.5f, 0.5f, 0.75f, 0.0f);
int count = 5;
// int count = 1;
dMatrix shapeOffsetMatrix (dGetIdentityMatrix());
AddPrimitiveArray(scene, 10.0f, location, size, count, count, 5.0f, _SPHERE_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddPrimitiveArray(scene, 10.0f, location, size, count, count, 5.0f, _BOX_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddPrimitiveArray(scene, 10.0f, location, size, count, count, 5.0f, _CAPSULE_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddPrimitiveArray(scene, 10.0f, location, size, count, count, 5.0f, _CYLINDER_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddPrimitiveArray(scene, 10.0f, location, size, count, count, 5.0f, _CONE_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddPrimitiveArray(scene, 10.0f, location, size, count, count, 5.0f, _CHAMFER_CYLINDER_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddPrimitiveArray(scene, 10.0f, location, size, count, count, 5.0f, _REGULAR_CONVEX_HULL_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddPrimitiveArray(scene, 10.0f, location, size, count, count, 5.0f, _RANDOM_CONVEX_HULL_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
AddPrimitiveArray(scene, 10.0f, location, size, count, count, 5.0f, _COMPOUND_CONVEX_CRUZ_PRIMITIVE, defaultMaterialID, shapeOffsetMatrix);
}
static void AddSinglePrimitive (DemoEntityManager* const scene, dFloat x, PrimitiveType type, int materialID)
{
dVector size(0.5f, 0.5f, 0.75f, 0.0f);
dMatrix matrix (dGetIdentityMatrix());
// create the shape and visual mesh as a common data to be re used
NewtonWorld* const world = scene->GetNewton();
NewtonCollision* const collision = CreateConvexCollision (world, dGetIdentityMatrix(), size, type, materialID);
// DemoMesh____* const geometry = new DemoMesh____("cylinder_1", collision, "wood_0.tga", "wood_0.tga", "wood_1.tga");
DemoMesh* const geometry = new DemoMesh("cylinder_1", scene->GetShaderCache(), collision, "smilli.tga", "smilli.tga", "smilli.tga");
matrix = dRollMatrix(dPi/2.0f);
matrix.m_posit.m_x = 0;
matrix.m_posit.m_z = x;
matrix.m_posit.m_y = 0;
CreateSimpleSolid (scene, geometry, 1.0, matrix, collision, materialID);
// do not forget to release the assets
geometry->Release();
NewtonDestroyCollision (collision);
}
