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 bool hasRgtcSupport = false; 115 }; 116 117 struct ArrayData { 118 void* data = nullptr; 119 GLenum type = 0; 120 unsigned int stride = 0; 121 bool allocated = false; 122 }; 123 124 struct BufferBinding { 125 GLuint buffer = 0; 126 GLintptr offset = 0; 127 GLsizeiptr size = 0; 128 GLintptr stride = 0; 129 GLuint divisor = 0; 130 bool isBindBase = false; 131 void onLoad(android::base::Stream* stream); 132 void onSave(android::base::Stream* stream) const; 133 }; 134 135 typedef std::vector<GLESpointer> VertexAttribInfoVector; 136 typedef std::vector<BufferBinding> VertexAttribBindingVector; 137 138 struct VAOState { VAOStateVAOState139 VAOState() : VAOState(0, NULL, 0) { } VAOStateVAOState140 VAOState(GLuint ibo, ArraysMap* arr, int numVertexAttribBindings) : 141 element_array_buffer_binding(ibo), 142 vertexAttribInfo(numVertexAttribBindings), 143 bindingState(numVertexAttribBindings), 144 everBound(false), 145 legacy(arr != nullptr), 146 arraysMap(arr) { } 147 VAOState(android::base::Stream* stream); 148 GLuint element_array_buffer_binding; 149 VertexAttribInfoVector vertexAttribInfo; 150 VertexAttribBindingVector bindingState; 151 bool bufferBacked; 152 bool everBound; 153 bool legacy = false; 154 std::unique_ptr<ArraysMap> arraysMap; 155 void onSave(android::base::Stream* stream) const; 156 }; 157 158 typedef std::unordered_map<GLuint, VAOState> VAOStateMap; 159 160 struct VAOStateRef { VAOStateRefVAOStateRef161 VAOStateRef() { } VAOStateRefVAOStateRef162 VAOStateRef(VAOStateMap::iterator iter) : it(iter) { } vaoIdVAOStateRef163 GLuint vaoId() const { return it->first; } iboIdVAOStateRef164 GLuint& iboId() { return it->second.element_array_buffer_binding; } 165 attribInfo_constVAOStateRef166 const VertexAttribInfoVector& attribInfo_const() const { 167 return it->second.vertexAttribInfo; 168 } 169 attribInfoVAOStateRef170 VertexAttribInfoVector& attribInfo() { 171 return it->second.vertexAttribInfo; 172 } 173 beginVAOStateRef174 ArraysMap::iterator begin() { 175 return it->second.arraysMap->begin(); 176 } endVAOStateRef177 ArraysMap::iterator end() { 178 return it->second.arraysMap->end(); 179 } findVAOStateRef180 ArraysMap::iterator find(GLenum arrType) { 181 return it->second.arraysMap->find(arrType); 182 } 183 GLESpointer*& operator[](size_t k) { 184 ArraysMap* map = it->second.arraysMap.get(); 185 return (*map)[k]; 186 } bufferBindingsVAOStateRef187 VertexAttribBindingVector& bufferBindings() { 188 return it->second.bindingState; 189 } setEverBoundVAOStateRef190 void setEverBound() { 191 it->second.everBound = true; 192 } isEverBoundVAOStateRef193 bool isEverBound() { 194 return it->second.everBound; 195 } 196 VAOStateMap::iterator it; 197 }; 198 199 class FramebufferData; 200 201 class GLESConversionArrays 202 { 203 public: 204 void setArr(void* data,unsigned int stride,GLenum type); 205 void allocArr(unsigned int size,GLenum type); 206 ArrayData& operator[](int i); 207 void* getCurrentData(); 208 ArrayData& getCurrentArray(); 209 unsigned int getCurrentIndex(); 210 void operator++(); 211 212 ~GLESConversionArrays(); 213 private: 214 std::unordered_map<GLenum,ArrayData> m_arrays; 215 unsigned int m_current = 0; 216 }; 217 218 219 class GLEScontext{ 220 public: 221 GLEScontext(); 222 GLEScontext(GlobalNameSpace* globalNameSpace, android::base::Stream* stream, 223 GlLibrary* glLib); 224 virtual void init(); 225 static void initGlobal(EGLiface* eglIface); 226 GLenum getGLerror(); 227 void setGLerror(GLenum err); setShareGroup(ShareGroupPtr grp)228 void setShareGroup(ShareGroupPtr grp){m_shareGroup = std::move(grp);}; shareGroup()229 const ShareGroupPtr& shareGroup() const { return m_shareGroup; } 230 virtual void setActiveTexture(GLenum tex); getActiveTextureUnit()231 unsigned int getActiveTextureUnit() const { return m_activeTexture; } 232 unsigned int getBindedTexture(GLenum target); 233 unsigned int getBindedTexture(GLenum unit,GLenum target); 234 void setBindedTexture(GLenum target,unsigned int tex); 235 bool isTextureUnitEnabled(GLenum unit); 236 void setTextureEnabled(GLenum target, GLenum enable); 237 ObjectLocalName getDefaultTextureName(GLenum target); 238 ObjectLocalName getTextureLocalName(GLenum target, unsigned int tex); isInitialized()239 bool isInitialized() { return m_initialized; }; 240 bool needRestore(); 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, bool* needEnablingPostDraw) = 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 void blitFromReadBufferToEGLImage(EGLImage image, GLint internalFormat, int width, int height); 479 480 protected: 481 void initDefaultFboImpl( 482 GLint width, GLint height, 483 GLint colorFormat, GLint depthstencilFormat, 484 GLint multisamples, 485 GLuint* eglSurfaceRBColorId, 486 GLuint* eglSurfaceRBDepthId); 487 488 virtual void postLoadRestoreShareGroup(); 489 virtual void postLoadRestoreCtx(); 490 491 static void buildStrings(bool isGles1, const char* baseVendor, const char* baseRenderer, const char* baseVersion, const char* version); 492 493 void freeVAOState(); 494 virtual void addVertexArrayObject(GLuint array); 495 void removeVertexArrayObject(GLuint array); 496 497 virtual bool needConvert(GLESConversionArrays& fArrs,GLint first,GLsizei count,GLenum type,const GLvoid* indices,bool direct,GLESpointer* p,GLenum array_id) = 0; 498 void convertDirect(GLESConversionArrays& fArrs,GLint first,GLsizei count,GLenum array_id,GLESpointer* p); 499 void convertDirectVBO(GLESConversionArrays& fArrs,GLint first,GLsizei count,GLenum array_id,GLESpointer* p); 500 void convertIndirect(GLESConversionArrays& fArrs,GLsizei count,GLenum type,const GLvoid* indices,GLenum array_id,GLESpointer* p); 501 void convertIndirectVBO(GLESConversionArrays& fArrs,GLsizei count,GLenum indices_type,const GLvoid* indices,GLenum array_id,GLESpointer* p); 502 static void initCapsLocked(const GLubyte * extensionString); 503 virtual void initExtensionString() =0; 504 505 bool m_needRestoreFromSnapshot = false; 506 static android::base::Lock s_lock; 507 static GLDispatch s_glDispatch; 508 bool m_initialized = false; 509 unsigned int m_activeTexture = 0; 510 511 VAOStateMap m_vaoStateMap; 512 VAOStateRef m_currVaoState; 513 // Buffer binding state 514 GLuint m_copyReadBuffer = 0; 515 GLuint m_copyWriteBuffer = 0; 516 GLuint m_pixelPackBuffer = 0; 517 GLuint m_pixelUnpackBuffer = 0; 518 GLuint m_transformFeedbackBuffer = 0; 519 GLuint m_uniformBuffer = 0; 520 GLuint m_atomicCounterBuffer = 0; 521 GLuint m_dispatchIndirectBuffer = 0; 522 GLuint m_drawIndirectBuffer = 0; 523 GLuint m_shaderStorageBuffer = 0; 524 std::vector<BufferBinding> m_indexedTransformFeedbackBuffers; 525 std::vector<BufferBinding> m_indexedUniformBuffers; 526 std::vector<BufferBinding> m_indexedAtomicCounterBuffers; 527 std::vector<BufferBinding> m_indexedShaderStorageBuffers; 528 529 bool m_isViewport = false; 530 GLint m_viewportX = 0; 531 GLint m_viewportY = 0; 532 GLsizei m_viewportWidth = 0; 533 GLsizei m_viewportHeight = 0; 534 535 GLfloat m_polygonOffsetFactor = 0.0f; 536 GLfloat m_polygonOffsetUnits = 0.0f; 537 538 bool m_isScissor = false; 539 GLint m_scissorX = 0; 540 GLint m_scissorY = 0; 541 GLsizei m_scissorWidth = 0; 542 GLsizei m_scissorHeight = 0; 543 544 std::unordered_map<GLenum, bool> m_glEnableList = std::unordered_map<GLenum, bool>(); 545 546 GLenum m_blendEquationRgb = GL_FUNC_ADD; 547 GLenum m_blendEquationAlpha = GL_FUNC_ADD; 548 549 GLenum m_blendSrcRgb = GL_ONE; 550 GLenum m_blendDstRgb = GL_ZERO; 551 GLenum m_blendSrcAlpha = GL_ONE; 552 GLenum m_blendDstAlpha = GL_ZERO; 553 554 std::unordered_map<GLenum, GLint> m_glPixelStoreiList; 555 556 GLenum m_cullFace = GL_BACK; 557 GLenum m_frontFace = GL_CCW; 558 559 GLenum m_depthFunc = GL_LESS; 560 GLboolean m_depthMask = GL_TRUE; 561 GLclampf m_zNear = 0.0f; 562 GLclampf m_zFar = 1.0f; 563 564 GLfloat m_lineWidth = 1.0f; 565 566 GLclampf m_sampleCoverageVal = 1.0f; 567 GLboolean m_sampleCoverageInvert = GL_FALSE; 568 569 enum { 570 StencilFront = 0, 571 StencilBack 572 }; 573 struct { 574 GLenum m_func = GL_ALWAYS; 575 GLint m_ref = 0; 576 GLuint m_funcMask = -1; // all bits set to 1 577 GLuint m_writeMask = -1; // all bits set to 1 578 GLenum m_sfail = GL_KEEP; 579 GLenum m_dpfail = GL_KEEP; 580 GLenum m_dppass = GL_KEEP; 581 } m_stencilStates[2]; 582 583 bool m_colorMaskR = GL_TRUE; 584 bool m_colorMaskG = GL_TRUE; 585 bool m_colorMaskB = GL_TRUE; 586 bool m_colorMaskA = GL_TRUE; 587 588 GLclampf m_clearColorR = 0.0f; 589 GLclampf m_clearColorG = 0.0f; 590 GLclampf m_clearColorB = 0.0f; 591 GLclampf m_clearColorA = 0.0f; 592 593 GLclampf m_clearDepth = 1.0f; 594 GLint m_clearStencil = 0; 595 596 static std::string* s_glExtensionsGles1; 597 static bool s_glExtensionsGles1Initialized; 598 static std::string* s_glExtensions; 599 static bool s_glExtensionsInitialized; 600 601 // Common for gles1/2 602 static GLSupport s_glSupport; 603 604 int m_glesMajorVersion = 1; 605 int m_glesMinorVersion = 0; 606 607 ShareGroupPtr m_shareGroup; 608 609 // Default FBO per-context state 610 GLuint m_defaultFBO = 0; 611 GLuint m_defaultReadFBO = 0; 612 GLuint m_defaultRBColor = 0; 613 GLuint m_defaultRBDepth = 0; 614 GLint m_defaultFBOWidth = 0; 615 GLint m_defaultFBOHeight = 0; 616 GLint m_defaultFBOColorFormat = 0; 617 GLint m_defaultFBODepthFormat = 0; 618 GLint m_defaultFBOStencilFormat = 0; 619 GLint m_defaultFBOSamples = 0; 620 GLenum m_defaultFBODrawBuffer = GL_COLOR_ATTACHMENT0; 621 GLenum m_defaultFBOReadBuffer = GL_COLOR_ATTACHMENT0; 622 623 // Texture emulation state 624 void initTexImageEmulation(); 625 GLuint m_textureEmulationFBO = 0; 626 GLuint m_textureEmulationTextures[2] = {}; 627 GLuint m_textureEmulationProg = 0; 628 GLuint m_textureEmulationVAO = 0; 629 GLuint m_textureEmulationVBO = 0; 630 GLuint m_textureEmulationSamplerLoc = 0; 631 632 std::function<GLESbuffer*(GLuint)> getBufferObj 633 = [this] (GLuint bufferName) -> GLESbuffer* { 634 return (GLESbuffer*)m_shareGroup->getObjectData( 635 NamedObjectType::VERTEXBUFFER, 636 (ObjectLocalName)bufferName); 637 }; 638 639 GLuint m_useProgram = 0; 640 641 private: 642 643 GLenum m_glError = GL_NO_ERROR; 644 int m_maxTexUnits; 645 unsigned int m_maxUsedTexUnit = 0; 646 textureUnitState* m_texState = nullptr; 647 unsigned int m_arrayBuffer = 0; 648 unsigned int m_elementBuffer = 0; 649 GLuint m_renderbuffer = 0; 650 GLuint m_drawFramebuffer = 0; 651 GLuint m_readFramebuffer = 0; 652 653 static std::string s_glVendorGles1; 654 static std::string s_glRendererGles1; 655 static std::string s_glVersionGles1; 656 657 static std::string s_glVendor; 658 static std::string s_glRenderer; 659 static std::string s_glVersion; 660 661 NameSpace* m_fboNameSpace = nullptr; 662 // m_vaoNameSpace is an empty shell that holds the names but not the data 663 // TODO(yahan): consider moving the data into it? 664 NameSpace* m_vaoNameSpace = nullptr; 665 666 bool m_coreProfile = false; 667 668 std::unordered_map<GLenum, GLenum> m_hints; 669 670 bool m_primitiveRestartEnabled = false; 671 672 struct ImageBlitState { 673 GLuint program = 0; 674 GLuint samplerLoc = 0; 675 676 GLuint vao = 0; 677 GLuint vbo = 0; 678 GLuint ibo = 0; 679 680 GLuint fbo = 0; 681 GLuint resolveFbo = 0; 682 GLuint tex = 0; 683 684 uint32_t width = 0; 685 uint32_t height = 0; 686 GLint internalFormat = 0; 687 uint32_t samples = 0; 688 uint32_t prevSamples = 0; 689 690 GLuint eglImageTex = 0; 691 }; 692 693 ImageBlitState m_blitState = {}; 694 GLint getReadBufferSamples(); 695 GLint getReadBufferInternalFormat(); 696 void getReadBufferDimensions(GLint* width, GLint* height); 697 void setupImageBlitState(); 698 bool setupImageBlitForTexture(uint32_t width, uint32_t height, 699 GLint internalFormat); 700 }; 701 702 #endif 703 704