RE/RE_Tess.h

Go to the documentation of this file.

#ifndef CELLBE
//
//  support general tesselation of polygons
//

#ifdef MBSD_COCOA
#   include <OpenGL/glu.h>
#else
#   include <GL/glu.h>
#endif

#ifndef CALLBACK
    #define CALLBACK
#endif

//
//  define max texture coordindate dimensionality
//
#define RE_TEXTURE_DIM  2

//
//  class to hold tesselated vertex info 
//
struct  RE_TessVertex {
    float       v[3];           // the vertex
    float       n[3];           // its normal
    float       c[4];           // its color;
    float       t[4];           // its texture coords
    float       a[4];           // its attrib data

    //  there's no point in making these bit fields, 
    //  since structure alignment, will pad it to 
    //  the next mod 4 address anyway
    char        nSet;           // is normal valid
    char        cCount;         // is color set, and w/ 3 or 4 values
    char        tCount;         // are texture coords set, how many values
    char        aCount;         // are attrib data set, how many values
    int         aLoc;           // attrib data location

    //  clear all the flags to the default state
    void        clear() {
        nSet = GL_FALSE;
        cCount = 0;             // not set
        tCount = 0;
        aCount = 0;
        aLoc = -1;
    }
};

//
//  RE_TessCommand contains an operator and data
//
struct  RE_TessCommand {
    enum TessOperator { begin, vertex, end };

    TessOperator        op;
    int                 data;
};


//
//  The RE_Tesselator class manages an array of RE_TessVertex's
//  Color, Normal and Texture data are put into the current
//  vertex, if we are rendering a concave polygon.
//
//  RE_TessVertexBuffer is a Singleton Design Pattern
//
class   RE_Tesselator {
public:
    static RE_Tesselator        *instance();
    static void                  deReference();

    void        init() { 
                    _currentVert = 0;
                    _currentCmd = 0;
                    clearVert();
                }

    void        buffer();
    void        immediate();

    void        normal( const float n[] ) {
                    currentVert()->nSet = GL_TRUE;
                    currentVert()->n[0] = n[0];
                    currentVert()->n[1] = n[1];
                    currentVert()->n[2] = n[2];
                }
    void        texture1( const float t[] ) {
                    currentVert()->tCount = 1;
                    currentVert()->t[0] = t[0];
                }
    void        texture2( const float t[] ) {
                    currentVert()->tCount = 2;
                    currentVert()->t[0] = t[0];
                    currentVert()->t[1] = t[1];
                }
    void        texture3( const float t[] ) {
#if     RE_TEXTURE_DIM >= 3
                    currentVert()->tCount = 3;
                    currentVert()->t[0] = t[0];
                    currentVert()->t[1] = t[1];
                    currentVert()->t[2] = t[2];
#else   // use 2D
                    texture2( t );
#endif  // RE_TEXTURE_DIM >= 3
                }
    void        texture4( const float t[] ) {
#if     RE_TEXTURE_DIM >= 4
                    currentVert()->tCount = 4;
                    currentVert()->t[0] = t[0];
                    currentVert()->t[1] = t[1];
                    currentVert()->t[2] = t[2];
                    currentVert()->t[3] = t[3];
#else   // use 3D (texture3 may actually use texture2)
                    texture3( t );
#endif  // RE_TEXTURE_DIM >= 4
                }
    void        attrib1( unsigned int loc, const float a[] ) {
                    currentVert()->aLoc = loc;
                    currentVert()->aCount = 1;
                    currentVert()->a[0] = a[0];
                }
    void        attrib2( unsigned int loc, const float a[] ) {
                    currentVert()->aLoc = loc;
                    currentVert()->aCount = 2;
                    currentVert()->a[0] = a[0];
                    currentVert()->a[1] = a[1];
                }
    void        attrib3( unsigned int loc, const float a[] ) {
                    currentVert()->aLoc = loc;
                    currentVert()->aCount = 3;
                    currentVert()->a[0] = a[0];
                    currentVert()->a[1] = a[1];
                    currentVert()->a[2] = a[2];
                }
    void        attrib4( unsigned int loc, const float a[] ) {
                    currentVert()->aLoc = loc;
                    currentVert()->aCount = 4;
                    currentVert()->a[0] = a[0];
                    currentVert()->a[1] = a[1];
                    currentVert()->a[2] = a[2];
                    currentVert()->a[3] = a[3];
                }
    void        color3( const float c[] ) {
                    currentVert()->cCount = 3;
                    currentVert()->c[0] = c[0];
                    currentVert()->c[1] = c[1];
                    currentVert()->c[2] = c[2];
                }
    void        color4( const float c[] ) {
                    currentVert()->cCount = 4;
                    currentVert()->c[0] = c[0];
                    currentVert()->c[1] = c[1];
                    currentVert()->c[2] = c[2];
                    currentVert()->c[3] = c[3];
                }
    void        vertex( const float v[] );

    void        tesselate();
    void        interp();

    ~RE_Tesselator();
protected:
    RE_Tesselator();

    RE_TessVertex       *currentVert() { return &_vbuf[_currentVert]; }

    int         degenerateShape();

    //  tesselator callback functions
    static      void    CALLBACK beginCB( GLenum );
    static      void    CALLBACK vertexCB( void *data );
    static      void    CALLBACK endCB();

    void        doVert( int index );

private:
    static      RE_Tesselator   *_instance;

    GLUtriangulatorObj  *_gluTess;
    int                 _immediate;

    //
    //  expandable buffer of vertex's
    //
    RE_TessVertex       *_vbuf;
    int                 _currentVert;
    int                 _vbufSize;

    void                clearVert() { currentVert()->clear(); }
    void                nextVert();

    //
    //  expandable buffer of commands
    //
    RE_TessCommand      *_cmdBuf;
    int                 _currentCmd;
    int                 _cmdBufSize;

    void                nextCmd();
};

#endif // CELLBE

---