1 // Copyright 2016 The SwiftShader Authors. All Rights Reserved.
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 //    http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14 
15 // Context.h: Defines the Context class, managing all GL state and performing
16 // rendering operations. It is the GLES2 specific implementation of EGLContext.
17 
18 #ifndef LIBGLES_CM_CONTEXT_H_
19 #define LIBGLES_CM_CONTEXT_H_
20 
21 #include "libEGL/Context.hpp"
22 #include "ResourceManager.h"
23 #include "common/NameSpace.hpp"
24 #include "common/Object.hpp"
25 #include "common/Image.hpp"
26 #include "Renderer/Sampler.hpp"
27 #include "common/MatrixStack.hpp"
28 
29 #include <GLES/gl.h>
30 #include <GLES/glext.h>
31 #include <EGL/egl.h>
32 
33 #include <map>
34 #include <string>
35 
36 namespace gl { class Surface; }
37 
38 namespace egl
39 {
40 class Display;
41 class Config;
42 }
43 
44 namespace es1
45 {
46 struct TranslatedAttribute;
47 struct TranslatedIndexData;
48 
49 class Device;
50 class Buffer;
51 class Texture;
52 class Texture2D;
53 class TextureExternal;
54 class Framebuffer;
55 class Renderbuffer;
56 class RenderbufferStorage;
57 class Colorbuffer;
58 class Depthbuffer;
59 class StreamingIndexBuffer;
60 class Stencilbuffer;
61 class DepthStencilbuffer;
62 class VertexDataManager;
63 class IndexDataManager;
64 
65 enum
66 {
67 	MAX_VERTEX_ATTRIBS = sw::MAX_VERTEX_INPUTS,
68 	MAX_VARYING_VECTORS = 10,
69 	MAX_TEXTURE_UNITS = 2,
70 	MAX_DRAW_BUFFERS = 1,
71 	MAX_LIGHTS = 8,
72 	MAX_CLIP_PLANES = sw::MAX_CLIP_PLANES,
73 
74 	MAX_MODELVIEW_STACK_DEPTH = 32,
75 	MAX_PROJECTION_STACK_DEPTH = 2,
76 	MAX_TEXTURE_STACK_DEPTH = 2,
77 };
78 
79 const GLenum compressedTextureFormats[] =
80 {
81 	GL_ETC1_RGB8_OES,
82 	GL_COMPRESSED_RGB_S3TC_DXT1_EXT,
83 	GL_COMPRESSED_RGBA_S3TC_DXT1_EXT,
84 };
85 
86 const GLint NUM_COMPRESSED_TEXTURE_FORMATS = sizeof(compressedTextureFormats) / sizeof(compressedTextureFormats[0]);
87 
88 const GLint multisampleCount[] = {4, 2, 1};
89 const GLint NUM_MULTISAMPLE_COUNTS = sizeof(multisampleCount) / sizeof(multisampleCount[0]);
90 const GLint IMPLEMENTATION_MAX_SAMPLES = multisampleCount[0];
91 
92 const float ALIASED_LINE_WIDTH_RANGE_MIN = 1.0f;
93 const float ALIASED_LINE_WIDTH_RANGE_MAX = 1.0f;
94 const float ALIASED_POINT_SIZE_RANGE_MIN = 0.125f;
95 const float ALIASED_POINT_SIZE_RANGE_MAX = 8192.0f;
96 const float SMOOTH_LINE_WIDTH_RANGE_MIN = 1.0f;
97 const float SMOOTH_LINE_WIDTH_RANGE_MAX = 1.0f;
98 const float SMOOTH_POINT_SIZE_RANGE_MIN = 0.125f;
99 const float SMOOTH_POINT_SIZE_RANGE_MAX = 8192.0f;
100 const float MAX_TEXTURE_MAX_ANISOTROPY = 16.0f;
101 
102 struct Color
103 {
104 	float red;
105 	float green;
106 	float blue;
107 	float alpha;
108 };
109 
110 struct Point
111 {
112 	float x;
113 	float y;
114 	float z;
115 	float w;
116 };
117 
118 struct Vector
119 {
120 	float x;
121 	float y;
122 	float z;
123 };
124 
125 struct Attenuation
126 {
127 	float constant;
128 	float linear;
129 	float quadratic;
130 };
131 
132 struct Light
133 {
134 	bool enabled;
135 	Color ambient;
136 	Color diffuse;
137 	Color specular;
138 	Point position;
139 	Vector direction;
140 	Attenuation attenuation;
141 	float spotExponent;
142 	float spotCutoffAngle;
143 };
144 
145 // Helper structure describing a single vertex attribute
146 class VertexAttribute
147 {
148 public:
VertexAttribute()149 	VertexAttribute() : mType(GL_FLOAT), mSize(4), mNormalized(false), mStride(0), mPointer(nullptr), mArrayEnabled(false)
150 	{
151 		mCurrentValue[0] = 0.0f;
152 		mCurrentValue[1] = 0.0f;
153 		mCurrentValue[2] = 0.0f;
154 		mCurrentValue[3] = 1.0f;
155 	}
156 
typeSize()157 	int typeSize() const
158 	{
159 		switch(mType)
160 		{
161 		case GL_BYTE:           return mSize * sizeof(GLbyte);
162 		case GL_UNSIGNED_BYTE:  return mSize * sizeof(GLubyte);
163 		case GL_SHORT:          return mSize * sizeof(GLshort);
164 		case GL_UNSIGNED_SHORT: return mSize * sizeof(GLushort);
165 		case GL_FIXED:          return mSize * sizeof(GLfixed);
166 		case GL_FLOAT:          return mSize * sizeof(GLfloat);
167 		default: UNREACHABLE(mType); return mSize * sizeof(GLfloat);
168 		}
169 	}
170 
stride()171 	GLsizei stride() const
172 	{
173 		return mStride ? mStride : typeSize();
174 	}
175 
176 	// From glVertexAttribPointer
177 	GLenum mType;
178 	GLint mSize;
179 	bool mNormalized;
180 	GLsizei mStride;   // 0 means natural stride
181 
182 	union
183 	{
184 		const void *mPointer;
185 		intptr_t mOffset;
186 	};
187 
188 	gl::BindingPointer<Buffer> mBoundBuffer;   // Captured when glVertexAttribPointer is called.
189 
190 	bool mArrayEnabled;   // From glEnable/DisableVertexAttribArray
191 	float mCurrentValue[4];   // From glVertexAttrib
192 };
193 
194 typedef VertexAttribute VertexAttributeArray[MAX_VERTEX_ATTRIBS];
195 
196 struct TextureUnit
197 {
198 	Color color;
199 	GLenum environmentMode;
200 	GLenum combineRGB;
201 	GLenum combineAlpha;
202 	GLenum src0RGB;
203 	GLenum src0Alpha;
204 	GLenum src1RGB;
205 	GLenum src1Alpha;
206 	GLenum src2RGB;
207 	GLenum src2Alpha;
208 	GLenum operand0RGB;
209 	GLenum operand0Alpha;
210 	GLenum operand1RGB;
211 	GLenum operand1Alpha;
212 	GLenum operand2RGB;
213 	GLenum operand2Alpha;
214 };
215 
216 // Helper structure to store all raw state
217 struct State
218 {
219 	Color colorClearValue;
220 	GLclampf depthClearValue;
221 	int stencilClearValue;
222 
223 	bool cullFaceEnabled;
224 	GLenum cullMode;
225 	GLenum frontFace;
226 	bool depthTestEnabled;
227 	GLenum depthFunc;
228 	bool blendEnabled;
229 	GLenum sourceBlendRGB;
230 	GLenum destBlendRGB;
231 	GLenum sourceBlendAlpha;
232 	GLenum destBlendAlpha;
233 	GLenum blendEquationRGB;
234 	GLenum blendEquationAlpha;
235 	bool stencilTestEnabled;
236 	GLenum stencilFunc;
237 	GLint stencilRef;
238 	GLuint stencilMask;
239 	GLenum stencilFail;
240 	GLenum stencilPassDepthFail;
241 	GLenum stencilPassDepthPass;
242 	GLuint stencilWritemask;
243 	bool polygonOffsetFillEnabled;
244 	GLfloat polygonOffsetFactor;
245 	GLfloat polygonOffsetUnits;
246 	bool sampleAlphaToCoverageEnabled;
247 	bool sampleCoverageEnabled;
248 	GLclampf sampleCoverageValue;
249 	bool sampleCoverageInvert;
250 	bool scissorTestEnabled;
251 	bool ditherEnabled;
252 	GLenum shadeModel;
253 
254 	GLfloat lineWidth;
255 
256 	GLenum generateMipmapHint;
257 	GLenum perspectiveCorrectionHint;
258 	GLenum fogHint;
259 
260 	GLint viewportX;
261 	GLint viewportY;
262 	GLsizei viewportWidth;
263 	GLsizei viewportHeight;
264 	float zNear;
265 	float zFar;
266 
267 	GLint scissorX;
268 	GLint scissorY;
269 	GLsizei scissorWidth;
270 	GLsizei scissorHeight;
271 
272 	bool colorMaskRed;
273 	bool colorMaskGreen;
274 	bool colorMaskBlue;
275 	bool colorMaskAlpha;
276 	bool depthMask;
277 
278 	unsigned int activeSampler;   // Active texture unit selector - GL_TEXTURE0
279 	gl::BindingPointer<Buffer> arrayBuffer;
280 	gl::BindingPointer<Buffer> elementArrayBuffer;
281 	GLuint framebuffer;
282 	gl::BindingPointer<Renderbuffer> renderbuffer;
283 
284 	VertexAttribute vertexAttribute[MAX_VERTEX_ATTRIBS];
285 	gl::BindingPointer<Texture> samplerTexture[TEXTURE_TYPE_COUNT][MAX_TEXTURE_UNITS];
286 
287 	GLint unpackAlignment;
288 	GLint packAlignment;
289 
290 	TextureUnit textureUnit[MAX_TEXTURE_UNITS];
291 };
292 
293 class [[clang::lto_visibility_public]] Context : public egl::Context
294 {
295 public:
296 	Context(egl::Display *display, const Context *shareContext, const egl::Config *config);
297 
298 	void makeCurrent(gl::Surface *surface) override;
299 	EGLint getClientVersion() const override;
300 	EGLint getConfigID() const override;
301 
302 	void finish() override;
303 
304 	void markAllStateDirty();
305 
306 	// State manipulation
307 	void setClearColor(float red, float green, float blue, float alpha);
308 	void setClearDepth(float depth);
309 	void setClearStencil(int stencil);
310 
311 	void setCullFaceEnabled(bool enabled);
312 	bool isCullFaceEnabled() const;
313 	void setCullMode(GLenum mode);
314 	void setFrontFace(GLenum front);
315 
316 	void setDepthTestEnabled(bool enabled);
317 	bool isDepthTestEnabled() const;
318 	void setDepthFunc(GLenum depthFunc);
319 	void setDepthRange(float zNear, float zFar);
320 
321 	void setAlphaTestEnabled(bool enabled);
322 	bool isAlphaTestEnabled() const;
323 	void setAlphaFunc(GLenum alphaFunc, GLclampf reference);
324 
325 	void setBlendEnabled(bool enabled);
326 	bool isBlendEnabled() const;
327 	void setBlendFactors(GLenum sourceRGB, GLenum destRGB, GLenum sourceAlpha, GLenum destAlpha);
328 	void setBlendEquation(GLenum rgbEquation, GLenum alphaEquation);
329 
330 	void setStencilTestEnabled(bool enabled);
331 	bool isStencilTestEnabled() const;
332 	void setStencilParams(GLenum stencilFunc, GLint stencilRef, GLuint stencilMask);
333 	void setStencilWritemask(GLuint stencilWritemask);
334 	void setStencilOperations(GLenum stencilFail, GLenum stencilPassDepthFail, GLenum stencilPassDepthPass);
335 
336 	void setPolygonOffsetFillEnabled(bool enabled);
337 	bool isPolygonOffsetFillEnabled() const;
338 	void setPolygonOffsetParams(GLfloat factor, GLfloat units);
339 
340 	void setSampleAlphaToCoverageEnabled(bool enabled);
341 	bool isSampleAlphaToCoverageEnabled() const;
342 	void setSampleCoverageEnabled(bool enabled);
343 	bool isSampleCoverageEnabled() const;
344 	void setSampleCoverageParams(GLclampf value, bool invert);
345 
346 	void setShadeModel(GLenum mode);
347 	void setDitherEnabled(bool enabled);
348 	bool isDitherEnabled() const;
349 	void setLightingEnabled(bool enabled);
350 	bool isLightingEnabled() const;
351 	void setLightEnabled(int index, bool enable);
352 	bool isLightEnabled(int index) const;
353 	void setLightAmbient(int index, float r, float g, float b, float a);
354 	void setLightDiffuse(int index, float r, float g, float b, float a);
355 	void setLightSpecular(int index, float r, float g, float b, float a);
356 	void setLightPosition(int index, float x, float y, float z, float w);
357 	void setLightDirection(int index, float x, float y, float z);
358 	void setLightAttenuationConstant(int index, float constant);
359 	void setLightAttenuationLinear(int index, float linear);
360 	void setLightAttenuationQuadratic(int index, float quadratic);
361 	void setSpotLightExponent(int index, float exponent);
362 	void setSpotLightCutoff(int index, float cutoff);
363 
364 	void setGlobalAmbient(float red, float green, float blue, float alpha);
365 	void setMaterialAmbient(float red, float green, float blue, float alpha);
366 	void setMaterialDiffuse(float red, float green, float blue, float alpha);
367 	void setMaterialSpecular(float red, float green, float blue, float alpha);
368 	void setMaterialEmission(float red, float green, float blue, float alpha);
369 	void setMaterialShininess(float shininess);
370 	void setLightModelTwoSide(bool enable);
371 
372 	void setFogEnabled(bool enabled);
373 	bool isFogEnabled() const;
374 	void setFogMode(GLenum mode);
375 	void setFogDensity(float fogDensity);
376 	void setFogStart(float fogStart);
377 	void setFogEnd(float fogEnd);
378 	void setFogColor(float r, float g, float b, float a);
379 
380 	void setTexture2Denabled(bool enabled);
381 	bool isTexture2Denabled() const;
382 	void setTextureExternalEnabled(bool enabled);
383 	bool isTextureExternalEnabled() const;
384 	void clientActiveTexture(GLenum texture);
385 	GLenum getClientActiveTexture() const;
386 	unsigned int getActiveTexture() const;
387 
388 	void setTextureEnvMode(GLenum texEnvMode);
389 	void setTextureEnvColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha);
390 	void setCombineRGB(GLenum combineRGB);
391 	void setCombineAlpha(GLenum combineAlpha);
392 	void setOperand0RGB(GLenum operand);
393 	void setOperand1RGB(GLenum operand);
394 	void setOperand2RGB(GLenum operand);
395 	void setOperand0Alpha(GLenum operand);
396 	void setOperand1Alpha(GLenum operand);
397 	void setOperand2Alpha(GLenum operand);
398 	void setSrc0RGB(GLenum src);
399 	void setSrc1RGB(GLenum src);
400 	void setSrc2RGB(GLenum src);
401 	void setSrc0Alpha(GLenum src);
402 	void setSrc1Alpha(GLenum src);
403 	void setSrc2Alpha(GLenum src);
404 
405 	void setLineWidth(GLfloat width);
406 
407 	void setGenerateMipmapHint(GLenum hint);
408 	void setPerspectiveCorrectionHint(GLenum hint);
409 	void setFogHint(GLenum hint);
410 
411 	void setViewportParams(GLint x, GLint y, GLsizei width, GLsizei height);
412 
413 	void setScissorTestEnabled(bool enabled);
414 	bool isScissorTestEnabled() const;
415 	void setScissorParams(GLint x, GLint y, GLsizei width, GLsizei height);
416 
417 	void setColorMask(bool red, bool green, bool blue, bool alpha);
418 	void setDepthMask(bool mask);
419 
420 	void setActiveSampler(unsigned int active);
421 
422 	GLuint getFramebufferName() const;
423 	GLuint getRenderbufferName() const;
424 
425 	GLuint getArrayBufferName() const;
426 
427 	void setVertexAttribArrayEnabled(unsigned int attribNum, bool enabled);
428 	const VertexAttribute &getVertexAttribState(unsigned int attribNum);
429 	void setVertexAttribState(unsigned int attribNum, Buffer *boundBuffer, GLint size, GLenum type,
430 	                          bool normalized, GLsizei stride, const void *pointer);
431 	const void *getVertexAttribPointer(unsigned int attribNum) const;
432 
433 	const VertexAttributeArray &getVertexAttributes();
434 
435 	void setUnpackAlignment(GLint alignment);
436 	GLint getUnpackAlignment() const;
437 
438 	void setPackAlignment(GLint alignment);
439 	GLint getPackAlignment() const;
440 
441 	// These create and destroy methods are merely pass-throughs to
442 	// ResourceManager, which owns these object types
443 	GLuint createBuffer();
444 	GLuint createTexture();
445 	GLuint createRenderbuffer();
446 
447 	void deleteBuffer(GLuint buffer);
448 	void deleteTexture(GLuint texture);
449 	void deleteRenderbuffer(GLuint renderbuffer);
450 
451 	// Framebuffers are owned by the Context, so these methods do not pass through
452 	GLuint createFramebuffer();
453 	void deleteFramebuffer(GLuint framebuffer);
454 
455 	void bindArrayBuffer(GLuint buffer);
456 	void bindElementArrayBuffer(GLuint buffer);
457 	void bindTexture(TextureType type, GLuint texture);
458 	void bindTextureExternal(GLuint texture);
459 	void bindFramebuffer(GLuint framebuffer);
460 	void bindRenderbuffer(GLuint renderbuffer);
461 
462 	void setFramebufferZero(Framebuffer *framebuffer);
463 
464 	void setRenderbufferStorage(RenderbufferStorage *renderbuffer);
465 
466 	void setVertexAttrib(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w);
467 
468 	Buffer *getBuffer(GLuint handle);
469 	virtual Texture *getTexture(GLuint handle);
470 	Framebuffer *getFramebuffer(GLuint handle);
471 	virtual Renderbuffer *getRenderbuffer(GLuint handle);
472 
473 	Buffer *getArrayBuffer();
474 	Buffer *getElementArrayBuffer();
475 	Texture2D *getTexture2D();
476 	TextureExternal *getTextureExternal();
477 	Texture *getSamplerTexture(unsigned int sampler, TextureType type);
478 	Framebuffer *getFramebuffer();
479 
480 	bool getFloatv(GLenum pname, GLfloat *params);
481 	bool getIntegerv(GLenum pname, GLint *params);
482 	bool getBooleanv(GLenum pname, GLboolean *params);
483 	bool getPointerv(GLenum pname, const GLvoid **params);
484 
485 	int getQueryParameterNum(GLenum pname);
486 	bool isQueryParameterInt(GLenum pname);
487 	bool isQueryParameterFloat(GLenum pname);
488 	bool isQueryParameterBool(GLenum pname);
489 	bool isQueryParameterPointer(GLenum pname);
490 
491 	void drawArrays(GLenum mode, GLint first, GLsizei count);
492 	void drawElements(GLenum mode, GLsizei count, GLenum type, const void *indices);
493 	void drawTexture(GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height);
494 	void blit(sw::Surface *source, const sw::SliceRect &sRect, sw::Surface *dest, const sw::SliceRect &dRect) override;
495 	void readPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei *bufSize, void* pixels);
496 	void clear(GLbitfield mask);
497 	void flush();
498 
499 	void recordInvalidEnum();
500 	void recordInvalidValue();
501 	void recordInvalidOperation();
502 	void recordOutOfMemory();
503 	void recordInvalidFramebufferOperation();
504 	void recordMatrixStackOverflow();
505 	void recordMatrixStackUnderflow();
506 
507 	GLenum getError();
508 
509 	static int getSupportedMultisampleCount(int requested);
510 
511 	void bindTexImage(gl::Surface *surface) override;
512 	EGLenum validateSharedImage(EGLenum target, GLuint name, GLuint textureLevel) override;
513 	egl::Image *createSharedImage(EGLenum target, GLuint name, GLuint textureLevel) override;
514 	egl::Image *getSharedImage(GLeglImageOES image);
515 
516 	Device *getDevice();
517 
518 	void setMatrixMode(GLenum mode);
519 	void loadIdentity();
520 	void load(const GLfloat *m);
521 	void pushMatrix();
522 	void popMatrix();
523 	void rotate(GLfloat angle, GLfloat x, GLfloat y, GLfloat z);
524 	void translate(GLfloat x, GLfloat y, GLfloat z);
525 	void scale(GLfloat x, GLfloat y, GLfloat z);
526 	void multiply(const GLfloat *m);
527 	void frustum(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar);
528 	void ortho(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar);
529 
530 	void setClipPlane(int index, const float plane[4]);
531 	void setClipPlaneEnabled(int index, bool enable);
532 	bool isClipPlaneEnabled(int index) const;
533 
534 	void setColorLogicOpEnabled(bool enable);
535 	bool isColorLogicOpEnabled() const;
536 	void setLogicalOperation(GLenum logicOp);
537 
538 	void setPointSmoothEnabled(bool enable);
539 	bool isPointSmoothEnabled() const;
540 
541 	void setLineSmoothEnabled(bool enable);
542 	bool isLineSmoothEnabled() const;
543 
544 	void setColorMaterialEnabled(bool enable);
545 	bool isColorMaterialEnabled() const;
546 
547 	void setNormalizeEnabled(bool enable);
548 	bool isNormalizeEnabled() const;
549 
550 	void setRescaleNormalEnabled(bool enable);
551 	bool isRescaleNormalEnabled() const;
552 
553 	void setVertexArrayEnabled(bool enable);
554 	bool isVertexArrayEnabled() const;
555 
556 	void setNormalArrayEnabled(bool enable);
557 	bool isNormalArrayEnabled() const;
558 
559 	void setColorArrayEnabled(bool enable);
560 	bool isColorArrayEnabled() const;
561 
562 	void setPointSizeArrayEnabled(bool enable);
563 	bool isPointSizeArrayEnabled() const;
564 
565 	void setTextureCoordArrayEnabled(bool enable);
566 	bool isTextureCoordArrayEnabled() const;
567 
568 	void setMultisampleEnabled(bool enable);
569 	bool isMultisampleEnabled() const;
570 
571 	void setSampleAlphaToOneEnabled(bool enable);
572 	bool isSampleAlphaToOneEnabled() const;
573 
574 	void setPointSpriteEnabled(bool enable);
575 	bool isPointSpriteEnabled() const;
576 	void setPointSizeMin(float min);
577 	void setPointSizeMax(float max);
578 	void setPointDistanceAttenuation(float a, float b, float c);
579 	void setPointFadeThresholdSize(float threshold);
580 
581 private:
582 	~Context() override;
583 
584 	bool applyRenderTarget();
585 	void applyState(GLenum drawMode);
586 	GLenum applyVertexBuffer(GLint base, GLint first, GLsizei count);
587 	GLenum applyIndexBuffer(const void *indices, GLsizei count, GLenum mode, GLenum type, TranslatedIndexData *indexInfo);
588 	void applyTextures();
589 	void applyTexture(int sampler, Texture *texture);
590 
591 	void detachBuffer(GLuint buffer);
592 	void detachTexture(GLuint texture);
593 	void detachFramebuffer(GLuint framebuffer);
594 	void detachRenderbuffer(GLuint renderbuffer);
595 
596 	bool cullSkipsDraw(GLenum drawMode);
597 	bool isTriangleMode(GLenum drawMode);
598 
599 	const egl::Config *const config;
600 
601 	State mState;
602 
603 	gl::BindingPointer<Texture2D> mTexture2DZero;
604 	gl::BindingPointer<TextureExternal> mTextureExternalZero;
605 
606 	gl::NameSpace<Framebuffer> mFramebufferNameSpace;
607 
608 	VertexDataManager *mVertexDataManager;
609 	IndexDataManager *mIndexDataManager;
610 
611 	bool lightingEnabled;
612 	Light light[MAX_LIGHTS];
613 	Color globalAmbient;
614 	Color materialAmbient;
615 	Color materialDiffuse;
616 	Color materialSpecular;
617 	Color materialEmission;
618 	GLfloat materialShininess;
619 	bool lightModelTwoSide;
620 
621 	// Recorded errors
622 	bool mInvalidEnum;
623 	bool mInvalidValue;
624 	bool mInvalidOperation;
625 	bool mOutOfMemory;
626 	bool mInvalidFramebufferOperation;
627 	bool mMatrixStackOverflow;
628 	bool mMatrixStackUnderflow;
629 
630 	bool mHasBeenCurrent;
631 
632 	// state caching flags
633 	bool mDepthStateDirty;
634 	bool mMaskStateDirty;
635 	bool mBlendStateDirty;
636 	bool mStencilStateDirty;
637 	bool mPolygonOffsetStateDirty;
638 	bool mSampleStateDirty;
639 	bool mFrontFaceDirty;
640 	bool mDitherStateDirty;
641 
642 	sw::MatrixStack &currentMatrixStack();
643 	GLenum matrixMode;
644 	sw::MatrixStack modelViewStack;
645 	sw::MatrixStack projectionStack;
646 	sw::MatrixStack textureStack0;
647 	sw::MatrixStack textureStack1;
648 
649 	bool texture2Denabled[MAX_TEXTURE_UNITS];
650 	bool textureExternalEnabled[MAX_TEXTURE_UNITS];
651 	GLenum clientTexture;
652 
653 	int clipFlags;
654 
655 	bool alphaTestEnabled;
656 	GLenum alphaTestFunc;
657 	float alphaTestRef;
658 
659 	bool fogEnabled;
660 	GLenum fogMode;
661 	float fogDensity;
662 	float fogStart;
663 	float fogEnd;
664 	Color fogColor;
665 
666 	bool lineSmoothEnabled;
667 	bool colorMaterialEnabled;
668 	bool normalizeEnabled;
669 	bool rescaleNormalEnabled;
670 	bool multisampleEnabled;
671 	bool sampleAlphaToOneEnabled;
672 
673 	bool pointSpriteEnabled;
674 	bool pointSmoothEnabled;
675 	float pointSizeMin;
676 	float pointSizeMax;
677 	Attenuation pointDistanceAttenuation;
678 	float pointFadeThresholdSize;
679 
680 	bool colorLogicOpEnabled;
681 	GLenum logicalOperation;
682 
683 	Device *device;
684 	ResourceManager *mResourceManager;
685 };
686 }
687 
688 #endif   // INCLUDE_CONTEXT_H_
689