Tessellator.h

Go to the documentation of this file.

/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield
 *
 * This library is open source and may be redistributed and/or modified under
 * the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
 * (at your option) any later version.  The full license is in LICENSE file
 * included with this distribution, and on the openscenegraph.org website.
 *
 * This library 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
 * OpenSceneGraph Public License for more details.
*/

#ifndef OSGUTIL_Tessellator
#define OSGUTIL_Tessellator

#include <osg/Geometry>

#include <osgUtil/Export>

#include <osg/GLU>

#include <vector>

#ifndef CALLBACK
    /* Win32 calling conventions. (or a least thats what the GLUT example tess.c uses.)*/
    #define CALLBACK
#endif

namespace osgUtil {

class OSGUTIL_EXPORT Tessellator : public osg::Referenced
{
    public:

        Tessellator();
        ~Tessellator();

        enum WindingType{
            TESS_WINDING_ODD          = GLU_TESS_WINDING_ODD,
            TESS_WINDING_NONZERO      = GLU_TESS_WINDING_NONZERO,
            TESS_WINDING_POSITIVE     = GLU_TESS_WINDING_POSITIVE,
            TESS_WINDING_NEGATIVE     = GLU_TESS_WINDING_NEGATIVE,
            TESS_WINDING_ABS_GEQ_TWO  = GLU_TESS_WINDING_ABS_GEQ_TWO
        } ;

        enum TessellationType {
            TESS_TYPE_GEOMETRY, // tessellate everything in the geometry object
            TESS_TYPE_DRAWABLE, // tessellate each polygon, triangles & quads drawables in geometry separately
            TESS_TYPE_POLYGONS // tessellate ONLY polygon drawables in geometry separately
        };

        void setBoundaryOnly (const bool tt) { _boundaryOnly=tt;}
        inline bool getBoundaryOnly ( ) { return _boundaryOnly;}

        void setWindingType (const WindingType wt) { _wtype=wt;}
        inline WindingType getWindingType ( ) { return _wtype;}

        void setTessellationType (const TessellationType tt) { _ttype=tt;}
        inline TessellationType getTessellationType ( ) { return _ttype;}

        void retessellatePolygons(osg::Geometry &cxgeom);

        void setTessellationNormal(const osg::Vec3 norm) { tessNormal=norm;}

        osg::Geometry::PrimitiveSetList  getContours() { return _Contours;}

        struct Prim : public osg::Referenced
        {
            Prim(GLenum mode):_mode(mode) {}

            typedef std::vector<osg::Vec3*> VecList;

            GLenum  _mode;
            VecList _vertices;
        };

        virtual void beginTessellation();

        void beginContour();

        void addVertex(osg::Vec3* vertex);

        void endContour();

        void endTessellation();

        typedef std::vector< osg::ref_ptr<Prim> > PrimList;

        PrimList& getPrimList() { return _primList; }

        void reset();

    protected:

        void reduceArray(osg::Array * cold, const unsigned int nnu);

        void collectTessellation(osg::Geometry &cxgeom, unsigned int originalIndex);

        typedef std::map<osg::Vec3*,unsigned int> VertexPtrToIndexMap;
        void addContour(GLenum  mode, unsigned int first, unsigned int last, osg::Vec3Array* vertices);
        void addContour(osg::PrimitiveSet* primitive, osg::Vec3Array* vertices);
        void handleNewVertices(osg::Geometry& geom,VertexPtrToIndexMap &vertexPtrToIndexMap);

        void begin(GLenum mode);
        void vertex(osg::Vec3* vertex);
        void combine(osg::Vec3* vertex,void* vertex_data[4],GLfloat weight[4]);
        void end();
        void error(GLenum errorCode);


        static void CALLBACK beginCallback(GLenum which, void* userData);
        static void CALLBACK vertexCallback(GLvoid *data, void* userData);
        static void CALLBACK combineCallback(GLdouble coords[3], void* vertex_data[4],
                              GLfloat weight[4], void** outData,
                              void* useData);
        static void CALLBACK endCallback(void* userData);
        static void CALLBACK errorCallback(GLenum errorCode, void* userData);


        struct Vec3d
        {
            double _v[3];
        };


        struct NewVertex
        {

            NewVertex():
                _vpos(0),
                _f1(0),
                _v1(0),
                _f2(0),
                _v2(0),
                _f3(0),
                _v3(0),
                _f4(0),
                _v4(0) {}

            NewVertex(const NewVertex& nv):
                _vpos(nv._vpos),
                _f1(nv._f1),
                _v1(nv._v1),
                _f2(nv._f2),
                _v2(nv._v2),
                _f3(nv._f3),
                _v3(nv._v3),
                _f4(nv._f4),
                _v4(nv._v4) {}

            NewVertex(osg::Vec3* vx,
                      float f1,osg::Vec3* v1,
                      float f2,osg::Vec3* v2,
                      float f3,osg::Vec3* v3,
                      float f4,osg::Vec3* v4):
                _vpos(vx),
                _f1(f1),
                _v1(v1),
                _f2(f2),
                _v2(v2),
                _f3(f3),
                _v3(v3),
                _f4(f4),
                _v4(v4) {}

            osg::Vec3  *_vpos; // added gwm Jan 2004 the vertex coords s.t. NewVertex can be used in a std::vector

            float       _f1;
            osg::Vec3*  _v1;

            float       _f2;
            osg::Vec3*  _v2;

            float       _f3;
            osg::Vec3*  _v3;

            float       _f4;
            osg::Vec3*  _v4;

        };

        //change NewVertexList from std::map<osg::Vec3*,NewVertex> NewVertexList;
        // because this has undefined order of insertion for new vertices.
        // which occasionally corrupted the texture mapping.
        typedef std::vector<NewVertex> NewVertexList;
        typedef std::vector<Vec3d*> Vec3dList;

        osg::GLUtesselator*  _tobj;

        PrimList        _primList;
        Vec3dList       _coordData;
        NewVertexList   _newVertexList;
        GLenum          _errorCode;

        WindingType _wtype;

        TessellationType _ttype;

        bool _boundaryOnly; // see gluTessProperty - if true: make the boundary edges only.

        unsigned int _numberVerts;

        osg::Geometry::PrimitiveSetList                _Contours;

        unsigned int _index;

        osg::Vec3 tessNormal;

        unsigned int _extraPrimitives;
};

}

#endif