You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
933 lines
21 KiB
C++
933 lines
21 KiB
C++
/*=========================================================================
|
|
|
|
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.
|
|
|
|
=========================================================================*/
|
|
/**
|
|
* @class vtkOpenGLState
|
|
* @brief Raw OpenGL State.
|
|
*
|
|
* 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.
|
|
*
|
|
* @par Implementation:
|
|
* Not all the OpenGL state is covered yet.
|
|
*/
|
|
|
|
#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
|