SO3Engine/SO3PhysicGraph/SO3MaterialPair.cpp

Go to the documentation of this file.

#include "SO3MaterialPair.h"
#include "SO3MaterialID.h"
#include "SO3Body.h"
#include "..\SO3SceneGraph\SO3NodeScol.h"
#include "..\SO3SceneGraph\SO3Scene.h"

#include "../SCOLPack/SO3SCOL.h"

extern WindowHandle hwndScol;
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;

        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(bool state)
{
  contactCallbackActivated = state;
}

bool SMaterialPair::GetOverlapStartedCallbackActivated()
{
  return overlapStartedCallbackActivated;
}

void SMaterialPair::SetOverlapStartedCallbackActivated(bool state)
{
  overlapStartedCallbackActivated = state;
}

bool SMaterialPair::GetOverlapEndedCallbackActivated()
{
  return overlapEndedCallbackActivated;
}

void SMaterialPair::SetOverlapEndedCallbackActivated(bool state)
{
  overlapEndedCallbackActivated = state;
}

void SMaterialPair::SetDefaultSurfaceThickness(Ogre::Real value)
{
  O3MaterialPair->setDefaultSurfaceThickness(value);
}

void SMaterialPair::SetDefaultElasticity(Ogre::Real value)
{
  O3MaterialPair->setDefaultElasticity(value);
}

void SMaterialPair::SetDefaultFriction(Ogre::Real stat, 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(Ogre::Real value)
{
  O3MaterialPair->setDefaultSoftness(value);
}

void SMaterialPair::SetDefaultCollidable(bool enable)
{
  O3MaterialPair->setDefaultCollidable(enable ? 1 : 0);
}

void SMaterialPair::SetContinuousCollisionMode(bool enable)
{
  O3MaterialPair->setContinuousCollisionMode(enable ? 1 : 0);
}

SScene* SMaterialPair::GetParentScene()
{
  return mScene;
}

int SMaterialPair::onAABBOverlap(OgreNewt::Body* body0, OgreNewt::Body* body1, int threadIndex )
{
  // 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,(LPARAM)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,(LPARAM)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();

      // Contact begin detection
      if (GetOverlapStartedCallbackActivated())
      {
        //MMechostr(MSKDEBUG, "Material contact %s with %s", mMat1->GetName().c_str(), mMat2->GetName().c_str());
        BodyPairMap::iterator iBodyPairSearched = world->bodyPairMap.find(b0->GetParentNode()->GetName() + "|" + b1->GetParentNode()->GetName());
        if(iBodyPairSearched == world->bodyPairMap.end())
        {
          iBodyPairSearched = world->bodyPairMap.find(b1->GetParentNode()->GetName() + "|" + b0->GetParentNode()->GetName());

          if(iBodyPairSearched == world->bodyPairMap.end())
          {
            // 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->bodyPairMap.insert(BodyPairMap::value_type(b0->GetParentNode()->GetName() + "|" + b1->GetParentNode()->GetName(), bpair));
            world->physicContactOverlapStartMap.insert(PhysicContactMap::value_type(b0->GetParentNode()->GetName() + "|" + b1->GetParentNode()->GetName(), mCollResult));
          }
        }
      }

      // For each contact point between those two bodies.
      if (GetContactCallbackActivated())
      {
        for (OgreNewt::Contact contact = contactJoint.getFirstContact(); contact; contact = contact.getNext())
        {
          PhysicContactMap::iterator iBodyContactSearched = world->physicContactMap.find(b0->GetParentNode()->GetName() + "|" + b1->GetParentNode()->GetName());
          if(iBodyContactSearched == world->physicContactMap.end())
            iBodyContactSearched = world->physicContactMap.find(b1->GetParentNode()->GetName() + "|" + b0->GetParentNode()->GetName());

          Ogre::Vector3 pos;
          Ogre::Vector3 normal;
          contact.getPositionAndNormal(pos, normal);
          
          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;
          
          if (iBodyContactSearched != world->physicContactMap.end())
          {
            delete (iBodyContactSearched->second);
            iBodyContactSearched->second = mCollResult;
            //mScene->physicContactMap.insert(PhysicContactMap::value_type(iBodyContactSearched->first, mCollResult));
          }
          else
          {
            world->physicContactMap.insert(PhysicContactMap::value_type(b0->GetParentNode()->GetName() + "|" + b1->GetParentNode()->GetName(), mCollResult));
          }
        }
      }
    }
        }
}

}

---