source: code/branches/physics/src/ogreode/OgreOdeSpace.h @ 2029

#ifndef _OGREODESPACE_H_
#define _OGREODESPACE_H_

#include "OgreOdePreReqs.h"
#include <OgreAxisAlignedBox.h>

namespace OgreOde 
{
        class _OgreOdeExport Space
        {
        friend class Geometry;
                friend class World;
        
#if ODE_VERSION_MINOR > 9
        public:
                enum Class
                {
                        Class_SimpleSpace               = dSimpleSpaceClass,
                        Class_HashSpace                 = dHashSpaceClass,
                        Class_SweepAndPrune             = dSweepAndPruneSpaceClass,
                        Class_QuadTree                  = dQuadTreeSpaceClass,
                        Class_FirstUser                 = dFirstUserClass,
                        Class_LastUser                  = dLastUserClass
                };
                Space::Class getClass(); 
#endif

        public:
                Space(World *world, const Space* space = 0);
                virtual ~Space();

                void registerSpace();

                void setAutoCleanup(bool on); 
                bool getAutoCleanup(); 

                void addGeometry(const Geometry& geometry); 
                void removeGeometry(const Geometry& geometry); 
                bool containsGeometry(const Geometry& geometry); 
                int getGeometryCount(); 
                Geometry* getGeometry(int index);

                virtual void collide(void* data = 0);
                virtual void collide(Space* space,void* data = 0);
                virtual void collide(Geometry* geometry,void* data = 0);
                
                
                virtual void collide(CollisionCallback* colCallback, bool useInternalCollisionFlag = true);
                virtual void collide(CollisionCallback* colCallback, Space* space);
                virtual void collide(CollisionCallback* colCallback, Geometry* geometry, bool useInternalCollisionFlag = true);
                
                
                void setInternalCollisions(bool collide);
                bool getInternalCollisions();

                virtual const Ogre::AxisAlignedBox& getAxisAlignedBox(); 

                virtual size_t getID();

                World* getWorld(){ return _world; }

        protected:
                dSpaceID getSpaceID() const;
                dSpaceID getSpaceID(const Space* space) const;

        protected:
                dSpaceID                _space;
                bool                    _internal_collisions;
                Ogre::AxisAlignedBox    _bounding_box;
        World                   *_world;
        };

        class _OgreOdeExport SimpleSpace:public Space
        {
        public:
                SimpleSpace(World *world, const Space* space = 0);
                ~SimpleSpace();
        };

        class _OgreOdeExport HashTableSpace:public Space
        {
        public:
                HashTableSpace(World *world, const Space* space = 0);
                ~HashTableSpace();

                void setLevels(int min_level,int max_level);
                int getMinimumLevel();
                int getMaximumLevel();
        };

        class _OgreOdeExport QuadTreeSpace:public Space
        {
        public:
                QuadTreeSpace(const Ogre::Vector3& center,const Ogre::Vector3& extents,int depth,World *world, const Space* space = 0);
                ~QuadTreeSpace();
    };

#if ODE_VERSION_MINOR > 9
        class _OgreOdeExport SweepAndPruneSpace : public Space
        {
        public:
                enum AxisOrder
                {
                        AxisOrder_XYZ = dSAP_AXES_XYZ,
                        AxisOrder_XZY = dSAP_AXES_XZY,
                        AxisOrder_YXZ = dSAP_AXES_YXZ,
                        AxisOrder_YZX = dSAP_AXES_YZX,
                        AxisOrder_ZXY = dSAP_AXES_ZXY,
                        AxisOrder_ZYX = dSAP_AXES_ZYX
                };
                
                // "Order XZY or ZXY usually works best, if your Y is up."
                SweepAndPruneSpace(AxisOrder axisOrder, World *world, const Space* space = 0);
        };
#endif
        
    /*
    * use Scene manager specialized scene partition algo to find collision
    * 
    */
    class _OgreOdeExport OgreSceneManagerSpace:public Space
    {
    public:
        OgreSceneManagerSpace(const Ogre::Vector3& center,
                                const Ogre::Vector3& extents,
                                int depth,
                                Ogre::SceneManager *scn_mgr,
                                World *world, const Space* space = 0);
        ~OgreSceneManagerSpace();

        void collide(void* data = 0);

    private:
        Ogre::SceneManager              *_scn_mgr;
        Ogre::IntersectionSceneQuery    *_intersection_query;

        // does scene manager has plane collision geometry support
        // BSP scene manager has that.
        bool                            _scene_geometry;
    };

        
}

#endif