//-----------------------------------------------------------------------
int cPhysicsMaterialNewton::BeginContactCallback(const NewtonMaterial* material,
const NewtonBody* apBody1, const NewtonBody* apBody2,
int alThreadIndex)
{
iPhysicsBody* pContactBody1 = (cPhysicsBodyNewton*) NewtonBodyGetUserData(apBody1);
iPhysicsBody* pContactBody2 = (cPhysicsBodyNewton*) NewtonBodyGetUserData(apBody2);
if(pContactBody1->GetCollide()==false) return 0;
if(pContactBody2->GetCollide()==false) return 0;
if(pContactBody1->IsActive()==false) return 0;
if(pContactBody2->IsActive()==false) return 0;
if(pContactBody1->IsRagDoll() && pContactBody2->GetCollideRagDoll()==false) return 0;
if(pContactBody2->IsRagDoll() && pContactBody1->GetCollideRagDoll()==false) return 0;
if(pContactBody1->IsCharacter() && pContactBody2->GetCollideCharacter()==false) return 0;
if(pContactBody2->IsCharacter() && pContactBody1->GetCollideCharacter()==false) return 0;
//Log("----- Begin contact between body '%s' and '%s'.\n",mpContactBody1->GetName().c_str(),
// mpContactBody2->GetName().c_str());
if(pContactBody1->OnBeginCollision(pContactBody2) == false) return 0;
if(pContactBody2->OnBeginCollision(pContactBody1) == false) return 0;
return 1;
}
void GenericContactProcessCompatible(const void* const newtonContactJoint, float64 timestep, int threadIndex)
{
con_assert(newtonContactJoint != nullptr, "zero pointer")
NewtonBody* body0 = NewtonJointGetBody0(static_cast<const NewtonJoint*>(newtonContactJoint));
NewtonBody* body1 = NewtonJointGetBody1(static_cast<const NewtonJoint*>(newtonContactJoint));
con_assert(body0 != nullptr && body1 != nullptr, "zero pointers")
if (body0 != nullptr && body1 != nullptr)
{
iPhysicsBody* physicsBody0 = static_cast<iPhysicsBody*>(NewtonBodyGetUserData(static_cast<const NewtonBody*>(body0)));
iPhysicsBody* physicsBody1 = static_cast<iPhysicsBody*>(NewtonBodyGetUserData(static_cast<const NewtonBody*>(body1)));
con_assert(physicsBody0 != nullptr && physicsBody1 != nullptr, "zero pointers");
void* contact = NewtonContactJointGetFirstContact(static_cast<const NewtonJoint*>(newtonContactJoint));
NewtonMaterial* materialCombo = NewtonContactGetMaterial(contact);
iPhysicsMaterialCombo* physicsMaterialCombo = static_cast<iPhysicsMaterialCombo*>(NewtonMaterialGetMaterialPairUserData(materialCombo));
if (physicsMaterialCombo != nullptr && physicsBody0 != nullptr && physicsBody1 != nullptr)
{
physicsMaterialCombo->contact(physicsBody0, physicsBody1);
}
}
}
int dNewton::OnBodiesAABBOverlap (const NewtonMaterial* const material, const NewtonBody* const body0, const NewtonBody* const body1, int threadIndex)
{
dAssert (NewtonBodyGetWorld (body0) == NewtonBodyGetWorld (body1));
dNewton* const world = (dNewton*) NewtonWorldGetUserData(NewtonBodyGetWorld (body0));
dNewtonBody* const dBody0 = (dNewtonBody*) NewtonBodyGetUserData (body0);
dNewtonBody* const dBody1 = (dNewtonBody*) NewtonBodyGetUserData (body1);
return world->OnBodiesAABBOverlap(dBody0, dBody1, threadIndex);
}
int _CDECL MaterialPair::collisionCallback_onAABBOverlap( const NewtonMaterial* material, const NewtonBody* newtonBody0, const NewtonBody* newtonBody1, int threadIndex )
{
MaterialPair* me;
me = (MaterialPair*)NewtonMaterialGetMaterialPairUserData( material );
Body* body0 = (OgreNewt::Body*)NewtonBodyGetUserData( newtonBody0 );
Body* body1 = (OgreNewt::Body*)NewtonBodyGetUserData( newtonBody1 );
return me->m_contactcallback->onAABBOverlap( body0, body1, threadIndex );
}
int PhysWorld3D::OnAABBOverlap(const NewtonMaterial* const material, const NewtonBody* const body0, const NewtonBody* const body1, int threadIndex)
{
RigidBody3D* bodyA = static_cast<RigidBody3D*>(NewtonBodyGetUserData(body0));
RigidBody3D* bodyB = static_cast<RigidBody3D*>(NewtonBodyGetUserData(body1));
assert(bodyA && bodyB);
Callback* callbackData = static_cast<Callback*>(NewtonMaterialGetMaterialPairUserData(material));
assert(callbackData);
assert(callbackData->aabbOverlapCallback);
return callbackData->aabbOverlapCallback(*bodyA, *bodyB);
}
int _CDECL ContactCallback::contactBegin( const NewtonMaterial* material, const NewtonBody* body0, const NewtonBody* body1 )
{
ContactCallback* me;
me = (ContactCallback*)NewtonMaterialGetMaterialPairUserData( material );
me->m_material = (NewtonMaterial*)material;
//save the bodies...
me->m_body0 = (OgreNewt::Body*)NewtonBodyGetUserData( body0 );
me->m_body1 = (OgreNewt::Body*)NewtonBodyGetUserData( body1 );
return me->userBegin();
}
void PostUpdate(dFloat timestep, int threadIndex)
{
int count = 1;
void* nodes[32];
dMatrix parentMatrix[32];
nodes[0] = NewtonInverseDynamicsGetRoot(m_kinematicSolver);
parentMatrix[0] = dGetIdentityMatrix();
NewtonWorld* const world = GetManager()->GetWorld();
DemoEntityManager* const scene = (DemoEntityManager*)NewtonWorldGetUserData(world);
while (count) {
dMatrix matrix;
count --;
void* const rootNode = nodes[count];
NewtonBody* const body = NewtonInverseDynamicsGetBody(m_kinematicSolver, rootNode);
NewtonBodyGetMatrix (body, &matrix[0][0]);
dMatrix localMatrix (matrix * parentMatrix[count]);
DemoEntity* const ent = (DemoEntity*)NewtonBodyGetUserData(body);
dQuaternion rot(localMatrix);
ent->SetMatrix(*scene, rot, localMatrix.m_posit);
matrix = matrix.Inverse();
for (void* node = NewtonInverseDynamicsGetFirstChildNode(m_kinematicSolver, rootNode); node; node = NewtonInverseDynamicsGetNextChildNode(m_kinematicSolver, node)) {
nodes[count] = node;
parentMatrix[count] = matrix;
count ++;
}
}
}
void Body::__setTransformCallback(const NewtonBody* body, const dFloat* matrix, int threadIndex)
{
//std::cout << "\ttransform " << threadIndex << " " << body << std::endl;
Body* _body = (Body*)NewtonBodyGetUserData(body);
_body->m_matrix = Mat4f(matrix);
//std::cout << "\ttransform end " << threadIndex << " " << body << std::endl;
}
virtual void EventCallback (const CustomTriggerController* const me, TriggerEventType event, NewtonBody* const visitor) const
{
// send this message to the entity
DemoEntity* const entity = (DemoEntity*) NewtonBodyGetUserData(visitor);
if (entity) {
// map the event massage
int message = -1;
switch (event)
{
case m_enterTrigger:
message = ENTER_TRIGGER;
break;
case m_exitTrigger:
message = EXIT_TRIGGER;
break;
case m_inTrigger:
message = INSIDE_TRIGGER;
break;
}
// pass the controller pointer as the user data of this massage
entity->MessageHandler(me->GetBody(), message, (void*)me);
}
}
void CProjectile::OnHit( const NewtonBody* body, vector3df vImpactVel, f32 fImpactMass )
{
dFloat mass;
dFloat Ixx;
dFloat Iyy;
dFloat Izz;
NewtonBodyGetMassMatrix( body, &mass, &Ixx, &Iyy, &Izz );
if ( mass != 0.0f )
{
CNewtonNode* newtonNode = 0;
newtonNode = ( CNewtonNode * )NewtonBodyGetUserData( body );
if ( newtonNode )
{
OnHitNewtonNode( newtonNode, vImpactVel, fImpactMass );
}
vector3df vImpulse = vImpactVel* fImpactMass* fImpactMass* fImpactMass * 0.00001f; //TEMP: 0.00
NewtonAddBodyImpulse( body, &vImpulse.X, &Pos.X );
}
else
{
OnHitLevel( vImpactVel, fImpactMass );
}
}
static void OnReconstructMainMeshCallBack (NewtonBody* const body, NewtonFracturedCompoundMeshPart* const mainMesh, const NewtonCollision* const fracturedCompoundCollision)
{
DemoEntity* const entity = (DemoEntity*)NewtonBodyGetUserData(body);
DemoMesh* const visualMesh = (DemoMesh*)entity->GetMesh();
dAssert (visualMesh->IsType(DemoMesh::GetRttiType()));
dAssert (NewtonCollisionGetType(fracturedCompoundCollision) == SERIALIZE_ID_FRACTURED_COMPOUND);
DemoEntityManager* const scene = (DemoEntityManager*)NewtonWorldGetUserData(NewtonBodyGetWorld(body));
dAssert (scene);
visualMesh->RemoveAll();
for (void* segment = NewtonFracturedCompoundMeshPartGetFirstSegment(mainMesh); segment; segment = NewtonFracturedCompoundMeshPartGetNextSegment (segment)) {
DemoSubMesh* const subMesh = visualMesh->AddSubMesh();
int material = NewtonFracturedCompoundMeshPartGetMaterial (segment);
int indexCount = NewtonFracturedCompoundMeshPartGetIndexCount (segment);
subMesh->m_textureHandle = AddTextureRef ((GLuint)material);
subMesh->m_shader = scene->GetShaderCache().m_diffuseEffect;
subMesh->AllocIndexData (indexCount);
subMesh->m_indexCount = NewtonFracturedCompoundMeshPartGetIndexStream (fracturedCompoundCollision, mainMesh, segment, (int*)subMesh->m_indexes);
}
visualMesh->OptimizeForRender();
}
unsigned _CDECL Raycast::newtonRaycastPreFilter(const NewtonBody *body, const NewtonCollision *collision, void* userData)
{
// get our object!
Raycast* me = (Raycast*)userData;
Body* bod = (Body*)NewtonBodyGetUserData( body );
const World* world = bod->getWorld();
me->m_treecollisioncallback_bodyalreadyadded = false;
me->m_treecollisioncallback_lastbody = bod;
if (me->userPreFilterCallback( bod ))
return 1;
else
{
if( world->getDebugger().isRaycastRecording() && world->getDebugger().isRaycastRecordingHitBodies() )
{
world->getDebugger().addDiscardedBody(bod);
}
return 0;
}
}
float _CDECL Raycast::newtonRaycastFilter(const NewtonBody* body, const float* hitNormal, int collisionID, void* userData, float intersectParam)
{
// get our object!
Raycast* me = (Raycast*)userData;
Body* bod = (Body*)NewtonBodyGetUserData( body );
const World* world = bod->getWorld();
Ogre::Vector3 normal = Ogre::Vector3( hitNormal[0], hitNormal[1], hitNormal[2] );
if( me->m_treecollisioncallback_bodyalreadyadded )
return intersectParam;
if( world->getDebugger().isRaycastRecording() && world->getDebugger().isRaycastRecordingHitBodies() )
{
world->getDebugger().addHitBody(bod);
}
if (me->userCallback( bod, intersectParam, normal, collisionID ))
return intersectParam;
else
return 1.1;
}
void dNewtonTriggerManager::EventCallback (const dCustomTriggerController* const trigger, dTriggerEventType event, NewtonBody* const guess) const
{
dNewtonTrigger* const callback = (dNewtonTrigger*) trigger->GetUserData();
dNewtonBody* const guessBody = (dNewtonBody*) NewtonBodyGetUserData(guess);
switch (event)
{
case m_enterTrigger:
{
callback->OnEnter(guessBody);
break;
}
case m_exitTrigger:
{
callback->OnExit(guessBody);
break;
}
case m_inTrigger:
{
callback->OnInside(guessBody);
break;
}
}
}
static void MagneticField (const NewtonJoint* contactJoint, dFloat timestep, int threadIndex)
{
dFloat magnetStregnth;
const NewtonBody* body0;
const NewtonBody* body1;
const NewtonBody* magneticField;
const NewtonBody* magneticPiece;
body0 = NewtonJointGetBody0 (contactJoint);
body1 = NewtonJointGetBody1 (contactJoint);
// get the magnetic field body
magneticPiece = body0;
magneticField = body1;
if (NewtonCollisionIsTriggerVolume (NewtonBodyGetCollision(body0))) {
magneticPiece = body1;
magneticField = body0;
}
_ASSERTE (NewtonCollisionIsTriggerVolume (NewtonBodyGetCollision(magneticField)));
// calculate the magnetic force field
dMatrix center;
dMatrix location;
NewtonBodyGetMatrix (magneticField, ¢er[0][0]);
NewtonBodyGetMatrix (magneticPiece, &location[0][0]);
Magnet* magnet;
magnet = (Magnet*)NewtonBodyGetUserData(magneticField);
magnetStregnth = magnet->m_magnetStregnth;
// calculate the magnetic force;
dFloat den;
dVector force (center.m_posit - location.m_posit);
den = force % force;
den = magnetStregnth / (den * dSqrt (den) + 0.1f);
force = force.Scale (den);
// because we are modifiing one of the bodies membber in the call back, there uis a chace that
// another materail can be operations on the same object at the same time of aother thread
// therfore we need to make the assigmnet in a critical section.
NewtonWorldCriticalSectionLock (NewtonBodyGetWorld (magneticPiece));
// add the magner force
NewtonBodyAddForce (magneticPiece, &force[0]);
force = force.Scale (-1.0f);
NewtonBodyAddForce (magnet->m_magneticCore, &force[0]);
// also if the body is sleeping fore it to wake up for this frame
NewtonBodySetFreezeState (magneticPiece, 0);
NewtonBodySetFreezeState (magnet->m_magneticCore, 0);
// unlock the critical section
NewtonWorldCriticalSectionUnlock (NewtonBodyGetWorld (magneticPiece));
}
unsigned _convexCastBodyFilter(const NewtonBody* body, const NewtonCollision* collision, void* userData)
{
tPlayerController * ctrl = (tPlayerController *)userData;
tBody * tbody = (tBody *)NewtonBodyGetUserData(body);
return 1;
}
void _cdecl Body::newtonForceTorqueCallback( const NewtonBody* body )
{
OgreNewt::Body* me = (OgreNewt::Body*)NewtonBodyGetUserData( body );
if (me->m_forcecallback)
(*me->m_forcecallback)( me );
}
void RigidBodyWorld::UpdatePhysics ()
{
RigidBodyWorldDesc* const desc = (RigidBodyWorldDesc*) RigidBodyWorldDesc::GetDescriptor();
float timestep = 1.0f / desc->m_minFps;
if (timestep > 1.0f / 60.0f) {
timestep = 1.0f / 60.0f;
}
desc->m_updateRigidBodyMatrix = false;
NewtonUpdate(desc->m_newton, timestep);
TimeValue t (GetCOREInterface()->GetTime());
float scale = 1.0f / float (GetMasterScale(UNITS_METERS));
for (NewtonBody* body = NewtonWorldGetFirstBody(desc->m_newton); body; body = NewtonWorldGetNextBody(desc->m_newton, body)) {
dMatrix matrix;
INode* const node = (INode*)NewtonBodyGetUserData(body);
NewtonBodyGetMatrix(body, &matrix[0][0]);
matrix = desc->m_systemMatrix * matrix * desc->m_systemMatrixInv;
matrix.m_posit = matrix.m_posit.Scale (scale);
Matrix3 maxMatrix (GetMatrixFromdMatrix (matrix));
node->SetNodeTM(t, maxMatrix);
}
UpdateViewPorts ();
desc->m_updateRigidBodyMatrix = true;
}
unsigned dNewtonRayCast::PrefilterCallback(const NewtonBody* const body, const NewtonCollision* const collision, void* const userData)
{
dNewtonRayCast* const me = (dNewtonRayCast*) userData;
const dNewtonBody* const myBody = (dNewtonBody*) NewtonBodyGetUserData(body);
const dNewtonCollision* const myCollision = (dNewtonCollision*) NewtonCollisionGetUserData(collision);
return me->OnPrefilter (myBody, myCollision);
}
dFloat dNewtonRayCast::RayFilterCallback(const NewtonBody* const body, const NewtonCollision* const shapeHit, const dFloat* const hitContact, const dFloat* const hitNormal, dLong collisionID, void* const userData, dFloat intersectParam)
{
dNewtonRayCast* const me = (dNewtonRayCast*) userData;
const dNewtonBody* const myBody = (dNewtonBody*) NewtonBodyGetUserData(body);
const dNewtonCollision* const myCollision = (dNewtonCollision*) NewtonCollisionGetUserData(shapeHit);
return me->OnRayHit (myBody, myCollision, hitContact, hitNormal, collisionID, intersectParam);
}
// Transform callback to set the matrix of a the visual entity
void SetTransformCallback (const NewtonBody* body, const float* matrix, int threadIndex)
{
NewtonEntity* ent;
// Get the position from the matrix
glm::vec4 position (matrix[12], matrix[13], matrix[14], 1.0f);
glm::quat rotation;
// we will ignore the Rotation part of matrix and use the quaternion rotation stored in the body
NewtonBodyGetRotation(body, &rotation[0]);
// get the entity associated with this rigid body
ent = (NewtonEntity*) NewtonBodyGetUserData(body);
// since this tutorial run the physics and a different fps than the Graphics
// we need to save the entity current transformation state before updating the new state.
ent->prevPosition = ent->curPosition;
ent->prevRotation = ent->curRotation;
if (glm::dot(ent->curRotation,rotation) < 0.0f) {
ent->prevRotation *= -1.0f;
}
// set the new position and orientation for this entity
ent->curPosition = position;
ent->curRotation = rotation;
}
dNewtonTriggerManager::dNewtonTrigger* dNewtonTriggerManager::GetFirstTrigger() const
{
dListNode* const node = GetFirst();
if (node) {
return (dNewtonTriggerManager::dNewtonTrigger*) NewtonBodyGetUserData (node->GetInfo().GetBody());
}
return NULL;
}
// set the transformation of a rigid body
void PhysicsNodeSetTransform(const void* body, const float* matrix, int threadIndex)
{
iPhysicsBody* physicsBody = static_cast<iPhysicsBody*>(NewtonBodyGetUserData(static_cast<const NewtonBody*>(body)));
if (nullptr != physicsBody)
{
physicsBody->setTransformNodeMatrix(matrix);
}
}
void PhysicsApplyForceAndTorque(const void* body, float64 timestep, int threadIndex)
{
iPhysicsBody* physicsBody = static_cast<iPhysicsBody*>(NewtonBodyGetUserData(static_cast<const NewtonBody*>(body)));
if (nullptr != physicsBody)
{
physicsBody->applyForceAndTorque(timestep, threadIndex);
}
}
// use this to display debug information about vehicle
void Debug () const
{
for (dListNode* ptr = GetFirst(); ptr; ptr = ptr->GetNext()) {
CustomVehicleController* const controller = &ptr->GetInfo();
BasicCarEntity* const vehicleEntity = (BasicCarEntity*)NewtonBodyGetUserData (controller->GetBody());
vehicleEntity->Debug();
}
}
Body* World::getFirstBody() const
{
NewtonBody* body = NewtonWorldGetFirstBody( m_world );
if( body )
return (Body*) NewtonBodyGetUserData(body);
return NULL;
}
static void AddUniversal(DemoEntityManager* const scene, const dVector& origin)
{
dVector size(1.0f, 1.0f, 1.0f);
NewtonBody* const box0 = CreateBox(scene, origin + dVector(0.0f, 4.0f, 0.0f, 0.0f), dVector(0.25f, 0.25f, 4.0f, 0.0f));
NewtonBody* const box1 = CreateWheel(scene, origin + dVector(0.0f, 4.0f, 2.0f, 0.0f), 1.0f, 0.5f);
NewtonBody* const box2 = CreateWheel(scene, origin + dVector(0.0f, 4.0f, -2.0f, 0.0f), 1.0f, 0.5f);
NewtonBodySetMassMatrix(box0, 0.0f, 0.0f, 0.0f, 0.0f);
// align the object so that is looks nice
dMatrix matrix;
NewtonBodyGetMatrix(box1, &matrix[0][0]);
matrix = dYawMatrix (3.1416f * 0.5f) * matrix;
NewtonBodySetMatrix(box1, &matrix[0][0]);
((DemoEntity*) NewtonBodyGetUserData(box1))->ResetMatrix (*scene, matrix);
NewtonBodyGetMatrix(box2, &matrix[0][0]);
matrix = dYawMatrix(3.1416f * 0.5f) * matrix;
NewtonBodySetMatrix(box2, &matrix[0][0]);
((DemoEntity*) NewtonBodyGetUserData(box2))->ResetMatrix (*scene, matrix);
// link the two boxes
NewtonBodyGetMatrix(box1, &matrix[0][0]);
CustomUniversal* const joint1 = new CustomUniversal(matrix, box1, box0);
joint1->EnableLimit_0(true);
joint1->SetLimis_0 (-5.0f * 3.141592f, 2.0f * 3.141592f);
joint1->EnableLimit_1(true);
joint1->SetLimis_1 (-3.0f * 3.141592f, 4.0f * 3.141592f);
// link the two boxes
NewtonBodyGetMatrix(box2, &matrix[0][0]);
CustomUniversal* const joint2 = new CustomUniversal(matrix, box2, box0);
joint2->EnableLimit_0(true);
joint2->SetLimis_0 (-3.0f * 3.141592f, 5.0f * 3.141592f);
joint2->EnableLimit_1(true);
joint2->SetLimis_1(-4.0f * 3.141592f, 2.0f * 3.141592f);
#ifdef _USE_HARD_JOINTS
NewtonSkeletonContainer* const skeleton = NewtonSkeletonContainerCreate(scene->GetNewton(), box0, NULL);
NewtonSkeletonContainerAttachBone(skeleton, box1, box0);
NewtonSkeletonContainerAttachBone(skeleton, box2, box0);
NewtonSkeletonContainerFinalize(skeleton);
#endif
}
//-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~-~
// set the transformation of a rigid body
void
PhysicsActor::TransformCallback(const NewtonBody* _body, const Zen::Math::Real* _matrix)
{
void* pBody = NewtonBodyGetUserData(_body);
if (pBody != NULL)
{
PhysicsActor* pShape = static_cast<PhysicsActor*>(pBody);
// Only use the transform callback if the state is active
if (pShape->m_activationState != 0)
{
Math::Matrix4 transform;
for(int x = 0; x < 16; x++)
{
transform.m_array[x] = _matrix[x];
}
TransformEventData evenData(*pShape, transform);
pShape->onTransformEvent(evenData);
}
}
#if 0
// HACK Keep the object to a constant velocity
Math::Vector3 velocity;
NewtonBodyGetVelocity(_body, velocity.m_array);
velocity.normalize();
velocity = velocity * 50;
NewtonBodySetVelocity(_body, velocity.m_array);
#endif
//std::cout << "TransformCallback()" << std::endl;
#if 0
RenderPrimitive* primitive;
// get the graphic object form the rigid body
primitive = (RenderPrimitive*) NewtonBodyGetUserData (body);
// set the transformation matrix for this rigid body
dMatrix& mat = *((dMatrix*)matrix);
primitive->SetMatrix (mat);
#endif
}
dNewtonArticulationManager::dNewtonArticulationController* dNewtonArticulationManager::GetFirstController() const
{
dAssert (0);
dListNode* const node = GetFirst();
if (node) {
return (dNewtonArticulationManager::dNewtonArticulationController*) NewtonBodyGetUserData (node->GetInfo().GetBody());
}
return NULL;
}
void BodyIterator (const NewtonBody* body, void* userData)
{
//Undvik att hantera kollision med sig själv
if(NewtonBodyGetUserData(body)!=userData)
{
PlayerEntity* player = (PlayerEntity*)userData;
player->UpdateCollision((NewtonBody*)body);
}
}
