gzBasicTypes.h

Go to the documentation of this file.

//*****************************************************************************
// File         : gzBasictypes.h
// Module       : gzBase
// Description  : Class definition of basic types
// Author       : Anders Modén      
// Product      : GizmoBase 2.1.1
//      
// Copyright © 2003- Saab Training Systems AB, Sweden
//          
// NOTE:    GizmoBase is a platform abstraction utility layer for C++. It contains 
//          design patterns and C++ solutions for the advanced programmer.
//
//
// Revision History...                          
//                                  
// Who  Date    Description                     
//                                  
// AMO  980819  Created file    
//
//******************************************************************************

#ifndef __GZ_BASIC_TYPES_H__
#define __GZ_BASIC_TYPES_H__

#include "memory.h"
#include "limits.h"
#include "float.h"

// ------------------------- Detect Win32 environment ----------------------------------------------

#if defined WIN32 && !(defined GZ_WIN32 || defined GZ_WINCE || defined GZ_PPC_2002)
    #define GZ_WIN32
#endif


// ------------------ Check to see that a valid platform is defined ---------------------------------

#if !defined GZ_WIN32 && !defined GZ_MAC && !defined GZ_LINUX && !defined GZ_SGI && !defined GZ_WINCE
#error "You need to define your platform (GZ_WIN32,GZ_MAC,GZ_LINUX,GZ_SGI,GZ_WINCE)"
#endif


// --------------------------- Platform settings ----------------------------------------------------

#if defined GZ_WIN32  // ---------------- WinNT , 2000, XP  ---------------

    // Disable warning about proper C++
    #pragma warning( disable : 4290 )
    #pragma warning( disable : 4786 )
    #if _MSC_VER > 1200
        #pragma warning(disable : 4244) 
        #pragma warning(disable : 4996) 
    #endif



    // Definitions of WINNT as minimal level
    #if !defined _WIN32_WINNT | _WIN32_WINNT<0x0500
        #undef _WIN32_WINNT
        #define _WIN32_WINNT 0x0500
    #endif

    #define GZ_LIB_EXT_SEP_D    "_d"
    #define GZ_LIB_EXT_SEP_DP   "_dp"
    #define GZ_LIB_PREFIX       

    #define GZ_ADVANCED_MEM
    #define GZ_NO_EXCEPTIONS 0  // Use c++ exceptions
    #include <windows.h>

    #define LL(x) x
    #define GZ_CALLBACK     __stdcall
    #define GZ_CALLBACK_C   __cdecl
    #define GZ_64_BITS

    #ifndef GZ_PLATFORM
        #define GZ_PLATFORM "win32"
    #endif

    #define GZ_WINDOWS  // Common for all WINDOWS based platforms

#endif

#if defined GZ_PPC_2002         // ---------------- PPC 2002 ---------------
    #define GZ_NO_EXCEPTIONS 1  // Dont' use c++ exceptions
    #include <windows.h>
    #define LL(x) x

    #define GZ_LIB_EXT_SEP_D    "_d"
    #define GZ_LIB_EXT_SEP_DP   "_dp"
    #define GZ_LIB_PREFIX       

    #define GZ_CALLBACK  __stdcall
    #define GZ_CALLBACK_C   __cdecl

    #ifndef GZ_PLATFORM
        #define GZ_PLATFORM "ppc2002"
    #endif

    #define GZ_WINDOWS  // Common for all WINDOWS based platforms

#endif

#ifdef GZ_WINCE

/*
    // Disable warning about proper C++
    #pragma warning( disable : 4290 )
    #pragma warning( disable : 4786 )
*/
    // Definitions of WINNT as minimal level
    #if !defined _WIN32_WINNT | _WIN32_WINNT<0x0400
        #define _WIN32_WINNT 0x0400
    #endif

    #define GZ_LIB_EXT_SEP_D    "_d"
    #define GZ_LIB_EXT_SEP_DP   "_dp"
    #define GZ_LIB_PREFIX       

    #define GZ_ADVANCED_MEM
    #define GZ_NO_EXCEPTIONS 0  // Use c++ exceptions
    #include <windows.h>

    #define LL(x) x
    #define GZ_CALLBACK     __stdcall
    #define GZ_CALLBACK_C   __cdecl
    //#define GZ_64_BITS

    #ifndef GZ_PLATFORM
        #define GZ_PLATFORM "wince"
    #endif

    #define GZ_WINDOWS  // Common for all WINDOWS based platforms

#endif

#ifdef GZ_SGI // --------------------- Irix 6.5 GCC ----------------

    #define GZ_ADVANCED_MEM     // GCC
    #define LL(x) (x ## ll)

    #define GZ_GLX          // GLX X11
    #define GZ_LIB_EXT_SEP_D    "-g"
    #define GZ_LIB_EXT_SEP_DP   "-dp"
    #define GZ_LIB_PREFIX       "lib"
    #define GZ_UNIX         // Unix or posix like API
    #define GZ_CALLBACK
    #define GZ_CALLBACK_C   
    #define GZ_NO_EXCEPTIONS 0  // Use c++ exceptions
    #include <ctype.h>

    #ifndef GZ_PLATFORM
        #define GZ_PLATFORM "irix"
    #endif

#endif

#if defined GZ_LINUX // --------------- Linux on I686 HW -----------------

    #define GZ_ADVANCED_MEM
    #define LL(x) (x ## ll)
    #define GZ_GLX          // GLX X11
    #define GZ_LIB_EXT_SEP_D    "-g"
    #define GZ_LIB_EXT_SEP_DP   "-dp"
    #define GZ_LIB_PREFIX       "lib"
    #define GZ_UNIX         // Unix or posix like API
    #define GZ_NO_EXCEPTIONS 0  // Use c++ exceptions
    #define GZ_CALLBACK
    #define GZ_CALLBACK_C
    #include <ctype.h>

    #ifndef GZ_PLATFORM
        #define GZ_PLATFORM "linux686"
    #endif

#endif

#ifdef GZ_MAC // ---------------------- MacOSX ---------------------------
    
    #include <Carbon/Carbon.h>
    #define GZ_ADVANCED_MEM
    #define LL(x) (x ## ll)
    #define GZ_UNIX         // Unix or posix like API
    #define GZ_LIB_EXT_SEP_D    "-g"
    #define GZ_LIB_EXT_SEP_DP   "-dp"
    #define GZ_LIB_PREFIX       "lib"

    #define GZ_CALLBACK
    #define GZ_CALLBACK_C
    #define GZ_NO_EXCEPTIONS 0  // Use c++ exceptions

    #ifndef GZ_PLATFORM
        #define GZ_PLATFORM "osx"
    #endif
    
    #define GZ_64_BITS

#endif


#if GZ_NO_EXCEPTIONS
    #define GZ_EXCEPTION(x) 
    #define GZ_EXCEPTION_ELSE(x) x
    #define GZ_NO_THROW 
    #define GZ_THROW(x) 
#else
    #define GZ_EXCEPTION(x) x
    #define GZ_EXCEPTION_ELSE(x) 
    #define GZ_NO_THROW throw()
    #define GZ_THROW(x) throw(x)
#endif

//**************** some general includes and definitions ********************

#include <stdlib.h>
#include <math.h>
#include <string.h>

#ifndef NULL
#define NULL 0
#endif

#ifndef TRUE
#define TRUE 1
#endif

#ifndef FALSE
#define FALSE 0
#endif

template <class T> inline const T & gzMax(const T& x , const T& y) { return x>y ? x : y; }

template <class T> inline const T & gzMin(const T& x , const T& y) { return x<y ? x : y; }

template <class T> inline const T & gzClamp(const T& x , const T &min=(T)-1 , const T &max=(T)1 ) { return x<max ? x>min ? x : min : max; }

template <class T> inline void gzSwap(T& a , T& b ) { T temp=a;a=b;b=temp;}

template <class T> inline const T gzSign(const T& x ) { return x>=0 ? (T)1 : (T)-1; }

//******************* basic types for gizmo ************************************


typedef unsigned char   gzBool;         
typedef unsigned int    gzBitfield;     
typedef signed char     gzByte;         
typedef char            gzChar;         
typedef unsigned char   gzUByte;        
typedef short           gzShort;        
typedef unsigned short  gzUShort;       
typedef int             gzInt;          
typedef unsigned int    gzUInt;         
typedef long            gzLong;         
typedef unsigned long   gzULong;        
typedef float           gzFloat;        
typedef double          gzDouble;       
typedef unsigned long   gzHandle;       

#if !defined GZ_USE_SHORT_WCHAR 
typedef wchar_t         gzWideChar;     
#else
typedef unsigned short  gzWideChar;     
#endif


#if defined GZ_MAC | defined GZ_LINUX | defined GZ_IRIX         // Check to see that wchar_t is compatible with Windows
#include "wchar.h"
#if (WCHAR_MAX!=0xFFFF) & !defined GZ_USE_SHORT_WCHAR   // two bytes unsigned short
    // To ensure the same compatibility with wide strings on all platforms
    //#error    You need to compile GizmoSDK with -fshort-wchar or define GZ_USE_SHORT_WCHAR
#endif
#endif

#ifdef  GZ_WINDOWS
typedef __int64             gzLongLong;
typedef unsigned __int64    gzULongLong;
#else
typedef long long           gzLongLong;     
typedef unsigned long long  gzULongLong;    
#endif

typedef void            gzVoid;             
typedef void *          gzMemPointer;       

// Temprary fix to save 64 bits error
#define gzLargeValCast(x)   ((gzULong)x)    

#if defined GZ_64_BITS  // 64 bit pointers

inline gzULongLong gzPtr2Val(const gzVoid * const x)    { return (gzULongLong)x; }
inline gzVoid * gzVal2Ptr(gzULongLong x)                { return (gzVoid *)x; }

typedef gzULongLong     gzMemSize;      
typedef gzLongLong      gzMemOffset;    

#else                   // 32 bit pointers

inline gzULong gzPtr2Val(const gzVoid * const x)        { return (gzULong)x; }
inline gzVoid * gzVal2Ptr(gzULong x)                    { return (gzVoid *)x; }

typedef gzULong         gzMemSize;      
typedef gzLong          gzMemOffset;    

#endif

#define GZ_BOOL(x)  ((x) ? TRUE : FALSE)

//************************ double or single precision compile ******************

//#define GZ_DOUBLE_PRECISION       // Enable if we want double precision for REAL types
                                    // You must use the proper libs named gzxxxx_dp.

#ifdef GZ_DOUBLE_PRECISION          // Double precision

    #define GZ_REAL GZ_DOUBLE
    typedef gzDouble gzReal;
    
    #ifdef GZ_DEBUG
        #define GZ_LIB_EXT GZ_LIB_EXT_SEP_D GZ_LIB_EXT_SEP_DP
    #else
        #define GZ_LIB_EXT GZ_LIB_EXT_SEP_DP
    #endif

    #define GZ_REAL_MAX DBL_MAX

#else                               // Single precision for all graph calls

    #define GZ_REAL GZ_FLOAT 
    typedef gzFloat gzReal;

    #ifdef GZ_DEBUG
        #define GZ_LIB_EXT GZ_LIB_EXT_SEP_D
    #else
        #define GZ_LIB_EXT ""
    #endif

    #define GZ_REAL_MAX FLT_MAX

#endif

//************************** math constants ************************************

const gzDouble      GZ_PI=3.14159265358979323846264338;
const gzDouble      GZ_2PI=GZ_PI*2;
const gzDouble      GZ_PI_HALF=GZ_PI/2;
const gzDouble      GZ_PI_QUARTER=GZ_PI/4;

const gzDouble      GZ_INV_PI=1.0/GZ_PI;
const gzDouble      GZ_INV_2PI=1.0/GZ_2PI;
const gzDouble      GZ_INV_PI_HALF=1.0/GZ_PI_HALF;
const gzDouble      GZ_INV_PI_QUARTER=1.0/GZ_PI_QUARTER;

const gzFloat       GZ_INV_255=1.0f/255.0f;

const gzFloat       GZ_FLOAT_ONE=1.0f;
const gzFloat       GZ_FLOAT_ZERO=0.0f;

const gzDouble      GZ_DOUBLE_ONE=1.0;
const gzDouble      GZ_DOUBLE_ZERO=0.0;

const gzReal        GZ_REAL_ONE=1.0f;
const gzReal        GZ_REAL_ZERO=0.0f;

const gzDouble      GZ_DEG2RAD=0.017453292519943295769236907666667;
const gzDouble      GZ_MILS2RAD=9.8174770424681038701957605625011e-4;
const gzDouble      GZ_RAD2DEG=57.295779513082320876798154873916;
const gzDouble      GZ_RAD2MILS=1018.5916357881301489208560866473;

//************************* clamping class utilites ******************************

class gzClampd
{
public:
    gzClampd(const gzDouble &d=0) {m_val=gzMax(gzMin(d,GZ_DOUBLE_ONE),GZ_DOUBLE_ZERO);}

    const gzClampd & operator=(const gzDouble &right)
    {
        m_val=gzMax(gzMin(right,GZ_DOUBLE_ONE),GZ_DOUBLE_ZERO);

        return *this;
    }

    operator const gzDouble &() const { return m_val; }

private:
    gzDouble m_val;
};

class gzClampf
{
public:
    gzClampf(const gzFloat &d=0) {m_val=gzMax(gzMin(d,GZ_FLOAT_ONE),GZ_FLOAT_ZERO);}

    const gzClampf & operator=(const gzFloat &right)
    {
        m_val=gzMax(gzMin(right,GZ_FLOAT_ONE),GZ_FLOAT_ZERO);

        return *this;
    }

    operator const gzFloat &() const { return m_val; }

private:
    gzFloat m_val;
};

class gzClampr
{
public:
    gzClampr(const gzReal &d=0) {m_val=gzMax(gzMin(d,GZ_REAL_ONE),GZ_REAL_ZERO);}

    const gzClampr & operator=(const gzReal &right)
    {
        m_val=gzMax(gzMin(right,GZ_REAL_ONE),GZ_REAL_ZERO);

        return *this;
    }

    operator const gzReal &() const { return m_val; }

private:
    gzReal m_val;
};

//******************************* constants ****************************************

// Some constants to avoid conflicts with OpenGL

typedef enum {
    /* Boolean values */
    GZ_FALSE            = 0,
    GZ_TRUE             = 1,

    /* Data types */
    GZ_BYTE             = 0x1400,
    GZ_UNSIGNED_BYTE    = 0x1401,
    GZ_SHORT            = 0x1402,
    GZ_UNSIGNED_SHORT   = 0x1403,
    GZ_INT              = 0x1404,
    GZ_UNSIGNED_INT     = 0x1405,
    GZ_FLOAT            = 0x1406,
    GZ_DOUBLE           = 0x140A,
    GZ_2_BYTES          = 0x1407,
    GZ_3_BYTES          = 0x1408,
    GZ_4_BYTES          = 0x1409,

    /* Primitives */
    GZ_LINES                = 0x0001,
    GZ_POINTS               = 0x0000,
    GZ_LINE_STRIP           = 0x0003,
    GZ_LINE_LOOP            = 0x0002,
    GZ_TRIANGLES            = 0x0004,
    GZ_TRIANGLE_STRIP       = 0x0005,
    GZ_TRIANGLE_FAN         = 0x0006,
    GZ_QUADS                = 0x0007,
    GZ_QUAD_STRIP           = 0x0008,
    GZ_POLYGON              = 0x0009,
    GZ_EDGE_FLAG            = 0x0B43,

    /* Vertex Arrays */
    GZ_VERTEX_ARRAY         = 0x8074,
    GZ_NORMAL_ARRAY         = 0x8075,
    GZ_COLOR_ARRAY          = 0x8076,
    GZ_INDEX_ARRAY          = 0x8077,
    GZ_TEXTURE_COORD_ARRAY  = 0x8078,
    GZ_EDGE_FLAG_ARRAY      = 0x8079,
    GZ_VERTEX_ARRAY_SIZE    = 0x807A,
    GZ_VERTEX_ARRAY_TYPE    = 0x807B,
    GZ_VERTEX_ARRAY_STRIDE  = 0x807C,
    GZ_NORMAL_ARRAY_TYPE    = 0x807E,
    GZ_NORMAL_ARRAY_STRIDE  = 0x807F,
    GZ_COLOR_ARRAY_SIZE     = 0x8081,
    GZ_COLOR_ARRAY_TYPE     = 0x8082,
    GZ_COLOR_ARRAY_STRIDE   = 0x8083,
    GZ_INDEX_ARRAY_TYPE     = 0x8085,
    GZ_INDEX_ARRAY_STRIDE   = 0x8086,
    GZ_TEXTURE_COORD_ARRAY_SIZE = 0x8088,
    GZ_TEXTURE_COORD_ARRAY_TYPE = 0x8089,
    GZ_TEXTURE_COORD_ARRAY_STRIDE   = 0x808A,
    GZ_EDGE_FLAG_ARRAY_STRIDE   = 0x808C,
    GZ_VERTEX_ARRAY_POINTER     = 0x808E,
    GZ_NORMAL_ARRAY_POINTER     = 0x808F,
    GZ_COLOR_ARRAY_POINTER      = 0x8090,
    GZ_INDEX_ARRAY_POINTER      = 0x8091,
    GZ_TEXTURE_COORD_ARRAY_POINTER  = 0x8092,
    GZ_EDGE_FLAG_ARRAY_POINTER  = 0x8093,

    GZ_V2F              = 0x2A20,
    GZ_V3F              = 0x2A21,
    GZ_C4UB_V2F         = 0x2A22,
    GZ_C4UB_V3F         = 0x2A23,
    GZ_C3F_V3F          = 0x2A24,
    GZ_N3F_V3F          = 0x2A25,
    GZ_C4F_N3F_V3F          = 0x2A26,
    GZ_T2F_V3F          = 0x2A27,
    GZ_T4F_V4F          = 0x2A28,
    GZ_T2F_C4UB_V3F         = 0x2A29,
    GZ_T2F_C3F_V3F          = 0x2A2A,
    GZ_T2F_N3F_V3F          = 0x2A2B,
    GZ_T2F_C4F_N3F_V3F      = 0x2A2C,
    GZ_T4F_C4F_N3F_V4F      = 0x2A2D,

    /* Matrix Mode */
    GZ_MATRIX_MODE          = 0x0BA0,
    GZ_MODELVIEW            = 0x1700,
    GZ_PROJECTION           = 0x1701,
    GZ_TEXTURE              = 0x1702,

    /* Points */
    GZ_POINT_SMOOTH         = 0x0B10,
    GZ_POINT_SIZE           = 0x0B11,
    GZ_POINT_SIZE_GRANULARITY   = 0x0B13,
    GZ_POINT_SIZE_RANGE     = 0x0B12,

    /* Lines */
    GZ_LINE_SMOOTH          = 0x0B20,
    GZ_LINE_STIPPLE         = 0x0B24,
    GZ_LINE_STIPPLE_PATTERN     = 0x0B25,
    GZ_LINE_STIPPLE_REPEAT      = 0x0B26,
    GZ_LINE_WIDTH           = 0x0B21,
    GZ_LINE_WIDTH_GRANULARITY   = 0x0B23,
    GZ_LINE_WIDTH_RANGE     = 0x0B22,

    /* Polygons */
    GZ_POINT            = 0x1B00,
    GZ_LINE             = 0x1B01,
    GZ_FILL             = 0x1B02,
    GZ_CCW              = 0x0901,
    GZ_CW               = 0x0900,
    GZ_FRONT            = 0x0404,
    GZ_BACK             = 0x0405,
    GZ_CULL_FACE            = 0x0B44,
    GZ_CULL_FACE_MODE       = 0x0B45,
    GZ_POLYGON_SMOOTH       = 0x0B41,
    GZ_POLYGON_STIPPLE      = 0x0B42,
    GZ_FRONT_FACE           = 0x0B46,
    GZ_POLYGON_MODE         = 0x0B40,
    GZ_POLYGON_OFFSET_FACTOR    = 0x8038,
    GZ_POLYGON_OFFSET_UNITS     = 0x2A00,
    GZ_POLYGON_OFFSET_POINT     = 0x2A01,
    GZ_POLYGON_OFFSET_LINE      = 0x2A02,
    GZ_POLYGON_OFFSET_FILL      = 0x8037,

    /* Display Lists */
    GZ_COMPILE          = 0x1300,
    GZ_COMPILE_AND_EXECUTE      = 0x1301,
    GZ_LIST_BASE            = 0x0B32,
    GZ_LIST_INDEX           = 0x0B33,
    GZ_LIST_MODE            = 0x0B30,

    /* Depth buffer */
    GZ_NEVER            = 0x0200,
    GZ_LESS             = 0x0201,
    GZ_GEQUAL           = 0x0206,
    GZ_LEQUAL           = 0x0203,
    GZ_GREATER          = 0x0204,
    GZ_NOTEQUAL         = 0x0205,
    GZ_EQUAL            = 0x0202,
    GZ_ALWAYS           = 0x0207,
    GZ_DEPTH_TEST           = 0x0B71,
    GZ_DEPTH_BITS           = 0x0D56,
    GZ_DEPTH_CLEAR_VALUE        = 0x0B73,
    GZ_DEPTH_FUNC           = 0x0B74,
    GZ_DEPTH_RANGE          = 0x0B70,
    GZ_DEPTH_WRITEMASK      = 0x0B72,
    GZ_DEPTH_COMPONENT      = 0x1902,

    /* Lighting */
    GZ_LIGHTING         = 0x0B50,
    GZ_LIGHT0           = 0x4000,
    GZ_LIGHT1           = 0x4001,
    GZ_LIGHT2           = 0x4002,
    GZ_LIGHT3           = 0x4003,
    GZ_LIGHT4           = 0x4004,
    GZ_LIGHT5           = 0x4005,
    GZ_LIGHT6           = 0x4006,
    GZ_LIGHT7           = 0x4007,
    GZ_SPOT_EXPONENT        = 0x1205,
    GZ_SPOT_CUTOFF          = 0x1206,
    GZ_CONSTANT_ATTENUATION     = 0x1207,
    GZ_LINEAR_ATTENUATION       = 0x1208,
    GZ_QUADRATIC_ATTENUATION    = 0x1209,
    GZ_AMBIENT          = 0x1200,
    GZ_DIFFUSE          = 0x1201,
    GZ_SPECULAR         = 0x1202,
    GZ_SHININESS            = 0x1601,
    GZ_EMISSION         = 0x1600,
    GZ_POSITION         = 0x1203,
    GZ_SPOT_DIRECTION       = 0x1204,
    GZ_AMBIENT_AND_DIFFUSE      = 0x1602,
    GZ_COLOR_INDEXES        = 0x1603,
    GZ_LIGHT_MODEL_TWO_SIDE     = 0x0B52,
    GZ_LIGHT_MODEL_LOCAL_VIEWER = 0x0B51,
    GZ_LIGHT_MODEL_AMBIENT      = 0x0B53,
    GZ_FRONT_AND_BACK       = 0x0408,
    GZ_SHADE_MODEL          = 0x0B54,
    GZ_FLAT             = 0x1D00,
    GZ_SMOOTH           = 0x1D01,
    GZ_COLOR_MATERIAL       = 0x0B57,
    GZ_COLOR_MATERIAL_FACE      = 0x0B55,
    GZ_COLOR_MATERIAL_PARAMETER = 0x0B56,
    GZ_NORMALIZE            = 0x0BA1,

    /* User clipping planes */
    GZ_CLIP_PLANE0          = 0x3000,
    GZ_CLIP_PLANE1          = 0x3001,
    GZ_CLIP_PLANE2          = 0x3002,
    GZ_CLIP_PLANE3          = 0x3003,
    GZ_CLIP_PLANE4          = 0x3004,
    GZ_CLIP_PLANE5          = 0x3005,

    /* Accumulation buffer */
    GZ_ACCUM_RED_BITS       = 0x0D58,
    GZ_ACCUM_GREEN_BITS     = 0x0D59,
    GZ_ACCUM_BLUE_BITS      = 0x0D5A,
    GZ_ACCUM_ALPHA_BITS     = 0x0D5B,
    GZ_ACCUM_CLEAR_VALUE        = 0x0B80,
    GZ_ACCUM            = 0x0100,
    GZ_ADD              = 0x0104,
    GZ_LOAD             = 0x0101,
    GZ_MULT             = 0x0103,
    GZ_RETURN           = 0x0102,

    /* Alpha testing */
    GZ_ALPHA_TEST           = 0x0BC0,
    GZ_ALPHA_TEST_REF       = 0x0BC2,
    GZ_ALPHA_TEST_FUNC      = 0x0BC1,

    /* Blending */
    GZ_BLEND            = 0x0BE2,
    GZ_BLEND_SRC            = 0x0BE1,
    GZ_BLEND_DST            = 0x0BE0,
    GZ_ZERO             = 0,
    GZ_ONE              = 1,
    GZ_SRC_COLOR            = 0x0300,
    GZ_ONE_MINUS_SRC_COLOR      = 0x0301,
    GZ_DST_COLOR            = 0x0306,
    GZ_ONE_MINUS_DST_COLOR      = 0x0307,
    GZ_SRC_ALPHA            = 0x0302,
    GZ_ONE_MINUS_SRC_ALPHA      = 0x0303,
    GZ_DST_ALPHA            = 0x0304,
    GZ_ONE_MINUS_DST_ALPHA      = 0x0305,
    GZ_SRC_ALPHA_SATURATE       = 0x0308,
    GZ_CONSTANT_COLOR       = 0x8001,
    GZ_ONE_MINUS_CONSTANT_COLOR = 0x8002,
    GZ_CONSTANT_ALPHA       = 0x8003,
    GZ_ONE_MINUS_CONSTANT_ALPHA = 0x8004,

    /* Render Mode */
    GZ_FEEDBACK         = 0x1C01,
    GZ_RENDER           = 0x1C00,
    GZ_SELECT           = 0x1C02,

    /* Feedback */
    GZ_2D               = 0x0600,
    GZ_3D               = 0x0601,
    GZ_3D_COLOR         = 0x0602,
    GZ_3D_COLOR_TEXTURE     = 0x0603,
    GZ_4D_COLOR_TEXTURE     = 0x0604,
    GZ_POINT_TOKEN          = 0x0701,
    GZ_LINE_TOKEN           = 0x0702,
    GZ_LINE_RESET_TOKEN     = 0x0707,
    GZ_POLYGON_TOKEN        = 0x0703,
    GZ_BITMAP_TOKEN         = 0x0704,
    GZ_DRAW_PIXEL_TOKEN     = 0x0705,
    GZ_COPY_PIXEL_TOKEN     = 0x0706,
    GZ_PASS_THROUGH_TOKEN       = 0x0700,
    GZ_FEEDBACK_BUFFER_POINTER  = 0x0DF0,
    GZ_FEEDBACK_BUFFER_SIZE     = 0x0DF1,
    GZ_FEEDBACK_BUFFER_TYPE     = 0x0DF2,

    /* Selection */
    GZ_SELECTION_BUFFER_POINTER = 0x0DF3,
    GZ_SELECTION_BUFFER_SIZE    = 0x0DF4,

    /* Fog */
    GZ_FOG              = 0x0B60,
    GZ_FOG_MODE         = 0x0B65,
    GZ_FOG_DENSITY          = 0x0B62,
    GZ_FOG_COLOR            = 0x0B66,
    GZ_FOG_INDEX            = 0x0B61,
    GZ_FOG_START            = 0x0B63,
    GZ_FOG_END          = 0x0B64,
    GZ_LINEAR           = 0x2601,
    GZ_EXP              = 0x0800,
    GZ_EXP2             = 0x0801,

    /* Logic Ops */
    GZ_LOGIC_OP         = 0x0BF1,
    GZ_INDEX_LOGIC_OP       = 0x0BF1,
    GZ_COLOR_LOGIC_OP       = 0x0BF2,
    GZ_LOGIC_OP_MODE        = 0x0BF0,
    GZ_CLEAR            = 0x1500,
    GZ_SET              = 0x150F,
    GZ_COPY             = 0x1503,
    GZ_COPY_INVERTED        = 0x150C,
    GZ_NOOP             = 0x1505,
    GZ_INVERT           = 0x150A,
    GZ_AND              = 0x1501,
    GZ_NAND             = 0x150E,
    GZ_OR               = 0x1507,
    GZ_NOR              = 0x1508,
    GZ_XOR              = 0x1506,
    GZ_EQUIV            = 0x1509,
    GZ_AND_REVERSE          = 0x1502,
    GZ_AND_INVERTED         = 0x1504,
    GZ_OR_REVERSE           = 0x150B,
    GZ_OR_INVERTED          = 0x150D,

    /* Stencil */
    GZ_STENCIL_TEST         = 0x0B90,
    GZ_STENCIL_WRITEMASK        = 0x0B98,
    GZ_STENCIL_BITS         = 0x0D57,
    GZ_STENCIL_FUNC         = 0x0B92,
    GZ_STENCIL_VALUE_MASK       = 0x0B93,
    GZ_STENCIL_REF          = 0x0B97,
    GZ_STENCIL_FAIL         = 0x0B94,
    GZ_STENCIL_PASS_DEPTH_PASS  = 0x0B96,
    GZ_STENCIL_PASS_DEPTH_FAIL  = 0x0B95,
    GZ_STENCIL_CLEAR_VALUE      = 0x0B91,
    GZ_STENCIL_INDEX        = 0x1901,
    GZ_KEEP             = 0x1E00,
    GZ_REPLACE          = 0x1E01,
    GZ_INCR             = 0x1E02,
    GZ_DECR             = 0x1E03,

    /* Buffers, Pixel Drawing/Reading */
    GZ_NONE             = 0,
    GZ_LEFT             = 0x0406,
    GZ_RIGHT            = 0x0407,
    /*GZ_FRONT          = 0x0404, */
    /*GZ_BACK           = 0x0405, */
    /*GZ_FRONT_AND_BACK     = 0x0408, */
    GZ_FRONT_LEFT           = 0x0400,
    GZ_FRONT_RIGHT          = 0x0401,
    GZ_BACK_LEFT            = 0x0402,
    GZ_BACK_RIGHT           = 0x0403,
    GZ_AUX0             = 0x0409,
    GZ_AUX1             = 0x040A,
    GZ_AUX2             = 0x040B,
    GZ_AUX3             = 0x040C,
    GZ_COLOR_INDEX          = 0x1900,
    GZ_RED              = 0x1903,
    GZ_GREEN            = 0x1904,
    GZ_BLUE             = 0x1905,
    GZ_ALPHA            = 0x1906,
    GZ_LUMINANCE            = 0x1909,
    GZ_LUMINANCE_ALPHA      = 0x190A,
    GZ_ALPHA_BITS           = 0x0D55,
    GZ_RED_BITS         = 0x0D52,
    GZ_GREEN_BITS           = 0x0D53,
    GZ_BLUE_BITS            = 0x0D54,
    GZ_INDEX_BITS           = 0x0D51,
    GZ_SUBPIXEL_BITS        = 0x0D50,
    GZ_AUX_BUFFERS          = 0x0C00,
    GZ_READ_BUFFER          = 0x0C02,
    GZ_DRAW_BUFFER          = 0x0C01,
    GZ_DOUBLEBUFFER         = 0x0C32,
    GZ_STEREO           = 0x0C33,
    GZ_BITMAP           = 0x1A00,
    GZ_COLOR            = 0x1800,
    GZ_DEPTH            = 0x1801,
    GZ_STENCIL          = 0x1802,
    GZ_DITHER           = 0x0BD0,
    GZ_RGB              = 0x1907,
    GZ_RGBA             = 0x1908,

    /* Implementation limits */
    GZ_MAX_LIST_NESTING     = 0x0B31,
    GZ_MAX_ATTRIB_STACK_DEPTH   = 0x0D35,
    GZ_MAX_MODELVIEW_STACK_DEPTH    = 0x0D36,
    GZ_MAX_NAME_STACK_DEPTH     = 0x0D37,
    GZ_MAX_PROJECTION_STACK_DEPTH   = 0x0D38,
    GZ_MAX_TEXTURE_STACK_DEPTH  = 0x0D39,
    GZ_MAX_EVAL_ORDER       = 0x0D30,
    GZ_MAX_LIGHTS           = 0x0D31,
    GZ_MAX_CLIP_PLANES      = 0x0D32,
    GZ_MAX_TEXTURE_SIZE     = 0x0D33,
    GZ_MAX_PIXEL_MAP_TABLE      = 0x0D34,
    GZ_MAX_VIEWPORT_DIMS        = 0x0D3A,
    GZ_MAX_CLIENT_ATTRIB_STACK_DEPTH= 0x0D3B,

    /* Gets */
    GZ_ATTRIB_STACK_DEPTH       = 0x0BB0,
    GZ_CLIENT_ATTRIB_STACK_DEPTH    = 0x0BB1,
    GZ_COLOR_CLEAR_VALUE        = 0x0C22,
    GZ_COLOR_WRITEMASK      = 0x0C23,
    GZ_CURRENT_INDEX        = 0x0B01,
    GZ_CURRENT_COLOR        = 0x0B00,
    GZ_CURRENT_NORMAL       = 0x0B02,
    GZ_CURRENT_RASTER_COLOR     = 0x0B04,
    GZ_CURRENT_RASTER_DISTANCE  = 0x0B09,
    GZ_CURRENT_RASTER_INDEX     = 0x0B05,
    GZ_CURRENT_RASTER_POSITION  = 0x0B07,
    GZ_CURRENT_RASTER_TEXTURE_COORDS = 0x0B06,
    GZ_CURRENT_RASTER_POSITION_VALID = 0x0B08,
    GZ_CURRENT_TEXTURE_COORDS   = 0x0B03,
    GZ_INDEX_CLEAR_VALUE        = 0x0C20,
    GZ_INDEX_MODE           = 0x0C30,
    GZ_INDEX_WRITEMASK      = 0x0C21,
    GZ_MODELVIEW_MATRIX     = 0x0BA6,
    GZ_MODELVIEW_STACK_DEPTH    = 0x0BA3,
    GZ_NAME_STACK_DEPTH     = 0x0D70,
    GZ_PROJECTION_MATRIX        = 0x0BA7,
    GZ_PROJECTION_STACK_DEPTH   = 0x0BA4,
    GZ_RENDER_MODE          = 0x0C40,
    GZ_RGBA_MODE            = 0x0C31,
    GZ_TEXTURE_MATRIX       = 0x0BA8,
    GZ_TEXTURE_STACK_DEPTH      = 0x0BA5,
    GZ_VIEWPORT         = 0x0BA2,


    /* Evaluators */
    GZ_AUTO_NORMAL          = 0x0D80,
    GZ_MAP1_COLOR_4         = 0x0D90,
    GZ_MAP1_GRID_DOMAIN     = 0x0DD0,
    GZ_MAP1_GRID_SEGMENTS       = 0x0DD1,
    GZ_MAP1_INDEX           = 0x0D91,
    GZ_MAP1_NORMAL          = 0x0D92,
    GZ_MAP1_TEXTURE_COORD_1     = 0x0D93,
    GZ_MAP1_TEXTURE_COORD_2     = 0x0D94,
    GZ_MAP1_TEXTURE_COORD_3     = 0x0D95,
    GZ_MAP1_TEXTURE_COORD_4     = 0x0D96,
    GZ_MAP1_VERTEX_3        = 0x0D97,
    GZ_MAP1_VERTEX_4        = 0x0D98,
    GZ_MAP2_COLOR_4         = 0x0DB0,
    GZ_MAP2_GRID_DOMAIN     = 0x0DD2,
    GZ_MAP2_GRID_SEGMENTS       = 0x0DD3,
    GZ_MAP2_INDEX           = 0x0DB1,
    GZ_MAP2_NORMAL          = 0x0DB2,
    GZ_MAP2_TEXTURE_COORD_1     = 0x0DB3,
    GZ_MAP2_TEXTURE_COORD_2     = 0x0DB4,
    GZ_MAP2_TEXTURE_COORD_3     = 0x0DB5,
    GZ_MAP2_TEXTURE_COORD_4     = 0x0DB6,
    GZ_MAP2_VERTEX_3        = 0x0DB7,
    GZ_MAP2_VERTEX_4        = 0x0DB8,
    GZ_COEFF            = 0x0A00,
    GZ_DOMAIN           = 0x0A02,
    GZ_ORDER            = 0x0A01,

    /* Hints */
    GZ_FOG_HINT         = 0x0C54,
    GZ_LINE_SMOOTH_HINT     = 0x0C52,
    GZ_PERSPECTIVE_CORRECTION_HINT  = 0x0C50,
    GZ_POINT_SMOOTH_HINT        = 0x0C51,
    GZ_POLYGON_SMOOTH_HINT      = 0x0C53,
    GZ_DONT_CARE            = 0x1100,
    GZ_FASTEST          = 0x1101,
    GZ_NICEST           = 0x1102,

    /* Scissor box */
    GZ_SCISSOR_TEST         = 0x0C11,
    GZ_SCISSOR_BOX          = 0x0C10,

    /* Pixel Mode / Transfer */
    GZ_MAP_COLOR            = 0x0D10,
    GZ_MAP_STENCIL          = 0x0D11,
    GZ_INDEX_SHIFT          = 0x0D12,
    GZ_INDEX_OFFSET         = 0x0D13,
    GZ_RED_SCALE            = 0x0D14,
    GZ_RED_BIAS         = 0x0D15,
    GZ_GREEN_SCALE          = 0x0D18,
    GZ_GREEN_BIAS           = 0x0D19,
    GZ_BLUE_SCALE           = 0x0D1A,
    GZ_BLUE_BIAS            = 0x0D1B,
    GZ_ALPHA_SCALE          = 0x0D1C,
    GZ_ALPHA_BIAS           = 0x0D1D,
    GZ_DEPTH_SCALE          = 0x0D1E,
    GZ_DEPTH_BIAS           = 0x0D1F,
    GZ_PIXEL_MAP_S_TO_S_SIZE    = 0x0CB1,
    GZ_PIXEL_MAP_I_TO_I_SIZE    = 0x0CB0,
    GZ_PIXEL_MAP_I_TO_R_SIZE    = 0x0CB2,
    GZ_PIXEL_MAP_I_TO_G_SIZE    = 0x0CB3,
    GZ_PIXEL_MAP_I_TO_B_SIZE    = 0x0CB4,
    GZ_PIXEL_MAP_I_TO_A_SIZE    = 0x0CB5,
    GZ_PIXEL_MAP_R_TO_R_SIZE    = 0x0CB6,
    GZ_PIXEL_MAP_G_TO_G_SIZE    = 0x0CB7,
    GZ_PIXEL_MAP_B_TO_B_SIZE    = 0x0CB8,
    GZ_PIXEL_MAP_A_TO_A_SIZE    = 0x0CB9,
    GZ_PIXEL_MAP_S_TO_S     = 0x0C71,
    GZ_PIXEL_MAP_I_TO_I     = 0x0C70,
    GZ_PIXEL_MAP_I_TO_R     = 0x0C72,
    GZ_PIXEL_MAP_I_TO_G     = 0x0C73,
    GZ_PIXEL_MAP_I_TO_B     = 0x0C74,
    GZ_PIXEL_MAP_I_TO_A     = 0x0C75,
    GZ_PIXEL_MAP_R_TO_R     = 0x0C76,
    GZ_PIXEL_MAP_G_TO_G     = 0x0C77,
    GZ_PIXEL_MAP_B_TO_B     = 0x0C78,
    GZ_PIXEL_MAP_A_TO_A     = 0x0C79,
    GZ_PACK_ALIGNMENT       = 0x0D05,
    GZ_PACK_LSB_FIRST       = 0x0D01,