OgreNewt_CollisionPrimitives.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_COLLISIONPRIMITIVES
#define _INCLUDE_OGRENEWT_COLLISIONPRIMITIVES
 
 
#include "OgreNewt_Prerequisites.h"
#include "OgreNewt_Collision.h"
#include "OgreNewt_MaterialID.h"
 
 
// OgreNewt namespace.  all functions and classes use this namespace.
namespace OgreNewt
{
 
    namespace CollisionPrimitives
    {
        enum FaceWinding { FW_DEFAULT, FW_REVERSE };
 
        class _OgreNewtExport Null : public OgreNewt::Collision
        {
        public:
            Null( const World* world );
 
            ~Null() {}
        };
 
 
        class _OgreNewtExport Box : public OgreNewt::ConvexCollision
        {
        public:
 
            Box(const World* world);
 
 
            Box( const World* world, const Ogre::Vector3& size,  int id,
                const Ogre::Quaternion& orient = Ogre::Quaternion::IDENTITY, const Ogre::Vector3& pos = Ogre::Vector3::ZERO );
 
            ~Box() {}
        };
 
        class _OgreNewtExport Ellipsoid : public OgreNewt::ConvexCollision
        {
        public:
 
            Ellipsoid(const World* world);
 
 
            Ellipsoid(const World* world, const Ogre::Vector3& size, int id,
                const Ogre::Quaternion& orient = Ogre::Quaternion::IDENTITY, const Ogre::Vector3& pos = Ogre::Vector3::ZERO );
 
            ~Ellipsoid() {}
        };
 
        class _OgreNewtExport Cylinder : public OgreNewt::ConvexCollision
        {
        public:
 
            Cylinder(const World* world);
 
 
            Cylinder( const World* world, Ogre::Real radius, Ogre::Real height, int id,
                const Ogre::Quaternion& orient = Ogre::Quaternion::IDENTITY, const Ogre::Vector3& pos = Ogre::Vector3::ZERO );
 
            ~Cylinder() {}
        };
 
        class _OgreNewtExport Capsule : public OgreNewt::ConvexCollision
        {
        public:
 
            Capsule(const World* world);
 
 
            Capsule( const World* world, Ogre::Real radius, Ogre::Real height, int id,
                const Ogre::Quaternion& orient = Ogre::Quaternion::IDENTITY, const Ogre::Vector3& pos = Ogre::Vector3::ZERO );
 
            ~Capsule() {}
        };
 
        class _OgreNewtExport Cone : public OgreNewt::ConvexCollision
        {
        public:
 
            Cone(const World* world);
 
 
            Cone( const World* world, Ogre::Real radius, Ogre::Real height, int id,
                const Ogre::Quaternion& orient = Ogre::Quaternion::IDENTITY, const Ogre::Vector3& pos = Ogre::Vector3::ZERO );
 
            ~Cone() {}
        };
 
        class _OgreNewtExport ChamferCylinder : public OgreNewt::ConvexCollision
        {
        public:
 
            ChamferCylinder(const World* world);
 
 
            ChamferCylinder( const World* world, Ogre::Real radius, Ogre::Real height, int id,
                const Ogre::Quaternion& orient = Ogre::Quaternion::IDENTITY, const Ogre::Vector3& pos = Ogre::Vector3::ZERO );
 
            ~ChamferCylinder() {}
        };  
 
 
        class _OgreNewtExport ConvexHull : public OgreNewt::ConvexCollision
        {
        public:
 
            ConvexHull(const World* world);
 
 
            ConvexHull( const World* world, Ogre::Entity* ent, int id = 1,
                const Ogre::Quaternion& orient = Ogre::Quaternion::IDENTITY, const Ogre::Vector3& pos = Ogre::Vector3::ZERO, Ogre::Real tolerance = 0.001f, const Ogre::Vector3& scale = Ogre::Vector3::UNIT_SCALE);
 
            ConvexHull( const World* world, const Ogre::Vector3* verts, int vertcount,int id = 1,
                const Ogre::Quaternion& orient = Ogre::Quaternion::IDENTITY, const Ogre::Vector3& pos = Ogre::Vector3::ZERO, Ogre::Real tolerance = 0.001f );
 
            ~ConvexHull() {}
        };
 
        
 
        class _OgreNewtExport ConcaveHull : public OgreNewt::ConvexCollision
        {
        public:
 
            ConcaveHull(const World* world);
 
 
            ConcaveHull( const World* world, Ogre::Entity* ent, int id = 1, Ogre::Real tolerance = 0.001f, const Ogre::Vector3& scale = Ogre::Vector3::UNIT_SCALE);
 
            ConcaveHull( const World* world, const Ogre::Vector3* verts, int vertcount,int id = 1, Ogre::Real tolerance = 0.001f);
 
            ~ConcaveHull() {}
        };
 
 
 
        class _OgreNewtExport TreeCollision : public OgreNewt::Collision
        {
        public:
 
            TreeCollision( const World* world);
 
 
            TreeCollision( const World* world, Ogre::Entity* ent, bool optimize, int id, FaceWinding fw = FW_DEFAULT, const Ogre::Vector3& scale = Ogre::Vector3::UNIT_SCALE);
            TreeCollision( const World* world, const Ogre::SceneNode* node, bool optimize, int id, FaceWinding fw = FW_DEFAULT, const Ogre::Vector3& scale = Ogre::Vector3::UNIT_SCALE);
            void AddEntities(const Ogre::SceneNode* node, const Ogre::SceneNode* mainNode, const Ogre::Vector3 scale, FaceWinding fw = FW_DEFAULT);
 
            TreeCollision( const World* world, int numVertices, int numIndices, const float *vertices, const int *indices, bool optimize, int id, FaceWinding fw = FW_DEFAULT); 
 
 
            TreeCollision( const World* world, int numVertices, Ogre::Vector3* vertices, Ogre::IndexData* indexData, bool optimize, int id, FaceWinding fw = FW_DEFAULT);
 
            ~TreeCollision() {}
 
            void start(int id);
 
 
            void addPoly( Ogre::Vector3* polys, unsigned int ID );
 
            void finish( bool optimize );
 
 
            void setRayCastCallbackactive(bool active = true)
            {
                setRayCastCallbackactive( active, m_col );
            }
 
            //Newton >= 2.30
            static dFloat _CDECL newtonRayCastCallback(const NewtonBody* const body, const NewtonCollision* const treeCollision, dFloat distance, dFloat* normal, int faceId, void* userData);
            //static float _CDECL newtonRayCastCallback(float distance, float* normal, int faceId, void* userData);
 
        private:
            static void setRayCastCallbackactive( bool active , const NewtonCollision *col );
 
        };
 
 
        class _OgreNewtExport TreeCollisionSceneParser : public TreeCollision
        {
        public:
            TreeCollisionSceneParser( OgreNewt::World* world );
 
            ~TreeCollisionSceneParser() {}
 
            void parseScene( Ogre::SceneNode* startNode, int id, bool optimize = true, FaceWinding fw = FW_DEFAULT );
 
        protected:
 
 
            virtual bool entityFilter( const Ogre::SceneNode* currentNode, const Ogre::Entity* currentEntity, FaceWinding& fw ) { return true; }
 
            virtual unsigned int getID( const Ogre::SceneNode* currentNode, const Ogre::Entity* currentEntity, unsigned int currentSubMesh ) { return count++; }
 
        private:
            void _parseNode( Ogre::SceneNode* node, const Ogre::Quaternion& curOrient, const Ogre::Vector3& curPos, const Ogre::Vector3& curScale, FaceWinding fw );
 
 
            static int count;
        };
 
        //  COMPOUND COLLISION!
 
        class _OgreNewtExport CompoundCollision : public OgreNewt::Collision
        {
        public:
 
            CompoundCollision(const World* world);
 
 
            CompoundCollision( const World* world, std::vector<OgreNewt::CollisionPtr> col_array, int id );
 
            ~CompoundCollision() {}
        };
 
 
        // supplemental primitives built from convex hulls
 
 
        class _OgreNewtExport Pyramid : public OgreNewt::ConvexCollision
        {
        public:
 
            Pyramid(const World* world);
 
 
            Pyramid( const World* world, const Ogre::Vector3& size, int id,
                const Ogre::Quaternion& orient = Ogre::Quaternion::IDENTITY, const Ogre::Vector3& pos = Ogre::Vector3::ZERO, Ogre::Real tolerance = 0.001f );
 
            ~Pyramid() {}
        };
 
 
                /* Waiting for Ogre 1.7
                class _OgreNewtExport HeightField : public OgreNewt::Collision 
                {
                public:
                        HeightField(const World* world): OgreNewt::Collision(world){}
                        HeightField(const World* world, int width, int height, int gridsDiagonals, unsigned short *elevationMap, char *attributeMap, Ogre::Real horizontalScale, Ogre::Real verticleScale, int shapeID);
                        HeightField(const World* world, Ogre::Terrain *terrain, int shapeID);
 
                ~HeightField(){}
 
                private:
                        void createHeightFieldCollision(const World *world,int width,int height,int gridsDiagonals,unsigned short *elevationMap,char *attributeMap,Ogre::Real horizontalScale,Ogre::Real verticleScale,int shapeID);
                };
          */
    }   // end namespace CollisionPrimitives
 
}// end namespace OgreNewt
 
#endif  // _INCLUDE_OGRENEWT_COLLISIONPRIMITIVES