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 ¤tMatrixStack(); 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