blob: 877d7681538e2339c413b525eaaea4cfd1f11169 [file] [log] [blame]
// Copyright 2016 The SwiftShader Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Context.h: Defines the Context class, managing all GL state and performing
// rendering operations.
#ifndef LIBGL_CONTEXT_H_
#define LIBGL_CONTEXT_H_
#include "ResourceManager.h"
#include "common/NameSpace.hpp"
#include "common/Object.hpp"
#include "Image.hpp"
#include "Renderer/Sampler.hpp"
#include "Renderer/Vertex.hpp"
#include "common/MatrixStack.hpp"
#define _GDI32_
#include <windows.h>
#include <GL/GL.h>
#include <GL/glext.h>
#include <map>
#include <list>
#include <vector>
namespace gl
{
class Display;
class Surface;
class Config;
class Command
{
public:
Command() {};
virtual ~Command() {};
virtual void call() = 0;
};
class Command0 : public Command
{
public:
Command0(void (APIENTRY *function)())
: function(function)
{
}
virtual void call()
{
function();
}
void (APIENTRY *function)();
};
template<typename A1>
class Command1 : public Command
{
public:
Command1(void (APIENTRY *function)(A1), A1 arg1)
: function(function)
, argument1(arg1)
{
}
virtual void call()
{
function(argument1);
}
void (APIENTRY *function)(A1);
A1 argument1;
};
template<typename A1, typename A2>
class Command2 : public Command
{
public:
Command2(void (APIENTRY *function)(A1, A2), A1 arg1, A2 arg2)
: function(function)
, argument1(arg1)
, argument2(arg2)
{
}
virtual void call()
{
function(argument1, argument2);
}
void (APIENTRY *function)(A1, A2);
A1 argument1;
A2 argument2;
};
template<typename A1, typename A2, typename A3>
class Command3 : public Command
{
public:
Command3(void (APIENTRY *function)(A1, A2, A3), A1 arg1, A2 arg2, A3 arg3)
: function(function)
, argument1(arg1)
, argument2(arg2)
, argument3(arg3)
{
}
virtual void call()
{
function(argument1, argument2, argument3);
}
void (APIENTRY *function)(A1, A2, A3);
A1 argument1;
A2 argument2;
A3 argument3;
};
template<typename A1, typename A2, typename A3, typename A4>
class Command4 : public Command
{
public:
Command4(void (APIENTRY *function)(A1, A2, A3, A4), A1 arg1, A2 arg2, A3 arg3, A4 arg4)
: function(function)
, argument1(arg1)
, argument2(arg2)
, argument3(arg3)
, argument4(arg4)
{
}
virtual void call()
{
function(argument1, argument2, argument3, argument4);
}
void (APIENTRY *function)(A1, A2, A3, A4);
A1 argument1;
A2 argument2;
A3 argument3;
A4 argument4;
};
template<typename A1, typename A2, typename A3, typename A4, typename A5>
class Command5 : public Command
{
public:
Command5(void (APIENTRY *function)(A1, A2, A3, A4, A5), A1 arg1, A2 arg2, A3 arg3, A4 arg4, A5 arg5)
: function(function)
, argument1(arg1)
, argument2(arg2)
, argument3(arg3)
, argument4(arg4)
, argument5(arg5)
{
}
virtual void call()
{
function(argument1, argument2, argument3, argument4, argument5);
}
void (APIENTRY *function)(A1, A2, A3, A4, A5);
A1 argument1;
A2 argument2;
A3 argument3;
A4 argument4;
A5 argument5;
};
template<typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
class Command6 : public Command
{
public:
Command6(void (APIENTRY *function)(A1, A2, A3, A4, A5, A6), A1 arg1, A2 arg2, A3 arg3, A4 arg4, A5 arg5, A6 arg6)
: function(function)
, argument1(arg1)
, argument2(arg2)
, argument3(arg3)
, argument4(arg4)
, argument5(arg5)
, argument6(arg6)
{
}
~Command6()
{
if(function == glVertexAttribArray)
{
delete[] argument6;
}
}
virtual void call()
{
function(argument1, argument2, argument3, argument4, argument5, argument6);
}
void (APIENTRY *function)(A1, A2, A3, A4, A5, A6);
A1 argument1;
A2 argument2;
A3 argument3;
A4 argument4;
A5 argument5;
A6 argument6;
};
inline Command0 *newCommand(void (APIENTRY *function)())
{
return new Command0(function);
}
template<typename A1>
Command1<A1> *newCommand(void (APIENTRY *function)(A1), A1 arg1)
{
return new Command1<A1>(function, arg1);
}
template<typename A1, typename A2>
Command2<A1, A2> *newCommand(void (APIENTRY *function)(A1, A2), A1 arg1, A2 arg2)
{
return new Command2<A1, A2>(function, arg1, arg2);
}
template<typename A1, typename A2, typename A3>
Command3<A1, A2, A3> *newCommand(void (APIENTRY *function)(A1, A2, A3), A1 arg1, A2 arg2, A3 arg3)
{
return new Command3<A1, A2, A3>(function, arg1, arg2, arg3);
}
template<typename A1, typename A2, typename A3, typename A4>
Command4<A1, A2, A3, A4> *newCommand(void (APIENTRY *function)(A1, A2, A3, A4), A1 arg1, A2 arg2, A3 arg3, A4 arg4)
{
return new Command4<A1, A2, A3, A4>(function, arg1, arg2, arg3, arg4);
}
template<typename A1, typename A2, typename A3, typename A4, typename A5>
Command5<A1, A2, A3, A4, A5> *newCommand(void (APIENTRY *function)(A1, A2, A3, A4, A5), A1 arg1, A2 arg2, A3 arg3, A4 arg4, A5 arg5)
{
return new Command5<A1, A2, A3, A4, A5>(function, arg1, arg2, arg3, arg4, arg5);
}
template<typename A1, typename A2, typename A3, typename A4, typename A5, typename A6>
Command6<A1, A2, A3, A4, A5, A6> *newCommand(void (APIENTRY *function)(A1, A2, A3, A4, A5, A6), A1 arg1, A2 arg2, A3 arg3, A4 arg4, A5 arg5, A6 arg6)
{
return new Command6<A1, A2, A3, A4, A5, A6>(function, arg1, arg2, arg3, arg4, arg5, arg6);
}
class DisplayList
{
public:
DisplayList()
{
}
~DisplayList()
{
while(!list.empty())
{
delete list.back();
list.pop_back();
}
}
void call()
{
for(CommandList::iterator command = list.begin(); command != list.end(); command++)
{
(*command)->call();
}
}
typedef std::list<Command*> CommandList;
CommandList list;
};
struct TranslatedAttribute;
struct TranslatedIndexData;
class Device;
class Buffer;
class Shader;
class Program;
class Texture;
class Texture2D;
class TextureCubeMap;
class Framebuffer;
class Renderbuffer;
class RenderbufferStorage;
class Colorbuffer;
class Depthbuffer;
class StreamingIndexBuffer;
class Stencilbuffer;
class DepthStencilbuffer;
class VertexDataManager;
class IndexDataManager;
class Fence;
class Query;
enum
{
MAX_VERTEX_ATTRIBS = 9,
MAX_UNIFORM_VECTORS = 256, // Device limit
MAX_VERTEX_UNIFORM_VECTORS = sw::VERTEX_UNIFORM_VECTORS - 3, // Reserve space for gl_DepthRange
MAX_VARYING_VECTORS = 10,
MAX_TEXTURE_IMAGE_UNITS = 2,
MAX_VERTEX_TEXTURE_IMAGE_UNITS = 1,
MAX_COMBINED_TEXTURE_IMAGE_UNITS = MAX_TEXTURE_IMAGE_UNITS + MAX_VERTEX_TEXTURE_IMAGE_UNITS,
MAX_FRAGMENT_UNIFORM_VECTORS = sw::FRAGMENT_UNIFORM_VECTORS - 3, // Reserve space for gl_DepthRange
MAX_DRAW_BUFFERS = 1,
IMPLEMENTATION_COLOR_READ_FORMAT = GL_RGB,
IMPLEMENTATION_COLOR_READ_TYPE = GL_UNSIGNED_SHORT_5_6_5
};
const GLenum compressedTextureFormats[] =
{
#if (S3TC_SUPPORT)
GL_COMPRESSED_RGB_S3TC_DXT1_EXT,
GL_COMPRESSED_RGBA_S3TC_DXT1_EXT,
GL_COMPRESSED_RGBA_S3TC_DXT3_EXT,
GL_COMPRESSED_RGBA_S3TC_DXT5_EXT,
#endif
};
const GLint NUM_COMPRESSED_TEXTURE_FORMATS = sizeof(compressedTextureFormats) / sizeof(compressedTextureFormats[0]);
const GLint multisampleCount[] = {4, 2, 1};
const GLint NUM_MULTISAMPLE_COUNTS = sizeof(multisampleCount) / sizeof(multisampleCount[0]);
const GLint IMPLEMENTATION_MAX_SAMPLES = multisampleCount[0];
const float ALIASED_LINE_WIDTH_RANGE_MIN = 1.0f;
const float ALIASED_LINE_WIDTH_RANGE_MAX = 128.0f;
const float ALIASED_POINT_SIZE_RANGE_MIN = 0.125f;
const float ALIASED_POINT_SIZE_RANGE_MAX = 8192.0f;
const float MAX_TEXTURE_MAX_ANISOTROPY = 16.0f;
enum QueryType
{
QUERY_ANY_SAMPLES_PASSED,
QUERY_ANY_SAMPLES_PASSED_CONSERVATIVE,
QUERY_TYPE_COUNT
};
struct Color
{
float red;
float green;
float blue;
float alpha;
};
// Helper structure describing a single vertex attribute
class VertexAttribute
{
public:
VertexAttribute() : mType(GL_FLOAT), mSize(0), mNormalized(false), mStride(0), mPointer(nullptr), mArrayEnabled(false)
{
mCurrentValue[0] = 0.0f;
mCurrentValue[1] = 0.0f;
mCurrentValue[2] = 0.0f;
mCurrentValue[3] = 1.0f;
}
int typeSize() const
{
switch(mType)
{
case GL_BYTE: return mSize * sizeof(GLbyte);
case GL_UNSIGNED_BYTE: return mSize * sizeof(GLubyte);
case GL_SHORT: return mSize * sizeof(GLshort);
case GL_UNSIGNED_SHORT: return mSize * sizeof(GLushort);
case GL_FIXED: return mSize * sizeof(GLfixed);
case GL_FLOAT: return mSize * sizeof(GLfloat);
default: UNREACHABLE(mType); return mSize * sizeof(GLfloat);
}
}
GLsizei stride() const
{
return mStride ? mStride : typeSize();
}
// From glVertexAttribPointer
GLenum mType;
GLint mSize;
bool mNormalized;
GLsizei mStride; // 0 means natural stride
union
{
const void *mPointer;
intptr_t mOffset;
};
BindingPointer<Buffer> mBoundBuffer; // Captured when glVertexAttribPointer is called.
bool mArrayEnabled; // From glEnable/DisableVertexAttribArray
float mCurrentValue[4]; // From glVertexAttrib
};
typedef VertexAttribute VertexAttributeArray[MAX_VERTEX_ATTRIBS];
// Helper structure to store all raw state
struct State
{
Color colorClearValue;
GLclampf depthClearValue;
int stencilClearValue;
bool cullFaceEnabled;
GLenum cullMode;
GLenum frontFace;
bool depthTestEnabled;
GLenum depthFunc;
bool blendEnabled;
GLenum sourceBlendRGB;
GLenum destBlendRGB;
GLenum sourceBlendAlpha;
GLenum destBlendAlpha;
GLenum blendEquationRGB;
GLenum blendEquationAlpha;
Color blendColor;
bool stencilTestEnabled;
GLenum stencilFunc;
GLint stencilRef;
GLuint stencilMask;
GLenum stencilFail;
GLenum stencilPassDepthFail;
GLenum stencilPassDepthPass;
GLuint stencilWritemask;
GLenum stencilBackFunc;
GLint stencilBackRef;
GLuint stencilBackMask;
GLenum stencilBackFail;
GLenum stencilBackPassDepthFail;
GLenum stencilBackPassDepthPass;
GLuint stencilBackWritemask;
bool polygonOffsetFillEnabled;
GLfloat polygonOffsetFactor;
GLfloat polygonOffsetUnits;
bool sampleAlphaToCoverageEnabled;
bool sampleCoverageEnabled;
GLclampf sampleCoverageValue;
bool sampleCoverageInvert;
bool scissorTestEnabled;
bool ditherEnabled;
bool colorLogicOpEnabled;
GLenum logicalOperation;
GLfloat lineWidth;
GLenum generateMipmapHint;
GLenum fragmentShaderDerivativeHint;
GLint viewportX;
GLint viewportY;
GLsizei viewportWidth;
GLsizei viewportHeight;
float zNear;
float zFar;
GLint scissorX;
GLint scissorY;
GLsizei scissorWidth;
GLsizei scissorHeight;
bool colorMaskRed;
bool colorMaskGreen;
bool colorMaskBlue;
bool colorMaskAlpha;
bool depthMask;
unsigned int activeSampler; // Active texture unit selector - GL_TEXTURE0
BindingPointer<Buffer> arrayBuffer;
BindingPointer<Buffer> elementArrayBuffer;
GLuint readFramebuffer;
GLuint drawFramebuffer;
BindingPointer<Renderbuffer> renderbuffer;
GLuint currentProgram;
VertexAttribute vertexAttribute[MAX_VERTEX_ATTRIBS];
BindingPointer<Texture> samplerTexture[TEXTURE_TYPE_COUNT][MAX_COMBINED_TEXTURE_IMAGE_UNITS];
BindingPointer<Query> activeQuery[QUERY_TYPE_COUNT];
GLint unpackAlignment;
GLint packAlignment;
};
class Context
{
public:
Context(const Context *shareContext);
~Context();
void makeCurrent(Surface *surface);
void markAllStateDirty();
// State manipulation
void setClearColor(float red, float green, float blue, float alpha);
void setClearDepth(float depth);
void setClearStencil(int stencil);
void setCullFaceEnabled(bool enabled);
bool isCullFaceEnabled() const;
void setCullMode(GLenum mode);
void setFrontFace(GLenum front);
void setDepthTestEnabled(bool enabled);
bool isDepthTestEnabled() const;
void setDepthFunc(GLenum depthFunc);
void setDepthRange(float zNear, float zFar);
void setBlendEnabled(bool enabled);
bool isBlendEnabled() const;
void setBlendFactors(GLenum sourceRGB, GLenum destRGB, GLenum sourceAlpha, GLenum destAlpha);
void setBlendColor(float red, float green, float blue, float alpha);
void setBlendEquation(GLenum rgbEquation, GLenum alphaEquation);
void setStencilTestEnabled(bool enabled);
bool isStencilTestEnabled() const;
void setStencilParams(GLenum stencilFunc, GLint stencilRef, GLuint stencilMask);
void setStencilBackParams(GLenum stencilBackFunc, GLint stencilBackRef, GLuint stencilBackMask);
void setStencilWritemask(GLuint stencilWritemask);
void setStencilBackWritemask(GLuint stencilBackWritemask);
void setStencilOperations(GLenum stencilFail, GLenum stencilPassDepthFail, GLenum stencilPassDepthPass);
void setStencilBackOperations(GLenum stencilBackFail, GLenum stencilBackPassDepthFail, GLenum stencilBackPassDepthPass);
void setPolygonOffsetFillEnabled(bool enabled);
bool isPolygonOffsetFillEnabled() const;
void setPolygonOffsetParams(GLfloat factor, GLfloat units);
void setSampleAlphaToCoverageEnabled(bool enabled);
bool isSampleAlphaToCoverageEnabled() const;
void setSampleCoverageEnabled(bool enabled);
bool isSampleCoverageEnabled() const;
void setSampleCoverageParams(GLclampf value, bool invert);
void setDitherEnabled(bool enabled);
bool isDitherEnabled() const;
void setLineWidth(GLfloat width);
void setGenerateMipmapHint(GLenum hint);
void setFragmentShaderDerivativeHint(GLenum hint);
void setViewportParams(GLint x, GLint y, GLsizei width, GLsizei height);
void setScissorTestEnabled(bool enabled);
bool isScissorTestEnabled() const;
void setScissorParams(GLint x, GLint y, GLsizei width, GLsizei height);
void setColorMask(bool red, bool green, bool blue, bool alpha);
void setDepthMask(bool mask);
void setActiveSampler(unsigned int active);
GLuint getReadFramebufferName() const;
GLuint getDrawFramebufferName() const;
GLuint getRenderbufferName() const;
GLuint getActiveQuery(GLenum target) const;
GLuint getArrayBufferName() const;
void setVertexAttribArrayEnabled(unsigned int attribNum, bool enabled);
const VertexAttribute &getVertexAttribState(unsigned int attribNum);
void setVertexAttribState(unsigned int attribNum, Buffer *boundBuffer, GLint size, GLenum type,
bool normalized, GLsizei stride, const void *pointer);
const void *getVertexAttribPointer(unsigned int attribNum) const;
const VertexAttributeArray &getVertexAttributes();
void setUnpackAlignment(GLint alignment);
GLint getUnpackAlignment() const;
void setPackAlignment(GLint alignment);
GLint getPackAlignment() const;
// These create and destroy methods are merely pass-throughs to
// ResourceManager, which owns these object types
GLuint createBuffer();
GLuint createShader(GLenum type);
GLuint createProgram();
GLuint createTexture();
GLuint createRenderbuffer();
void deleteBuffer(GLuint buffer);
void deleteShader(GLuint shader);
void deleteProgram(GLuint program);
void deleteTexture(GLuint texture);
void deleteRenderbuffer(GLuint renderbuffer);
// Framebuffers are owned by the Context, so these methods do not pass through
GLuint createFramebuffer();
void deleteFramebuffer(GLuint framebuffer);
// Fences are owned by the Context
GLuint createFence();
void deleteFence(GLuint fence);
// Queries are owned by the Context
GLuint createQuery();
void deleteQuery(GLuint query);
void bindArrayBuffer(GLuint buffer);
void bindElementArrayBuffer(GLuint buffer);
void bindTexture2D(GLuint texture);
void bindTextureCubeMap(GLuint texture);
void bindReadFramebuffer(GLuint framebuffer);
void bindDrawFramebuffer(GLuint framebuffer);
void bindRenderbuffer(GLuint renderbuffer);
void useProgram(GLuint program);
void beginQuery(GLenum target, GLuint query);
void endQuery(GLenum target);
void setFramebufferZero(Framebuffer *framebuffer);
void setRenderbufferStorage(RenderbufferStorage *renderbuffer);
void setVertexAttrib(GLuint index, float x, float y, float z, float w);
Buffer *getBuffer(GLuint handle);
Fence *getFence(GLuint handle);
Shader *getShader(GLuint handle);
Program *getProgram(GLuint handle);
Texture *getTexture(GLuint handle);
Framebuffer *getFramebuffer(GLuint handle);
Renderbuffer *getRenderbuffer(GLuint handle);
Query *getQuery(GLuint handle, bool create, GLenum type);
Buffer *getArrayBuffer();
Buffer *getElementArrayBuffer();
Program *getCurrentProgram();
Texture2D *getTexture2D(GLenum target);
TextureCubeMap *getTextureCubeMap();
Texture *getSamplerTexture(unsigned int sampler, TextureType type);
Framebuffer *getReadFramebuffer();
Framebuffer *getDrawFramebuffer();
bool getFloatv(GLenum pname, GLfloat *params);
bool getIntegerv(GLenum pname, GLint *params);
bool getBooleanv(GLenum pname, GLboolean *params);
bool getQueryParameterInfo(GLenum pname, GLenum *type, unsigned int *numParams);
void readPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei *bufSize, void* pixels);
void clear(GLbitfield mask);
void drawArrays(GLenum mode, GLint first, GLsizei count);
void drawElements(GLenum mode, GLsizei count, GLenum type, const void *indices);
void finish();
void flush();
void recordInvalidEnum();
void recordInvalidValue();
void recordInvalidOperation();
void recordOutOfMemory();
void recordInvalidFramebufferOperation();
GLenum getError();
static int getSupportedMultisampleCount(int requested);
void blitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1,
GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1,
GLbitfield mask);
void setMatrixMode(GLenum mode);
void loadIdentity();
void pushMatrix();
void popMatrix();
void rotate(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
void translate(GLfloat x, GLfloat y, GLfloat z);
void scale(GLfloat x, GLfloat y, GLfloat z);
void multiply(const GLdouble *m);
void multiply(const GLfloat *m);
void frustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar);
void ortho(double left, double right, double bottom, double top, double zNear, double zFar); // FIXME: GLdouble
void setLightingEnabled(bool enabled);
void setFogEnabled(bool enabled);
void setAlphaTestEnabled(bool enabled);
void alphaFunc(GLenum func, GLclampf ref);
void setTexture2DEnabled(bool enabled);
void setShadeModel(GLenum mode);
void setLightEnabled(int index, bool enable);
void setNormalizeNormalsEnabled(bool enable);
GLuint genLists(GLsizei range);
void newList(GLuint list, GLenum mode);
void endList();
void callList(GLuint list);
void deleteList(GLuint list);
GLuint getListIndex() {return listIndex;}
GLenum getListMode() {return listMode;}
void listCommand(Command *command);
void captureAttribs();
void captureDrawArrays(GLenum mode, GLint first, GLsizei count);
void restoreAttribs();
void clientActiveTexture(GLenum texture);
GLenum getClientActiveTexture() const;
unsigned int getActiveTexture() const;
void begin(GLenum mode);
void position(GLfloat x, GLfloat y, GLfloat z, GLfloat w);
void end();
void setColorMaterialEnabled(bool enable);
void setColorMaterialMode(GLenum mode);
void setColorLogicOpEnabled(bool colorLogicOpEnabled);
bool isColorLogicOpEnabled();
void setLogicalOperation(GLenum logicalOperation);
Device *getDevice();
private:
bool applyRenderTarget();
void applyState(GLenum drawMode);
GLenum applyVertexBuffer(GLint base, GLint first, GLsizei count);
GLenum applyIndexBuffer(const void *indices, GLsizei count, GLenum mode, GLenum type, TranslatedIndexData *indexInfo);
void applyShaders();
void applyTextures();
void applyTextures(sw::SamplerType type);
void applyTexture(sw::SamplerType type, int sampler, Texture *texture);
void detachBuffer(GLuint buffer);
void detachTexture(GLuint texture);
void detachFramebuffer(GLuint framebuffer);
void detachRenderbuffer(GLuint renderbuffer);
bool cullSkipsDraw(GLenum drawMode);
bool isTriangleMode(GLenum drawMode);
State mState;
BindingPointer<Texture2D> mTexture2DZero;
BindingPointer<Texture2D> mProxyTexture2DZero;
BindingPointer<TextureCubeMap> mTextureCubeMapZero;
gl::NameSpace<Framebuffer> mFramebufferNameSpace;
gl::NameSpace<Fence, 0> mFenceNameSpace;
gl::NameSpace<Query> mQueryNameSpace;
VertexDataManager *mVertexDataManager;
IndexDataManager *mIndexDataManager;
// Recorded errors
bool mInvalidEnum;
bool mInvalidValue;
bool mInvalidOperation;
bool mOutOfMemory;
bool mInvalidFramebufferOperation;
bool mHasBeenCurrent;
unsigned int mAppliedProgramSerial;
// state caching flags
bool mDepthStateDirty;
bool mMaskStateDirty;
bool mPixelPackingStateDirty;
bool mBlendStateDirty;
bool mStencilStateDirty;
bool mPolygonOffsetStateDirty;
bool mSampleStateDirty;
bool mFrontFaceDirty;
bool mDitherStateDirty;
bool mColorLogicOperatorDirty;
Device *device;
ResourceManager *mResourceManager;
sw::MatrixStack &currentMatrixStack();
GLenum matrixMode;
sw::MatrixStack modelView;
sw::MatrixStack projection;
sw::MatrixStack texture[8];
GLenum listMode;
//std::map<GLuint, GLuint> listMap;
std::map<GLuint, DisplayList*> displayList;
DisplayList *list;
GLuint listIndex;
GLuint firstFreeIndex;
GLenum clientTexture;
bool drawing;
GLenum drawMode;
struct InVertex
{
sw::float4 P; // Position
sw::float4 N; // Normal
sw::float4 C; // Color
sw::float4 T0; // Texture coordinate
sw::float4 T1;
};
std::vector<InVertex> vertex;
VertexAttribute clientAttribute[MAX_VERTEX_ATTRIBS];
bool envEnable[8];
};
}
#endif // INCLUDE_CONTEXT_H_