OgreNewt_World.cpp

Go to the documentation of this file.

#include "External/ogrenewt/OgreNewt_Stdafx.h"
#include "External/ogrenewt/OgreNewt_Stdafx.h"
#include "External/ogrenewt/OgreNewt_World.h"
#include "External/ogrenewt/OgreNewt_MaterialID.h"
#include "External/ogrenewt/OgreNewt_Body.h"
#include "External/ogrenewt/OgreNewt_BodyInAABBIterator.h"
 
#pragma warning(disable:4355)
 
namespace OgreNewt
{
  WorldTriggerManager::WorldTriggerManager(World* const world): CustomTriggerManager(world->getNewtonWorld())
  {
  }
 
 
  void WorldTriggerManager::TriggerCallback::setTriggerEnterCallback(WorldTriggerEnterCallback callback)
  {
    m_EnterCallback = callback;
  }
 
  void WorldTriggerManager::TriggerCallback::setTriggerInsideCallback(WorldTriggerInsideCallback callback)
  {
    m_InsideCallback = callback;
  }
 
  void WorldTriggerManager::TriggerCallback::setTriggerExitCallback(WorldTriggerExitCallback callback)
  {
    m_ExitCallback = callback;
  }
 
 
// Constructor
World::World(Ogre::Real desiredFps, int maxUpdatesPerFrames, Ogre::String name) :
    m_bodyInAABBIterator(this)
{
        setUpdateFPS(desiredFps, maxUpdatesPerFrames);
  m_world = NewtonCreate();
  NewtonWorldSetUserData(m_world, this);
  //NewtonSelectBroadphaseAlgorithm (m_world, 0);
 
  // create the default ID.
  m_defaultMatID = new OgreNewt::MaterialID( this, NewtonMaterialGetDefaultGroupID( m_world ) );
  m_defaultAngularDamping = Ogre::Vector3(0.1f, 0.1f, 0.1f);
  m_defaultLinearDamping = 0.1f;
  m_debugger = new Debugger(this);
  m_triggerManager = new WorldTriggerManager(this);
 
        // set the default solve mode to be iterative the fastest
        setSolverModel(SM_FASTEST);
 
        // use the more advanced hardware in the system
        //Ogre::String description;
        //setPlatformArchitecture(0);
        //getPlatformArchitecture(description);
 
  //NewtonSetMultiThreadSolverOnSingleIsland(m_world, 1);
}
 
// Destructor
World::~World()
{
    if (m_debugger)
    {
        delete m_debugger;
        m_debugger = NULL;
    }
 
    if (m_defaultMatID)
    {
        delete m_defaultMatID;
        m_defaultMatID = NULL;
    }
 
    if (m_world)
    {
        NewtonDestroy( m_world );
        m_world = NULL;
    }
}
 
CustomTriggerController* World::CreateController(const dMatrix& matrix, NewtonCollision* const convexShape)
{
  if (m_triggerManager)
    return m_triggerManager->CreateController(matrix, convexShape);
 
  return 0;
}
 
void World::DestroyController(CustomTriggerController* const controller)
{
  m_triggerManager->DestroyController(controller);
}
 
void World::setPreListener(std::string name, void* const listenerUserData, NewtonWorldUpdateListenerCallback update)
{
  NewtonWorldAddPreListener(m_world, name.c_str(), listenerUserData, update, NULL);
}
 
void World::setpostListener(std::string name, void* const listenerUserData, NewtonWorldUpdateListenerCallback update)
{
  NewtonWorldAddPostListener(m_world, name.c_str(), listenerUserData, update, NULL);
}
 
void World::setUpdateFPS(Ogre::Real desiredFps, int maxUpdatesPerFrames)
{
        if (maxUpdatesPerFrames < 1) {
                maxUpdatesPerFrames = 1;
        }
 
  if (desiredFps < 120.0f)
    desiredFps = 120.0f;
  else if (desiredFps > 600.0f)
    desiredFps = 600.0f;
 
        m_maxTicksPerFrames = maxUpdatesPerFrames;
        m_updateFPS = desiredFps;
        m_timestep = 1.0f / desiredFps;
        m_invTimestep = desiredFps;
        m_timeAcumulator = 0.0f;
}
 
// Set allocators
void World::setAllocators (NewtonAllocMemory newtonAlloc, NewtonFreeMemory newtonFree)
{
        NewtonSetMemorySystem (newtonAlloc, newtonFree);
}
 
void World::setThreadCount(int threads)
{
        NewtonSetThreadsCount(m_world, threads);
}
 
// update
int World::update( Ogre::Real t_step )
{
        int realUpdates = 0;
  bool sync = true;
  float ntimeStep = t_step;
 
        // clamp the step if necessary
  ntimeStep = std::min(ntimeStep, m_timestep * m_maxTicksPerFrames);
 
        // advance the accumulator;
        m_timeAcumulator += ntimeStep;
 
  while (m_timeAcumulator >= ntimeStep)
  {
    if (sync)
      NewtonUpdate(m_world, m_timestep);
    else
      NewtonUpdateAsync(m_world, m_timestep);
 
    m_timeAcumulator -= m_timestep;
    realUpdates++;
  }
 
  /*
  if (m_timeAcumulator >= ntimeStep)
  {
    while (m_timeAcumulator >= ntimeStep)
    {
      if (sync)
        NewtonUpdate(m_world, ntimeStep);
      else
        NewtonUpdateAsync(m_world, ntimeStep);
      m_timeAcumulator -= ntimeStep;
      realUpdates++;
    }
  }
  else
  {
    if (sync)
      NewtonUpdate(m_world, t_step);
    else
      NewtonUpdateAsync(m_world, t_step);
 
    m_timeAcumulator -= ntimeStep;
  }*/
 
  //Ogre::Real param = m_timeAcumulator * m_invTimestep;
 
        for(Body* body = getFirstBody(); body; body = body->getNext())
  {
                body->updateNode(1.0f); // param : issue on vehicle wheels :/
  }
 
        return realUpdates;
}
 
Body* World::getFirstBody() const
{
    NewtonBody* body = NewtonWorldGetFirstBody( m_world );
    if( body )
        return (Body*) NewtonBodyGetUserData(body);
 
    return NULL;
}
 
void World::setSolverModel(int model)
{
  // add +3 to get the previous behavior < newton 3.13
  if (model <= 0)
    model = 0;
  //else if (model > 1)
    model = model + 3;
 
  NewtonSetSolverModel(m_world, model);
  NewtonSetFrictionModel(m_world, model);
}
 
 
// -------------------------------------------------------------------------------------------------------------
// -------------------------------------------------------------------------------------------------------------
// -------------------------------------------------------------------------------------------------------------
// -------------------------------------------------------------------------------------------------------------
 
 
}