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. Comamnds are grouped, in this order,
 *   under these tags:
 *
 *      - RENDERING ENVIRONMENT         (gl version, extensions, driver)
 *      - MONITOR SCREEN                (monitor setup)
 *      - DISPLAY MODE & WINDOWS        (windows, visuals)
 *      - ERROR REPORTING               (gl errors)
 *      - FRAMEBUFFER OBJECTS
 *      - BUFFER CONTROL                
 *      - FRUSTUM & CLIPPING
 *      - TRANSFORMATION
 *      - COLOR
 *      - LINE & POINT STYLES
 *      - STENCIL, LOGIC & DEPTH
 *      - BLENDING & SMOOTHING
 *      - DISPLAY LISTS
 *      - MATERIALS
 *      - GLSL SHADERS
 *      - TEXTURING
 *      - LIGHTING & SHADING
 *      - PICKING
 *      - RASTER OPERATIONS
 *      - SIMPLE PRIMITIVES             (rect, circles, arcs)
 *      - FONT RENDERING
 *      - SURFACES                      (nurbs)
 *      - OBSOLETE DRAWING METHODS      (begin/end stuff, vertex calls)
 */
#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_IntArray.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>

#include <UT/UT_VectorTypes.h>
class UT_RGBA;
class UT_WorkBuffer;
class RE_Light;
class IMG_Raster;
class TIL_Raster;
class PXL_Raster;
class PXL_Lookup;

class RE_Cursor;
class RE_Font;
class RE_OGLFramebuffer;
class RE_Material;
class RE_OGLMaterial;
class RE_OGLTexture2DMap;
class RE_OGLTexture;
class RE_Server;
class RE_Uniform;
class RE_Visual;
class RE_Window;
class RE_WindowList;
class RE_OGLFramebuffer;
class RE_GeometryObject;
class RE_OcclusionQuery;

class RE_Tesselator;
class RE_OGLExt;
class RE_Shader;
class RE_Render;
class RE_SmartObject;
class re_UniformEntry;

#include "RE_OGLState.h"
#include "RE_OGLDisplayList.h"
#include "RE_Extension.h"
#include "RE_LightVal.h"
#include "RE_OGLVertex.h"
#include "RE_Uniform.h"

typedef RE_OGLDisplayList RE_CacheObject;

#define OPEN_GL

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

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

    const char          *className() const;
    static void          initialize();
    bool                 isInitialized() const { return !myFirstInitialize; }
    
    // For RE_OGLRender methods to pass an RE_Render * to various objects
    virtual RE_Render *getRender() = 0;


    // RENDERING ENVIRONMENT ------------------------------------------------
    // You can use these methods to query support for a specific OpenGL
    // version on the machine Houdini is running on.
    static bool          hasGL11();
    static bool          hasGL12(); 
    static bool          hasGL13();
    static bool          hasGL14();
    static bool          hasGL15();
    static bool          hasGL20();
    static bool          hasGL21();
    static int           glMajorVersion();
    static int           glMinorVersion();

    // Determines the version of GLSL. Currently it's either 1.xx or 0.0 (unsup)
    int                  glslMajorVersion();  // 1
    int                  glslMinorVersion();  // 0, 10, 20, 30, 40 or 50

    int                  hasGLExtension(RE_Extension e) const;
    
    // These track whether GL2 is supported.
    static bool          hasShadersExt();
    static void          disableShadersExt();

    // 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();

    // The driver version. NVidia uses XX.XX, while ATI uses X.XX.XX
    static bool          hasDriverVersion();
    static int           getDriverMajorVersion();
    static int           getDriverMinorVersion();
    static int           getDriverBuildVersion();
    void                 getDriverInfo(UT_WorkBuffer &info);

    // Access to the RE_OGLExt methods. Should not be used outside of RE; use
    // hasGLExtension() instead.
    RE_OGLExt           *getExt() const;

    // Queries to return the total free memory, and optionally the largest
    // available chunk of memory on the GPU. Extension RE_EXT_MEMORY_QUERY
    // is required.
    int64               getFreeTextureMemoryKB(int64 *largest_chunk = NULL);
    int64               getFreeBufferMemoryKB(int64 *largest_chunk = NULL);
    int64               getFreeFramebufferMemoryKB(int64 *largest_chunk = NULL);

    // Returns the amount of free memory on the GPU when Houdini first started.
    static int64        getInitialFreeMemoryKB();
    
    // MONITOR SCREEN ---------------------------------------------------------
    
    // For dual monitors, the span is 0 to res-1, res to virtualres-1.
    // You can get more specific information from getScreen(). 
    static int          resX();
    static int          resY();
    static int          virtualResX();
    static int          virtualResY();

    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();
    static void         updateScreensAndWorkAreas();

    // 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();
    static float pixelsToInches(int n);
    static int   inchesToPixels(float i);
    static void  scaleDPI(fpreal dpi);


    // DISPLAY MODE & WINDOWS ----------------------------------------------
    
    RE_DisplayMode       getMode() const;
    RE_VisualType        getVisualType() const;
    
    void                 enableMultisample(bool enable);
    bool                 isMultisampleEnabled() const;

    void                 getMaxViewportSize(int &w, int &h) 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 *);
    
    bool                 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.
    bool                 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(); 

    static RE_OGLRender *getCurrentRender();
    static RE_WindowList *getWindowList();
    const  RE_Window    *getCurrentWindow() const; 
           RE_Window    *getCurrentWindow();
    
    // These 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;
    // Initializaion
                         // Set Icon loader on a per window basis
    void                 setIconLoader(RE_IDType wid, RE_IconLoader loader);
    void                 clearIconLoader(RE_IDType wid);
                         // Set universal icon loader
    void                 setIconLoader(RE_IconLoader loader);
    
    void                 setIconImage(const char *filename);


    // ERROR REPORTING --------------------------------------------------
    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                 dumpState(bool extended_info = true) const;
    void                 dumpTextureState() const;
    void                 dumpLightState() const;
    void                 verifyState();

    

    // FRAMEBUFFER OBJECTS -------------------------------------------------
    
    // There are two bindings for framebuffers, read and draw. If
    // RE_EXT_FRAME_BUFFER_OBJECT_ARB is not supported, these will be the same.
    int                  pushDrawFramebuffer(); // no change to FBO state
    int                  pushDrawFramebuffer(RE_OGLFramebuffer *fb);
    void                 setDrawFramebuffer(RE_OGLFramebuffer *fb);
    RE_OGLFramebuffer   *getDrawFramebuffer();
    void                 popDrawFramebuffer(int *nest = NULL);

    int                  pushReadFramebuffer(); // no change to FBO state
    int                  pushReadFramebuffer(RE_OGLFramebuffer *fb);
    void                 setReadFramebuffer(RE_OGLFramebuffer *fb);
    RE_OGLFramebuffer   *getReadFramebuffer();
    void                 popReadFramebuffer(int *nest = NULL);

    
    void                 updateFramebuffer();
    // Only called by RE_OGLFramebuffer; updates the current FBO state.
    void                 updateCurrentFramebuffer(RE_OGLFramebuffer *fb,
                                                  bool for_draw);
    
    
    // BUFFER CONTROL -------------------------------------------------------

    // 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(float z = 1.0);
    void                clearCZ(float z = 1.0);
    void                clearS();

    // 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();
    bool                getColorBufferWriting();
    void                updateColorBufferWriting();

    // 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(); 
    void                disableDepthBufferWriting();
    bool                getDepthBufferWriting();
    void                updateDepthBufferWriting();
    
    int                 enableZbuffer(int state, int clear_it);
    void                swapbuffers();

    // By default, the buffer is not changed (RE_BUFFER_UNINIT)
    int                 pushDrawBuffer( RE_RenderBuf buf = RE_BUFFER_UNINIT);
    void                popDrawBuffer(int *nest = 0);
    void                setDrawBuffer( RE_RenderBuf buf );
    RE_RenderBuf        getDrawBuffer();

    int                 pushReadBuffer( RE_RenderBuf buf = RE_BUFFER_UNINIT);
    void                popReadBuffer(int *nest = 0);
    void                setReadBuffer( RE_RenderBuf buf );
    RE_RenderBuf        getReadBuffer();

    // 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;
    void                setFrontBufferDirty(bool d);

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

    
    // FRUSTUM & CLIPPING  ------------------------------------------------
    void         ortho2DW(float l, float r, float b, float t);
    void         ortho3DW(float l, float r, float b, float t, float n,float f);

    void         perspective(float fov_radians, 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,
                            const UT_DimRect &viewport,
                            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, 
                           const UT_DimRect &viewport,
                           const UT_Matrix4 &proj, 
                           const UT_Matrix4 &view,
                           float *xs, float *ys);

    // masked rendering (scissor)
    void         viewport2DI(const UT_DimRect &rect);
    void         screenMask2DI(const UT_DimRect &rect);
    void         disableScreenMask();
    void         intersectMask2DI(const UT_DimRect &rect);
    UT_DimRect   getScreenMask2DI();
    UT_DimRect   getViewport2DI();
    bool         getViewportMaskActive() const;

    // Call ortho2DW() from a viewport rectangle
    void         orthoFromViewport2DI(const UT_DimRect &viewport)
                 {
                    ortho2DW(viewport.x1(), viewport.x2e(),
                             viewport.y1(), viewport.y2e());
                 }

    // Setup an orthographic pixel viewport
    void         viewportOrtho2DI(const UT_DimRect &rect)
                    { viewport2DI(rect); orthoFromViewport2DI(rect); }

    // clip planes
    void         clipPlane(int which, int onoff, const UT_Vector4 *parms = 0);
    int          getOGLMaxClipPlanes();

    // Active Occlusion query (only 1 active at a time)
    void         setActiveOcclusionQuery(RE_OcclusionQuery *q);
    RE_OcclusionQuery *getActiveOcclusionQuery() const;

    // Backface culling
    int          isBackface();
    void         setBackface(int removeBackface = 0);
    int          getReverseWinding();
    void         setReverseWinding(int reverse_winding);

    // polygon/line offset
    bool         isPointOffset();
    bool         isLineOffset();
    bool         isPolygonOffset();
    void         pointOffset( bool onoff );
    void         lineOffset( bool onoff );
    void         polygonOffset( bool onoff );
    void         setOffsetAmount( float variable, float constant );
    void         getOffsetAmount( float* variable, float* constant );
    

    // TRANSFORMATION ------------------------------------------------------
    void         pushViewport();
    void         popViewport();

    // pushes both the viewport and the matrix. 
    void         pushState(int viewing);
    void         popState();

    void         matrixMode(RE_MatrixMode mode);
    RE_MatrixMode getMatrixMode();
    
    void         pushMatrix(int update_projection=1);
    void         popMatrix(int update_projection=1);
    
    void         loadIdentityMatrix();
    void         loadMatrix(const UT_Matrix4 &m);
    void         loadMatrix(const UT_DMatrix4 &m);
    
    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);
    

    // COLOR -----------------------------------------------------------------
    void         setColor(const UT_Color &c, float alpha=1.0);
    void         setColor(float r, float g, float b, float a);
    void         setColorMask(bool red, bool green, bool blue, bool alpha);
    void         getColorMask(bool &red, bool &green, bool &blue, bool &alpha);
    void         getColor(UT_Color &c) const;
    void         setAlpha(float alpha);
    float        getAlpha() const;
    int          pushColor();
    void         popColor(int *nest = NULL);
    int          pushColor(const UT_Color &c, float alpha=1.0f);
    void         resetColorCache();

    
    // LINE & POINT STYLES --------------------------------------------------
    int          pushPattern(RE_FillPattern p);
    void         popPattern(int *nest = NULL);

    int          pushLineStyle(RE_LineStyle s);
    void         popLineStyle(int *nest = NULL);

    int          pushLineWidth(float w);
    void         popLineWidth(int *nest = NULL);
    float        getLineWidth() const;
    float        getMaxSmoothLineWidth();

    int          pushPointSize(float size);
    void         popPointSize(int *nest = NULL);
    void         setPointSize(float size);

    
    // STENCIL, LOGIC & DEPTH ------------------------------------------------

    void          setZFunction(RE_ZFunction func);
    RE_ZFunction  getZFunction() const;
    int           isZbuffer();
    void          updateZFunction() const;

    void          enableDepthClamp(bool b);
    bool          getDepthClamp() const;
    
    int           pushStencilState();
    void          popStencilState(int *nest = NULL);
    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);
    void          updateStencilState();
    void          resetSFunction();
    void          resetSWriteMask();
    void          resetSClearValue();
    void          resetSOperation();

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

    // 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(RE_CacheObject *&id);
    void                 endXORDraw  (RE_CacheObject *&id);
    void                 clearXORDraw(RE_CacheObject *&id);
    void                 resetXORDraw(RE_CacheObject *&id);


    
    // BLENDING and SMOOTHING -----------------------------------------------
    
    int           pushBlendState();
    void          popBlendState(int *nesting = 0);
    
    bool          isBlending() const;
    void          blend(int onoff);
    void          setBlendFunction(RE_BlendSourceFactor  sourceFactor,
                                   RE_BlendDestFactor    destFactor);
    bool          setAlphaBlendFunction(RE_BlendSourceFactor  sourceFactor,
                                        RE_BlendDestFactor    destFactor,
                                        bool force = false);
    void          getBlendFunction(RE_BlendSourceFactor* sourceFactor,
                                  RE_BlendDestFactor*   destFactor);
    void          getAlphaBlendFunction(RE_BlendSourceFactor  *sourceFactor,
                                        RE_BlendDestFactor    *destFactor);

    // blendAlpha uses (Sa, 1-Sa). blendAlphaPremult uses (1, 1-Sa) (assumes
    // color is premultiplied)
    void          blendAlpha(int onoff, int usezbuffer=0);
    void          blendAlphaPremult(bool onoff, int usezbuffer=0);
    
    void          alphaTest(int onoff);
    void          setAlphaTestFunction(RE_ZFunction func, float val);

    int           pushSmoothLines();
    void          popSmoothLines(int *nesting = 0);
    void          forceSmooth();
    void          smoothBlendLines(RE_SmoothMode mode);
    void          smoothBlendLinesNoFlagChange(bool by_smooth);
    RE_SmoothMode getSmoothLines();

    int           getBlendSmoothLevel() const;

    static void   allowSmoothLines(int yn);
    static int    allowsSmoothLines();

    static int    getGLBlendSource(RE_BlendSourceFactor sourceFactor);
    static int    getGLBlendDest(RE_BlendDestFactor destFactor);
    
    // DISPLAY LISTS -------------------------------------------------------

    RE_CacheObject *startObjectDefine();                
    void          endObjectDefine(bool push_attribs = true);                    
    void          deleteObject(RE_CacheObject *obj);
    void          drawObject(RE_CacheObject *obj);      

    int           useDisplayLists();
    int           isCaching() const;
    void          insertGeometryIntoCache(RE_GeometryObject *obj,
                                          const char *gname);
    void          insertReferenceIntoCache(RE_GeometryObject *obj);

    
    // 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().
    RE_SmartObject *startSmartObjectDefine();   
    bool          endSmartObjectDefine(bool push_attribs = true);       
    void          deleteSmartObject(RE_SmartObject *obj);       
    bool          isSmartObjectDirty(RE_SmartObject *obj);

    bool          inObjectDefine() const;
    bool          trackingObjectShaderUsage() const;
    bool          trackingObjectTextureUsage() const;
    
    // Return an array of shader programs used by the smart object.
    const UT_IntArray   *getShadersUsedBySmartObject(RE_SmartObject *obj);

    // 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.
    static bool  notifySmartObjectsOfShaderDeletion( int shader_idx );
    static 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 );

    // Ditto for textures.
    void         recordTextureForSmartObject( int texture_idx );


    
    // MATERIALS -------------------------------------------------------------

    void         clearAllMaterials();
    void         clearAllTextures();

    // 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, bool texture=true);
    int          pushMaterial(RE_Material *mat, int layer=0, bool texture=true);
    void         popMaterial(int *nest = NULL);

    // 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();

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

    // Apply the default shader to a material
    bool                 assignDefaultShader(RE_OGLMaterial *mat, int layer=0,
                                             bool textured = true);
    RE_Shader           *getDefaultShader();

    // GLSL SHADERS ---------------------------------------------------------

    int          pushShader(); // no change to state
    int          pushShader(RE_Shader *s);
    void         bindShader(RE_Shader *s);
    RE_Shader   *getShader();
    void         popShader(int *nest = NULL);
    
    void         updateShader(RE_Shader *s); // only called by RE_Shader.
    
    // Assign a built-in uniform to a value. NULL may be passed to clear the
    // value. This should only be used by RE_Uniform. If owned = true, the 
    // uniform is freed when overwritten.
    void         setUniform(RE_UniformBuiltIn builtin_var_type,
                            RE_Uniform *var, bool owned);
    RE_Uniform  *getUniform(RE_UniformBuiltIn builtin_var_type,
                            bool &owned);

    // Prints all builtins that have been assigned, or only those which the
    // current shader has bound (if bound_only is true).
    void         printBuiltinUniforms(bool bound_only);

    int          pushUniform(RE_UniformBuiltIn builtin_var_type);
    void         popUniform(int *level = NULL);

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

    
    // TEXTURING -------------------------------------------------------------

    // Set the texture type for the active or given texture unit (0-31)
    void         enableTexture(RE_TextureDimension t,
                               int textureunit = RE_ACTIVE_UNIT);
    void         disableTexture(int textureunit = RE_ACTIVE_UNIT);
    bool         isTextureEnabled(RE_TextureDimension t,
                                  int textureunit = RE_ACTIVE_UNIT) const;

    // Bind the given texture to the specified, or active, texture unit. The
    // texturing mode can be optionally set at the same time (if not set to
    // UNKNOWN). If texturing for the texture's type is not enabled on the
    // texturing unit, it is enabled.
    void         bindTexture(RE_OGLTexture *tex,
                             int unit = RE_ACTIVE_UNIT,
                             RE_TextureMode mode = RE_TEXTURE_UNKNOWN);

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

    // Set the texture combine mode for the active or specified texture unit
    void         setTextureMode(RE_TextureMode mode,
                                int textureunit = RE_ACTIVE_UNIT);
    RE_TextureMode getTextureMode(int textureunit = RE_ACTIVE_UNIT) const;

    // Save the texture state for the specified texture unit, or all of
    // them (RE_ALL_UNITS). If the entire state is pushed, the active texture
    // unit is saved as well. RE_ALL_UNITS is relatively expensive, so use
    // with care. push returns a nesting index which can be passed to pop to
    // ensure proper nesting of push/pop calls.
    int          pushTextureState(int textureunit = RE_ACTIVE_UNIT);
    void         popTextureState(int *nest = NULL);

    // The type and texture object currently bound to the given,
    // or current (-1), texture unit
    RE_TextureDimension getBoundTextureType(int texunit = RE_ACTIVE_UNIT) const;
    RE_OGLTexture      *getBoundTexture(int texunit = RE_ACTIVE_UNIT) const;

    
    // This will disable for all texture units.
    void         disableAllTextures();
    
    // Reads in initial values for all the textures.
    void         updateTextureState() const;
    
    // Query the maximum number of texture units we support.
    int          getMaxTextureUnits() const
                                           { return myMaxTextureUnits; }
    int          getMaxTextureCoords() const
                                           { return myMaxTextureCoords; }
    int          getMaxShaderTextureUnits() const
                                           { return myMaxTextureShaderUnits; }
    int          getMaxVertexTextureUnits() const
                                           { return myMaxTextureVertexUnits; }
    int          getMaxFragmentTextureUnits() const
                                           { return myMaxTextureFragmentUnits; }
    int          getTextureAnisotropyLimit() const
                                           { return myMaxTextureAnisotropy; }

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

    // These methods ensure that the pixel store options are set so that the
    // 
    int          pushReadAlignment(const void *data, int scansize);
    void         popReadAlignment(int *nest = NULL);

    int          pushWriteAlignment(const void *data, int scansize);
    void         popWriteAlignment(int *nest = NULL);

    // Enables seamless cubemap filtering for all cubemaps, if supported.
    void         useSeamlessMaps(bool enable);
    bool         usingSeamlessMaps();

    // 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);

    void         removeTextureRefs(RE_OGLTexture *tex);

    // Returns an 8b RGBA 64x64 texture with 0-1 random values in all
    // components. There is only ever one texture created, unless 'owned'
    // is true. If seed is changed and owned is false, a new set of random
    // numbers will be set to the texture. Do NOT delete this texture if
    // you have set owned to false. Do not cache a pointer to the texture
    // unless you own it.
    RE_OGLTexture *getRandomTexture(unsigned int seed, bool interp,
                                    int size = 64,
                                    bool owned = false);
    
    // LIGHTING & SHADING ---------------------------------------------------

    void         setLightModel(int local_viewer, int two_sided_lighting);

    // Defines a light but does not turn it on. 'light_flags' can be zero or
    // a bitmask of RE_LightDefineFlags (in RE_Types.h)
    unsigned     defineLight(const RE_Light &light, int light_flags = 0);
    
#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

    int          whichGLLightIs(const RE_Light *light);
    
    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();
    int          getMaxLights() const;
    void         setGLSpots(int f);
    void         setAllowSpecular(int f);
    int          getAllowSpecular() const;
    RE_Uniform  *getLightEnabledUniform() const;
    void         setNormalizeGlobalAmbient(bool normalize);
    bool         getNormalizeGlobalAmbient() const;

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

                         // 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);

    // The color used when toggleLightShading() is called to disable lighting.
    void         setNonLitColor(const UT_Color &col);

    // Bind/unbind either the light's projective texture.  The texture is
    // bound to the current texture unit.
    void         useProjectiveTexture(bool ison, RE_Light *light,
                                      RE_TextureCompress format,
                                      bool limitres, int maxw, int maxh,
                                      float texturescale,
                                      bool mipmap, int aniso_samples);

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

    
    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);
    // 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);


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

    void         scaleViewForPick(float *l, float *r, float *b, float *t);

    
    // RASTER OPERATIONS ----------------------------------------------------
    // 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         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);

    float        getRasterX() const;
    float        getRasterY() const;
    float        getRasterZ() const;
    
    // 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 *lookup);
    bool         setupShaderForLUT(RE_Shader *shader,
                                   PXL_Lookup *lookup,
                                   int lut_texture_unit = 1,
                                   float gamma = 1.0f,
                                   bool add_shader = true);
    bool         is3DLUTSupported();
    
    int          isFloatZoomSupported();
    int          getMaxPixelMapSize();
    int          isHalfFloatSupported();

    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);
    TIL_Raster * saveRaster(short x, short y, short w, short h,
                                    PXL_DataFormat format, bool alphatoo,
                                    bool use_backbuf = true);

    void                 setDrawPixelsMode(RE_DrawPixelsMode new_mode);
    RE_DrawPixelsMode    getDrawPixelsMode();
    
    // SIMPLE PRIMITIVES ---------------------------------------------------

    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);

    // FONT RENDERING --------------------------------------------------------
    
    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);
    int          getViewportFontOffsetX() const;
    int          getViewportFontOffsetY() const;

    /// 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);

    /// 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);

    // SURFACES ---------------------------------------------------------------
    
    // 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);


    // -----------------------------------------------------------------------
    // OBSOLETE DRAWING METHODS - use RE_GeometryObject or RE_VertexArray
    //
    // All these methods will become obsolete -- DO NOT USE THEM
    //
    // 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


//
//  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); }

#define SETGLCOLOR(r,g,b,a)             \
        UT_ASSERT(a != -1);             \
        myState->pushColorBuf();        \
        myState->myGLColor[0] = r;      \
        myState->myGLColor[1] = g;      \
        myState->myGLColor[2] = b;      \
        myState->myGLColor[3] = a;
    
    void         c3DS(const short v[3])
                   {
                       myVtxOut->c3DS(v);
                       SETGLCOLOR(v[0]/32768.0f, v[1]/32768.0f,
                                  v[2]/32768.0f, 1.0f);
                   }
    void         c3DW(const float v[3])
                   {
                       myVtxOut->c3DW(v);
                       SETGLCOLOR(v[0], v[1], v[2], 1.0f);
                   }
    void         c4DW(const float v[4])
                   {
                       myVtxOut->c4DW(v);
                       SETGLCOLOR(v[0], v[1], v[2], v[3]);
                   }
    void         cacheC3DW(const float v[3])
                   {
                       if (v[0] != myState->myGLColor[0] ||
                           v[1] != myState->myGLColor[1] ||
                           v[2] != myState->myGLColor[2] ||
                           1.0f != myState->myGLColor[3])
                       {
                           c3DW(v);
                       }

                   }
    void         cacheC4DW(const float v[4])
                   {
                       if (v[0] != myState->myGLColor[0] ||
                           v[1] != myState->myGLColor[1] ||
                           v[2] != myState->myGLColor[2] ||
                           v[3] != myState->myGLColor[3])
                       {
                           c4DW(v);
                       }
                   }
#undef SETGLCOLOR
    
    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         mt2DW(const float v[2], unsigned int tclayer);
    void         mt3DW(const float v[3], unsigned int tclayer);
    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); }

    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);

    void         enable( int state ) { enabled = state; }


    // Called by various RE classes; do not call directly.
    static void  destroyShaderObject(unsigned int progid, bool unreg,
                                     bool shader);
    static void  destroyTextureObject(unsigned int texid, RE_OGLTexture *tex);
    static void  destroyFramebufferObject(unsigned int fbo);
    static void  destroyRenderbufferObject(unsigned int rb);
    static void  destroyBufferObject(unsigned int buf);
    static void  destroyDisplayList(unsigned int list);
    static void  destroyOcclusionQuery(unsigned int query);


#if RE_CHECK_STATE == 4
#define CHECK_STATE(name, flag, expected)       \
    if(!inObjectDefine())                       \
    { int s; ::glGetIntegerv(flag, &s); UT_ASSERT(s == expected); }
#else
#define CHECK_STATE(n,f,e) { }
#endif
    //  use macros for state change functions. Member variables are in
    // RE_OGLState.
#define RE_FLAG_STATE(RE_NAME,GL_FLAG) \
    void enable##RE_NAME () { if( myState->my##RE_NAME##State != 1 ) { myState->pushEnable(); ::glEnable( GL_FLAG ); myState->my##RE_NAME##State = 1; } else CHECK_STATE(RE_NAME,GL_FLAG, 1); } \
    void disable##RE_NAME () { if( myState->my##RE_NAME##State != 0 ) { myState->pushEnable(); ::glDisable( GL_FLAG ); myState->my##RE_NAME##State = 0; } else CHECK_STATE(RE_NAME,GL_FLAG,0); } \
    bool get##RE_NAME () { if(myState->my##RE_NAME##State == 3) update##RE_NAME(); return (myState->my##RE_NAME##State ==1); } \
    void update##RE_NAME () { myState->my##RE_NAME##State = ::glIsEnabled( GL_FLAG ); } \
    void invalidate##RE_NAME() { myState->my##RE_NAME##State = 3; }

    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(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) \
    void enable##RE_NAME () { if( (myState->my##RE_NAME##State) != 1 && hasGL11() ) { myState->pushEnable(); ::glEnable( GLenum(GL_FLAG) ); myState->my##RE_NAME##State = 1; } else if(hasGL11()) CHECK_STATE(RE_NAME,GL_FLAG,1); } \
    void disable##RE_NAME () { if( myState->my##RE_NAME##State && hasGL11() ) { myState->pushEnable(); ::glDisable( GLenum(GL_FLAG) ); myState->my##RE_NAME##State = 0; } else if(hasGL11()) CHECK_STATE(RE_NAME, GL_FLAG, 0); } \
    bool get##RE_NAME () { if(myState->my##RE_NAME##State == 3) update##RE_NAME(); return (myState->my##RE_NAME##State==1) ; } \
    void update##RE_NAME () { if( hasGL11() ) { myState->my##RE_NAME##State = ::glIsEnabled( GLenum(GL_FLAG) ); } else { myState->my##RE_NAME##State = 0; } } \
    void invalidate##RE_NAME() { if(hasGL11()) myState->my##RE_NAME##State=3; }

    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

    
// Private methods ----------------------------------------------------------
private:
    RE_PolyOffStrategy getPolygonOffsetStrategy() const;
    void        updateOffsetAmount();
    
    GLint       getOGLMatrixMode();
    void        setOGLMatrixMode( GLint mode );
    void        updateOGLMaxClipPlanes();

    static void  initTextureCache();
    static void  initTexture3DCache();
    static bool  initGLVersionInfo();
    void         initGLState();
    void         initGLExtensions();
    void         updateGLState();// load the following state variables
    void         updateStacks();
    void         switchTexture(int textureunit, RE_OGLTexture *texture);


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

    RE_CacheObject *allocRenderCache (bool smart_object);
    void         beginCache       ( RE_CacheObject *list);
    void         executeCache     ( RE_CacheObject *list);
    void         endCache(bool push_attribs);

#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.
    static void  internalAddScreen(UT_DimRect rect)
                 { theScreens.append(rect); }
    static void  internalAddWorkArea(UT_DimRect rect)
                 { theWorkAreas.append(rect); }
private:
#endif

    void                updateBlendSmoothState();
    int                 privPushBlendSmoothState(bool smooth_too);
    void                privPopBlendSmoothState(bool smooth_too, int *idx);

    //  save and restore GL state to speed up any call to glDrawPixels 
    void                preDrawPixels( int allowDither = TRUE );
    void                postDrawPixels();
    void                initRasterCopy();
   
    void                freePendingObjects();
    
    // get the viewportState from GL
    void                updateViewport();

    void                resetAmbientLight();

#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);
    
    UT_DimRect   adjustFramebufferViewport(const UT_DimRect &rect, bool to_fbo);


    static RE_ZFunction  oglToREzfunc( int oglZFunc );
    static int           reToOGLzfunc( RE_ZFunction reZFunc );
    static RE_SFunction  oglToREsfunc( int oglSFunc );
    static int           reToOGLsfunc( RE_SFunction reSFunc );
    static RE_SOperation oglToREsoperation( int oglSOperation );
    static int           reToOGLsoperation( RE_SOperation reSOperation );

private:
    // ---------------------------------------------------------------------
    // Cached OpenGL State 

    RE_OGLState *myState;
    RE_OGLState  myNormalState;
    RE_OGLState  myListState;

    // ------------------------------------------------------------------------
    // State independent data
    
    bool        myFirstInitialize;
    int         beginBegun;     //  Flags for RE_STRICT
    int         enabled;           // gross hack to disable RE calls
    bool        myPicking;

    RE_OGLExt   *myExt;
    RE_Window   *currentWindow;
    RE_Window   *mySavedMainThreadCurrentWindow;

    RE_OGLVertex *myVtxOut;     // Vertex output handler

#ifndef CELLBE
    RE_Tesselator *tesselator;
#endif
    uint          *pickBuffer;
    uint          *realPickBuffer;
    long           pickBufferSize;

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

    short          currentDisplayMode;
    short          currentDrawingMode;
    short          currentMapSize;

    short          overlayMode;
    short          fullScreenOverlayActive;
    UT_Bool        isRGBmode;
    RE_OGLContext  pushedGraphicsContext;
    
#if ! RE_OGL_SINGLE_CONTEXT
    RE_OGLContext  myContext;
    bool           myContextInitialized;
    OGLDrawable    myDrawable;
    OGLDrawable    myPushedDrawable;
    
    UT_RecursiveSpinLock    myOpenGLLock;
    int                     myOpenGLContextLockCount;
#endif

    
    int          myMaxTextureUnits;
    int          myMaxTextureCoords;
    int          myMaxTextureShaderUnits;
    int          myMaxTextureVertexUnits;
    int          myMaxTextureFragmentUnits;
    int          myMaxTextureSize;
    int          myMaxTexture3DSize;
    int          myMaxTextureAnisotropy;
    GLint        maxClipPlanes;

    int          myFloatZoomSupported;
    float        myDefaultStacklessColor[4];
    
    bool         myFrontBufferDirty;
    int          myXORDrawCount;
    RE_RenderBuf myDrawBuffer[RE_BUFFER_STACK_SIZE];
    int          myDrawBufferIndex;
    RE_RenderBuf myReadBuffer[RE_BUFFER_STACK_SIZE];
    int          myReadBufferIndex;

    bool         myMultisampleEnable;

    int          currGLError;
    int          drawPixelsMode;
    
    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

    void        *saveBuffer;
    unsigned     saveSize;

    short        cacheIndex;

    RE_State     stateStack[RE_STACK_DEPTH];
    short        stateIndex;

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

#ifndef CELLBE
    GLUquadricObj       *filledQuadric();
    GLUquadricObj       *unfilledQuadric();
    GLUquadricObj       *myFilledQuadric, *myUnfilledQuadric;
#endif

    // Bound built-in uniform list for RE_Uniform.
    RE_Uniform          *myBuiltInUniforms[RE_UNIFORM_BUILT_IN__count]; 
    bool                 myBuiltInUniformsOwned[RE_UNIFORM_BUILT_IN__count]; 

    // Lighting data
    UT_RefArray<RE_LightVal>     myLightArray;
    int *                        myLightStates;
    RE_Uniform                  *myLightEnabledUniform;
    unsigned                     myNumLightStates;
    bool                         myNormalizeGlobalAmbient;
    unsigned                     myLightModelSet:1,
                                 myUseOGLSpots:1,
                                 myAllowLightSpecular:1;
    int            myViewportFontOffsetX, myViewportFontOffsetY;
    RE_CacheObject              *myCurrentList;
    UT_PtrArray<re_UniformEntry *> myUniformStack;

    RE_OGLTexture               *myRandomTexture;
    unsigned int                 myRandomTexSeed;
    bool                         myRandomTexInterp;

    RE_OcclusionQuery           *myActiveQuery;

    RE_Material         *myMaterialStack[RE_MAX_TEXTURE_STATE_STACK];
    bool                 myMaterialTextureStack[RE_MAX_TEXTURE_STATE_STACK];
    int                  myMaterialLayerStack[RE_MAX_TEXTURE_STATE_STACK];
    bool                 myMaterialAlphaTest;
    bool                 myMaterialLighting;
    int                  myMatStackIndex;
    
    
    // Static data ----------------------------------------------------------
    static int           majorGLVersion;  
    static int           minorGLVersion;  
           int           majorGLSLVersion;  
           int           minorGLSLVersion;  

    static RE_Server    *theServer;
    static short   theXRes;
    static short   theYRes;
    static short   theVirtualX;
    static short   theVirtualY;
    static short   theDotsPerInch;
    static bool    theSmoothLinesAllowed;

    // 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;

    static UT_Pointers   theVisuals;
    static RE_WindowList *theWindowList;
    static RE_Window    *theMainContextWindow;
    
    // 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_IntArray   thePendingDeleteTextures;
    static UT_IntArray   thePendingDeleteShaders;
    static UT_IntArray   thePendingDeleteShaderReg;
    static UT_IntArray   thePendingDeleteShaderType;
    static UT_IntArray   thePendingDeleteFBOs;
    static UT_IntArray   thePendingDeleteRenderBuffers;
    static UT_IntArray   thePendingDeleteBufferObjects;
    static UT_IntArray   thePendingDeleteDisplayLists;
    static UT_IntArray   thePendingDeleteOcclQueries;
    static UT_Lock       thePendingDeleteLock;
    
protected:
    static UT_ThreadSpecificValue <RE_OGLRender*> theCurrentRender;
#if ! RE_OGL_SINGLE_CONTEXT
    static UT_ThreadSpecificValue <RE_OGLRender*> theLastRender;
#endif

    // which thread this context was created in.
    ut_thread_id_t      myNativeThread;
    bool         myIsAllowingOtherThreads;
};

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


// RE_SmartObject --------------------------------------------------------

class RE_API RE_SmartObject : public RE_CacheObject
{
public:
    virtual ~RE_SmartObject();

private:
    RE_SmartObject(unsigned int id);

    UT_IntArray myShaderRefs;
    UT_IntArray myTextureRefs;
    bool        myDirtyFlag;

    friend class RE_OGLRender;
};


// Inlines ---------------------------------------------------------------

inline bool
RE_OGLRender::hasGL11() { return ((majorGLVersion > 1) ||
                                  ((majorGLVersion >= 1) &&
                                   (minorGLVersion >= 1))); };
inline bool
RE_OGLRender::hasGL12() { return ((majorGLVersion > 1) ||
                                  ((majorGLVersion >= 1) &&
                                   (minorGLVersion >= 2))); };
inline bool
RE_OGLRender::hasGL13() { return ((majorGLVersion > 1) ||
                                  ((majorGLVersion >= 1) &&
                                   (minorGLVersion >= 3))); };
inline bool
RE_OGLRender::hasGL14() { return ((majorGLVersion > 1) ||
                                  ((majorGLVersion >= 1) &&
                                   (minorGLVersion >= 4))); };
inline bool
RE_OGLRender::hasGL15() { return ((majorGLVersion > 1) ||
                                  ((majorGLVersion >= 1) &&
                                   (minorGLVersion >= 5))); };
inline bool
RE_OGLRender::hasGL20() { return ((majorGLVersion > 2) ||
                                  ((majorGLVersion >= 2) &&
                                   (minorGLVersion >= 0))); };
inline bool
RE_OGLRender::hasGL21() { return ((majorGLVersion > 2) ||
                                  ((majorGLVersion >= 2) &&
                                   (minorGLVersion >= 1))); };

inline int RE_OGLRender::glMajorVersion() { return majorGLVersion; }
inline int RE_OGLRender::glMinorVersion() { return minorGLVersion; }

inline int RE_OGLRender::glslMajorVersion() { return majorGLSLVersion; }
inline int RE_OGLRender::glslMinorVersion() { return minorGLSLVersion; }

inline bool RE_OGLRender::hasShadersExt() { return theHasShadersExt; }
inline void RE_OGLRender::disableShadersExt() { theHasShadersExt = false; }

inline RE_GraphicsDevice
RE_OGLRender::getGraphicsDevice() { return theDevice; }

inline bool RE_OGLRender::hasDriverVersion() { return !(theDriverMajor == 0 &&
                                                        theDriverMinor == 0 &&
                                                        theDriverBuild == 0); }
inline int RE_OGLRender::getDriverMajorVersion() { return theDriverMajor;}
inline int RE_OGLRender::getDriverMinorVersion() { return theDriverMinor;}
inline int RE_OGLRender::getDriverBuildVersion() { return theDriverBuild;}

inline RE_OGLExt *RE_OGLRender::getExt() const   { return myExt; }

inline int RE_OGLRender::resX()         { return theXRes; }
inline int RE_OGLRender::resY()         { return theYRes; }
inline int RE_OGLRender::virtualResX()  { return theVirtualX; }
inline int RE_OGLRender::virtualResY()  { return theVirtualY; }
inline short RE_OGLRender::dpi()        { return theDotsPerInch; }

inline void
RE_OGLRender::updateScreensAndWorkAreas() { determineTwinView(); };

inline float
RE_OGLRender::pixelsToInches(int n)
{
    return (float)n / dpi();
}

inline int
RE_OGLRender::inchesToPixels(float i)
{
    return (int)UTrint(i*(float)dpi());
}

inline RE_Window *
RE_OGLRender::getMainContext() { return theMainContextWindow; }

inline RE_OGLRender *
RE_OGLRender::getCurrentRender() { return theCurrentRender.get(); }

inline RE_WindowList *
RE_OGLRender::getWindowList()   { return theWindowList; }

inline const RE_Window *
RE_OGLRender::getCurrentWindow() const { return currentWindow; }

inline RE_Window *
RE_OGLRender::getCurrentWindow()          { return currentWindow; }

inline void
RE_OGLRender::setIconLoader(RE_IconLoader loader)
{
    iconLoader = loader;
}

inline bool
RE_OGLRender::isFrontBufferDirty() const
{ return myFrontBufferDirty;}

inline void
RE_OGLRender::setFrontBufferDirty(bool d)
{ myFrontBufferDirty = d; }

inline int
RE_OGLRender::getOGLMaxClipPlanes() { return maxClipPlanes; }

inline bool
RE_OGLRender::isPointOffset() { return getPointOffset(); }
inline bool
RE_OGLRender::isLineOffset() { return getLineOffset();  }

inline void
RE_OGLRender::pointOffset( bool onoff )
{
    if( onoff )
        enablePointOffset();
    else
        disablePointOffset();
}

inline void
RE_OGLRender::lineOffset( bool onoff )
{
    if( onoff )
        enableLineOffset();
    else
        disableLineOffset();
}

inline void
RE_OGLRender::getOffsetAmount( float* variable, float* constant )
{
    *variable = myState->_offset_variable;
    *constant = myState->_offset_constant;
}

inline int
RE_OGLRender::pushColor(const UT_Color &c, float alpha) 
{
    int nest = pushColor();
    setColor(c, alpha);
    return nest;
}

inline void
RE_OGLRender::resetColorCache()
{
    myState->myGLColor[0] = myState->myGLColor[1] = myState->myGLColor[2]
        = myState->myGLColor[3] = -1.0f;
}

inline bool
RE_OGLRender::isBlending() const
{
    return myState->myBlendSmoothStack[myState->myBlendSmoothLevel].myBlend==1;
}
inline int
RE_OGLRender::getBlendSmoothLevel() const
{
    return myState->myBlendSmoothLevel;
}

inline void RE_OGLRender::allowSmoothLines(int yn) { theSmoothLinesAllowed=yn; }
inline int  RE_OGLRender::allowsSmoothLines() { return theSmoothLinesAllowed; }

inline bool RE_OGLRender::inObjectDefine() const
{ return myInObjectDefine; }

inline bool RE_OGLRender:: trackingObjectShaderUsage() const
{ return myTrackingObjectShaderUsage; }

inline bool RE_OGLRender::trackingObjectTextureUsage() const
{ return myTrackingObjectTextureUsage; }

inline int
RE_OGLRender::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;
                 }

inline void
RE_OGLRender::setGLSpots(int f) { myUseOGLSpots = f; }

inline void
RE_OGLRender::setAllowSpecular(int f) { myAllowLightSpecular = f; }
inline int
RE_OGLRender::getAllowSpecular() const { return myAllowLightSpecular; }

inline RE_Uniform *
RE_OGLRender::getLightEnabledUniform() const
{ return myLightEnabledUniform; }

inline void
RE_OGLRender::setNormalizeGlobalAmbient(bool normalize)
{ myNormalizeGlobalAmbient = normalize; }

inline bool
RE_OGLRender::getNormalizeGlobalAmbient() const
{ return myNormalizeGlobalAmbient; }

inline float RE_OGLRender::getRasterX() const { return myState->rx; }
inline float RE_OGLRender::getRasterY() const { return myState->ry; }
inline float RE_OGLRender::getRasterZ() const { return myState->rz; }

inline int       
RE_OGLRender::getViewportFontOffsetX() const
{ return myViewportFontOffsetX; }

inline int       
RE_OGLRender::getViewportFontOffsetY() const
{ return myViewportFontOffsetY; }

  
inline int
RE_OGLRender::isCaching() const { return cacheIndex; }

inline void     
RE_OGLRender::setOGLMatrixMode( GLint mode )
{ 
    if( myState->_matrixMode != mode )
    { 
        ::glMatrixMode( GLenum(mode) );
        myState->_matrixMode = mode;
    } 
}

inline void
RE_OGLRender::updateOGLMaxClipPlanes()
{
    ::glGetIntegerv( GL_MAX_CLIP_PLANES, &maxClipPlanes );
}

#endif

---