NewtonBody* CreateBodyPart(DemoEntity* const bodyPart)
{
NewtonWorld* const world = GetWorld();
NewtonCollision* const shape = bodyPart->CreateCollisionFromchildren(world);
dAssert(shape);
// calculate the bone matrix
dMatrix matrix(bodyPart->CalculateGlobalMatrix());
// create the rigid body that will make this bone
NewtonBody* const bone = NewtonCreateDynamicBody(world, shape, &matrix[0][0]);
// calculate the moment of inertia and the relative center of mass of the solid
//NewtonBodySetMassProperties (bone, definition.m_mass, shape);
NewtonBodySetMassProperties(bone, 1.0f, shape);
// save the user data with the bone body (usually the visual geometry)
NewtonBodySetUserData(bone, bodyPart);
// assign the material for early collision culling
//NewtonBodySetMaterialGroupID(bone, m_material);
// set the bod part force and torque call back to the gravity force, skip the transform callback
//NewtonBodySetForceAndTorqueCallback (bone, PhysicsApplyGravityForce);
NewtonBodySetForceAndTorqueCallback(bone, ClampAngularVelocity);
// destroy the collision helper shape
NewtonDestroyCollision(shape);
return bone;
}
void CustomPlayerController::SetPlayerOrigin (dFloat originHigh)
{
dAssert (0);
NewtonCollision* const playerShape = NewtonBodyGetCollision(m_body);
NewtonCompoundCollisionBeginAddRemove(playerShape);
dMatrix supportShapeMatrix (dGetIdentityMatrix());
supportShapeMatrix[0] = m_upVector;
supportShapeMatrix[1] = m_frontVector;
supportShapeMatrix[2] = supportShapeMatrix[0] * supportShapeMatrix[1];
supportShapeMatrix.m_posit = supportShapeMatrix[0].Scale(m_height * 0.5f - originHigh);
supportShapeMatrix.m_posit.m_w = 1.0f;
NewtonCollisionSetMatrix (m_supportShape, &supportShapeMatrix[0][0]);
dMatrix collisionShapeMatrix (supportShapeMatrix);
dFloat cylinderHeight = m_height - m_stairStep;
dAssert (cylinderHeight > 0.0f);
collisionShapeMatrix.m_posit = collisionShapeMatrix[0].Scale(cylinderHeight * 0.5f + m_stairStep - originHigh);
collisionShapeMatrix.m_posit.m_w = 1.0f;
NewtonCollisionSetMatrix (m_upperBodyShape, &collisionShapeMatrix[0][0]);
NewtonCompoundCollisionEndAddRemove (playerShape);
dFloat Ixx;
dFloat Iyy;
dFloat Izz;
dFloat mass;
NewtonBodyGetMassMatrix(m_body, &mass, &Ixx, &Iyy, &Izz);
NewtonBodySetMassProperties(m_body, mass, playerShape);
}
NewtonBody* CreateBodyPart(DemoEntity* const bodyPart, const dArmRobotConfig& definition)
{
NewtonCollision* const shape = MakeConvexHull(bodyPart);
// calculate the bone matrix
dMatrix matrix(bodyPart->CalculateGlobalMatrix());
NewtonWorld* const world = GetWorld();
// create the rigid body that will make this bone
NewtonBody* const body = NewtonCreateDynamicBody(world, shape, &matrix[0][0]);
// destroy the collision helper shape
NewtonDestroyCollision(shape);
// get the collision from body
NewtonCollision* const collision = NewtonBodyGetCollision(body);
// calculate the moment of inertia and the relative center of mass of the solid
NewtonBodySetMassProperties(body, definition.m_mass, collision);
//NewtonBodySetMassProperties(body, 0.0f, collision);
// save the user lifterData with the bone body (usually the visual geometry)
NewtonBodySetUserData(body, bodyPart);
// assign a body part id
//NewtonCollisionSetUserID(collision, definition.m_bodyPartID);
// set the bod part force and torque call back to the gravity force, skip the transform callback
NewtonBodySetForceAndTorqueCallback(body, PhysicsApplyGravityForce);
return body;
}
NewtonBody* CreateRigidBody(DemoEntityManager* const scene, dFloat mass, NewtonCollision* const deformableCollision)
{
//create the rigid body
NewtonWorld* const world = scene->GetNewton();
dMatrix matrix(GetCurrentMatrix());
//matrix.m_posit.m_y = FindFloor (world, matrix.m_posit.m_x, matrix.m_posit.m_z) + 4.0f;
SetMatrix(*scene, dQuaternion(), matrix.m_posit);
SetMatrix(*scene, dQuaternion(), matrix.m_posit);
NewtonBody* const deformableBody = NewtonCreateDynamicBody(world, deformableCollision, &matrix[0][0]);
// set the mass matrix
NewtonBodySetMassProperties(deformableBody, mass, deformableCollision);
// save the pointer to the graphic object with the body.
NewtonBodySetUserData(deformableBody, this);
// assign the wood id
// NewtonBodySetMaterialGroupID (deformableBody, materialId);
// set a destructor for this rigid body
NewtonBodySetDestructorCallback(deformableBody, PhysicsBodyDestructor);
// set the transform call back function
NewtonBodySetTransformCallback(deformableBody, DemoEntity::TransformCallback);
// set the force and torque call back function
NewtonBodySetForceAndTorqueCallback(deformableBody, PhysicsApplyGravityForce);
return deformableBody;
}
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);
}
NewtonBody* CreateSimpleBody (NewtonWorld* const world, void* const userData, dFloat mass, const dMatrix& matrix, NewtonCollision* const collision, int materialId)
{
// calculate the moment of inertia and the relative center of mass of the solid
// dVector origin;
// dVector inertia;
// NewtonConvexCollisionCalculateInertialMatrix (collision, &inertia[0], &origin[0]);
// dFloat Ixx = mass * inertia[0];
// dFloat Iyy = mass * inertia[1];
// dFloat Izz = mass * inertia[2];
//create the rigid body
NewtonBody* const rigidBody = NewtonCreateDynamicBody (world, collision, &matrix[0][0]);
// set the correct center of gravity for this body (these function are for legacy)
// NewtonBodySetCentreOfMass (rigidBody, &origin[0]);
// NewtonBodySetMassMatrix (rigidBody, mass, Ixx, Iyy, Izz);
// use a more convenient function for setting mass and inertia matrix
NewtonBodySetMassProperties (rigidBody, mass, collision);
// save the pointer to the graphic object with the body.
NewtonBodySetUserData (rigidBody, userData);
// assign the wood id
NewtonBodySetMaterialGroupID (rigidBody, materialId);
// set continuous collision mode
// NewtonBodySetContinuousCollisionMode (rigidBody, continueCollisionMode);
// set a destructor for this rigid body
NewtonBodySetDestructorCallback (rigidBody, PhysicsBodyDestructor);
// set the transform call back function
NewtonBodySetTransformCallback (rigidBody, DemoEntity::TransformCallback);
// set the force and torque call back function
NewtonBodySetForceAndTorqueCallback (rigidBody, PhysicsApplyGravityForce);
// set the matrix for both the rigid body and the graphic body
//NewtonBodySetMatrix (rigidBody, &matrix[0][0]);
//PhysicsSetTransform (rigidBody, &matrix[0][0], 0);
//dVector xxx (0, -9.8f * mass, 0.0f, 0.0f);
//NewtonBodySetForce (rigidBody, &xxx[0]);
// force the body to be active of inactive
// NewtonBodySetAutoSleep (rigidBody, sleepMode);
return rigidBody;
}
static void AddFracturedEntity(DemoEntityManager* const scene, DemoMesh* const visualMesh, NewtonCollision* const collision, const FractureEffect& fractureEffect, const dVector& location)
{
dQuaternion rotation;
SimpleFracturedEffectEntity* const entity = new SimpleFracturedEffectEntity(visualMesh, fractureEffect);
entity->SetMatrix(*scene, rotation, location);
entity->InterpolateMatrix(*scene, 1.0f);
scene->Append(entity);
dVector origin(0.0f);
dVector inertia(0.0f);
NewtonConvexCollisionCalculateInertialMatrix(collision, &inertia[0], &origin[0]);
dFloat mass = 10.0f;
int materialId = 0;
//create the rigid body
dMatrix matrix(dGetIdentityMatrix());
matrix.m_posit = location;
NewtonWorld* const world = scene->GetNewton();
NewtonBody* const rigidBody = NewtonCreateDynamicBody(world, collision, &matrix[0][0]);
entity->m_myBody = rigidBody;
entity->m_myMassInverse = 1.0f / mass;
// set the correct center of gravity for this body
//NewtonBodySetCentreOfMass (rigidBody, &origin[0]);
// set the mass matrix
NewtonBodySetMassProperties(rigidBody, mass, collision);
// save the pointer to the graphic object with the body.
NewtonBodySetUserData(rigidBody, entity);
// assign the wood id
NewtonBodySetMaterialGroupID(rigidBody, materialId);
// set continuous collision mode
// NewtonBodySetContinuousCollisionMode (rigidBody, continueCollisionMode);
// set a destructor for this rigid body
NewtonBodySetDestructorCallback(rigidBody, PhysicsBodyDestructor);
// set the transform call back function
NewtonBodySetTransformCallback(rigidBody, DemoEntity::TransformCallback);
// set the force and torque call back function
NewtonBodySetForceAndTorqueCallback(rigidBody, PhysicsApplyGravityForce);
}
void dVehicleChassis::Init(NewtonCollision* const chassisShape, dFloat mass, const dMatrix& localFrame, NewtonApplyForceAndTorque forceAndTorque, dFloat gravityMag)
{
dVehicleManager* const manager = (dVehicleManager*)GetManager();
NewtonWorld* const world = manager->GetWorld();
// create a body and call the low level init function
dMatrix locationMatrix(dGetIdentityMatrix());
NewtonBody* const body = NewtonCreateDynamicBody(world, chassisShape, &locationMatrix[0][0]);
// set vehicle mass, inertia and center of mass
NewtonBodySetMassProperties(body, mass, chassisShape);
// initialize
Init(body, localFrame, forceAndTorque, gravityMag);
}
void CustomVehicleController::Init (NewtonCollision* const chassisShape, const dMatrix& vehicleFrame, dFloat mass, const dVector& gravityVector)
{
CustomVehicleControllerManager* const manager = (CustomVehicleControllerManager*) GetManager();
NewtonWorld* const world = manager->GetWorld();
// create a body and an call the low level init function
dMatrix locationMatrix (dGetIdentityMatrix());
NewtonBody* const body = NewtonCreateDynamicBody(world, chassisShape, &locationMatrix[0][0]);
// set vehicle mass, inertia and center of mass
NewtonBodySetMassProperties (body, mass, chassisShape);
// initialize
Init (body, vehicleFrame, gravityVector);
}
void RigidBodyData::CreateBody(NewtonCollision* const collision, const dVector& veloc, const dVector& omega)
{
_ASSERTE (!m_body);
RigidBodyWorldDesc& me = *(RigidBodyWorldDesc*) RigidBodyWorldDesc::GetDescriptor();
dMatrix matrix (GetIdentityMatrix());
m_body = NewtonCreateDynamicBody(me.m_newton, collision, &matrix[0][0]);
//NewtonBodySetMassMatrix(m_body, m_mass, m_mass * m_inertia.m_x, m_mass * m_inertia.m_y, m_mass * m_inertia.m_z);
NewtonBodySetMassProperties(m_body, m_mass, collision);
NewtonBodySetCentreOfMass(m_body, &m_origin[0]);
NewtonBodySetVelocity(m_body, &veloc[0]);
NewtonBodySetOmega(m_body, &omega[0]);
NewtonBodySetForceAndTorqueCallback(m_body, RigidBodyController::ApplyGravityForce);
}
dNewtonDynamicBody::dNewtonDynamicBody(dNewtonWorld* const world, dNewtonCollision* const collision, dMatrix matrix, dFloat mass)
:dNewtonBody(matrix)
{
NewtonWorld* const newton = world->m_world;
NewtonWaitForUpdateToFinish(newton);
m_body = NewtonCreateDynamicBody(newton, collision->m_shape, &matrix[0][0]);
collision->DeleteShape();
collision->SetShape(NewtonBodyGetCollision(m_body));
NewtonBodySetMassProperties(m_body, mass, NewtonBodyGetCollision(m_body));
NewtonBodySetUserData(m_body, this);
NewtonBodySetTransformCallback(m_body, OnBodyTransformCallback);
NewtonBodySetForceAndTorqueCallback(m_body, OnForceAndTorqueCallback);
}
void dNewtonBody::SetCenterOfMass(float com_x, float com_y, float com_z)
{
dVector com;
dFloat Ixx;
dFloat Iyy;
dFloat Izz;
dFloat mass;
NewtonBodyGetMass(m_body, &mass, &Ixx, &Iyy, &Izz);
NewtonCollision* const collision = NewtonBodyGetCollision(m_body);
NewtonBodySetMassProperties(m_body, mass, NewtonBodyGetCollision(m_body));
NewtonBodyGetCentreOfMass (m_body, &com[0]);
com.m_x += com_x;
com.m_y += com_y;
com.m_z += com_z;
NewtonBodySetCentreOfMass(m_body, &com[0]);
}
// it fires a box when a key is pressed.
static void FireNewtonCcdBox(NewtonWorld* world, const dVector & postion, const dVector & velocity)
{
NewtonCollision* collision = NewtonCreateBox(world, 1.0f, 1.0f, 1.0f, 0, NULL);
dMatrix matrix(dGetIdentityMatrix());
matrix.m_posit = postion;
NewtonBody* const body = NewtonCreateDynamicBody(world, collision, &matrix[0][0]);
// set the force callback for applying the force and torque
NewtonBodySetForceAndTorqueCallback(body, ApplyGravity);
// set the mass for this body
dFloat mass = 1.0f;
NewtonBodySetMassProperties(body, mass, collision);
NewtonDestroyCollision(collision);
NewtonBodySetVelocity(body, &velocity[0]);
NewtonBodySetContinuousCollisionMode(body, 1);
}
static void AddSingleCompound(DemoEntityManager* const scene)
{
NewtonWorld* const world = scene->GetNewton();
NewtonCollision* compoundCollision = NewtonCreateCompoundCollision(world, 0);
NewtonCompoundCollisionBeginAddRemove(compoundCollision);
NewtonCollision* boxCollision = NewtonCreateBox(world, 50, 50, 50, 0, NULL);
NewtonCompoundCollisionAddSubCollision(compoundCollision, boxCollision);
NewtonDestroyCollision(boxCollision);
dMatrix matrix(dGetIdentityMatrix());
matrix.m_posit.m_y = 10.0f;
NewtonCompoundCollisionEndAddRemove(compoundCollision);
NewtonBody* compoundBody = NewtonCreateDynamicBody(world, compoundCollision, &matrix[0][0]);
NewtonDestroyCollision(compoundCollision);
// scale after creating body slows everything down. Without the scale it runs fine even though the body is huge
NewtonCollisionSetScale(NewtonBodyGetCollision(compoundBody), 0.05f, 0.05f, 0.05f);
// adding some visualization
NewtonBodySetMassProperties (compoundBody, 1.0f, NewtonBodyGetCollision(compoundBody));
NewtonBodySetTransformCallback(compoundBody, DemoEntity::TransformCallback);
NewtonBodySetForceAndTorqueCallback(compoundBody, PhysicsApplyGravityForce);
DemoMesh* mesh = new DemoMesh("geometry", NewtonBodyGetCollision(compoundBody), "smilli.tga", "smilli.tga", "smilli.tga");
DemoEntity* const entity = new DemoEntity(matrix, NULL);
entity->SetMesh(mesh, dGetIdentityMatrix());
mesh->Release();
NewtonBodySetUserData(compoundBody, entity);
scene->Append(entity);
NewtonBodySetSimulationState(compoundBody, 0);
NewtonBodySetSimulationState(compoundBody, 1);
}
dCustomPlayerController* dCustomPlayerControllerManager::CreateController(const dMatrix& location, const dMatrix& localAxis, dFloat mass, dFloat radius, dFloat height, dFloat stepHeight)
{
NewtonWorld* const world = GetWorld();
dMatrix shapeMatrix(localAxis);
shapeMatrix.m_posit = shapeMatrix.m_front.Scale (height * 0.5f);
shapeMatrix.m_posit.m_w = 1.0f;
dFloat scale = 3.0f;
height = dMax(height - 2.0f * radius / scale, dFloat(0.1f));
NewtonCollision* const bodyCapsule = NewtonCreateCapsule(world, radius / scale, radius / scale, height, 0, &shapeMatrix[0][0]);
NewtonCollisionSetScale(bodyCapsule, 1.0f, scale, scale);
// create the kinematic body
NewtonBody* const body = NewtonCreateKinematicBody(world, bodyCapsule, &location[0][0]);
// players must have weight, otherwise they are infinitely strong when they collide
NewtonCollision* const shape = NewtonBodyGetCollision(body);
NewtonBodySetMassProperties(body, mass, shape);
// make the body collidable with other dynamics bodies, by default
NewtonBodySetCollidable(body, 1);
NewtonDestroyCollision(bodyCapsule);
dCustomPlayerController& controller = m_playerList.Append()->GetInfo();
controller.m_localFrame = localAxis;
controller.m_mass = mass;
controller.m_invMass = 1.0f / mass;
controller.m_manager = this;
controller.m_kinematicBody = body;
controller.m_contactPatch = radius / scale;
controller.m_stepHeight = dMax (stepHeight, controller.m_contactPatch * 2.0f);
return &controller;
}
void CustomVehicleController::Init (NewtonCollision* const chassisShape, const dMatrix& vehicleFrame, dFloat mass, const dVector& gravityVector)
{
m_finalized = false;
m_externalContactStatesCount = 0;
m_sleepCounter = VEHICLE_SLEEP_COUNTER;
m_freeContactList = m_externalContactStatesPoll.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
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);
// create the rigid body for this vehicle
dMatrix locationMatrix (dGetIdentityMatrix());
m_body = NewtonCreateDynamicBody(world, vehShape, &locationMatrix[0][0]);
// set vehicle mass, inertia and center of mass
NewtonBodySetMassProperties (m_body, mass, 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_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_staticWorld);
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;
SetDryRollingFrictionTorque (100.0f/4.0f);
SetAerodynamicsDownforceCoefficient (0.5f * dSqrt (gravityVector % gravityVector), 60.0f * 0.447f);
}
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.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;
}
static void AddStructuredFractured (DemoEntityManager* const scene, const dVector& origin, int materialID, const char* const assetName)
{
// create the shape and visual mesh as a common data to be re used
NewtonWorld* const world = scene->GetNewton();
#if 0
// load the mesh asset
DemoEntity entity(GetIdentityMatrix(), NULL);
entity.LoadNGD_mesh (assetName, world);
DemoMesh____* const mesh = entity.GetMesh();
dAssert (mesh);
// convert the mesh to a newtonMesh
NewtonMesh* const solidMesh = mesh->CreateNewtonMesh (world, entity.GetMeshMatrix() * entity.GetCurrentMatrix());
#else
int externalMaterial = LoadTexture("wood_0.tga");
NewtonCollision* const collision = CreateConvexCollision (world, dGetIdentityMatrix(), dVector (3.0f, 3.0f, 3.0f, 0.0), _BOX_PRIMITIVE, 0);
NewtonMesh* const solidMesh = NewtonMeshCreateFromCollision(collision);
NewtonDestroyCollision(collision);
//NewtonMeshTriangulate(solidMesh);
NewtonMeshApplyBoxMapping (solidMesh, externalMaterial, externalMaterial, externalMaterial);
#endif
// create a random point cloud
dVector points[MAX_POINT_CLOUD_SIZE];
int pointCount = MakeRandomPoisonPointCloud (solidMesh, points);
// int pointCount = MakeRandomGuassianPointCloud (solidMesh, points, MAX_POINT_CLOUD_SIZE);
// create and interiors material for texturing the fractured pieces
//int internalMaterial = LoadTexture("KAMEN-stup.tga");
int internalMaterial = LoadTexture("concreteBrick.tga");
// crate a texture matrix for uv mapping of fractured pieces
dMatrix textureMatrix (dGetIdentityMatrix());
textureMatrix[0][0] = 1.0f / 2.0f;
textureMatrix[1][1] = 1.0f / 2.0f;
/// create the fractured collision and mesh
int debreePhysMaterial = NewtonMaterialGetDefaultGroupID(world);
NewtonCollision* structuredFracturedCollision = NewtonCreateFracturedCompoundCollision (world, solidMesh, 0, debreePhysMaterial, pointCount, &points[0][0], sizeof (dVector), internalMaterial, &textureMatrix[0][0],
OnReconstructMainMeshCallBack, OnEmitFracturedCompound, OnEmitFracturedChunk);
// uncomment this to test serialization
#if 0
FILE* file = fopen ("serialize.bin", "wb");
NewtonCollisionSerialize (world, structuredFracturedCollision, DemoEntityManager::SerializeFile, file);
NewtonDestroyCollision (structuredFracturedCollision);
fclose (file);
file = fopen ("serialize.bin", "rb");
structuredFracturedCollision = NewtonCreateCollisionFromSerialization (world, DemoEntityManager::DeserializeFile, file);
NewtonFracturedCompoundSetCallbacks (structuredFracturedCollision, OnReconstructMainMeshCallBack, OnEmitFracturedCompound, OnEmitFracturedChunk);
fclose (file);
#endif
#if 0
// test the interface
dTree<void*, void*> detachableNodes;
NewtonCompoundCollisionBeginAddRemove(structuredFracturedCollision);
// remove all chunk that can be detached for the first layer
for (void* node = NewtonCompoundCollisionGetFirstNode(structuredFracturedCollision); node; node = NewtonCompoundCollisionGetNextNode(structuredFracturedCollision, node)) {
if (NewtonFracturedCompoundIsNodeFreeToDetach (structuredFracturedCollision, node)) {
detachableNodes.Insert(node, node);
}
// remove any node that can be deched fro the secund layer, this codul; be reusive
void* neighbors[32];
int count = NewtonFracturedCompoundNeighborNodeList (structuredFracturedCollision, node, neighbors, sizeof (neighbors) / sizeof (neighbors[0]));
for (int i = 0; i < count; i ++ ) {
if (NewtonFracturedCompoundIsNodeFreeToDetach (structuredFracturedCollision, neighbors[i])) {
detachableNodes.Insert(node, node);
}
}
}
// now delete the actual nodes
dTree<void*, void*>::Iterator iter (detachableNodes) ;
for (iter.Begin(); iter; iter ++) {
void* const node = iter.GetNode()->GetInfo();
NewtonCompoundCollisionRemoveSubCollision (structuredFracturedCollision, node);
}
NewtonCompoundCollisionEndAddRemove(structuredFracturedCollision);
#endif
#if 1
dVector plane (0.0f, 1.0f, 0.0f, 0.0f);
NewtonCollision* const crack = NewtonFracturedCompoundPlaneClip (structuredFracturedCollision, &plane[0]);
if (crack) {
NewtonDestroyCollision (structuredFracturedCollision);
}
#endif
dVector com(0.0f);
dVector inertia(0.0f);
NewtonConvexCollisionCalculateInertialMatrix (structuredFracturedCollision, &inertia[0], &com[0]);
//dFloat mass = 10.0f;
//int materialId = 0;
//create the rigid body
dMatrix matrix (dGetIdentityMatrix());
matrix.m_posit = origin;
matrix.m_posit.m_y = 20.0;
matrix.m_posit.m_w = 1.0f;
NewtonBody* const rigidBody = NewtonCreateDynamicBody (world, structuredFracturedCollision, &matrix[0][0]);
// set the mass and center of mass
dFloat density = 1.0f;
dFloat mass = density * NewtonConvexCollisionCalculateVolume (structuredFracturedCollision);
NewtonBodySetMassProperties (rigidBody, mass, structuredFracturedCollision);
// set the transform call back function
NewtonBodySetTransformCallback (rigidBody, DemoEntity::TransformCallback);
// set the force and torque call back function
NewtonBodySetForceAndTorqueCallback (rigidBody, PhysicsApplyGravityForce);
// create the entity and visual mesh and attach to the body as user data
CreateVisualEntity (scene, rigidBody);
// assign the wood id
// NewtonBodySetMaterialGroupID (rigidBody, materialId);
// set a destructor for this rigid body
// NewtonBodySetDestructorCallback (rigidBody, PhysicsBodyDestructor);
// release the interior texture
// ReleaseTexture (internalMaterial);
// delete the solid mesh since it no longed needed
NewtonMeshDestroy (solidMesh);
// destroy the fracture collision
NewtonDestroyCollision (structuredFracturedCollision);
}
void SimulationPostListener(DemoEntityManager* const scene, DemoEntityManager::dListNode* const mynode, dFloat timeStep)
{
// see if the net force on the body comes fr a high impact collision
dFloat breakImpact = 0.0f;
for (NewtonJoint* joint = NewtonBodyGetFirstContactJoint(m_myBody); joint; joint = NewtonBodyGetNextContactJoint(m_myBody, joint)) {
for (void* contact = NewtonContactJointGetFirstContact(joint); contact; contact = NewtonContactJointGetNextContact(joint, contact)) {
dVector contactForce;
NewtonMaterial* const material = NewtonContactGetMaterial(contact);
dFloat impulseImpact = NewtonMaterialGetContactMaxNormalImpact(material);
if (impulseImpact > breakImpact) {
breakImpact = impulseImpact;
}
}
}
// if the force is bigger than N time Gravities, It is considered a collision force
breakImpact *= m_myMassInverse;
// breakImpact = 1000.0f;
if (breakImpact > BREAK_IMPACT_IN_METERS_PER_SECONDS) {
NewtonWorld* const world = NewtonBodyGetWorld(m_myBody);
dMatrix bodyMatrix;
dVector com(0.0f);
dVector veloc(0.0f);
dVector omega(0.0f);
dFloat Ixx;
dFloat Iyy;
dFloat Izz;
dFloat mass;
NewtonBodyGetVelocity(m_myBody, &veloc[0]);
NewtonBodyGetOmega(m_myBody, &omega[0]);
NewtonBodyGetCentreOfMass(m_myBody, &com[0]);
NewtonBodyGetMatrix(m_myBody, &bodyMatrix[0][0]);
NewtonBodyGetMass(m_myBody, &mass, &Ixx, &Iyy, &Izz);
com = bodyMatrix.TransformVector(com);
dMatrix matrix(GetCurrentMatrix());
dQuaternion rotation(matrix);
// we need to lock the world before creation a bunch of bodies
scene->Lock(m_lock);
for (FractureEffect::dListNode* node = m_effect.GetFirst(); node; node = node->GetNext()) {
FractureAtom& atom = node->GetInfo();
DemoEntity* const entity = new DemoEntity(dMatrix(rotation, matrix.m_posit), NULL);
entity->SetMesh(atom.m_mesh, dGetIdentityMatrix());
scene->Append(entity);
int materialId = 0;
dFloat debriMass = mass * atom.m_massFraction;
//create the rigid body
NewtonBody* const rigidBody = NewtonCreateDynamicBody(world, atom.m_collision, &matrix[0][0]);
// calculate debris initial velocity
dVector center(matrix.TransformVector(atom.m_centerOfMass));
dVector v(veloc + omega.CrossProduct(center - com));
// set initial velocity
NewtonBodySetVelocity(rigidBody, &v[0]);
NewtonBodySetOmega(rigidBody, &omega[0]);
// set the debris mass properties, mass, center of mass, and inertia
NewtonBodySetMassProperties(rigidBody, debriMass, atom.m_collision);
// save the pointer to the graphic object with the body.
NewtonBodySetUserData(rigidBody, entity);
// assign the wood id
NewtonBodySetMaterialGroupID(rigidBody, materialId);
// set continuous collision mode
// NewtonBodySetContinuousCollisionMode (rigidBody, continueCollisionMode);
// set a destructor for this rigid body
NewtonBodySetDestructorCallback(rigidBody, PhysicsBodyDestructor);
// set the transform call back function
NewtonBodySetTransformCallback(rigidBody, DemoEntity::TransformCallback);
// set the force and torque call back function
NewtonBodySetForceAndTorqueCallback(rigidBody, PhysicsApplyGravityForce);
}
NewtonDestroyBody(m_myBody);
scene->RemoveEntity(mynode);
// unlock the work after done with the effect
scene->Unlock(m_lock);
}
}
// 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);
}