GeometryHandlers.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_GEOMETRY_HANDLERS_H
#define PHY_GEOMETRY_HANDLERS_H

#include <ode/ode.h>
#include <osg/Referenced>
#include <osg/ref_ptr>
#include <PVLE/Physics/Converters.h>
#include <PVLE/Export.h>
#include <PVLE/Util/Util.h>
#include <PVLE/Util/Singleton.h>
#include <PVLE/Util/Callback.h>

#include <osg/Array>

// For MeshHandler
#include <boost/filesystem/path.hpp>
#include <osg/Geometry>


namespace osg {
    class Heightfield;
}


namespace Physics {

class GeometryHandler;

class GHChangeCallback : public Util::Callback<GHChangeCallback> {
public:
    virtual void operator()(GeometryHandler * pGH) {
        // Callback is responsible for calling nested callbacks, so you should always call traverse(pGH)
        traverse(pGH);
    }

    void traverse(GeometryHandler * pGH) { if (_nestedCallback.valid()) _nestedCallback->operator()(pGH); }
};


class PVLE_EXPORT GeometryHandler : public osg::Referenced {
public:
    enum EGeomType { SPHERE=dSphereClass, BOX=dBoxClass, CAPSULE=dCapsuleClass, CYLINDER=dCylinderClass, PLANE=dPlaneClass, RAY=dRayClass, CONVEX=dConvexClass, TRANSFORM=dGeomTransformClass, MESH=dTriMeshClass, HEIGHT_FIELD=dHeightfieldClass, USER1=dFirstUserClass };

    enum EBodyADOverride {
        AD_NO_OVERRIDE   = 0,           
        AD_FLAG          = 0x01,        
        AD_LINEAR        = 0x02,        
        AD_ANGULAR       = 0x04,        
        AD_STEPS         = 0x08,        
        AD_TIME          = 0x10,        
        AD_SAMPLES_COUNT = 0x20         
    };

    GeometryHandler() : id(0) {}
    virtual EGeomType type() const =0;


    virtual UINT getADOverrideFlag() { return AD_NO_OVERRIDE; }
    virtual bool getADFlag() { return true; }                       
    virtual dReal getADLinearThreshold() { return 0.01f; }
    virtual dReal getADAngularThreshold() { return 0.01f; }
    virtual UINT getADSteps() { return 10; }
    virtual dReal getADTime() { return 0; }
    virtual UINT getADSamplesCount() { return 1; }

    virtual GeometryHandler * clone() const =0;

    osg::ref_ptr<GHChangeCallback> pChangeCallback;
    inline void addOrSetChangeCallback(GHChangeCallback * callback) { if (pChangeCallback.valid()) pChangeCallback->addNestedCallback(callback); else pChangeCallback = callback; }


protected:
    friend class Geom;
    virtual dGeomID create(dSpaceID spaceId) =0;
    mutable dGeomID id;

    virtual ~GeometryHandler() {}
};


class PVLE_EXPORT UserGeomsInitializer : public Util::Singleton<UserGeomsInitializer> {
public:
    UserGeomsInitializer();
    dGeomID createUserGeom(GeometryHandler::EGeomType type) { return dCreateGeom(type); }
};


// ---------------------------------------------------------------------------------------------------


class PVLE_EXPORT SphereHandler : public GeometryHandler {
public:
    SphereHandler(dReal radius = 1) : radius(radius) {}
    virtual EGeomType type() const { return SPHERE; }

    void setRadius(dReal radius) {
        if (this->radius == radius) return;
        if(!id) this->radius = radius; else dGeomSphereSetRadius(id, radius);
        if (pChangeCallback.valid()) pChangeCallback->operator()(this);
    }
    dReal getRadius() const { if(!id) return radius; return dGeomSphereGetRadius(id); }

    dReal getPointDepth(graphVec3 point) { ASSERT(id); return dGeomSpherePointDepth(id, point.x(), point.y(), point.z()); }

    // Sphere can be auto-disabled quickly
    virtual UINT getADOverrideFlag() { return AD_STEPS; }
    virtual UINT getADSteps() { return 2; }

    virtual GeometryHandler * clone() const { return new SphereHandler(radius); }
protected:
    virtual dGeomID create(dSpaceID spaceId) { id = dCreateSphere(spaceId, radius); return id; }
    dReal radius;
};


class PVLE_EXPORT BoxHandler : public GeometryHandler {
public:
    BoxHandler(dReal x =1, dReal y =1, dReal z =1) : x(x), y(y), z(z) {}
    BoxHandler(graphVec3 v) { setSize(v); }
    virtual EGeomType type() const { return BOX; }

    void setSize(graphVec3 v) { setSize(v.x(), v.y(), v.z()); }
    void setSize(dReal x, dReal y, dReal z) {
        if (this->x == x && this->y == y && this->z == z) return;
        this->x = x; this->y = y; this->z = z;
        if (id) dGeomBoxSetLengths(id, x, y, z);
        if (pChangeCallback.valid()) pChangeCallback->operator()(this);
    }

    graphVec3 getSize() const { if(!id) return graphVec3(x,y,z); dVector3 v; dGeomBoxGetLengths(id, v); return toGraphVec3(v); }
    dReal getPointDepth(graphVec3 point) { ASSERT(id); return dGeomBoxPointDepth(id, point.x(), point.y(), point.z()); }

    virtual GeometryHandler * clone() const { return new BoxHandler(x,y,z); }

protected:
    virtual dGeomID create(dSpaceID spaceId) { id = dCreateBox(spaceId, x, y, z); return id; }
    dReal x,y,z;
};


class PVLE_EXPORT PlaneHandler : public GeometryHandler {
public:
    PlaneHandler(graphVec4 plane = graphVec4(0,0,1,0)) : x(plane.x()), y(plane.y()), z(plane.z()), t(plane.w()) {}
    PlaneHandler(dReal x, dReal y =0, dReal z =1, dReal t =0) : x(x), y(y), z(z), t(t) {}
    
    virtual EGeomType type() const { return PLANE; }

    void setParams(graphVec4 plane) { setParams(plane.x(), plane.y(), plane.z(), plane.w()); }
    void setParams(dReal x, dReal y, dReal z, dReal t) {
        if (this->x == x && this->y == y && this->z == z && this->t == t) return;
        this->x = x; this->y = y; this->z = z; this->t = t;
        if (id) dGeomPlaneSetParams(id, x, y, z, t);
        if (pChangeCallback.valid()) pChangeCallback->operator()(this);
    }

    graphVec4 getParams() const {
        if(!id) return graphVec4(x,y,z,t);
        dVector4 v;
        dGeomPlaneGetParams(id, v);
        return toGraphVec4(v);
    }

    dReal getPointDepth(graphVec3 point) { ASSERT(id); return dGeomPlanePointDepth(id, point.x(), point.y(), point.z()); }

    virtual GeometryHandler * clone() const { return new PlaneHandler(x,y,z,t); }

protected:
    virtual dGeomID create(dSpaceID spaceId) { id = dCreatePlane(spaceId, x, y, z, t); return id; }
    dReal x,y,z,t;
};


class PVLE_EXPORT CylinderHandler : public GeometryHandler {
public:
    CylinderHandler(dReal radius = 1, dReal length = 1) : radius(radius), length(length) {}
    virtual EGeomType type() const { return CYLINDER; }

    void setParams(dReal radius, dReal length) {
        if (this->radius == radius && this->length == length) return;
        this->radius = radius; this->length = length;
        if (id) dGeomCylinderSetParams(id, radius, length);
        if (pChangeCallback.valid()) pChangeCallback->operator()(this);
    }

    std::pair<dReal, dReal> getParams() const {
        if(!id) return std::make_pair(radius, length);
        dReal r, l;
        dGeomCylinderGetParams(id, &r, &l);
        return std::make_pair(r,l);
    }

    //dReal getPointDepth(graphVec3 point) { ASSERT(id); dGeomCylinderPointDepth(id, point.x(), point.y(), point.z()); }

    virtual GeometryHandler * clone() const { return new CylinderHandler(radius, length); }
protected:
    virtual dGeomID create(dSpaceID spaceId) { id = dCreateCylinder(spaceId, radius, length); return id; }
    dReal radius, length;
};


class PVLE_EXPORT CapsuleHandler : public GeometryHandler {
public:
    CapsuleHandler(dReal radius = 1, dReal length = 1) : radius(radius), length(length) {}
    virtual EGeomType type() const { return CAPSULE; }

    void setParams(dReal radius, dReal length) {
        if (this->radius == radius && this->length == length) return;
        this->radius = radius; this->length = length;
        if (id) dGeomCapsuleSetParams(id, radius, length);
        if (pChangeCallback.valid()) pChangeCallback->operator()(this);
    }

    std::pair<dReal, dReal> getParams() const {
        if(!id) return std::make_pair(radius, length);
        dReal r, l;
        dGeomCapsuleGetParams(id, &r, &l);
        return std::make_pair(r,l);
    }

    dReal getPointDepth(graphVec3 point) { ASSERT(id); return dGeomCapsulePointDepth(id, point.x(), point.y(), point.z()); }

    virtual GeometryHandler * clone() const { return new CapsuleHandler(radius, length); }

protected:
    virtual dGeomID create(dSpaceID spaceId) { id = dCreateCapsule(spaceId, radius, length); return id; }
    dReal radius, length;
};


class PVLE_EXPORT RayHandler : public GeometryHandler {
public:
    RayHandler(dReal length) : length(length), startPoint(osg::Vec3(0,0,0)), dir(osg::Vec3(0,0,1)) {}
    RayHandler(dReal length, graphVec3 startPoint, graphVec3 dir) : length(length), startPoint(startPoint), dir(dir) {}
    virtual EGeomType type() const { return RAY; }

    void setLength(dReal length) {
        if (this->length == length) return;
        this->length = length;
        if (id) dGeomRaySetLength(id, length);
        if (pChangeCallback.valid()) pChangeCallback->operator()(this);
    }
    dReal getLength() const { if(!id) return length; return dGeomRayGetLength(id); }

    void setRay(graphVec3 startPoint, graphVec3 dir) {
        if (this->startPoint == startPoint && this->dir == dir) return;
        this->startPoint = startPoint; this->dir = dir;
        if (id) dGeomRaySet(id, startPoint.x(), startPoint.y(), startPoint.z(), dir.x(), dir.y(), dir.z());
        if (pChangeCallback.valid()) pChangeCallback->operator()(this);
    }

    graphVec3 getStartPoint() {
        if(!id) return startPoint;
        dVector3 s, d;
        dGeomRayGet(id, s, d);
        return toGraphVec3(s);
    }
    graphVec3 getDir() {
        if(!id) return dir;
        dVector3 s, d;
        dGeomRayGet(id, s, d);
        return toGraphVec3(d);
    }

    virtual GeometryHandler * clone() const { return new RayHandler(length, startPoint, dir); }

protected:
    virtual dGeomID create(dSpaceID spaceId) {
        id = dCreateRay(spaceId, length);
        dGeomRaySet(id, startPoint.x(), startPoint.y(), startPoint.z(), dir.x(), dir.y(), dir.z());
        dGeomRaySetLength(id, length);
        return id;
    }
    dReal length;
    graphVec3 startPoint, dir;
};


class PVLE_EXPORT HeightFieldHandler : public GeometryHandler {
public:
    HeightFieldHandler(const osg::HeightField * pGfxHeightField, float thickness = 1, const graphVec3 & offset_from_graph = graphVec3(0,0,0), bool bWarp = false);

    HeightFieldHandler(const HeightFieldHandler & hf);

    // Warning : bPlaceable is a constant (you will not ba able to change it once instanciated).
    //HeightFieldHandler(const osg::HeightField * pGfxHeightField, bool bPlaceable = true, float scale = 1, float thickness = 1, bool bWarp = false);

    virtual EGeomType type() const { return HEIGHT_FIELD; }

    //void refreshData(???) {
    //  if(!id) { this-> = ; }
    //  else dGeomHei??? (id, ???);
    //}

    //??? getParams() const {}

    virtual GeometryHandler * clone() const { return new HeightFieldHandler(*this); }

protected:
    virtual dGeomID create(dSpaceID spaceId);

    float * pData;                      
    float width, depth;                 
    UINT widthSamples, depthSamples;    
    float scale, offset, thickness;     // ODE parameters (Note : scale and offset are applied on HEIGHT DATA, as ODE do).
    bool bPlaceable, bWarp;             // ODE parameters
    dVector3 pos;                       
    dQuaternion rot;                    
    dHeightfieldDataID idHFData;        
    dGeomID idHF;                       

    virtual ~HeightFieldHandler() {
        if (idHFData) dGeomHeightfieldDataDestroy(idHFData);
        delete[] pData;
    }
};


class PVLE_EXPORT MeshHandler : public GeometryHandler {
public:
    MeshHandler(const osg::Geometry * pGfxGeometry) : pGeo(pGfxGeometry), pLocalIndexArray(NULL) { meshDataId = dGeomTriMeshDataCreate(); }
    MeshHandler(osg::Node * pModel);
    MeshHandler(const osg::HeightField * pGfxHeightField);

    virtual EGeomType type() const { return MESH; }

    const osg::Geometry * getGeometry() const { ASSERT(pGeo); return pGeo; }
    //void setGeometry(const osg::Geometry * pGfxGeometry) {}

    osg::Geometry * DEBUG_getOwnGeometry() { return pOwnGeo.get(); }        

    //void meshStep();      // Deprecated ? Used for accuracy ?

    void clearCache() { dGeomTriMeshClearTCCache(id);}
    //dGeomTriMeshGetTriangle
    //dGeomTriMeshGetPoint

    //dGeomTriMeshEnableTC
    //dGeomTriMeshIsTCEnabled

    //virtual UINT getADOverrideFlag() { return AD_STEPS | AD_SAMPLES_COUNT | AD_LINEAR | AD_ANGULAR; }
    //virtual UINT getADSteps() { return 8; }
    //virtual UINT getADSamplesCount() { return 8; }
    //virtual dReal getADLinearThreshold() { return 1.0; }
    //virtual dReal getADAngularThreshold() { return 1.0; }

    virtual UINT getADOverrideFlag();
    virtual UINT getADSteps();
    virtual UINT getADSamplesCount();
    virtual dReal getADLinearThreshold();
    virtual dReal getADAngularThreshold();

    virtual GeometryHandler * clone() const {
        THROW_TRACED_EXCEPTION("Not implemented");
        //return new MeshHandler();
    }
protected:
    virtual dGeomID create(dSpaceID spaceId);
    const osg::Geometry * pGeo;
    dTriMeshDataID meshDataId;

    typedef osg::TemplateIndexArray< GLuint, osg::Array::UIntArrayType, sizeof(GLuint), GL_UNSIGNED_INT > TIndexArray;
    osg::ref_ptr<TIndexArray> pLocalIndexArray;

    template<class TDrawElements>
    void indexAdd(const osg::PrimitiveSet * pPrimitive);

    // Turn GL triangle list into an indexed primitive by filling internal index array, for DrawArrayLengths.
    void indexTriangles(UINT lengthPrimitive, UINT offset);
    void indexTriangleStrip(UINT lengthPrimitive, UINT offset);
    void indexTriangleFan(UINT lengthPrimitive, UINT offset);
    void indexQuads(UINT lengthPrimitive, UINT offset);
    void indexQuadStrip(UINT lengthPrimitive, UINT offset);

    // Same for DrawElements*
    template<class TDrawElements>
    void indexTriangles(const TDrawElements * pPrimitive);
    template<class TDrawElements>
    void indexTriangleStrip(const TDrawElements * pPrimitive);
    template<class TDrawElements>
    void indexTriangleFan(const TDrawElements * pPrimitive);
    template<class TDrawElements>
    void indexQuads(const TDrawElements * pPrimitive);
    template<class TDrawElements>
    void indexQuadStrip(const TDrawElements * pPrimitive);

    template <class TDrawElements>
    void indexByType(const osg::PrimitiveSet * pPrimitive);

    virtual ~MeshHandler() { dGeomTriMeshDataDestroy(meshDataId); }

private:
    osg::ref_ptr<osg::Geometry> pOwnGeo;        
};


/*
class PVLE_EXPORT TerrainHandler : public GeometryHandler {
public:
    TerrainHandler(osg::HeightField * pGfxHeightField, const graphMat & WTLMatrix, const graphBB & initialBB) : pHF(pGfxHeightField), initialBB(initialBB) {
        this->WTLMatrix = pHF->computeRotationMatrix() * graphMat::translate(pHF->getOrigin()) * WTLMatrix;
    }

    virtual EGeomType type() const { return TERRAIN; }


    // Selector for collisions.
    static dColliderFn * collide(int num) {
        if (num == dBoxClass) return Physics::TerrainHandler::collideBox;
        if (num == dSphereClass) return Physics::TerrainHandler::collideSphere;
        //if (num == dTerrainClass) return Physics::TerrainHandler::collideTerrain;
        return 0;
    }

    static int collideBox(dGeomID o1, dGeomID o2, int flags, dContactGeom * pContact, int skip);
    static int collideSphere(dGeomID o1, dGeomID o2, int flags, dContactGeom * pContact, int skip);
    static void aabb(dGeomID g, dReal aabb[6]) { toPhyBB(static_cast<TerrainHandler *>(dGeomGetData(g))->initialBB, aabb); }
    //static int aabb_test(dGeomID o1, dGeomID o2, dReal aabb2[6]) { return 0; }

    virtual GeometryHandler * clone() const {
        THROW_TRACED_EXCEPTION("Not implemented");
        //return new MeshHandler();
    }

protected:
    virtual dGeomID create(dSpaceID spaceId) {
        id = UserGeomsInitializer::instance().createUserGeom(TERRAIN);
        return id;
    }

    osg::HeightField * pHF;
    graphMat WTLMatrix;
    graphBB initialBB;

    virtual ~TerrainHandler() {}
};
*/
}   // namespace Physics


#endif  // PHY_GEOMETRY_HANDLERS_H

---