SO3MaterialPair.cpp

Go to the documentation of this file.

 
#include "SO3PhysicGraph/SO3MaterialPair.h"
#include "SO3PhysicGraph/SO3MaterialID.h"
#include "SO3PhysicGraph/SO3Body.h"
#include "SO3SceneGraph/SO3NodeScol.h"
#include "SO3SceneGraph/SO3Scene.h"
 
extern mmachine mm;
 
namespace SO3
{
 
SMaterialPair::SMaterialPair(SScene* scene, SMaterialID* mat1, SMaterialID* mat2)
{
        O3MaterialPair = new OgreNewt::MaterialPair(scene->GetPhysicsWorld()->GetPhysicWorld(), mat1->getOgreNewtMaterialID(), mat2->getOgreNewtMaterialID());
        mScene = scene;
        mMat1 = mat1;
  mMat2 = mat2;
  contactCallbackActivated = false;
  overlapStartedCallbackActivated = false;
  overlapEndedCallbackActivated = false;
 
  //needed due to a bug in newton, this make the physcis lag without it
  O3MaterialPair->setDefaultSurfaceThickness(0.001);
  O3MaterialPair->setDefaultElasticity(0.4f);
  O3MaterialPair->setDefaultSoftness(0.1f);
  O3MaterialPair->setDefaultFriction(0.9f, 0.5f);
  O3MaterialPair->setDefaultCollidable(1);
 
        O3MaterialPair->setContactCallback(this);
}
 
SMaterialPair::~SMaterialPair()
{
        delete O3MaterialPair;
}
 
int SMaterialPair::getID1() 
{
        return mMat1->getID();
}
 
int SMaterialPair::getID2() 
{
  return mMat2->getID();
}
 
bool SMaterialPair::GetContactCallbackActivated()
{
  return contactCallbackActivated;
}
 
void SMaterialPair::SetContactCallbackActivated(const bool& state)
{
  contactCallbackActivated = state;
}
 
bool SMaterialPair::GetOverlapStartedCallbackActivated()
{
  return overlapStartedCallbackActivated;
}
 
void SMaterialPair::SetOverlapStartedCallbackActivated(const bool& state)
{
  overlapStartedCallbackActivated = state;
}
 
bool SMaterialPair::GetOverlapEndedCallbackActivated()
{
  return overlapEndedCallbackActivated;
}
 
void SMaterialPair::SetOverlapEndedCallbackActivated(const bool& state)
{
  overlapEndedCallbackActivated = state;
}
 
void SMaterialPair::SetDefaultSurfaceThickness(const Ogre::Real& value)
{
  O3MaterialPair->setDefaultSurfaceThickness(value);
}
 
void SMaterialPair::SetDefaultElasticity(const Ogre::Real& value)
{
  O3MaterialPair->setDefaultElasticity(value);
}
 
void SMaterialPair::SetDefaultFriction(const Ogre::Real& stat, const Ogre::Real& kin)
{
  //Use a minimum value instead of 0 to prevent a bug that make not possible to set greater values after setting to 0
  O3MaterialPair->setDefaultFriction(stat == 0.0f ? 0.01f : stat, kin == 0.0f ? 0.01f : kin);
}
 
void SMaterialPair::SetDefaultSoftness(const Ogre::Real& value)
{
  O3MaterialPair->setDefaultSoftness(value);
}
 
void SMaterialPair::SetDefaultCollidable(const bool& enable)
{
  O3MaterialPair->setDefaultCollidable(enable ? 1 : 0);
}
 
SScene* SMaterialPair::GetParentScene()
{
  return mScene;
}
 
int SMaterialPair::onAABBOverlap(OgreNewt::Body* body0, OgreNewt::Body* body1, int threadIndex)
{
  SNode* nodeScol0 = Ogre::any_cast<SNode*>(body0->getUserData()); 
        SNode* nodeScol1 = Ogre::any_cast<SNode*>(body1->getUserData()); 
  
        if((nodeScol0 != NULL) && (nodeScol1 != NULL))
        {
                SBody* b0 = nodeScol0->GetSceneNodeBody();
                SBody* b1 = nodeScol1->GetSceneNodeBody();
 
    // return no collision if any of the bodies have the ignore state
    if(((b0 != NULL) && b0->GetIgnoreCollision()) || ((b1 != NULL) && b1->GetIgnoreCollision()))
      return 0;
  }
 
  // Process further contact detection.
  /*
  SBody* b0;
  SBody* b1;
  SNode* nodeScol0                = Ogre::any_cast<SNode*>(body0->getUserData()); 
  SNode* nodeScol1                = Ogre::any_cast<SNode*>(body1->getUserData()); 
  b0 = nodeScol0->nodeBody;
  b1 = nodeScol1->nodeBody;
 
  if(b0->isFluid)
  {
    b1->setBuoyancyForce(b0);
    // Construct CollResult
    SScene* mScene = nodeScol0->GetParentScene();
    MCOLL* mCollResult = (MCOLL*)malloc(sizeof (MCOLL));
    mCollResult->body0 = nodeScol0->nodeBody;
    mCollResult->body1 = nodeScol1->nodeBody;
    mCollResult->curScene = mScene;
    //SendMessage( hwndScol, SO3_MATERIALPAIR_FLUID_CONTACT, (int)b0,(LONG)mCollResult);
    free(mCollResult);
  }
  else if(b1->isFluid)
  {
    b0->setBuoyancyForce(b1);
    // Construct CollResult
    SScene* mScene = nodeScol0->GetParentScene();
    MCOLL* mCollResult = (MCOLL*)malloc(sizeof (MCOLL));
    mCollResult->body0 = nodeScol1->nodeBody;
    mCollResult->body1 = nodeScol0->nodeBody;
    mCollResult->curScene = mScene;
    //SendMessage( hwndScol, SO3_MATERIALPAIR_FLUID_CONTACT, (int)b1,(LONG)mCollResult);
    free(mCollResult);
  }
*/
  return 1;
}
 
void SMaterialPair::contactsProcess(OgreNewt::ContactJoint &contactJoint, Ogre::Real timeStep, int threadIndex)
{  
  SNode* nodeScol0 = Ogre::any_cast<SNode*>(contactJoint.getBody0()->getUserData()); 
        SNode* nodeScol1 = Ogre::any_cast<SNode*>(contactJoint.getBody1()->getUserData()); 
  
        if((nodeScol0 != NULL) && (nodeScol1 != NULL))
        {
                SBody* b0 = nodeScol0->GetSceneNodeBody();
                SBody* b1 = nodeScol1->GetSceneNodeBody();
    
    if(b0 != NULL && b1 != NULL)
    {
      SScene* mScene = nodeScol0->GetParentScene();
      SPhysicWorld* world = mScene->GetPhysicsWorld();
 
      if (world->GetBodyPairSize() < world->GetMaxBodyPair())
      {
        // Contact begin detection
        if (GetOverlapStartedCallbackActivated() && (!world->GetBodyPairExist(b0, b1)))
        {
          // Construct CollResult
          MCOLL* mCollResult = new MCOLL();
          mCollResult->matPair = this;
          mCollResult->node0 = b0->GetParentNode()->GetName();
          mCollResult->node1 = b1->GetParentNode()->GetName();
          mCollResult->curScene = mScene;
 
          SBody** bpair = (SBody**)malloc(sizeof(SBody*) * 2);
          if (bpair == 0)
            return;
 
          bpair[0] = b0;
          bpair[1] = b1;
 
          // Contact begin
          world->AddBodyPair(b0->GetParentNode()->GetName() + "|" + b1->GetParentNode()->GetName(), bpair);
          world->AddContactOverlapStart(b0->GetParentNode()->GetName() + "|" + b1->GetParentNode()->GetName(), mCollResult);
        }
 
        // For each contact point between those two bodies.
        if (GetContactCallbackActivated())
        {
          int maxcontact = 3;
          int nbcontact = 0;
 
          for (OgreNewt::Contact contact = contactJoint.getFirstContact(); contact && nbcontact < maxcontact; contact = contact.getNext())
          {
            Ogre::Vector3 pos;
            Ogre::Vector3 normal;
            contact.getPositionAndNormal(pos, normal, b0->getOgreNewtBodyPointer());
 
            MCOLL* mCollResult = new MCOLL();
            mCollResult->matPair = this;
            mCollResult->node0 = b0->GetParentNode()->GetName();
            mCollResult->node1 = b1->GetParentNode()->GetName();
            mCollResult->position = pos;
            mCollResult->normal = normal;
            mCollResult->normalspeed = contact.getNormalSpeed();
            mCollResult->force = contact.getForce();
            mCollResult->curScene = mScene;
 
            world->SetContactActivated(b0, b1, mCollResult);
            nbcontact++;
          }
        }
      }
    }
        }
}
 
}