Space.h

Go to the documentation of this file.

//-----------------------------------------------------------------------------------
//
// Pro-Vocation Light Engine (PVLE)
// Copyright (C) 2007-2009  Sukender, KinoX & Buzib
// For more information, contact us : sukender@free.fr
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 3 of the License, or
// (at your option) any later version.
//
// For any use that is not compatible with the terms of the GNU 
// General Public License, please contact the authors for alternative
// licensing options.
//
// 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this program; if not, write to the Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
//
//-----------------------------------------------------------------------------------

#ifndef PHY_SPACE_H
#define PHY_SPACE_H

#include <PVLE/Export.h>
#include <PVLE/Physics/AbstractGeom.h>
#include <PVLE/Physics/Geom.h>
#include <set>
#include <algorithm>

#pragma warning(push)
#pragma warning(disable : 4345)     // For SpaceTypeInfo ONLY - Stupid warning about the fact that SimpleData is POD type in boost::variant.

//#include <boost/variant.hpp>          // Too much includes :)
#include <boost/variant/variant.hpp>
#include <boost/variant/get.hpp>

#pragma warning(pop)


class C3DPhy;

namespace Physics {
/*
struct SpaceTypeInfo {
    enum ESpaceType { SIMPLE, HASH, QUAD };

    SpaceTypeInfo(ESpaceType type = SIMPLE) :
        type(type),
        hashMinLevel(1), hashMaxLevel(4),
        quadWorldBox(1e7, 1e7, 1e7), quadCenter(0,0,0), quadLevel(4)
    {}

    ESpaceType type;        ///< Type of the space.

    // Hash :
    UINT hashMinLevel, hashMaxLevel;        ///< Hash parameter.

    // Quadtree :
    osg::Vec3 quadWorldBox, quadCenter;     ///< Quad parameter.
    UINT quadLevel;                         ///< Quad parameter.
};
*/


#pragma warning(push)
#pragma warning(disable : 4345)     // For SpaceTypeInfo ONLY - Stupid warning about the fact that SimpleData is POD type in boost::variant.

class SpaceTypeInfo {
public:
    enum ESpaceType { SIMPLE, HASH, QUAD, SWEEP_AND_PRUNE };

    SpaceTypeInfo(ESpaceType type = SIMPLE) { setType(type); }

    inline ESpaceType getType() const { return type; }

    void setType(ESpaceType type) {
        this->type = type;
        if (type == SIMPLE) setTypeSimple();
        else if (type == HASH) setTypeHash();
        else if (type == QUAD) setTypeQuad();
        else if (type == SWEEP_AND_PRUNE) setTypeSweepAndPrune();
    }

    struct HashData {
        UINT minLevel, maxLevel;
    };

    struct QuadData {
        osg::Vec3 worldBox, center;
        UINT level;
    };

    enum ESAPAxesOrder {
        SAP_AXES_XYZ = dSAP_AXES_XYZ,
        SAP_AXES_XZY = dSAP_AXES_XZY,
        SAP_AXES_YXZ = dSAP_AXES_YXZ,
        SAP_AXES_YZX = dSAP_AXES_YZX,
        SAP_AXES_ZXY = dSAP_AXES_ZXY,
        SAP_AXES_ZYX = dSAP_AXES_ZYX
    };

    struct SweepAndPruneData {
        ESAPAxesOrder axisOrder;
    };

    inline HashData & getHashData() { ASSERT(type == HASH); return boost::get<HashData>(data); }
    inline const HashData & getHashData() const { ASSERT(type == HASH); return boost::get<HashData>(data); }
    inline QuadData & getQuadData() { ASSERT(type == QUAD); return boost::get<QuadData>(data); }
    inline const QuadData & getQuadData() const { ASSERT(type == QUAD); return boost::get<QuadData>(data); }
    inline SweepAndPruneData & getSweepAndPruneData() { ASSERT(type == SWEEP_AND_PRUNE); return boost::get<SweepAndPruneData>(data); }
    inline const SweepAndPruneData & getSweepAndPruneData() const { ASSERT(type == SWEEP_AND_PRUNE); return boost::get<SweepAndPruneData>(data); }


    inline void setTypeSimple() {
        type = SIMPLE;
        data = SimpleData();
    }

    inline HashData & setTypeHash() {
        type = HASH;
        HashData hash;
        //HashData & hash = getHashData();
        hash.minLevel = 1;
        hash.maxLevel = 4;
        data = hash;
        return getHashData();
    }

    inline QuadData & setTypeQuad() {
        type = QUAD;
        QuadData quad;
        //QuadData & quad = getQuadData();
        quad.worldBox = osg::Vec3(1e7, 1e7, 1e7);
        quad.center = osg::Vec3(0,0,0);
        quad.level = 4;
        data = quad;
        return getQuadData();
    }

    inline SweepAndPruneData & setTypeSweepAndPrune() {
        type = SWEEP_AND_PRUNE;
        SweepAndPruneData sap;
        //SweepAndPruneData & sap = getSweepAndPruneData();
        sap.axisOrder = SAP_AXES_XYZ;
        data = sap;
        return getSweepAndPruneData();
    }

protected:
    ESpaceType type;        

    // MSCV8 causes warning C4345 ; a stupid warning about the fact that SimpleData is POD type in boost::variant.
    struct SimpleData {};   
    //struct SimpleData { osg::Vec3f a; };
    boost::variant<HashData, QuadData, SweepAndPruneData, SimpleData> data;
};


#pragma warning(pop)



class Visitor;

class PVLE_EXPORT Space : public AbstractGeom {
public:
    Space() : collided(false) { init(); }
    Space(const SpaceTypeInfo & spaceTypeInfo) : collided(false), typeInfo(spaceTypeInfo) { init(); }
    Space(const osg::Vec3 & worldBox) : collided(false) { typeInfo.setTypeQuad().worldBox = worldBox; init(); }

    Space(const Space & v, UINT opts = COPY_ALL, IGeomCollisionContainer * pGeomsContainer = NULL, TDuplicatedBodiesMap * pDuplicatedBodies = NULL);

    //Space(const Space & v, ECopyOpts opts = COPY_???);        // TODO copy a space with its geoms ????

    virtual Space * asSpace() { return this; }
    virtual const Space * asSpace() const { return this; }

    typedef std::set<osg::ref_ptr<AbstractGeom> > TListGeoms;
    TListGeoms::const_iterator getGeomsBegin() const { return vGeoms.begin(); }     // Does not exist in non-const.
    TListGeoms::const_iterator getGeomsEnd() const { return vGeoms.end(); }         // Does not exist in non-const.

#ifdef ENABLE_PHYSICS_EXTRA_WRAPPING
    UINT nbGeoms() const { ASSERT(vGeoms.size() == dSpaceGetNumGeoms(reinterpret_cast<dSpaceID>(id))); return vGeoms.size(); }
#endif
    bool isInSpace(AbstractGeom * pAbstractGeom) const;     

    void add(AbstractGeom * pAbstractGeom);
    void add(C3DPhy & r3DPhy);

    void remove(AbstractGeom * pAbstractGeom);
    void removeAll();
    void remove(C3DPhy & r3DPhy);

    virtual void accept(Visitor & v);
    virtual void traverse(Visitor & v);

    SpaceTypeInfo::ESpaceType getType() const {
        return typeInfo.getType();
        // Note : could use dSpaceGetClass()
    };

#ifdef ENABLE_PHYSICS_EXTRA_WRAPPING
    int getSublevel() const { return dSpaceGetSublevel(reinterpret_cast<dSpaceID>(id)); }
    void getSublevel(int subLevel) { return dSpaceSetSublevel(reinterpret_cast<dSpaceID>(id), subLevel); }
#endif

    operator dSpaceID() { return reinterpret_cast<dSpaceID>(id); }
    operator const dSpaceID() const { return reinterpret_cast<dSpaceID>(id); }

protected:
    friend class World;

    TListGeoms vGeoms;

    bool collided;          

    SpaceTypeInfo typeInfo;     // Used only for copy constructor

    virtual ~Space();

private:
    void init();
    void initSimple();
    void initHash(UINT minLevel, UINT maxLevel);
    void initQuad(osg::Vec3 worldBox, osg::Vec3 center = osg::Vec3(0,0,0), UINT level = 4);
    void initSweepAndPrune(int axesOrder);
};


}   // namespace Physics

#endif  // PHY_SPACE_H

---