OgreNewt_Collision.h

Go to the documentation of this file.

/*
    OgreNewt Library
 
    Ogre implementation of Newton Game Dynamics SDK
 
    OgreNewt basically has no license, you may use any or all of the library however you desire... I hope it can help you in any way.
 
        by Walaber
        some changes by melven
 
*/
#ifndef _INCLUDE_OGRENEWT_COLLISION
#define _INCLUDE_OGRENEWT_COLLISION
 
 
#include "OgreNewt_Prerequisites.h"
 
 
// OgreNewt namespace.  all functions and classes use this namespace.
namespace OgreNewt
{
 
 
  enum CollisionPrimitiveType
  {
    BoxPrimitiveType = SERIALIZE_ID_BOX,
    ConePrimitiveType = SERIALIZE_ID_CONE,
    EllipsoidPrimitiveType = SERIALIZE_ID_SPHERE,
    CapsulePrimitiveType = SERIALIZE_ID_CAPSULE,
    CylinderPrimitiveType = SERIALIZE_ID_CYLINDER,
    CompoundCollisionPrimitiveType = SERIALIZE_ID_COMPOUND,
    ConvexHullPrimitiveType = SERIALIZE_ID_CONVEXHULL,
    ChamferCylinderPrimitiveType = SERIALIZE_ID_CHAMFERCYLINDER,
    TreeCollisionPrimitiveType = SERIALIZE_ID_TREE,
    NullPrimitiveType = SERIALIZE_ID_NULL,
    HeighFieldPrimitiveType = SERIALIZE_ID_HEIGHTFIELD,
    ScenePrimitiveType = SERIALIZE_ID_SCENE
  };
 
  /*
      CLASS DEFINITION:
 
          Collision
 
      USE:
          this class represents a NewtonCollision, which is the newton structure
          for collision geometry.
  */
  class _OgreNewtExport Collision
  {
  public:
    Collision(const World* world);
 
    Collision(const Collision& shape);
 
    Collision(const NewtonCollision* collision, const World* world);
 
 
    virtual ~Collision();
 
 
    NewtonCollision* const getNewtonCollision() const { return m_col; }
 
    const World* getWorld() const { return m_world; }
 
    //    this is not possible any more (since newton 2.04), you can only set the id when creating the collision
    //    //! set a user ID for collision callback identification
    //    /*!
    //        you can set different IDs for each piece in a compound collision object, and then use these IDs in a collision callback to
    //        determine which part is currently colliding.
    //    */
    //    void setUserID( unsigned id ) const { NewtonCollisionSetUserID( m_col, id); }
 
    unsigned getUserID() const { return NewtonCollisionGetUserID(m_col); }
 
 
    Ogre::AxisAlignedBox getAABB(const Ogre::Quaternion& orient = Ogre::Quaternion::IDENTITY, const Ogre::Vector3& pos = Ogre::Vector3::ZERO) const;
 
    CollisionPrimitiveType getCollisionPrimitiveType() const { return getCollisionPrimitiveType(m_col); }
 
    static CollisionPrimitiveType getCollisionPrimitiveType(const NewtonCollision *col);
 
    NewtonCollisionInfoRecord* getInfo() { return getInfo(m_col); }
 
    static NewtonCollisionInfoRecord* getInfo(const NewtonCollision *col);
 
    friend class OgreNewt::CollisionSerializer;
    //friend void CollisionSerializer::exportCollision(const CollisionPtr& collision, const Ogre::String& filename);
    //friend CollisionPtr CollisionSerializer::importCollision(Ogre::DataStreamPtr& stream, OgreNewt::World* world);
 
  protected:
    NewtonCollision* m_col;
    const World* m_world;
 
  };
 
 
 
  class _OgreNewtExport ConvexCollision : public Collision
  {
  public:
    ConvexCollision(const World* world);
 
    ConvexCollision(const Collision& convexShape);
 
    ConvexCollision(const ConvexCollision& convexShape);
 
    ~ConvexCollision();
 
    Ogre::Real calculateVolume() const { return (Ogre::Real)NewtonConvexCollisionCalculateVolume(m_col); }
 
    void calculateInertialMatrix(Ogre::Vector3& inertia, Ogre::Vector3& offset) const
    {
      dVector iner;
      dVector off;
      NewtonConvexCollisionCalculateInertialMatrix(m_col, &iner.m_x, &off.m_x);
 
      inertia.x = Ogre::Real(iner.m_x);
      inertia.y = Ogre::Real(iner.m_y);
      inertia.z = Ogre::Real(iner.m_z);
      offset.x = Ogre::Real(off.m_x);
      offset.y = Ogre::Real(off.m_y);
      offset.z = Ogre::Real(off.m_z);
    }
  };
 
 
#ifdef OGRENEWT_NO_COLLISION_SHAREDPTR
  typedef Collision* CollisionPtr;
  typedef ConvexCollision* ConvexCollisionPtr;
#else
  typedef std::shared_ptr<Collision> CollisionPtr;
  typedef std::shared_ptr<ConvexCollision> ConvexCollisionPtr;
#endif
 
}   // end NAMESPACE OgreNewt
 
#endif
// _INCLUDE_OGRENEWT_COLLISION