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