void CustomPlayerController::SetPlayerOrigin (dFloat originHeight)
{
/*
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;
NewtonBodyGetMass(m_body, &mass, &Ixx, &Iyy, &Izz);
NewtonBodySetMassProperties(m_body, mass, playerShape);
*/
originHeight = dClamp (originHeight, dFloat(0.0f), m_height);
dVector origin (m_upVector.Scale (originHeight));
NewtonBodySetCentreOfMass (m_body, &origin[0]);
}
NewtonBody* CPhysics::CreateRigidBody(NewtonWorld *world, CObject3D *object, NewtonCollision *collision, float mass)
{
object->UpdateMatrix();
float matrix[16];
object->matrixModel.FlattenToArray(matrix);
Vector3 angles = object->rotation * ToRad;
NewtonBody *body = NewtonCreateBody(world, collision, matrix);
if (mass > 0)
{
float inertia[3], origin[3];
NewtonConvexCollisionCalculateInertialMatrix (collision, &inertia[0], &origin[0]);
NewtonBodySetMassMatrix(body, mass, mass * inertia[0], mass * inertia[1], mass * inertia[2]);
NewtonBodySetCentreOfMass(body, &origin[0]);
}
NewtonBodySetUserData(body, object);
NewtonBodySetTransformCallback(body, CPhysics::TransformCallback);
NewtonBodySetDestructorCallback(body, CPhysics::DestroyBodyCallback);
NewtonReleaseCollision(world, collision);
return body;
}
NewtonBody* Body::create(NewtonCollision* collision, float mass, int freezeState, const Vec4f& damping)
{
Vec4f minBox, maxBox;
Vec4f origin, inertia;
m_body = NewtonCreateBody(newton::world, collision, this->m_matrix[0]);
NewtonBodySetUserData(m_body, this);
NewtonBodySetMatrix(m_body, this->m_matrix[0]);
NewtonConvexCollisionCalculateInertialMatrix(collision, &inertia[0], &origin[0]);
if (mass < 0.0f)
mass = NewtonConvexCollisionCalculateVolume(collision) * 0.5f;
if (mass != 0.0f)
NewtonBodySetMassMatrix(m_body, mass, mass * inertia.x, mass * inertia.y, mass * inertia.z);
NewtonBodySetCentreOfMass(m_body, &origin[0]);
NewtonBodySetForceAndTorqueCallback(m_body, Body::__applyForceAndTorqueCallback);
NewtonBodySetTransformCallback(m_body, Body::__setTransformCallback);
NewtonBodySetDestructorCallback(m_body, Body::__destroyBodyCallback);
NewtonBodySetFreezeState(m_body, freezeState);
NewtonBodySetLinearDamping(m_body, damping.w);
NewtonBodySetAngularDamping(m_body, &damping[0]);
return m_body;
}
static void AddShatterEntity (DemoEntityManager* const scene, DemoMesh* const visualMesh, NewtonCollision* const collision, const ShatterEffect& shatterEffect, dVector location)
{
dQuaternion rotation;
SimpleShatterEffectEntity* const entity = new SimpleShatterEffectEntity (visualMesh, shatterEffect);
entity->SetMatrix(*scene, rotation, location);
entity->InterpolateMatrix (*scene, 1.0f);
scene->Append(entity);
dVector origin;
dVector inertia;
NewtonConvexCollisionCalculateInertialMatrix (collision, &inertia[0], &origin[0]);
float mass = 10.0f;
int materialId = 0;
dFloat Ixx = mass * inertia[0];
dFloat Iyy = mass * inertia[1];
dFloat Izz = mass * inertia[2];
//create the rigid body
dMatrix matrix (GetIdentityMatrix());
matrix.m_posit = location;
NewtonWorld* const world = scene->GetNewton();
NewtonBody* const rigidBody = NewtonCreateBody (world, collision, &matrix[0][0]);
entity->m_myBody = rigidBody;
entity->m_myweight = dAbs (mass * DEMO_GRAVITY);
// set the correct center of gravity for this body
NewtonBodySetCentreOfMass (rigidBody, &origin[0]);
// set the mass matrix
NewtonBodySetMassMatrix (rigidBody, mass, Ixx, Iyy, Izz);
// activate
// NewtonBodyCoriolisForcesMode (blockBoxBody, 1);
// save the pointer to the graphic object with the body.
NewtonBodySetUserData (rigidBody, entity);
// assign the wood id
NewtonBodySetMaterialGroupID (rigidBody, materialId);
// set continue collision mode
// NewtonBodySetContinuousCollisionMode (rigidBody, continueCollisionMode);
// set a destructor for this rigid body
NewtonBodySetDestructorCallback (rigidBody, PhysicsBodyDestructor);
// set the transform call back function
NewtonBodySetTransformCallback (rigidBody, DemoEntity::SetTransformCallback);
// set the force and torque call back function
NewtonBodySetForceAndTorqueCallback (rigidBody, PhysicsApplyGravityForce);
}
void cPhysicsBodyNewton::SetMass(float afMass)
{
cCollideShapeNewton *pShapeNewton = static_cast<cCollideShapeNewton*>(mpShape);
cVector3f vInertia;// = pShapeNewton->GetInertia(afMass);
cVector3f vOffset;
NewtonConvexCollisionCalculateInertialMatrix(pShapeNewton->GetNewtonCollision(),
vInertia.v, vOffset.v);
vInertia = vInertia * afMass;
NewtonBodySetCentreOfMass(mpNewtonBody,vOffset.v);
NewtonBodySetMassMatrix(mpNewtonBody, afMass, vInertia.x, vInertia.y, vInertia.z);
mfMass = afMass;
}
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);
}
NewtonUserJoint* CreateRayCastCast (NewtonBody* body, SceneManager* sceneManager, dFloat tirePosit[4][3])
{
dVector minBox;
dVector maxBox;
dVector origin(0, 0, 0, 1);
dVector inertia(0, 0, 0, 1);
NewtonUserJoint* carJoint;
NewtonCollision* chassisCollision;
// the first thing we need to do is to place the vehicle center of Mass on a stable position for a car
// calculate the moment of inertia and the relative center of mass of the solid
chassisCollision = NewtonBodyGetCollision(body);
NewtonConvexCollisionCalculateInertialMatrix (chassisCollision, &inertia[0], &origin[0]);
CalculateBoxdingBox (chassisCollision, minBox, maxBox);
//displace the center of mass by some value
origin.m_y -= 0.5f * (maxBox.m_y - minBox.m_y) * LOW_CENTER_OF_MASS_FACTOR;
// now we Set a new center of mass for this car
NewtonBodySetCentreOfMass (body, &origin[0]);
// Next we need to set the internal coordinate system of the car geometry
// this particular demo the car direction of motion is axis (1, 0, 0)
// the car up direction (0, 1, 0);
// the car lateral direction is the cross product of the front and vertical axis
dMatrix chassisMatrix;
chassisMatrix.m_front = dVector (1.0f, 0.0f, 0.0f, 0.0f); // this is the vehicle direction of travel
chassisMatrix.m_up = dVector (0.0f, 1.0f, 0.0f, 0.0f); // this is the downward vehicle direction
chassisMatrix.m_right = chassisMatrix.m_front * chassisMatrix.m_up; // this is in the side vehicle direction (the plane of the wheels)
chassisMatrix.m_posit = dVector (0.0f, 0.0f, 0.0f, 1.0f);
// create a vehicle joint with 4 tires
carJoint = DGRaycastVehicleCreate (4, &chassisMatrix[0][0], body);
// we need to set a transform call back to render the tire entities
DGRaycastVehicleSetTireTransformCallback (carJoint, TireTransformCallback);
// now we will add four tires to this vehicle,
AddTire (carJoint, "leftTire.dat", dVector (tirePosit[0][0], tirePosit[0][1], tirePosit[0][2], 0.0f), sceneManager);
AddTire (carJoint, "rightTire.dat", dVector (tirePosit[1][0], tirePosit[1][1], tirePosit[1][2], 0.0f), sceneManager);
AddTire (carJoint, "leftTire.dat", dVector (tirePosit[2][0], tirePosit[2][1], tirePosit[2][2], 0.0f), sceneManager);
AddTire (carJoint, "rightTire.dat", dVector (tirePosit[3][0], tirePosit[3][1], tirePosit[3][2], 0.0f), sceneManager);
return carJoint;
}
/*
=============
CMod_PhysicsAddEntity
=============
*/
void CMod_PhysicsAddEntity(sharedEntity_t * gEnt) {
NewtonCollision* collision = NULL;
NewtonBody* body = NULL;
std::map<int, bspCmodel>::iterator it = bspModels.find (gEnt->s.modelindex);
if ( it == bspModels.end() ) {
return;
}
vec3_t inertia, com;
dMatrix matrix (GetIdentityMatrix());
bspCmodel* bmodel = &it->second;
collision = NewtonCreateConvexHull (g_world, bmodel->vertices.size(), &bmodel->vertices[0].m_x, sizeof (dVector), 0.0f, &matrix[0][0]);
body = NewtonCreateBody (g_world, collision);
NewtonConvexCollisionCalculateVolume (collision);
NewtonReleaseCollision (g_world, collision);
bmodel->rigidBody = body;
NewtonBodySetMaterialGroupID (body, defaultMaterialGroup);
NewtonBodySetUserData (body, (void*)gEnt);
NewtonBodySetDestructorCallback (body, PhysicsEntityDie);
NewtonBodySetContinuousCollisionMode (body, 0);
NewtonBodySetForceAndTorqueCallback (body, PhysicsEntityThink);
NewtonBodySetTransformCallback (body, PhysicsEntitySetTransform);
NewtonConvexCollisionCalculateInertialMatrix (collision, &inertia[0], &com[0]);
NewtonBodySetCentreOfMass (body, &com[0]);
VectorScale (inertia, 10.0f, inertia); // The inertia needs to be scaled by the mass.
NewtonBodySetMassMatrix (body, 10.f, inertia[0], inertia[1], inertia[2]);
matrix.m_posit.m_x = gEnt->s.origin[0] * UNITS_PER_METRE;
matrix.m_posit.m_y = gEnt->s.origin[1] * UNITS_PER_METRE;
matrix.m_posit.m_z = gEnt->s.origin[2] * UNITS_PER_METRE;
NewtonBodySetMatrix (body, &matrix[0][0]);
gEnt->s.pos.trType = TR_INTERPOLATE;
VectorCopy (gEnt->s.origin, gEnt->s.pos.trBase);
VectorCopy (gEnt->s.origin, gEnt->r.currentOrigin);
gEnt->s.apos.trType = TR_INTERPOLATE;
VectorCopy (gEnt->s.angles, gEnt->s.apos.trBase);
VectorCopy (gEnt->s.angles, gEnt->r.currentAngles);
}
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]);
}
NewtonBody* CreateRigidBody (NewtonWorld* world, Entity* ent, NewtonCollision* collision, dFloat mass)
{
dVector minBox;
dVector maxBox;
dVector origin;
dVector inertia;
NewtonBody* body;
// Now with the collision Shape we can crate a rigid body
body = NewtonCreateBody (world, collision);
// bodies can have a destructor.
// this is a function callback that can be used to destroy any local data stored
// and that need to be destroyed before the body is destroyed.
NewtonBodySetDestructorCallback (body, DestroyBodyCallback);
// save the entity as the user data for this body
nEWTONbODySetUserData (body, ent);
// we need to set physics properties to this body
dMatrix matrix (ent->m_curRotation, ent->m_curPosition);
NewtonBodySetMatrix (body, &matrix[0][0]);
// we need to set the proper center of mass and inertia matrix for this body
// the inertia matrix calculated by this function does not include the mass.
// therefore it needs to be multiplied by the mass of the body before it is used.
NewtonConvexCollisionCalculateInertialMatrix (collision, &inertia[0], &origin[0]);
// set the body mass matrix
NewtonBodySetMassMatrix (body, mass, mass * inertia.m_x, mass * inertia.m_y, mass * inertia.m_z);
// set the body origin
NewtonBodySetCentreOfMass (body, &origin[0]);
// set the function callback to apply the external forces and torque to the body
// the most common force is Gravity
NewtonBodySetForceAndTorqueCallback (body, ApplyForceAndTorqueCallback);
// set the function callback to set the transformation state of the graphic entity associated with this body
// each time the body change position and orientation in the physics world
NewtonBodySetTransformCallback (body, SetTransformCallback);
return body;
}
void Car::initPhysics() {
NewtonWorld * nWorld = this->controller->getWorld();
NewtonCollision* collision;
float mass = 900.0f;
vector3df v1 = this->carNode->getBoundingBox().MinEdge;
vector3df v2 = this->carNode->getBoundingBox().MaxEdge;
dVector minBox(v1.X, v1.Y, v1.Z);
dVector maxBox(v2.X, v2.Y, v2.Z);
dVector size(maxBox - minBox);
dVector origin((maxBox + minBox).Scale(0.5f));
size.m_w = 1.0f;
origin.m_w = 1.0f;
dMatrix offset(GetIdentityMatrix());
offset.m_posit = origin;
collision = NewtonCreateBox(nWorld, size.m_x, size.m_y, size.m_z, 0, &offset[0][0]);
dVector inertia;
matrix4 m = this->carNode->getRelativeTransformation();
NewtonConvexHullModifierSetMatrix(collision, m.pointer());
NewtonBody * body = NewtonCreateBody(nWorld, collision, m.pointer());
NewtonBodySetUserData(body, this);
NewtonConvexCollisionCalculateInertialMatrix(collision, &inertia[0], &origin[0]);
NewtonBodySetMassMatrix(body, mass, mass * inertia.m_x, mass * inertia.m_y, mass * inertia.m_z);
NewtonBodySetCentreOfMass(body, &origin[0]);
NewtonBodySetForceAndTorqueCallback(body, applyCarMoveForce);
NewtonBodySetTransformCallback(body, applyCarTransform);
int matId = NewtonMaterialGetDefaultGroupID(nWorld);
NewtonMaterialSetCollisionCallback(nWorld, matId, matId, this, 0, applyCarCollisionForce);
NewtonReleaseCollision(nWorld, collision);
this->setCarBodyAndGravity(body, dVector(0,-10,0,0));
this->setLocalCoordinates(this->createChassisMatrix());
}
void RigidBodyUIPane::SetSelectionMass (dFloat mass)
{
RigidBodyWorldDesc* const plugin = (RigidBodyWorldDesc*) RigidBodyWorldDesc::GetDescriptor();
Interface* const ip = GetCOREInterface();
int selectionCount = ip->GetSelNodeCount();
for (int i = 0; i < selectionCount; i ++) {
INode* const node = ip->GetSelNode(i);
RigidBodyController* const bodyInfo = (RigidBodyController*)plugin->GetRigidBodyControl(node);
if (bodyInfo) {
bodyInfo->m_mass = mass;
_ASSERTE (bodyInfo->m_body);
// dVector inertia (bodyInfo->m_inertia.Scale (mass));
// NewtonBodySetMassMatrix(bodyInfo->m_body, mass, inertia.m_x, inertia.m_y, inertia.m_z);
NewtonCollisionInfoRecord info;
NewtonCollision* const collision = NewtonBodyGetCollision(bodyInfo->m_body);
NewtonCollisionGetInfo (collision, &info);
switch (info.m_collisionType)
{
case SERIALIZE_ID_BOX:
case SERIALIZE_ID_CONE:
case SERIALIZE_ID_SPHERE:
case SERIALIZE_ID_CAPSULE:
case SERIALIZE_ID_CYLINDER:
case SERIALIZE_ID_COMPOUND:
case SERIALIZE_ID_CONVEXHULL:
case SERIALIZE_ID_CONVEXMODIFIER:
case SERIALIZE_ID_CHAMFERCYLINDER:
{
NewtonConvexCollisionCalculateInertialMatrix (collision, &bodyInfo->m_inertia[0], &bodyInfo->m_origin[0]);
NewtonBodySetCentreOfMass(bodyInfo->m_body, &bodyInfo->m_origin[0]);
NewtonBodySetMassMatrix(bodyInfo->m_body, bodyInfo->m_mass, bodyInfo->m_mass * bodyInfo->m_inertia.m_x, bodyInfo->m_mass * bodyInfo->m_inertia.m_y, bodyInfo->m_mass * bodyInfo->m_inertia.m_z);
}
}
}
}
}
void NzPhysObject::SetMass(float mass)
{
if (m_mass > 0.f)
{
float Ix, Iy, Iz;
NewtonBodyGetMassMatrix(m_body, &m_mass, &Ix, &Iy, &Iz);
float scale = mass/m_mass;
NewtonBodySetMassMatrix(m_body, mass, Ix*scale, Iy*scale, Iz*scale);
}
else if (mass > 0.f)
{
NzVector3f inertia, origin;
m_geom->ComputeInertialMatrix(&inertia, &origin);
NewtonBodySetCentreOfMass(m_body, &origin.x);
NewtonBodySetMassMatrix(m_body, mass, inertia.x*mass, inertia.y*mass, inertia.z*mass);
NewtonBodySetForceAndTorqueCallback(m_body, &ForceAndTorqueCallback);
NewtonBodySetTransformCallback(m_body, &TransformCallback);
}
m_mass = mass;
}
NewtonBody* dRigidbodyNodeInfo::CreateNewtonBody (NewtonWorld* const world, dScene* const scene, dScene::dTreeNode* const myNode) const
{
// find the collision and crate a rigid body
dAssert (IsType (dRigidbodyNodeInfo::GetRttiType()));
// attach the parent node as user data
dScene::dTreeNode* parentNode = scene->FindParentByType(myNode, dSceneNodeInfo::GetRttiType());
dSceneNodeInfo* sceneInfo = (dSceneNodeInfo*) scene->GetInfoFromNode(parentNode);
dScene::dTreeNode* shapeNode = scene->FindChildByType (myNode, dCollisionNodeInfo::GetRttiType());
dAssert (shapeNode);
dCollisionNodeInfo* collInfo = (dCollisionNodeInfo*) scene->GetInfoFromNode(shapeNode);
dMatrix matrix (sceneInfo->CalculateOrthoMatrix());
NewtonCollision* const collision = collInfo->CreateNewtonCollision (world, scene, shapeNode);
NewtonBody* const body = NewtonCreateDynamicBody(world, collision, &matrix[0][0]);
NewtonDestroyCollision(collision);
// NewtonBodySetMatrix(body, &matrix[0][0]);
NewtonBodySetUserData(body, parentNode);
NewtonBodySetCentreOfMass(body, &m_centerOfMass[0]);
NewtonBodySetMassMatrix(body, m_massMatrix.m_w, m_massMatrix.m_x, m_massMatrix.m_y, m_massMatrix.m_z);
NewtonBodySetVelocity(body, &m_velocity[0]);
NewtonBodySetOmega(body, &m_omega[0]);
//dVector internalDamp(rigidBody->GetI);
//NewtonBodySetLinearDamping(body, internalDamp);
//dVariable* bodyType = rigidBody->FindVariable("rigidBodyType");
//if (!bodyType || !strcmp (bodyType->GetString(), "default gravity")) {
// NewtonBodySetTransformCallback(body, DemoEntity::TransformCallback);
//}
return body;
}
void NzPhysObject::SetMassCenter(const NzVector3f& center)
{
if (m_mass > 0.f)
NewtonBodySetCentreOfMass(m_body, center);
}
void cPhysicsBodyNewton::SetMassCentre(const cVector3f &a_vCentre)
{
NewtonBodySetCentreOfMass(m_pNewtonBody, a_vCentre.v);
}
Car::Car(const ion::base::String& identifier,NewtonWorld *pWorld,const ion::video::Mesh& srcmesh,const float mass,
const float Ixx,const float Iyy,const float Izz):Node(identifier),m_pNewtonChassisCollision(0),m_pBody(0),
m_pNewtonworld(pWorld),m_pNewtonJoint(0)
{
if (pWorld==0) {
ion::base::log("Car::Car()",ion::base::Error) << "No NewtonWorld pointer given\n";
return;
}
if (!srcmesh.isValid()) {
ion::base::log("Car::Car()",ion::base::Error) << "Source mesh is invalid\n";
return;
}
if (!srcmesh.vertexstream().isMapped()) {
ion::base::log("Car::Car()",ion::base::Error) << "source mesh \"" << srcmesh.objIdentifier() << " is not mapped!\n";
return;
}
if ((m_pNewtonChassisCollision!=0) && (m_pNewtonworld!=0))
NewtonReleaseCollision(m_pNewtonworld,m_pNewtonChassisCollision);
float *pPoints;
{
pPoints=new float[3*srcmesh.vertexstream().capacity()];
for (ion_uint32 v=0;v<srcmesh.vertexstream().capacity();++v) {
const ion::math::Vector3f &rV=srcmesh.vertexstream().position(v);
pPoints[v*3+0]=rV.x();
pPoints[v*3+1]=rV.y();
pPoints[v*3+2]=rV.z();
}
}
ion::math::Matrix4f c;
m_pNewtonworld=pWorld;
m_pNewtonChassisCollision=NewtonCreateConvexHull(m_pNewtonworld,srcmesh.vertexstream().capacity(),pPoints,12,c);
m_pBody=NewtonCreateBody(m_pNewtonworld,m_pNewtonChassisCollision);
NewtonBodySetUserData(m_pBody,this);
ion::math::Vector3f origin,inertia;
// calculate the moment of inertia and the relative center of mass of the solid
NewtonConvexCollisionCalculateInertialMatrix (m_pNewtonChassisCollision, &inertia[0], &origin[0]);
float ixx = mass * inertia[0];
float iyy = mass * inertia[1];
float izz = mass * inertia[2];
// set the mass matrix
NewtonBodySetMassMatrix (m_pBody, mass, ixx, iyy, izz);
origin.y()=-1;
NewtonBodySetCentreOfMass (m_pBody, &origin[0]);
NewtonBodySetMatrix(m_pBody,localTransform().matrix());
NewtonReleaseCollision(m_pNewtonworld,m_pNewtonChassisCollision);
NewtonBodySetTransformCallback (m_pBody, physicsSetTransform);
NewtonBodySetForceAndTorqueCallback (m_pBody, physicsApplyForceAndTorque);
float updir[3]={0,1,0};
m_pNewtonJoint=NewtonConstraintCreateVehicle(m_pNewtonworld,&updir[0],m_pBody);
NewtonVehicleSetTireCallback(m_pNewtonJoint,tireUpdate);
delete [] pPoints;
}
void SimulationLister(DemoEntityManager* const scene, DemoEntityManager::dListNode* const mynode, dFloat timeStep)
{
m_delay --;
if (m_delay > 0) {
return;
}
// see if the net force on the body comes fr a high impact collision
dFloat maxInternalForce = 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 point;
//dVector normal;
dVector contactForce;
NewtonMaterial* const material = NewtonContactGetMaterial (contact);
//NewtonMaterialGetContactPositionAndNormal (material, &point.m_x, &normal.m_x);
NewtonMaterialGetContactForce(material, m_myBody, &contactForce[0]);
dFloat forceMag = contactForce % contactForce;
if (forceMag > maxInternalForce) {
maxInternalForce = forceMag;
}
}
}
// if the force is bigger than 4 Gravities, It is considered a collision force
dFloat maxForce = BREAK_FORCE_IN_GRAVITIES * m_myweight;
if (maxInternalForce > (maxForce * maxForce)) {
NewtonWorld* const world = NewtonBodyGetWorld(m_myBody);
dFloat Ixx;
dFloat Iyy;
dFloat Izz;
dFloat mass;
NewtonBodyGetMassMatrix(m_myBody, &mass, &Ixx, &Iyy, &Izz);
dVector com;
dVector veloc;
dVector omega;
dMatrix bodyMatrix;
NewtonBodyGetVelocity(m_myBody, &veloc[0]);
NewtonBodyGetOmega(m_myBody, &omega[0]);
NewtonBodyGetCentreOfMass(m_myBody, &com[0]);
NewtonBodyGetMatrix(m_myBody, &bodyMatrix[0][0]);
com = bodyMatrix.TransformVector (com);
dMatrix matrix (GetCurrentMatrix());
dQuaternion rotation (matrix);
for (ShatterEffect::dListNode* node = m_effect.GetFirst(); node; node = node->GetNext()) {
ShatterAtom& atom = node->GetInfo();
DemoEntity* const entity = new DemoEntity (NULL);
entity->SetMesh (atom.m_mesh);
entity->SetMatrix(*scene, rotation, matrix.m_posit);
entity->InterpolateMatrix (*scene, 1.0f);
scene->Append(entity);
int materialId = 0;
dFloat debriMass = mass * atom.m_massFraction;
dFloat Ixx = debriMass * atom.m_momentOfInirtia.m_x;
dFloat Iyy = debriMass * atom.m_momentOfInirtia.m_y;
dFloat Izz = debriMass * atom.m_momentOfInirtia.m_z;
//create the rigid body
NewtonBody* const rigidBody = NewtonCreateBody (world, atom.m_collision, &matrix[0][0]);
// set the correct center of gravity for this body
NewtonBodySetCentreOfMass (rigidBody, &atom.m_centerOfMass[0]);
// calculate the center of mas of the debris
dVector center (matrix.TransformVector(atom.m_centerOfMass));
// calculate debris initial velocity
dVector v (veloc + omega * (center - com));
// set initial velocity
NewtonBodySetVelocity(rigidBody, &v[0]);
NewtonBodySetOmega(rigidBody, &omega[0]);
// set the debrie center of mass
NewtonBodySetCentreOfMass (rigidBody, &atom.m_centerOfMass[0]);
// set the mass matrix
NewtonBodySetMassMatrix (rigidBody, debriMass, Ixx, Iyy, Izz);
// activate
// NewtonBodyCoriolisForcesMode (blockBoxBody, 1);
// save the pointer to the graphic object with the body.
NewtonBodySetUserData (rigidBody, entity);
// assign the wood id
NewtonBodySetMaterialGroupID (rigidBody, materialId);
// set continue collision mode
// NewtonBodySetContinuousCollisionMode (rigidBody, continueCollisionMode);
// set a destructor for this rigid body
NewtonBodySetDestructorCallback (rigidBody, PhysicsBodyDestructor);
// set the transform call back function
NewtonBodySetTransformCallback (rigidBody, DemoEntity::SetTransformCallback);
// set the force and torque call back function
NewtonBodySetForceAndTorqueCallback (rigidBody, PhysicsApplyGravityForce);
}
NewtonDestroyBody(world, m_myBody);
scene->RemoveEntity (mynode);
}
};
static void CreateDebriPiece (const NewtonBody* sourceBody, NewtonMesh* mesh, dFloat volume)
{
dFloat Ixx;
dFloat Iyy;
dFloat Izz;
dFloat mass;
dFloat shapeVolume;
NewtonWorld* world;
NewtonBody* rigidBody;
NewtonCollision* collision;
OGLMesh* meshInstance;
SceneManager* system;
RenderPrimitive* primitive;
dVector inertia;
dVector origin;
dVector veloc;
dVector omega;
dMatrix matrix;
world = NewtonBodyGetWorld (sourceBody);
NewtonBodyGetMatrix (sourceBody, &matrix[0][0]);
NewtonBodyGetMassMatrix (sourceBody, &mass, &Ixx, &Iyy, &Izz);
// make a visual object
meshInstance = new OGLMesh();
meshInstance->BuildFromMesh (mesh);
// create a visual geometry
primitive = new RenderPrimitive (matrix, meshInstance);
meshInstance->Release();
// save the graphics system
system = (SceneManager*) NewtonWorldGetUserData(world);
system->AddModel (primitive);
collision = NewtonCreateConvexHullFromMesh (world, mesh, 0.1f, DEBRI_ID);
// calculate the moment of inertia and the relative center of mass of the solid
shapeVolume = NewtonConvexCollisionCalculateVolume (collision);
NewtonConvexCollisionCalculateInertialMatrix (collision, &inertia[0], &origin[0]);
mass = mass * shapeVolume / volume;
Ixx = mass * inertia[0];
Iyy = mass * inertia[1];
Izz = mass * inertia[2];
//create the rigid body
rigidBody = NewtonCreateBody (world, collision);
// set the correct center of gravity for this body
NewtonBodySetCentreOfMass (rigidBody, &origin[0]);
// set the mass matrix
NewtonBodySetMassMatrix (rigidBody, mass, Ixx, Iyy, Izz);
// save the pointer to the graphic object with the body.
NewtonBodySetUserData (rigidBody, primitive);
// assign the wood id
// NewtonBodySetMaterialGroupID (rigidBody, NewtonBodyGetMaterialGroupID(source));
// set continue collision mode
NewtonBodySetContinuousCollisionMode (rigidBody, 1);
// set a destructor for this rigid body
NewtonBodySetDestructorCallback (rigidBody, PhysicsBodyDestructor);
// set the transform call back function
NewtonBodySetTransformCallback (rigidBody, PhysicsSetTransform);
// 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);
NewtonBodyGetVelocity(sourceBody, &veloc[0]);
NewtonBodyGetOmega(sourceBody, &omega[0]);
veloc += omega * matrix.RotateVector(origin);
// for now so that I can see the body
veloc = dVector (0, 0, 0, 0);
// omega = dVector (0, 0, 0, 0);
NewtonBodySetVelocity(rigidBody, &veloc[0]);
NewtonBodySetOmega(rigidBody, &omega[0]);
NewtonReleaseCollision(world, collision);
}