SO3Engine/SO3SceneGraph/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) 2010 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

You may alternatively use this source under the terms of a specific version of
the OpenSpace3D Unrestricted License provided you have obtained such a license from
I-maginer.
-----------------------------------------------------------------------------
*/

#ifndef __SO3PHYSICS_H__
#define __SO3PHYSICS_H__

#include "../SCOLBasic/SO3Prerequisites.h"
#include <OgreNewt.h>

namespace SO3
{

  typedef struct MCOLL
  {
          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 boost::unordered_map<std::string, SBody**> BodyPairMap;
  typedef boost::unordered_map<std::string, MCOLL*> PhysicContactMap;

  class SPhysicWorld
  {
    public :
      bool showPhysicsLine;
      BodyPairMap bodyPairMap;
      PhysicContactMap physicContactMap;
      PhysicContactMap physicContactOverlapStartMap;

      SMaterialPairMap listOfPhysicsMaterialPair;
      SMaterialIDMap listOfMaterialID;

    protected :

    private :
      OgreNewt::World* world;
      const SScene* mscene;
      bool worldIsEnabled;
      int worldFPS;
      OgreNewt::Debugger* worldDebugger;
      bool worldDebuggerIsInit;
      Ogre::Vector3 mGravity;
      int solverModel;
      int frictionModel;
      Ogre::Vector3 minWorldSize;
      Ogre::Vector3 maxWorldSize;
      bool mResetPhysicWorld;

    public :
      SPhysicWorld(SScene* scene);

      ~SPhysicWorld();

      OgreNewt::World* GetPhysicWorld();

      bool GetPhysicWorldEnable();

      void SetPhysicWorldEnable(bool enable);

      bool GetPhysicDebugEnable();

      void SetPhysicDebugEnable(bool enable);

      void SetPhysicFPS(int fps);

      int GetPhysicFPS();

      OgreNewt::Debugger* GetPhysicDebugger();
      
      void ResetPhysicWorld();

      void SetPhysicBodiesInitialState();

      void SetPhysicSolverModel(int mod);

      int GetPhysicSolverModel();

      void SetPhysicFrictionModel(int mod);

      int GetPhysicFrictionModel();

      void SetPhysicPlatformArchitecture(int mod);

      int GetPhysicPlatformArchitecture();

      void SetPhysicGravity(Ogre::Vector3 gravity);

      Ogre::Vector3 GetPhysicGravity();

      bool GetResetPhysicWorld();

      void SetResetPhysicWorld(bool state);

      SBody* PhysicsRayCast(Ogre::Vector3 src, Ogre::Vector3 dir, Ogre::Real maxdist, Ogre::Real &hitdistance, Ogre::Vector3 &hitnormal);

      void SetPhysicWorldSize(Ogre::Vector3 minsize, Ogre::Vector3 maxsize);
      
      void GetPhysicWorldSize(Ogre::Vector3 &minsize, Ogre::Vector3 &maxsize);

      SMaterialID* CreatePhysicMaterialID(std::string materialIdName);

      void DeletePhysicMaterialID(SMaterialID* matID);

      SMaterialPair* CreatePhysicMaterialPair(SMaterialID* mat1, SMaterialID* mat2);

      void DeletePhysicMaterialPair(SMaterialPair* matpair);

    protected :

      void LeaveWorldCallBack(OgreNewt::Body*, int threadIndex);

    private :

      SPhysicWorld();

      void initNewtonWorld();
  };

}

#endif

---