1 /* 2 * Copyright 2011 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #ifndef GLES_CONTEXT_H 18 #define GLES_CONTEXT_H 19 20 #include "base/Lookup.h" 21 #include "base/Stream.h" 22 #include "base/Lock.h" 23 24 #include "GLDispatch.h" 25 #include "GLESpointer.h" 26 #include "ObjectNameSpace.h" 27 #include "ShareGroup.h" 28 29 #include <memory> 30 #include <string> 31 #include <unordered_map> 32 #include <vector> 33 #include <functional> 34 35 static constexpr int kMaxVertexAttributes = 16; 36 37 typedef std::unordered_map<GLenum,GLESpointer*> ArraysMap; 38 39 enum TextureTarget { 40 TEXTURE_2D, 41 TEXTURE_CUBE_MAP, 42 TEXTURE_2D_ARRAY, 43 TEXTURE_3D, 44 TEXTURE_2D_MULTISAMPLE, 45 NUM_TEXTURE_TARGETS 46 }; 47 48 typedef struct _textureTargetState { 49 GLuint texture; 50 GLboolean enabled; 51 } textureTargetState; 52 53 typedef textureTargetState textureUnitState[NUM_TEXTURE_TARGETS]; 54 55 class Version{ 56 public: 57 explicit Version(int major = 0,int minor = 0,int release = 0); 58 Version(const char* versionString); 59 Version(const Version& ver); 60 bool operator<(const Version& ver) const; 61 Version& operator=(const Version& ver); 62 private: 63 int m_major; 64 int m_minor; 65 int m_release; 66 }; 67 68 struct GLSupport { 69 int maxLights = 0; 70 int maxVertexAttribs = 0; 71 int maxClipPlane = 0; 72 int maxTexUnits = 0; 73 int maxTexImageUnits = 0; 74 int maxTexSize = 0; 75 int maxCombinedTexImageUnits = 0; 76 77 int maxTransformFeedbackSeparateAttribs = 0; 78 int maxUniformBufferBindings = 0; 79 int maxAtomicCounterBufferBindings = 0; 80 int maxShaderStorageBufferBindings = 0; 81 int maxVertexAttribBindings = 0; 82 83 int maxDrawBuffers = 1; 84 85 Version glslVersion; 86 bool GL_EXT_TEXTURE_FORMAT_BGRA8888 = false; 87 bool GL_EXT_FRAMEBUFFER_OBJECT = false; 88 bool GL_ARB_VERTEX_BLEND = false; 89 bool GL_ARB_MATRIX_PALETTE = false; 90 bool GL_EXT_PACKED_DEPTH_STENCIL = false; 91 bool GL_OES_READ_FORMAT = false; 92 bool GL_ARB_HALF_FLOAT_PIXEL = false; 93 bool GL_NV_HALF_FLOAT = false; 94 bool GL_ARB_HALF_FLOAT_VERTEX = false; 95 bool GL_SGIS_GENERATE_MIPMAP = false; 96 bool GL_ARB_ES2_COMPATIBILITY = false; 97 bool GL_OES_STANDARD_DERIVATIVES = false; 98 bool GL_OES_TEXTURE_NPOT = false; 99 bool GL_OES_RGB8_RGBA8 = false; 100 101 bool ext_GL_EXT_color_buffer_float = false; 102 bool ext_GL_EXT_color_buffer_half_float = false; 103 bool ext_GL_EXT_shader_framebuffer_fetch = false; 104 105 bool ext_GL_EXT_memory_object = false; 106 bool ext_GL_EXT_semaphore = false; 107 108 bool ext_GL_KHR_texture_compression_astc_ldr = false; 109 110 bool hasEtc2Support = false; 111 bool hasAstcSupport = false; 112 bool hasBptcSupport = false; 113 bool hasS3tcSupport = false; 114 }; 115 116 struct ArrayData { 117 void* data = nullptr; 118 GLenum type = 0; 119 unsigned int stride = 0; 120 bool allocated = false; 121 }; 122 123 struct BufferBinding { 124 GLuint buffer = 0; 125 GLintptr offset = 0; 126 GLsizeiptr size = 0; 127 GLintptr stride = 0; 128 GLuint divisor = 0; 129 bool isBindBase = false; 130 void onLoad(android::base::Stream* stream); 131 void onSave(android::base::Stream* stream) const; 132 }; 133 134 typedef std::vector<GLESpointer> VertexAttribInfoVector; 135 typedef std::vector<BufferBinding> VertexAttribBindingVector; 136 137 struct VAOState { VAOStateVAOState138 VAOState() : VAOState(0, NULL, 0) { } VAOStateVAOState139 VAOState(GLuint ibo, ArraysMap* arr, int numVertexAttribBindings) : 140 element_array_buffer_binding(ibo), 141 vertexAttribInfo(numVertexAttribBindings), 142 bindingState(numVertexAttribBindings), 143 everBound(false), 144 legacy(arr != nullptr), 145 arraysMap(arr) { } 146 VAOState(android::base::Stream* stream); 147 GLuint element_array_buffer_binding; 148 VertexAttribInfoVector vertexAttribInfo; 149 VertexAttribBindingVector bindingState; 150 bool bufferBacked; 151 bool everBound; 152 bool legacy = false; 153 std::unique_ptr<ArraysMap> arraysMap; 154 void onSave(android::base::Stream* stream) const; 155 }; 156 157 typedef std::unordered_map<GLuint, VAOState> VAOStateMap; 158 159 struct VAOStateRef { VAOStateRefVAOStateRef160 VAOStateRef() { } VAOStateRefVAOStateRef161 VAOStateRef(VAOStateMap::iterator iter) : it(iter) { } vaoIdVAOStateRef162 GLuint vaoId() const { return it->first; } iboIdVAOStateRef163 GLuint& iboId() { return it->second.element_array_buffer_binding; } 164 attribInfo_constVAOStateRef165 const VertexAttribInfoVector& attribInfo_const() const { 166 return it->second.vertexAttribInfo; 167 } 168 attribInfoVAOStateRef169 VertexAttribInfoVector& attribInfo() { 170 return it->second.vertexAttribInfo; 171 } 172 beginVAOStateRef173 ArraysMap::iterator begin() { 174 return it->second.arraysMap->begin(); 175 } endVAOStateRef176 ArraysMap::iterator end() { 177 return it->second.arraysMap->end(); 178 } findVAOStateRef179 ArraysMap::iterator find(GLenum arrType) { 180 return it->second.arraysMap->find(arrType); 181 } 182 GLESpointer*& operator[](size_t k) { 183 ArraysMap* map = it->second.arraysMap.get(); 184 return (*map)[k]; 185 } bufferBindingsVAOStateRef186 VertexAttribBindingVector& bufferBindings() { 187 return it->second.bindingState; 188 } setEverBoundVAOStateRef189 void setEverBound() { 190 it->second.everBound = true; 191 } isEverBoundVAOStateRef192 bool isEverBound() { 193 return it->second.everBound; 194 } 195 VAOStateMap::iterator it; 196 }; 197 198 class FramebufferData; 199 200 class GLESConversionArrays 201 { 202 public: 203 void setArr(void* data,unsigned int stride,GLenum type); 204 void allocArr(unsigned int size,GLenum type); 205 ArrayData& operator[](int i); 206 void* getCurrentData(); 207 ArrayData& getCurrentArray(); 208 unsigned int getCurrentIndex(); 209 void operator++(); 210 211 ~GLESConversionArrays(); 212 private: 213 std::unordered_map<GLenum,ArrayData> m_arrays; 214 unsigned int m_current = 0; 215 }; 216 217 218 class GLEScontext{ 219 public: 220 GLEScontext(); 221 GLEScontext(GlobalNameSpace* globalNameSpace, android::base::Stream* stream, 222 GlLibrary* glLib); 223 virtual void init(); 224 static void initGlobal(EGLiface* eglIface); 225 GLenum getGLerror(); 226 void setGLerror(GLenum err); setShareGroup(ShareGroupPtr grp)227 void setShareGroup(ShareGroupPtr grp){m_shareGroup = std::move(grp);}; shareGroup()228 const ShareGroupPtr& shareGroup() const { return m_shareGroup; } 229 virtual void setActiveTexture(GLenum tex); getActiveTextureUnit()230 unsigned int getActiveTextureUnit() const { return m_activeTexture; } 231 unsigned int getBindedTexture(GLenum target); 232 unsigned int getBindedTexture(GLenum unit,GLenum target); 233 void setBindedTexture(GLenum target,unsigned int tex); 234 bool isTextureUnitEnabled(GLenum unit); 235 void setTextureEnabled(GLenum target, GLenum enable); 236 ObjectLocalName getDefaultTextureName(GLenum target); 237 ObjectLocalName getTextureLocalName(GLenum target, unsigned int tex); isInitialized()238 bool isInitialized() { return m_initialized; }; 239 bool needRestore(); 240 GLint getUnpackAlignment(); 241 242 bool isArrEnabled(GLenum); 243 virtual void enableArr(GLenum arr,bool enable); 244 245 void addVertexArrayObjects(GLsizei n, GLuint* arrays); 246 void removeVertexArrayObjects(GLsizei n, const GLuint* arrays); 247 bool setVertexArrayObject(GLuint array); 248 void setVAOEverBound(); 249 GLuint getVertexArrayObject() const; 250 bool vertexAttributesBufferBacked(); 251 const GLvoid* setPointer(GLenum arrType,GLint size,GLenum type,GLsizei stride,const GLvoid* data, GLsizei dataSize, bool normalize = false, bool isInt = false); 252 virtual const GLESpointer* getPointer(GLenum arrType); 253 virtual void setupArraysPointers(GLESConversionArrays& fArrs,GLint first,GLsizei count,GLenum type,const GLvoid* indices,bool direct) = 0; 254 255 static void prepareCoreProfileEmulatedTexture(TextureData* texData, bool is3d, GLenum target, 256 GLenum format, GLenum type, 257 GLint* internalformat_out, GLenum* format_out); 258 259 GLuint bindBuffer(GLenum target,GLuint buffer); // returns global name for dispatcher 260 virtual void bindIndexedBuffer(GLenum target, 261 GLuint index, 262 GLuint buffer, 263 GLintptr offset, 264 GLsizeiptr size, 265 GLintptr stride = 0, 266 bool isBindBase = false); 267 virtual void bindIndexedBuffer(GLenum target, GLuint index, GLuint buffer); 268 virtual void unbindBuffer(GLuint buffer); 269 bool isBuffer(GLuint buffer); 270 bool isBindedBuffer(GLenum target); 271 GLvoid* getBindedBuffer(GLenum target); 272 GLuint getBuffer(GLenum target); 273 virtual GLuint getIndexedBuffer(GLenum target, GLuint index); 274 void getBufferSize(GLenum target,GLint* param); 275 void getBufferSizeById(GLuint buffer,GLint* param); 276 void getBufferUsage(GLenum target,GLint* param); 277 bool setBufferData(GLenum target,GLsizeiptr size,const GLvoid* data,GLenum usage); 278 bool setBufferSubData(GLenum target,GLintptr offset,GLsizeiptr size,const GLvoid* data); 279 const char * getExtensionString(bool isGles1); 280 const char * getVendorString(bool isGles1) const; 281 const char * getRendererString(bool isGles1) const; 282 const char * getVersionString(bool isGles1) const; 283 void getGlobalLock(); 284 void releaseGlobalLock(); getCaps()285 virtual GLSupport* getCaps(){return &s_glSupport;}; getCapsGlobal()286 static GLSupport* getCapsGlobal(){return &s_glSupport;}; vulkanInteropSupported()287 static bool vulkanInteropSupported() { 288 return s_glSupport.ext_GL_EXT_memory_object && 289 s_glSupport.ext_GL_EXT_semaphore; 290 } shaderFramebufferFetchSupported()291 static bool shaderFramebufferFetchSupported() { 292 return s_glSupport.ext_GL_EXT_shader_framebuffer_fetch; 293 } 294 virtual ~GLEScontext(); 295 virtual int getMaxTexUnits() = 0; getMaxCombinedTexUnits()296 virtual int getMaxCombinedTexUnits() { return getMaxTexUnits(); } 297 virtual void drawValidate(void); 298 299 // Default FBO emulation. Do not call this from GLEScontext context; 300 // it needs dynamic dispatch (from GLEScmContext or GLESv2Context DLLs) 301 // to pick up on the right functions. 302 virtual void initDefaultFBO( 303 GLint width, GLint height, GLint colorFormat, GLint depthstencilFormat, GLint multisamples, 304 GLuint* eglSurfaceRBColorId, GLuint* eglSurfaceRBDepthId, 305 GLuint readWidth, GLint readHeight, GLint readColorFormat, GLint readDepthStencilFormat, GLint readMultisamples, 306 GLuint* eglReadSurfaceRBColorId, GLuint* eglReadSurfaceRBDepthId); 307 void initEmulatedEGLSurface(GLint width, GLint height, 308 GLint colorFormat, GLint depthstencilFormat, GLint multisamples, 309 GLuint rboColor, GLuint rboDepth); 310 getDefaultFBOGlobalName()311 GLuint getDefaultFBOGlobalName() const { return m_defaultFBO; } isDefaultFBOBound(GLenum target)312 bool isDefaultFBOBound(GLenum target) const { return !getFramebufferBinding(target); } hasEmulatedDefaultFBO()313 bool hasEmulatedDefaultFBO() const { return m_defaultFBO != 0; } 314 getDefaultFBOColorFormat()315 int getDefaultFBOColorFormat() const { return m_defaultFBOColorFormat; } getDefaultFBOWidth()316 int getDefaultFBOWidth() const { return m_defaultFBOWidth; } getDefaultFBOHeight()317 int getDefaultFBOHeight() const { return m_defaultFBOHeight; } getDefaultFBOMultisamples()318 int getDefaultFBOMultisamples() const { return m_defaultFBOSamples; } 319 setRenderbufferBinding(GLuint rb)320 void setRenderbufferBinding(GLuint rb) { m_renderbuffer = rb; } getRenderbufferBinding()321 GLuint getRenderbufferBinding() const { return m_renderbuffer; } setFramebufferBinding(GLenum target,GLuint fb)322 void setFramebufferBinding(GLenum target, GLuint fb) { 323 switch (target) { 324 case GL_READ_FRAMEBUFFER: 325 m_readFramebuffer = fb; 326 break; 327 case GL_DRAW_FRAMEBUFFER: 328 m_drawFramebuffer = fb; 329 break; 330 case GL_FRAMEBUFFER: 331 m_readFramebuffer = fb; 332 m_drawFramebuffer = fb; 333 break; 334 default: 335 m_drawFramebuffer = fb; 336 break; 337 } 338 } getFramebufferBinding(GLenum target)339 GLuint getFramebufferBinding(GLenum target) const { 340 switch (target) { 341 case GL_READ_FRAMEBUFFER: 342 return m_readFramebuffer; 343 case GL_DRAW_FRAMEBUFFER: 344 case GL_FRAMEBUFFER: 345 return m_drawFramebuffer; 346 } 347 return m_drawFramebuffer; 348 } 349 350 void setEnable(GLenum item, bool isEnable); 351 bool isEnabled(GLenum item) const; 352 void setBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha); 353 void setBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, 354 GLenum srcAlpha, GLenum dstAlpha); 355 void setPixelStorei(GLenum pname, GLint param); 356 357 void setViewport(GLint x, GLint y, GLsizei width, GLsizei height); 358 void getViewport(GLint* params); 359 void setPolygonOffset(GLfloat factor, GLfloat units); 360 void setScissor(GLint x, GLint y, GLsizei width, GLsizei height); 361 void setCullFace(GLenum mode); 362 void setFrontFace(GLenum mode); 363 364 void setDepthFunc(GLenum func); 365 void setDepthMask(GLboolean flag); 366 void setDepthRangef(GLclampf zNear, GLclampf zFar); 367 void setLineWidth(GLfloat lineWidth); 368 void setSampleCoverage(GLclampf value, GLboolean invert); 369 370 void setStencilFuncSeparate(GLenum face, GLenum func, GLint ref, 371 GLuint mask); 372 void setStencilMaskSeparate(GLenum face, GLuint mask); 373 void setStencilOpSeparate(GLenum face, GLenum fail, GLenum zfail, 374 GLenum zpass); 375 376 void setColorMask(GLboolean red, GLboolean green, GLboolean blue, 377 GLboolean alpha); 378 379 void setClearColor(GLclampf red, GLclampf green, GLclampf blue, 380 GLclampf alpha); 381 void setClearDepth(GLclampf depth); 382 void setClearStencil(GLint s); 383 384 // Core profile doesn't support GL_GENERATE_MIPMAP_HINT, 385 // so just emulate it here with no-ops. setHint(GLenum target,GLenum mode)386 void setHint(GLenum target, GLenum mode) { 387 m_hints[target] = mode; 388 } getHint(GLenum target)389 GLenum getHint(GLenum target) const { 390 return android::base::findOrDefault(m_hints, target, GL_DONT_CARE); 391 } 392 dispatcher()393 static GLDispatch& dispatcher(){return s_glDispatch;}; 394 static EGLiface* eglIface(); 395 static void initEglIface(EGLiface* iface); 396 getMaxLights()397 static int getMaxLights(){return s_glSupport.maxLights;} getMaxClipPlanes()398 static int getMaxClipPlanes(){return s_glSupport.maxClipPlane;} getMaxTexSize()399 static int getMaxTexSize(){return s_glSupport.maxTexSize;} glslVersion()400 static Version glslVersion(){return s_glSupport.glslVersion;} isAutoMipmapSupported()401 static bool isAutoMipmapSupported(){return s_glSupport.GL_SGIS_GENERATE_MIPMAP;} 402 static TextureTarget GLTextureTargetToLocal(GLenum target); 403 static unsigned int findMaxIndex(GLsizei count,GLenum type,const GLvoid* indices); 404 405 virtual bool glGetIntegerv(GLenum pname, GLint *params); 406 virtual bool glGetBooleanv(GLenum pname, GLboolean *params); 407 virtual bool glGetFloatv(GLenum pname, GLfloat *params); 408 virtual bool glGetFixedv(GLenum pname, GLfixed *params); 409 getMajorVersion()410 int getMajorVersion() const { return m_glesMajorVersion; } getMinorVersion()411 int getMinorVersion() const { return m_glesMinorVersion; } 412 413 // FBO 414 void initFBONameSpace(GlobalNameSpace* globalNameSpace, 415 android::base::Stream* stream); 416 bool isFBO(ObjectLocalName p_localName); 417 ObjectLocalName genFBOName(ObjectLocalName p_localName = 0, 418 bool genLocal = 0); 419 void setFBOData(ObjectLocalName p_localName, ObjectDataPtr data); 420 void setDefaultFBODrawBuffer(GLenum buffer); 421 void setDefaultFBOReadBuffer(GLenum buffer); 422 void deleteFBO(ObjectLocalName p_localName); 423 FramebufferData* getFBOData(ObjectLocalName p_localName) const; 424 ObjectDataPtr getFBODataPtr(ObjectLocalName p_localName) const; 425 unsigned int getFBOGlobalName(ObjectLocalName p_localName) const; 426 ObjectLocalName getFBOLocalName(unsigned int p_globalName) const; 427 int queryCurrFboBits(ObjectLocalName localFboName, GLenum pname); 428 429 // Texture emulation 430 void copyTexImageWithEmulation( 431 TextureData* texData, 432 bool isSubImage, 433 GLenum target, 434 GLint level, 435 GLenum internalformat, 436 GLint xoffset, GLint yoffset, 437 GLint x, GLint y, 438 GLsizei width, GLsizei height, 439 GLint border); 440 441 // Primitive restart emulation 442 void setPrimitiveRestartEnabled(bool enabled); primitiveRestartEnabled()443 bool primitiveRestartEnabled() const { 444 return m_primitiveRestartEnabled; 445 } 446 void updatePrimitiveRestartIndex(GLenum type); 447 448 bool isVAO(ObjectLocalName p_localName); 449 ObjectLocalName genVAOName(ObjectLocalName p_localName = 0, 450 bool genLocal = 0); 451 void deleteVAO(ObjectLocalName p_localName); 452 unsigned int getVAOGlobalName(ObjectLocalName p_localName); 453 ObjectLocalName getVAOLocalName(unsigned int p_globalName); 454 455 // Snapshot save 456 virtual void onSave(android::base::Stream* stream) const; 457 virtual void postSave(android::base::Stream* stream) const; 458 virtual ObjectDataPtr loadObject(NamedObjectType type, 459 ObjectLocalName localName, android::base::Stream* stream) const; 460 // postLoad is triggered after setting up ShareGroup 461 virtual void postLoad(); 462 virtual void restore(); 463 isCoreProfile()464 bool isCoreProfile() const { return m_coreProfile; } setCoreProfile(bool core)465 void setCoreProfile(bool core) { m_coreProfile = core; } 466 467 // Utility functions for emulation 468 static GLuint compileAndValidateCoreShader(GLenum shaderType, const char* src); 469 static GLuint linkAndValidateProgram(GLuint vshader, GLuint fshader); 470 contextNeedsRestore()471 bool contextNeedsRestore() const { 472 return m_needRestoreFromSnapshot; 473 } 474 475 void blitFromReadBufferToTextureFlipped(GLuint globalTexObj, 476 GLuint width, GLuint height, 477 GLint internalFormat, GLenum format, GLenum type); 478 479 protected: 480 void initDefaultFboImpl( 481 GLint width, GLint height, 482 GLint colorFormat, GLint depthstencilFormat, 483 GLint multisamples, 484 GLuint* eglSurfaceRBColorId, 485 GLuint* eglSurfaceRBDepthId); 486 487 virtual void postLoadRestoreShareGroup(); 488 virtual void postLoadRestoreCtx(); 489 490 static void buildStrings(bool isGles1, const char* baseVendor, const char* baseRenderer, const char* baseVersion, const char* version); 491 492 void freeVAOState(); 493 virtual void addVertexArrayObject(GLuint array); 494 void removeVertexArrayObject(GLuint array); 495 496 virtual bool needConvert(GLESConversionArrays& fArrs,GLint first,GLsizei count,GLenum type,const GLvoid* indices,bool direct,GLESpointer* p,GLenum array_id) = 0; 497 void convertDirect(GLESConversionArrays& fArrs,GLint first,GLsizei count,GLenum array_id,GLESpointer* p); 498 void convertDirectVBO(GLESConversionArrays& fArrs,GLint first,GLsizei count,GLenum array_id,GLESpointer* p); 499 void convertIndirect(GLESConversionArrays& fArrs,GLsizei count,GLenum type,const GLvoid* indices,GLenum array_id,GLESpointer* p); 500 void convertIndirectVBO(GLESConversionArrays& fArrs,GLsizei count,GLenum indices_type,const GLvoid* indices,GLenum array_id,GLESpointer* p); 501 static void initCapsLocked(const GLubyte * extensionString); 502 virtual void initExtensionString() =0; 503 504 bool m_needRestoreFromSnapshot = false; 505 static android::base::Lock s_lock; 506 static GLDispatch s_glDispatch; 507 bool m_initialized = false; 508 unsigned int m_activeTexture = 0; 509 510 VAOStateMap m_vaoStateMap; 511 VAOStateRef m_currVaoState; 512 // Buffer binding state 513 GLuint m_copyReadBuffer = 0; 514 GLuint m_copyWriteBuffer = 0; 515 GLuint m_pixelPackBuffer = 0; 516 GLuint m_pixelUnpackBuffer = 0; 517 GLuint m_transformFeedbackBuffer = 0; 518 GLuint m_uniformBuffer = 0; 519 GLuint m_atomicCounterBuffer = 0; 520 GLuint m_dispatchIndirectBuffer = 0; 521 GLuint m_drawIndirectBuffer = 0; 522 GLuint m_shaderStorageBuffer = 0; 523 std::vector<BufferBinding> m_indexedTransformFeedbackBuffers; 524 std::vector<BufferBinding> m_indexedUniformBuffers; 525 std::vector<BufferBinding> m_indexedAtomicCounterBuffers; 526 std::vector<BufferBinding> m_indexedShaderStorageBuffers; 527 528 bool m_isViewport = false; 529 GLint m_viewportX = 0; 530 GLint m_viewportY = 0; 531 GLsizei m_viewportWidth = 0; 532 GLsizei m_viewportHeight = 0; 533 534 GLfloat m_polygonOffsetFactor = 0.0f; 535 GLfloat m_polygonOffsetUnits = 0.0f; 536 537 bool m_isScissor = false; 538 GLint m_scissorX = 0; 539 GLint m_scissorY = 0; 540 GLsizei m_scissorWidth = 0; 541 GLsizei m_scissorHeight = 0; 542 543 std::unordered_map<GLenum, bool> m_glEnableList = std::unordered_map<GLenum, bool>(); 544 545 GLenum m_blendEquationRgb = GL_FUNC_ADD; 546 GLenum m_blendEquationAlpha = GL_FUNC_ADD; 547 548 GLenum m_blendSrcRgb = GL_ONE; 549 GLenum m_blendDstRgb = GL_ZERO; 550 GLenum m_blendSrcAlpha = GL_ONE; 551 GLenum m_blendDstAlpha = GL_ZERO; 552 553 std::unordered_map<GLenum, GLint> m_glPixelStoreiList; 554 555 GLenum m_cullFace = GL_BACK; 556 GLenum m_frontFace = GL_CCW; 557 558 GLenum m_depthFunc = GL_LESS; 559 GLboolean m_depthMask = GL_TRUE; 560 GLclampf m_zNear = 0.0f; 561 GLclampf m_zFar = 1.0f; 562 563 GLfloat m_lineWidth = 1.0f; 564 565 GLclampf m_sampleCoverageVal = 1.0f; 566 GLboolean m_sampleCoverageInvert = GL_FALSE; 567 568 enum { 569 StencilFront = 0, 570 StencilBack 571 }; 572 struct { 573 GLenum m_func = GL_ALWAYS; 574 GLint m_ref = 0; 575 GLuint m_funcMask = -1; // all bits set to 1 576 GLuint m_writeMask = -1; // all bits set to 1 577 GLenum m_sfail = GL_KEEP; 578 GLenum m_dpfail = GL_KEEP; 579 GLenum m_dppass = GL_KEEP; 580 } m_stencilStates[2]; 581 582 bool m_colorMaskR = GL_TRUE; 583 bool m_colorMaskG = GL_TRUE; 584 bool m_colorMaskB = GL_TRUE; 585 bool m_colorMaskA = GL_TRUE; 586 587 GLclampf m_clearColorR = 0.0f; 588 GLclampf m_clearColorG = 0.0f; 589 GLclampf m_clearColorB = 0.0f; 590 GLclampf m_clearColorA = 0.0f; 591 592 GLclampf m_clearDepth = 1.0f; 593 GLint m_clearStencil = 0; 594 595 static std::string* s_glExtensionsGles1; 596 static bool s_glExtensionsGles1Initialized; 597 static std::string* s_glExtensions; 598 static bool s_glExtensionsInitialized; 599 600 // Common for gles1/2 601 static GLSupport s_glSupport; 602 603 int m_glesMajorVersion = 1; 604 int m_glesMinorVersion = 0; 605 606 ShareGroupPtr m_shareGroup; 607 608 // Default FBO per-context state 609 GLuint m_defaultFBO = 0; 610 GLuint m_defaultReadFBO = 0; 611 GLuint m_defaultRBColor = 0; 612 GLuint m_defaultRBDepth = 0; 613 GLint m_defaultFBOWidth = 0; 614 GLint m_defaultFBOHeight = 0; 615 GLint m_defaultFBOColorFormat = 0; 616 GLint m_defaultFBODepthFormat = 0; 617 GLint m_defaultFBOStencilFormat = 0; 618 GLint m_defaultFBOSamples = 0; 619 GLenum m_defaultFBODrawBuffer = GL_COLOR_ATTACHMENT0; 620 GLenum m_defaultFBOReadBuffer = GL_COLOR_ATTACHMENT0; 621 622 // Texture emulation state 623 void initTexImageEmulation(); 624 GLuint m_textureEmulationFBO = 0; 625 GLuint m_textureEmulationTextures[2] = {}; 626 GLuint m_textureEmulationProg = 0; 627 GLuint m_textureEmulationVAO = 0; 628 GLuint m_textureEmulationVBO = 0; 629 GLuint m_textureEmulationSamplerLoc = 0; 630 631 std::function<GLESbuffer*(GLuint)> getBufferObj 632 = [this] (GLuint bufferName) -> GLESbuffer* { 633 return (GLESbuffer*)m_shareGroup->getObjectData( 634 NamedObjectType::VERTEXBUFFER, 635 (ObjectLocalName)bufferName); 636 }; 637 638 GLuint m_useProgram = 0; 639 640 private: 641 642 GLenum m_glError = GL_NO_ERROR; 643 int m_maxTexUnits; 644 unsigned int m_maxUsedTexUnit = 0; 645 textureUnitState* m_texState = nullptr; 646 unsigned int m_arrayBuffer = 0; 647 unsigned int m_elementBuffer = 0; 648 GLuint m_renderbuffer = 0; 649 GLuint m_drawFramebuffer = 0; 650 GLuint m_readFramebuffer = 0; 651 652 static std::string s_glVendorGles1; 653 static std::string s_glRendererGles1; 654 static std::string s_glVersionGles1; 655 656 static std::string s_glVendor; 657 static std::string s_glRenderer; 658 static std::string s_glVersion; 659 660 NameSpace* m_fboNameSpace = nullptr; 661 // m_vaoNameSpace is an empty shell that holds the names but not the data 662 // TODO(yahan): consider moving the data into it? 663 NameSpace* m_vaoNameSpace = nullptr; 664 665 bool m_coreProfile = false; 666 667 std::unordered_map<GLenum, GLenum> m_hints; 668 669 bool m_primitiveRestartEnabled = false; 670 671 struct ImageBlitState { 672 GLuint program = 0; 673 GLuint samplerLoc = 0; 674 675 GLuint vao = 0; 676 GLuint vbo = 0; 677 GLuint ibo = 0; 678 679 GLuint fbo = 0; 680 GLuint resolveFbo = 0; 681 GLuint tex = 0; 682 683 uint32_t width = 0; 684 uint32_t height = 0; 685 GLint internalFormat = 0; 686 uint32_t samples = 0; 687 uint32_t prevSamples = 0; 688 }; 689 690 ImageBlitState m_blitState = {}; 691 GLint getReadBufferSamples(); 692 GLint getReadBufferInternalFormat(); 693 void getReadBufferDimensions(GLint* width, GLint* height); 694 void setupImageBlitState(); 695 bool setupImageBlitForTexture(uint32_t width, uint32_t height, 696 GLint internalFormat); 697 }; 698 699 #endif 700 701