gfx_opengl.hh

Go to the documentation of this file.

/*
 * LEGAL:   COPYRIGHT (C) 2004 JIM E. BROOKS
 *          THIS SOURCE CODE IS RELEASED UNDER THE TERMS
 *          OF THE GNU GENERAL PUBLIC LICENSE VERSION 2 (GPL 2).
 *****************************************************************************/

#if GFXSYS_OPENGL
#ifndef GFX_OPENGL_HH
#define GFX_OPENGL_HH 1

namespace gfx {

class GFX : public NonThreadable
{
;
    GFX( void );
    ~GFX();
public:
    CLASS_CONST uint MATRIX_ELEMS               = 16;   // OpenGL matrix is 4x4
    #define DEFAULT_PERSPECTIVE_FOV             (8.0)
    #define DEFAULT_PERSPECTIVE_FRUSTUM_NEAR    (125.0)
    #define DEFAULT_PERSPECTIVE_FRUSTUM_FAR     (100000.0)

    enum ePrim
    {
        ePrim_POINTS            = GL_POINTS,
        ePrim_LINES             = GL_LINES,
        ePrim_LINE_LOOP         = GL_LINE_LOOP,
        ePrim_TRIANGLES         = GL_TRIANGLES,
        ePrim_TRIANGLE_STRIP    = GL_TRIANGLE_STRIP,
        ePrim_QUADS             = GL_QUADS,
        ePrim_QUAD_STRIP        = GL_QUAD_STRIP,
        ePrim_POLYGON           = GL_POLYGON,
    };

    enum ePolygonMode
    {
        ePolygonMode_POINT      = GL_POINT,
        ePolygonMode_LINE       = GL_LINE,
        ePolygonMode_FILL       = GL_FILL,
        ePolygonMode_DEFAULT    = GL_FILL
    };

    enum eBlend
    {
        // source:
        eBlend_SRC_ALPHA            = GL_SRC_ALPHA,
        eBlend_SRC_COLOR            = GL_SRC_COLOR,
        eBlend_ONE_MINUS_SRC_ALPHA  = GL_ONE_MINUS_SRC_ALPHA,
        // destination:
        eBlend_DST_ALPHA            = GL_DST_ALPHA,
        eBlend_DST_COLOR            = GL_DST_COLOR,
        eBlend_ONE_MINUS_DST_ALPHA  = GL_ONE_MINUS_DST_ALPHA,
        eBlend_DST_ONE              = GL_ONE
    };

    enum eColorFormat
    {
        eColorFormat_RGBA   = GL_RGBA,
        eColorFormat_RGBA8  = GL_RGBA8,
        eColorFormat_BGRA   = GL_BGRA,
    };

    enum eDepthTest
    {
        eDepthTest_DISABLE,
        eDepthTest_ENABLE,
    };

    enum eShadeModel
    {
        eShadeModel_FLAT   = GL_FLAT,
        eShadeModel_NORMAL = GL_FLAT,
        eShadeModel_SMOOTH = GL_SMOOTH,
    };

    enum eAntialias
    {
        // Correlate to literal numbers in settings.conf:Antialias.
        eAntialias_OFF      = 0,    
        eAntialias_1        = 1,    
        eAntialias_2        = 2,
        eAntialias_3        = 3,    
        eAntialias_DEFAULT  = eAntialias_OFF,
    };

    enum eKey
    {
        eKey_ENTER      = 0xd,
        eKey_ESC        = 27,
        eKey_TAB        = 0x9,
        eKey_BACKSPACE  = 0x8,
        eKey_DELETE     = 0x7f,
        eKey_CTRL_C     = 0x3,
        eKey_CTRL_P     = 0x10,
        eKey_CTRL_S     = 0x13,
        eKey_CTRL_X     = 0x18,
        eKey_CTRL_Z     = 0x1a,
        eKey_1          = 0x31,
        eKey_PLUS       = 0x2b,
        eKey_MINUS      = 0x2d,

        // For GLUT special key handler:
        eKey_LEFT       = 0x64,
        eKey_RIGHT      = 0x66,
        eKey_UP         = 0x65,
        eKey_DOWN       = 0x67,
        eKey_HOME       = 0x6a,
        eKey_END        = 0x6b,
        eKey_F1         = 0x1,
        eKey_F2         = 0x2,
        eKey_F3         = 0x3,
        eKey_F4         = 0x4,
        eKey_F5         = 0x5,
        eKey_F6         = 0x6,
        eKey_F7         = 0x7,
        eKey_F8         = 0x8,
        eKey_F9         = 0x9,
        eKey_F10        = 0xa,
        eKey_F11        = 0xb,
        eKey_F12        = 0xc,
    };

//------------------------------------------------------------------------------
// GFX structs:

public:
    class Modes
    {
    ;
    friend class GFX;
    public:
        Modes( void );
        ~Modes();

    public:
        CLASS_CONST ePolygonMode DEFAULT_POLYGON_MODE = ePolygonMode_DEFAULT;
        CLASS_CONST bool         DEFAULT_DEPTH_MASK   = true;  // true enables writing to depth buffer
        CLASS_CONST bool         DEFAULT_DEPTH_TEST   = true;
        CLASS_CONST bool         DEFAULT_BLEND        = false;
        CLASS_CONST eBlend       DEFAULT_BLEND_SRC    = eBlend_SRC_ALPHA;
        CLASS_CONST eBlend       DEFAULT_BLEND_DST    = eBlend_ONE_MINUS_SRC_ALPHA;
        CLASS_CONST bool         DEFAULT_TEXTURE2     = false;
        CLASS_CONST bool         DEFAULT_LIGHTING     = false;
        // By default, don't explicitly override antialiasing.
        // The user may have increased antialiasing using a control panel (nvidia-settings).
        CLASS_CONST eAntialias   DEFAULT_ANTIALIAS    = eAntialias_DEFAULT;
        CLASS_CONST bool         DEFAULT_LINE_SMOOTH  = false;
        CLASS_CONST bool         DEFAULT_FOG          = false;
    private:
        // -- reminder: update SetModes() --
        ePolygonMode mPolygonMode;
        bool         mDepthMask;
        bool         mDepthTest;
        bool         mBlend;
        eBlend       mBlendSrc;
        eBlend       mBlendDst;
        bool         mTexture2;
        bool         mLighting;
        eAntialias   mAntialias;  // FSAA actually
        bool         mLineSmooth;
        bool         mFog;
        // -- reminder: update SetModes() --
    };

//------------------------------------------------------------------------------
// GFX drawing methods:

public:
    CLASS_METHOD
    void
    Begin( ePrim prim )
    {
    ASSERT2( IfReady() );
    ASSERT( msBlockNest == 0 );
    

        glBegin( prim );
    }

    CLASS_METHOD
    void
    End( void )
    {
    ASSERT2( IfReady() );
    ASSERT( msBlockNest == 1 );
    

        glEnd();
    }

    CLASS_METHOD
    void
    Begin2D( const Rect<int>& rect );

    CLASS_METHOD
    void
    End2D( void );

    CLASS_METHOD
    void
    BeginAux( void );

    CLASS_METHOD
    void
    EndAux( void );

    CLASS_METHOD
    void
    Vertex( const EyeVertex* v )
    {
    ASSERT2( IfReady() );

    #if PORTABLE_VERTEX
        glVertex3f( v->x, v->y, v->z );
    #else
        glVertex3fv( reinterpret_cast<const GLfloat*>( v ) );
    #endif
    }

    CLASS_METHOD
    void
    Vertex( const EyeVertex& v )
    {
    ASSERT2( IfReady() );

    #if PORTABLE_VERTEX
        glVertex3f( v.x, v.y, v.z );
    #else
        glVertex3fv( reinterpret_cast<const GLfloat*>( &v ) );
    #endif
    }

    CLASS_METHOD
    void
    Vertex2D( fp x, fp y )
    {
    ASSERT2( IfReady() );

        // glVertex3f() with Z=1.0 is actually used for a 2D vertex
        // in order to draw 2D vertexs over a 3D scene.
        // A particular problem is drawing 2D fonts when a 3D land polygon
        // at low altitude becomes so close that it would obscure the 2D fonts.
        glVertex3f( x, y, 1.0 );
    }

    CLASS_METHOD
    void
    Normal( const NormalVertex& n )
    {
    ASSERT2( IfReady() );

        glNormal3f( n.x, n.y, n.z );
    }

    CLASS_METHOD
    void
    Color( const RGBA rgba )
    {
    ASSERT2( IfReady() );

        glColor4ubv( const_cast<uint8*>( rgba.Get() ) );
    }

    CLASS_METHOD
    void
    DrawRect2D( const Rect<int>& rect, const RGBA rgba );

//------------------------------------------------------------------------------
// GFX modes:

private:
    // Enable or disable an OpenGL mode if necessary, else leave unchanged.
    // Returns previous mode and updates variable to remember next mode.
    CLASS_METHOD bool
    Enable( const bool enable, bool& var, const GLenum mode )
    {
    ASSERT2( IfReady() );

        const bool prev = var;

        if ( enable and (not var) )
        {
            glEnable( mode );
            var = enable;
        }
        else if ( (not enable) and var )
        {
            glDisable( mode );
            var = enable;
        }

        return prev;

    
    }

public:
    CLASS_METHOD Modes
    GetModes( void )
    {
        return msModes;
    }

    CLASS_METHOD void
    SetModes( const Modes& modes );

    CLASS_METHOD
    void
    SetPolygonMode( const ePolygonMode polygonMode );

    CLASS_METHOD bool
    EnableDepthMask( const bool enable );

    CLASS_METHOD bool
    EnableDepthTest( const bool enable );

    CLASS_METHOD bool
    EnableTexture2( const bool enable )
    {
        return Enable( enable, msModes.mTexture2, GL_TEXTURE_2D );
    }

    CLASS_METHOD
    ePrim
    Polygon2Prim( const uint vertexCnt )
    {
    ASSERT2( IfReady() );
    ASSERT( vertexCnt < sizeof(msPrimTable) );

        return msPrimTable[vertexCnt];
    }

    CLASS_METHOD
    void
    SetShadeModel( const eShadeModel shade );

    CLASS_METHOD
    void
    SetLineWidth( const fp lineWidth, const bool lineSmooth = false );

    CLASS_METHOD
    void
    SetPointSize( const fp pointSize );

//------------------------------------------------------------------------------
// GFX lighting:

public:
    class Light
    {
    friend class GFX;
    
    public:
        enum eLightId
        {
            eLightId_0 = GL_LIGHT0,
            eLightId_1 = GL_LIGHT1,
            eLightId_2 = GL_LIGHT2,
            eLightId_3 = GL_LIGHT3,
            eLightId_4 = GL_LIGHT4,
            eLightId_6 = GL_LIGHT6,
            eLightId_7 = GL_LIGHT7
        };

    public:
                Light( const eLightId lightId = eLightId_0 );
        void    SetAmbient( const RGBA color );
        void    SetDiffuse( const RGBA color );
        void    SetSpecular( const RGBA color );
        void    SetPosition( const WorldVertex& position, const fp w );
        pair<WorldVertex,fp> GetPosition( void ) const;

    private:
        eLightId mId;
        bool mSetAmbient;  TinyArray<4,GLfloat> mAmbient;  // mSet* become true if Set*() were called (valid flags)
        bool mSetDiffuse;  TinyArray<4,GLfloat> mDiffuse;
        bool mSetSpecular; TinyArray<4,GLfloat> mSpecular;
        bool mSetPosition; TinyArray<4,GLfloat> mPosition;  // (x,y,z,w)
    };

    CLASS_METHOD
    void
    EnableLighting( const bool enable = true )
    {
        if ( enable )
            glEnable( GL_LIGHTING );
        else
            glDisable( GL_LIGHTING );

        msModes.mLighting = enable;
    }

    CLASS_METHOD
    bool IfLighting( void )
    {
        return msModes.mLighting;
    }

    CLASS_METHOD
    void
    SetLight( Light& light, const bool enable = true );

//------------------------------------------------------------------------------
// GFX materials:

    class Material
    {
    friend class GFX;
    
    public:
                    Material( void );
        void        SetAmbient( const RGBA rgba );
        void        SetDiffuse( const RGBA rgba );
        void        SetSpecular( const RGBA rgba );
        void        SetShininess( const fp shininess );
        friend inline bool operator<( const Material& a, const Material& b )
        {
            RETURN_LT_TRUE_GT_FALSE( int(a.mSetAmbient),   int(b.mSetAmbient) )
            RETURN_LT_TRUE_GT_FALSE( int(a.mSetDiffuse),   int(b.mSetDiffuse) )
            RETURN_LT_TRUE_GT_FALSE( int(a.mSetSpecular),  int(b.mSetSpecular) )
            RETURN_LT_TRUE_GT_FALSE( int(a.mSetShininess), int(b.mSetShininess) )
            RETURN_LT_TRUE_GT_FALSE( a.mAmbient,   b.mAmbient )
            RETURN_LT_TRUE_GT_FALSE( a.mDiffuse,   b.mDiffuse )
            RETURN_LT_TRUE_GT_FALSE( a.mSpecular,  b.mSpecular )
            RETURN_LT_TRUE_GT_FALSE( a.mShininess, b.mShininess )
            return false;
        }

    private:
        bool mSetAmbient;   TinyArray<4,GLfloat> mAmbient;
        bool mSetDiffuse;   TinyArray<4,GLfloat> mDiffuse;
        bool mSetSpecular;  TinyArray<4,GLfloat> mSpecular;
        bool mSetShininess; TinyArray<1,GLfloat> mShininess;
    };

    CLASS_METHOD
    void
    SetMaterial( Material& material );

//------------------------------------------------------------------------------
// GFX texture matrix:

    CLASS_METHOD
    void
    IdentityTextureMatrix( void );


    CLASS_METHOD
    void
    SetTextureMatrix( const Matrix& m );

    CLASS_METHOD
    void
    SetTextureMatrix( const fp[16] );

    CLASS_METHOD
    void
    GetTextureMatrix( fp[16] /*OUT*/ );

    CLASS_METHOD
    void
    TranslateTextureMatrix( fp x, fp y, fp z );

    CLASS_METHOD
    void
    RotateTextureMatrix( const Degree deg, fp x, fp y, fp z );

//------------------------------------------------------------------------------
// GFX translucent:

    CLASS_METHOD
    void
    EnableTranslucent( void );

    CLASS_METHOD
    void
    DisableTranslucent( void );

//------------------------------------------------------------------------------
// GFX fragment blending:

    CLASS_METHOD
    void
    EnableBlend( const eBlend src = eBlend_SRC_ALPHA,
                 const eBlend dst = eBlend_ONE_MINUS_SRC_ALPHA,
                 const eDepthTest depthTest = eDepthTest_ENABLE );

    CLASS_METHOD
    void
    DisableBlend( void );

    CLASS_METHOD
    void
    SetBlendFunc( const eBlend src, const eBlend dst )
    {
        if ( (src != msModes.mBlendSrc)
          || (dst != msModes.mBlendDst) )
        {
            msModes.mBlendSrc = src;
            msModes.mBlendDst = dst;
            glBlendFunc( src, dst );
        }
    }

//------------------------------------------------------------------------------
// GFX image blending:

    CLASS_METHOD
    void
    BeginBlendImage( const uint width, const eColorFormat colorFormat = eColorFormat_RGBA );

    CLASS_METHOD
    void
    BlendImage( const void* img, const uint imgLen );

    CLASS_METHOD
    void
    GetBlendImage( void* img/*OUT*/, const uint imgLen );

    CLASS_METHOD
    void
    EndBlendImage( void );

//------------------------------------------------------------------------------
// GFX antialiasing:

    CLASS_METHOD void
    EnableAntialias( const eAntialias antialias );

//------------------------------------------------------------------------------
// GFX fog:

    CLASS_METHOD bool
    EnableFog( const bool enable );

    CLASS_METHOD bool
    EnableFog( const bool enable, const float fogDensity, const RGBA fogRgba );

    CLASS_METHOD
    void
    SetFogColor( const RGBA rgba );

    CLASS_METHOD
    RGBA
    GetFogColor( void );

    CLASS_METHOD
    void
    SetFogDensity( const fp fogDensity );

    CLASS_METHOD
    void
    SetBaseFogDensity( const fp baseFogDensity );

    CLASS_METHOD
    fp
    GetFogDensity( void );

//------------------------------------------------------------------------------
// GFX viewport/perspective/frustum:

    struct Perspective
    {
        Perspective( void );
        Perspective( Degree fov, fp frustumNear, fp frustumFar );

        Degree  mFov;
        fp      mFrustumNear;
        fp      mFrustumFar;
    };

    CLASS_METHOD void
    SetViewport( const Rect<int>& rect, bool force = false );

    CLASS_METHOD void
    ClearViewport( void );

    CLASS_METHOD Rect<int>
    GetViewport( void );

    CLASS_METHOD WidthHeight<int>
    GetWindow( void );

    CLASS_METHOD Rect<int>
    GetWindowRect( void );

    CLASS_METHOD void
    SetPerspective( const Perspective& perspective );

    CLASS_METHOD void
    SetPerspective( const Perspective& perspective, const WidthHeight<int>& widthHeight );

    CLASS_METHOD Perspective
    GetPerspective( void )
    {
        return msPerspective;
    }

    CLASS_METHOD fp
    GetPerspectiveFov( void )
    {
        return msPerspective.mFov;
    }

    CLASS_METHOD Vector2 Project( const EyeVertex& ev );

    CLASS_METHOD bool
    IfVisible( const Vector3& v );

    CLASS_METHOD bool
    IfVisibleSphere( const Vector3& v, const fp radius );

private:
    CLASS_METHOD void
    ComputeFrustum( void );

//------------------------------------------------------------------------------
// GFX events and error-checking:

public:
    CLASS_METHOD
    void
    PostRedisplay( void )
    {
    ASSERT2( IfReady() );

        glutPostRedisplay();
    }

    CLASS_METHOD
    void
    ClearError( void );

    CLASS_METHOD
    void
    CheckError( const string funcName = string(), bool dumpcore = false );

//------------------------------------------------------------------------------
// GFX timer:

    CLASS_METHOD Milliseconds GetTick( void );
    CLASS_METHOD Milliseconds GetTickDelta( void );
    CLASS_METHOD Milliseconds GetTickFreq( void );
    CLASS_METHOD void SetTickFreq( const Milliseconds freq );

//------------------------------------------------------------------------------
// GFX misc methods:

    CLASS_METHOD
    void
    SetBackgroundColor( const RGBA rgba );

//------------------------------------------------------------------------------
// GFX initialization:

    CLASS_METHOD void Init( int argc, char** argv );

    CLASS_METHOD void Start( void );

    CLASS_METHOD bool IfReady( void ) { return msReady; }

//------------------------------------------------------------------------------
// private methods
private:

    CLASS_METHOD void Cmdargs( int argc, char** argv );

    CLASS_METHOD void CheckCapabilities( void );

    CLASS_METHOD void ConfigureSettingsBeforeReady( void );

    CLASS_METHOD void ConfigureSettingsAfterReady( void );

    CLASS_METHOD void Idle( void );

    CLASS_METHOD void Reshape( int w, int h );

    CLASS_METHOD void Display( void );

    CLASS_METHOD void Timer( int unused );

    CLASS_METHOD void MouseButtonHandler( int button, int state, int x, int y );

    CLASS_METHOD void MouseMotionPassiveHandler( int x, int y );

    CLASS_METHOD void MouseMotionHandler( int x, int y );

    CLASS_METHOD void ResetModelViewMatrix( void );

    CLASS_METHOD void UpdatePerspective( void );

    CLASS_METHOD fp PerspectiveAngle( const fp size, const fp dist );

//------------------------------------------------------------------------------
// GFX system state:
private:
    CLASS_VAR bool              msReady;
    CLASS_VAR WidthHeight<int>  msWindow;  
    CLASS_VAR Rect<int>         msViewport;
    CLASS_VAR Perspective       msPerspective;
    CLASS_VAR fp                msFrustum[6][4];  
    CLASS_VAR GLfloat           msProjectionMatrix[GFX::MATRIX_ELEMS];
    CLASS_VAR Milliseconds      msTick;         
    CLASS_VAR Milliseconds      msTickFreq;     
    CLASS_CONST uint            DEFAULT_TICK_FREQ_MILLISEC = 20;

//------------------------------------------------------------------------------
// GFX drawing state:
private:
    CLASS_VAR Modes         msModes;
    CLASS_VAR Modes         msModesSaved2D;
    CLASS_VAR GLint         msIfAuxBuffer;  // if OpenGL auxillary buffer available
    CLASS_CONST ePrim       msPrimTable[5];  // limited to triangles and quads (3,4)
    CLASS_VAR RGBA          msFogColor;
    CLASS_VAR GLint         msFogMode;
    CLASS_VAR fp            msFogDensity;
    CLASS_VAR fp            msBaseFogDensity;
    CLASS_VAR int           msBlockNest;  // prevent nesting glBegin()/glEnd()
#if DEBUG
    CLASS_VAR int           msAuxBlockNest;
    CLASS_VAR bool          msComputedFrustum;
#endif
};

//------------------------------------------------------------------------------
// Minimum OpenGL requirements.  OpenGL 1.4 provides required glWindowPos().
#if OLD_OPENGL
    const fp MIN_OPENGL_VERSION_FLOAT = 1.2;  // stumble forth
#else
    #ifndef GL_VERSION_1_4  // equal or at least
    #error "Below minimum requirement: OpenGL 1.4"
    #endif
    const fp MIN_OPENGL_VERSION_FLOAT = 1.4;
#endif
//------------------------------------------------------------------------------

} // namespace gfx

#endif // GFX_OPENGL_HH
#endif // GFXSYS_OPENGL

Palomino 3D Engine documents generated by doxygen 1.5.3 on Fri Nov 23 11:26:11 2007