text: /*=========================================================================
  
    Program:   Visualization Toolkit
    Module:    vtkOpenGLState.h
  
    Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen
    All rights reserved.
    See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
  
       This software is distributed WITHOUT ANY WARRANTY; without even
       the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
       PURPOSE.  See the above copyright notice for more information.
  
  =========================================================================*/
  // .NAME vtkOpenGLState - Raw OpenGL State.
  // .SECTION Description
  // A vtkOpenGLState object can record the OpenGL state from OpenGL query calls.
  // The only purpose of this class is debugging. It is useful when there is no
  // available OpenGL debugging tool of if the existing OpenGL debugging tools
  // cannot work in special configurations.
  // 
  // The typical usage, is to dump the state in a file at different points of
  // an algorithm. To use it, create an instance of vtkOpenGLState by passing it
  // a valid OpenGL context (a vtkOpenGLRenderWindow), call Update(), call
  // PrintSelf() on a ofstream. Debugging consists then to perform a diff between
  // output text files.
  
  // .SECTION Implementation
  // Not all the OpenGL state is covered yet.
  
  #ifndef __vtkOpenGLState_h
  #define __vtkOpenGLState_h
  
  #include "vtkgl.h"
  #include <vector>
  
  class vtkOpenGLRenderWindow;
  
  class vtkOpenGLMaterialState
  {
  public:
    GLfloat Ambient[4];
    GLfloat Diffuse[4];
    GLfloat Specular[4];
    GLfloat Shininess;
    
    GLfloat AmbientIndex;
    GLfloat DiffuseIndex;
    GLfloat SpecularIndex;
  };
  
  class vtkOpenGLLightState
  {
  public:
    void Update();
    
    GLfloat Ambient[4];
    GLfloat Diffuse[4];
    GLfloat Specular[4];
    GLfloat Position[4];
    GLfloat ConstantAttenuation;
    GLfloat LinearAttenuation;
    GLfloat QuadraticAttenuation;
    GLfloat SpotDirection[4];
    GLfloat SpotExponent;
    GLfloat SpotCutoff;
  };
  
  class vtkOpenGLTextureImageState
  {
  public:
    void Update();
    
    GLvoid *Image;
    GLint Width;
    GLint Height;
    GLint Border;
    GLint InternalFormat;
    GLint RedSize;
    GLint GreenSize;
    GLint BlueSize;
    GLint AlphaSize;
    GLint LuminanceSize;
    GLint IntensitySize;
    
    // 1.2.1
    GLint Depth;
    
    // 1.3
    GLboolean Compressed;
    GLint CompressedImageSize;
    
    // 1.4
    GLint DepthSize;
    
  };
  
  #if 0
  class vtkOpenGLTextureObjectState
  {
  public:
    void Update();
    
    static const int n=10;
    vtkOpenGLTextureImageState Texture1D[n];
    vtkOpenGLTextureImageState Texture2D[n];
    
    GLfloat BorderColor[4];
    GLint MinFilter;
    GLint MagFilter;
    GLint WrapS;
    GLint WrapT;
    GLfloat TexturePriority;
    GLboolean TextureResident;
    
    // 1.2.1
    vtkOpenGLTextureImageState Texture3D[n];
    
    GLint WrapR;
    GLint MinLOD;
    GLint MaxLOD;
    GLint BaseLevel;
    GLint MaxLevel;
    
    // 1.3
    vtkOpenGLTextureImageState TextureCubeMapPositiveX[n];
    vtkOpenGLTextureImageState TextureCubeMapNegativeX[n];
    vtkOpenGLTextureImageState TextureCubeMapPositiveY[n];
    vtkOpenGLTextureImageState TextureCubeMapNegativeY[n];
    vtkOpenGLTextureImageState TextureCubeMapPositiveZ[n];
    vtkOpenGLTextureImageState TextureCubeMapNegativeZ[n];
    
    // 1.4
    GLfloat LODBias;
    GLint DepthTextureMode;
    GLint TextureCompareMode;
    GLint TextureCompareFunc;
    GLboolean GenerateMipmap;
  };
  #endif
  
  class vtkOpenGLTexGenState
  {
  public:
    void Update();
    
    GLboolean Enabled;
    GLfloat EyePlane[4];
    GLfloat ObjectPlane[4];
    GLint Mode;
  };
  
  class vtkOpenGLPixelControl
  {
  public:
    void Update();
    void PrintSelf(ostream &os,
                   vtkIndent indent);
    GLboolean SwapBytes;
    GLboolean LsbFirst; // Warning: cannot be LSBFirst, as it is defined in X.h
    GLint RowLength;
    GLint SkipRows;
    GLint SkipPixels;
    GLint Alignment;
    
    // 1.2.1
    GLint ImageHeight;
    GLint SkipImages;
  };
  
  class vtkOpenGLComponentTransform
  {
  public:
    void Update();
    void PrintSelf(ostream &os,
                   vtkIndent indent);
    GLfloat Scale;
    GLfloat Bias;
  };
  
  class vtkOpenGLRGBAPixelMapState
  {
  public:
    void Update();
    
    GLint Size;
    GLfloat *Map; // values
  };
  
  class vtkOpenGLIndexPixelMapState
  {
  public:
    void Update();
    
    GLint Size;
    GLint *Map; // values
  };
  
  class vtkOpenGLTextureCoordinateProcessingUnit
  {
  public:
    GLfloat CurrentMatrix[16];
    GLint MatrixStackDepth;
    vtkOpenGLTexGenState TextureGenS;
    vtkOpenGLTexGenState TextureGenT;
    vtkOpenGLTexGenState TextureGenR;
    vtkOpenGLTexGenState TextureGenQ;
    // Texture environment generation, 2.0
    GLboolean CoordReplace;
    
    GLfloat CurrentTextureCoords[4];
    GLfloat CurrentRasterTextureCoords[4];
  };
  
  class vtkOpenGLTextureImageUnit
  {
  public:
    // Texture object bound to 1D target/sampler
    GLint TextureBinding1D;
    // Texture object bound to 2D target/sampler
    GLint TextureBinding2D;
    // 1.2.1
    // Texture object bound to 3D target/sampler
    GLint TextureBinding3D;
    // 1.3
    // Texture object bound to cubemap target/sampler
    GLint TextureBindingCubeMap;
  };
  
  class vtkOpenGLTextureImageUnitFixedPipelineState
  {
  public:
    GLboolean Texture1DEnabled;
    GLboolean Texture2DEnabled;
    // 1.2.1
    GLboolean Texture3DEnabled;
    // 1.3
    GLboolean TextureCubeMapEnabled;
  };
  
  class vtkOpenGLClipPlaneState
  {
  public:
    GLfloat Equation[4];
    GLboolean Enabled;
  };
  
  
  // Replaced by shader program
  class vtkOpenGLFixePipelineState
  {
  public:
    // Replaced by verter shader
    
    // Transformation state
    GLboolean Normalize;
    
    // Transformation state: 1.2.1
    GLboolean RescaleNormal;
    
    // Lighting
    GLboolean LightingEnabled;
    
    std::vector<GLboolean> *LightEnabled; // MaxLights (ex:8)
    
    
    // Replaced by fragment shader:
    
    // 1.3
    GLint CombineRGB;
    GLint CombineAlpha;
    GLint Source0RGB;
    GLint Source1RGB;
    GLint Source2RGB;
    GLint Source0Alpha;
    GLint Source1Alpha;
    GLint Source2Alpha;
    GLint Operand0RGB;
    GLint Operand1RGB;
    GLint Operand2RGB;
    GLint Operand0Alpha;
    GLint Operand1Alpha;
    GLint Operand2Alpha;
    GLint RGBScale;
    GLint AlphaScale;
    
    std::vector<vtkOpenGLTextureImageUnitFixedPipelineState> *TextureImageUnitEnabled; // MaxTextureUnits (ex: 4)
    
      // Coloring
    GLboolean FogEnabled;
    // Coloring, 1.4
    GLboolean ColorSumEnabled;
  };
  
  class vtkOpenGLBufferObjectState
  {
  public:
    void PrintSelf(ostream &os,
                   vtkIndent indent);
    
    GLuint Id;
    GLint Size;
    GLenum Usage;
    GLenum Access;
    GLenum AccessFlags; // in GL 3.1 spec but missing in header files
    GLboolean Mapped;
    GLvoid *MapPointer;
    GLint MapOffset; // in GL 3.1 spec but missing in header files
    GLint MapLength; // in GL 3.1 spec but missing in header files
  protected:
    void BufferAccessFlagsToStream(ostream &os);
    const char *BufferUsageToString();
    const char *BufferAccessToString();
  };
  
  class vtkOpenGLShaderState
  {
  public:
    void PrintSelf(ostream &os,
                   vtkIndent indent);
    GLuint Id;
    GLenum Type;
    GLboolean DeleteStatus;
    GLboolean CompileStatus;
    vtkgl::GLchar *InfoLog;
    GLint InfoLogLength;
    vtkgl::GLchar *Source;
    GLint SourceLength;
  protected:
    const char *ShaderTypeToString();
  };
  
  class vtkOpenGLProgramState
  {
  public:
    void PrintSelf(ostream &os,
                   vtkIndent indent);
    GLuint Id;
    GLboolean DeleteStatus;
    GLboolean LinkStatus;
    GLboolean ValidateStatus;
    GLint NumberOfAttachedShaders;
    GLint InfoLogLength;
    GLint ActiveUniforms;
    GLint ActiveUniformMaxLength;
    GLint ActiveAttributes;
    GLint ActiveAttributeMaxLength;
    std::vector<vtkOpenGLShaderState> *AttachedShaders;
    vtkgl::GLchar *InfoLog;
    
    
    bool HasVertexShader;
    bool HasFragmentShader;
  };
  
  class VTK_RENDERING_EXPORT vtkOpenGLState
  {
  public:
    vtkOpenGLState(vtkOpenGLRenderWindow *context);
    ~vtkOpenGLState();
    
    // Save current OpenGL state in the object. 
    void Update();
    
    void PrintSelf(ostream &os,
                   vtkIndent indent);
    
    // There are too many variables to make them protected and implement
    // a public Get method for each of them. We keep them public.
    // I wish C++ would syntaxically forbid construction like c->value=x,
    // like Eiffel does...
    
    
    vtkOpenGLFixePipelineState FixedPipeline;
    
    // OpenGL 1.1 state
    
    // Current values and associated data
    
    GLfloat CurrentColor[4];
    GLfloat CurrentIndex;
    //  CurrentTextureCoords: see vtkOpenGLTextureCoordinateProcessingUnit
    GLfloat CurrentNormal[3];
    
    GLfloat CurrentRasterPosition[4];
    GLfloat CurrentRasterDistance;
    GLfloat CurrentRasterColor[4];
    GLfloat CurrentRasterIndex;
    //  CurrentRasterTextureCoords:  see vtkOpenGLTextureCoordinateProcessingUnit
    GLboolean CurrentRasterPositionValid;
    GLboolean EdgeFlag;
    
    // Current values and associated data, 1.4
    GLfloat CurrentSecondaryColor[4];
    GLfloat CurrentFogCoordinate[3]; // or scalar?
    
    // Current values and associated data, 2.1
    GLfloat CurrentRasterSecondaryColor[4];
    
    
    // Vertex Array Data
    
    GLboolean VertexArrayEnabled;
    GLint VertexArraySize;
    GLint VertexArrayType;
    GLint VertexArrayStride;
    GLvoid *VertexArrayPointer;
    
    GLboolean NormalArrayEnabled;
    GLint NormalArrayType;
    GLint NormalArrayStride;
    GLvoid *NormalArrayPointer;
    
    GLboolean ColorArrayEnabled;
    GLint ColorArraySize;
    GLint ColorArrayType;
    GLint ColorArrayStride;
    GLvoid *ColorArrayPointer;
    
    GLboolean IndexArrayEnabled;
    GLint IndexArrayType;
    GLint IndexArrayStride;
    GLvoid *IndexArrayPointer;
    
    GLboolean TextureCoordArrayEnabled;
    GLint TextureCoordArraySize;
    GLint TextureCoordArrayType;
    GLint TextureCoordArrayStride;
    GLvoid *TextureCoordArrayPointer;
    
    GLboolean EdgeFlagArray;
    GLint EdgeFlagArrayStride;
    GLvoid *EdgeFlagArrayPointer;
    
    // Vertex Array Data, 1.3
    GLenum ClientActiveTexture;
    
    // Vertex Array Data, 1.4
    GLboolean FogCoordinateArrayEnabled;
    GLint FogCoordinateArrayType;
    GLint FogCoordinateArrayStride;
    GLvoid *FogCoordinateArrayPointer;
    
    GLboolean SecondaryColorArrayEnabled;
    GLint SecondaryColorArraySize;
    GLint SecondaryColorArrayType;
    GLint SecondaryColorArrayStride;
    GLvoid *SecondaryColorArrayPointer;
    
    // Vertex Array Data, 1.5, VBO
    GLint ArrayBufferBinding;
    GLint VertexArrayBufferBinding;
    GLint NormalArrayBufferBinding;
    GLint ColorArrayBufferBinding;
    GLint IndexArrayBufferBinding;
    GLint TextureCoordArrayBufferBinding;
    GLint EdgeFlagArrayBufferBinding;
    GLint SecondaryColorArrayBufferBinding;
    GLint FogCoordArrayBufferBinding;
    GLint ElementArrayBufferBinding;
    
    // Vertex Array Data, 2.0
    GLboolean VertexAttribArrayEnabled;
    GLint VertexAttribArraySize;
    GLint VertexAttribArrayStride;
    GLint VertexAttribArrayType;
    GLboolean VertexAttribArrayNormalized;
    GLvoid *VertexAttribArrayPointer;
    
    // Vertex Array Data, 2.1
    GLint VertexAttribArrayBufferBinding;
    
    // Buffer Object State, 1.5
    GLint BufferSize;
    GLint BufferUsage;
    GLint BufferAccess;
    GLboolean BufferMapped;
    GLvoid *BufferMapPointer;
    
    // Transformation state
    
    GLfloat ModelViewMatrix[16];
    GLint ModelViewStackDepth;
    
    GLfloat ProjectionMatrix[16];
    GLint ProjectionStackDepth;
    
    // 2.0
    GLint MaxTextureCoords; // 8
    std::vector<vtkOpenGLTextureCoordinateProcessingUnit> *TCPU;
   
    // 2.0
    GLint MaxCombinedTextureImageUnits; // 16
    std::vector<vtkOpenGLTextureImageUnit> *TIU;
    
    GLint Viewport[4];
    GLfloat DepthRange[2];
    
    GLint MatrixMode;
    GLboolean Normalize;
    
    std::vector<vtkOpenGLClipPlaneState> *ClipPlanes; // MaxClipPlanes (ex: 6)
    
    // Transformation state: 1.2.1, optional
    GLfloat ColorMatrix[16];
    GLint ColorMatrixStackDepth;
    
    // Coloring
    
    GLfloat FogColor[4];
    GLfloat FogIndex;
    GLfloat FogDensity;
    GLfloat FogStart;
    GLfloat FogEnd;
    GLint FogMode;
    
    GLint ShadeModel; // fixed-pipeline and GLSL
    
    // Coloring, 1.4
    GLint FogCoordinateSource; // renamed FogCoordSrc in 1.5
    
    // Lighting
    GLboolean ColorMaterialEnabled;
    GLint ColorMaterialParameter;
    GLint ColorMaterialFace;
    vtkOpenGLMaterialState FrontMaterial;
    vtkOpenGLMaterialState BackMaterial;
    
    GLfloat LightModelAmbient[4];
    GLboolean LightModelLocalViewer;
    GLboolean LightModelTwoSide;
    
    std::vector<vtkOpenGLLightState> *Lights; // MaxLights (ex: 8)
    
    // Lighting: 1.2.1
    GLint lightModelColorControl;
    
    // Rasterization
    GLfloat PointSize;
    GLboolean PointSmoothEnabled;
    
    GLfloat LineWidth;
    GLboolean LineSmoothEnabled;
    GLint LineStipplePattern;
    GLint LineStippleRepeat;
    GLboolean LineStippleEnabled;
    
    GLboolean CullFaceEnabled;
    GLint CullFaceMode;
    GLint FrontFace;
    GLboolean PolygonSmoothEnabled;
    GLint PolygonMode[2]; //0=front, 1=back
    GLfloat PolygonOffsetFactor;
    GLfloat PolygonOffsetUnits;
    GLboolean PolygonOffsetPointEnabled;
    GLboolean PolygonOffsetLineEnabled;
    GLboolean PolygonOffsetFillEnabled;
    GLint PolygonStipple;
    GLboolean PolygonStippleEnabled;
    
    // Rasterization, 1.4
    GLfloat PointSizeMin;
    GLfloat PointSizeMax;
    GLfloat PointFadeThresholdSize;
    GLfloat PointDistanceAttenuation;
    
    // Rasterization, 2.0
    GLboolean PointSpriteEnabled;
    GLint PointSpriteCoordOrigin;
    
    // Multisampling (1.2.1)
    GLboolean MultiSampleEnabled;
    GLboolean SampleAlphaToCoverageEnabled;
    GLboolean SampleAlphaToOneEnabled;
    GLboolean SampleCoverageEnabled;
    GLfloat SampleCoverageValue;
    GLboolean SampleCoverageInvert;
    
    
    
  //  vtkOpenGLTextureObjectState TextureObjects;
    
    // Texture environment generation
    GLint TextureEnvMode;
    GLfloat TextureEnvColor;
    
    // Texture environment generation, 1.3
    GLenum ActiveTexture;
    
    // Texture environment generation, 1.4
    GLfloat TextureLODBias;
    
    // Pixel operations
    // - Scissor
    GLboolean ScissorTestEnabled;
    GLint ScissorBox[4];
    
    GLboolean AlphaTestEnabled;
    GLint AlphaTestFunc;
    GLfloat AlphaTestRef;
    
    GLboolean StencilTestEnabled;
    GLint StencilFunc;
    GLint StencilValueMask;
    GLint StencilRef;
    GLint StencilFail;
    GLint StencilPassDepthFail;
    GLint StencilPassDepthPass;
    
    // - Stencil, 2.0
    GLint StencilBackFunc;
    GLint StencilBackValueMask;
    GLint StencilBackRef;
    GLint StencilBackFail;
    GLint StencilBackPassDepthFail;
    GLint StencilBackPassDepthPass;
    
    GLboolean DepthTestEnabled;
    GLint DepthFunc;
    
    GLboolean BlendEnabled;
    GLint BlendSrc; // <=1.3
    GLint BlendDst; // <=1.3
    
    // Optional in 1.2.1, mandatory in 1.4
    GLint BlendEquation; // renamed BlendEquationRGB in 2.0
    GLfloat BlendColor[4];
    
    // 1.4
    GLint BlendSrcRGB;
    GLint BlendSrcAlpha;
    GLint BlendDstRGB;
    GLint BlendDstAlpha;
    
    // 2.0
    GLint BlendEquationRGB;
    GLint BlendEquationAlpha;
    
    GLboolean DitherEnabled;
    
    GLboolean IndexLogicOpEnabled;
    GLboolean ColorLogicOpEnabled;
    GLint LogicOpMode;
    
    // Framebuffer control (drawing)
    
    // 2.0
    GLint MaxDrawBuffers;
    std::vector<GLint> *DrawBuffers;
    
    GLint IndexWriteMask;
    GLboolean ColorWriteMask[4];
    GLboolean DepthWriteMask;
    GLuint StencilWriteMask;
    GLfloat ColorClearValue[4];
    GLfloat IndexClearValue;
    GLfloat DepthClearValue;
    GLint StencilClearValue;
    GLfloat AccumClearValue[4];
    
    // Framebuffer control (drawing) 2.0
    GLuint StencilBackWriteMask;
    
    // Framebuffer control (drawing) 2.1
    GLint DrawBuffer0;
    GLint DrawBuffer1;
    GLint DrawBuffer3; // <max
    
    // Pixels
    
    vtkOpenGLPixelControl Unpack;
    vtkOpenGLPixelControl Pack;
    
    GLboolean MapColor; // see PixelMap
    GLboolean MapStencil; // see PixelMap
    GLint IndexShift;
    GLint IndexOffset;
    
    vtkOpenGLComponentTransform RedTransform;
    vtkOpenGLComponentTransform GreenTransform;
    vtkOpenGLComponentTransform BlueTransform;
    vtkOpenGLComponentTransform AlphaTransform;
    vtkOpenGLComponentTransform DepthTransform;
    
    GLfloat ZoomX;
    GLfloat ZoomY;
    
    // Size==1 <=> not used.
    vtkOpenGLIndexPixelMapState PixelMapColorIndexToColorIndex;
    vtkOpenGLIndexPixelMapState PixelMapStencilIndexToStencilIndex;
    vtkOpenGLRGBAPixelMapState PixelMapColorIndexToRed;
    vtkOpenGLRGBAPixelMapState PixelMapColorIndexToGreen;
    vtkOpenGLRGBAPixelMapState PixelMapColorIndexToBlue;
    vtkOpenGLRGBAPixelMapState PixelMapColorIndexToAlpha;
    vtkOpenGLRGBAPixelMapState PixelMapRedToRed;
    vtkOpenGLRGBAPixelMapState PixelMapGreenToGreen;
    vtkOpenGLRGBAPixelMapState PixelMapBlueToBlue;
    vtkOpenGLRGBAPixelMapState PixelMapAlphaToAlpha;
    
    // Pixels, 2.1
    GLenum PixelPackBufferBinding;
    GLenum PixelUnpackBufferBinding;
    
    // Relevant only if PixelPackBufferBinding>0
    vtkOpenGLBufferObjectState PixelPackBufferObject;
    // Relevant only if PixelUnPackBufferBinding>0
    vtkOpenGLBufferObjectState PixelUnpackBufferObject;
  
    // 1.2.1, optional
    GLboolean ColorTableEnabled;
    GLboolean PostConvolutionColorTableEnabled;
    GLboolean PostColorMatricColorTableEnabled;
    // TODO ...
    
    // Framebuffer control (reading)
    
    GLint ReadBuffer;
    
    // Evaluators
    // TODO
    
    // Shader Object State 2.0
    vtkOpenGLProgramState *CurrentProgramState;
    
  #if 0
    GLint ShaderType;
    GLboolean DeleteStatus;
    GLboolean CompileStatus;
    vtkgl::GLchar *ShaderLogInfo;
    GLint InfoLogLength;
    vtkgl::GLchar *ShaderSource;
    GLint ShaderSourceLength;
  #endif
    // Program Object State 2.0
    GLuint CurrentProgram;
    
  #if 0
    GLboolean DeleteStatus;
    GLboolean LinkStatus;
    GLboolean ValidateStatus;
    GLint *AttachedShaders;
    GLint InfoLogLength;
    GLint ActiveUniforms;
    GLint ActiveUniformMaxLength;
    GLint ActiveAttributes;
    GLint ActiveAttributesMaxLength;
  #endif
    
    // Vertex Shader State 2.0
    GLboolean VertexProgramTwoSideEnabled;
    GLfloat CurrentVertexAttrib[16][4];
    GLboolean VertexProgramPointSizeEnabled;
    
    // Hints
    GLint PerpectiveCorrectionHint;
    GLint PointSmoothHint;
    GLint LineSmoothHint;
    GLint PolygonSmoothHint;
    GLint FogHint;
    // Hints: 1.3
    GLint TextureCompressionHint;
    // Hints: 1.4
    GLint GenerateMipMapHint;
    // Hints: 2.0
    GLint FragmentShaderDerivativeHint;
    
    // Implementation dependent values
    
    // per OpenGL implementation
    
    GLint MaxLights;
    GLint MaxClipPlanes;
    GLint MaxModelViewStackDepth;
    GLint MaxProjectionStackDepth;
    GLint MaxTextureStackDepth;
    GLint SubpixelBits;
    GLint MaxTextureSize;
    GLint MaxPixelMapTable;
    GLint MaxNameStackDepth;
    GLint MaxListNesting;
    GLint MaxEvalOrder;
    GLint MaxViewportDims;
    GLint MaxAttribStackDepth;
    GLint MaxClientAttribStackDepth;
    
    // per framebuffer
    GLint AuxBuffers;
    GLboolean RGBAMode;
    GLboolean IndexMode;
    GLboolean DoubleBuffer;
    GLboolean Stereo;
    
    // per framebuffer object
    GLint MaxColorAttachments;
    
    // per OpenGL implementation
    
    GLfloat PointSizeRange[2]; // 1.2.1: renamed SmoothPointSizeRange
    GLfloat PointSizeGranularity; // 1.2.1: renamed SmoothPointSizeGranularity
    GLfloat LineWidthRange[2]; // 1.2.1: renamed SmoothLineWidthRange
    GLfloat LineWidthGranularity; // 1.2.1: renamed SmoothLineWidthGranularity
    
    // per framebuffer (for each color buffer)
    GLint RedBits;
    GLint GreenBits;
    GLint BlueBits;
    GLint AlphaBits;
    GLint IndexBits;
    
    GLint DepthBits; // depth buffer
    GLint StencilBits; // stencil buffer
    
    GLint AccumRedBits;
    GLint AccumGreenBits;
    GLint AccumBlueBits;
    GLint AccumAlphaBits;
    
    // per OpenGL implementation, 1.2.1
    GLint Max3DTextureSize;
    GLfloat AliasedPointSizeRange[2];
    GLfloat AliasedLineWidthRange[2];
    GLint MaxElementsIndices;
    GLint MaxElementsVertices;
    
    
    // per OpenGL implementation, 1.2.1, optional
    GLint MaxColorMatrixStackDepth;
    GLint MaxConvolutionWidth[3];
    GLint MaxConvolutionHeight[2];
    
    // per OpenGL implementation, 1.3
    GLint MaxCubeMapTextureSize;
    GLint MaxTextureUnits;
    GLint CompressedTextureFormats;
    GLint NumCompressedTextureFormats;
    
    // per framebuffer, 1.3
    GLint SampleBuffers;
    GLint Samples;
    
    // per OpenGL implementation, 1.4
    GLfloat MaxTextureLODBias;
    
    // per OpenGL implementation, 1.5
    GLint QueryCounterBits;
    
    // per OpenGL implementations, 2.0
    GLubyte *Extensions;
    GLubyte *Renderer;
    GLubyte *ShadingLanguageVersion;
    GLubyte *Vendor;
    GLubyte *Version;  
    GLint MaxVertexAttribs;
    GLint MaxVertexUniformComponents;
    GLint MaxVaryingFloats;
    GLint MaxVertexTextureImageUnits;
    GLint MaxTextureImageUnits;
    GLint MaxFragmentUniformComponents;
    
    // Misc.
    
    // - Display lists
    GLint ListBase;
    GLint ListIndex;
    GLint ListMode;
    
    
    // - Current depth of stacks
    GLint AttribStackDepth;
    GLint ClientAtribStackDepth;
    GLint NameStackDepth;
    
    GLint RenderMode;
    
    // - Selection buffer
    GLvoid *SelectionBufferPointer;
    GLint SelectionBufferSize;
    
    // - Feedback buffer
    GLvoid *FeedbackBufferPointer;
    GLint FeedbackBufferSize;
    GLint FeedbackBufferType;
    
    // - error code
    GLenum ErrorCode;
    
    // Misc, 1.5
    GLint CurrentQuery;
    
    // Framebuffer, GL_EXT_framebuffer_object
    GLint FrameBufferBinding;
    GLint Read;
    
  protected:
    void UpdateCurrentProgram();
    void UpdateShader(size_t i);
    
    void ColorBufferToStream(ostream &os,GLint colorBuffer);
    const char *ErrorCodeToString();
    const char *BlendFuncToString(GLint blendFunc);
    const char *BlendEquationToString(GLint blendEquation);
    const char *LogicOpModeToString();
    const char *ListModeToString();
    const char *BooleanToString(GLint booleanValue);
    const char *ShadeModelToString();
    const char *CullFaceModeToString();
    const char *FrontFaceToString();
    const char *PolygonModeToString(GLint polygonMode);
    const char *AlphaTestFuncToString();
    const char *DepthFuncToString();
    const char *RenderModeToString();
    const char *MatrixModeToString();
  
    const char *ValueToString(GLint value,
                              int valueTable[],
                              const char *stringTable[],
                              int tableSize);
    
    void PrintMatrix(ostream &os,
                     vtkIndent indent,
                     GLfloat matrix[16]);
    
    vtkOpenGLRenderWindow *Context;
  };
  
  
  
  #endif
  