SO3Body.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 __SO3BODY_H__
#define __SO3BODY_H__
 
#include "SCOLBasic/SO3Prerequisites.h"
#include <External/ogrenewt/OgreNewt.h>
#include "SO3Shape.h"
 
namespace SO3
{
 
class SBody
{
public:
protected:
        OgreNewt::Body* O3Body;
  SShape* mShape;
  SNode* mNode;
  SScene* mScene;
  Ogre::ManualObject* mDebugBody;
  bool mIgnoreCollision;
  bool mApplyGravity;
  bool HasBuoyancy;
        Ogre::Real mMass; 
        Ogre::Vector3 force;
        Ogre::Vector3 torque;
  Ogre::Vector3 constantForce;
        Ogre::Vector3 constantTorque;
        Ogre::Vector3 localForce;
        Ogre::Vector3 globalForce;
        Ogre::Vector3 globalLocationForce;
        Ogre::Vector3 localLocationForce;
  Ogre::Vector3 destPosition;
  Ogre::Quaternion destOrientation;
  Ogre::Real moveStiffness;
  Ogre::Real rotateStiffness;
  Ogre::Real mFluidWaterToVolume;
  Ogre::Real mFluidViscosity;
 
  bool isFluid;
  bool haveToMove;
  bool haveToRotate;
  SMaterialID* materialId;
  bool mEnable;
private:
  OgreNewt::UpVector* mUpJoint;
 
public:
  SBody(SNode* node, SShape* shape);
        
  ~SBody();
        
  SShape* GetShape();
 
  void BodyAddForceCallback(OgreNewt::Body* body, float timeStep, int threadIndex);
  
  /*
  */
  void BodyUpdateCallback(OgreNewt::Body* body);
 
  OgreNewt::Body* getOgreNewtBodyPointer();
 
  void SetFluidState(bool state);
 
  bool GetFluidState();
 
  void SetFluidVolumeRatio(float waterToVolume);
 
  void SetFluidViscosity(float viscosity);
 
  float GetFluidWaterToVolumeRatio();
 
  float GetFluidViscosity();
 
  Ogre::Real GetMass();
        
  bool GetFreezeState();
 
  void SetGravityEnable(bool state);
        
  bool GetGravityEnable();
 
  //Ogre::Vector3 GetInertia();
        
  //Ogre::Vector3 GetOffset();
        
  Ogre::Vector3 GetCenterOfMass();
        
  Ogre::Vector3 GetForce();
        
  Ogre::Vector3 GetTorque();
        
  Ogre::Vector3 GetLocalForce();
        
  Ogre::Vector3 GetGlobalForce();
        
  Ogre::Vector3 GetGlobalLocationForce();
        
  Ogre::Vector3 GetLocalLocationForce();
        
  //void setInertia(Ogre::Vector3 mInteria);
 
  //void setOffset(Ogre::Vector3 mOffset);
        
  void SetMass(const Ogre::Real& mass);
        
  void SetMassMatrix(const Ogre::Real& mass, const Ogre::Vector3& inertial);
 
  void SetMaterialID(SMaterialID* matID);
        
  const std::string GetMaterialName() ;
 
  const OgreNewt::MaterialID* GetMaterialID();
 
  const SMaterialID* GetMaterial();
 
  void SetFreezeState(const bool& state);
        
  void SetForce(const Ogre::Vector3& mForce);
        
  void SetTorque(const Ogre::Vector3& mTorque);
        
  void SetOmega(const Ogre::Vector3& omega);
 
  Ogre::Vector3 GetOmega();
 
  void SetConstantForce(const Ogre::Vector3& mForce);
        
  void SetConstantTorque(const Ogre::Vector3& mTorque);
 
  void AddConstantForce(const Ogre::Vector3& mForce);
        
  void AddConstantTorque(const Ogre::Vector3& mTorque);
 
  Ogre::Vector3 GetConstantForce();
        
  Ogre::Vector3 GetConstantTorque();
 
  void SetLocalForce(const Ogre::Vector3& mLocalForce);
        
  void SetGlobalForce(const Ogre::Vector3& mGlobalForce);
        
  void SetGlobalLocationForce(const Ogre::Vector3& mGlobalLocationForce);
        
  void SetLocalLocationForce(const Ogre::Vector3& mLocalLocationForce);
  
  void SetBuoyancyForce(SBody* fluidBody);
  
  void SetPositionOrientation(const Ogre::Vector3& mDerivedPos, const Ogre::Quaternion& mDerivedOrientation);
  
  void UpdatePositionOrientation();
 
  void UpdatePositionOrientation(const Ogre::Vector3& mDerivedPos, const Ogre::Quaternion& mDerivedOrientation);
  
  void SetScale(const Ogre::Vector3& mDerivedScale);
 
  void SetMatrix(const Ogre::Vector3& mDerivedPos, const Ogre::Quaternion& mDerivedOrientation);
  
  void SetVelocity(const Ogre::Vector3& velocity);
 
  Ogre::Vector3 GetVelocity();
 
  void UpdateMatrix();
  
  void AddImpulse(const Ogre::Vector3& delta, const Ogre::Vector3& pos);
 
  void SetUpJoint(const Ogre::Vector3& vec);
 
  void RemoveUpJoint();
  
  void SetAngularDamping(const Ogre::Vector3& vec);
 
  Ogre::Vector3 GetAngularDamping();
  
  void SetCenterOfMass(const Ogre::Vector3& vec);
 
  void SetLinearDamping(const Ogre::Real& ang);
 
  Ogre::Real GetLinearDamping();
 
  void SetAutoSleep(const bool& enable);
 
  bool GetAutoSleep();
 
  void EnableSimulation(const bool& enable);
 
  bool GetSimulationState();
 
  void SetContinuousCollisionMode(const bool& enable);
 
  bool GetContinuousCollisionMode();
 
  void GetInvMass(Ogre::Real& mass, Ogre::Vector3& inertia);
 
  void GetMassMatrix(Ogre::Real& mass, Ogre::Vector3& inertia);
 
  void MoveToPosition(const Ogre::Vector3 &destPos, const Ogre::Real &stiffness);
  
  void RotateToOrientation(const Ogre::Quaternion &destQuat, const Ogre::Real &stiffness);
 
  bool GetSleepState();
 
  void GetPositionOrientation(Ogre::Vector3& pos, Ogre::Quaternion& orient);
 
  void SetType(const int& value);
 
  int GetType();
 
  void SetIgnoreCollision(const bool& state);
 
  bool GetIgnoreCollision();
 
  Ogre::Vector3 CalculateBodyOffset();
 
  SNode* GetParentNode();
 
  void Reset();
 
  void ShowDebug(bool state);
 
  void BuoyancyForce(OgreNewt::Body* visitor);
protected:
private:
  SBody();
  static void _CDECL newtonPerPoly(void* userData, int vertexCount, const float* faceVertec, int id);
};
 
}
 
#endif