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