lilith3dgl.h

/*--License:
        Lilith 3D Engine
        Copyright Lee Thomason (Grinning Lizard Software) 2002-2007
        www.grinninglizard.com/lilith

        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 2
        of the License, or (at your option) any later version.

        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., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

        The full text of the license can be found in license.txt
*/
#ifndef LILITH3D_OPENGL_INCLUDED
#define LILITH3D_OPENGL_INCLUDED

#include "glew.h"
//#include <GL/glu.h>
#include "SDL.h"
#include "../grinliz/glvector.h"
#include "../grinliz/glcolor.h"


#ifdef LILITH_GL_HERE
        #define LILITHEXTERN
#else
        #define LILITHEXTERN extern
#endif

namespace lilith3d
{

// Access to SDL_image
typedef SDL_Surface* (SDLCALL * PFN_IMG_LOAD) (const char *file);
LILITHEXTERN PFN_IMG_LOAD libIMG_Load;

// Initialize libraries.
bool InitLilith3D();

class Texture;
struct Shader;

struct Vertex
{
        grinliz::Vector3F       pos;
        grinliz::Vector3F       normal;
        grinliz::Vector2F       tex;

        U32 HashCode() const
        {
                // Need a low res hash code due to rounding and bit differences from
                // floating point compution. Also, the Compare has an epsilon.
                // And the normal may not matter. Grr.
                return   grinliz::LRintf( pos.x ) + 10*grinliz::LRintf( pos.y ) + 100*grinliz::LRintf(pos.z)
                           + 1000*grinliz::LRintf( tex.x ) + 10000*grinliz::LRintf( tex.y );
        }

        inline int Compare( const Vertex& rhs, const float epsilon ) const {
                int c = pos.Compare( rhs.pos, epsilon );
                if ( c ) return c;
                c = normal.Compare( rhs.normal, epsilon );
                if ( c ) return c;
                return tex.Compare( rhs.tex, epsilon );
        }
        inline int CompareWONormal( const Vertex& rhs, const float epsilon ) const {
                int c = pos.Compare( rhs.pos, epsilon );
                if ( c ) return c;
                return tex.Compare( rhs.tex, epsilon );
        }

        // set the OpenGL vertex, normal, and texture pointers.
        static void SetPointers( const Vertex* v );
};


struct L3VertexState
{
        L3VertexState()
                :       color3Pointer( 0 ),
                        color4Pointer( 0 ),
                        color4BytePointer( 0 ),
                        vPointer( 0 ),
                        vertexPointer( 0 ),
                        vertexPointerStride( 0 ),
                        texturePointer( 0 ),
                        texturePointerStride( 0 ),
                        normalPointer( 0 ),
                        normalPointerStride( 0 ),
                        indexPointer( 0 )
        {}

        const Vertex                            *vPointer;
        const grinliz::Vector3F         *vertexPointer;
        unsigned                                        vertexPointerStride;
        const grinliz::Vector2F         *texturePointer;
        unsigned                                        texturePointerStride;
        const grinliz::Vector3F         *normalPointer;
        unsigned                                        normalPointerStride;
        const int                                       *indexPointer;

        const grinliz::Color3F  *color3Pointer;
        const grinliz::Color4F  *color4Pointer;
        const grinliz::Color4U8 *color4BytePointer;
};

struct L3State
{
        L3State() 
                :       blend( false ),
                        linear( false ),
                        clamp( false ),
                        depthWrite( true ),
                        depthCheck( true ),
                        lighting( true ),
                        texture( 0 ),
                        alphaTest( 0.0f ),
                        shader( 0 )
        {}

        bool                    blend;                  // turn on blending (alpha)
        bool                    linear;                 // use linear texture hint (instead of mipmap)
        bool                    clamp;                  // clamp instead of repeat texture
        bool                    depthWrite;             // set to false to disable writing to the depth buffer
        bool                    depthCheck;             // check the depth buffer before writing a texel
        bool                    lighting;               // turn on opengl lights

        const Texture *texture;
        
        float alphaTest;
        const Shader* shader;
};

class StateManager
{
        friend class LightingStack;
        friend class Texture2DStack;
        friend class AlphaTestStack;

  public:
        static void Reset();

        static void Enable( const L3State& state );
        static void Enable( const L3VertexState& state );
        static void Enable( const L3State& state, const L3VertexState& vState )
        {
                Enable( state );
                Enable( vState );
        }

        static void ChangeTexture( const Texture* tex );
        static void SetLightProperties( const grinliz::Vector3F& vector, 
                                                                        const grinliz::Color4F& ambient, 
                                                                        const grinliz::Color4F& diffuse );

        static void Texture2D( bool enable ) {
                if ( enable && !flags.IsSet( TEXTURE_2D ) ) {
                        glEnable( GL_TEXTURE_2D );
                        flags.Set( TEXTURE_2D );
                }
                else if ( !enable && flags.IsSet( TEXTURE_2D ) ) {
                        glDisable( GL_TEXTURE_2D );
                        flags.Clear( TEXTURE_2D );
                }
        }

        static void AlphaTest( bool enable, float v ) {
                if ( enable && !flags.IsSet( ALPHA_TEST ) ) {
                        glEnable( GL_ALPHA_TEST );
                        flags.Set( ALPHA_TEST );
                        glAlphaFunc ( GL_GREATER, v ) ;
                }
                else if ( !enable && flags.IsSet( ALPHA_TEST ) ) {
                        glDisable( GL_ALPHA_TEST );
                        flags.Clear( ALPHA_TEST );
                }
        }


        static void DepthWrite( bool enable ) {
                if ( enable && !flags.IsSet( DEPTHWRITE ) ) {
                        glDepthMask( GL_TRUE );
                        flags.Set( DEPTHWRITE );
                }
                else if ( !enable && flags.IsSet( DEPTHWRITE ) ) {
                        glDepthMask( GL_FALSE );
                        flags.Clear( DEPTHWRITE );
                }
        }

        static void Blend( bool enable ) {
                if ( enable && !flags.IsSet( BLEND ) ) {
                        glEnable( GL_BLEND );
                        flags.Set( BLEND );
                }
                else if ( !enable && flags.IsSet( BLEND ) ) {
                        glDisable( GL_BLEND );
                        flags.Clear( BLEND );
                }
        }

        static void ErrorCheck() {
                #ifdef DEBUG
                GLenum result = glGetError();
                if ( result != GL_NO_ERROR )
                        GLOUTPUT(( "GL Error 0x%x\n", result )); 
                GLASSERT( result == GL_NO_ERROR );
                #endif
        }

        static U32 Flags()      { return flags.ToU32(); }

        enum {
                // Vertex array support
                VERTEX_ARRAY                    = 0x00001,
                TEXTURE_ARRAY                   = 0x00002,
                COLOR_ARRAY                             = 0x00004,
                NORMAL_ARRAY                    = 0x00020,
                INDEX_ARRAY                             = 0x00040,

                // Texture
                TEXTURE_2D                              = 0x00100,

                // General modes
                BLEND                                   = 0x01000,
                DEPTHWRITE                              = 0x02000,
                DEPTH_TEST                              = 0x04000,
                ALPHA_TEST                              = 0x08000,
                LIGHTING                                = 0x10000,

        };

  private:
        static void Lighting( bool enable ) {
                GLASSERT( flags.IsSet( LIGHTING ) ? glIsEnabled( GL_LIGHTING ) : !glIsEnabled( GL_LIGHTING ) );
                if ( enable && !flags.IsSet( LIGHTING ) ) {
                        glEnable( GL_LIGHTING );
                        flags.Set( LIGHTING );
                }
                else if ( !enable && flags.IsSet( LIGHTING ) ) {
                        glDisable( GL_LIGHTING );
                        flags.Clear( LIGHTING );
                }
        }

        static const Texture* texture;

        static grinliz::Flag< U32 > flags;
};


class LightingStack
{
  public:
        LightingStack( bool enable ) {
                wasEnabled = StateManager::flags.IsSet( StateManager::LIGHTING );
                StateManager::Lighting( enable );
        }
        ~LightingStack() {
                StateManager::Lighting( wasEnabled != 0 );
        }

  private:
        U32 wasEnabled;
};


class AlphaTestStack
{
  public:
        AlphaTestStack( bool enable, float v ) {
                wasEnabled = StateManager::flags.IsSet( StateManager::ALPHA_TEST );
                StateManager::AlphaTest( enable, v );
        }
        ~AlphaTestStack() {
                StateManager::AlphaTest( wasEnabled != 0, 0.5f );
        }

  private:
        U32 wasEnabled;
};


class Texture2DStack
{
  public:
        Texture2DStack( bool enable ) {
                wasEnabled = StateManager::flags.IsSet( StateManager::TEXTURE_2D );
                StateManager::Texture2D( enable );
        }
        ~Texture2DStack() {
                StateManager::Texture2D( wasEnabled != 0 );
        }

  private:
        U32 wasEnabled;
};


class FogStack
{
  public:
        FogStack( bool enable ) {
                wasEnabled = glIsEnabled( GL_FOG );
                if ( enable && !wasEnabled )
                        glEnable( GL_FOG );
                else if ( !enable && wasEnabled )
                        glDisable( GL_FOG );
        }
        ~FogStack() {
                if ( wasEnabled ) glEnable( GL_FOG );
                else glDisable( GL_FOG );
        }

  private:
        GLboolean wasEnabled;
};


void L3glInitFrame();
void L3glDestroy();

// SDL pixel functions.
Uint32 GetPixel(SDL_Surface *surface, int x, int y);
void PutPixel(SDL_Surface *surface, int x, int y, Uint32 pixel);
/*
inline Uint32 GetPixel32( SDL_Surface *surface, int x, Uint8* row )
{
        GLASSERT( surface->format->BytesPerPixel == 4 );
    Uint8 *p = row + (x<<2);
    return *(Uint32 *)p;
}


inline Uint32 GetPixel24(SDL_Surface *surface, int x, Uint8* row )
{
        GLASSERT( surface->format->BytesPerPixel == 3 );
    Uint8 *p = row + x*3;

    #if (SDL_BYTEORDER == SDL_BIG_ENDIAN)
                return p[0] << 16 | p[1] << 8 | p[2];
    #else
        return p[0] | p[1] << 8 | p[2] << 16;
        #endif
}
*/

// SDL OpenGL Surface functions.
void InvertGlSurface( SDL_Surface* surface );
void SurfaceCopyAndInvert( SDL_Surface* target, SDL_Surface* source );
void SurfaceCopyInvertAndReduce( SDL_Surface* target, SDL_Surface* source, int reduce );



struct VertexEqual
{
        bool operator()(const Vertex& s1, const Vertex& s2) const
        {
                const float EPS = 0.000002f;    
                return s1.Compare( s2, EPS ) == 0;
        }
};

struct VertexEqualWONormal
{
        bool operator()(const Vertex& s1, const Vertex& s2) const
        {
                const float EPS = 0.000002f;    
                return s1.CompareWONormal( s2, EPS ) == 0;
        }
};

};

#endif

---