RE/RE_OGLRender.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * Produced by:
 *      Side Effects
 *      123 Front Street West, Suite 1401
 *      Toronto, Ontario
 *      Canada   M5J 2M2
 *      416-504-9876
 *
 * NAME:        RE_OGLRender.h ( UI Library, C++)
 *
 * COMMENTS:
 *      Interface class for Open GL.
 */
#ifndef __RE_OGLRender__
#define __RE_OGLRender__

#include "RE_API.h"

#include <SYS/SYS_Math.h>
#include <tools/prisms.h>

#include <UT/UT_Defines.h>
#include <UT/UT_Pointers.h>
#include <UT/UT_PtrArray.h>
#include <UT/UT_RefArray.h>
#include <UT/UT_Color.h>
#include <UT/UT_Floor.h>
#include <UT/UT_Rect.h>
#include <UT/UT_RefArray.h>
#include <UT/UT_Thread.h>
#include <UT/UT_ThreadSpecificValue.h>
#include <UT/UT_SpinLock.h>

#include <TIL/TIL_Defines.h>

class UT_DMatrix4;
class UT_IntArray;
class UT_RGBA;
class UT_WorkBuffer;
class RE_Light;
class UT_Vector4;
class IMG_Raster;
class PXL_Raster;
class PXL_Lookup;

class RE_Cursor;
class RE_Font;
class RE_Material;
class RE_OGLTexture2DMap;
class RE_Server;
class RE_Uniform;
class RE_Visual;
class RE_Window;
class RE_WindowList;

class RE_Tesselator;
class RE_OGLExt;
class RE_Shader;

#include "RE_Types.h"
#include "RE_TextureTypes.h"
#include "RE_Extension.h"
#include "RE_LightVal.h"
#include "RE_OGLVertex.h"               // Ultra-fast vertex routines
#include "RE_Uniform.h"

#define OPEN_GL

#define RE_SYMBOL_FONT_SIZE_TINY        3.0f
#define RE_SYMBOL_FONT_SIZE_SMALL       6.0f
#define RE_SYMBOL_FONT_SIZE_SMEDIUM     8.0f
#define RE_SYMBOL_FONT_SIZE_MEDIUM      9.0f
#define RE_SYMBOL_FONT_SIZE_LARGE       12.0f

// --------------------------------------------------------------------------

class RE_API RE_OGLRender
{
public:
     RE_OGLRender(int do_foreground, const char *appname = 0);

    ~RE_OGLRender();

    static void  initialize();

    // You can use these methods to query support for a specific OpenGL
    // version on the machine Houdini is running on.
    static bool          hasGL11() { return ((majorGLVersion > 1) ||
                                             ((majorGLVersion >= 1) &&
                                              (minorGLVersion >= 1))); };
    static bool          hasGL12() { return ((majorGLVersion > 1) ||
                                             ((majorGLVersion >= 1) &&
                                              (minorGLVersion >= 2))); };
    static bool          hasGL13() { return ((majorGLVersion > 1) ||
                                             ((majorGLVersion >= 1) &&
                                              (minorGLVersion >= 3))); };
    static bool          hasGL14() { return ((majorGLVersion > 1) ||
                                             ((majorGLVersion >= 1) &&
                                              (minorGLVersion >= 4))); };
    static bool          hasGL15() { return ((majorGLVersion > 1) ||
                                             ((majorGLVersion >= 1) &&
                                              (minorGLVersion >= 5))); };
    static bool          hasGL20() { return ((majorGLVersion > 2) ||
                                             ((majorGLVersion >= 2) &&
                                              (minorGLVersion >= 0))); };
    static bool          hasGL21() { return ((majorGLVersion > 2) ||
                                             ((majorGLVersion >= 2) &&
                                              (minorGLVersion >= 1))); };
    
    static int           glMajorVersion() { return majorGLVersion; }
    static int           glMinorVersion() { return minorGLVersion; }

    // These track whether GL2 is supported.
    static bool          hasShadersExt()        { return theHasShadersExt; }
    static void          disableShadersExt()    { theHasShadersExt = false; }


    // Low-level hardware and driver verisons. Use these only to work
    // around driver issues. All other features should use the GL version,
    // or RE_OGLExt.
    
    // Returns the hardware doing the rendering.
    static RE_GraphicsDevice getGraphicsDevice() { return theDevice; }

    // The driver version. NVidia uses XX.XX, while ATI uses X.XX.XX
    static int           getDriverMajorVersion() { return theDriverMajor;}
    static int           getDriverMinorVersion() { return theDriverMinor;}
    static int           getDriverBuildVersion() { return theDriverBuild;}

    // material used as a default material
    static const RE_Material    *getDefaultMaterial();

    void                 getDriverInfo(UT_WorkBuffer &info);


    // Access to the RE_OGLExt methods. Should not be used outside of RE.
    RE_OGLExt           *getExt() const { return myExt; }

    void  pushState(int viewing);
    void  popState();

    short resC()                  const;

    // For dual monitors, the span is 0 to res-1, res to virtualres-1.
    // You can get more specific information from getScreen(). 
    static short resX()         { return theXRes; }
    static short resY()         { return theYRes; }
    static short virtualResX()  { return theVirtualX; }
    static short virtualResY()  { return theVirtualY; }

    static void  updateScreenSize();

    // Multi-monitor support. Primary monitor is screen 0.
    //
    static int          getNumScreens();
    static UT_DimRect   getScreen(int i);
    static UT_DimRect   getWorkArea(int i);
    static int          getScreenContaining(int x, int y,
                                            bool closest_if_none = false);
    // returns true if all the screens are the same size
    static bool         areScreensUniform();
    // returns a work area for the screen(s) occupied by 'area', for use when
    // multiple screens aren't uniform in size.
    static UT_DimRect   getWorkAreaForScreen(UT_DimRect area);

    // returns the union of all screens/workareas.
    static UT_DimRect   getTotalScreenArea();
    static UT_DimRect   getTotalWorkArea();

    // this method positions rect entirely on one screen, shifting if
    // required. If screen_hint is not -1, the screen containing that
    // coord will be used. It returns the screen chosen.
    //
    static int          positionOnScreen(UT_DimRect &area,
                                         int screen_hint=-1);

    // returns true if the area fits entirely within one of the screens.
    static bool  positionOkay(const UT_DimRect &area) ;
    
    static short dpi() { return theDotsPerInch; }

    static float pixelsToInches(int n)    { return (float)n / dpi(); }

    static int   inchesToPixels(float i)  { return (int)UTrint(i*(float)dpi()); }
    static void  scaleDPI(fpreal dpi);

    float getRasterX()            const { return rx; }
    float getRasterY()            const { return ry; }
    float getRasterZ()            const { return rz; }

    int getViewportFontOffsetX()  const { return myViewportFontOffsetX; }
    int getViewportFontOffsetY()  const { return myViewportFontOffsetY; }

    short getFullscreenX()        const { return 0; }
    short getFullscreenY()        const { return 0; }


    RE_DisplayMode       mapBestMode(RE_DisplayMode mode);
    RE_DisplayMode       getMode() const;
    
    RE_VisualType        getVisualType() const;
    static RE_Visual    *getVisualForMode(RE_DisplayMode newmode);
    static RE_Server    *getServer();
    static RE_Cursor    *getCursor(const char *name);

#if RE_OGL_SINGLE_CONTEXT
    void                 setContext(RE_IDType wid, int force = 0);
    void                 setContext(RE_Window *, int force = 0);
    void                 pushContext(RE_IDType wid);
    void                 pushContext(RE_Window *);
    void                 popContext();

    RE_IDType            getContextID() const;
    bool                 contextIsValid() { return 0 != getContextID(); }
#else
    void                 setWindow(RE_Window *);
    
    void                 makeCurrent();
    bool                 isCurrent() { return theCurrentRender.get() == this; }
    static void          resetCurrent();
    bool                 contextIsValid() { return (bool)myContext; }
    RE_OGLContext        getContext() const { return myContext; }

    // When using Pbuffers instead of FBOs, we have to set them up as the
    // render target. You cannot push more than 1 buffer at a time.
    void                 pushOffscreenBuffer(OGLDrawable type);
    void                 popOffscreenBuffer();
#endif
    
    // This is the context of the main window, which should persist always.
    void                 setMainContext(RE_Window *w);
    static RE_Window    *getMainContext() { return theMainContextWindow; }

    // This pair of methods prepares for another thread to access OpenGL.
    // They are called from the same thread that will be accessing OpenGL.
    // If they're called from the main thread, they do nothing.
    //
    // These methods work by giving each thread its own OpenGL context.
    // Because other threads do not know when the main thread changes the
    // OpenGL context or drawable, they must call the prepare...() method
    // to explicitly set their context, before they main RE/OGL calls.
    //
    // These methods do not provide support for concurrent access to RE
    // from multiple threads: only one thread at a time may make RE calls.
    // The main thread must be blocked while the other thread makes the
    // calls.  That other thread must call lock...() while the main thread
    // is blocked, make its RE calls, call unlock...(), and only then may it
    // unblock the main thread.
    //
    // These methods are called by HOMF_HOMGLAutoLock so HOMF methods can
    // call code that eventually makes OpenGL calls, even when the Python
    // interpreter is running in a separate thread.
    void                 lockContextForRender();
    void                 unlockContextAfterRender();
    bool                 tryLockContextForRender();
    bool                 isContextLocked() const;

    void                 dumpState(bool extended_info = true) const;
    void                 dumpLightState() const;

    void                 scaleViewForPick(float *l, float *r, float *b, float *t);
    void                 depthCueing(int state, int usegreyramp = 0);

    void                 enableFog(int type, float density,
                                   float nearf, float farf,
                                   const float *col, float alpha);
    void                 disableFog();
    void                 useFogCoord(bool onoff);

    void                 enableLogicOp(void);
    void                 disableLogicOp(void);
    void                 invertPixels(void);
    void                 xorPixels(void);

    int                  overlaySupported() const { return 0; }
    void                 overlaySupported(int ) {}

    void                 swapbuffers();

    // set by the current window, UI_Window::setContext(). returns if the
    // front buffer has been written to since last swap (for marquee drawing)
    //
    bool                 isFrontBufferDirty() const
                         { return myFrontBufferDirty; }
    void                 setFrontBufferDirty(bool dirty)
                         { myFrontBufferDirty = dirty; }

    // Simple XOR drawing functions. Call begin before starting the drawing,
    // and end afterwards. 
    // You must pass an id in, initially zeroed. After that, do not touch the
    // value of id (even for subsequent passes). These methods take care of
    // erasing the previous drawing for you (so you only need to draw once).
    // If you're not drawing another pass, ensure the front buffer is
    // cleared by calling clearXORDraw.
    //
    void                 beginXORDraw(GLuint &id);
    void                 endXORDraw  (GLuint &id);
    void                 clearXORDraw(GLuint &id);
    void                 resetXORDraw(GLuint &id);
    
    RE_RenderBuf         enablebuffers(RE_RenderBuf which);
    int                  enableZbuffer(int state, int clear_it);
    void                 setZFunction(RE_ZFunction func);
    RE_ZFunction         getZFunction() const { return _z_function; };
    int                  isZbuffer();
    
    void                 pushStencilState();
    void                 popStencilState();
    void                 setSClearValue(int clearValue);
    void                 setSWriteMask(int writeMask);
    void                 setSFunction(RE_SFunction func, int ref, int mask);
    void                 setSOperation(RE_SOperation sfail,
                                       RE_SOperation dpfail,
                                       RE_SOperation dppass);

    RE_RenderBuf         getDrawBuffer() { return drawBuffer; }
    void                 setDrawBuffer( RE_RenderBuf buf );

    bool                 setCompactPick( bool c )
                         {
                            bool old = myCompactPick;
                            myCompactPick = c;
                            return old;
                         }

private:
    static RE_ZFunction  oglToREzfunc( int oglZFunc );
    static int           reToOGLzfunc( RE_ZFunction reZFunc );
    void                 setZFunction();
    RE_ZFunction         _z_function;

    static RE_SFunction  oglToREsfunc( int oglSFunc );
    static int           reToOGLsfunc( RE_SFunction reSFunc );
    static RE_SOperation oglToREsoperation( int oglSOperation );
    static int           reToOGLsoperation( RE_SOperation reSOperation );
    void                 setSClearValue();
    int                  _s_clear_value;
    void                 setSWriteMask();
    int                  _s_write_mask;
    void                 setSFunction();
    RE_SFunction         _s_function;
    int                  _s_function_ref;
    int                  _s_function_mask;
    void                 setSOperation();
    RE_SOperation        _s_operation_sfail;
    RE_SOperation        _s_operation_dpfail;
    RE_SOperation        _s_operation_dppass;
public:

    void                 copyToFront(short x, short y, short w, short h);
    void                 copyToBack(short x, short y, short w, short h);
    void                 saveFront(short x, short y, short w, short h);
    void                 restoreFront(short x, short y, short w, short h);

    // The saveRaster method saves the front buffer to a raster.  The
    //  raster should be the same size as the w and h parms.  As well,
    //  currently, we only support 8 bit channels in the raster. A zoom of -1
    // uses the current zoom (default).
    void                 saveRaster(short x, short y, short w, short h,
                                    IMG_Raster *r, bool use_backbuf = true);
    PXL_Raster *         saveRaster(short x, short y, short w, short h,
                                    PXL_DataFormat format, bool alphatoo,
                                    bool use_backbuf = true);
    void                 displayRaster(float x, float y, short w, short h,
                                       IMG_Raster *r, float zoom = -1.0f,
                                       int dither = 1);
    void                 displayRaster(float x, float y, short w, short h,
                                        UT_RGBA *r, short stride,
                                       float zoom=-1.0f, int dither = 1);
    void                 displayRaster(float x, float y,
                                       const PXL_Raster *raster,
                                       const RE_RasterOpts *opts = 0);
    void                 displayRasterTexture(float x, float y,
                                              const PXL_Raster *raster,
                                              const RE_RasterOpts *opts = 0);

    // makes a texture out of the raster, and stores the id in the raster.
    void                 convertRasterToTexture(PXL_Raster *raster,
                                                int convert16bit = 0);
    void                 convertLUTToTexture(PXL_Lookup *raster, int size);
    bool                 is3DLUTSupported();
    int                  getMaxTextureRectangleSize();
    
    int                  isFloatZoomSupported();
    int                  getMaxPixelMapSize();
    int                  isHalfFloatSupported();

    // if yzoom == -1, then it will be equal to xzoom.
    void                 zoomRaster(float xzoom, float yzoom = -1);
    void                 getRasterZoom(float &xzoom, float &yzoom) const;

    void                 ortho2DW(float l, float r, float b, float t);
    void                 ortho3DW(float l, float r, float b, float t, float n,
                                  float f);

                         // WARNING, the fov is in radians, not Angle
    void                 perspective(float fov, float a, float n, float f);
    void                 window3DW( float l, float r, float b, float t,
                                    float near, float far );
    int                  mapWorld(  float xs, float xy,
                                    float *x1, float *y1, float *z1,
                                    float *x2, float *y2, float *z2 );
    int                  mapWorld(  float xs, float ys,
                                    short vpl, short vpr, short vpb, short vpt,
                                    const UT_Matrix4 &proj, 
                                    const UT_Matrix4 &view,
                                    float *x1, float *y1, float *z1,
                                    float *x2, float *y2, float *z2);
    int                  mapScreen( float xw, float yw, float zw,
                                    float *xs, float *ys );
    int                  mapScreen(float xw, float yw, float zw, 
                                    short vpl, short vpr, short vpb, short vpt,
                                    const UT_Matrix4 &proj, 
                                    const UT_Matrix4 &view,
                                    float *xs, float *ys);
    void              viewport2DS(short l, short r, short b, short t);
    void            screenMask2DS(short l, short r, short b, short t);
    void        disableScreenMask();
    void         intersectMask2DS(short l, short r, short b, short t);
    void         getScreenMask2DS(short *l, short *r, short *b,
                                                short *t);

    void        getViewport2DS( int *l, int *r, int *b, int *t );
    bool        getViewportMaskActive() const;

    void        enableMultisample(bool enable);
    bool        isMultisampleEnabled() const;

    void         pushPattern(RE_FillPattern p);
    void          popPattern();

    void         pushLineStyle(RE_LineStyle s);
    void          popLineStyle();

    void         pushLineWidth(float w);
    void          popLineWidth();
    float        getLineWidth() const;
    float        getMaxSmoothLineWidth();

    void         pushPointSize(float size);
    void          popPointSize();
    void          setPointSize(float size);


    void         pushViewport();
    void          popViewport();

    void         matrixMode(RE_MatrixMode mode);
    RE_MatrixMode getMatrixMode();
    void         pushMatrix(int update_projection=1);
    void          popMatrix(int update_projection=1);
    void         loadMatrix(const UT_Matrix4 &m);
    void         loadMatrix(const UT_DMatrix4 &m);
    void         loadIdentityMatrix();
    void          getMatrix(      UT_Matrix4 &m);
    void          getAMatrix(RE_MatrixMode mmode, UT_Matrix4 &m);
    void          getAMatrix(RE_MatrixMode mmode, UT_DMatrix4 &m);
    void         multiplyMatrix(const UT_Matrix4 &m);
    void         multiplyMatrix(const UT_DMatrix4 &m);

    void         translate(float x, float y, float z = 0.0);
    void         scale(float x = 1.0, float y = 1.0, float z = 1.0);
    void         rotate(float angle, char axis);
    
#if RE_OGL_SINGLE_CONTEXT
    void         getOrigin(long *x, long *y);
#endif
    void         getOverlayRelOrigin( short *x, short *y );

    int          startObjectDefine();   // makeobj()
    void         endObjectDefine();     // closeobj()
    void         deleteObject(int id);  // delobj()
    void         drawObject(int id);    // callobj()

    // The "smart" variants of the display list management methods that track
    // texture objects referenced.  Use the regular drawObject() method to
    // execute these "smart" display lists.  A return value of false from the
    // endSmartObjectDefine() is used to signal that referenced textures were
    // released during the creation, so the first drawObject() call must be
    // followed by a call to deletePendingTexturesFromSmartObjectCreation().
    int          startSmartObjectDefine();      // makeobj()
    bool         endSmartObjectDefine();        // closeobj(), false if dirty
    void         deleteSmartObject(int id);     // delobj()
    bool         isSmartObjectDirty(int id);

    bool         inObjectDefine() const { return myInObjectDefine; }
    bool         trackingObjectShaderUsage() const
                                        { return myTrackingObjectShaderUsage; }
    bool         trackingObjectTextureUsage() const
                                        { return myTrackingObjectTextureUsage; }

    // Return an array of shader programs used by the smart object.
    const UT_IntArray   *getShadersUsedBySmartObject(int id);

    // Called to notify the smart object cache of a shader/texture object
    // deletion.  The return value is very important, with true meaning that
    // it is safe to proceed with the shader/texture deletion and false
    // indicating alternate arrangements for the shader/texture deletion have
    // been made and not to proceed.
    bool         notifySmartObjectsOfShaderDeletion( int shader_idx );
    bool         notifySmartObjectsOfTextureDeletion( int texture_idx );

    // Call these methods after the first drawObject() call for a smart object
    // that returned false from endSmartObjectDefine().
    void         deletePendingShadersFromSmartObjectCreation();
    void         deletePendingTexturesFromSmartObjectCreation();

    // Call this method when a shader is used.  It is public because we don't
    // have a wrapper for glUseProgramObject, which is called through RE_OGLExt.
    void         recordShaderForSmartObject( int shader_idx );

    // Assign a built-in uniform to a value. NULL may be passed to clear the
    // value. This should only be used by RE_Uniform.
    void         setUniform(RE_UniformBuiltIn builtin_var_type,
                            const RE_Uniform *var);

    // Bind all builtin uniforms to the shader. 
    void         bindBuiltInUniforms(RE_Shader *s,
                                     RE_UniformBinding bind);

    void         setColor(const UT_Color &c, float alpha=1.0);
    void         setColor(float r, float g, float b, float a);
    void         setColorMask(int red, int green, int blue, int alpha);
    void         getColor(UT_Color &c) const;
    void         setAlpha(float alpha);
    float        getAlpha() const;
    void         pushColor();
    void         popColor();
    void         pushColor(const UT_Color &c, float alpha=1.0f) 
                                      { pushColor(); setColor(c, alpha); }
    void         resetColorCache()
                   { myGLColor[0]=myGLColor[1]=myGLColor[2]=myGLColor[3]=-1.f; }

    void         clearAllMaterials(void) const;
    void         clearAllTextures(void) const;

    // The layer here is indexed from 0, while the layers in the GU_Details
    // are indexed from 1.
    void         setMaterial(RE_Material &mat, int layer = 0);
                         // TODO: Move this to the base class
    void         pushMaterial(RE_Material *mat, int layer = 0);
    void         popMaterial();

    // Methods to enable/disable the tracking of the diffuse material property
    // from the current color.  Note that disabling this tracking does not
    // reset the current material settings.
    void         pushMaterialDiffuse();
    void         popMaterialDiffuse();

    // Set the current color from the diffuse property of the material on top
    // of the current material stack.  This is useful to get the material to
    // the last specified setting without having to call the more costly
    // popMaterialDiffuse() and setMaterial().
    void         setDiffuseMaterialFromMaterialStack();

//JC    void     rebindMaterial();

    // This method computes the actual resolution used for a texture
    // map.  The result is 2^n where n is the smallest non-negative
    // integer such that |res - 2^n| <= |res - 2^k| for all non-negative
    // integers k.  In other words, the result is the nearest power of
    // 2, favouring the smaller when two are equi-distant.
    //        
    static int   computeTextureRes(unsigned int res)
                 {
                     int m = 0;
                     unsigned int a = res;
                     while (a >>= 1) m++;
                     int lbound = 1 << m;       // lower bound

                     // Compare against the midpoint of lower and upper bound.
                     return (res > (lbound + (lbound >> 1))) ?
                         (lbound << 1) : lbound;
                 }

    // These will set the current texture of the current texture unit.
    void         useTexture2D(int idx);
    void         useTexture3D(int idx);
    void         useTextureCubeMap(int idx);

    // Query & set the active texture units.  Note these are 0 based,
    // not GL_TEXTURE0 based.
    int          getActiveTexture() const;
    void         setActiveTexture(int tunit);

    // Sets the texture combine mode for the active texture unit.
    void         setTextureMode(RE_TextureMode mode);
    RE_TextureMode getTextureMode() const;

    // Query the maximum number of texture units we support.
    int          getMaxTextureUnits() const { return myMaxTextureUnits; }

    // Query the maximum size of a texture that is supported (either width or
    // height)
    int          getMaxTextureSize() const { return myMaxTextureSize; }

    // These will enable/disable for thie unit only.
    void         enableTexture2D();
    void         disableTexture2D();
    int          getTexture2D();
    void         enableTexture3D();
    void         disableTexture3D();
    int          getTexture3D();
    void         enableTextureCubeMap();
    void         disableTextureCubeMap();
    int          getTextureCubeMap();

    // This will disable for all texture units.
    void         disableAllTextures();
    
    // Reads in initial values for all the textures.
    void         initAllTextures();
    
    void         setLightModel(int local_viewer, int two_sided_lighting);
    // Specify normalize = true to normalize the light color.  Currently this
    // is used during the high quality rendering mode where light colors are
    // normalized and then scaled at a later time in order to reduce the
    // effects of clamping.
    unsigned     defineLight(const RE_Light &light, bool normalize = false); 
    
#if ! RE_OGL_SINGLE_CONTEXT
    bool         isLightDefined(const RE_Light &light) const;
    void         deNormalizeLightDefinition(const RE_Light &light);
    void         setLightState(const RE_Light &light, int onoff);
#endif
    
    void         deNormalizeLightDefinition(unsigned index);
    void         undefineLight(unsigned index);
    void         undefineAllLights();
    void         setLightState(unsigned index, int onoff);
    bool         getLightState(unsigned index);
    void         allLightsOff();
    RE_Light    *getLight(int index);
    int          getNumLights();
    void         setGLSpots(int f) { myUseOGLSpots = f; }
    void         setAllowSpecular(int f) { myAllowLightSpecular = f; }
    int          getAllowSpecular() const { return myAllowLightSpecular; }
    RE_Uniform  *getLightEnabledUniform() const{ return myLightEnabledUniform; }
    void         setNormalizeGlobalAmbient(bool normalize)
                        { myNormalizeGlobalAmbient = normalize; }
    bool         getNormalizeGlobalAmbient() const
                        { return myNormalizeGlobalAmbient; }

private:
    void         resetAmbientLight();

public:
                         // If there is no argument to the setWorldLight
                         // method (or the ambient array is 0), then all
                         // lighting will be turned off.  Otherwise, the
                         // ambient value will be used for world ambient
                         // light. There should be 3 floats in the array.
    void         toggleLighting(int onoff);
    void         toggleLightShading(int onoff);
    void         setDefaultStacklessColor(const UT_Color &color);

    // Bind/unbind either the light's projective texture.  The texture is
    // bound to the current texture unit.
    void         useProjectiveTexture(bool ison, RE_Light *light);

    // Multiply the current texture unit's matrix by the projective texture
    // transform.
    void         setProjectiveTextureTransform(const RE_Light *light,
                                               bool bias);

    // Multiply the current texture unit's matrix by the spotlight cone
    // transform.
    void         setSpotlightConeTransform(const RE_Light *light, bool bias);

    // Multiplies the current GL matrix by the transformation that maps a
    // world space point to a light space point.
    void         setShadowMapTransform(const RE_Light *light, bool bias);

    // Sets up GL to render the light's shadow map.  The proper transform
    // will be set for you.  If this returns false, shadow maps are not
    // supported and no further shadow map calls should be made (including
    // finishShadowMapRender).  If this returns true, the shadow map is
    // ready to be rendered to and finishShadowMapRender must be called
    // after rendering to it.
    bool         prepShadowMapRender(const RE_Light *light);

    // A debug method to examine the depth buffer.  Must be called prior to
    // finishShadowMapRender.
    void         saveShadowMapToRaster(PXL_Raster &raster);

    // When you are done rendering from the light's view, call this
    // to clean up your GL state and return you to the main viewport.
    void         finishShadowMapRender();

    // Enables or disables the use of shadow maps for the specified light.
    // Currently there is only one shadow map shared by all lights so you
    // need to re-render the maps just in time.
    void         useShadowMap(bool ison, const RE_Light *light);

public:
    // If possible, call clearCZ() instead of clear() followed by clearZ(),
    // since a single clearCZ() is much faster on all post-Indy machines.
    void         clear();
    void         clearZ();
    void         clearCZ();
    void         clearS();

    void         pushBlendState();
    void         popBlendState();
    
    int          isBlending() const { return getBlending(); }
    void         blend(int onoff);
    void         setBlendFunction(RE_BlendSourceFactor  sourceFactor,
                                  RE_BlendDestFactor    destFactor);
    void         getBlendFunction(RE_BlendSourceFactor* sourceFactor,
                                  RE_BlendDestFactor*   destFactor);
    void         blendAlpha(int onoff, int usezbuffer=0);  
    void         alphaTest(int onoff);
    void         setAlphaTestFunction(RE_ZFunction func, float val);

    void         beginPicking(uint *buf, long bufsiz, short x, short y,
                                        short w, short h );
    long           endPicking(uint *buf);
    int             isPicking(void) const;
    void          loadPickId(uint id);
    void          pushPickId(uint id);
    void           popPickId();

    int           isBackface()          { return stateInfo.backface; }
    void         setBackface(int removeBackface = 0);
    int    getReverseWinding()          { return stateInfo.reverse_winding; }
    void   setReverseWinding(int reverse_winding);

    int           isCaching() const { return avoidCacheCount ? 1:cacheIndex; }

    int           avoidCache() const            { return avoidCacheCount; }
    void          bumpAvoidCache(int d)         { avoidCacheCount += d; }

    UT_Bool        isPointOffset() const { return getPointOffset(); };
    UT_Bool         isLineOffset() const { return getLineOffset();  };
    UT_Bool      isPolygonOffset() const;
    void             pointOffset( UT_Bool onoff ) { if( onoff ) enablePointOffset(); else disablePointOffset(); };
    void              lineOffset( UT_Bool onoff ) { if( onoff ) enableLineOffset();  else disableLineOffset();  };
    void           polygonOffset( UT_Bool onoff );
    void         setOffsetAmount( float variable, float constant );
    void         getOffsetAmount( float* variable, float* constant ) { (*variable) = _offset_variable; (*constant) = _offset_constant; };

private:
    RE_PolyOffStrategy getPolygonOffsetStrategy() const;

    void        setOffsetAmount();
    float       _offset_variable;
    float       _offset_constant;

public:

    // drawing modes.  See glBegin.
    //  beginPolygon     == glBegin( GL_POLYGON );
    //  beginLine        == glBegin( GL_LINE_STRIP );
    //  beginLines       == glBegin( GL_LINES );
    //  beginClosedLine  == glBegin( GL_LINE_LOOP );
    //  beginPoint       == glBegin( GL_POINTS );
    //  beginTriangles   == glBegin( GL_TRIANGLES );
    //  beginTriangleFan == glBegin( GL_TRIANGLE_FAN );
    //  beginTriMesh     == glBegin( GL_TRIANGLE_STRIP );
    //  beginQuads       == glBegin( GL_QUADS );
    //  beginQuadStrip   == glBegin( GL_QUAD_STRIP );
    //  end* == glEnd();
    //  end 
    void           end();               // do this here 'cuz end* == glEnd();
                                        // and sometimes its a lot of 
                                        // trouble to remember what you 
                                        // were doing.

    void         beginPolygon(int concave);
    void           endPolygon();
    void         beginLine();
    void           endLine();
    void         beginLines();          // Treates each pair of vertices 
    void           endLines();          // as an independent line segment.
                                        // Vertices 2n-1 and 2n define line n.
                                        // N/2 lines are drawn.
    void         beginClosedLine();
    void           endClosedLine();
    void         beginPoint();
    void           endPoint();
    void         beginTriangles();      // Treates each triplet of vertices 
    void           endTriangles();      // as an independent triangle.
                                        // Vertices 3n-2, 3n-1, and 3n define
                                        // triangle n.  N/3 triangles
                                        // are drawn.

    void         beginTriangleFan();    // Draws a connected group of
    void           endTriangleFan();    // triangles.  One triangle is defined
                                        // for each vertex presented after the
                                        // first two vertices.
                                        // Vertices 1, n+1, and n+2 define
                                        // triangle n.  N-2 triangles are
                                        // drawn.

    void         beginTriMesh();
    void           endTriMesh();
    void         beginQuads();          // Draws a connected group of
    void           endQuads();          // quadrilaterals.  One quadrilateral
                                        // is defined for each pair of vertices
                                        // presented after the first
                                        // pair.  Vertices 2n-1, 2n, 2n+2,
                                        // and 2n+1 define quadrilateral
                                        // n.  N/2-1 quadrilaterals are drawn.
                                        // Note that the order in
                                        // which vertices are used to construct
                                        // a quadrilateral from strip
                                        // data is different from that used
                                        // with independent data.

    void         beginQuadStrip();
    void           endQuadStrip();

    void         v2DS(const short v[2]) { myVtxOut->v2DS(v); }  // Position
    void         v2DI(const int   v[2]) { myVtxOut->v2DI(v); }  // Position
    void         v2DW(const float v[2]) { myVtxOut->v2DW(v); }  // Position
    void         v3DS(const short v[3]) { myVtxOut->v3DS(v); }  // Position
    void         v3DI(const int   v[3]) { myVtxOut->v3DI(v); }  // Position
    void         v3DW(const float v[3]) { myVtxOut->v3DW(v); }  // Position

    // Methods for allocating, binding, and releasing named textures
    int          generateTexture(); 
    void         bindTexture(int index); 
    void         bindTexture3D(int index); 
    void         bindTextureCubeMap(int index);
    void         deleteTexture(int index); 

//
//  The following vertex methods are more optimal for Open GL:
//
    void         vertex2DI(int   x, int   y) { myVtxOut->vertex2DI(x, y); }
    void         vertex2DS(short x, short y) { myVtxOut->vertex2DS(x, y); }
    void         vertex2DW(float x, float y) { myVtxOut->vertex2DW(x, y); }
    void         vertex3DI(int x, int y, int z)
                     { myVtxOut->vertex3DS(x, y, z); }
    void         vertex3DS(short x, short y, short z)
                     { myVtxOut->vertex3DS(x, y, z); }
    void         vertex3DW(float x, float y, float z)
                     { myVtxOut->vertex3DW(x, y, z); }

    void         c3DS(const short v[3])
                   {
                       myVtxOut->c3DS(v);
                       myGLColor[0]=v[0]/32768.0f; myGLColor[1]=v[1]/32768.0f;
                       myGLColor[2]=v[2]/32768.0f; myGLColor[3]=1.0f;
                   }
    void         c3DW(const float v[3])
                   {
                       myVtxOut->c3DW(v);
                       myGLColor[0]=v[0]; myGLColor[1]=v[1];
                       myGLColor[2]=v[2]; myGLColor[3]=1.0f;
                   }
    void         c4DW(const float v[4])
                   {
                       myVtxOut->c4DW(v);
                       myGLColor[0]=v[0]; myGLColor[1]=v[1];
                       myGLColor[2]=v[2]; myGLColor[3]=v[3];
                   }
    void         cacheC3DW(const float v[3])
                   {
                       if (v[0] != myGLColor[0] || v[1] != myGLColor[1] ||
                           v[2] != myGLColor[2] || 1.0f != myGLColor[3])
                       {
                           c3DW(v);
                       }

                   }
    void         cacheC4DW(const float v[4])
                   {
                       if (v[0] != myGLColor[0] || v[1] != myGLColor[1] ||
                           v[2] != myGLColor[2] || v[3] != myGLColor[3])
                       {
                           c4DW(v);
                       }
                   }
    void         n3DW(const float v[3]) { myVtxOut->n3DW(v); }
    void         t2DW(const float v[2]) { myVtxOut->t2DW(v); }
    void         t3DW(const float v[3]) { myVtxOut->t3DW(v); }
    void         t4DW(const float v[4]) { myVtxOut->t4DW(v); }
    void         a1DW(unsigned int loc, const float v[1])
                                                { myVtxOut->a1DW(loc, v); }
    void         a2DW(unsigned int loc, const float v[2]) 
                                                { myVtxOut->a2DW(loc, v); }
    void         a3DW(unsigned int loc, const float v[3])
                                                { myVtxOut->a3DW(loc, v); }
    void         a4DW(unsigned int loc, const float v[4]) 
                                                { myVtxOut->a4DW(loc, v); }

    // TODO: Handling of the fog coordinate should be moved into RE_OGLVertex
    //       as that is where it properly belongs.  However, at the moment we
    //       do not use it on a per-vertex basis, so we can get away without
    //       this.
    void         fogCoord(const float z);

    RE_InterpMode getInterpMode();
    void          interpMode(RE_InterpMode mode);

    void          pushSmoothLines();
    void          popSmoothLines();
    void          forceSmooth();
    void          smoothBlendLines(RE_SmoothMode mode);
    void          smoothBlendLinesNoFlagChange();
    RE_SmoothMode getSmoothLines() { return mySmoothingLines ? RE_SMOOTH_ON : RE_SMOOTH_OFF; };
    void          subPixel(int mode);
    void          clipPlane(int which, int onoff, const UT_Vector4 *parms = 0);

    void          move2DW(float x, float y);
    void          move2DS(short x, short y);
    void          move3DW(float x, float y, float z);
    void          move3DS(short x, short y, short z);
    void         rmove2DW(float x, float y);
    void         rmove2DS(short x, short y);
    void         rmove3DW(float x, float y, float z);
    void         rmove3DS(short x, short y, short z);
    void          draw2DW(float x, float y);
    void          draw2DS(short x, short y);
    void          draw3DW(float x, float y, float z);
    void          draw3DS(short x, short y, short z);
    void         rdraw2DW(float x, float y);
    void         rdraw2DS(short x, short y);
    void         rdraw3DW(float x, float y, float z);
    void         rdraw3DS(short x, short y, short z);

//      These are obsolete.
//    void       polyClose();
//    void       polyDraw2DW(float x, float y);
//    void       polyDraw2DS(short x, short y);
//    void       polyDraw3DW(float x, float y, float z);
//    void       polyDraw3DS(short x, short y, short z);
//    void       polyMove2DW(float x, float y);
//    void       polyMove2DS(short x, short y);
//    void       polyMove3DW(float x, float y, float z);
//    void       polyMove3DS(short x, short y, short z);

    void         rect2DW (float x1, float y1, float x2, float y2);
    void         rect2DS (short x1, short y1, short x2, short y2);
    void         rectf2DW(float x1, float y1, float x2, float y2);
    void         rectf2DS(short x1, short y1, short x2, short y2);
    void         box2DS  (short x1, short y1, short x2, short y2);
    void         boxf2DS (short x1, short y1, short x2, short y2);

    void          arcW(float x, float y, float r, short a, short b);
    void          arcS(short x, short y, short r, short a, short b);
    void         arcfW(float x, float y, float r, short a, short b);
    void         arcfS(short x, short y, short r, short a, short b);

    void         sectorS(short x, short y, short ir, short outer, 
                         float a, float b, int slices = 20, int loops = 1);
    void         sectorW(float x, float y, float ir, float outer, 
                         float a, float b, int slices = 20, int loops = 1);


    /// Draw a circle with a hole in the centre of it: draws only from radius
    /// innerr to radius outerr.
    void         circlefS(short x, short y, short innerr, short outerr, 
                            int slices = 50);
    void         circlefW(float x, float y, float innerr, float outerr, 
                            int slices = 50);

    /// Draw a filled circle of radius r.
    void         circlefS(short x, short y, short r, int slices = 50);
    void         circlefW(float x, float y, float r, int slices = 50);

    /// Draw a circle of radius r with lines.
    void         circleS (short x, short y, short r, int slices = 50);
    void         circleW (float x, float y, float r, int slices = 50);

    void         sphereW(float x, float y, float z, float r, int divs = 20);
    void         spherefW(float x, float y, float z, float r, int divs = 20);

    void         textMove3S(short x, short y, short z);
    void         textMove3W(float x, float y, float z);
    void         textMoveS(short x, short y);
    void         textMoveW(float x, float y);

    // The following method is used to align text in the viewport where the
    // current xform makes attempting to use textMove* impractical for this
    // purpose.
    // NOTE: Clipping is performed using the actual raster position (set
    // through textMove*) and not the offset position.
    // NOTE: Only works for bitmap fonts, not texture fonts.
    void         setViewportFontOffset(int x, int y);
    
    /// Get a standard font for the UI. Size is in points.
    /// This should be protected with some friends, but due to various issues
    /// it can't be.
    /// Never use this - use UIgetFont instead.
    static RE_Font      *internalGetFont(const char *name, float size);

public:
    /// Get the font we use in the viewport. This is not antialiased, but it
    /// is properly clipped and transformed in 3D space.
    static RE_Font      *getViewportFont();

    /// Get the symbol font we use in the viewport. Not antialiased, but
    /// properly clipped and transformed in 3D space.
    static RE_Font      *getViewportSymbolFont(float size);

    static void  setDefaultFont(const char *name, float size);

    void         getTextPos(short *x, short *y);

    void         flush(int wait=0) const;
    void         waitForRetrace() const;

    // Methods for rendering NURBS surfaces and trim curves:
    void        *createNurbsObject (void);
    void         destroyNurbsObject(void *nurbsobj);
    void         beginNurbsSurface(void *nurbsobj);
    void         endNurbsSurface  (void *nurbsobj);
    void         nurbsSurface(int uklen, float *uknots, int vklen,
                              float *vknots, int nrows, float *cvs,
                              int uorder, int vorder, int rational,
                              void *nurbsobj);
    void         beginTrimLoop(void *nurbsobj);
    void         endTrimLoop  (void *nurbsobj);
    void         polyTrimCurve (int nvtx, float *cvs, void *nurbsobj);
    void         nurbsTrimCurve(int uklen, float *uknots, int order,
                                float *cvs, int rational, void *nurbsobj);
    void         setNurbsProperties(int autonormal, float tol,
                                    void *nurbsobj = 0);

    const char  *className() const;

    void                 setIconImage(const char *filename);
                         // Set universal icon loader
    void                 setIconLoader(RE_IconLoader loader)
                         {
                            iconLoader = loader;
                         }
                         // Set Icon loader on a per window basis
    void                 setIconLoader(RE_IDType wid, RE_IconLoader loader);
    void                 clearIconLoader(RE_IDType wid);

    void                 initGLState();

    int                  useDisplayLists();

    static RE_WindowList *getWindowList()       { return theWindowList; }

    int                  getGLError();
    int                  getNextGLError();
    void                 clearGLErrors();
    const char          *getGLErrorString( int error );
    void                 printGLError(const char *header,
                                      bool assert = false );
    void                 printAllGLErrors( const char *header,
                                           bool assert = false );

    void                 setDrawPixelsMode(RE_DrawPixelsMode new_mode);
    RE_DrawPixelsMode    getDrawPixelsMode();
    void                 enable( int state ) { enabled = state; }

    static void          allowSmoothLines(int yn)
                         {
                             theSmoothLinesAllowed = yn;
                         }
    static int           allowsSmoothLines()
                         {
                             return theSmoothLinesAllowed;
                         }

    const RE_Window     *getCurrentWindow() const { return currentWindow; }
          RE_Window     *getCurrentWindow()       { return currentWindow; }
    
    void                 updateScreensAndWorkAreas() { determineTwinView(); };

protected:
    void         defineTexture(int idx, PXL_Raster *rp) const;

    unsigned int allocRenderCache ( unsigned int num = 1 );
    void         deleteRenderCache( unsigned int cache, 
                                            unsigned int num = 1 );
    void         beginCache       ( unsigned int cache   );
    void         executeCache     ( unsigned int cache   );
    void         endCache();

    // Make a record of a texture object referenced while compiling a "smart" 
    // object (display list).
    void         recordTextureForSmartObject( int texture_idx );
    
private:
    static void  initTextureCache();
    static void  initTexture3DCache();

    inline int   setConcave(int concave);
    UT_Bool      updateRGBmode();
    void         determineTwinView();
    void         switchContextForRender();

#if RE_OGL_SINGLE_CONTEXT
    void         makeWindowCurrent(RE_Window *win);
#endif
    
#ifdef WIN32
public:
    // This is public to avoid problems with friend function declarations,
    // and to avoid using windows.h in RE_OGLRender.h. Don't call it.
    void         internalAddScreen(UT_DimRect rect)
                 { theScreens.append(rect); }
    void         internalAddWorkArea(UT_DimRect rect)
                 { theWorkAreas.append(rect); }
private:
#endif

#if ! RE_OGL_SINGLE_CONTEXT
    RE_LightVal *validateLight(const RE_Light &light);
#endif
    
    RE_LightVal *validateLightIndex(unsigned index);
    void         turnLightOn(unsigned int index);
    void         turnLightOff(unsigned int index);

    void         displayClippedRaster(const unsigned char *base, int offset,
                                      int psize, int w, int h,
                                      GLenum type, GLenum format,
                                      float x, float y);
    
    void         setState( RE_State currentState, RE_State newState, int push );
    RE_State     stateStack[RE_STACK_DEPTH];
    short        stateIndex;

    void        *saveBuffer;
    unsigned     saveSize;

#if RE_OGL_SINGLE_CONTEXT
    RE_Window   *contextStack[CONTEXT_STACK_SIZE];
    short        contextStackIndex;
#endif
    
    IMG_Raster    *iconImage;
    RE_IconLoader  iconLoader;

    RE_CMMatrix    projectionStack[PROJECTION_STACK_SIZE];
    float          lineWidthStack[PATTERN_STACK_SIZE];
    unsigned short lineStyleStack[PATTERN_STACK_SIZE];
    short          patternStack[PATTERN_STACK_SIZE];
    RE_ColorStack  colorStack[RE_COLOR_STACK_SIZE];
    float          pointSizeStack[PATTERN_STACK_SIZE];
    float          myGLColor[4];

    static bool    theSmoothLinesAllowed;
    bool           myForceSmoothLines;
    short          mySmoothingLines;
    short          myActuallySmoothingLines;

    short          myOverlaySupported;

    bool           myInObjectDefine;  // True when inside an object definition
    bool           myTrackingObjectShaderUsage;
    bool           myTrackingObjectTextureUsage; // inside smart object def'n
    bool           myProjectingTexture; // using projected texture of a light

    UT_RefArray<RE_LightVal>     myLightArray;
    int *                        myLightStates;
    RE_Uniform                  *myLightEnabledUniform;
    unsigned                     myNumLightStates;
    bool                         myNormalizeGlobalAmbient;
    unsigned                     myLightModelSet:1,
                                 myUseOGLSpots:1,
                                 myAllowLightSpecular:1,
                                 myFirstInitialize:1;

    RE_StateInfo   stateInfo;

    short          projectionIndex;
    short          lineWidthIndex;
    short          lineStyleIndex;
    short          patternIndex;
    short          colorStackIndex;
    short          pointSizeIndex;

    float          myXZoom;
    float          myYZoom;

    float          zNear, zFar;

    static short   theXRes;
    static short   theYRes;
    static short   theVirtualX;
    static short   theVirtualY;
    static short   theDotsPerInch;

    short          currentDisplayMode;
    short          currentDrawingMode;
    short          currentMapSize;

    short          overlayMode;
    short          fullScreenOverlayActive;

    float          pickLeft;
    float          pickRight;
    float          pickBottom;
    float          pickTop;

    UT_Bool        isRGBmode;

    static RE_Server    *theServer;

    RE_OGLContext        pushedGraphicsContext;
    
#if ! RE_OGL_SINGLE_CONTEXT
    RE_OGLContext        myContext;
    bool                 myContextInitialized;
    OGLDrawable          myDrawable;
    OGLDrawable          myPushedDrawable;
    
    UT_SpinLock          myOpenGLLock;
    int                  myOpenGLContextLockCount;
#endif

    static UT_Pointers   theVisuals;

#ifndef CELLBE
    GLUquadricObj       *filledQuadric();
    GLUquadricObj       *unfilledQuadric();
    GLUquadricObj       *myFilledQuadric, *myUnfilledQuadric;
#endif
    float                wPosX, wPosY, wPosZ;

    short               *scanline;
    short                scanlength;

    char                 scissorEnabled;

#ifndef CELLBE
    RE_Tesselator       *tesselator;
#endif
    float                rx, ry, rz;
    int                  myViewportFontOffsetX, myViewportFontOffsetY;

    uint                *pickBuffer;
    uint                *realPickBuffer;
    long                 pickBufferSize;

    RE_Window           *currentWindow;
    RE_Window           *mySavedMainThreadCurrentWindow;
    static RE_WindowList *theWindowList;
    static RE_Window    *theMainContextWindow;

    int                  currGLError;

    void                 initRasterCopy();
    void                 initGLExtensions();
public:
    int                  hasGLExtension( RE_Extension ext ) const;
private:

    // These store version information
    // for the runtime OpenGL implementation.
    static int           majorGLVersion;  
    static int           minorGLVersion;  

    static bool          initGLVersionInfo();

    int                  drawPixelsMode;

    //
    //  maintain OGL state internally for faster access, and to 
    //  eliminate the glGet*() calls.
    //
    void                 getState();    // load the following state variables

public:
    //  use macros for state flags and values
#define RE_FLAG_STATE(RE_NAME,GL_FLAG) \
    GLint       _##RE_NAME ; \
    void        enable##RE_NAME () { if( !_##RE_NAME ) { ::glEnable( GL_FLAG ); _##RE_NAME = GL_TRUE; } } \
    void        disable##RE_NAME () { if( _##RE_NAME ) { ::glDisable( GL_FLAG ); _##RE_NAME = GL_FALSE; } } \
    int         get##RE_NAME () const { return _##RE_NAME ; } \
    void        set##RE_NAME () { _##RE_NAME = ::glIsEnabled( GL_FLAG ); }

    RE_FLAG_STATE(ColorMaterial,GL_COLOR_MATERIAL);
    RE_FLAG_STATE(DepthCueing,GL_FOG);
    RE_FLAG_STATE(DepthTest,GL_DEPTH_TEST);
    RE_FLAG_STATE(Dither,GL_DITHER);
    RE_FLAG_STATE(Lighting,GL_LIGHTING);
    RE_FLAG_STATE(Scissor,GL_SCISSOR_TEST);
    RE_FLAG_STATE(Blending,GL_BLEND);
    RE_FLAG_STATE(AlphaTest,GL_ALPHA_TEST);
    RE_FLAG_STATE(LineSmoothing,GL_LINE_SMOOTH);
    RE_FLAG_STATE(PointSmoothing,GL_POINT_SMOOTH);
    RE_FLAG_STATE(Stencil,GL_STENCIL_TEST);
#undef  RE_FLAG_STATE

#define RE_FLAG_11_STATE(RE_NAME,GL_FLAG) \
        GLint   _##RE_NAME ; \
        void    enable##RE_NAME () { if( (!_##RE_NAME) && hasGL11() ) { ::glEnable( GLenum(GL_FLAG) ); _##RE_NAME = GL_TRUE; } } \
        void    disable##RE_NAME () { if( _##RE_NAME && hasGL11() ) { ::glDisable( GLenum(GL_FLAG) ); _##RE_NAME = GL_FALSE; } } \
        int     get##RE_NAME () const { return _##RE_NAME ; } \
        void    set##RE_NAME () { if( hasGL11() ) { _##RE_NAME = ::glIsEnabled( GLenum(GL_FLAG) ); } else { _##RE_NAME = GL_FALSE; } }

    RE_FLAG_11_STATE(PointOffset,GL_POLYGON_OFFSET_POINT);
    RE_FLAG_11_STATE(LineOffset,GL_POLYGON_OFFSET_LINE);
    RE_FLAG_11_STATE(FillOffset,GL_POLYGON_OFFSET_FILL);
#undef  RE_FLAG_11_STATE

    void        updateBlendState();
    void        updateSmoothState();    
private:
    RE_RenderBuf    drawBuffer;

    GLint       _matrixMode;
    GLint       getOGLMatrixMode() { return _matrixMode; }
    void        setOGLMatrixMode( GLint mode ) { if( _matrixMode != mode ) { ::glMatrixMode( GLenum(mode) ); _matrixMode = mode; } }

    GLint       maxClipPlanes;
    GLint       getOGLMaxClipPlanes() { return maxClipPlanes; }
    void        setOGLMaxClipPlanes() { ::glGetIntegerv( GL_MAX_CLIP_PLANES, &maxClipPlanes ); }

    unsigned int getShadowFrameBuffer(GLuint &shadowtx);

private:
    UT_Bool     _colorBufferWriting;
    UT_Bool     _depthBufferWriting;

public:
    // Using these methods, you can disable updates to the colour and/or depth
    // bits of the frame buffer.  Be careful with these, since the associated
    // calculations will still be performed (eg. even if color buffer updates are
    // disabled, useless lighting calculations are still done if GL_LIGHTING is
    // enabled).  Same with GL_DEPTH_TEST.  So you can easily write inefficient code.  
    void         enableColorBufferWriting();
    void        disableColorBufferWriting();
    UT_Bool         getColorBufferWriting();
    void            setColorBufferWriting();

    // Note that popBlendState() will reset the depth buffer write mask if
    // called enable or disable is called between a push/popBlendState(), to
    // the state it was in when pushBlendState() was called. This is due to
    // the characteristics of blendAlpha().
    void         enableDepthBufferWriting();  // Side effects with blendAlpha().
    void        disableDepthBufferWriting();
    UT_Bool         getDepthBufferWriting();
    void            setDepthBufferWriting();

    void            updateStacks();

    //
    //  viewport and scissor have flags, since they are more expensive 
    //  get.  The RE_OGLBox is stored in the format returned by OGL, 
    //  but with access routines for right and bottom.
    //
    struct      RE_OGLBox {
        GLint   v[4];

        GLint   x() const { return v[0]; }
        GLint   y() const { return v[1]; }
        GLint   width() const { return v[2]; }
        GLint   height() const { return v[3]; }

        void    x( GLint _x ) { v[0] = _x; }
        void    y( GLint _y ) { v[1] = _y; }
        void    width( GLint _w ) { v[2] = _w; }
        void    height( GLint _h ) { v[3] = _h; }

        GLint   left() const { return v[0]; }
        GLint   bottom() const { return v[1]; }
        GLint   right() const { return left() + width() - 1; }
        GLint   top() const { return bottom() + height() - 1; }

        void    leftRight( GLint l, GLint r) { v[0] = l; width( r - l + 1 ); }
        void    bottomTop( GLint b, GLint t) { v[1] = b; height( t - b + 1 ); }

    } scissorState, viewportState;

    int viewportStateValid;
    int scissorStateValid;

    void        getViewport();                  // get the viewportState 


    unsigned    lightingOn:2;

    //  save and restore GL state to speed up any call to glDrawPixels 
    void                 preDrawPixels( int allowDither = TRUE );
    void                 postDrawPixels();

    //
    //  Flags for RE_STRICT
    //
    int         beginBegun;

    // Vertex output handler
    RE_OGLVertex        *myVtxOut;

    //
    //  Info for displayRaster if ABGR extrension not supported.
    //
    UT_RGBA             *drScanline;
    int                  drScanlineWidth;
    int                  enabled;           // gross hack to disable RE calls

    short        cacheIndex;
    short        avoidCacheCount;
    int          myFloatZoomSupported;

    float        myDefaultStacklessColor[4];

    // These are the state caches for our mulitple texture units:
    int          myActiveTexture;
    int          myTexture2DFlags, myTexture3DFlags, myTextureCubeMapFlags;
    int          myTextureMode[32];
    int          myMaxTextureUnits;
    int          myMaxTextureSize;

    int          myShadowMapSize;

    bool         myCompactPick;

    RE_OGLExt *  myExt;

    // which thread this context was created in.
    ut_thread_id_t      myNativeThread;
    
    // blending stack
    int           myBlendLevel;
    re_BlendState myBlendStack[RE_BLEND_STACK_SIZE];

    // smooth lines stack
    int            mySmoothLevel;
    re_SmoothState mySmoothStack[RE_SMOOTH_STACK_SIZE];

    // stenciling stack
    int             myStencilLevel;
    re_StencilState myStencilStack[RE_STENCIL_STACK_SIZE];

    // List of screens for multiple monitors; contains the area of each.
    // It is still valid for one monitor, just 1 screen is listed.
    static UT_RefArray<UT_DimRect>  theScreens;
    static UT_RefArray<UT_DimRect>  theWorkAreas;

    bool         myFrontBufferDirty;
    int          myXORDrawCount;

    bool         myMultisampleEnable;
    bool         myIsAllowingOtherThreads;

    // Bound built-in uniform list for RE_Uniform.
    const RE_Uniform    *myBuiltInUniforms[RE_UNIFORM_BUILT_IN__count]; 
    
    // Card and driver info
    static RE_GraphicsDevice    theDevice;
    static int                  theDriverMajor;
    static int                  theDriverMinor;
    static int                  theDriverBuild;
    
    static bool  theHasShadersExt;
    static bool  theFastDisplayRasterHack;
    
    static UT_ThreadSpecificValue <RE_OGLRender*> theCurrentRender;
#if ! RE_OGL_SINGLE_CONTEXT
    static UT_ThreadSpecificValue <RE_OGLRender*> theLastRender;
#endif
};

class RE_API RE_RenderAutoLock
{
public:
     RE_RenderAutoLock(RE_OGLRender *r)
         : myR(r)
         { myR->lockContextForRender(); }
     
    ~RE_RenderAutoLock()
         { myR->unlockContextAfterRender(); }
private:
    RE_OGLRender *myR;
};
    

#endif

---