1 /* 2 * Copyright 2012 Google Inc. 3 * 4 * Use of this source code is governed by a BSD-style license that can be 5 * found in the LICENSE file. 6 */ 7 8 #include "GrGLCaps.h" 9 #include "GrContextOptions.h" 10 #include "GrGLContext.h" 11 #include "GrGLRenderTarget.h" 12 #include "GrGLTexture.h" 13 #include "GrShaderCaps.h" 14 #include "SkTSearch.h" 15 #include "SkTSort.h" 16 #include "instanced/GLInstancedRendering.h" 17 18 GrGLCaps::GrGLCaps(const GrContextOptions& contextOptions, 19 const GrGLContextInfo& ctxInfo, 20 const GrGLInterface* glInterface) : INHERITED(contextOptions) { 21 fStandard = ctxInfo.standard(); 22 23 fStencilFormats.reset(); 24 fMSFBOType = kNone_MSFBOType; 25 fInvalidateFBType = kNone_InvalidateFBType; 26 fMapBufferType = kNone_MapBufferType; 27 fTransferBufferType = kNone_TransferBufferType; 28 fMaxFragmentUniformVectors = 0; 29 fUnpackRowLengthSupport = false; 30 fUnpackFlipYSupport = false; 31 fPackRowLengthSupport = false; 32 fPackFlipYSupport = false; 33 fTextureUsageSupport = false; 34 fTextureRedSupport = false; 35 fImagingSupport = false; 36 fVertexArrayObjectSupport = false; 37 fDirectStateAccessSupport = false; 38 fDebugSupport = false; 39 fES2CompatibilitySupport = false; 40 fDrawInstancedSupport = false; 41 fDrawIndirectSupport = false; 42 fMultiDrawIndirectSupport = false; 43 fBaseInstanceSupport = false; 44 fIsCoreProfile = false; 45 fBindFragDataLocationSupport = false; 46 fRectangleTextureSupport = false; 47 fTextureSwizzleSupport = false; 48 fRGBA8888PixelsOpsAreSlow = false; 49 fPartialFBOReadIsSlow = false; 50 fMipMapLevelAndLodControlSupport = false; 51 fRGBAToBGRAReadbackConversionsAreSlow = false; 52 fDoManualMipmapping = false; 53 fSRGBDecodeDisableSupport = false; 54 fSRGBDecodeDisableAffectsMipmaps = false; 55 56 fBlitFramebufferFlags = kNoSupport_BlitFramebufferFlag; 57 58 fShaderCaps.reset(new GrShaderCaps(contextOptions)); 59 60 this->init(contextOptions, ctxInfo, glInterface); 61 } 62 63 void GrGLCaps::init(const GrContextOptions& contextOptions, 64 const GrGLContextInfo& ctxInfo, 65 const GrGLInterface* gli) { 66 GrGLStandard standard = ctxInfo.standard(); 67 GrGLVersion version = ctxInfo.version(); 68 69 /************************************************************************** 70 * Caps specific to GrGLCaps 71 **************************************************************************/ 72 73 if (kGLES_GrGLStandard == standard) { 74 GR_GL_GetIntegerv(gli, GR_GL_MAX_FRAGMENT_UNIFORM_VECTORS, 75 &fMaxFragmentUniformVectors); 76 } else { 77 SkASSERT(kGL_GrGLStandard == standard); 78 GrGLint max; 79 GR_GL_GetIntegerv(gli, GR_GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, &max); 80 fMaxFragmentUniformVectors = max / 4; 81 if (version >= GR_GL_VER(3, 2)) { 82 GrGLint profileMask; 83 GR_GL_GetIntegerv(gli, GR_GL_CONTEXT_PROFILE_MASK, &profileMask); 84 fIsCoreProfile = SkToBool(profileMask & GR_GL_CONTEXT_CORE_PROFILE_BIT); 85 } 86 } 87 GR_GL_GetIntegerv(gli, GR_GL_MAX_VERTEX_ATTRIBS, &fMaxVertexAttributes); 88 89 if (kGL_GrGLStandard == standard) { 90 fUnpackRowLengthSupport = true; 91 fUnpackFlipYSupport = false; 92 fPackRowLengthSupport = true; 93 fPackFlipYSupport = false; 94 } else { 95 fUnpackRowLengthSupport = version >= GR_GL_VER(3,0) || 96 ctxInfo.hasExtension("GL_EXT_unpack_subimage"); 97 fUnpackFlipYSupport = ctxInfo.hasExtension("GL_CHROMIUM_flipy"); 98 fPackRowLengthSupport = version >= GR_GL_VER(3,0) || 99 ctxInfo.hasExtension("GL_NV_pack_subimage"); 100 fPackFlipYSupport = 101 ctxInfo.hasExtension("GL_ANGLE_pack_reverse_row_order"); 102 } 103 104 fTextureUsageSupport = (kGLES_GrGLStandard == standard) && 105 ctxInfo.hasExtension("GL_ANGLE_texture_usage"); 106 107 if (kGL_GrGLStandard == standard) { 108 fTextureBarrierSupport = version >= GR_GL_VER(4,5) || 109 ctxInfo.hasExtension("GL_ARB_texture_barrier") || 110 ctxInfo.hasExtension("GL_NV_texture_barrier"); 111 } else { 112 fTextureBarrierSupport = ctxInfo.hasExtension("GL_NV_texture_barrier"); 113 } 114 115 if (kGL_GrGLStandard == standard) { 116 fSampleLocationsSupport = version >= GR_GL_VER(3,2) || 117 ctxInfo.hasExtension("GL_ARB_texture_multisample"); 118 } else { 119 fSampleLocationsSupport = version >= GR_GL_VER(3,1); 120 } 121 122 // ARB_texture_rg is part of OpenGL 3.0, but osmesa doesn't support GL_RED 123 // and GL_RG on FBO textures. 124 if (kOSMesa_GrGLRenderer != ctxInfo.renderer()) { 125 if (kGL_GrGLStandard == standard) { 126 fTextureRedSupport = version >= GR_GL_VER(3,0) || 127 ctxInfo.hasExtension("GL_ARB_texture_rg"); 128 } else { 129 fTextureRedSupport = version >= GR_GL_VER(3,0) || 130 ctxInfo.hasExtension("GL_EXT_texture_rg"); 131 } 132 } 133 fImagingSupport = kGL_GrGLStandard == standard && 134 ctxInfo.hasExtension("GL_ARB_imaging"); 135 136 // A driver but on the nexus 6 causes incorrect dst copies when invalidate is called beforehand. 137 // Thus we are blacklisting this extension for now on Adreno4xx devices. 138 if (kAdreno4xx_GrGLRenderer != ctxInfo.renderer() && 139 ((kGL_GrGLStandard == standard && version >= GR_GL_VER(4,3)) || 140 (kGLES_GrGLStandard == standard && version >= GR_GL_VER(3,0)) || 141 ctxInfo.hasExtension("GL_ARB_invalidate_subdata"))) { 142 fDiscardRenderTargetSupport = true; 143 fInvalidateFBType = kInvalidate_InvalidateFBType; 144 } else if (ctxInfo.hasExtension("GL_EXT_discard_framebuffer")) { 145 fDiscardRenderTargetSupport = true; 146 fInvalidateFBType = kDiscard_InvalidateFBType; 147 } 148 149 if (kARM_GrGLVendor == ctxInfo.vendor() || kImagination_GrGLVendor == ctxInfo.vendor()) { 150 fFullClearIsFree = true; 151 } 152 153 if (kGL_GrGLStandard == standard) { 154 fVertexArrayObjectSupport = version >= GR_GL_VER(3, 0) || 155 ctxInfo.hasExtension("GL_ARB_vertex_array_object") || 156 ctxInfo.hasExtension("GL_APPLE_vertex_array_object"); 157 } else { 158 fVertexArrayObjectSupport = version >= GR_GL_VER(3, 0) || 159 ctxInfo.hasExtension("GL_OES_vertex_array_object"); 160 } 161 162 if (kGL_GrGLStandard == standard) { 163 fDirectStateAccessSupport = ctxInfo.hasExtension("GL_EXT_direct_state_access"); 164 } else { 165 fDirectStateAccessSupport = false; 166 } 167 168 if (kGL_GrGLStandard == standard && version >= GR_GL_VER(4,3)) { 169 fDebugSupport = true; 170 } else { 171 fDebugSupport = ctxInfo.hasExtension("GL_KHR_debug"); 172 } 173 174 if (kGL_GrGLStandard == standard) { 175 fES2CompatibilitySupport = ctxInfo.hasExtension("GL_ARB_ES2_compatibility"); 176 } 177 else { 178 fES2CompatibilitySupport = true; 179 } 180 181 if (kGL_GrGLStandard == standard) { 182 fMultisampleDisableSupport = true; 183 } else { 184 fMultisampleDisableSupport = ctxInfo.hasExtension("GL_EXT_multisample_compatibility"); 185 } 186 187 if (kGL_GrGLStandard == standard) { 188 if (version >= GR_GL_VER(3, 0)) { 189 fBindFragDataLocationSupport = true; 190 } 191 } else { 192 if (version >= GR_GL_VER(3, 0) && ctxInfo.hasExtension("GL_EXT_blend_func_extended")) { 193 fBindFragDataLocationSupport = true; 194 } 195 } 196 197 fBindUniformLocationSupport = ctxInfo.hasExtension("GL_CHROMIUM_bind_uniform_location"); 198 199 if (kGL_GrGLStandard == standard) { 200 if (version >= GR_GL_VER(3, 1) || ctxInfo.hasExtension("GL_ARB_texture_rectangle")) { 201 // We also require textureSize() support for rectangle 2D samplers which was added in 202 // GLSL 1.40. 203 if (ctxInfo.glslGeneration() >= k140_GrGLSLGeneration) { 204 fRectangleTextureSupport = true; 205 } 206 } 207 } else { 208 // Command buffer exposes this in GL ES context for Chromium reasons, 209 // but it should not be used. Also, at the time of writing command buffer 210 // lacks TexImage2D support and ANGLE lacks GL ES 3.0 support. 211 } 212 213 if (kGL_GrGLStandard == standard) { 214 if (version >= GR_GL_VER(3,3) || ctxInfo.hasExtension("GL_ARB_texture_swizzle")) { 215 fTextureSwizzleSupport = true; 216 } 217 } else { 218 if (version >= GR_GL_VER(3,0)) { 219 fTextureSwizzleSupport = true; 220 } 221 } 222 223 if (kGL_GrGLStandard == standard) { 224 fMipMapLevelAndLodControlSupport = true; 225 } else if (kGLES_GrGLStandard == standard) { 226 if (version >= GR_GL_VER(3,0)) { 227 fMipMapLevelAndLodControlSupport = true; 228 } 229 } 230 231 #ifdef SK_BUILD_FOR_WIN 232 // We're assuming that on Windows Chromium we're using ANGLE. 233 bool isANGLE = kANGLE_GrGLDriver == ctxInfo.driver() || 234 kChromium_GrGLDriver == ctxInfo.driver(); 235 // Angle has slow read/write pixel paths for 32bit RGBA (but fast for BGRA). 236 fRGBA8888PixelsOpsAreSlow = isANGLE; 237 // On DX9 ANGLE reading a partial FBO is slow. TODO: Check whether this is still true and 238 // check DX11 ANGLE. 239 fPartialFBOReadIsSlow = isANGLE; 240 #endif 241 242 bool isMESA = kMesa_GrGLDriver == ctxInfo.driver(); 243 bool isMAC = false; 244 #ifdef SK_BUILD_FOR_MAC 245 isMAC = true; 246 #endif 247 248 // Both mesa and mac have reduced performance if reading back an RGBA framebuffer as BGRA or 249 // vis-versa. 250 fRGBAToBGRAReadbackConversionsAreSlow = isMESA || isMAC; 251 252 /************************************************************************** 253 * GrShaderCaps fields 254 **************************************************************************/ 255 256 // This must be called after fCoreProfile is set on the GrGLCaps 257 this->initGLSL(ctxInfo); 258 GrShaderCaps* shaderCaps = fShaderCaps.get(); 259 260 if (!contextOptions.fSuppressPathRendering) { 261 shaderCaps->fPathRenderingSupport = this->hasPathRenderingSupport(ctxInfo, gli); 262 } 263 264 // For now these two are equivalent but we could have dst read in shader via some other method. 265 // Before setting this, initGLSL() must have been called. 266 shaderCaps->fDstReadInShaderSupport = shaderCaps->fFBFetchSupport; 267 268 // Enable supported shader-related caps 269 if (kGL_GrGLStandard == standard) { 270 shaderCaps->fDualSourceBlendingSupport = (ctxInfo.version() >= GR_GL_VER(3, 3) || 271 ctxInfo.hasExtension("GL_ARB_blend_func_extended")) && 272 GrGLSLSupportsNamedFragmentShaderOutputs(ctxInfo.glslGeneration()); 273 shaderCaps->fShaderDerivativeSupport = true; 274 // we don't support GL_ARB_geometry_shader4, just GL 3.2+ GS 275 shaderCaps->fGeometryShaderSupport = ctxInfo.version() >= GR_GL_VER(3, 2) && 276 ctxInfo.glslGeneration() >= k150_GrGLSLGeneration; 277 shaderCaps->fIntegerSupport = ctxInfo.version() >= GR_GL_VER(3, 0) && 278 ctxInfo.glslGeneration() >= k130_GrGLSLGeneration; 279 } 280 else { 281 shaderCaps->fDualSourceBlendingSupport = ctxInfo.hasExtension("GL_EXT_blend_func_extended"); 282 283 shaderCaps->fShaderDerivativeSupport = ctxInfo.version() >= GR_GL_VER(3, 0) || 284 ctxInfo.hasExtension("GL_OES_standard_derivatives"); 285 286 shaderCaps->fGeometryShaderSupport = ctxInfo.hasExtension("GL_EXT_geometry_shader"); 287 288 shaderCaps->fIntegerSupport = ctxInfo.version() >= GR_GL_VER(3, 0) && 289 ctxInfo.glslGeneration() >= k330_GrGLSLGeneration; // We use this value for GLSL ES 3.0. 290 } 291 292 // Protect ourselves against tracking huge amounts of texture state. 293 static const uint8_t kMaxSaneSamplers = 32; 294 GrGLint maxSamplers; 295 GR_GL_GetIntegerv(gli, GR_GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS, &maxSamplers); 296 shaderCaps->fMaxVertexSamplers = SkTMin<GrGLint>(kMaxSaneSamplers, maxSamplers); 297 if (shaderCaps->fGeometryShaderSupport) { 298 GR_GL_GetIntegerv(gli, GR_GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS, &maxSamplers); 299 shaderCaps->fMaxGeometrySamplers = SkTMin<GrGLint>(kMaxSaneSamplers, maxSamplers); 300 } 301 GR_GL_GetIntegerv(gli, GR_GL_MAX_TEXTURE_IMAGE_UNITS, &maxSamplers); 302 shaderCaps->fMaxFragmentSamplers = SkTMin<GrGLint>(kMaxSaneSamplers, maxSamplers); 303 GR_GL_GetIntegerv(gli, GR_GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &maxSamplers); 304 shaderCaps->fMaxCombinedSamplers = SkTMin<GrGLint>(kMaxSaneSamplers, maxSamplers); 305 306 if (kGL_GrGLStandard == standard) { 307 shaderCaps->fImageLoadStoreSupport = ctxInfo.version() >= GR_GL_VER(4, 2); 308 if (!shaderCaps->fImageLoadStoreSupport && 309 ctxInfo.hasExtension("GL_ARB_shader_image_load_store")) { 310 shaderCaps->fImageLoadStoreSupport = true; 311 shaderCaps->fImageLoadStoreExtensionString = "GL_ARB_shader_image_load_store"; 312 } 313 } else { 314 shaderCaps->fImageLoadStoreSupport = ctxInfo.version() >= GR_GL_VER(3, 1); 315 } 316 if (shaderCaps->fImageLoadStoreSupport) { 317 // Protect ourselves against tracking huge amounts of image state. 318 static constexpr int kMaxSaneImages = 4; 319 GrGLint maxUnits; 320 GR_GL_GetIntegerv(gli, GR_GL_MAX_IMAGE_UNITS, &maxUnits); 321 GR_GL_GetIntegerv(gli, GR_GL_MAX_VERTEX_IMAGE_UNIFORMS, 322 &shaderCaps->fMaxVertexImageStorages); 323 if (shaderCaps->fGeometryShaderSupport) { 324 GR_GL_GetIntegerv(gli, GR_GL_MAX_GEOMETRY_IMAGE_UNIFORMS, 325 &shaderCaps->fMaxGeometryImageStorages); 326 } 327 GR_GL_GetIntegerv(gli, GR_GL_MAX_FRAGMENT_IMAGE_UNIFORMS, 328 &shaderCaps->fMaxFragmentImageStorages); 329 GR_GL_GetIntegerv(gli, GR_GL_MAX_COMBINED_IMAGE_UNIFORMS, 330 &shaderCaps->fMaxCombinedImageStorages); 331 // We use one unit for every image uniform 332 shaderCaps->fMaxCombinedImageStorages = SkTMin(SkTMin(shaderCaps->fMaxCombinedImageStorages, 333 maxUnits), kMaxSaneImages); 334 shaderCaps->fMaxVertexImageStorages = SkTMin(maxUnits, 335 shaderCaps->fMaxVertexImageStorages); 336 shaderCaps->fMaxGeometryImageStorages = SkTMin(maxUnits, 337 shaderCaps->fMaxGeometryImageStorages); 338 shaderCaps->fMaxFragmentImageStorages = SkTMin(maxUnits, 339 shaderCaps->fMaxFragmentImageStorages); 340 } 341 342 /************************************************************************** 343 * GrCaps fields 344 **************************************************************************/ 345 346 // We need dual source blending and the ability to disable multisample in order to support mixed 347 // samples in every corner case. We only use mixed samples if the stencil-and-cover path 348 // renderer is available and enabled; no other path renderers support this feature. 349 if (fMultisampleDisableSupport && 350 shaderCaps->dualSourceBlendingSupport() && 351 fShaderCaps->pathRenderingSupport() && 352 (contextOptions.fGpuPathRenderers & GrContextOptions::GpuPathRenderers::kStencilAndCover)) { 353 fUsesMixedSamples = ctxInfo.hasExtension("GL_NV_framebuffer_mixed_samples") || 354 ctxInfo.hasExtension("GL_CHROMIUM_framebuffer_mixed_samples"); 355 // Workaround NVIDIA bug related to glInvalidateFramebuffer and mixed samples. 356 if (fUsesMixedSamples && (kNVIDIA_GrGLDriver == ctxInfo.driver() || 357 kChromium_GrGLDriver == ctxInfo.driver())) { 358 fDiscardRenderTargetSupport = false; 359 fInvalidateFBType = kNone_InvalidateFBType; 360 } 361 } 362 363 // SGX and Mali GPUs that are based on a tiled-deferred architecture that have trouble with 364 // frequently changing VBOs. We've measured a performance increase using non-VBO vertex 365 // data for dynamic content on these GPUs. Perhaps we should read the renderer string and 366 // limit this decision to specific GPU families rather than basing it on the vendor alone. 367 if (!GR_GL_MUST_USE_VBO && 368 !fIsCoreProfile && 369 (kARM_GrGLVendor == ctxInfo.vendor() || 370 kImagination_GrGLVendor == ctxInfo.vendor() || 371 kQualcomm_GrGLVendor == ctxInfo.vendor())) { 372 fPreferClientSideDynamicBuffers = true; 373 } 374 375 // fUsesMixedSamples must be set before calling initFSAASupport. 376 this->initFSAASupport(ctxInfo, gli); 377 this->initBlendEqationSupport(ctxInfo); 378 this->initStencilFormats(ctxInfo); 379 380 if (kGL_GrGLStandard == standard) { 381 // we could also look for GL_ATI_separate_stencil extension or 382 // GL_EXT_stencil_two_side but they use different function signatures 383 // than GL2.0+ (and than each other). 384 fTwoSidedStencilSupport = (ctxInfo.version() >= GR_GL_VER(2,0)); 385 // supported on GL 1.4 and higher or by extension 386 fStencilWrapOpsSupport = (ctxInfo.version() >= GR_GL_VER(1,4)) || 387 ctxInfo.hasExtension("GL_EXT_stencil_wrap"); 388 } else { 389 // ES 2 has two sided stencil and stencil wrap 390 fTwoSidedStencilSupport = true; 391 fStencilWrapOpsSupport = true; 392 } 393 394 if (kGL_GrGLStandard == standard) { 395 fMapBufferFlags = kCanMap_MapFlag; // we require VBO support and the desktop VBO 396 // extension includes glMapBuffer. 397 if (version >= GR_GL_VER(3, 0) || ctxInfo.hasExtension("GL_ARB_map_buffer_range")) { 398 fMapBufferFlags |= kSubset_MapFlag; 399 fMapBufferType = kMapBufferRange_MapBufferType; 400 } else { 401 fMapBufferType = kMapBuffer_MapBufferType; 402 } 403 } else { 404 // Unextended GLES2 doesn't have any buffer mapping. 405 fMapBufferFlags = kNone_MapBufferType; 406 if (ctxInfo.hasExtension("GL_CHROMIUM_map_sub")) { 407 fMapBufferFlags = kCanMap_MapFlag | kSubset_MapFlag; 408 fMapBufferType = kChromium_MapBufferType; 409 } else if (version >= GR_GL_VER(3, 0) || ctxInfo.hasExtension("GL_EXT_map_buffer_range")) { 410 fMapBufferFlags = kCanMap_MapFlag | kSubset_MapFlag; 411 fMapBufferType = kMapBufferRange_MapBufferType; 412 } else if (ctxInfo.hasExtension("GL_OES_mapbuffer")) { 413 fMapBufferFlags = kCanMap_MapFlag; 414 fMapBufferType = kMapBuffer_MapBufferType; 415 } 416 } 417 418 if (kGL_GrGLStandard == standard) { 419 if (version >= GR_GL_VER(3, 0) || ctxInfo.hasExtension("GL_ARB_pixel_buffer_object")) { 420 fTransferBufferType = kPBO_TransferBufferType; 421 } 422 } else { 423 if (version >= GR_GL_VER(3, 0) || ctxInfo.hasExtension("GL_NV_pixel_buffer_object")) { 424 fTransferBufferType = kPBO_TransferBufferType; 425 } else if (ctxInfo.hasExtension("GL_CHROMIUM_pixel_transfer_buffer_object")) { 426 fTransferBufferType = kChromium_TransferBufferType; 427 } 428 } 429 430 // On many GPUs, map memory is very expensive, so we effectively disable it here by setting the 431 // threshold to the maximum unless the client gives us a hint that map memory is cheap. 432 if (fBufferMapThreshold < 0) { 433 #if 0 434 // We think mapping on Chromium will be cheaper once we know ahead of time how much space 435 // we will use for all GrMeshDrawOps. Right now we might wind up mapping a large buffer and 436 // using a small subset. 437 fBufferMapThreshold = kChromium_GrGLDriver == ctxInfo.driver() ? 0 : SK_MaxS32; 438 #else 439 fBufferMapThreshold = SK_MaxS32; 440 #endif 441 } 442 443 if (kGL_GrGLStandard == standard) { 444 SkASSERT(ctxInfo.version() >= GR_GL_VER(2,0) || 445 ctxInfo.hasExtension("GL_ARB_texture_non_power_of_two")); 446 fNPOTTextureTileSupport = true; 447 fMipMapSupport = true; 448 } else { 449 // Unextended ES2 supports NPOT textures with clamp_to_edge and non-mip filters only 450 // ES3 has no limitations. 451 fNPOTTextureTileSupport = ctxInfo.version() >= GR_GL_VER(3,0) || 452 ctxInfo.hasExtension("GL_OES_texture_npot"); 453 // ES2 supports MIP mapping for POT textures but our caps don't allow for limited MIP 454 // support. The OES extension or ES 3.0 allow for MIPS on NPOT textures. So, apparently, 455 // does the undocumented GL_IMG_texture_npot extension. This extension does not seem to 456 // to alllow arbitrary wrap modes, however. 457 fMipMapSupport = fNPOTTextureTileSupport || ctxInfo.hasExtension("GL_IMG_texture_npot"); 458 } 459 460 // Using MIPs on this GPU seems to be a source of trouble. 461 if (kPowerVR54x_GrGLRenderer == ctxInfo.renderer()) { 462 fMipMapSupport = false; 463 } 464 465 GR_GL_GetIntegerv(gli, GR_GL_MAX_TEXTURE_SIZE, &fMaxTextureSize); 466 GR_GL_GetIntegerv(gli, GR_GL_MAX_RENDERBUFFER_SIZE, &fMaxRenderTargetSize); 467 // Our render targets are always created with textures as the color 468 // attachment, hence this min: 469 fMaxRenderTargetSize = SkTMin(fMaxTextureSize, fMaxRenderTargetSize); 470 471 fGpuTracingSupport = ctxInfo.hasExtension("GL_EXT_debug_marker"); 472 473 // Disable scratch texture reuse on Mali and Adreno devices 474 fReuseScratchTextures = kARM_GrGLVendor != ctxInfo.vendor(); 475 476 #if 0 477 fReuseScratchBuffers = kARM_GrGLVendor != ctxInfo.vendor() && 478 kQualcomm_GrGLVendor != ctxInfo.vendor(); 479 #endif 480 481 // initFSAASupport() must have been called before this point 482 if (GrGLCaps::kES_IMG_MsToTexture_MSFBOType == fMSFBOType) { 483 GR_GL_GetIntegerv(gli, GR_GL_MAX_SAMPLES_IMG, &fMaxStencilSampleCount); 484 } else if (GrGLCaps::kNone_MSFBOType != fMSFBOType) { 485 GR_GL_GetIntegerv(gli, GR_GL_MAX_SAMPLES, &fMaxStencilSampleCount); 486 } 487 // We only have a use for raster multisample if there is coverage modulation from mixed samples. 488 if (fUsesMixedSamples && ctxInfo.hasExtension("GL_EXT_raster_multisample")) { 489 GR_GL_GetIntegerv(gli, GR_GL_MAX_RASTER_SAMPLES, &fMaxRasterSamples); 490 // This is to guard against platforms that may not support as many samples for 491 // glRasterSamples as they do for framebuffers. 492 fMaxStencilSampleCount = SkTMin(fMaxStencilSampleCount, fMaxRasterSamples); 493 } 494 fMaxColorSampleCount = fMaxStencilSampleCount; 495 496 if (ctxInfo.hasExtension("GL_EXT_window_rectangles")) { 497 GR_GL_GetIntegerv(gli, GR_GL_MAX_WINDOW_RECTANGLES, &fMaxWindowRectangles); 498 } 499 500 if (kPowerVR54x_GrGLRenderer == ctxInfo.renderer() || 501 kPowerVRRogue_GrGLRenderer == ctxInfo.renderer() || 502 (kAdreno3xx_GrGLRenderer == ctxInfo.renderer() && 503 ctxInfo.driver() != kChromium_GrGLDriver)) { 504 fUseDrawInsteadOfClear = true; 505 } 506 507 if (kAdreno4xx_GrGLRenderer == ctxInfo.renderer()) { 508 fUseDrawInsteadOfPartialRenderTargetWrite = true; 509 } 510 511 // Texture uploads sometimes seem to be ignored to textures bound to FBOS on Tegra3. 512 if (kTegra3_GrGLRenderer == ctxInfo.renderer()) { 513 fUseDrawInsteadOfPartialRenderTargetWrite = true; 514 fUseDrawInsteadOfAllRenderTargetWrites = true; 515 } 516 517 #ifdef SK_BUILD_FOR_WIN 518 // On ANGLE deferring flushes can lead to GPU starvation 519 fPreferVRAMUseOverFlushes = !isANGLE; 520 #endif 521 522 if (kChromium_GrGLDriver == ctxInfo.driver()) { 523 fMustClearUploadedBufferData = true; 524 } 525 526 if (kGL_GrGLStandard == standard) { 527 // ARB allows mixed size FBO attachments, EXT does not. 528 if (ctxInfo.version() >= GR_GL_VER(3, 0) || 529 ctxInfo.hasExtension("GL_ARB_framebuffer_object")) { 530 fOversizedStencilSupport = true; 531 } else { 532 SkASSERT(ctxInfo.hasExtension("GL_EXT_framebuffer_object")); 533 } 534 } else { 535 // ES 3.0 supports mixed size FBO attachments, 2.0 does not. 536 fOversizedStencilSupport = ctxInfo.version() >= GR_GL_VER(3, 0); 537 } 538 539 if (kGL_GrGLStandard == standard) { 540 // 3.1 has draw_instanced but not instanced_arrays, for the time being we only care about 541 // instanced arrays, but we could make this more granular if we wanted 542 fDrawInstancedSupport = 543 version >= GR_GL_VER(3, 2) || 544 (ctxInfo.hasExtension("GL_ARB_draw_instanced") && 545 ctxInfo.hasExtension("GL_ARB_instanced_arrays")); 546 } else { 547 fDrawInstancedSupport = 548 version >= GR_GL_VER(3, 0) || 549 (ctxInfo.hasExtension("GL_EXT_draw_instanced") && 550 ctxInfo.hasExtension("GL_EXT_instanced_arrays")); 551 } 552 553 if (kGL_GrGLStandard == standard) { 554 fDrawIndirectSupport = version >= GR_GL_VER(4,0) || 555 ctxInfo.hasExtension("GL_ARB_draw_indirect"); 556 fBaseInstanceSupport = version >= GR_GL_VER(4,2); 557 fMultiDrawIndirectSupport = version >= GR_GL_VER(4,3) || 558 (fDrawIndirectSupport && 559 !fBaseInstanceSupport && // The ARB extension has no base inst. 560 ctxInfo.hasExtension("GL_ARB_multi_draw_indirect")); 561 fDrawRangeElementsSupport = version >= GR_GL_VER(2,0); 562 } else { 563 fDrawIndirectSupport = version >= GR_GL_VER(3,1); 564 fMultiDrawIndirectSupport = fDrawIndirectSupport && 565 ctxInfo.hasExtension("GL_EXT_multi_draw_indirect"); 566 fBaseInstanceSupport = fDrawIndirectSupport && 567 ctxInfo.hasExtension("GL_EXT_base_instance"); 568 fDrawRangeElementsSupport = version >= GR_GL_VER(3,0); 569 } 570 571 this->initShaderPrecisionTable(ctxInfo, gli, shaderCaps); 572 573 if (contextOptions.fUseShaderSwizzling) { 574 fTextureSwizzleSupport = false; 575 } 576 577 if (kGL_GrGLStandard == standard) { 578 if ((version >= GR_GL_VER(4, 0) || ctxInfo.hasExtension("GL_ARB_sample_shading")) && 579 ctxInfo.vendor() != kIntel_GrGLVendor) { 580 fSampleShadingSupport = true; 581 } 582 } else if (ctxInfo.hasExtension("GL_OES_sample_shading")) { 583 fSampleShadingSupport = true; 584 } 585 586 // TODO: support CHROMIUM_sync_point and maybe KHR_fence_sync 587 if (kGL_GrGLStandard == standard) { 588 if (version >= GR_GL_VER(3, 2) || ctxInfo.hasExtension("GL_ARB_sync")) { 589 fFenceSyncSupport = true; 590 } 591 } else if (version >= GR_GL_VER(3, 0)) { 592 fFenceSyncSupport = true; 593 } 594 595 // Safely moving textures between contexts requires fences. The Windows Intel driver has a 596 // bug with deleting and reusing texture IDs across contexts, so disallow this feature. 597 fCrossContextTextureSupport = fFenceSyncSupport; 598 #ifdef SK_BUILD_FOR_WIN 599 if (kIntel_GrGLVendor == ctxInfo.vendor()) { 600 fCrossContextTextureSupport = false; 601 } 602 #endif 603 604 // We support manual mip-map generation (via iterative downsampling draw calls). This fixes 605 // bugs on some cards/drivers that produce incorrect mip-maps for sRGB textures when using 606 // glGenerateMipmap. Our implementation requires mip-level sampling control. Additionally, 607 // it can be much slower (especially on mobile GPUs), so we opt-in only when necessary: 608 if (fMipMapLevelAndLodControlSupport && 609 (contextOptions.fDoManualMipmapping || 610 (kIntel_GrGLVendor == ctxInfo.vendor()) || 611 (kNVIDIA_GrGLDriver == ctxInfo.driver() && isMAC) || 612 (kATI_GrGLVendor == ctxInfo.vendor()))) { 613 fDoManualMipmapping = true; 614 } 615 616 fSRGBDecodeDisableSupport = ctxInfo.hasExtension("GL_EXT_texture_sRGB_decode"); 617 fSRGBDecodeDisableAffectsMipmaps = fSRGBDecodeDisableSupport && 618 kChromium_GrGLDriver != ctxInfo.driver(); 619 620 // Requires fTextureRedSupport, fTextureSwizzleSupport, msaa support, ES compatibility have 621 // already been detected. 622 this->initConfigTable(contextOptions, ctxInfo, gli, shaderCaps); 623 624 this->applyOptionsOverrides(contextOptions); 625 shaderCaps->applyOptionsOverrides(contextOptions); 626 } 627 628 const char* get_glsl_version_decl_string(GrGLStandard standard, GrGLSLGeneration generation, 629 bool isCoreProfile) { 630 switch (generation) { 631 case k110_GrGLSLGeneration: 632 if (kGLES_GrGLStandard == standard) { 633 // ES2s shader language is based on version 1.20 but is version 634 // 1.00 of the ES language. 635 return "#version 100\n"; 636 } else { 637 SkASSERT(kGL_GrGLStandard == standard); 638 return "#version 110\n"; 639 } 640 case k130_GrGLSLGeneration: 641 SkASSERT(kGL_GrGLStandard == standard); 642 return "#version 130\n"; 643 case k140_GrGLSLGeneration: 644 SkASSERT(kGL_GrGLStandard == standard); 645 return "#version 140\n"; 646 case k150_GrGLSLGeneration: 647 SkASSERT(kGL_GrGLStandard == standard); 648 if (isCoreProfile) { 649 return "#version 150\n"; 650 } else { 651 return "#version 150 compatibility\n"; 652 } 653 case k330_GrGLSLGeneration: 654 if (kGLES_GrGLStandard == standard) { 655 return "#version 300 es\n"; 656 } else { 657 SkASSERT(kGL_GrGLStandard == standard); 658 if (isCoreProfile) { 659 return "#version 330\n"; 660 } else { 661 return "#version 330 compatibility\n"; 662 } 663 } 664 case k400_GrGLSLGeneration: 665 SkASSERT(kGL_GrGLStandard == standard); 666 if (isCoreProfile) { 667 return "#version 400\n"; 668 } else { 669 return "#version 400 compatibility\n"; 670 } 671 case k420_GrGLSLGeneration: 672 SkASSERT(kGL_GrGLStandard == standard); 673 if (isCoreProfile) { 674 return "#version 420\n"; 675 } 676 else { 677 return "#version 420 compatibility\n"; 678 } 679 case k310es_GrGLSLGeneration: 680 SkASSERT(kGLES_GrGLStandard == standard); 681 return "#version 310 es\n"; 682 case k320es_GrGLSLGeneration: 683 SkASSERT(kGLES_GrGLStandard == standard); 684 return "#version 320 es\n"; 685 } 686 return "<no version>"; 687 } 688 689 void GrGLCaps::initGLSL(const GrGLContextInfo& ctxInfo) { 690 GrGLStandard standard = ctxInfo.standard(); 691 GrGLVersion version = ctxInfo.version(); 692 693 /************************************************************************** 694 * Caps specific to GrShaderCaps 695 **************************************************************************/ 696 697 GrShaderCaps* shaderCaps = fShaderCaps.get(); 698 shaderCaps->fGLSLGeneration = ctxInfo.glslGeneration(); 699 if (kGLES_GrGLStandard == standard) { 700 if (ctxInfo.hasExtension("GL_EXT_shader_framebuffer_fetch")) { 701 shaderCaps->fFBFetchNeedsCustomOutput = (version >= GR_GL_VER(3, 0)); 702 shaderCaps->fFBFetchSupport = true; 703 shaderCaps->fFBFetchColorName = "gl_LastFragData[0]"; 704 shaderCaps->fFBFetchExtensionString = "GL_EXT_shader_framebuffer_fetch"; 705 } 706 else if (ctxInfo.hasExtension("GL_NV_shader_framebuffer_fetch")) { 707 // Actually, we haven't seen an ES3.0 device with this extension yet, so we don't know 708 shaderCaps->fFBFetchNeedsCustomOutput = false; 709 shaderCaps->fFBFetchSupport = true; 710 shaderCaps->fFBFetchColorName = "gl_LastFragData[0]"; 711 shaderCaps->fFBFetchExtensionString = "GL_NV_shader_framebuffer_fetch"; 712 } 713 else if (ctxInfo.hasExtension("GL_ARM_shader_framebuffer_fetch")) { 714 // The arm extension also requires an additional flag which we will set onResetContext 715 shaderCaps->fFBFetchNeedsCustomOutput = false; 716 shaderCaps->fFBFetchSupport = true; 717 shaderCaps->fFBFetchColorName = "gl_LastFragColorARM"; 718 shaderCaps->fFBFetchExtensionString = "GL_ARM_shader_framebuffer_fetch"; 719 } 720 shaderCaps->fUsesPrecisionModifiers = true; 721 } 722 723 // Currently the extension is advertised but fb fetch is broken on 500 series Adrenos like the 724 // Galaxy S7. 725 // TODO: Once this is fixed we can update the check here to look at a driver version number too. 726 if (kAdreno5xx_GrGLRenderer == ctxInfo.renderer()) { 727 shaderCaps->fFBFetchSupport = false; 728 } 729 730 shaderCaps->fBindlessTextureSupport = ctxInfo.hasExtension("GL_NV_bindless_texture"); 731 732 if (kGL_GrGLStandard == standard) { 733 shaderCaps->fFlatInterpolationSupport = ctxInfo.glslGeneration() >= k130_GrGLSLGeneration; 734 } else { 735 shaderCaps->fFlatInterpolationSupport = 736 ctxInfo.glslGeneration() >= k330_GrGLSLGeneration; // This is the value for GLSL ES 3.0. 737 } 738 739 if (kGL_GrGLStandard == standard) { 740 shaderCaps->fNoPerspectiveInterpolationSupport = 741 ctxInfo.glslGeneration() >= k130_GrGLSLGeneration; 742 } else { 743 if (ctxInfo.hasExtension("GL_NV_shader_noperspective_interpolation")) { 744 shaderCaps->fNoPerspectiveInterpolationSupport = true; 745 shaderCaps->fNoPerspectiveInterpolationExtensionString = 746 "GL_NV_shader_noperspective_interpolation"; 747 } 748 } 749 750 if (kGL_GrGLStandard == standard) { 751 shaderCaps->fMultisampleInterpolationSupport = 752 ctxInfo.glslGeneration() >= k400_GrGLSLGeneration; 753 } else { 754 if (ctxInfo.glslGeneration() >= k320es_GrGLSLGeneration) { 755 shaderCaps->fMultisampleInterpolationSupport = true; 756 } else if (ctxInfo.hasExtension("GL_OES_shader_multisample_interpolation")) { 757 shaderCaps->fMultisampleInterpolationSupport = true; 758 shaderCaps->fMultisampleInterpolationExtensionString = 759 "GL_OES_shader_multisample_interpolation"; 760 } 761 } 762 763 if (kGL_GrGLStandard == standard) { 764 shaderCaps->fSampleVariablesSupport = ctxInfo.glslGeneration() >= k400_GrGLSLGeneration; 765 } else { 766 if (ctxInfo.glslGeneration() >= k320es_GrGLSLGeneration) { 767 shaderCaps->fSampleVariablesSupport = true; 768 } else if (ctxInfo.hasExtension("GL_OES_sample_variables")) { 769 shaderCaps->fSampleVariablesSupport = true; 770 shaderCaps->fSampleVariablesExtensionString = "GL_OES_sample_variables"; 771 } 772 } 773 774 if (shaderCaps->fSampleVariablesSupport && 775 ctxInfo.hasExtension("GL_NV_sample_mask_override_coverage")) { 776 // Pre-361 NVIDIA has a bug with NV_sample_mask_override_coverage. 777 shaderCaps->fSampleMaskOverrideCoverageSupport = 778 kNVIDIA_GrGLDriver != ctxInfo.driver() || 779 ctxInfo.driverVersion() >= GR_GL_DRIVER_VER(361,00); 780 } 781 782 // Adreno GPUs have a tendency to drop tiles when there is a divide-by-zero in a shader 783 shaderCaps->fDropsTileOnZeroDivide = kQualcomm_GrGLVendor == ctxInfo.vendor(); 784 785 // On the NexusS and GalaxyNexus, the use of 'any' causes the compilation error "Calls to any 786 // function that may require a gradient calculation inside a conditional block may return 787 // undefined results". This appears to be an issue with the 'any' call since even the simple 788 // "result=black; if (any()) result=white;" code fails to compile. This issue comes into play 789 // from our GrTextureDomain processor. 790 shaderCaps->fCanUseAnyFunctionInShader = kImagination_GrGLVendor != ctxInfo.vendor(); 791 792 shaderCaps->fVersionDeclString = get_glsl_version_decl_string(standard, 793 shaderCaps->fGLSLGeneration, 794 fIsCoreProfile); 795 796 if (kGLES_GrGLStandard == standard && k110_GrGLSLGeneration == shaderCaps->fGLSLGeneration) { 797 shaderCaps->fShaderDerivativeExtensionString = "GL_OES_standard_derivatives"; 798 } 799 800 // Frag Coords Convention support is not part of ES 801 // Known issue on at least some Intel platforms: 802 // http://code.google.com/p/skia/issues/detail?id=946 803 if (kIntel_GrGLVendor != ctxInfo.vendor() && 804 kGLES_GrGLStandard != standard && 805 (ctxInfo.glslGeneration() >= k150_GrGLSLGeneration || 806 ctxInfo.hasExtension("GL_ARB_fragment_coord_conventions"))) { 807 shaderCaps->fFragCoordConventionsExtensionString = "GL_ARB_fragment_coord_conventions"; 808 } 809 810 if (kGLES_GrGLStandard == standard) { 811 shaderCaps->fSecondaryOutputExtensionString = "GL_EXT_blend_func_extended"; 812 } 813 814 if (ctxInfo.hasExtension("GL_OES_EGL_image_external")) { 815 if (ctxInfo.glslGeneration() == k110_GrGLSLGeneration) { 816 shaderCaps->fExternalTextureSupport = true; 817 } else if (ctxInfo.hasExtension("GL_OES_EGL_image_external_essl3") || 818 ctxInfo.hasExtension("OES_EGL_image_external_essl3")) { 819 // At least one driver has been found that has this extension without the "GL_" prefix. 820 shaderCaps->fExternalTextureSupport = true; 821 } 822 } 823 824 if (shaderCaps->fExternalTextureSupport) { 825 if (ctxInfo.glslGeneration() == k110_GrGLSLGeneration) { 826 shaderCaps->fExternalTextureExtensionString = "GL_OES_EGL_image_external"; 827 } else { 828 shaderCaps->fExternalTextureExtensionString = "GL_OES_EGL_image_external_essl3"; 829 } 830 } 831 832 if (kGL_GrGLStandard == standard) { 833 shaderCaps->fTexelFetchSupport = ctxInfo.glslGeneration() >= k130_GrGLSLGeneration; 834 } else { 835 shaderCaps->fTexelFetchSupport = 836 ctxInfo.glslGeneration() >= k330_GrGLSLGeneration; // We use this value for GLSL ES 3.0. 837 } 838 839 if (shaderCaps->fTexelFetchSupport) { 840 if (kGL_GrGLStandard == standard) { 841 shaderCaps->fTexelBufferSupport = ctxInfo.version() >= GR_GL_VER(3, 1) && 842 ctxInfo.glslGeneration() >= k330_GrGLSLGeneration; 843 } else { 844 if (ctxInfo.version() >= GR_GL_VER(3, 2) && 845 ctxInfo.glslGeneration() >= k320es_GrGLSLGeneration) { 846 shaderCaps->fTexelBufferSupport = true; 847 } else if (ctxInfo.hasExtension("GL_OES_texture_buffer")) { 848 shaderCaps->fTexelBufferSupport = true; 849 shaderCaps->fTexelBufferExtensionString = "GL_OES_texture_buffer"; 850 } else if (ctxInfo.hasExtension("GL_EXT_texture_buffer")) { 851 shaderCaps->fTexelBufferSupport = true; 852 shaderCaps->fTexelBufferExtensionString = "GL_EXT_texture_buffer"; 853 } 854 } 855 } 856 857 // The Tegra3 compiler will sometimes never return if we have min(abs(x), 1.0), so we must do 858 // the abs first in a separate expression. 859 if (kTegra3_GrGLRenderer == ctxInfo.renderer()) { 860 shaderCaps->fCanUseMinAndAbsTogether = false; 861 } 862 863 // On Intel GPU there is an issue where it reads the second argument to atan "- %s.x" as an int 864 // thus must us -1.0 * %s.x to work correctly 865 if (kIntel_GrGLVendor == ctxInfo.vendor()) { 866 shaderCaps->fMustForceNegatedAtanParamToFloat = true; 867 } 868 869 // On Adreno devices with framebuffer fetch support, there is a bug where they always return 870 // the original dst color when reading the outColor even after being written to. By using a 871 // local outColor we can work around this bug. 872 if (shaderCaps->fFBFetchSupport && kQualcomm_GrGLVendor == ctxInfo.vendor()) { 873 shaderCaps->fRequiresLocalOutputColorForFBFetch = true; 874 } 875 876 #ifdef SK_BUILD_FOR_MAC 877 // On at least some MacBooks, geometry shaders fall apart if we use more than one invocation. To 878 // work around this, we always use a single invocation and wrap the shader in a loop. The long- 879 // term plan for this WAR is for it to eventually be baked into SkSL. 880 shaderCaps->fMustImplementGSInvocationsWithLoop = true; 881 #endif 882 } 883 884 bool GrGLCaps::hasPathRenderingSupport(const GrGLContextInfo& ctxInfo, const GrGLInterface* gli) { 885 bool hasChromiumPathRendering = ctxInfo.hasExtension("GL_CHROMIUM_path_rendering"); 886 887 if (!(ctxInfo.hasExtension("GL_NV_path_rendering") || hasChromiumPathRendering)) { 888 return false; 889 } 890 891 if (kGL_GrGLStandard == ctxInfo.standard()) { 892 if (ctxInfo.version() < GR_GL_VER(4, 3) && 893 !ctxInfo.hasExtension("GL_ARB_program_interface_query")) { 894 return false; 895 } 896 } else { 897 if (!hasChromiumPathRendering && 898 ctxInfo.version() < GR_GL_VER(3, 1)) { 899 return false; 900 } 901 } 902 // We only support v1.3+ of GL_NV_path_rendering which allows us to 903 // set individual fragment inputs with ProgramPathFragmentInputGen. The API 904 // additions are detected by checking the existence of the function. 905 // We also use *Then* functions that not all drivers might have. Check 906 // them for consistency. 907 if (!gli->fFunctions.fStencilThenCoverFillPath || 908 !gli->fFunctions.fStencilThenCoverStrokePath || 909 !gli->fFunctions.fStencilThenCoverFillPathInstanced || 910 !gli->fFunctions.fStencilThenCoverStrokePathInstanced || 911 !gli->fFunctions.fProgramPathFragmentInputGen) { 912 return false; 913 } 914 return true; 915 } 916 917 bool GrGLCaps::readPixelsSupported(GrPixelConfig surfaceConfig, 918 GrPixelConfig readConfig, 919 std::function<void (GrGLenum, GrGLint*)> getIntegerv, 920 std::function<bool ()> bindRenderTarget, 921 std::function<void ()> unbindRenderTarget) const { 922 // If it's not possible to even have a color attachment of surfaceConfig then read pixels is 923 // not supported regardless of readConfig. 924 if (!this->canConfigBeFBOColorAttachment(surfaceConfig)) { 925 return false; 926 } 927 928 if (GrPixelConfigIsSint(surfaceConfig) != GrPixelConfigIsSint(readConfig)) { 929 return false; 930 } 931 932 GrGLenum readFormat; 933 GrGLenum readType; 934 if (!this->getReadPixelsFormat(surfaceConfig, readConfig, &readFormat, &readType)) { 935 return false; 936 } 937 938 if (kGL_GrGLStandard == fStandard) { 939 // Some OpenGL implementations allow GL_ALPHA as a format to glReadPixels. However, 940 // the manual (https://www.opengl.org/sdk/docs/man/) says only these formats are allowed: 941 // GL_STENCIL_INDEX, GL_DEPTH_COMPONENT, GL_DEPTH_STENCIL, GL_RED, GL_GREEN, GL_BLUE, 942 // GL_RGB, GL_BGR, GL_RGBA, and GL_BGRA. We check for the subset that we would use. 943 // The manual does not seem to fully match the spec as the spec allows integer formats 944 // when the bound color buffer is an integer buffer. It doesn't specify which integer 945 // formats are allowed, so perhaps all of them are. We only use GL_RGBA_INTEGER currently. 946 if (readFormat != GR_GL_RED && readFormat != GR_GL_RG && readFormat != GR_GL_RGB && 947 readFormat != GR_GL_RGBA && readFormat != GR_GL_BGRA && 948 readFormat != GR_GL_RGBA_INTEGER) { 949 return false; 950 } 951 // There is also a set of allowed types, but all the types we use are in the set: 952 // GL_UNSIGNED_BYTE, GL_BYTE, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, 953 // GL_HALF_FLOAT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, 954 // GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, 955 // GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, 956 // GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV,GL_UNSIGNED_INT_10_10_10_2, 957 // GL_UNSIGNED_INT_2_10_10_10_REV, GL_UNSIGNED_INT_24_8, GL_UNSIGNED_INT_10F_11F_11F_REV, 958 // GL_UNSIGNED_INT_5_9_9_9_REV, or GL_FLOAT_32_UNSIGNED_INT_24_8_REV. 959 return true; 960 } 961 962 // See Section 16.1.2 in the ES 3.2 specification. 963 switch (fConfigTable[surfaceConfig].fFormatType) { 964 case kNormalizedFixedPoint_FormatType: 965 if (GR_GL_RGBA == readFormat && GR_GL_UNSIGNED_BYTE == readType) { 966 return true; 967 } 968 break; 969 case kInteger_FormatType: 970 if (GR_GL_RGBA_INTEGER == readFormat && GR_GL_INT == readType) { 971 return true; 972 } 973 break; 974 case kFloat_FormatType: 975 if (GR_GL_RGBA == readFormat && GR_GL_FLOAT == readType) { 976 return true; 977 } 978 break; 979 } 980 981 if (0 == fConfigTable[surfaceConfig].fSecondReadPixelsFormat.fFormat) { 982 ReadPixelsFormat* rpFormat = 983 const_cast<ReadPixelsFormat*>(&fConfigTable[surfaceConfig].fSecondReadPixelsFormat); 984 GrGLint format = 0, type = 0; 985 if (!bindRenderTarget()) { 986 return false; 987 } 988 getIntegerv(GR_GL_IMPLEMENTATION_COLOR_READ_FORMAT, &format); 989 getIntegerv(GR_GL_IMPLEMENTATION_COLOR_READ_TYPE, &type); 990 rpFormat->fFormat = format; 991 rpFormat->fType = type; 992 unbindRenderTarget(); 993 } 994 995 return fConfigTable[surfaceConfig].fSecondReadPixelsFormat.fFormat == readFormat && 996 fConfigTable[surfaceConfig].fSecondReadPixelsFormat.fType == readType; 997 } 998 999 void GrGLCaps::initFSAASupport(const GrGLContextInfo& ctxInfo, const GrGLInterface* gli) { 1000 if (kGL_GrGLStandard != ctxInfo.standard()) { 1001 // We prefer the EXT/IMG extension over ES3 MSAA because we've observed 1002 // ES3 driver bugs on at least one device with a tiled GPU (N10). 1003 if (ctxInfo.hasExtension("GL_EXT_multisampled_render_to_texture")) { 1004 fMSFBOType = kES_EXT_MsToTexture_MSFBOType; 1005 } else if (ctxInfo.hasExtension("GL_IMG_multisampled_render_to_texture")) { 1006 fMSFBOType = kES_IMG_MsToTexture_MSFBOType; 1007 } else if (fUsesMixedSamples) { 1008 fMSFBOType = kMixedSamples_MSFBOType; 1009 } else if (ctxInfo.version() >= GR_GL_VER(3,0) || 1010 ctxInfo.hasExtension("GL_CHROMIUM_framebuffer_multisample") || 1011 ctxInfo.hasExtension("GL_ANGLE_framebuffer_multisample")) { 1012 fMSFBOType = kStandard_MSFBOType; 1013 } else if (ctxInfo.hasExtension("GL_APPLE_framebuffer_multisample")) { 1014 fMSFBOType = kES_Apple_MSFBOType; 1015 } 1016 1017 // Above determined the preferred MSAA approach, now decide whether glBlitFramebuffer 1018 // is available. 1019 if (ctxInfo.version() >= GR_GL_VER(3, 0)) { 1020 fBlitFramebufferFlags = kNoFormatConversionForMSAASrc_BlitFramebufferFlag | 1021 kRectsMustMatchForMSAASrc_BlitFramebufferFlag; 1022 } else if (ctxInfo.hasExtension("GL_CHROMIUM_framebuffer_multisample") || 1023 ctxInfo.hasExtension("GL_ANGLE_framebuffer_blit")) { 1024 // The CHROMIUM extension uses the ANGLE version of glBlitFramebuffer and includes its 1025 // limitations. 1026 fBlitFramebufferFlags = kNoScalingOrMirroring_BlitFramebufferFlag | 1027 kResolveMustBeFull_BlitFrambufferFlag | 1028 kNoMSAADst_BlitFramebufferFlag | 1029 kNoFormatConversion_BlitFramebufferFlag; 1030 } 1031 } else { 1032 if (fUsesMixedSamples) { 1033 fMSFBOType = kMixedSamples_MSFBOType; 1034 fBlitFramebufferFlags = 0; 1035 } else if (ctxInfo.version() >= GR_GL_VER(3,0) || 1036 ctxInfo.hasExtension("GL_ARB_framebuffer_object")) { 1037 fMSFBOType = kStandard_MSFBOType; 1038 fBlitFramebufferFlags = 0; 1039 } else if (ctxInfo.hasExtension("GL_EXT_framebuffer_multisample") && 1040 ctxInfo.hasExtension("GL_EXT_framebuffer_blit")) { 1041 fMSFBOType = kEXT_MSFBOType; 1042 fBlitFramebufferFlags = 0; 1043 } 1044 } 1045 } 1046 1047 void GrGLCaps::initBlendEqationSupport(const GrGLContextInfo& ctxInfo) { 1048 GrShaderCaps* shaderCaps = static_cast<GrShaderCaps*>(fShaderCaps.get()); 1049 1050 // Disabling advanced blend on various platforms with major known issues. We also block Chrome 1051 // for now until its own blacklists can be updated. 1052 if (kAdreno4xx_GrGLRenderer == ctxInfo.renderer() || 1053 kAdreno5xx_GrGLRenderer == ctxInfo.renderer() || 1054 kIntel_GrGLDriver == ctxInfo.driver() || 1055 kChromium_GrGLDriver == ctxInfo.driver()) { 1056 return; 1057 } 1058 1059 if (ctxInfo.hasExtension("GL_NV_blend_equation_advanced_coherent")) { 1060 fBlendEquationSupport = kAdvancedCoherent_BlendEquationSupport; 1061 shaderCaps->fAdvBlendEqInteraction = GrShaderCaps::kAutomatic_AdvBlendEqInteraction; 1062 } else if (ctxInfo.hasExtension("GL_KHR_blend_equation_advanced_coherent")) { 1063 fBlendEquationSupport = kAdvancedCoherent_BlendEquationSupport; 1064 shaderCaps->fAdvBlendEqInteraction = GrShaderCaps::kGeneralEnable_AdvBlendEqInteraction; 1065 } else if (kNVIDIA_GrGLDriver == ctxInfo.driver() && 1066 ctxInfo.driverVersion() < GR_GL_DRIVER_VER(337,00)) { 1067 // Non-coherent advanced blend has an issue on NVIDIA pre 337.00. 1068 return; 1069 } else if (ctxInfo.hasExtension("GL_NV_blend_equation_advanced")) { 1070 fBlendEquationSupport = kAdvanced_BlendEquationSupport; 1071 shaderCaps->fAdvBlendEqInteraction = GrShaderCaps::kAutomatic_AdvBlendEqInteraction; 1072 } else if (ctxInfo.hasExtension("GL_KHR_blend_equation_advanced")) { 1073 fBlendEquationSupport = kAdvanced_BlendEquationSupport; 1074 shaderCaps->fAdvBlendEqInteraction = GrShaderCaps::kGeneralEnable_AdvBlendEqInteraction; 1075 // TODO: Use kSpecificEnables_AdvBlendEqInteraction if "blend_support_all_equations" is 1076 // slow on a particular platform. 1077 } else { 1078 return; // No advanced blend support. 1079 } 1080 1081 SkASSERT(this->advancedBlendEquationSupport()); 1082 1083 if (kNVIDIA_GrGLDriver == ctxInfo.driver() && 1084 ctxInfo.driverVersion() < GR_GL_DRIVER_VER(355,00)) { 1085 // Blacklist color-dodge and color-burn on pre-355.00 NVIDIA. 1086 fAdvBlendEqBlacklist |= (1 << kColorDodge_GrBlendEquation) | 1087 (1 << kColorBurn_GrBlendEquation); 1088 } 1089 if (kARM_GrGLVendor == ctxInfo.vendor()) { 1090 // Blacklist color-burn on ARM until the fix is released. 1091 fAdvBlendEqBlacklist |= (1 << kColorBurn_GrBlendEquation); 1092 } 1093 } 1094 1095 namespace { 1096 const GrGLuint kUnknownBitCount = GrGLStencilAttachment::kUnknownBitCount; 1097 } 1098 1099 void GrGLCaps::initStencilFormats(const GrGLContextInfo& ctxInfo) { 1100 1101 // Build up list of legal stencil formats (though perhaps not supported on 1102 // the particular gpu/driver) from most preferred to least. 1103 1104 // these consts are in order of most preferred to least preferred 1105 // we don't bother with GL_STENCIL_INDEX1 or GL_DEPTH32F_STENCIL8 1106 1107 static const StencilFormat 1108 // internal Format stencil bits total bits packed? 1109 gS8 = {GR_GL_STENCIL_INDEX8, 8, 8, false}, 1110 gS16 = {GR_GL_STENCIL_INDEX16, 16, 16, false}, 1111 gD24S8 = {GR_GL_DEPTH24_STENCIL8, 8, 32, true }, 1112 gS4 = {GR_GL_STENCIL_INDEX4, 4, 4, false}, 1113 // gS = {GR_GL_STENCIL_INDEX, kUnknownBitCount, kUnknownBitCount, false}, 1114 gDS = {GR_GL_DEPTH_STENCIL, kUnknownBitCount, kUnknownBitCount, true }; 1115 1116 if (kGL_GrGLStandard == ctxInfo.standard()) { 1117 bool supportsPackedDS = 1118 ctxInfo.version() >= GR_GL_VER(3,0) || 1119 ctxInfo.hasExtension("GL_EXT_packed_depth_stencil") || 1120 ctxInfo.hasExtension("GL_ARB_framebuffer_object"); 1121 1122 // S1 thru S16 formats are in GL 3.0+, EXT_FBO, and ARB_FBO since we 1123 // require FBO support we can expect these are legal formats and don't 1124 // check. These also all support the unsized GL_STENCIL_INDEX. 1125 fStencilFormats.push_back() = gS8; 1126 fStencilFormats.push_back() = gS16; 1127 if (supportsPackedDS) { 1128 fStencilFormats.push_back() = gD24S8; 1129 } 1130 fStencilFormats.push_back() = gS4; 1131 if (supportsPackedDS) { 1132 fStencilFormats.push_back() = gDS; 1133 } 1134 } else { 1135 // ES2 has STENCIL_INDEX8 without extensions but requires extensions 1136 // for other formats. 1137 // ES doesn't support using the unsized format. 1138 1139 fStencilFormats.push_back() = gS8; 1140 //fStencilFormats.push_back() = gS16; 1141 if (ctxInfo.version() >= GR_GL_VER(3,0) || 1142 ctxInfo.hasExtension("GL_OES_packed_depth_stencil")) { 1143 fStencilFormats.push_back() = gD24S8; 1144 } 1145 if (ctxInfo.hasExtension("GL_OES_stencil4")) { 1146 fStencilFormats.push_back() = gS4; 1147 } 1148 } 1149 } 1150 1151 SkString GrGLCaps::dump() const { 1152 1153 SkString r = INHERITED::dump(); 1154 1155 r.appendf("--- GL-Specific ---\n"); 1156 for (int i = 0; i < fStencilFormats.count(); ++i) { 1157 r.appendf("Stencil Format %d, stencil bits: %02d, total bits: %02d\n", 1158 i, 1159 fStencilFormats[i].fStencilBits, 1160 fStencilFormats[i].fTotalBits); 1161 } 1162 1163 static const char* kMSFBOExtStr[] = { 1164 "None", 1165 "EXT", 1166 "Standard", 1167 "Apple", 1168 "IMG MS To Texture", 1169 "EXT MS To Texture", 1170 "MixedSamples", 1171 }; 1172 GR_STATIC_ASSERT(0 == kNone_MSFBOType); 1173 GR_STATIC_ASSERT(1 == kEXT_MSFBOType); 1174 GR_STATIC_ASSERT(2 == kStandard_MSFBOType); 1175 GR_STATIC_ASSERT(3 == kES_Apple_MSFBOType); 1176 GR_STATIC_ASSERT(4 == kES_IMG_MsToTexture_MSFBOType); 1177 GR_STATIC_ASSERT(5 == kES_EXT_MsToTexture_MSFBOType); 1178 GR_STATIC_ASSERT(6 == kMixedSamples_MSFBOType); 1179 GR_STATIC_ASSERT(SK_ARRAY_COUNT(kMSFBOExtStr) == kLast_MSFBOType + 1); 1180 1181 static const char* kInvalidateFBTypeStr[] = { 1182 "None", 1183 "Discard", 1184 "Invalidate", 1185 }; 1186 GR_STATIC_ASSERT(0 == kNone_InvalidateFBType); 1187 GR_STATIC_ASSERT(1 == kDiscard_InvalidateFBType); 1188 GR_STATIC_ASSERT(2 == kInvalidate_InvalidateFBType); 1189 GR_STATIC_ASSERT(SK_ARRAY_COUNT(kInvalidateFBTypeStr) == kLast_InvalidateFBType + 1); 1190 1191 static const char* kMapBufferTypeStr[] = { 1192 "None", 1193 "MapBuffer", 1194 "MapBufferRange", 1195 "Chromium", 1196 }; 1197 GR_STATIC_ASSERT(0 == kNone_MapBufferType); 1198 GR_STATIC_ASSERT(1 == kMapBuffer_MapBufferType); 1199 GR_STATIC_ASSERT(2 == kMapBufferRange_MapBufferType); 1200 GR_STATIC_ASSERT(3 == kChromium_MapBufferType); 1201 GR_STATIC_ASSERT(SK_ARRAY_COUNT(kMapBufferTypeStr) == kLast_MapBufferType + 1); 1202 1203 r.appendf("Core Profile: %s\n", (fIsCoreProfile ? "YES" : "NO")); 1204 r.appendf("MSAA Type: %s\n", kMSFBOExtStr[fMSFBOType]); 1205 r.appendf("Invalidate FB Type: %s\n", kInvalidateFBTypeStr[fInvalidateFBType]); 1206 r.appendf("Map Buffer Type: %s\n", kMapBufferTypeStr[fMapBufferType]); 1207 r.appendf("Max FS Uniform Vectors: %d\n", fMaxFragmentUniformVectors); 1208 r.appendf("Unpack Row length support: %s\n", (fUnpackRowLengthSupport ? "YES": "NO")); 1209 r.appendf("Unpack Flip Y support: %s\n", (fUnpackFlipYSupport ? "YES": "NO")); 1210 r.appendf("Pack Row length support: %s\n", (fPackRowLengthSupport ? "YES": "NO")); 1211 r.appendf("Pack Flip Y support: %s\n", (fPackFlipYSupport ? "YES": "NO")); 1212 1213 r.appendf("Texture Usage support: %s\n", (fTextureUsageSupport ? "YES": "NO")); 1214 r.appendf("GL_R support: %s\n", (fTextureRedSupport ? "YES": "NO")); 1215 r.appendf("GL_ARB_imaging support: %s\n", (fImagingSupport ? "YES": "NO")); 1216 r.appendf("Vertex array object support: %s\n", (fVertexArrayObjectSupport ? "YES": "NO")); 1217 r.appendf("Direct state access support: %s\n", (fDirectStateAccessSupport ? "YES": "NO")); 1218 r.appendf("Debug support: %s\n", (fDebugSupport ? "YES": "NO")); 1219 r.appendf("Draw instanced support: %s\n", (fDrawInstancedSupport ? "YES" : "NO")); 1220 r.appendf("Draw indirect support: %s\n", (fDrawIndirectSupport ? "YES" : "NO")); 1221 r.appendf("Multi draw indirect support: %s\n", (fMultiDrawIndirectSupport ? "YES" : "NO")); 1222 r.appendf("Base instance support: %s\n", (fBaseInstanceSupport ? "YES" : "NO")); 1223 r.appendf("RGBA 8888 pixel ops are slow: %s\n", (fRGBA8888PixelsOpsAreSlow ? "YES" : "NO")); 1224 r.appendf("Partial FBO read is slow: %s\n", (fPartialFBOReadIsSlow ? "YES" : "NO")); 1225 r.appendf("Bind uniform location support: %s\n", (fBindUniformLocationSupport ? "YES" : "NO")); 1226 r.appendf("Rectangle texture support: %s\n", (fRectangleTextureSupport? "YES" : "NO")); 1227 r.appendf("Texture swizzle support: %s\n", (fTextureSwizzleSupport ? "YES" : "NO")); 1228 r.appendf("BGRA to RGBA readback conversions are slow: %s\n", 1229 (fRGBAToBGRAReadbackConversionsAreSlow ? "YES" : "NO")); 1230 1231 r.append("Configs\n-------\n"); 1232 for (int i = 0; i < kGrPixelConfigCnt; ++i) { 1233 r.appendf(" cfg: %d flags: 0x%04x, b_internal: 0x%08x s_internal: 0x%08x, e_format: " 1234 "0x%08x, e_format_teximage: 0x%08x, e_type: 0x%08x, i_for_teximage: 0x%08x, " 1235 "i_for_renderbuffer: 0x%08x\n", 1236 i, 1237 fConfigTable[i].fFlags, 1238 fConfigTable[i].fFormats.fBaseInternalFormat, 1239 fConfigTable[i].fFormats.fSizedInternalFormat, 1240 fConfigTable[i].fFormats.fExternalFormat[kOther_ExternalFormatUsage], 1241 fConfigTable[i].fFormats.fExternalFormat[kTexImage_ExternalFormatUsage], 1242 fConfigTable[i].fFormats.fExternalType, 1243 fConfigTable[i].fFormats.fInternalFormatTexImage, 1244 fConfigTable[i].fFormats.fInternalFormatRenderbuffer); 1245 } 1246 1247 return r; 1248 } 1249 1250 static GrGLenum precision_to_gl_float_type(GrSLPrecision p) { 1251 switch (p) { 1252 case kLow_GrSLPrecision: 1253 return GR_GL_LOW_FLOAT; 1254 case kMedium_GrSLPrecision: 1255 return GR_GL_MEDIUM_FLOAT; 1256 case kHigh_GrSLPrecision: 1257 return GR_GL_HIGH_FLOAT; 1258 } 1259 SkFAIL("Unknown precision."); 1260 return -1; 1261 } 1262 1263 static GrGLenum shader_type_to_gl_shader(GrShaderType type) { 1264 switch (type) { 1265 case kVertex_GrShaderType: 1266 return GR_GL_VERTEX_SHADER; 1267 case kGeometry_GrShaderType: 1268 return GR_GL_GEOMETRY_SHADER; 1269 case kFragment_GrShaderType: 1270 return GR_GL_FRAGMENT_SHADER; 1271 } 1272 SkFAIL("Unknown shader type."); 1273 return -1; 1274 } 1275 1276 void GrGLCaps::initShaderPrecisionTable(const GrGLContextInfo& ctxInfo, 1277 const GrGLInterface* intf, 1278 GrShaderCaps* shaderCaps) { 1279 if (kGLES_GrGLStandard == ctxInfo.standard() || ctxInfo.version() >= GR_GL_VER(4, 1) || 1280 ctxInfo.hasExtension("GL_ARB_ES2_compatibility")) { 1281 for (int s = 0; s < kGrShaderTypeCount; ++s) { 1282 if (kGeometry_GrShaderType != s) { 1283 GrShaderType shaderType = static_cast<GrShaderType>(s); 1284 GrGLenum glShader = shader_type_to_gl_shader(shaderType); 1285 GrShaderCaps::PrecisionInfo* first = nullptr; 1286 shaderCaps->fShaderPrecisionVaries = false; 1287 for (int p = 0; p < kGrSLPrecisionCount; ++p) { 1288 GrSLPrecision precision = static_cast<GrSLPrecision>(p); 1289 GrGLenum glPrecision = precision_to_gl_float_type(precision); 1290 GrGLint range[2]; 1291 GrGLint bits; 1292 GR_GL_GetShaderPrecisionFormat(intf, glShader, glPrecision, range, &bits); 1293 if (bits) { 1294 shaderCaps->fFloatPrecisions[s][p].fLogRangeLow = range[0]; 1295 shaderCaps->fFloatPrecisions[s][p].fLogRangeHigh = range[1]; 1296 shaderCaps->fFloatPrecisions[s][p].fBits = bits; 1297 if (!first) { 1298 first = &shaderCaps->fFloatPrecisions[s][p]; 1299 } 1300 else if (!shaderCaps->fShaderPrecisionVaries) { 1301 shaderCaps->fShaderPrecisionVaries = 1302 (*first != shaderCaps->fFloatPrecisions[s][p]); 1303 } 1304 } 1305 } 1306 } 1307 } 1308 } 1309 else { 1310 // We're on a desktop GL that doesn't have precision info. Assume they're all 32bit float. 1311 shaderCaps->fShaderPrecisionVaries = false; 1312 for (int s = 0; s < kGrShaderTypeCount; ++s) { 1313 if (kGeometry_GrShaderType != s) { 1314 for (int p = 0; p < kGrSLPrecisionCount; ++p) { 1315 shaderCaps->fFloatPrecisions[s][p].fLogRangeLow = 127; 1316 shaderCaps->fFloatPrecisions[s][p].fLogRangeHigh = 127; 1317 shaderCaps->fFloatPrecisions[s][p].fBits = 23; 1318 } 1319 } 1320 } 1321 } 1322 // GetShaderPrecisionFormat doesn't accept GL_GEOMETRY_SHADER as a shader type. Assume they're 1323 // the same as the vertex shader. Only fragment shaders were ever allowed to omit support for 1324 // highp. GS was added after GetShaderPrecisionFormat was added to the list of features that 1325 // are recommended against. 1326 if (shaderCaps->fGeometryShaderSupport) { 1327 for (int p = 0; p < kGrSLPrecisionCount; ++p) { 1328 shaderCaps->fFloatPrecisions[kGeometry_GrShaderType][p] = 1329 shaderCaps->fFloatPrecisions[kVertex_GrShaderType][p]; 1330 } 1331 } 1332 shaderCaps->initSamplerPrecisionTable(); 1333 } 1334 1335 bool GrGLCaps::bgraIsInternalFormat() const { 1336 return fConfigTable[kBGRA_8888_GrPixelConfig].fFormats.fBaseInternalFormat == GR_GL_BGRA; 1337 } 1338 1339 bool GrGLCaps::getTexImageFormats(GrPixelConfig surfaceConfig, GrPixelConfig externalConfig, 1340 GrGLenum* internalFormat, GrGLenum* externalFormat, 1341 GrGLenum* externalType) const { 1342 if (!this->getExternalFormat(surfaceConfig, externalConfig, kTexImage_ExternalFormatUsage, 1343 externalFormat, externalType)) { 1344 return false; 1345 } 1346 *internalFormat = fConfigTable[surfaceConfig].fFormats.fInternalFormatTexImage; 1347 return true; 1348 } 1349 1350 bool GrGLCaps::getCompressedTexImageFormats(GrPixelConfig surfaceConfig, 1351 GrGLenum* internalFormat) const { 1352 if (!GrPixelConfigIsCompressed(surfaceConfig)) { 1353 return false; 1354 } 1355 *internalFormat = fConfigTable[surfaceConfig].fFormats.fInternalFormatTexImage; 1356 return true; 1357 } 1358 1359 bool GrGLCaps::getReadPixelsFormat(GrPixelConfig surfaceConfig, GrPixelConfig externalConfig, 1360 GrGLenum* externalFormat, GrGLenum* externalType) const { 1361 if (!this->getExternalFormat(surfaceConfig, externalConfig, kOther_ExternalFormatUsage, 1362 externalFormat, externalType)) { 1363 return false; 1364 } 1365 return true; 1366 } 1367 1368 bool GrGLCaps::getRenderbufferFormat(GrPixelConfig config, GrGLenum* internalFormat) const { 1369 if (GrPixelConfigIsCompressed(config)) { 1370 return false; 1371 } 1372 *internalFormat = fConfigTable[config].fFormats.fInternalFormatRenderbuffer; 1373 return true; 1374 } 1375 1376 bool GrGLCaps::getExternalFormat(GrPixelConfig surfaceConfig, GrPixelConfig memoryConfig, 1377 ExternalFormatUsage usage, GrGLenum* externalFormat, 1378 GrGLenum* externalType) const { 1379 SkASSERT(externalFormat && externalType); 1380 if (GrPixelConfigIsCompressed(memoryConfig)) { 1381 return false; 1382 } 1383 1384 bool surfaceIsAlphaOnly = GrPixelConfigIsAlphaOnly(surfaceConfig); 1385 bool memoryIsAlphaOnly = GrPixelConfigIsAlphaOnly(memoryConfig); 1386 1387 // We don't currently support moving RGBA data into and out of ALPHA surfaces. It could be 1388 // made to work in many cases using glPixelStore and what not but is not needed currently. 1389 if (surfaceIsAlphaOnly && !memoryIsAlphaOnly) { 1390 return false; 1391 } 1392 1393 *externalFormat = fConfigTable[memoryConfig].fFormats.fExternalFormat[usage]; 1394 *externalType = fConfigTable[memoryConfig].fFormats.fExternalType; 1395 1396 // When GL_RED is supported as a texture format, our alpha-only textures are stored using 1397 // GL_RED and we swizzle in order to map all components to 'r'. However, in this case the 1398 // surface is not alpha-only and we want alpha to really mean the alpha component of the 1399 // texture, not the red component. 1400 if (memoryIsAlphaOnly && !surfaceIsAlphaOnly) { 1401 if (this->textureRedSupport()) { 1402 SkASSERT(GR_GL_RED == *externalFormat); 1403 *externalFormat = GR_GL_ALPHA; 1404 } 1405 } 1406 1407 return true; 1408 } 1409 1410 void GrGLCaps::initConfigTable(const GrContextOptions& contextOptions, 1411 const GrGLContextInfo& ctxInfo, const GrGLInterface* gli, 1412 GrShaderCaps* shaderCaps) { 1413 /* 1414 Comments on renderability of configs on various GL versions. 1415 OpenGL < 3.0: 1416 no built in support for render targets. 1417 GL_EXT_framebuffer_object adds possible support for any sized format with base internal 1418 format RGB, RGBA and NV float formats we don't use. 1419 This is the following: 1420 R3_G3_B2, RGB4, RGB5, RGB8, RGB10, RGB12, RGB16, RGBA2, RGBA4, RGB5_A1, RGBA8 1421 RGB10_A2, RGBA12,RGBA16 1422 Though, it is hard to believe the more obscure formats such as RGBA12 would work 1423 since they aren't required by later standards and the driver can simply return 1424 FRAMEBUFFER_UNSUPPORTED for anything it doesn't allow. 1425 GL_ARB_framebuffer_object adds everything added by the EXT extension and additionally 1426 any sized internal format with a base internal format of ALPHA, LUMINANCE, 1427 LUMINANCE_ALPHA, INTENSITY, RED, and RG. 1428 This adds a lot of additional renderable sized formats, including ALPHA8. 1429 The GL_ARB_texture_rg brings in the RED and RG formats (8, 8I, 8UI, 16, 16I, 16UI, 1430 16F, 32I, 32UI, and 32F variants). 1431 Again, the driver has an escape hatch via FRAMEBUFFER_UNSUPPORTED. 1432 1433 For both the above extensions we limit ourselves to those that are also required by 1434 OpenGL 3.0. 1435 1436 OpenGL 3.0: 1437 Any format with base internal format ALPHA, RED, RG, RGB or RGBA is "color-renderable" 1438 but are not required to be supported as renderable textures/renderbuffer. 1439 Required renderable color formats: 1440 - RGBA32F, RGBA32I, RGBA32UI, RGBA16, RGBA16F, RGBA16I, 1441 RGBA16UI, RGBA8, RGBA8I, RGBA8UI, SRGB8_ALPHA8, and 1442 RGB10_A2. 1443 - R11F_G11F_B10F. 1444 - RG32F, RG32I, RG32UI, RG16, RG16F, RG16I, RG16UI, RG8, RG8I, 1445 and RG8UI. 1446 - R32F, R32I, R32UI, R16F, R16I, R16UI, R16, R8, R8I, and R8UI. 1447 - ALPHA8 1448 1449 OpenGL 3.1, 3.2, 3.3 1450 Same as 3.0 except ALPHA8 requires GL_ARB_compatibility/compatibility profile. 1451 OpengGL 3.3, 4.0, 4.1 1452 Adds RGB10_A2UI. 1453 OpengGL 4.2 1454 Adds 1455 - RGB5_A1, RGBA4 1456 - RGB565 1457 OpenGL 4.4 1458 Does away with the separate list and adds a column to the sized internal color format 1459 table. However, no new formats become required color renderable. 1460 1461 ES 2.0 1462 color renderable: RGBA4, RGB5_A1, RGB565 1463 GL_EXT_texture_rg adds support for R8, RG5 as a color render target 1464 GL_OES_rgb8_rgba8 adds support for RGB8 and RGBA8 1465 GL_ARM_rgba8 adds support for RGBA8 (but not RGB8) 1466 GL_EXT_texture_format_BGRA8888 does not add renderbuffer support 1467 GL_CHROMIUM_renderbuffer_format_BGRA8888 adds BGRA8 as color-renderable 1468 GL_APPLE_texture_format_BGRA8888 does not add renderbuffer support 1469 1470 ES 3.0 1471 - RGBA32I, RGBA32UI, RGBA16I, RGBA16UI, RGBA8, RGBA8I, 1472 RGBA8UI, SRGB8_ALPHA8, RGB10_A2, RGB10_A2UI, RGBA4, and 1473 RGB5_A1. 1474 - RGB8 and RGB565. 1475 - RG32I, RG32UI, RG16I, RG16UI, RG8, RG8I, and RG8UI. 1476 - R32I, R32UI, R16I, R16UI, R8, R8I, and R8UI 1477 ES 3.1 1478 Adds RGB10_A2, RGB10_A2UI, 1479 ES 3.2 1480 Adds R16F, RG16F, RGBA16F, R32F, RG32F, RGBA32F, R11F_G11F_B10F. 1481 */ 1482 uint32_t nonMSAARenderFlags = ConfigInfo::kRenderable_Flag | 1483 ConfigInfo::kFBOColorAttachment_Flag; 1484 uint32_t allRenderFlags = nonMSAARenderFlags; 1485 if (kNone_MSFBOType != fMSFBOType) { 1486 allRenderFlags |= ConfigInfo::kRenderableWithMSAA_Flag; 1487 } 1488 GrGLStandard standard = ctxInfo.standard(); 1489 GrGLVersion version = ctxInfo.version(); 1490 1491 bool texStorageSupported = false; 1492 if (kGL_GrGLStandard == standard) { 1493 // The EXT version can apply to either GL or GLES. 1494 texStorageSupported = version >= GR_GL_VER(4,2) || 1495 ctxInfo.hasExtension("GL_ARB_texture_storage") || 1496 ctxInfo.hasExtension("GL_EXT_texture_storage"); 1497 } else { 1498 texStorageSupported = version >= GR_GL_VER(3,0) || 1499 ctxInfo.hasExtension("GL_EXT_texture_storage"); 1500 } 1501 1502 // TODO: remove after command buffer supports full ES 3.0 1503 if (kGLES_GrGLStandard == standard && version >= GR_GL_VER(3,0) && 1504 kChromium_GrGLDriver == ctxInfo.driver()) { 1505 texStorageSupported = false; 1506 } 1507 1508 bool texelBufferSupport = this->shaderCaps()->texelBufferSupport(); 1509 1510 fConfigTable[kUnknown_GrPixelConfig].fFormats.fBaseInternalFormat = 0; 1511 fConfigTable[kUnknown_GrPixelConfig].fFormats.fSizedInternalFormat = 0; 1512 fConfigTable[kUnknown_GrPixelConfig].fFormats.fExternalFormat[kOther_ExternalFormatUsage] = 0; 1513 fConfigTable[kUnknown_GrPixelConfig].fFormats.fExternalType = 0; 1514 fConfigTable[kUnknown_GrPixelConfig].fFormatType = kNormalizedFixedPoint_FormatType; 1515 fConfigTable[kUnknown_GrPixelConfig].fSwizzle = GrSwizzle::RGBA(); 1516 1517 fConfigTable[kRGBA_8888_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_RGBA; 1518 fConfigTable[kRGBA_8888_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_RGBA8; 1519 fConfigTable[kRGBA_8888_GrPixelConfig].fFormats.fExternalFormat[kOther_ExternalFormatUsage] = 1520 GR_GL_RGBA; 1521 fConfigTable[kRGBA_8888_GrPixelConfig].fFormats.fExternalType = GR_GL_UNSIGNED_BYTE; 1522 fConfigTable[kRGBA_8888_GrPixelConfig].fFormatType = kNormalizedFixedPoint_FormatType; 1523 fConfigTable[kRGBA_8888_GrPixelConfig].fFlags = ConfigInfo::kTextureable_Flag; 1524 if (kGL_GrGLStandard == standard) { 1525 // We require some form of FBO support and all GLs with FBO support can render to RGBA8 1526 fConfigTable[kRGBA_8888_GrPixelConfig].fFlags |= allRenderFlags; 1527 } else { 1528 if (version >= GR_GL_VER(3,0) || ctxInfo.hasExtension("GL_OES_rgb8_rgba8") || 1529 ctxInfo.hasExtension("GL_ARM_rgba8")) { 1530 fConfigTable[kRGBA_8888_GrPixelConfig].fFlags |= allRenderFlags; 1531 } 1532 } 1533 if (texStorageSupported) { 1534 fConfigTable[kRGBA_8888_GrPixelConfig].fFlags |= ConfigInfo::kCanUseTexStorage_Flag; 1535 } 1536 if (texelBufferSupport) { 1537 fConfigTable[kRGBA_8888_GrPixelConfig].fFlags |= ConfigInfo::kCanUseWithTexelBuffer_Flag; 1538 } 1539 fConfigTable[kRGBA_8888_GrPixelConfig].fSwizzle = GrSwizzle::RGBA(); 1540 1541 fConfigTable[kBGRA_8888_GrPixelConfig].fFormats.fExternalFormat[kOther_ExternalFormatUsage] = 1542 GR_GL_BGRA; 1543 fConfigTable[kBGRA_8888_GrPixelConfig].fFormats.fExternalType = GR_GL_UNSIGNED_BYTE; 1544 fConfigTable[kBGRA_8888_GrPixelConfig].fFormatType = kNormalizedFixedPoint_FormatType; 1545 if (kGL_GrGLStandard == standard) { 1546 fConfigTable[kBGRA_8888_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_RGBA; 1547 fConfigTable[kBGRA_8888_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_RGBA8; 1548 if (version >= GR_GL_VER(1, 2) || ctxInfo.hasExtension("GL_EXT_bgra")) { 1549 // Since the internal format is RGBA8, it is also renderable. 1550 fConfigTable[kBGRA_8888_GrPixelConfig].fFlags = ConfigInfo::kTextureable_Flag | 1551 allRenderFlags; 1552 } 1553 } else { 1554 fConfigTable[kBGRA_8888_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_BGRA; 1555 fConfigTable[kBGRA_8888_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_BGRA8; 1556 if (ctxInfo.hasExtension("GL_APPLE_texture_format_BGRA8888")) { 1557 // The APPLE extension doesn't make this renderable. 1558 fConfigTable[kBGRA_8888_GrPixelConfig].fFlags = ConfigInfo::kTextureable_Flag; 1559 if (version < GR_GL_VER(3,0) && !ctxInfo.hasExtension("GL_EXT_texture_storage")) { 1560 // On ES2 the internal format of a BGRA texture is RGBA with the APPLE extension. 1561 // Though, that seems to not be the case if the texture storage extension is 1562 // present. The specs don't exactly make that clear. 1563 fConfigTable[kBGRA_8888_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_RGBA; 1564 fConfigTable[kBGRA_8888_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_RGBA8; 1565 } 1566 } else if (ctxInfo.hasExtension("GL_EXT_texture_format_BGRA8888")) { 1567 fConfigTable[kBGRA_8888_GrPixelConfig].fFlags = ConfigInfo::kTextureable_Flag | 1568 nonMSAARenderFlags; 1569 if (ctxInfo.hasExtension("GL_CHROMIUM_renderbuffer_format_BGRA8888") && 1570 (this->usesMSAARenderBuffers() || this->fMSFBOType == kMixedSamples_MSFBOType)) { 1571 fConfigTable[kBGRA_8888_GrPixelConfig].fFlags |= 1572 ConfigInfo::kRenderableWithMSAA_Flag; 1573 } 1574 } 1575 } 1576 if (texStorageSupported) { 1577 fConfigTable[kBGRA_8888_GrPixelConfig].fFlags |= ConfigInfo::kCanUseTexStorage_Flag; 1578 } 1579 fConfigTable[kBGRA_8888_GrPixelConfig].fSwizzle = GrSwizzle::RGBA(); 1580 1581 // We only enable srgb support if both textures and FBOs support srgb, 1582 // *and* we can disable sRGB decode-on-read, to support "legacy" mode. 1583 if (kGL_GrGLStandard == standard) { 1584 if (ctxInfo.version() >= GR_GL_VER(3,0)) { 1585 fSRGBSupport = true; 1586 } else if (ctxInfo.hasExtension("GL_EXT_texture_sRGB")) { 1587 if (ctxInfo.hasExtension("GL_ARB_framebuffer_sRGB") || 1588 ctxInfo.hasExtension("GL_EXT_framebuffer_sRGB")) { 1589 fSRGBSupport = true; 1590 } 1591 } 1592 // All the above srgb extensions support toggling srgb writes 1593 if (fSRGBSupport) { 1594 fSRGBWriteControl = true; 1595 } 1596 } else { 1597 fSRGBSupport = ctxInfo.version() >= GR_GL_VER(3,0) || ctxInfo.hasExtension("GL_EXT_sRGB"); 1598 #if defined(SK_CPU_X86) 1599 if (kPowerVRRogue_GrGLRenderer == ctxInfo.renderer()) { 1600 // NexusPlayer has strange bugs with sRGB (skbug.com/4148). This is a targeted fix to 1601 // blacklist that device (and any others that might be sharing the same driver). 1602 fSRGBSupport = false; 1603 } 1604 #endif 1605 // ES through 3.1 requires EXT_srgb_write_control to support toggling 1606 // sRGB writing for destinations. 1607 // See https://bug.skia.org/5329 for Adreno4xx issue. 1608 fSRGBWriteControl = kAdreno4xx_GrGLRenderer != ctxInfo.renderer() && 1609 ctxInfo.hasExtension("GL_EXT_sRGB_write_control"); 1610 } 1611 if (contextOptions.fRequireDecodeDisableForSRGB && !fSRGBDecodeDisableSupport) { 1612 // To support "legacy" L32 mode, we require the ability to turn off sRGB decode. Clients 1613 // can opt-out of that requirement, if they intend to always do linear blending. 1614 fSRGBSupport = false; 1615 } 1616 1617 // This is very conservative, if we're on a platform where N32 is BGRA, and using ES, disable 1618 // all sRGB support. Too much code relies on creating surfaces with N32 + sRGB colorspace, 1619 // and sBGRA is basically impossible to support on any version of ES (with our current code). 1620 // In particular, ES2 doesn't support sBGRA at all, and even in ES3, there is no valid pair 1621 // of formats that can be used for TexImage calls to upload BGRA data to sRGBA (which is what 1622 // we *have* to use as the internal format, because sBGRA doesn't exist). This primarily 1623 // affects Windows. 1624 if (kSkia8888_GrPixelConfig == kBGRA_8888_GrPixelConfig && kGLES_GrGLStandard == standard) { 1625 fSRGBSupport = false; 1626 } 1627 1628 fConfigTable[kSRGBA_8888_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_SRGB_ALPHA; 1629 fConfigTable[kSRGBA_8888_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_SRGB8_ALPHA8; 1630 // GL does not do srgb<->rgb conversions when transferring between cpu and gpu. Thus, the 1631 // external format is GL_RGBA. See below for note about ES2.0 and glTex[Sub]Image. 1632 fConfigTable[kSRGBA_8888_GrPixelConfig].fFormats.fExternalFormat[kOther_ExternalFormatUsage] = 1633 GR_GL_RGBA; 1634 fConfigTable[kSRGBA_8888_GrPixelConfig].fFormats.fExternalType = GR_GL_UNSIGNED_BYTE; 1635 fConfigTable[kSRGBA_8888_GrPixelConfig].fFormatType = kNormalizedFixedPoint_FormatType; 1636 if (fSRGBSupport) { 1637 fConfigTable[kSRGBA_8888_GrPixelConfig].fFlags = ConfigInfo::kTextureable_Flag | 1638 allRenderFlags; 1639 } 1640 if (texStorageSupported) { 1641 fConfigTable[kSRGBA_8888_GrPixelConfig].fFlags |= ConfigInfo::kCanUseTexStorage_Flag; 1642 } 1643 fConfigTable[kSRGBA_8888_GrPixelConfig].fSwizzle = GrSwizzle::RGBA(); 1644 1645 // sBGRA is not a "real" thing in OpenGL, but GPUs support it, and on platforms where 1646 // kN32 == BGRA, we need some way to work with it. (The default framebuffer on Windows 1647 // is in this format, for example). 1648 fConfigTable[kSBGRA_8888_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_SRGB_ALPHA; 1649 fConfigTable[kSBGRA_8888_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_SRGB8_ALPHA8; 1650 // GL does not do srgb<->rgb conversions when transferring between cpu and gpu. Thus, the 1651 // external format is GL_BGRA. 1652 fConfigTable[kSBGRA_8888_GrPixelConfig].fFormats.fExternalFormat[kOther_ExternalFormatUsage] = 1653 GR_GL_BGRA; 1654 fConfigTable[kSBGRA_8888_GrPixelConfig].fFormats.fExternalType = GR_GL_UNSIGNED_BYTE; 1655 fConfigTable[kSBGRA_8888_GrPixelConfig].fFormatType = kNormalizedFixedPoint_FormatType; 1656 if (fSRGBSupport) { 1657 fConfigTable[kSBGRA_8888_GrPixelConfig].fFlags = ConfigInfo::kTextureable_Flag | 1658 allRenderFlags; 1659 } 1660 if (texStorageSupported) { 1661 fConfigTable[kSBGRA_8888_GrPixelConfig].fFlags |= ConfigInfo::kCanUseTexStorage_Flag; 1662 } 1663 fConfigTable[kSBGRA_8888_GrPixelConfig].fSwizzle = GrSwizzle::RGBA(); 1664 1665 bool hasIntegerTextures; 1666 if (standard == kGL_GrGLStandard) { 1667 hasIntegerTextures = version >= GR_GL_VER(3, 0) || 1668 ctxInfo.hasExtension("GL_EXT_texture_integer"); 1669 } else { 1670 hasIntegerTextures = (version >= GR_GL_VER(3, 0)); 1671 } 1672 // We may have limited GLSL to an earlier version that doesn't have integer sampler types. 1673 if (ctxInfo.glslGeneration() == k110_GrGLSLGeneration) { 1674 hasIntegerTextures = false; 1675 } 1676 fConfigTable[kRGBA_8888_sint_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_RGBA_INTEGER; 1677 fConfigTable[kRGBA_8888_sint_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_RGBA8I; 1678 fConfigTable[kRGBA_8888_sint_GrPixelConfig].fFormats.fExternalFormat[kOther_ExternalFormatUsage] = GR_GL_RGBA_INTEGER; 1679 fConfigTable[kRGBA_8888_sint_GrPixelConfig].fFormats.fExternalType = GR_GL_BYTE; 1680 fConfigTable[kRGBA_8888_sint_GrPixelConfig].fFormatType = kInteger_FormatType; 1681 // We currently only support using integer textures as srcs, not for rendering (even though GL 1682 // allows it). 1683 if (hasIntegerTextures) { 1684 fConfigTable[kRGBA_8888_sint_GrPixelConfig].fFlags = ConfigInfo::kTextureable_Flag | 1685 ConfigInfo::kFBOColorAttachment_Flag; 1686 if (texStorageSupported) { 1687 fConfigTable[kRGBA_8888_sint_GrPixelConfig].fFlags |= 1688 ConfigInfo::kCanUseTexStorage_Flag; 1689 } 1690 } 1691 1692 fConfigTable[kRGB_565_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_RGB; 1693 if (this->ES2CompatibilitySupport()) { 1694 fConfigTable[kRGB_565_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_RGB565; 1695 } else { 1696 fConfigTable[kRGB_565_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_RGB5; 1697 } 1698 fConfigTable[kRGB_565_GrPixelConfig].fFormats.fExternalFormat[kOther_ExternalFormatUsage] = 1699 GR_GL_RGB; 1700 fConfigTable[kRGB_565_GrPixelConfig].fFormats.fExternalType = GR_GL_UNSIGNED_SHORT_5_6_5; 1701 fConfigTable[kRGB_565_GrPixelConfig].fFormatType = kNormalizedFixedPoint_FormatType; 1702 fConfigTable[kRGB_565_GrPixelConfig].fFlags = ConfigInfo::kTextureable_Flag; 1703 if (kGL_GrGLStandard == standard) { 1704 if (version >= GR_GL_VER(4, 2) || ctxInfo.hasExtension("GL_ARB_ES2_compatibility")) { 1705 fConfigTable[kRGB_565_GrPixelConfig].fFlags |= allRenderFlags; 1706 } 1707 } else { 1708 fConfigTable[kRGB_565_GrPixelConfig].fFlags |= allRenderFlags; 1709 } 1710 // 565 is not a sized internal format on desktop GL. So on desktop with 1711 // 565 we always use an unsized internal format to let the system pick 1712 // the best sized format to convert the 565 data to. Since TexStorage 1713 // only allows sized internal formats we disallow it. 1714 // 1715 // TODO: As of 4.2, regular GL supports 565. This logic is due for an 1716 // update. 1717 if (texStorageSupported && kGL_GrGLStandard != standard) { 1718 fConfigTable[kRGB_565_GrPixelConfig].fFlags |= ConfigInfo::kCanUseTexStorage_Flag; 1719 } 1720 fConfigTable[kRGB_565_GrPixelConfig].fSwizzle = GrSwizzle::RGBA(); 1721 1722 fConfigTable[kRGBA_4444_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_RGBA; 1723 fConfigTable[kRGBA_4444_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_RGBA4; 1724 fConfigTable[kRGBA_4444_GrPixelConfig].fFormats.fExternalFormat[kOther_ExternalFormatUsage] = 1725 GR_GL_RGBA; 1726 fConfigTable[kRGBA_4444_GrPixelConfig].fFormats.fExternalType = GR_GL_UNSIGNED_SHORT_4_4_4_4; 1727 fConfigTable[kRGBA_4444_GrPixelConfig].fFormatType = kNormalizedFixedPoint_FormatType; 1728 fConfigTable[kRGBA_4444_GrPixelConfig].fFlags = ConfigInfo::kTextureable_Flag; 1729 if (kGL_GrGLStandard == standard) { 1730 if (version >= GR_GL_VER(4, 2)) { 1731 fConfigTable[kRGBA_4444_GrPixelConfig].fFlags |= allRenderFlags; 1732 } 1733 } else { 1734 fConfigTable[kRGBA_4444_GrPixelConfig].fFlags |= allRenderFlags; 1735 } 1736 if (texStorageSupported) { 1737 fConfigTable[kRGBA_4444_GrPixelConfig].fFlags |= ConfigInfo::kCanUseTexStorage_Flag; 1738 } 1739 fConfigTable[kRGBA_4444_GrPixelConfig].fSwizzle = GrSwizzle::RGBA(); 1740 1741 fConfigTable[kAlpha_8_GrPixelConfig].fFormats.fExternalType = GR_GL_UNSIGNED_BYTE; 1742 fConfigTable[kAlpha_8_GrPixelConfig].fFormatType = kNormalizedFixedPoint_FormatType; 1743 fConfigTable[kAlpha_8_GrPixelConfig].fFlags = ConfigInfo::kTextureable_Flag; 1744 if (this->textureRedSupport()) { 1745 fConfigTable[kAlpha_8_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_RED; 1746 fConfigTable[kAlpha_8_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_R8; 1747 fConfigTable[kAlpha_8_GrPixelConfig].fFormats.fExternalFormat[kOther_ExternalFormatUsage] = 1748 GR_GL_RED; 1749 fConfigTable[kAlpha_8_GrPixelConfig].fSwizzle = GrSwizzle::RRRR(); 1750 if (texelBufferSupport) { 1751 fConfigTable[kAlpha_8_GrPixelConfig].fFlags |= ConfigInfo::kCanUseWithTexelBuffer_Flag; 1752 } 1753 } else { 1754 fConfigTable[kAlpha_8_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_ALPHA; 1755 fConfigTable[kAlpha_8_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_ALPHA8; 1756 fConfigTable[kAlpha_8_GrPixelConfig].fFormats.fExternalFormat[kOther_ExternalFormatUsage] = 1757 GR_GL_ALPHA; 1758 fConfigTable[kAlpha_8_GrPixelConfig].fSwizzle = GrSwizzle::AAAA(); 1759 } 1760 if (this->textureRedSupport() || 1761 (kStandard_MSFBOType == this->msFBOType() && ctxInfo.renderer() != kOSMesa_GrGLRenderer)) { 1762 // OpenGL 3.0+ (and GL_ARB_framebuffer_object) supports ALPHA8 as renderable. 1763 // However, osmesa fails if it used even when GL_ARB_framebuffer_object is present. 1764 // Core profile removes ALPHA8 support, but we should have chosen R8 in that case. 1765 fConfigTable[kAlpha_8_GrPixelConfig].fFlags |= allRenderFlags; 1766 } 1767 if (texStorageSupported) { 1768 fConfigTable[kAlpha_8_GrPixelConfig].fFlags |= ConfigInfo::kCanUseTexStorage_Flag; 1769 } 1770 1771 fConfigTable[kGray_8_GrPixelConfig].fFormats.fExternalType = GR_GL_UNSIGNED_BYTE; 1772 fConfigTable[kGray_8_GrPixelConfig].fFormatType = kNormalizedFixedPoint_FormatType; 1773 fConfigTable[kGray_8_GrPixelConfig].fFlags = ConfigInfo::kTextureable_Flag; 1774 if (this->textureRedSupport()) { 1775 fConfigTable[kGray_8_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_RED; 1776 fConfigTable[kGray_8_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_R8; 1777 fConfigTable[kGray_8_GrPixelConfig].fFormats.fExternalFormat[kOther_ExternalFormatUsage] = 1778 GR_GL_RED; 1779 fConfigTable[kGray_8_GrPixelConfig].fSwizzle = GrSwizzle::RRRA(); 1780 if (texelBufferSupport) { 1781 fConfigTable[kGray_8_GrPixelConfig].fFlags |= ConfigInfo::kCanUseWithTexelBuffer_Flag; 1782 } 1783 } else { 1784 fConfigTable[kGray_8_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_LUMINANCE; 1785 fConfigTable[kGray_8_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_LUMINANCE8; 1786 fConfigTable[kGray_8_GrPixelConfig].fFormats.fExternalFormat[kOther_ExternalFormatUsage] = 1787 GR_GL_LUMINANCE; 1788 fConfigTable[kGray_8_GrPixelConfig].fSwizzle = GrSwizzle::RGBA(); 1789 } 1790 #if 0 // Leaving Gray8 as non-renderable, to keep things simple and match raster 1791 if (this->textureRedSupport() || 1792 (kDesktop_ARB_MSFBOType == this->msFBOType() && 1793 ctxInfo.renderer() != kOSMesa_GrGLRenderer)) { 1794 // desktop ARB extension/3.0+ supports LUMINANCE8 as renderable. 1795 // However, osmesa fails if it used even when GL_ARB_framebuffer_object is present. 1796 // Core profile removes LUMINANCE8 support, but we should have chosen R8 in that case. 1797 fConfigTable[kGray_8_GrPixelConfig].fFlags |= allRenderFlags; 1798 } 1799 #endif 1800 if (texStorageSupported) { 1801 fConfigTable[kGray_8_GrPixelConfig].fFlags |= ConfigInfo::kCanUseTexStorage_Flag; 1802 } 1803 1804 // Check for [half] floating point texture support 1805 // NOTE: We disallow floating point textures on ES devices if linear filtering modes are not 1806 // supported. This is for simplicity, but a more granular approach is possible. Coincidentally, 1807 // [half] floating point textures became part of the standard in ES3.1 / OGL 3.0. 1808 bool hasFPTextures = false; 1809 bool hasHalfFPTextures = false; 1810 // for now we don't support floating point MSAA on ES 1811 uint32_t fpRenderFlags = (kGL_GrGLStandard == standard) ? allRenderFlags : nonMSAARenderFlags; 1812 1813 if (kGL_GrGLStandard == standard) { 1814 if (version >= GR_GL_VER(3, 0) || ctxInfo.hasExtension("GL_ARB_texture_float")) { 1815 hasFPTextures = true; 1816 hasHalfFPTextures = true; 1817 } 1818 } else { 1819 if (version >= GR_GL_VER(3, 1)) { 1820 hasFPTextures = true; 1821 hasHalfFPTextures = true; 1822 } else { 1823 if (ctxInfo.hasExtension("GL_OES_texture_float_linear") && 1824 ctxInfo.hasExtension("GL_OES_texture_float")) { 1825 hasFPTextures = true; 1826 } 1827 if (ctxInfo.hasExtension("GL_OES_texture_half_float_linear") && 1828 ctxInfo.hasExtension("GL_OES_texture_half_float")) { 1829 hasHalfFPTextures = true; 1830 } 1831 } 1832 } 1833 1834 for (auto fpconfig : {kRGBA_float_GrPixelConfig, kRG_float_GrPixelConfig}) { 1835 const GrGLenum format = kRGBA_float_GrPixelConfig == fpconfig ? GR_GL_RGBA : GR_GL_RG; 1836 fConfigTable[fpconfig].fFormats.fBaseInternalFormat = format; 1837 fConfigTable[fpconfig].fFormats.fSizedInternalFormat = 1838 kRGBA_float_GrPixelConfig == fpconfig ? GR_GL_RGBA32F : GR_GL_RG32F; 1839 fConfigTable[fpconfig].fFormats.fExternalFormat[kOther_ExternalFormatUsage] = format; 1840 fConfigTable[fpconfig].fFormats.fExternalType = GR_GL_FLOAT; 1841 fConfigTable[fpconfig].fFormatType = kFloat_FormatType; 1842 if (hasFPTextures) { 1843 fConfigTable[fpconfig].fFlags = ConfigInfo::kTextureable_Flag; 1844 // For now we only enable rendering to float on desktop, because on ES we'd have to 1845 // solve many precision issues and no clients actually want this yet. 1846 if (kGL_GrGLStandard == standard /* || version >= GR_GL_VER(3,2) || 1847 ctxInfo.hasExtension("GL_EXT_color_buffer_float")*/) { 1848 fConfigTable[fpconfig].fFlags |= fpRenderFlags; 1849 } 1850 } 1851 if (texStorageSupported) { 1852 fConfigTable[fpconfig].fFlags |= ConfigInfo::kCanUseTexStorage_Flag; 1853 } 1854 if (texelBufferSupport) { 1855 fConfigTable[fpconfig].fFlags |= ConfigInfo::kCanUseWithTexelBuffer_Flag; 1856 } 1857 fConfigTable[fpconfig].fSwizzle = GrSwizzle::RGBA(); 1858 } 1859 1860 if (this->textureRedSupport()) { 1861 fConfigTable[kAlpha_half_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_RED; 1862 fConfigTable[kAlpha_half_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_R16F; 1863 fConfigTable[kAlpha_half_GrPixelConfig].fFormats.fExternalFormat[kOther_ExternalFormatUsage] 1864 = GR_GL_RED; 1865 fConfigTable[kAlpha_half_GrPixelConfig].fSwizzle = GrSwizzle::RRRR(); 1866 if (texelBufferSupport) { 1867 fConfigTable[kAlpha_half_GrPixelConfig].fFlags |= 1868 ConfigInfo::kCanUseWithTexelBuffer_Flag; 1869 } 1870 } else { 1871 fConfigTable[kAlpha_half_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_ALPHA; 1872 fConfigTable[kAlpha_half_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_ALPHA16F; 1873 fConfigTable[kAlpha_half_GrPixelConfig].fFormats.fExternalFormat[kOther_ExternalFormatUsage] 1874 = GR_GL_ALPHA; 1875 fConfigTable[kAlpha_half_GrPixelConfig].fSwizzle = GrSwizzle::AAAA(); 1876 } 1877 // ANGLE always returns GL_HALF_FLOAT_OES for GL_IMPLEMENTATION_COLOR_READ_TYPE, even though 1878 // ES3 would typically return GL_HALF_FLOAT. The correct fix is for us to respect the value 1879 // returned when we query, but that turns into a bigger refactor, so just work around it. 1880 if (kGL_GrGLStandard == ctxInfo.standard() || 1881 (ctxInfo.version() >= GR_GL_VER(3, 0) && kANGLE_GrGLDriver != ctxInfo.driver())) { 1882 fConfigTable[kAlpha_half_GrPixelConfig].fFormats.fExternalType = GR_GL_HALF_FLOAT; 1883 } else { 1884 fConfigTable[kAlpha_half_GrPixelConfig].fFormats.fExternalType = GR_GL_HALF_FLOAT_OES; 1885 } 1886 fConfigTable[kAlpha_half_GrPixelConfig].fFormatType = kFloat_FormatType; 1887 if (texStorageSupported) { 1888 fConfigTable[kAlpha_half_GrPixelConfig].fFlags |= ConfigInfo::kCanUseTexStorage_Flag; 1889 } 1890 if (hasHalfFPTextures) { 1891 fConfigTable[kAlpha_half_GrPixelConfig].fFlags = ConfigInfo::kTextureable_Flag; 1892 // ES requires either 3.2 or the combination of EXT_color_buffer_half_float and support for 1893 // GL_RED internal format. 1894 if (kGL_GrGLStandard == standard || version >= GR_GL_VER(3, 2) || 1895 (this->textureRedSupport() && 1896 ctxInfo.hasExtension("GL_EXT_color_buffer_half_float"))) { 1897 fConfigTable[kAlpha_half_GrPixelConfig].fFlags |= fpRenderFlags; 1898 } 1899 } 1900 1901 fConfigTable[kRGBA_half_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_RGBA; 1902 fConfigTable[kRGBA_half_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_RGBA16F; 1903 fConfigTable[kRGBA_half_GrPixelConfig].fFormats.fExternalFormat[kOther_ExternalFormatUsage] = 1904 GR_GL_RGBA; 1905 // See comment above, re: ANGLE and ES3. 1906 if (kGL_GrGLStandard == ctxInfo.standard() || 1907 (ctxInfo.version() >= GR_GL_VER(3, 0) && kANGLE_GrGLDriver != ctxInfo.driver())) { 1908 fConfigTable[kRGBA_half_GrPixelConfig].fFormats.fExternalType = GR_GL_HALF_FLOAT; 1909 } else { 1910 fConfigTable[kRGBA_half_GrPixelConfig].fFormats.fExternalType = GR_GL_HALF_FLOAT_OES; 1911 } 1912 fConfigTable[kRGBA_half_GrPixelConfig].fFormatType = kFloat_FormatType; 1913 if (hasHalfFPTextures) { 1914 fConfigTable[kRGBA_half_GrPixelConfig].fFlags = ConfigInfo::kTextureable_Flag; 1915 // ES requires 3.2 or EXT_color_buffer_half_float. 1916 if (kGL_GrGLStandard == standard || version >= GR_GL_VER(3,2) || 1917 ctxInfo.hasExtension("GL_EXT_color_buffer_half_float")) { 1918 fConfigTable[kRGBA_half_GrPixelConfig].fFlags |= fpRenderFlags; 1919 } 1920 } 1921 if (texStorageSupported) { 1922 fConfigTable[kRGBA_half_GrPixelConfig].fFlags |= ConfigInfo::kCanUseTexStorage_Flag; 1923 } 1924 if (texelBufferSupport) { 1925 fConfigTable[kRGBA_half_GrPixelConfig].fFlags |= ConfigInfo::kCanUseWithTexelBuffer_Flag; 1926 } 1927 fConfigTable[kRGBA_half_GrPixelConfig].fSwizzle = GrSwizzle::RGBA(); 1928 1929 // Compressed texture support 1930 1931 // glCompressedTexImage2D is available on all OpenGL ES devices. It is available on standard 1932 // OpenGL after version 1.3. We'll assume at least that level of OpenGL support. 1933 1934 // TODO: Fix command buffer bindings and remove this. 1935 fCompressedTexSubImageSupport = SkToBool(gli->fFunctions.fCompressedTexSubImage2D); 1936 1937 // No sized/unsized internal format distinction for compressed formats, no external format. 1938 // Below we set the external formats and types to 0. 1939 { 1940 fConfigTable[kETC1_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_COMPRESSED_ETC1_RGB8; 1941 fConfigTable[kETC1_GrPixelConfig].fFormats.fSizedInternalFormat = 1942 GR_GL_COMPRESSED_ETC1_RGB8; 1943 fConfigTable[kETC1_GrPixelConfig].fFormats.fExternalFormat[kOther_ExternalFormatUsage] = 0; 1944 fConfigTable[kETC1_GrPixelConfig].fFormats.fExternalType = 0; 1945 fConfigTable[kETC1_GrPixelConfig].fFormatType = kNormalizedFixedPoint_FormatType; 1946 if (kGL_GrGLStandard == standard) { 1947 if (version >= GR_GL_VER(4, 3) || ctxInfo.hasExtension("GL_ARB_ES3_compatibility")) { 1948 fConfigTable[kETC1_GrPixelConfig].fFlags = ConfigInfo::kTextureable_Flag; 1949 } 1950 } else { 1951 if (version >= GR_GL_VER(3, 0) || 1952 ctxInfo.hasExtension("GL_OES_compressed_ETC1_RGB8_texture") || 1953 // ETC2 is a superset of ETC1, so we can just check for that, too. 1954 (ctxInfo.hasExtension("GL_OES_compressed_ETC2_RGB8_texture") && 1955 ctxInfo.hasExtension("GL_OES_compressed_ETC2_RGBA8_texture"))) { 1956 fConfigTable[kETC1_GrPixelConfig].fFlags = ConfigInfo::kTextureable_Flag; 1957 } 1958 } 1959 fConfigTable[kETC1_GrPixelConfig].fSwizzle = GrSwizzle::RGBA(); 1960 } 1961 1962 // Bulk populate the texture internal/external formats here and then deal with exceptions below. 1963 1964 // ES 2.0 requires that the internal/external formats match. 1965 bool useSizedTexFormats = (kGL_GrGLStandard == ctxInfo.standard() || 1966 ctxInfo.version() >= GR_GL_VER(3,0)); 1967 // All ES versions (thus far) require sized internal formats for render buffers. 1968 // TODO: Always use sized internal format? 1969 bool useSizedRbFormats = kGLES_GrGLStandard == ctxInfo.standard(); 1970 1971 for (int i = 0; i < kGrPixelConfigCnt; ++i) { 1972 // Almost always we want to pass fExternalFormat[kOther_ExternalFormatUsage] as the <format> 1973 // param to glTex[Sub]Image. 1974 fConfigTable[i].fFormats.fExternalFormat[kTexImage_ExternalFormatUsage] = 1975 fConfigTable[i].fFormats.fExternalFormat[kOther_ExternalFormatUsage]; 1976 fConfigTable[i].fFormats.fInternalFormatTexImage = useSizedTexFormats ? 1977 fConfigTable[i].fFormats.fSizedInternalFormat : 1978 fConfigTable[i].fFormats.fBaseInternalFormat; 1979 fConfigTable[i].fFormats.fInternalFormatRenderbuffer = useSizedRbFormats ? 1980 fConfigTable[i].fFormats.fSizedInternalFormat : 1981 fConfigTable[i].fFormats.fBaseInternalFormat; 1982 } 1983 // OpenGL ES 2.0 + GL_EXT_sRGB allows GL_SRGB_ALPHA to be specified as the <format> 1984 // param to Tex(Sub)Image. ES 2.0 requires the <internalFormat> and <format> params to match. 1985 // Thus, on ES 2.0 we will use GL_SRGB_ALPHA as the <format> param. 1986 // On OpenGL and ES 3.0+ GL_SRGB_ALPHA does not work for the <format> param to glTexImage. 1987 if (ctxInfo.standard() == kGLES_GrGLStandard && ctxInfo.version() == GR_GL_VER(2,0)) { 1988 fConfigTable[kSRGBA_8888_GrPixelConfig].fFormats.fExternalFormat[kTexImage_ExternalFormatUsage] = 1989 GR_GL_SRGB_ALPHA; 1990 1991 // Additionally, because we had to "invent" sBGRA, there is no way to make it work 1992 // in ES 2.0, because there is no <internalFormat> we can use. So just make that format 1993 // unsupported. (If we have no sRGB support at all, this will get overwritten below). 1994 fConfigTable[kSBGRA_8888_GrPixelConfig].fFlags = 0; 1995 } 1996 1997 // If BGRA is supported as an internal format it must always be specified to glTex[Sub]Image 1998 // as a base format. 1999 // GL_EXT_texture_format_BGRA8888: 2000 // This extension GL_BGRA as an unsized internal format. However, it is written against ES 2001 // 2.0 and therefore doesn't define a value for GL_BGRA8 as ES 2.0 uses unsized internal 2002 // formats. 2003 // GL_APPLE_texture_format_BGRA8888: 2004 // ES 2.0: the extension makes BGRA an external format but not an internal format. 2005 // ES 3.0: the extension explicitly states GL_BGRA8 is not a valid internal format for 2006 // glTexImage (just for glTexStorage). 2007 if (useSizedTexFormats && this->bgraIsInternalFormat()) { 2008 fConfigTable[kBGRA_8888_GrPixelConfig].fFormats.fInternalFormatTexImage = GR_GL_BGRA; 2009 } 2010 2011 // If we don't have texture swizzle support then the shader generator must insert the 2012 // swizzle into shader code. 2013 if (!this->textureSwizzleSupport()) { 2014 for (int i = 0; i < kGrPixelConfigCnt; ++i) { 2015 shaderCaps->fConfigTextureSwizzle[i] = fConfigTable[i].fSwizzle; 2016 } 2017 } 2018 2019 // Shader output swizzles will default to RGBA. When we've use GL_RED instead of GL_ALPHA to 2020 // implement kAlpha_8_GrPixelConfig we need to swizzle the shader outputs so the alpha channel 2021 // gets written to the single component. 2022 if (this->textureRedSupport()) { 2023 for (int i = 0; i < kGrPixelConfigCnt; ++i) { 2024 GrPixelConfig config = static_cast<GrPixelConfig>(i); 2025 if (GrPixelConfigIsAlphaOnly(config) && 2026 fConfigTable[i].fFormats.fBaseInternalFormat == GR_GL_RED) { 2027 shaderCaps->fConfigOutputSwizzle[i] = GrSwizzle::AAAA(); 2028 } 2029 } 2030 } 2031 2032 // We currently only support images on rgba textures formats. We could add additional formats 2033 // if desired. The shader builder would have to be updated to add swizzles where appropriate 2034 // (e.g. where we use GL_RED textures to implement alpha configs). 2035 if (this->shaderCaps()->imageLoadStoreSupport()) { 2036 fConfigTable[kRGBA_8888_sint_GrPixelConfig].fFlags |= 2037 ConfigInfo::kCanUseAsImageStorage_Flag; 2038 // In OpenGL ES a texture may only be used with BindImageTexture if it has been made 2039 // immutable via TexStorage. We create non-integer textures as mutable textures using 2040 // TexImage because we may lazily add MIP levels. Thus, on ES we currently disable image 2041 // storage support for non-integer textures. 2042 if (kGL_GrGLStandard == ctxInfo.standard()) { 2043 fConfigTable[kRGBA_8888_GrPixelConfig].fFlags |= ConfigInfo::kCanUseAsImageStorage_Flag; 2044 fConfigTable[kRGBA_float_GrPixelConfig].fFlags |= 2045 ConfigInfo::kCanUseAsImageStorage_Flag; 2046 fConfigTable[kRGBA_half_GrPixelConfig].fFlags |= ConfigInfo::kCanUseAsImageStorage_Flag; 2047 } 2048 } 2049 2050 #ifdef SK_DEBUG 2051 // Make sure we initialized everything. 2052 ConfigInfo defaultEntry; 2053 for (int i = 0; i < kGrPixelConfigCnt; ++i) { 2054 // Make sure we didn't set renderable and not blittable or renderable with msaa and not 2055 // renderable. 2056 SkASSERT(!((ConfigInfo::kRenderable_Flag) && !(ConfigInfo::kFBOColorAttachment_Flag))); 2057 SkASSERT(!((ConfigInfo::kRenderableWithMSAA_Flag) && !(ConfigInfo::kRenderable_Flag))); 2058 SkASSERT(defaultEntry.fFormats.fBaseInternalFormat != 2059 fConfigTable[i].fFormats.fBaseInternalFormat); 2060 SkASSERT(defaultEntry.fFormats.fSizedInternalFormat != 2061 fConfigTable[i].fFormats.fSizedInternalFormat); 2062 for (int j = 0; j < kExternalFormatUsageCnt; ++j) { 2063 SkASSERT(defaultEntry.fFormats.fExternalFormat[j] != 2064 fConfigTable[i].fFormats.fExternalFormat[j]); 2065 } 2066 SkASSERT(defaultEntry.fFormats.fExternalType != fConfigTable[i].fFormats.fExternalType); 2067 } 2068 #endif 2069 } 2070 2071 bool GrGLCaps::initDescForDstCopy(const GrRenderTarget* src, GrSurfaceDesc* desc) const { 2072 // If the src is a texture, we can implement the blit as a draw assuming the config is 2073 // renderable. 2074 if (src->asTexture() && this->isConfigRenderable(src->config(), false)) { 2075 desc->fOrigin = kDefault_GrSurfaceOrigin; 2076 desc->fFlags = kRenderTarget_GrSurfaceFlag; 2077 desc->fConfig = src->config(); 2078 return true; 2079 } 2080 2081 const GrGLTexture* srcTexture = static_cast<const GrGLTexture*>(src->asTexture()); 2082 if (srcTexture && srcTexture->target() != GR_GL_TEXTURE_2D) { 2083 // Not supported for FBO blit or CopyTexSubImage 2084 return false; 2085 } 2086 2087 // We look for opportunities to use CopyTexSubImage, or fbo blit. If neither are 2088 // possible and we return false to fallback to creating a render target dst for render-to- 2089 // texture. This code prefers CopyTexSubImage to fbo blit and avoids triggering temporary fbo 2090 // creation. It isn't clear that avoiding temporary fbo creation is actually optimal. 2091 GrSurfaceOrigin originForBlitFramebuffer = kDefault_GrSurfaceOrigin; 2092 if (this->blitFramebufferSupportFlags() & kNoScalingOrMirroring_BlitFramebufferFlag) { 2093 originForBlitFramebuffer = src->origin(); 2094 } 2095 2096 // Check for format issues with glCopyTexSubImage2D 2097 if (this->bgraIsInternalFormat() && kBGRA_8888_GrPixelConfig == src->config()) { 2098 // glCopyTexSubImage2D doesn't work with this config. If the bgra can be used with fbo blit 2099 // then we set up for that, otherwise fail. 2100 if (this->canConfigBeFBOColorAttachment(kBGRA_8888_GrPixelConfig)) { 2101 desc->fOrigin = originForBlitFramebuffer; 2102 desc->fConfig = kBGRA_8888_GrPixelConfig; 2103 return true; 2104 } 2105 return false; 2106 } 2107 2108 const GrGLRenderTarget* srcRT = static_cast<const GrGLRenderTarget*>(src); 2109 if (srcRT->renderFBOID() != srcRT->textureFBOID()) { 2110 // It's illegal to call CopyTexSubImage2D on a MSAA renderbuffer. Set up for FBO blit or 2111 // fail. 2112 if (this->canConfigBeFBOColorAttachment(src->config())) { 2113 desc->fOrigin = originForBlitFramebuffer; 2114 desc->fConfig = src->config(); 2115 return true; 2116 } 2117 return false; 2118 } 2119 2120 // We'll do a CopyTexSubImage. Make the dst a plain old texture. 2121 desc->fConfig = src->config(); 2122 desc->fOrigin = src->origin(); 2123 desc->fFlags = kNone_GrSurfaceFlags; 2124 return true; 2125 } 2126 2127 void GrGLCaps::onApplyOptionsOverrides(const GrContextOptions& options) { 2128 if (options.fEnableInstancedRendering) { 2129 fInstancedSupport = gr_instanced::GLInstancedRendering::CheckSupport(*this); 2130 #ifndef SK_BUILD_FOR_MAC 2131 // OS X doesn't seem to write correctly to floating point textures when using 2132 // glDraw*Indirect, regardless of the underlying GPU. 2133 fAvoidInstancedDrawsToFPTargets = true; 2134 #endif 2135 } 2136 } 2137