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