SO3Physics.h

Go to the documentation of this file.

/*
-----------------------------------------------------------------------------
This source file is part of OpenSpace3D
For the latest info, see http://www.openspace3d.com
 
Copyright (c) 2012 I-maginer
 
This program is free software; you can redistribute it and/or modify it under
the terms of the GNU Lesser General Public License as published by the Free Software
Foundation; either version 2 of the License, or (at your option) any later
version.
 
This program is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more details.
 
You should have received a copy of the GNU Lesser General Public License along with
this program; if not, write to the Free Software Foundation, Inc., 59 Temple
Place - Suite 330, Boston, MA 02111-1307, USA, or go to
http://www.gnu.org/copyleft/lesser.txt
 
-----------------------------------------------------------------------------
*/
 
#ifndef __SO3PHYSICS_H__
#define __SO3PHYSICS_H__
 
#include <External/ogrenewt/OgreNewt.h>
#include "SCOLBasic/SO3Prerequisites.h"
#include <thread>
 
namespace SO3
{
 
  typedef struct MCOLL
  {
          const SScene* curScene;
    SMaterialPair* matPair;
    std::string node0;
          std::string node1;
    Ogre::Vector3 position;
    Ogre::Vector3 normal;
    Ogre::Vector3 force;
    Ogre::Real normalspeed;
 
    MCOLL()
    {
      curScene = 0;
      matPair = 0;
      node0 = "";
      node1 = "";
      position = Ogre::Vector3::ZERO;
      normal = Ogre::Vector3::ZERO;
      force = Ogre::Vector3::ZERO;
      normalspeed = 0.0f;
    };
  } MCOLL;
 
  typedef struct MRAYINFO
  {
    SBody* body; 
    Ogre::Real distance;
    Ogre::Vector3 normal;
 
    MRAYINFO()
    {
      body = 0;
      distance = 0.0f;
      normal = Ogre::Vector3::ZERO;
    };
  } MRAYINFO;
 
  typedef struct MIMPULSEDATA
  {
    Ogre::Real radius;
    Ogre::Real strenght;
    Ogre::Vector3 position;
    MIMPULSEDATA()
    {
      radius = 1.0f;
      strenght = 1.0f;
      position = Ogre::Vector3(0.0f, 0.0f, 0.0f);
    };
  } MIMPULSEDATA;
 
  typedef std::unordered_map<std::string, SBody**> BodyPairMap;
  typedef std::unordered_map<std::string, MCOLL*> PhysicContactMap;
  typedef std::set<SPhysicContraint*> PhysicContraintList;
  class SPhysicWorld
  {
    public :
      bool showPhysicsLine;
      SMaterialPairMap listOfPhysicsMaterialPair;
      SMaterialIDMap listOfMaterialID;
    protected :
      std::mutex mutexUpdate;
    private :
      OgreNewt::World* world;
      const SScene* mscene;
      bool worldIsEnabled;
      int worldFPS;
      OgreNewt::Debugger* worldDebugger;
      bool worldDebuggerIsInit;
      Ogre::Vector3 mGravity;
      int solverModel;
      int frictionModel;
      unsigned int maxBodyPair;
      bool mResetPhysicWorld;
      BodyPairMap bodyPairMap;
      PhysicContactMap physicContactMap;
      PhysicContactMap physicContactOverlapStartMap;
      PhysicContraintList physicContraintList;
 
    public :
      SPhysicWorld(SScene* scene);
 
      ~SPhysicWorld();
 
      OgreNewt::World* GetPhysicWorld();
 
      const SScene* GetScene();
 
      bool GetPhysicWorldEnable();
 
      void SetPhysicWorldEnable(const bool& enable);
 
      bool GetPhysicDebugEnable();
 
      void SetPhysicDebugEnable(const bool& enable);
 
      void SetPhysicFPS(const int& fps);
 
      int GetPhysicFPS();
 
      void UpdatePhysic(const float& frameTime);
 
      OgreNewt::Debugger* GetPhysicDebugger();
 
      void ResetPhysicWorld();
 
      void SetPhysicBodiesInitialState();
 
      void SetPhysicSolverModel(const int& mod);
 
      int GetPhysicSolverModel();
 
      void SetPhysicPlatformArchitecture(const int& mod);
 
      int GetPhysicPlatformArchitecture();
 
      void SetPhysicGravity(const Ogre::Vector3& gravity);
 
      Ogre::Vector3 GetPhysicGravity();
 
      bool GetResetPhysicWorld();
 
      void SetResetPhysicWorld(const bool& state);
 
      SBody* PhysicsRayCast(const Ogre::Vector3& src, const Ogre::Vector3& dir, const Ogre::Real& maxdist, Ogre::Real& hitdistance, Ogre::Vector3& hitnormal);
 
      std::vector<MRAYINFO> PhysicsRayCast(const Ogre::Vector3& src, const Ogre::Vector3& dir, const Ogre::Real& maxdist);
 
      void SetPhysicWorldSize(const Ogre::Vector3& minsize, const Ogre::Vector3& maxsize);
      
      void GetPhysicWorldSize(Ogre::Vector3& minsize, Ogre::Vector3& maxsize);
 
      SMaterialID* CreatePhysicMaterialID(const std::string& materialIdName);
 
      void DeletePhysicMaterialID(SMaterialID* matID);
 
      unsigned int GetMaxBodyPair();
 
      SMaterialPair* CreatePhysicMaterialPair(SMaterialID* mat1, SMaterialID* mat2);
 
      void DeletePhysicMaterialPair(SMaterialPair* matpair);
 
      bool GetBodyPairExist(SBody* b0, SBody* b1);
 
      unsigned int GetBodyPairSize();
 
      void AddBodyPair(std::string name, SBody** pair);
 
      void RemoveBodyPair(SBody* body);
 
      void AddPhysicContraint(SPhysicContraint* contraint);
 
      void ClearPhysicContraint();
 
      PhysicContraintList GetPhysicContraintList();
 
      void RemovePhysicContraint(SPhysicContraint* contraint);
 
      void RemoveBodyContraint(SBody* body);
 
      void ClearBodyPairs();
 
      void ClearContactOverlapStart();
 
      void AddContactOverlapStart(std::string name, MCOLL* coll);
 
      void ClearContactActivated();
 
      void SetContactActivated(SBody* b0, SBody* b1, MCOLL* coll);
 
      static void PreUpdate(const NewtonWorld* const world, void* const listenerUserData, dFloat timestep);
      static void PostUpdate(const NewtonWorld* const world, void* const listenerUserData, dFloat timestep);
 
      static int ImpulsePointCallback(const NewtonBody* const body, void* const userData);
      void ApplyImpulsePoint(Ogre::Vector3 pos, Ogre::Real radius, Ogre::Real strength);
 
    protected :
      void LeaveWorldCallBack(OgreNewt::Body*, int threadIndex);
 
    private :
      SPhysicWorld();
 
      void initNewtonWorld();
        };
 
}
 
#endif