// SwiftShader Software Renderer
//
// Copyright(c) 2005-2013 TransGaming Inc.
//
// All rights reserved. No part of this software may be copied, distributed, transmitted,
// transcribed, stored in a retrieval system, translated into any human or computer
// language by any means, or disclosed to third parties without the explicit written
// agreement of TransGaming Inc. Without such an agreement, no rights or licenses, express
// or implied, including but not limited to any patent rights, are granted to you.
//

// 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 <string>
#include <list>

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 = 256 - 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 = 224 - 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(NULL), 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;

    typedef std::map<GLint, Framebuffer*> FramebufferMap;
    FramebufferMap mFramebufferMap;
    //NameSpace mFramebufferNameSpace;

    typedef std::map<GLint, Fence*> FenceMap;
    FenceMap mFenceMap;
    //NameSpace mFenceNameSpace;

	typedef std::map<GLint, Query*> QueryMap;
    QueryMap mQueryMap;
    //NameSpace 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_