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;
}
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;
}
virtual const void InitRigiBody(const NewtonBody* const body, const char* const bodyName) const
{
dMatrix matrix;
DemoEntityManager* const scene = (DemoEntityManager*)NewtonWorldGetUserData(NewtonBodyGetWorld(body));
NewtonCollision* const collision = NewtonBodyGetCollision(body);
DemoMesh* const mesh = new DemoMesh("ragdoll", collision, "smilli.tga", "smilli.tga", "smilli.tga");
NewtonBodyGetMatrix(body, &matrix[0][0]);
DemoEntity* const entity = new DemoEntity(matrix, NULL);
entity->SetNameID (bodyName);
entity->SetMesh(mesh, dGetIdentityMatrix());
scene->Append(entity);
mesh->Release();
// save the pointer to the graphic object with the body.
NewtonBodySetUserData(body, entity);
// assign the wood id
NewtonBodySetMaterialGroupID(body, m_material);
//set continuous collision mode
//NewtonBodySetContinuousCollisionMode (rigidBody, continueCollisionMode);
// set a destructor for this rigid body
NewtonBodySetDestructorCallback(body, PhysicsBodyDestructor);
// set the transform call back function
NewtonBodySetTransformCallback(body, DemoEntity::TransformCallback);
// set the force and torque call back function
NewtonBodySetForceAndTorqueCallback(body, PhysicsApplyGravityForce);
}
static void OnEmitFracturedChunk (NewtonBody* const chunkBody, NewtonFracturedCompoundMeshPart* const fractureChunkMesh, const NewtonCollision* const fracturedCompoundCollision)
{
NewtonWorld* const world = NewtonBodyGetWorld(chunkBody);
DemoEntityManager* const scene = (DemoEntityManager*)NewtonWorldGetUserData(world);
// set the force an torque call back
NewtonBodySetForceAndTorqueCallback (chunkBody, PhysicsApplyGravityForce);
// set the transform callback
NewtonBodySetTransformCallback (chunkBody, DemoEntity::TransformCallback);
// create the visual entity and mesh, and set the use data
dMatrix matrix;
NewtonBodyGetMatrix (chunkBody, &matrix[0][0]);
DemoEntity* const visualChunkEntity = new DemoEntity(matrix, NULL);
scene->Append(visualChunkEntity);
NewtonBodySetUserData (chunkBody, visualChunkEntity);
// create the mesh geometry and attach it to the entity
DemoMesh* const visualChunkMesh = new DemoMesh ("fracturedChuckMesh");
visualChunkEntity->SetMesh (visualChunkMesh, dGetIdentityMatrix());
visualChunkMesh->Release();
// add the vertex data
AddMeshVertexwData (visualChunkMesh, fractureChunkMesh, fracturedCompoundCollision);
// add the mesh indices
OnReconstructMainMeshCallBack (chunkBody, fractureChunkMesh, fracturedCompoundCollision);
}
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;
}
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;
}
Roket_PhysicsBody::Roket_PhysicsBody(NewtonCollision* collision, NewtonWorld* physworld, ePhysicsType type, int materialid)
{
body = NewtonCreateBody(physworld,collision);
NewtonReleaseCollision(physworld,collision);
NewtonBodySetUserData(body,this);
NewtonBodySetTransformCallback(body,physics::TransformCallback);
NewtonBodySetForceAndTorqueCallback(body,physics::ApplyForceAndTorqueCallback);
affectedByGravity = true;
objectExists = true;
// apply initial force
/*float omega[3];
omega[0] = 10.0f;
omega[1] = 10.0f;
omega[2] = 10.0f;
NewtonBodySetOmega (body, &omega[0]);*/
/*
float force[3];
force[0] = 0.0f;
force[1] = -9.8f;
force[2] = 0.0f;
NewtonBodyAddForce( body, &force[0] );
*/
world = physworld;
}
NewtonBody* AddSphere(CScene *pScene, NewtonWorld *pWorld, Vector3 pos, float radius, float mass)
{
static map<float, CGeometry*> geometries;
static CMaterial *material = NULL;
if (!material)
{
material = new CMaterial();
material->features = EShaderFeature::LIGHT | EShaderFeature::FOG | EShaderFeature::SHADOW;
}
if (geometries.find(radius) == geometries.end())
{
CGeometry *g = new CSphereGeometry(radius);
g->materials.AddToTail(material);
geometries[radius] = g;
}
CMesh *sphere = new CMesh( geometries[radius] );
sphere->SetPosition(pos);
NewtonBody *body = CPhysics::CreateSphere(pWorld, sphere, radius, mass);
pScene->Add(sphere);
NewtonBodySetForceAndTorqueCallback(body, BoxGravityCallback);
return body;
}
iPhysicsBody* iPhysics::createBody(iPhysicsCollision* collisionVolume)
{
con_assert(collisionVolume != nullptr, "zero pointer");
con_assert(collisionVolume->_collision != nullptr, "zero pointer");
iaMatrixf matrix;
NewtonWaitForUpdateToFinish(static_cast<const NewtonWorld*>(_defaultWorld));
NewtonBody* newtonBody = NewtonCreateDynamicBody(static_cast<const NewtonWorld*>(_defaultWorld), static_cast<const NewtonCollision*>(collisionVolume->_collision), matrix.getData());
// set callbacks
NewtonBodySetDestructorCallback(newtonBody, reinterpret_cast<NewtonBodyDestructor>(PhysicsNodeDestructor));
NewtonBodySetTransformCallback(newtonBody, reinterpret_cast<NewtonSetTransform>(PhysicsNodeSetTransform));
NewtonBodySetForceAndTorqueCallback(newtonBody, reinterpret_cast<NewtonApplyForceAndTorque>(PhysicsApplyForceAndTorque));
NewtonBodySetMassMatrix(newtonBody, 0, 0, 0, 0);
NewtonBodySetMatrix(newtonBody, matrix.getData());
start();
iPhysicsBody* result = new iPhysicsBody(newtonBody);
_bodyListMutex.lock();
_bodys[result->getID()] = result;
_bodyListMutex.unlock();
return result;
}
Car::~Car()
{
NewtonBodySetForceAndTorqueCallback(this->getCarBody(), 0);
NewtonBodySetTransformCallback(this->getCarBody(), 0);
NewtonBodySetUserData(this->getCarBody(), 0);
NewtonDestroyBody(this->controller->getWorld(), this->getCarBody());
this->carNode->remove();
}
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);
}
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);
}
// custom user force callback
void Body::setCustomForceAndTorqueCallback( ForceCallback callback )
{
if (!m_forcecallback)
{
m_forcecallback = callback;
NewtonBodySetForceAndTorqueCallback( m_body, newtonForceTorqueCallback );
}
else
{
if (m_forcecallback != callback)
m_forcecallback = callback;
}
}
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);
}
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 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);
}
void Newtonnode::initConvexHull(NewtonWorld *pWorld,const ion::video::Mesh& srcmesh,const float mass,
const float Ixx,const float Iyy,const float Izz)
{
if (pWorld==0) {
ion::base::log("Newtonnode::initConvexHull()",ion::base::Error) << "No NewtonWorld pointer given\n";
return;
}
if (!srcmesh.isValid()) {
ion::base::log("Newtonnode::initConvexHull()",ion::base::Error) << "Source mesh is invalid\n";
return;
}
if (!srcmesh.vertexstream().isMapped()) {
ion::base::log("Newtonnode::initConvexHull()",ion::base::Error) << "source mesh \"" << srcmesh.objIdentifier() << " is not mapped!\n";
return;
}
if ((m_pNewtonCollision!=0) && (m_pNewtonworld!=0))
NewtonReleaseCollision(m_pNewtonworld,m_pNewtonCollision);
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();
}
}
m_pNewtonworld=pWorld;
m_pNewtonCollision=NewtonCreateConvexHull(m_pNewtonworld,srcmesh.vertexstream().capacity(),pPoints,12,0);
m_pBody=NewtonCreateBody(m_pNewtonworld,m_pNewtonCollision);
NewtonBodySetUserData(m_pBody,this);
NewtonBodySetMassMatrix(m_pBody,mass,Ixx,Iyy,Izz);
NewtonReleaseCollision(m_pNewtonworld,m_pNewtonCollision);
NewtonBodySetTransformCallback (m_pBody, physicsSetTransform);
NewtonBodySetForceAndTorqueCallback (m_pBody, physicsApplyForceAndTorque);
delete [] pPoints;
}
/*
=============
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);
}
// TODO (#1#): use a "physicComponent" instead
void PhysicMap::addEntity(int id, const std::string& type)
{
PhysicEntityLoader loader(m_world);
std::string path("../media/" + type + ".def");
NewtonBody* body = loader.parseEntity(id, path, m_playerID);
if (body)
{
// TODO (Benjamin#1#): used as debug for uninitialised entity
Matrix_f matrix;
matrix.setPosition(Triplet_f(-5, -5, -5));
NewtonBodySetMatrix(body, matrix.raw());
NewtonBodySetForceAndTorqueCallback(body, playerForceAndTorque);
m_bodyMap.insert(BodyMap::value_type(id, body));
}
}
void DemoEntityManager::LoadScene (const char* const fileName)
{
dScene database (GetNewton());
database.Deserialize(fileName);
// this will apply all global the scale to the mesh
database.FreezeScale();
// this will apply all local scale and transform to the mesh
//database.FreezePivot();
// Load the Visual Scene
EntityDictionary entDictionary;
LoadVisualScene(&database, entDictionary);
//Load the physics world
dList<NewtonBody*> bodyList;
database.SceneToNewtonWorld(m_world, bodyList);
// bind every rigidBody loaded to the scene entity
for (dList<NewtonBody*>::dListNode* bodyNode = bodyList.GetFirst(); bodyNode; bodyNode = bodyNode->GetNext()) {
// find the user data and set to the visual entity in the scene
NewtonBody* const body = bodyNode->GetInfo();
dScene::dTreeNode* const sceneNode = (dScene::dTreeNode*)NewtonBodyGetUserData(body);
DemoEntity* const entity = entDictionary.Find(sceneNode)->GetInfo();
NewtonBodySetUserData(body, entity);
// see if this body have some special setups
dScene::dTreeNode* const node = database.FindChildByType(sceneNode, dRigidbodyNodeInfo::GetRttiType());
dAssert (node);
dRigidbodyNodeInfo* const bodyData = (dRigidbodyNodeInfo*) database.GetInfoFromNode(node);
dVariable* bodyType = bodyData->FindVariable("rigidBodyType");
// set the default call backs
if (!bodyType || !strcmp (bodyType->GetString(), "default gravity")) {
NewtonBodySetTransformCallback(body, DemoEntity::TransformCallback);
NewtonBodySetForceAndTorqueCallback(body, PhysicsApplyGravityForce);
NewtonBodySetDestructorCallback (body, PhysicsBodyDestructor);
}
}
// clean up all caches the engine have saved
NewtonInvalidateCache (m_world);
}
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 DemoEntityManager::BodyDeserialization (NewtonBody* const body, void* const bodyUserData, NewtonDeserializeCallback deserializecallback, void* const serializeHandle)
{
int size;
char bodyIndentification[256];
deserializecallback (serializeHandle, &size, sizeof (size));
deserializecallback (serializeHandle, bodyIndentification, size);
// get the world and the scene form the world user data
NewtonWorld* const world = NewtonBodyGetWorld(body);
DemoEntityManager* const scene = (DemoEntityManager*)NewtonWorldGetUserData(world);
// here we attach a visual object to the entity,
dMatrix matrix;
NewtonBodyGetMatrix(body, &matrix[0][0]);
DemoEntity* const entity = new DemoEntity(matrix, NULL);
scene->Append (entity);
NewtonBodySetUserData (body, entity);
NewtonBodySetTransformCallback(body, DemoEntity::TransformCallback);
NewtonBodySetForceAndTorqueCallback(body, PhysicsApplyGravityForce);
NewtonCollision* const collision = NewtonBodyGetCollision(body);
#ifdef USE_STATIC_MESHES_DEBUG_COLLISION
if (NewtonCollisionGetType(collision) == SERIALIZE_ID_TREE) {
NewtonStaticCollisionSetDebugCallback (collision, ShowMeshCollidingFaces);
}
#endif
//for visual mesh we will collision mesh and convert it to a visual mesh using NewtonMesh
dTree <DemoMeshInterface*, const void*>* const cache = (dTree <DemoMeshInterface*, const void*>*)bodyUserData;
dTree <DemoMeshInterface*, const void*>::dTreeNode* node = cache->Find(NewtonCollisionDataPointer (collision));
if (!node) {
DemoMeshInterface* mesh = new DemoMesh(bodyIndentification, collision, NULL, NULL, NULL);
node = cache->Insert(mesh, NewtonCollisionDataPointer (collision));
} else {
node->GetInfo()->AddRef();
}
DemoMeshInterface* const mesh = node->GetInfo();
entity->SetMesh(mesh, dGetIdentityMatrix());
mesh->Release();
}
// create physics scene
void PrimitiveCollision (DemoEntityManager* const scene)
{
// load the skybox
scene->CreateSkyBox();
// customize the scene after loading
// set a user friction variable in the body for variable friction demos
// later this will be done using LUA script
NewtonWorld* const world = scene->GetNewton();
dMatrix offsetMatrix (dGetIdentityMatrix());
int materialID = NewtonMaterialGetDefaultGroupID (world);
// disable collision
NewtonMaterialSetDefaultCollidable (world, materialID, materialID, 0);
AddSinglePrimitive (scene, -10.0f, _SPHERE_PRIMITIVE, materialID);
AddSinglePrimitive (scene, -8.0f, _BOX_PRIMITIVE, materialID);
AddSinglePrimitive (scene, -6.0f, _CAPSULE_PRIMITIVE, materialID);
AddSinglePrimitive (scene, -4.0f, _CYLINDER_PRIMITIVE, materialID);
AddSinglePrimitive (scene, -2.0f, _CONE_PRIMITIVE, materialID);
AddSinglePrimitive (scene, 4.0f, _CHAMFER_CYLINDER_PRIMITIVE, materialID);
AddSinglePrimitive (scene, 6.0f, _RANDOM_CONVEX_HULL_PRIMITIVE, materialID);
AddSinglePrimitive (scene, 8.0f, _REGULAR_CONVEX_HULL_PRIMITIVE, materialID);
// here we will change the standard gravity force callback and apply null and add a
for (NewtonBody* body = NewtonWorldGetFirstBody(world); body; body = NewtonWorldGetNextBody(world, body)) {
DemoEntity* const entity = (DemoEntity*) NewtonBodyGetUserData(body);
entity->SetUserData (new ShowCollisionCollide(body));
NewtonBodySetForceAndTorqueCallback(body, PhysicsSpinBody);
NewtonBodySetAutoSleep (body, 0);
}
// place camera into position
//dMatrix camMatrix (dYawMatrix(90.0f * dDegreeToRad));
dMatrix camMatrix (dGetIdentityMatrix());
dQuaternion rot (camMatrix);
dVector origin (-15.0f, 0.0f, 0.0f, 0.0f);
scene->SetCameraMatrix(rot, origin);
}
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());
}
// 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);
}
void Newtonnode::initCube(NewtonWorld *pWorld,const float xlength,const float ylength,const float zlength)
{
if (pWorld==0) {
ion::base::log("Newtonnode::initCube()",ion::base::Error) << "No NewtonWorld pointer given\n";
return;
}
if ((m_pNewtonCollision!=0) && (m_pNewtonworld!=0))
NewtonReleaseCollision(m_pNewtonworld,m_pNewtonCollision);
m_pNewtonworld=pWorld;
m_pNewtonCollision=NewtonCreateBox(m_pNewtonworld,xlength,ylength,zlength,0);
m_pBody=NewtonCreateBody(m_pNewtonworld,m_pNewtonCollision);
NewtonBodySetUserData(m_pBody,this);
NewtonBodySetMassMatrix(m_pBody, 1.0f, 1.0f, 1.0f, 1.0f);
NewtonReleaseCollision(m_pNewtonworld,m_pNewtonCollision);
NewtonBodySetTransformCallback (m_pBody, physicsSetTransform);
NewtonBodySetForceAndTorqueCallback (m_pBody, physicsApplyForceAndTorque);
}
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* AddBox(CScene *pScene, NewtonWorld *pWorld, Vector3 pos, Vector3 size, Vector3 rot, float mass)
{
static map<string, CGeometry*> geometries;
static CMaterial *material = NULL;
if (!material)
{
material = new CMaterial();
//material->features = EShaderFeature::LIGHT | EShaderFeature::FOG;// | EShaderFeature::SHADOW;
//material->transparent = true;
}
string name = str("%f_%f_%f", size.x, size.y, size.z);
if (geometries.find(name) == geometries.end())
{
CGeometry *g = new CCubeGeometry(size.x, size.y, size.z);
g->materials.AddToTail(material);
geometries[name] = g;
}
CMesh *box = new CMesh( geometries[name] );
box->SetPosition(pos);
box->SetRotation(rot);
//box->matrixModel.SetEulerAngles(box->rotation);
NewtonBody *body = CPhysics::CreateBox(pWorld, box, size.x, size.y, size.z, mass);
box->color = SRGB(clamp(pos.x*255.0f/32.0f,0,255)*0.9f, clamp(pos.y*255.0f/32.0f,0,255)*0.9f, clamp(pos.z*255.0f/32.0f,0,255)*0.9f);
//NewtonBodySetMaterialGroupID(body, gLevelBlocksMaterialID); // ENABLED COLLISION
pScene->Add(box);
NewtonBodySetForceAndTorqueCallback(body, BoxGravityCallback);
NewtonBodySetAutoSleep(body, 1); // make boxes go to sleep automatically (default)
return body;
}
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);
}