v/vtk6/vtk6-doc_6.3.0%2Bdfsg2-2%2Bci202008041822_all.deb

/*=========================================================================


  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.


=========================================================================*/

#ifndef vtkOpenGLState_h

#define vtkOpenGLState_h


#include "vtkRenderingOpenGLModule.h" // For export macro

#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 VTKRENDERINGOPENGL_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

// VTK-HeaderTest-Exclude: vtkOpenGLState.h