blob: 9b12ce69c50b89ad0d66be2e6bfb15736a3ab960 [file] [log] [blame]
bsalomon@google.comf7fa8062012-02-14 14:09:57 +00001/*
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
9#include "GrGLCaps.h"
joshualittb4384b92014-10-21 12:53:15 -070010
egdanielb7e7d572015-11-04 04:23:53 -080011#include "GrContextOptions.h"
robertphillips@google.com6177e692013-02-28 20:16:25 +000012#include "GrGLContext.h"
bsalomon1aa20292016-01-22 08:16:09 -080013#include "GrGLRenderTarget.h"
jvanverthcba99b82015-06-24 06:59:57 -070014#include "glsl/GrGLSLCaps.h"
bsalomon@google.comc9668ec2012-04-11 18:16:41 +000015#include "SkTSearch.h"
bsalomon@google.com20f7f172013-05-17 19:05:03 +000016#include "SkTSort.h"
bsalomon@google.comf7fa8062012-02-14 14:09:57 +000017
bsalomon682c2692015-05-22 14:01:46 -070018GrGLCaps::GrGLCaps(const GrContextOptions& contextOptions,
19 const GrGLContextInfo& ctxInfo,
20 const GrGLInterface* glInterface) : INHERITED(contextOptions) {
bsalomon1aa20292016-01-22 08:16:09 -080021 fStandard = ctxInfo.standard();
22
bsalomon@google.comf7fa8062012-02-14 14:09:57 +000023 fStencilFormats.reset();
bsalomon@google.comf7fa8062012-02-14 14:09:57 +000024 fMSFBOType = kNone_MSFBOType;
commit-bot@chromium.org52ffbf62014-04-02 16:19:33 +000025 fInvalidateFBType = kNone_InvalidateFBType;
commit-bot@chromium.org160b4782014-05-05 12:32:37 +000026 fMapBufferType = kNone_MapBufferType;
jvanverthd7a2c1f2015-12-07 07:36:44 -080027 fTransferBufferType = kNone_TransferBufferType;
bsalomon@google.comf7fa8062012-02-14 14:09:57 +000028 fMaxFragmentUniformVectors = 0;
bsalomon@google.comf7fa8062012-02-14 14:09:57 +000029 fUnpackRowLengthSupport = false;
30 fUnpackFlipYSupport = false;
31 fPackRowLengthSupport = false;
32 fPackFlipYSupport = false;
33 fTextureUsageSupport = false;
robertphillips@google.com443e5a52012-04-30 20:01:21 +000034 fTextureRedSupport = false;
bsalomon@google.come76b7cc2012-06-18 12:47:06 +000035 fImagingSupport = false;
bsalomon@google.com07631cf2013-03-05 14:14:58 +000036 fVertexArrayObjectSupport = false;
cdalton626e1ff2015-06-12 13:56:46 -070037 fDirectStateAccessSupport = false;
38 fDebugSupport = false;
jvanverth3f801cb2014-12-16 09:49:38 -080039 fES2CompatibilitySupport = false;
cdaltond4727922015-11-10 12:49:06 -080040 fMultisampleDisableSupport = false;
cdalton06604b92016-02-05 10:09:51 -080041 fDrawIndirectSupport = false;
42 fMultiDrawIndirectSupport = false;
43 fBaseInstanceSupport = false;
bsalomon@google.com96966a52013-02-21 16:34:21 +000044 fUseNonVBOVertexAndIndexDynamicData = false;
bsalomon@google.com2b1b8c02013-02-28 22:06:02 +000045 fIsCoreProfile = false;
joshualittc1f56b52015-06-22 12:31:31 -070046 fBindFragDataLocationSupport = false;
bsalomone5286e02016-01-14 09:24:09 -080047 fRectangleTextureSupport = false;
bsalomoncdee0092016-01-08 13:20:12 -080048 fTextureSwizzleSupport = false;
bsalomon88c7b982015-07-31 11:20:16 -070049 fRGBA8888PixelsOpsAreSlow = false;
50 fPartialFBOReadIsSlow = false;
cblume09bd2c02016-03-01 14:08:28 -080051 fMipMapLevelAndLodControlSupport = false;
ericrkb4ecabd2016-03-11 15:18:20 -080052 fRGBAToBGRAReadbackConversionsAreSlow = false;
piotaixre4b23142014-10-02 10:57:53 -070053
bsalomon083617b2016-02-12 12:10:14 -080054 fBlitFramebufferSupport = kNone_BlitFramebufferSupport;
55
halcanary385fe4d2015-08-26 13:07:48 -070056 fShaderCaps.reset(new GrGLSLCaps(contextOptions));
bsalomon4ee6bd82015-05-27 13:23:23 -070057
cdalton4cd67132015-06-10 19:23:46 -070058 this->init(contextOptions, ctxInfo, glInterface);
bsalomon@google.comf7fa8062012-02-14 14:09:57 +000059}
60
cdalton4cd67132015-06-10 19:23:46 -070061void GrGLCaps::init(const GrContextOptions& contextOptions,
62 const GrGLContextInfo& ctxInfo,
63 const GrGLInterface* gli) {
commit-bot@chromium.org9e90aed2014-01-16 16:35:09 +000064 GrGLStandard standard = ctxInfo.standard();
bsalomon@google.comf7fa8062012-02-14 14:09:57 +000065 GrGLVersion version = ctxInfo.version();
66
bsalomon@google.combcce8922013-03-25 15:38:39 +000067 /**************************************************************************
68 * Caps specific to GrGLCaps
69 **************************************************************************/
70
commit-bot@chromium.org9e90aed2014-01-16 16:35:09 +000071 if (kGLES_GrGLStandard == standard) {
bsalomon@google.comf7fa8062012-02-14 14:09:57 +000072 GR_GL_GetIntegerv(gli, GR_GL_MAX_FRAGMENT_UNIFORM_VECTORS,
73 &fMaxFragmentUniformVectors);
74 } else {
commit-bot@chromium.org9e90aed2014-01-16 16:35:09 +000075 SkASSERT(kGL_GrGLStandard == standard);
bsalomon@google.comf7fa8062012-02-14 14:09:57 +000076 GrGLint max;
77 GR_GL_GetIntegerv(gli, GR_GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, &max);
78 fMaxFragmentUniformVectors = max / 4;
commit-bot@chromium.org46fbfe02013-08-30 15:52:12 +000079 if (version >= GR_GL_VER(3, 2)) {
80 GrGLint profileMask;
81 GR_GL_GetIntegerv(gli, GR_GL_CONTEXT_PROFILE_MASK, &profileMask);
82 fIsCoreProfile = SkToBool(profileMask & GR_GL_CONTEXT_CORE_PROFILE_BIT);
83 }
bsalomon@google.comf7fa8062012-02-14 14:09:57 +000084 }
bsalomon@google.com60da4172012-06-01 19:25:00 +000085 GR_GL_GetIntegerv(gli, GR_GL_MAX_VERTEX_ATTRIBS, &fMaxVertexAttributes);
bsalomon@google.comf7fa8062012-02-14 14:09:57 +000086
commit-bot@chromium.org9e90aed2014-01-16 16:35:09 +000087 if (kGL_GrGLStandard == standard) {
bsalomon@google.comf7fa8062012-02-14 14:09:57 +000088 fUnpackRowLengthSupport = true;
89 fUnpackFlipYSupport = false;
90 fPackRowLengthSupport = true;
91 fPackFlipYSupport = false;
92 } else {
commit-bot@chromium.orgdc3134c2013-08-16 16:12:23 +000093 fUnpackRowLengthSupport = version >= GR_GL_VER(3,0) ||
94 ctxInfo.hasExtension("GL_EXT_unpack_subimage");
bsalomon@google.comf7fa8062012-02-14 14:09:57 +000095 fUnpackFlipYSupport = ctxInfo.hasExtension("GL_CHROMIUM_flipy");
commit-bot@chromium.orgdc3134c2013-08-16 16:12:23 +000096 fPackRowLengthSupport = version >= GR_GL_VER(3,0) ||
97 ctxInfo.hasExtension("GL_NV_pack_subimage");
bsalomon@google.comf7fa8062012-02-14 14:09:57 +000098 fPackFlipYSupport =
99 ctxInfo.hasExtension("GL_ANGLE_pack_reverse_row_order");
100 }
101
commit-bot@chromium.org9e90aed2014-01-16 16:35:09 +0000102 fTextureUsageSupport = (kGLES_GrGLStandard == standard) &&
bsalomon@google.comf7fa8062012-02-14 14:09:57 +0000103 ctxInfo.hasExtension("GL_ANGLE_texture_usage");
104
commit-bot@chromium.org9e90aed2014-01-16 16:35:09 +0000105 if (kGL_GrGLStandard == standard) {
cdaltonfd4167d2015-04-21 11:45:56 -0700106 fTextureBarrierSupport = version >= GR_GL_VER(4,5) ||
107 ctxInfo.hasExtension("GL_ARB_texture_barrier") ||
108 ctxInfo.hasExtension("GL_NV_texture_barrier");
109 } else {
110 fTextureBarrierSupport = ctxInfo.hasExtension("GL_NV_texture_barrier");
111 }
112
cdaltoneb79eea2016-02-26 10:39:34 -0800113 if (kGL_GrGLStandard == standard) {
114 fSampleLocationsSupport = version >= GR_GL_VER(3,2) ||
115 ctxInfo.hasExtension("GL_ARB_texture_multisample");
116 } else {
117 fSampleLocationsSupport = version >= GR_GL_VER(3,1);
118 }
119
halcanary9d524f22016-03-29 09:03:52 -0700120 // ARB_texture_rg is part of OpenGL 3.0, but mesa doesn't support GL_RED
hendrikwa0d5ad72014-12-02 07:30:30 -0800121 // and GL_RG on FBO textures.
cdalton1acea862015-06-02 13:05:52 -0700122 if (kMesa_GrGLDriver != ctxInfo.driver()) {
hendrikwa0d5ad72014-12-02 07:30:30 -0800123 if (kGL_GrGLStandard == standard) {
commit-bot@chromium.org459104c2013-06-14 14:42:56 +0000124 fTextureRedSupport = version >= GR_GL_VER(3,0) ||
125 ctxInfo.hasExtension("GL_ARB_texture_rg");
hendrikwa0d5ad72014-12-02 07:30:30 -0800126 } else {
127 fTextureRedSupport = version >= GR_GL_VER(3,0) ||
128 ctxInfo.hasExtension("GL_EXT_texture_rg");
commit-bot@chromium.org459104c2013-06-14 14:42:56 +0000129 }
robertphillips@google.com443e5a52012-04-30 20:01:21 +0000130 }
commit-bot@chromium.org9e90aed2014-01-16 16:35:09 +0000131 fImagingSupport = kGL_GrGLStandard == standard &&
bsalomon@google.come76b7cc2012-06-18 12:47:06 +0000132 ctxInfo.hasExtension("GL_ARB_imaging");
133
bsalomon@google.com3012ded2013-02-22 16:44:04 +0000134 // SGX and Mali GPUs that are based on a tiled-deferred architecture that have trouble with
135 // frequently changing VBOs. We've measured a performance increase using non-VBO vertex
136 // data for dynamic content on these GPUs. Perhaps we should read the renderer string and
137 // limit this decision to specific GPU families rather than basing it on the vendor alone.
138 if (!GR_GL_MUST_USE_VBO &&
cdaltone2e71c22016-04-07 18:13:29 -0700139 !fIsCoreProfile &&
bsalomoned82c4e2014-09-02 07:54:47 -0700140 (kARM_GrGLVendor == ctxInfo.vendor() ||
141 kImagination_GrGLVendor == ctxInfo.vendor() ||
142 kQualcomm_GrGLVendor == ctxInfo.vendor())) {
bsalomon@google.com96966a52013-02-21 16:34:21 +0000143 fUseNonVBOVertexAndIndexDynamicData = true;
144 }
skia.committer@gmail.com631cdcb2013-03-01 12:12:55 +0000145
egdaniel9250d242015-05-18 13:04:26 -0700146 // A driver but on the nexus 6 causes incorrect dst copies when invalidate is called beforehand.
147 // Thus we are blacklisting this extension for now on Adreno4xx devices.
148 if (kAdreno4xx_GrGLRenderer != ctxInfo.renderer() &&
149 ((kGL_GrGLStandard == standard && version >= GR_GL_VER(4,3)) ||
150 (kGLES_GrGLStandard == standard && version >= GR_GL_VER(3,0)) ||
151 ctxInfo.hasExtension("GL_ARB_invalidate_subdata"))) {
commit-bot@chromium.org52ffbf62014-04-02 16:19:33 +0000152 fDiscardRenderTargetSupport = true;
153 fInvalidateFBType = kInvalidate_InvalidateFBType;
154 } else if (ctxInfo.hasExtension("GL_EXT_discard_framebuffer")) {
155 fDiscardRenderTargetSupport = true;
156 fInvalidateFBType = kDiscard_InvalidateFBType;
157 }
robertphillips@google.coma6ffb582013-04-29 16:50:17 +0000158
robertphillips@google.com56ce48a2013-10-31 21:44:25 +0000159 if (kARM_GrGLVendor == ctxInfo.vendor() || kImagination_GrGLVendor == ctxInfo.vendor()) {
160 fFullClearIsFree = true;
161 }
162
commit-bot@chromium.org9e90aed2014-01-16 16:35:09 +0000163 if (kGL_GrGLStandard == standard) {
bsalomon@google.com07631cf2013-03-05 14:14:58 +0000164 fVertexArrayObjectSupport = version >= GR_GL_VER(3, 0) ||
tomhudson612e9262014-11-24 11:22:36 -0800165 ctxInfo.hasExtension("GL_ARB_vertex_array_object") ||
166 ctxInfo.hasExtension("GL_APPLE_vertex_array_object");
bsalomon@google.com07631cf2013-03-05 14:14:58 +0000167 } else {
commit-bot@chromium.org2276c012013-08-16 15:53:33 +0000168 fVertexArrayObjectSupport = version >= GR_GL_VER(3, 0) ||
169 ctxInfo.hasExtension("GL_OES_vertex_array_object");
bsalomon@google.com07631cf2013-03-05 14:14:58 +0000170 }
171
cdalton626e1ff2015-06-12 13:56:46 -0700172 if (kGL_GrGLStandard == standard) {
173 fDirectStateAccessSupport = ctxInfo.hasExtension("GL_EXT_direct_state_access");
174 } else {
175 fDirectStateAccessSupport = false;
176 }
177
178 if (kGL_GrGLStandard == standard && version >= GR_GL_VER(4,3)) {
179 fDebugSupport = true;
180 } else {
181 fDebugSupport = ctxInfo.hasExtension("GL_KHR_debug");
182 }
183
jvanverth3f801cb2014-12-16 09:49:38 -0800184 if (kGL_GrGLStandard == standard) {
185 fES2CompatibilitySupport = ctxInfo.hasExtension("GL_ARB_ES2_compatibility");
186 }
187 else {
188 fES2CompatibilitySupport = true;
189 }
190
cdalton0edea2c2015-05-21 08:27:44 -0700191 if (kGL_GrGLStandard == standard) {
192 fMultisampleDisableSupport = true;
193 } else {
kkinnunenbf49e462015-07-30 22:43:52 -0700194 fMultisampleDisableSupport = ctxInfo.hasExtension("GL_EXT_multisample_compatibility");
cdalton0edea2c2015-05-21 08:27:44 -0700195 }
196
kkinnunend94708e2015-07-30 22:47:04 -0700197 if (kGL_GrGLStandard == standard) {
198 if (version >= GR_GL_VER(3, 0)) {
199 fBindFragDataLocationSupport = true;
200 }
201 } else {
202 if (version >= GR_GL_VER(3, 0) && ctxInfo.hasExtension("GL_EXT_blend_func_extended")) {
203 fBindFragDataLocationSupport = true;
204 }
joshualittc1f56b52015-06-22 12:31:31 -0700205 }
206
bsalomonb8909d32016-01-28 07:09:52 -0800207#if 0 // Disabled due to https://bug.skia.org/4454
joshualitt7bdd70a2015-10-01 06:28:11 -0700208 fBindUniformLocationSupport = ctxInfo.hasExtension("GL_CHROMIUM_bind_uniform_location");
bsalomonb8909d32016-01-28 07:09:52 -0800209#else
210 fBindUniformLocationSupport = false;
211#endif
joshualitt7bdd70a2015-10-01 06:28:11 -0700212
kkinnunene06ed252016-02-16 23:15:40 -0800213 if (kGL_GrGLStandard == standard) {
214 if (version >= GR_GL_VER(3, 1) || ctxInfo.hasExtension("GL_ARB_texture_rectangle")) {
215 // We also require textureSize() support for rectangle 2D samplers which was added in
216 // GLSL 1.40.
217 if (ctxInfo.glslGeneration() >= k140_GrGLSLGeneration) {
218 fRectangleTextureSupport = true;
219 }
bsalomone179a912016-01-20 06:18:10 -0800220 }
kkinnunene06ed252016-02-16 23:15:40 -0800221 } else {
222 // Command buffer exposes this in GL ES context for Chromium reasons,
223 // but it should not be used. Also, at the time of writing command buffer
224 // lacks TexImage2D support and ANGLE lacks GL ES 3.0 support.
bsalomone5286e02016-01-14 09:24:09 -0800225 }
226
bsalomoncdee0092016-01-08 13:20:12 -0800227 if (kGL_GrGLStandard == standard) {
228 if (version >= GR_GL_VER(3,3) || ctxInfo.hasExtension("GL_ARB_texture_swizzle")) {
229 fTextureSwizzleSupport = true;
230 }
231 } else {
232 if (version >= GR_GL_VER(3,0)) {
233 fTextureSwizzleSupport = true;
234 }
235 }
236
cblume09bd2c02016-03-01 14:08:28 -0800237 if (kGL_GrGLStandard == standard) {
238 fMipMapLevelAndLodControlSupport = true;
239 } else if (kGLES_GrGLStandard == standard) {
240 if (version >= GR_GL_VER(3,0)) {
241 fMipMapLevelAndLodControlSupport = true;
242 }
243 }
244
bsalomon88c7b982015-07-31 11:20:16 -0700245#ifdef SK_BUILD_FOR_WIN
246 // We're assuming that on Windows Chromium we're using ANGLE.
247 bool isANGLE = kANGLE_GrGLDriver == ctxInfo.driver() ||
248 kChromium_GrGLDriver == ctxInfo.driver();
halcanary9d524f22016-03-29 09:03:52 -0700249 // Angle has slow read/write pixel paths for 32bit RGBA (but fast for BGRA).
bsalomon88c7b982015-07-31 11:20:16 -0700250 fRGBA8888PixelsOpsAreSlow = isANGLE;
251 // On DX9 ANGLE reading a partial FBO is slow. TODO: Check whether this is still true and
252 // check DX11 ANGLE.
253 fPartialFBOReadIsSlow = isANGLE;
254#endif
255
ericrkb4ecabd2016-03-11 15:18:20 -0800256 bool isMESA = kMesa_GrGLDriver == ctxInfo.driver();
257 bool isMAC = false;
258#ifdef SK_BUILD_FOR_MAC
259 isMAC = true;
260#endif
261
262 // Both mesa and mac have reduced performance if reading back an RGBA framebuffer as BGRA or
263 // vis-versa.
264 fRGBAToBGRAReadbackConversionsAreSlow = isMESA || isMAC;
265
cdalton4cd67132015-06-10 19:23:46 -0700266 /**************************************************************************
egdaniel05ded892015-10-26 07:38:05 -0700267 * GrShaderCaps fields
268 **************************************************************************/
269
egdaniel0a482332015-10-26 08:59:10 -0700270 // This must be called after fCoreProfile is set on the GrGLCaps
271 this->initGLSL(ctxInfo);
272 GrGLSLCaps* glslCaps = static_cast<GrGLSLCaps*>(fShaderCaps.get());
273
egdaniel05ded892015-10-26 07:38:05 -0700274 glslCaps->fPathRenderingSupport = this->hasPathRenderingSupport(ctxInfo, gli);
275
276 // For now these two are equivalent but we could have dst read in shader via some other method.
277 // Before setting this, initGLSL() must have been called.
278 glslCaps->fDstReadInShaderSupport = glslCaps->fFBFetchSupport;
279
280 // Enable supported shader-related caps
281 if (kGL_GrGLStandard == standard) {
282 glslCaps->fDualSourceBlendingSupport = (ctxInfo.version() >= GR_GL_VER(3, 3) ||
283 ctxInfo.hasExtension("GL_ARB_blend_func_extended")) &&
284 GrGLSLSupportsNamedFragmentShaderOutputs(ctxInfo.glslGeneration());
285 glslCaps->fShaderDerivativeSupport = true;
286 // we don't support GL_ARB_geometry_shader4, just GL 3.2+ GS
287 glslCaps->fGeometryShaderSupport = ctxInfo.version() >= GR_GL_VER(3, 2) &&
288 ctxInfo.glslGeneration() >= k150_GrGLSLGeneration;
cdalton793dc262016-02-08 10:11:47 -0800289 glslCaps->fIntegerSupport = ctxInfo.version() >= GR_GL_VER(3, 0) &&
290 ctxInfo.glslGeneration() >= k130_GrGLSLGeneration;
egdaniel05ded892015-10-26 07:38:05 -0700291 }
292 else {
293 glslCaps->fDualSourceBlendingSupport = ctxInfo.hasExtension("GL_EXT_blend_func_extended");
294
295 glslCaps->fShaderDerivativeSupport = ctxInfo.version() >= GR_GL_VER(3, 0) ||
296 ctxInfo.hasExtension("GL_OES_standard_derivatives");
cdalton793dc262016-02-08 10:11:47 -0800297
298 glslCaps->fIntegerSupport = ctxInfo.version() >= GR_GL_VER(3, 0) &&
299 ctxInfo.glslGeneration() >= k330_GrGLSLGeneration; // We use this value for GLSL ES 3.0.
egdaniel05ded892015-10-26 07:38:05 -0700300 }
301
ethannicholas22793252016-01-30 09:59:10 -0800302 if (ctxInfo.hasExtension("GL_EXT_shader_pixel_local_storage")) {
303 #define GL_MAX_SHADER_PIXEL_LOCAL_STORAGE_FAST_SIZE_EXT 0x8F63
halcanary9d524f22016-03-29 09:03:52 -0700304 GR_GL_GetIntegerv(gli, GL_MAX_SHADER_PIXEL_LOCAL_STORAGE_FAST_SIZE_EXT,
ethannicholas22793252016-01-30 09:59:10 -0800305 &glslCaps->fPixelLocalStorageSize);
306 glslCaps->fPLSPathRenderingSupport = glslCaps->fFBFetchSupport;
307 }
308 else {
309 glslCaps->fPixelLocalStorageSize = 0;
310 glslCaps->fPLSPathRenderingSupport = false;
311 }
312
cdalton9c3f1432016-03-11 10:07:37 -0800313 // Protect ourselves against tracking huge amounts of texture state.
314 static const uint8_t kMaxSaneSamplers = 32;
315 GrGLint maxSamplers;
316 GR_GL_GetIntegerv(gli, GR_GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS, &maxSamplers);
317 glslCaps->fMaxVertexSamplers = SkTMin<GrGLint>(kMaxSaneSamplers, maxSamplers);
318 if (glslCaps->fGeometryShaderSupport) {
319 GR_GL_GetIntegerv(gli, GR_GL_MAX_GEOMETRY_TEXTURE_IMAGE_UNITS, &maxSamplers);
320 glslCaps->fMaxGeometrySamplers = SkTMin<GrGLint>(kMaxSaneSamplers, maxSamplers);
321 }
322 GR_GL_GetIntegerv(gli, GR_GL_MAX_TEXTURE_IMAGE_UNITS, &maxSamplers);
323 glslCaps->fMaxFragmentSamplers = SkTMin<GrGLint>(kMaxSaneSamplers, maxSamplers);
324 GR_GL_GetIntegerv(gli, GR_GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &maxSamplers);
325 glslCaps->fMaxCombinedSamplers = SkTMin<GrGLint>(kMaxSaneSamplers, maxSamplers);
326
egdaniel05ded892015-10-26 07:38:05 -0700327 /**************************************************************************
bsalomon4b91f762015-05-19 09:29:46 -0700328 * GrCaps fields
bsalomon@google.combcce8922013-03-25 15:38:39 +0000329 **************************************************************************/
cdalton4cd67132015-06-10 19:23:46 -0700330
cdalton63f6c1f2015-11-06 07:09:43 -0800331 // We need dual source blending and the ability to disable multisample in order to support mixed
332 // samples in every corner case.
egdanieleed519e2016-01-15 11:36:18 -0800333 if (fMultisampleDisableSupport &&
334 glslCaps->dualSourceBlendingSupport() &&
335 fShaderCaps->pathRenderingSupport()) {
336 fUsesMixedSamples = ctxInfo.hasExtension("GL_NV_framebuffer_mixed_samples") ||
kkinnunenea409432015-12-10 01:21:59 -0800337 ctxInfo.hasExtension("GL_CHROMIUM_framebuffer_mixed_samples");
cdalton63f6c1f2015-11-06 07:09:43 -0800338 // Workaround NVIDIA bug related to glInvalidateFramebuffer and mixed samples.
kkinnunen9f63b442016-01-25 00:31:49 -0800339 if (fUsesMixedSamples && (kNVIDIA_GrGLDriver == ctxInfo.driver() ||
340 kChromium_GrGLDriver == ctxInfo.driver())) {
cdalton63f6c1f2015-11-06 07:09:43 -0800341 fDiscardRenderTargetSupport = false;
342 fInvalidateFBType = kNone_InvalidateFBType;
343 }
344 }
345
egdanieleed519e2016-01-15 11:36:18 -0800346 // fUsesMixedSamples must be set before calling initFSAASupport.
cdalton4cd67132015-06-10 19:23:46 -0700347 this->initFSAASupport(ctxInfo, gli);
cdalton1dd05422015-06-12 09:01:18 -0700348 this->initBlendEqationSupport(ctxInfo);
cdalton4cd67132015-06-10 19:23:46 -0700349 this->initStencilFormats(ctxInfo);
350
commit-bot@chromium.org9e90aed2014-01-16 16:35:09 +0000351 if (kGL_GrGLStandard == standard) {
bsalomon@google.combcce8922013-03-25 15:38:39 +0000352 // we could also look for GL_ATI_separate_stencil extension or
353 // GL_EXT_stencil_two_side but they use different function signatures
354 // than GL2.0+ (and than each other).
355 fTwoSidedStencilSupport = (ctxInfo.version() >= GR_GL_VER(2,0));
356 // supported on GL 1.4 and higher or by extension
357 fStencilWrapOpsSupport = (ctxInfo.version() >= GR_GL_VER(1,4)) ||
358 ctxInfo.hasExtension("GL_EXT_stencil_wrap");
359 } else {
360 // ES 2 has two sided stencil and stencil wrap
361 fTwoSidedStencilSupport = true;
362 fStencilWrapOpsSupport = true;
363 }
364
commit-bot@chromium.org9e90aed2014-01-16 16:35:09 +0000365 if (kGL_GrGLStandard == standard) {
commit-bot@chromium.org160b4782014-05-05 12:32:37 +0000366 fMapBufferFlags = kCanMap_MapFlag; // we require VBO support and the desktop VBO
367 // extension includes glMapBuffer.
368 if (version >= GR_GL_VER(3, 0) || ctxInfo.hasExtension("GL_ARB_map_buffer_range")) {
369 fMapBufferFlags |= kSubset_MapFlag;
370 fMapBufferType = kMapBufferRange_MapBufferType;
371 } else {
372 fMapBufferType = kMapBuffer_MapBufferType;
373 }
bsalomon@google.combcce8922013-03-25 15:38:39 +0000374 } else {
commit-bot@chromium.org160b4782014-05-05 12:32:37 +0000375 // Unextended GLES2 doesn't have any buffer mapping.
376 fMapBufferFlags = kNone_MapBufferType;
kkinnunenf655e932016-03-03 07:39:48 -0800377 if (ctxInfo.hasExtension("GL_CHROMIUM_map_sub")) {
kkinnunen45c2c812016-02-25 02:03:43 -0800378 fMapBufferFlags = kCanMap_MapFlag | kSubset_MapFlag;
379 fMapBufferType = kChromium_MapBufferType;
kkinnunenf655e932016-03-03 07:39:48 -0800380 } else if (version >= GR_GL_VER(3, 0) || ctxInfo.hasExtension("GL_EXT_map_buffer_range")) {
381 fMapBufferFlags = kCanMap_MapFlag | kSubset_MapFlag;
382 fMapBufferType = kMapBufferRange_MapBufferType;
commit-bot@chromium.org160b4782014-05-05 12:32:37 +0000383 } else if (ctxInfo.hasExtension("GL_OES_mapbuffer")) {
384 fMapBufferFlags = kCanMap_MapFlag;
385 fMapBufferType = kMapBuffer_MapBufferType;
386 }
bsalomon@google.combcce8922013-03-25 15:38:39 +0000387 }
388
jvanverthd7a2c1f2015-12-07 07:36:44 -0800389 if (kGL_GrGLStandard == standard) {
390 if (version >= GR_GL_VER(3, 0) || ctxInfo.hasExtension("GL_ARB_pixel_buffer_object")) {
391 fTransferBufferType = kPBO_TransferBufferType;
halcanary9d524f22016-03-29 09:03:52 -0700392 }
jvanverthd7a2c1f2015-12-07 07:36:44 -0800393 } else {
394 if (version >= GR_GL_VER(3, 0) || ctxInfo.hasExtension("GL_NV_pixel_buffer_object")) {
395 fTransferBufferType = kPBO_TransferBufferType;
jvanverthc3d706f2016-04-20 10:33:27 -0700396 } else if (ctxInfo.hasExtension("GL_CHROMIUM_pixel_transfer_buffer_object")) {
397 fTransferBufferType = kChromium_TransferBufferType;
jvanverthd7a2c1f2015-12-07 07:36:44 -0800398 }
399 }
400
joshualitte5b74c62015-06-01 14:17:47 -0700401 // On many GPUs, map memory is very expensive, so we effectively disable it here by setting the
402 // threshold to the maximum unless the client gives us a hint that map memory is cheap.
cdalton397536c2016-03-25 12:15:03 -0700403 if (fBufferMapThreshold < 0) {
bsalomonbc233752015-06-26 11:38:25 -0700404 // We think mapping on Chromium will be cheaper once we know ahead of time how much space
405 // we will use for all GrBatchs. Right now we might wind up mapping a large buffer and using
406 // a small subset.
407#if 0
cdalton397536c2016-03-25 12:15:03 -0700408 fBufferMapThreshold = kChromium_GrGLDriver == ctxInfo.driver() ? 0 : SK_MaxS32;
bsalomonbc233752015-06-26 11:38:25 -0700409#else
cdalton397536c2016-03-25 12:15:03 -0700410 fBufferMapThreshold = SK_MaxS32;
bsalomonbc233752015-06-26 11:38:25 -0700411#endif
joshualitte5b74c62015-06-01 14:17:47 -0700412 }
413
commit-bot@chromium.org9e90aed2014-01-16 16:35:09 +0000414 if (kGL_GrGLStandard == standard) {
commit-bot@chromium.org47442312013-12-19 16:18:01 +0000415 SkASSERT(ctxInfo.version() >= GR_GL_VER(2,0) ||
416 ctxInfo.hasExtension("GL_ARB_texture_non_power_of_two"));
417 fNPOTTextureTileSupport = true;
418 fMipMapSupport = true;
bsalomon@google.combcce8922013-03-25 15:38:39 +0000419 } else {
420 // Unextended ES2 supports NPOT textures with clamp_to_edge and non-mip filters only
commit-bot@chromium.org22dd6b92013-08-16 18:13:48 +0000421 // ES3 has no limitations.
422 fNPOTTextureTileSupport = ctxInfo.version() >= GR_GL_VER(3,0) ||
423 ctxInfo.hasExtension("GL_OES_texture_npot");
commit-bot@chromium.org47442312013-12-19 16:18:01 +0000424 // ES2 supports MIP mapping for POT textures but our caps don't allow for limited MIP
425 // support. The OES extension or ES 3.0 allow for MIPS on NPOT textures. So, apparently,
426 // does the undocumented GL_IMG_texture_npot extension. This extension does not seem to
427 // to alllow arbitrary wrap modes, however.
428 fMipMapSupport = fNPOTTextureTileSupport || ctxInfo.hasExtension("GL_IMG_texture_npot");
bsalomon@google.combcce8922013-03-25 15:38:39 +0000429 }
430
bsalomone72bd022015-10-26 07:33:03 -0700431 // Using MIPs on this GPU seems to be a source of trouble.
432 if (kPowerVR54x_GrGLRenderer == ctxInfo.renderer()) {
433 fMipMapSupport = false;
434 }
435
bsalomon@google.combcce8922013-03-25 15:38:39 +0000436 GR_GL_GetIntegerv(gli, GR_GL_MAX_TEXTURE_SIZE, &fMaxTextureSize);
437 GR_GL_GetIntegerv(gli, GR_GL_MAX_RENDERBUFFER_SIZE, &fMaxRenderTargetSize);
438 // Our render targets are always created with textures as the color
439 // attachment, hence this min:
commit-bot@chromium.org972f9cd2014-03-28 17:58:28 +0000440 fMaxRenderTargetSize = SkTMin(fMaxTextureSize, fMaxRenderTargetSize);
bsalomon@google.combcce8922013-03-25 15:38:39 +0000441
commit-bot@chromium.orga3baf3b2014-02-21 18:45:30 +0000442 fGpuTracingSupport = ctxInfo.hasExtension("GL_EXT_debug_marker");
443
robertphillips@google.com8995b7b2013-11-01 15:03:34 +0000444 // Disable scratch texture reuse on Mali and Adreno devices
445 fReuseScratchTextures = kARM_GrGLVendor != ctxInfo.vendor() &&
446 kQualcomm_GrGLVendor != ctxInfo.vendor();
commit-bot@chromium.orgb8356522013-07-18 22:26:39 +0000447
robertphillips1b8e1b52015-06-24 06:54:10 -0700448#if 0
449 fReuseScratchBuffers = kARM_GrGLVendor != ctxInfo.vendor() &&
450 kQualcomm_GrGLVendor != ctxInfo.vendor();
451#endif
452
egdaniel05ded892015-10-26 07:38:05 -0700453 // initFSAASupport() must have been called before this point
bsalomon@google.com347c3822013-05-01 20:10:01 +0000454 if (GrGLCaps::kES_IMG_MsToTexture_MSFBOType == fMSFBOType) {
cdaltonaf8bc7d2016-02-05 09:35:20 -0800455 GR_GL_GetIntegerv(gli, GR_GL_MAX_SAMPLES_IMG, &fMaxStencilSampleCount);
bsalomon@google.combcce8922013-03-25 15:38:39 +0000456 } else if (GrGLCaps::kNone_MSFBOType != fMSFBOType) {
cdaltonaf8bc7d2016-02-05 09:35:20 -0800457 GR_GL_GetIntegerv(gli, GR_GL_MAX_SAMPLES, &fMaxStencilSampleCount);
bsalomon@google.combcce8922013-03-25 15:38:39 +0000458 }
cdaltonaf8bc7d2016-02-05 09:35:20 -0800459 // We only have a use for raster multisample if there is coverage modulation from mixed samples.
460 if (fUsesMixedSamples && ctxInfo.hasExtension("GL_EXT_raster_multisample")) {
461 GR_GL_GetIntegerv(gli, GR_GL_MAX_RASTER_SAMPLES, &fMaxRasterSamples);
462 // This is to guard against platforms that may not support as many samples for
463 // glRasterSamples as they do for framebuffers.
464 fMaxStencilSampleCount = SkTMin(fMaxStencilSampleCount, fMaxRasterSamples);
465 }
466 fMaxColorSampleCount = fMaxStencilSampleCount;
commit-bot@chromium.org73880512013-10-14 15:33:45 +0000467
bsalomon63b21962014-11-05 07:05:34 -0800468 if (kPowerVR54x_GrGLRenderer == ctxInfo.renderer() ||
bsalomone702d972015-01-29 10:07:32 -0800469 kPowerVRRogue_GrGLRenderer == ctxInfo.renderer() ||
bsalomona8fcea02015-02-13 09:00:39 -0800470 kAdreno3xx_GrGLRenderer == ctxInfo.renderer()) {
bsalomon63b21962014-11-05 07:05:34 -0800471 fUseDrawInsteadOfClear = true;
472 }
473
joshualitt83bc2292015-06-18 14:18:02 -0700474 if (kAdreno4xx_GrGLRenderer == ctxInfo.renderer()) {
475 fUseDrawInsteadOfPartialRenderTargetWrite = true;
476 }
477
bsalomonbabafcc2016-02-16 11:36:47 -0800478 // Texture uploads sometimes seem to be ignored to textures bound to FBOS on Tegra3.
479 if (kTegra3_GrGLRenderer == ctxInfo.renderer()) {
480 fUseDrawInsteadOfPartialRenderTargetWrite = true;
481 fUseDrawInsteadOfAllRenderTargetWrites = true;
482 }
483
robertphillips63926682015-08-20 09:39:02 -0700484#ifdef SK_BUILD_FOR_WIN
485 // On ANGLE deferring flushes can lead to GPU starvation
486 fPreferVRAMUseOverFlushes = !isANGLE;
487#endif
488
bsalomon7dea7b72015-08-19 08:26:51 -0700489 if (kChromium_GrGLDriver == ctxInfo.driver()) {
490 fMustClearUploadedBufferData = true;
491 }
492
bsalomond08ea5f2015-02-20 06:58:13 -0800493 if (kGL_GrGLStandard == standard) {
494 // ARB allows mixed size FBO attachments, EXT does not.
495 if (ctxInfo.version() >= GR_GL_VER(3, 0) ||
496 ctxInfo.hasExtension("GL_ARB_framebuffer_object")) {
497 fOversizedStencilSupport = true;
498 } else {
499 SkASSERT(ctxInfo.hasExtension("GL_EXT_framebuffer_object"));
500 }
501 } else {
502 // ES 3.0 supports mixed size FBO attachments, 2.0 does not.
503 fOversizedStencilSupport = ctxInfo.version() >= GR_GL_VER(3, 0);
504 }
505
joshualitt58001552015-06-26 12:46:36 -0700506 if (kGL_GrGLStandard == standard) {
507 // 3.1 has draw_instanced but not instanced_arrays, for the time being we only care about
508 // instanced arrays, but we could make this more granular if we wanted
509 fSupportsInstancedDraws =
510 version >= GR_GL_VER(3, 2) ||
511 (ctxInfo.hasExtension("GL_ARB_draw_instanced") &&
512 ctxInfo.hasExtension("GL_ARB_instanced_arrays"));
513 } else {
514 fSupportsInstancedDraws =
515 version >= GR_GL_VER(3, 0) ||
516 (ctxInfo.hasExtension("GL_EXT_draw_instanced") &&
517 ctxInfo.hasExtension("GL_EXT_instanced_arrays"));
518 }
519
cdalton06604b92016-02-05 10:09:51 -0800520 if (kGL_GrGLStandard == standard) {
521 // We don't use ARB_draw_indirect because it does not support a base instance.
522 // We don't use ARB_multi_draw_indirect because it does not support GL_DRAW_INDIRECT_BUFFER.
523 fDrawIndirectSupport =
524 fMultiDrawIndirectSupport = fBaseInstanceSupport = version >= GR_GL_VER(4,3);
525 } else {
526 fDrawIndirectSupport = version >= GR_GL_VER(3,1);
527 fMultiDrawIndirectSupport = ctxInfo.hasExtension("GL_EXT_multi_draw_indirect");
528 fBaseInstanceSupport = ctxInfo.hasExtension("GL_EXT_base_instance");
529 }
530
jvanverthcba99b82015-06-24 06:59:57 -0700531 this->initShaderPrecisionTable(ctxInfo, gli, glslCaps);
bsalomoncdee0092016-01-08 13:20:12 -0800532
533 if (contextOptions.fUseShaderSwizzling) {
534 fTextureSwizzleSupport = false;
535 }
536
ethannicholas28ef4452016-03-25 09:26:03 -0700537 if (kGL_GrGLStandard == standard) {
ethannicholas6536ae52016-05-02 12:16:49 -0700538 if ((version >= GR_GL_VER(4, 0) || ctxInfo.hasExtension("GL_ARB_sample_shading")) &&
539 ctxInfo.vendor() != kIntel_GrGLVendor) {
ethannicholas28ef4452016-03-25 09:26:03 -0700540 fSampleShadingSupport = true;
541 }
542 } else if (ctxInfo.hasExtension("GL_OES_sample_shading")) {
543 fSampleShadingSupport = true;
544 }
545
bsalomoncdee0092016-01-08 13:20:12 -0800546 // Requires fTextureRedSupport, fTextureSwizzleSupport, msaa support, ES compatibility have
547 // already been detected.
548 this->initConfigTable(ctxInfo, gli, glslCaps);
cdalton4cd67132015-06-10 19:23:46 -0700549
550 this->applyOptionsOverrides(contextOptions);
551 glslCaps->applyOptionsOverrides(contextOptions);
commit-bot@chromium.org73880512013-10-14 15:33:45 +0000552}
553
egdaniel472d44e2015-10-22 08:20:00 -0700554const char* get_glsl_version_decl_string(GrGLStandard standard, GrGLSLGeneration generation,
555 bool isCoreProfile) {
556 switch (generation) {
557 case k110_GrGLSLGeneration:
558 if (kGLES_GrGLStandard == standard) {
559 // ES2s shader language is based on version 1.20 but is version
560 // 1.00 of the ES language.
561 return "#version 100\n";
562 } else {
563 SkASSERT(kGL_GrGLStandard == standard);
564 return "#version 110\n";
565 }
566 case k130_GrGLSLGeneration:
567 SkASSERT(kGL_GrGLStandard == standard);
568 return "#version 130\n";
569 case k140_GrGLSLGeneration:
570 SkASSERT(kGL_GrGLStandard == standard);
571 return "#version 140\n";
572 case k150_GrGLSLGeneration:
573 SkASSERT(kGL_GrGLStandard == standard);
574 if (isCoreProfile) {
575 return "#version 150\n";
576 } else {
577 return "#version 150 compatibility\n";
578 }
579 case k330_GrGLSLGeneration:
580 if (kGLES_GrGLStandard == standard) {
581 return "#version 300 es\n";
582 } else {
583 SkASSERT(kGL_GrGLStandard == standard);
584 if (isCoreProfile) {
585 return "#version 330\n";
586 } else {
587 return "#version 330 compatibility\n";
588 }
589 }
cdalton33ad7012016-02-22 07:55:44 -0800590 case k400_GrGLSLGeneration:
591 SkASSERT(kGL_GrGLStandard == standard);
592 if (isCoreProfile) {
593 return "#version 400\n";
594 } else {
595 return "#version 400 compatibility\n";
596 }
egdaniel472d44e2015-10-22 08:20:00 -0700597 case k310es_GrGLSLGeneration:
598 SkASSERT(kGLES_GrGLStandard == standard);
599 return "#version 310 es\n";
cdalton33ad7012016-02-22 07:55:44 -0800600 case k320es_GrGLSLGeneration:
601 SkASSERT(kGLES_GrGLStandard == standard);
602 return "#version 320 es\n";
egdaniel472d44e2015-10-22 08:20:00 -0700603 }
604 return "<no version>";
605}
606
egdaniel05ded892015-10-26 07:38:05 -0700607void GrGLCaps::initGLSL(const GrGLContextInfo& ctxInfo) {
egdaniel472d44e2015-10-22 08:20:00 -0700608 GrGLStandard standard = ctxInfo.standard();
609 GrGLVersion version = ctxInfo.version();
610
611 /**************************************************************************
612 * Caps specific to GrGLSLCaps
613 **************************************************************************/
614
615 GrGLSLCaps* glslCaps = static_cast<GrGLSLCaps*>(fShaderCaps.get());
616 glslCaps->fGLSLGeneration = ctxInfo.glslGeneration();
egdaniel472d44e2015-10-22 08:20:00 -0700617 if (kGLES_GrGLStandard == standard) {
618 if (ctxInfo.hasExtension("GL_EXT_shader_framebuffer_fetch")) {
619 glslCaps->fFBFetchNeedsCustomOutput = (version >= GR_GL_VER(3, 0));
620 glslCaps->fFBFetchSupport = true;
621 glslCaps->fFBFetchColorName = "gl_LastFragData[0]";
622 glslCaps->fFBFetchExtensionString = "GL_EXT_shader_framebuffer_fetch";
623 }
624 else if (ctxInfo.hasExtension("GL_NV_shader_framebuffer_fetch")) {
625 // Actually, we haven't seen an ES3.0 device with this extension yet, so we don't know
626 glslCaps->fFBFetchNeedsCustomOutput = false;
627 glslCaps->fFBFetchSupport = true;
628 glslCaps->fFBFetchColorName = "gl_LastFragData[0]";
629 glslCaps->fFBFetchExtensionString = "GL_NV_shader_framebuffer_fetch";
630 }
631 else if (ctxInfo.hasExtension("GL_ARM_shader_framebuffer_fetch")) {
632 // The arm extension also requires an additional flag which we will set onResetContext
633 glslCaps->fFBFetchNeedsCustomOutput = false;
634 glslCaps->fFBFetchSupport = true;
635 glslCaps->fFBFetchColorName = "gl_LastFragColorARM";
636 glslCaps->fFBFetchExtensionString = "GL_ARM_shader_framebuffer_fetch";
637 }
638 glslCaps->fUsesPrecisionModifiers = true;
639 }
640
641 glslCaps->fBindlessTextureSupport = ctxInfo.hasExtension("GL_NV_bindless_texture");
642
cdaltonc08f1962016-02-12 12:14:06 -0800643 if (kGL_GrGLStandard == standard) {
644 glslCaps->fFlatInterpolationSupport = ctxInfo.glslGeneration() >= k130_GrGLSLGeneration;
645 } else {
646 glslCaps->fFlatInterpolationSupport =
647 ctxInfo.glslGeneration() >= k330_GrGLSLGeneration; // This is the value for GLSL ES 3.0.
648 }
649
650 if (kGL_GrGLStandard == standard) {
651 glslCaps->fNoPerspectiveInterpolationSupport =
652 ctxInfo.glslGeneration() >= k130_GrGLSLGeneration;
653 } else {
654 if (ctxInfo.hasExtension("GL_NV_shader_noperspective_interpolation")) {
655 glslCaps->fNoPerspectiveInterpolationSupport = true;
656 glslCaps->fNoPerspectiveInterpolationExtensionString =
657 "GL_NV_shader_noperspective_interpolation";
658 }
659 }
660
cdalton33ad7012016-02-22 07:55:44 -0800661 if (kGL_GrGLStandard == standard) {
cdalton4a98cdb2016-03-01 12:12:20 -0800662 glslCaps->fMultisampleInterpolationSupport =
663 ctxInfo.glslGeneration() >= k400_GrGLSLGeneration;
664 } else {
665 if (ctxInfo.glslGeneration() >= k320es_GrGLSLGeneration) {
666 glslCaps->fMultisampleInterpolationSupport = true;
667 } else if (ctxInfo.hasExtension("GL_OES_shader_multisample_interpolation")) {
668 glslCaps->fMultisampleInterpolationSupport = true;
669 glslCaps->fMultisampleInterpolationExtensionString =
670 "GL_OES_shader_multisample_interpolation";
671 }
672 }
673
674 if (kGL_GrGLStandard == standard) {
cdalton33ad7012016-02-22 07:55:44 -0800675 glslCaps->fSampleVariablesSupport = ctxInfo.glslGeneration() >= k400_GrGLSLGeneration;
676 } else {
677 if (ctxInfo.glslGeneration() >= k320es_GrGLSLGeneration) {
678 glslCaps->fSampleVariablesSupport = true;
679 } else if (ctxInfo.hasExtension("GL_OES_sample_variables")) {
680 glslCaps->fSampleVariablesSupport = true;
681 glslCaps->fSampleVariablesExtensionString = "GL_OES_sample_variables";
682 }
683 }
684
685 if (glslCaps->fSampleVariablesSupport) {
686 glslCaps->fSampleMaskOverrideCoverageSupport =
687 ctxInfo.hasExtension("GL_NV_sample_mask_override_coverage");
688 }
689
egdaniel472d44e2015-10-22 08:20:00 -0700690 // Adreno GPUs have a tendency to drop tiles when there is a divide-by-zero in a shader
691 glslCaps->fDropsTileOnZeroDivide = kQualcomm_GrGLVendor == ctxInfo.vendor();
692
693 // On the NexusS and GalaxyNexus, the use of 'any' causes the compilation error "Calls to any
694 // function that may require a gradient calculation inside a conditional block may return
695 // undefined results". This appears to be an issue with the 'any' call since even the simple
696 // "result=black; if (any()) result=white;" code fails to compile. This issue comes into play
697 // from our GrTextureDomain processor.
698 glslCaps->fCanUseAnyFunctionInShader = kImagination_GrGLVendor != ctxInfo.vendor();
699
egdaniel472d44e2015-10-22 08:20:00 -0700700 glslCaps->fVersionDeclString = get_glsl_version_decl_string(standard, glslCaps->fGLSLGeneration,
701 fIsCoreProfile);
egdaniel574a4c12015-11-02 06:22:44 -0800702
703 if (kGLES_GrGLStandard == standard && k110_GrGLSLGeneration == glslCaps->fGLSLGeneration) {
704 glslCaps->fShaderDerivativeExtensionString = "GL_OES_standard_derivatives";
705 }
egdaniel8dcdedc2015-11-11 06:27:20 -0800706
707 // Frag Coords Convention support is not part of ES
708 // Known issue on at least some Intel platforms:
709 // http://code.google.com/p/skia/issues/detail?id=946
710 if (kIntel_GrGLVendor != ctxInfo.vendor() &&
711 kGLES_GrGLStandard != standard &&
712 (ctxInfo.glslGeneration() >= k150_GrGLSLGeneration ||
713 ctxInfo.hasExtension("GL_ARB_fragment_coord_conventions"))) {
714 glslCaps->fFragCoordConventionsExtensionString = "GL_ARB_fragment_coord_conventions";
715 }
716
717 if (kGLES_GrGLStandard == standard) {
718 glslCaps->fSecondaryOutputExtensionString = "GL_EXT_blend_func_extended";
719 }
720
cdalton9c3f1432016-03-11 10:07:37 -0800721 if (ctxInfo.hasExtension("GL_OES_EGL_image_external")) {
722 if (ctxInfo.glslGeneration() == k110_GrGLSLGeneration) {
723 glslCaps->fExternalTextureSupport = true;
724 } else if (ctxInfo.hasExtension("GL_OES_EGL_image_external_essl3") ||
725 ctxInfo.hasExtension("OES_EGL_image_external_essl3")) {
726 // At least one driver has been found that has this extension without the "GL_" prefix.
727 glslCaps->fExternalTextureSupport = true;
728 }
729 }
730
731 if (glslCaps->fExternalTextureSupport) {
bsalomon7ea33f52015-11-22 14:51:00 -0800732 if (ctxInfo.glslGeneration() == k110_GrGLSLGeneration) {
733 glslCaps->fExternalTextureExtensionString = "GL_OES_EGL_image_external";
734 } else {
735 glslCaps->fExternalTextureExtensionString = "GL_OES_EGL_image_external_essl3";
736 }
737 }
738
cdaltonc04ce672016-03-11 14:07:38 -0800739 if (kGL_GrGLStandard == standard) {
cdaltonf8a6ce82016-04-11 13:02:05 -0700740 glslCaps->fTexelFetchSupport = ctxInfo.glslGeneration() >= k130_GrGLSLGeneration;
cdaltonc04ce672016-03-11 14:07:38 -0800741 } else {
cdaltonf8a6ce82016-04-11 13:02:05 -0700742 glslCaps->fTexelFetchSupport =
743 ctxInfo.glslGeneration() >= k330_GrGLSLGeneration; // We use this value for GLSL ES 3.0.
744 }
745
746 if (glslCaps->fTexelFetchSupport) {
747 if (kGL_GrGLStandard == standard) {
748 glslCaps->fTexelBufferSupport = ctxInfo.version() >= GR_GL_VER(4, 3) &&
749 ctxInfo.glslGeneration() >= k330_GrGLSLGeneration;
750 } else {
751 if (ctxInfo.version() >= GR_GL_VER(3, 2) &&
752 ctxInfo.glslGeneration() >= k320es_GrGLSLGeneration) {
753 glslCaps->fTexelBufferSupport = true;
754 } else if (ctxInfo.hasExtension("GL_OES_texture_buffer")) {
755 glslCaps->fTexelBufferSupport = true;
756 glslCaps->fTexelBufferExtensionString = "GL_OES_texture_buffer";
757 } else if (ctxInfo.hasExtension("GL_EXT_texture_buffer")) {
758 glslCaps->fTexelBufferSupport = true;
759 glslCaps->fTexelBufferExtensionString = "GL_EXT_texture_buffer";
760 }
cdaltonc04ce672016-03-11 14:07:38 -0800761 }
762 }
763
egdaniel8dcdedc2015-11-11 06:27:20 -0800764 // The Tegra3 compiler will sometimes never return if we have min(abs(x), 1.0), so we must do
765 // the abs first in a separate expression.
766 if (kTegra3_GrGLRenderer == ctxInfo.renderer()) {
767 glslCaps->fCanUseMinAndAbsTogether = false;
768 }
769
bsalomon7ea33f52015-11-22 14:51:00 -0800770 // On Intel GPU there is an issue where it reads the second argument to atan "- %s.x" as an int
egdaniel8dcdedc2015-11-11 06:27:20 -0800771 // thus must us -1.0 * %s.x to work correctly
772 if (kIntel_GrGLVendor == ctxInfo.vendor()) {
773 glslCaps->fMustForceNegatedAtanParamToFloat = true;
774 }
egdaniel472d44e2015-10-22 08:20:00 -0700775}
776
kkinnunencfe62e32015-07-01 02:58:50 -0700777bool GrGLCaps::hasPathRenderingSupport(const GrGLContextInfo& ctxInfo, const GrGLInterface* gli) {
kkinnunen6bb6d402015-07-14 10:59:23 -0700778 bool hasChromiumPathRendering = ctxInfo.hasExtension("GL_CHROMIUM_path_rendering");
779
780 if (!(ctxInfo.hasExtension("GL_NV_path_rendering") || hasChromiumPathRendering)) {
kkinnunencfe62e32015-07-01 02:58:50 -0700781 return false;
782 }
kkinnunen6bb6d402015-07-14 10:59:23 -0700783
kkinnunencfe62e32015-07-01 02:58:50 -0700784 if (kGL_GrGLStandard == ctxInfo.standard()) {
785 if (ctxInfo.version() < GR_GL_VER(4, 3) &&
786 !ctxInfo.hasExtension("GL_ARB_program_interface_query")) {
787 return false;
788 }
789 } else {
kkinnunen6bb6d402015-07-14 10:59:23 -0700790 if (!hasChromiumPathRendering &&
791 ctxInfo.version() < GR_GL_VER(3, 1)) {
kkinnunencfe62e32015-07-01 02:58:50 -0700792 return false;
793 }
794 }
795 // We only support v1.3+ of GL_NV_path_rendering which allows us to
796 // set individual fragment inputs with ProgramPathFragmentInputGen. The API
797 // additions are detected by checking the existence of the function.
798 // We also use *Then* functions that not all drivers might have. Check
799 // them for consistency.
bsalomon9f2dc272016-02-08 07:22:17 -0800800 if (!gli->fFunctions.fStencilThenCoverFillPath ||
801 !gli->fFunctions.fStencilThenCoverStrokePath ||
802 !gli->fFunctions.fStencilThenCoverFillPathInstanced ||
803 !gli->fFunctions.fStencilThenCoverStrokePathInstanced ||
804 !gli->fFunctions.fProgramPathFragmentInputGen) {
kkinnunencfe62e32015-07-01 02:58:50 -0700805 return false;
806 }
807 return true;
808}
bsalomon1aa20292016-01-22 08:16:09 -0800809
810bool GrGLCaps::readPixelsSupported(GrPixelConfig rtConfig,
bsalomon7928ef62016-01-05 10:26:39 -0800811 GrPixelConfig readConfig,
bsalomon1aa20292016-01-22 08:16:09 -0800812 std::function<void (GrGLenum, GrGLint*)> getIntegerv,
813 std::function<bool ()> bindRenderTarget) const {
bsalomone9573312016-01-25 14:33:25 -0800814 // If it's not possible to even have a render target of rtConfig then read pixels is
815 // not supported regardless of readConfig.
816 if (!this->isConfigRenderable(rtConfig, false)) {
817 return false;
818 }
bsalomon7928ef62016-01-05 10:26:39 -0800819
bsalomon76148af2016-01-12 11:13:47 -0800820 GrGLenum readFormat;
821 GrGLenum readType;
bsalomon1aa20292016-01-22 08:16:09 -0800822 if (!this->getReadPixelsFormat(rtConfig, readConfig, &readFormat, &readType)) {
bsalomon76148af2016-01-12 11:13:47 -0800823 return false;
824 }
825
bsalomon1aa20292016-01-22 08:16:09 -0800826 if (kGL_GrGLStandard == fStandard) {
bsalomone9573312016-01-25 14:33:25 -0800827 // Some OpenGL implementations allow GL_ALPHA as a format to glReadPixels. However,
828 // the manual (https://www.opengl.org/sdk/docs/man/) says only these formats are allowed:
829 // GL_STENCIL_INDEX, GL_DEPTH_COMPONENT, GL_DEPTH_STENCIL, GL_RED, GL_GREEN, GL_BLUE,
830 // GL_RGB, GL_BGR, GL_RGBA, and GL_BGRA. We check for the subset that we would use.
831 if (readFormat != GR_GL_RED && readFormat != GR_GL_RGB && readFormat != GR_GL_RGBA &&
832 readFormat != GR_GL_BGRA) {
833 return false;
834 }
835 // There is also a set of allowed types, but all the types we use are in the set:
836 // GL_UNSIGNED_BYTE, GL_BYTE, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT,
837 // GL_HALF_FLOAT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV,
838 // GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4,
839 // GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV,
840 // GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV,GL_UNSIGNED_INT_10_10_10_2,
841 // GL_UNSIGNED_INT_2_10_10_10_REV, GL_UNSIGNED_INT_24_8, GL_UNSIGNED_INT_10F_11F_11F_REV,
842 // GL_UNSIGNED_INT_5_9_9_9_REV, or GL_FLOAT_32_UNSIGNED_INT_24_8_REV.
bsalomon7928ef62016-01-05 10:26:39 -0800843 return true;
piotaixre4b23142014-10-02 10:57:53 -0700844 }
bsalomon7928ef62016-01-05 10:26:39 -0800845
bsalomon76148af2016-01-12 11:13:47 -0800846 // See Section 16.1.2 in the ES 3.2 specification.
bsalomon7928ef62016-01-05 10:26:39 -0800847
bsalomon1aa20292016-01-22 08:16:09 -0800848 if (kNormalizedFixedPoint_FormatType == fConfigTable[rtConfig].fFormatType) {
bsalomon7928ef62016-01-05 10:26:39 -0800849 if (GR_GL_RGBA == readFormat && GR_GL_UNSIGNED_BYTE == readType) {
850 return true;
851 }
852 } else {
bsalomon1aa20292016-01-22 08:16:09 -0800853 SkASSERT(kFloat_FormatType == fConfigTable[rtConfig].fFormatType);
bsalomon7928ef62016-01-05 10:26:39 -0800854 if (GR_GL_RGBA == readFormat && GR_GL_FLOAT == readType) {
855 return true;
856 }
857 }
858
bsalomon1aa20292016-01-22 08:16:09 -0800859 if (0 == fConfigTable[rtConfig].fSecondReadPixelsFormat.fFormat) {
bsalomon7928ef62016-01-05 10:26:39 -0800860 ReadPixelsFormat* rpFormat =
bsalomon1aa20292016-01-22 08:16:09 -0800861 const_cast<ReadPixelsFormat*>(&fConfigTable[rtConfig].fSecondReadPixelsFormat);
bsalomon7928ef62016-01-05 10:26:39 -0800862 GrGLint format = 0, type = 0;
bsalomon1aa20292016-01-22 08:16:09 -0800863 if (!bindRenderTarget()) {
864 return false;
865 }
866 getIntegerv(GR_GL_IMPLEMENTATION_COLOR_READ_FORMAT, &format);
867 getIntegerv(GR_GL_IMPLEMENTATION_COLOR_READ_TYPE, &type);
bsalomon7928ef62016-01-05 10:26:39 -0800868 rpFormat->fFormat = format;
869 rpFormat->fType = type;
870 }
871
bsalomon1aa20292016-01-22 08:16:09 -0800872 return fConfigTable[rtConfig].fSecondReadPixelsFormat.fFormat == readFormat &&
873 fConfigTable[rtConfig].fSecondReadPixelsFormat.fType == readType;
piotaixre4b23142014-10-02 10:57:53 -0700874}
875
robertphillips@google.com6177e692013-02-28 20:16:25 +0000876void GrGLCaps::initFSAASupport(const GrGLContextInfo& ctxInfo, const GrGLInterface* gli) {
bsalomon@google.comf7fa8062012-02-14 14:09:57 +0000877
878 fMSFBOType = kNone_MSFBOType;
commit-bot@chromium.org9e90aed2014-01-16 16:35:09 +0000879 if (kGL_GrGLStandard != ctxInfo.standard()) {
commit-bot@chromium.orga8e5a062013-09-05 23:44:09 +0000880 // We prefer the EXT/IMG extension over ES3 MSAA because we've observed
881 // ES3 driver bugs on at least one device with a tiled GPU (N10).
882 if (ctxInfo.hasExtension("GL_EXT_multisampled_render_to_texture")) {
883 fMSFBOType = kES_EXT_MsToTexture_MSFBOType;
884 } else if (ctxInfo.hasExtension("GL_IMG_multisampled_render_to_texture")) {
885 fMSFBOType = kES_IMG_MsToTexture_MSFBOType;
egdanieleed519e2016-01-15 11:36:18 -0800886 } else if (fUsesMixedSamples) {
vbuzinovdded6962015-06-12 08:59:45 -0700887 fMSFBOType = kMixedSamples_MSFBOType;
commit-bot@chromium.org92b78842014-01-16 20:49:46 +0000888 } else if (ctxInfo.version() >= GR_GL_VER(3,0)) {
commit-bot@chromium.orga8e5a062013-09-05 23:44:09 +0000889 fMSFBOType = GrGLCaps::kES_3_0_MSFBOType;
890 } else if (ctxInfo.hasExtension("GL_CHROMIUM_framebuffer_multisample")) {
891 // chrome's extension is equivalent to the EXT msaa
892 // and fbo_blit extensions.
893 fMSFBOType = kDesktop_EXT_MSFBOType;
894 } else if (ctxInfo.hasExtension("GL_APPLE_framebuffer_multisample")) {
895 fMSFBOType = kES_Apple_MSFBOType;
896 }
bsalomon083617b2016-02-12 12:10:14 -0800897
898 // Above determined the preferred MSAA approach, now decide whether glBlitFramebuffer
899 // is available.
900 if (ctxInfo.version() >= GR_GL_VER(3, 0)) {
901 fBlitFramebufferSupport = kFull_BlitFramebufferSupport;
902 } else if (ctxInfo.hasExtension("GL_CHROMIUM_framebuffer_multisample")) {
903 // The CHROMIUM extension uses the ANGLE version of glBlitFramebuffer and includes its
904 // limitations.
905 fBlitFramebufferSupport = kNoScalingNoMirroring_BlitFramebufferSupport;
906 }
bsalomon@google.comf7fa8062012-02-14 14:09:57 +0000907 } else {
egdanieleed519e2016-01-15 11:36:18 -0800908 if (fUsesMixedSamples) {
vbuzinovdded6962015-06-12 08:59:45 -0700909 fMSFBOType = kMixedSamples_MSFBOType;
bsalomon083617b2016-02-12 12:10:14 -0800910 fBlitFramebufferSupport = kFull_BlitFramebufferSupport;
vbuzinovdded6962015-06-12 08:59:45 -0700911 } else if ((ctxInfo.version() >= GR_GL_VER(3,0)) ||
bsalomon@google.comf7fa8062012-02-14 14:09:57 +0000912 ctxInfo.hasExtension("GL_ARB_framebuffer_object")) {
bsalomon@google.com347c3822013-05-01 20:10:01 +0000913 fMSFBOType = GrGLCaps::kDesktop_ARB_MSFBOType;
bsalomon083617b2016-02-12 12:10:14 -0800914 fBlitFramebufferSupport = kFull_BlitFramebufferSupport;
bsalomon@google.comf7fa8062012-02-14 14:09:57 +0000915 } else if (ctxInfo.hasExtension("GL_EXT_framebuffer_multisample") &&
916 ctxInfo.hasExtension("GL_EXT_framebuffer_blit")) {
bsalomon@google.com347c3822013-05-01 20:10:01 +0000917 fMSFBOType = GrGLCaps::kDesktop_EXT_MSFBOType;
bsalomon083617b2016-02-12 12:10:14 -0800918 fBlitFramebufferSupport = kFull_BlitFramebufferSupport;
bsalomon@google.comf7fa8062012-02-14 14:09:57 +0000919 }
bsalomon@google.comf7fa8062012-02-14 14:09:57 +0000920 }
921}
922
cdalton1dd05422015-06-12 09:01:18 -0700923void GrGLCaps::initBlendEqationSupport(const GrGLContextInfo& ctxInfo) {
924 GrGLSLCaps* glslCaps = static_cast<GrGLSLCaps*>(fShaderCaps.get());
925
926 // Disabling advanced blend on various platforms with major known issues. We also block Chrome
927 // for now until its own blacklists can be updated.
928 if (kAdreno4xx_GrGLRenderer == ctxInfo.renderer() ||
929 kIntel_GrGLDriver == ctxInfo.driver() ||
joel.liang9764c402015-07-09 19:46:18 -0700930 kChromium_GrGLDriver == ctxInfo.driver()) {
cdalton1dd05422015-06-12 09:01:18 -0700931 return;
932 }
933
934 if (ctxInfo.hasExtension("GL_NV_blend_equation_advanced_coherent")) {
935 fBlendEquationSupport = kAdvancedCoherent_BlendEquationSupport;
936 glslCaps->fAdvBlendEqInteraction = GrGLSLCaps::kAutomatic_AdvBlendEqInteraction;
937 } else if (ctxInfo.hasExtension("GL_KHR_blend_equation_advanced_coherent")) {
938 fBlendEquationSupport = kAdvancedCoherent_BlendEquationSupport;
939 glslCaps->fAdvBlendEqInteraction = GrGLSLCaps::kGeneralEnable_AdvBlendEqInteraction;
940 } else if (kNVIDIA_GrGLDriver == ctxInfo.driver() &&
941 ctxInfo.driverVersion() < GR_GL_DRIVER_VER(337,00)) {
942 // Non-coherent advanced blend has an issue on NVIDIA pre 337.00.
943 return;
944 } else if (ctxInfo.hasExtension("GL_NV_blend_equation_advanced")) {
945 fBlendEquationSupport = kAdvanced_BlendEquationSupport;
946 glslCaps->fAdvBlendEqInteraction = GrGLSLCaps::kAutomatic_AdvBlendEqInteraction;
947 } else if (ctxInfo.hasExtension("GL_KHR_blend_equation_advanced")) {
948 fBlendEquationSupport = kAdvanced_BlendEquationSupport;
949 glslCaps->fAdvBlendEqInteraction = GrGLSLCaps::kGeneralEnable_AdvBlendEqInteraction;
950 // TODO: Use kSpecificEnables_AdvBlendEqInteraction if "blend_support_all_equations" is
951 // slow on a particular platform.
952 } else {
953 return; // No advanced blend support.
954 }
955
956 SkASSERT(this->advancedBlendEquationSupport());
957
958 if (kNVIDIA_GrGLDriver == ctxInfo.driver()) {
959 // Blacklist color-dodge and color-burn on NVIDIA until the fix is released.
960 fAdvBlendEqBlacklist |= (1 << kColorDodge_GrBlendEquation) |
961 (1 << kColorBurn_GrBlendEquation);
962 }
joel.liang9764c402015-07-09 19:46:18 -0700963 if (kARM_GrGLVendor == ctxInfo.vendor()) {
964 // Blacklist color-burn on ARM until the fix is released.
965 fAdvBlendEqBlacklist |= (1 << kColorBurn_GrBlendEquation);
966 }
cdalton1dd05422015-06-12 09:01:18 -0700967}
968
bsalomon@google.comf7fa8062012-02-14 14:09:57 +0000969namespace {
egdaniel8dc7c3a2015-04-16 11:22:42 -0700970const GrGLuint kUnknownBitCount = GrGLStencilAttachment::kUnknownBitCount;
bsalomon@google.comf7fa8062012-02-14 14:09:57 +0000971}
972
973void GrGLCaps::initStencilFormats(const GrGLContextInfo& ctxInfo) {
974
975 // Build up list of legal stencil formats (though perhaps not supported on
976 // the particular gpu/driver) from most preferred to least.
977
978 // these consts are in order of most preferred to least preferred
979 // we don't bother with GL_STENCIL_INDEX1 or GL_DEPTH32F_STENCIL8
980
981 static const StencilFormat
982 // internal Format stencil bits total bits packed?
983 gS8 = {GR_GL_STENCIL_INDEX8, 8, 8, false},
984 gS16 = {GR_GL_STENCIL_INDEX16, 16, 16, false},
985 gD24S8 = {GR_GL_DEPTH24_STENCIL8, 8, 32, true },
986 gS4 = {GR_GL_STENCIL_INDEX4, 4, 4, false},
caryclark@google.comcf6285b2012-06-06 12:09:01 +0000987 // gS = {GR_GL_STENCIL_INDEX, kUnknownBitCount, kUnknownBitCount, false},
bsalomon@google.comf7fa8062012-02-14 14:09:57 +0000988 gDS = {GR_GL_DEPTH_STENCIL, kUnknownBitCount, kUnknownBitCount, true };
989
commit-bot@chromium.org9e90aed2014-01-16 16:35:09 +0000990 if (kGL_GrGLStandard == ctxInfo.standard()) {
bsalomon@google.comf7fa8062012-02-14 14:09:57 +0000991 bool supportsPackedDS =
rmistry@google.comfbfcd562012-08-23 18:09:54 +0000992 ctxInfo.version() >= GR_GL_VER(3,0) ||
bsalomon@google.comf7fa8062012-02-14 14:09:57 +0000993 ctxInfo.hasExtension("GL_EXT_packed_depth_stencil") ||
994 ctxInfo.hasExtension("GL_ARB_framebuffer_object");
995
996 // S1 thru S16 formats are in GL 3.0+, EXT_FBO, and ARB_FBO since we
997 // require FBO support we can expect these are legal formats and don't
998 // check. These also all support the unsized GL_STENCIL_INDEX.
999 fStencilFormats.push_back() = gS8;
1000 fStencilFormats.push_back() = gS16;
1001 if (supportsPackedDS) {
1002 fStencilFormats.push_back() = gD24S8;
1003 }
1004 fStencilFormats.push_back() = gS4;
1005 if (supportsPackedDS) {
1006 fStencilFormats.push_back() = gDS;
1007 }
1008 } else {
1009 // ES2 has STENCIL_INDEX8 without extensions but requires extensions
1010 // for other formats.
1011 // ES doesn't support using the unsized format.
1012
1013 fStencilFormats.push_back() = gS8;
1014 //fStencilFormats.push_back() = gS16;
commit-bot@chromium.org04c500f2013-09-06 15:28:01 +00001015 if (ctxInfo.version() >= GR_GL_VER(3,0) ||
1016 ctxInfo.hasExtension("GL_OES_packed_depth_stencil")) {
bsalomon@google.comf7fa8062012-02-14 14:09:57 +00001017 fStencilFormats.push_back() = gD24S8;
1018 }
1019 if (ctxInfo.hasExtension("GL_OES_stencil4")) {
1020 fStencilFormats.push_back() = gS4;
1021 }
1022 }
bsalomon@google.comf7fa8062012-02-14 14:09:57 +00001023}
1024
commit-bot@chromium.org8b656c62013-11-21 15:23:15 +00001025SkString GrGLCaps::dump() const {
bsalomon@google.combcce8922013-03-25 15:38:39 +00001026
commit-bot@chromium.org8b656c62013-11-21 15:23:15 +00001027 SkString r = INHERITED::dump();
bsalomon@google.combcce8922013-03-25 15:38:39 +00001028
commit-bot@chromium.org8b656c62013-11-21 15:23:15 +00001029 r.appendf("--- GL-Specific ---\n");
bsalomon@google.comf7fa8062012-02-14 14:09:57 +00001030 for (int i = 0; i < fStencilFormats.count(); ++i) {
commit-bot@chromium.org8b656c62013-11-21 15:23:15 +00001031 r.appendf("Stencil Format %d, stencil bits: %02d, total bits: %02d\n",
bsalomon@google.comf7fa8062012-02-14 14:09:57 +00001032 i,
1033 fStencilFormats[i].fStencilBits,
1034 fStencilFormats[i].fTotalBits);
1035 }
1036
bsalomon@google.com6b0cf022013-05-03 13:35:14 +00001037 static const char* kMSFBOExtStr[] = {
bsalomon@google.comf7fa8062012-02-14 14:09:57 +00001038 "None",
1039 "ARB",
1040 "EXT",
commit-bot@chromium.orga8e5a062013-09-05 23:44:09 +00001041 "ES 3.0",
bsalomon@google.comf7fa8062012-02-14 14:09:57 +00001042 "Apple",
bsalomon@google.com347c3822013-05-01 20:10:01 +00001043 "IMG MS To Texture",
1044 "EXT MS To Texture",
vbuzinovdded6962015-06-12 08:59:45 -07001045 "MixedSamples",
bsalomon@google.comf7fa8062012-02-14 14:09:57 +00001046 };
bsalomon@google.com6b0cf022013-05-03 13:35:14 +00001047 GR_STATIC_ASSERT(0 == kNone_MSFBOType);
1048 GR_STATIC_ASSERT(1 == kDesktop_ARB_MSFBOType);
1049 GR_STATIC_ASSERT(2 == kDesktop_EXT_MSFBOType);
commit-bot@chromium.orga8e5a062013-09-05 23:44:09 +00001050 GR_STATIC_ASSERT(3 == kES_3_0_MSFBOType);
1051 GR_STATIC_ASSERT(4 == kES_Apple_MSFBOType);
1052 GR_STATIC_ASSERT(5 == kES_IMG_MsToTexture_MSFBOType);
1053 GR_STATIC_ASSERT(6 == kES_EXT_MsToTexture_MSFBOType);
vbuzinovdded6962015-06-12 08:59:45 -07001054 GR_STATIC_ASSERT(7 == kMixedSamples_MSFBOType);
commit-bot@chromium.org972f9cd2014-03-28 17:58:28 +00001055 GR_STATIC_ASSERT(SK_ARRAY_COUNT(kMSFBOExtStr) == kLast_MSFBOType + 1);
bsalomon@google.com6b0cf022013-05-03 13:35:14 +00001056
commit-bot@chromium.org52ffbf62014-04-02 16:19:33 +00001057 static const char* kInvalidateFBTypeStr[] = {
1058 "None",
1059 "Discard",
1060 "Invalidate",
1061 };
1062 GR_STATIC_ASSERT(0 == kNone_InvalidateFBType);
1063 GR_STATIC_ASSERT(1 == kDiscard_InvalidateFBType);
1064 GR_STATIC_ASSERT(2 == kInvalidate_InvalidateFBType);
1065 GR_STATIC_ASSERT(SK_ARRAY_COUNT(kInvalidateFBTypeStr) == kLast_InvalidateFBType + 1);
bsalomon@google.com6b0cf022013-05-03 13:35:14 +00001066
commit-bot@chromium.org160b4782014-05-05 12:32:37 +00001067 static const char* kMapBufferTypeStr[] = {
1068 "None",
1069 "MapBuffer",
1070 "MapBufferRange",
1071 "Chromium",
1072 };
1073 GR_STATIC_ASSERT(0 == kNone_MapBufferType);
1074 GR_STATIC_ASSERT(1 == kMapBuffer_MapBufferType);
1075 GR_STATIC_ASSERT(2 == kMapBufferRange_MapBufferType);
1076 GR_STATIC_ASSERT(3 == kChromium_MapBufferType);
1077 GR_STATIC_ASSERT(SK_ARRAY_COUNT(kMapBufferTypeStr) == kLast_MapBufferType + 1);
1078
commit-bot@chromium.org8b656c62013-11-21 15:23:15 +00001079 r.appendf("Core Profile: %s\n", (fIsCoreProfile ? "YES" : "NO"));
commit-bot@chromium.org8b656c62013-11-21 15:23:15 +00001080 r.appendf("MSAA Type: %s\n", kMSFBOExtStr[fMSFBOType]);
commit-bot@chromium.org52ffbf62014-04-02 16:19:33 +00001081 r.appendf("Invalidate FB Type: %s\n", kInvalidateFBTypeStr[fInvalidateFBType]);
commit-bot@chromium.org160b4782014-05-05 12:32:37 +00001082 r.appendf("Map Buffer Type: %s\n", kMapBufferTypeStr[fMapBufferType]);
commit-bot@chromium.org8b656c62013-11-21 15:23:15 +00001083 r.appendf("Max FS Uniform Vectors: %d\n", fMaxFragmentUniformVectors);
commit-bot@chromium.org8b656c62013-11-21 15:23:15 +00001084 r.appendf("Unpack Row length support: %s\n", (fUnpackRowLengthSupport ? "YES": "NO"));
1085 r.appendf("Unpack Flip Y support: %s\n", (fUnpackFlipYSupport ? "YES": "NO"));
1086 r.appendf("Pack Row length support: %s\n", (fPackRowLengthSupport ? "YES": "NO"));
1087 r.appendf("Pack Flip Y support: %s\n", (fPackFlipYSupport ? "YES": "NO"));
bsalomon@google.combcce8922013-03-25 15:38:39 +00001088
commit-bot@chromium.org8b656c62013-11-21 15:23:15 +00001089 r.appendf("Texture Usage support: %s\n", (fTextureUsageSupport ? "YES": "NO"));
commit-bot@chromium.org8b656c62013-11-21 15:23:15 +00001090 r.appendf("GL_R support: %s\n", (fTextureRedSupport ? "YES": "NO"));
1091 r.appendf("GL_ARB_imaging support: %s\n", (fImagingSupport ? "YES": "NO"));
commit-bot@chromium.org8b656c62013-11-21 15:23:15 +00001092 r.appendf("Vertex array object support: %s\n", (fVertexArrayObjectSupport ? "YES": "NO"));
cdalton626e1ff2015-06-12 13:56:46 -07001093 r.appendf("Direct state access support: %s\n", (fDirectStateAccessSupport ? "YES": "NO"));
1094 r.appendf("Debug support: %s\n", (fDebugSupport ? "YES": "NO"));
cdaltond4727922015-11-10 12:49:06 -08001095 r.appendf("Multisample disable support: %s\n", (fMultisampleDisableSupport ? "YES" : "NO"));
cdalton06604b92016-02-05 10:09:51 -08001096 r.appendf("Draw indirect support: %s\n", (fDrawIndirectSupport ? "YES" : "NO"));
1097 r.appendf("Multi draw indirect support: %s\n", (fMultiDrawIndirectSupport ? "YES" : "NO"));
1098 r.appendf("Base instance support: %s\n", (fBaseInstanceSupport ? "YES" : "NO"));
commit-bot@chromium.org8b656c62013-11-21 15:23:15 +00001099 r.appendf("Use non-VBO for dynamic data: %s\n",
bsalomon@google.combcce8922013-03-25 15:38:39 +00001100 (fUseNonVBOVertexAndIndexDynamicData ? "YES" : "NO"));
robertphillips63926682015-08-20 09:39:02 -07001101 r.appendf("RGBA 8888 pixel ops are slow: %s\n", (fRGBA8888PixelsOpsAreSlow ? "YES" : "NO"));
1102 r.appendf("Partial FBO read is slow: %s\n", (fPartialFBOReadIsSlow ? "YES" : "NO"));
joshualitt7bdd70a2015-10-01 06:28:11 -07001103 r.appendf("Bind uniform location support: %s\n", (fBindUniformLocationSupport ? "YES" : "NO"));
bsalomone5286e02016-01-14 09:24:09 -08001104 r.appendf("Rectangle texture support: %s\n", (fRectangleTextureSupport? "YES" : "NO"));
bsalomoncdee0092016-01-08 13:20:12 -08001105 r.appendf("Texture swizzle support: %s\n", (fTextureSwizzleSupport ? "YES" : "NO"));
halcanary9d524f22016-03-29 09:03:52 -07001106 r.appendf("BGRA to RGBA readback conversions are slow: %s\n",
ericrkb4ecabd2016-03-11 15:18:20 -08001107 (fRGBAToBGRAReadbackConversionsAreSlow ? "YES" : "NO"));
bsalomon41e4384e2016-01-08 09:12:44 -08001108
1109 r.append("Configs\n-------\n");
1110 for (int i = 0; i < kGrPixelConfigCnt; ++i) {
1111 r.appendf(" cfg: %d flags: 0x%04x, b_internal: 0x%08x s_internal: 0x%08x, e_format: "
bsalomon76148af2016-01-12 11:13:47 -08001112 "0x%08x, e_format_teximage: 0x%08x, e_type: 0x%08x, i_for_teximage: 0x%08x, "
1113 "i_for_renderbuffer: 0x%08x\n",
bsalomon41e4384e2016-01-08 09:12:44 -08001114 i,
1115 fConfigTable[i].fFlags,
1116 fConfigTable[i].fFormats.fBaseInternalFormat,
1117 fConfigTable[i].fFormats.fSizedInternalFormat,
bsalomon76148af2016-01-12 11:13:47 -08001118 fConfigTable[i].fFormats.fExternalFormat[kOther_ExternalFormatUsage],
1119 fConfigTable[i].fFormats.fExternalFormat[kTexImage_ExternalFormatUsage],
bsalomon41e4384e2016-01-08 09:12:44 -08001120 fConfigTable[i].fFormats.fExternalType,
1121 fConfigTable[i].fFormats.fInternalFormatTexImage,
bsalomon76148af2016-01-12 11:13:47 -08001122 fConfigTable[i].fFormats.fInternalFormatRenderbuffer);
bsalomon41e4384e2016-01-08 09:12:44 -08001123 }
1124
jvanverthe9c0fc62015-04-29 11:18:05 -07001125 return r;
1126}
1127
jvanverthe9c0fc62015-04-29 11:18:05 -07001128static GrGLenum precision_to_gl_float_type(GrSLPrecision p) {
1129 switch (p) {
1130 case kLow_GrSLPrecision:
1131 return GR_GL_LOW_FLOAT;
1132 case kMedium_GrSLPrecision:
1133 return GR_GL_MEDIUM_FLOAT;
1134 case kHigh_GrSLPrecision:
1135 return GR_GL_HIGH_FLOAT;
1136 }
1137 SkFAIL("Unknown precision.");
1138 return -1;
1139}
1140
1141static GrGLenum shader_type_to_gl_shader(GrShaderType type) {
1142 switch (type) {
1143 case kVertex_GrShaderType:
1144 return GR_GL_VERTEX_SHADER;
1145 case kGeometry_GrShaderType:
1146 return GR_GL_GEOMETRY_SHADER;
1147 case kFragment_GrShaderType:
1148 return GR_GL_FRAGMENT_SHADER;
1149 }
1150 SkFAIL("Unknown shader type.");
1151 return -1;
1152}
1153
jvanverthcba99b82015-06-24 06:59:57 -07001154void GrGLCaps::initShaderPrecisionTable(const GrGLContextInfo& ctxInfo,
halcanary9d524f22016-03-29 09:03:52 -07001155 const GrGLInterface* intf,
jvanverthcba99b82015-06-24 06:59:57 -07001156 GrGLSLCaps* glslCaps) {
jvanverthe9c0fc62015-04-29 11:18:05 -07001157 if (kGLES_GrGLStandard == ctxInfo.standard() || ctxInfo.version() >= GR_GL_VER(4, 1) ||
1158 ctxInfo.hasExtension("GL_ARB_ES2_compatibility")) {
1159 for (int s = 0; s < kGrShaderTypeCount; ++s) {
1160 if (kGeometry_GrShaderType != s) {
1161 GrShaderType shaderType = static_cast<GrShaderType>(s);
1162 GrGLenum glShader = shader_type_to_gl_shader(shaderType);
halcanary96fcdcc2015-08-27 07:41:13 -07001163 GrShaderCaps::PrecisionInfo* first = nullptr;
jvanverthcba99b82015-06-24 06:59:57 -07001164 glslCaps->fShaderPrecisionVaries = false;
jvanverthe9c0fc62015-04-29 11:18:05 -07001165 for (int p = 0; p < kGrSLPrecisionCount; ++p) {
1166 GrSLPrecision precision = static_cast<GrSLPrecision>(p);
1167 GrGLenum glPrecision = precision_to_gl_float_type(precision);
1168 GrGLint range[2];
1169 GrGLint bits;
1170 GR_GL_GetShaderPrecisionFormat(intf, glShader, glPrecision, range, &bits);
1171 if (bits) {
jvanverthcba99b82015-06-24 06:59:57 -07001172 glslCaps->fFloatPrecisions[s][p].fLogRangeLow = range[0];
1173 glslCaps->fFloatPrecisions[s][p].fLogRangeHigh = range[1];
1174 glslCaps->fFloatPrecisions[s][p].fBits = bits;
jvanverthe9c0fc62015-04-29 11:18:05 -07001175 if (!first) {
jvanverthcba99b82015-06-24 06:59:57 -07001176 first = &glslCaps->fFloatPrecisions[s][p];
jvanverthe9c0fc62015-04-29 11:18:05 -07001177 }
jvanverthcba99b82015-06-24 06:59:57 -07001178 else if (!glslCaps->fShaderPrecisionVaries) {
halcanary9d524f22016-03-29 09:03:52 -07001179 glslCaps->fShaderPrecisionVaries =
jvanverthcba99b82015-06-24 06:59:57 -07001180 (*first != glslCaps->fFloatPrecisions[s][p]);
jvanverthe9c0fc62015-04-29 11:18:05 -07001181 }
1182 }
1183 }
1184 }
1185 }
1186 }
1187 else {
1188 // We're on a desktop GL that doesn't have precision info. Assume they're all 32bit float.
jvanverthcba99b82015-06-24 06:59:57 -07001189 glslCaps->fShaderPrecisionVaries = false;
jvanverthe9c0fc62015-04-29 11:18:05 -07001190 for (int s = 0; s < kGrShaderTypeCount; ++s) {
1191 if (kGeometry_GrShaderType != s) {
1192 for (int p = 0; p < kGrSLPrecisionCount; ++p) {
jvanverthcba99b82015-06-24 06:59:57 -07001193 glslCaps->fFloatPrecisions[s][p].fLogRangeLow = 127;
1194 glslCaps->fFloatPrecisions[s][p].fLogRangeHigh = 127;
1195 glslCaps->fFloatPrecisions[s][p].fBits = 23;
jvanverthe9c0fc62015-04-29 11:18:05 -07001196 }
1197 }
1198 }
1199 }
1200 // GetShaderPrecisionFormat doesn't accept GL_GEOMETRY_SHADER as a shader type. Assume they're
1201 // the same as the vertex shader. Only fragment shaders were ever allowed to omit support for
1202 // highp. GS was added after GetShaderPrecisionFormat was added to the list of features that
1203 // are recommended against.
jvanverthcba99b82015-06-24 06:59:57 -07001204 if (glslCaps->fGeometryShaderSupport) {
jvanverthe9c0fc62015-04-29 11:18:05 -07001205 for (int p = 0; p < kGrSLPrecisionCount; ++p) {
halcanary9d524f22016-03-29 09:03:52 -07001206 glslCaps->fFloatPrecisions[kGeometry_GrShaderType][p] =
jvanverthcba99b82015-06-24 06:59:57 -07001207 glslCaps->fFloatPrecisions[kVertex_GrShaderType][p];
jvanverthe9c0fc62015-04-29 11:18:05 -07001208 }
1209 }
cdaltona6b92ad2016-04-11 12:03:08 -07001210 glslCaps->initSamplerPrecisionTable();
jvanverthe9c0fc62015-04-29 11:18:05 -07001211}
1212
bsalomon41e4384e2016-01-08 09:12:44 -08001213bool GrGLCaps::bgraIsInternalFormat() const {
1214 return fConfigTable[kBGRA_8888_GrPixelConfig].fFormats.fBaseInternalFormat == GR_GL_BGRA;
1215}
1216
bsalomon76148af2016-01-12 11:13:47 -08001217bool GrGLCaps::getTexImageFormats(GrPixelConfig surfaceConfig, GrPixelConfig externalConfig,
1218 GrGLenum* internalFormat, GrGLenum* externalFormat,
1219 GrGLenum* externalType) const {
1220 if (!this->getExternalFormat(surfaceConfig, externalConfig, kTexImage_ExternalFormatUsage,
1221 externalFormat, externalType)) {
1222 return false;
1223 }
1224 *internalFormat = fConfigTable[surfaceConfig].fFormats.fInternalFormatTexImage;
1225 return true;
1226}
1227
1228bool GrGLCaps::getCompressedTexImageFormats(GrPixelConfig surfaceConfig,
1229 GrGLenum* internalFormat) const {
1230 if (!GrPixelConfigIsCompressed(surfaceConfig)) {
1231 return false;
1232 }
1233 *internalFormat = fConfigTable[surfaceConfig].fFormats.fInternalFormatTexImage;
1234 return true;
1235}
1236
1237bool GrGLCaps::getReadPixelsFormat(GrPixelConfig surfaceConfig, GrPixelConfig externalConfig,
1238 GrGLenum* externalFormat, GrGLenum* externalType) const {
1239 if (!this->getExternalFormat(surfaceConfig, externalConfig, kOther_ExternalFormatUsage,
1240 externalFormat, externalType)) {
1241 return false;
1242 }
1243 return true;
1244}
1245
1246bool GrGLCaps::getRenderbufferFormat(GrPixelConfig config, GrGLenum* internalFormat) const {
1247 if (GrPixelConfigIsCompressed(config)) {
1248 return false;
1249 }
1250 *internalFormat = fConfigTable[config].fFormats.fInternalFormatRenderbuffer;
1251 return true;
1252}
1253
1254bool GrGLCaps::getExternalFormat(GrPixelConfig surfaceConfig, GrPixelConfig memoryConfig,
1255 ExternalFormatUsage usage, GrGLenum* externalFormat,
1256 GrGLenum* externalType) const {
1257 SkASSERT(externalFormat && externalType);
1258 if (GrPixelConfigIsCompressed(memoryConfig) || GrPixelConfigIsCompressed(memoryConfig)) {
1259 return false;
1260 }
1261
1262 bool surfaceIsAlphaOnly = GrPixelConfigIsAlphaOnly(surfaceConfig);
1263 bool memoryIsAlphaOnly = GrPixelConfigIsAlphaOnly(memoryConfig);
1264
1265 // We don't currently support moving RGBA data into and out of ALPHA surfaces. It could be
1266 // made to work in many cases using glPixelStore and what not but is not needed currently.
1267 if (surfaceIsAlphaOnly && !memoryIsAlphaOnly) {
1268 return false;
1269 }
1270
1271 *externalFormat = fConfigTable[memoryConfig].fFormats.fExternalFormat[usage];
1272 *externalType = fConfigTable[memoryConfig].fFormats.fExternalType;
1273
bsalomone9573312016-01-25 14:33:25 -08001274 // When GL_RED is supported as a texture format, our alpha-only textures are stored using
1275 // GL_RED and we swizzle in order to map all components to 'r'. However, in this case the
1276 // surface is not alpha-only and we want alpha to really mean the alpha component of the
1277 // texture, not the red component.
1278 if (memoryIsAlphaOnly && !surfaceIsAlphaOnly) {
1279 if (this->textureRedSupport()) {
1280 SkASSERT(GR_GL_RED == *externalFormat);
1281 *externalFormat = GR_GL_ALPHA;
1282 }
1283 }
1284
bsalomon76148af2016-01-12 11:13:47 -08001285 return true;
1286}
1287
bsalomoncdee0092016-01-08 13:20:12 -08001288void GrGLCaps::initConfigTable(const GrGLContextInfo& ctxInfo, const GrGLInterface* gli,
1289 GrGLSLCaps* glslCaps) {
bsalomon41e4384e2016-01-08 09:12:44 -08001290 /*
1291 Comments on renderability of configs on various GL versions.
1292 OpenGL < 3.0:
1293 no built in support for render targets.
1294 GL_EXT_framebuffer_object adds possible support for any sized format with base internal
1295 format RGB, RGBA and NV float formats we don't use.
1296 This is the following:
1297 R3_G3_B2, RGB4, RGB5, RGB8, RGB10, RGB12, RGB16, RGBA2, RGBA4, RGB5_A1, RGBA8
1298 RGB10_A2, RGBA12,RGBA16
1299 Though, it is hard to believe the more obscure formats such as RGBA12 would work
1300 since they aren't required by later standards and the driver can simply return
1301 FRAMEBUFFER_UNSUPPORTED for anything it doesn't allow.
1302 GL_ARB_framebuffer_object adds everything added by the EXT extension and additionally
1303 any sized internal format with a base internal format of ALPHA, LUMINANCE,
1304 LUMINANCE_ALPHA, INTENSITY, RED, and RG.
1305 This adds a lot of additional renderable sized formats, including ALPHA8.
1306 The GL_ARB_texture_rg brings in the RED and RG formats (8, 8I, 8UI, 16, 16I, 16UI,
1307 16F, 32I, 32UI, and 32F variants).
1308 Again, the driver has an escape hatch via FRAMEBUFFER_UNSUPPORTED.
1309
1310 For both the above extensions we limit ourselves to those that are also required by
1311 OpenGL 3.0.
1312
1313 OpenGL 3.0:
1314 Any format with base internal format ALPHA, RED, RG, RGB or RGBA is "color-renderable"
1315 but are not required to be supported as renderable textures/renderbuffer.
1316 Required renderable color formats:
1317 - RGBA32F, RGBA32I, RGBA32UI, RGBA16, RGBA16F, RGBA16I,
1318 RGBA16UI, RGBA8, RGBA8I, RGBA8UI, SRGB8_ALPHA8, and
1319 RGB10_A2.
1320 - R11F_G11F_B10F.
1321 - RG32F, RG32I, RG32UI, RG16, RG16F, RG16I, RG16UI, RG8, RG8I,
1322 and RG8UI.
1323 - R32F, R32I, R32UI, R16F, R16I, R16UI, R16, R8, R8I, and R8UI.
1324 - ALPHA8
1325
1326 OpenGL 3.1, 3.2, 3.3
1327 Same as 3.0 except ALPHA8 requires GL_ARB_compatibility/compatibility profile.
1328 OpengGL 3.3, 4.0, 4.1
1329 Adds RGB10_A2UI.
1330 OpengGL 4.2
1331 Adds
1332 - RGB5_A1, RGBA4
1333 - RGB565
1334 OpenGL 4.4
1335 Does away with the separate list and adds a column to the sized internal color format
1336 table. However, no new formats become required color renderable.
1337
1338 ES 2.0
1339 color renderable: RGBA4, RGB5_A1, RGB565
1340 GL_EXT_texture_rg adds support for R8, RG5 as a color render target
1341 GL_OES_rgb8_rgba8 adds support for RGB8 and RGBA8
1342 GL_ARM_rgba8 adds support for RGBA8 (but not RGB8)
1343 GL_EXT_texture_format_BGRA8888 does not add renderbuffer support
1344 GL_CHROMIUM_renderbuffer_format_BGRA8888 adds BGRA8 as color-renderable
1345 GL_APPLE_texture_format_BGRA8888 does not add renderbuffer support
1346
1347 ES 3.0
1348 - RGBA32I, RGBA32UI, RGBA16I, RGBA16UI, RGBA8, RGBA8I,
1349 RGBA8UI, SRGB8_ALPHA8, RGB10_A2, RGB10_A2UI, RGBA4, and
1350 RGB5_A1.
1351 - RGB8 and RGB565.
1352 - RG32I, RG32UI, RG16I, RG16UI, RG8, RG8I, and RG8UI.
1353 - R32I, R32UI, R16I, R16UI, R8, R8I, and R8UI
1354 ES 3.1
1355 Adds RGB10_A2, RGB10_A2UI,
1356 ES 3.2
1357 Adds R16F, RG16F, RGBA16F, R32F, RG32F, RGBA32F, R11F_G11F_B10F.
1358 */
1359 uint32_t allRenderFlags = ConfigInfo::kRenderable_Flag;
1360 if (kNone_MSFBOType != fMSFBOType) {
1361 allRenderFlags |= ConfigInfo::kRenderableWithMSAA_Flag;
1362 }
1363
1364 GrGLStandard standard = ctxInfo.standard();
1365 GrGLVersion version = ctxInfo.version();
1366
cblume790d5132016-02-29 11:13:29 -08001367 bool texStorageSupported = false;
1368 if (kGL_GrGLStandard == standard) {
1369 // The EXT version can apply to either GL or GLES.
1370 texStorageSupported = version >= GR_GL_VER(4,2) ||
1371 ctxInfo.hasExtension("GL_ARB_texture_storage") ||
1372 ctxInfo.hasExtension("GL_EXT_texture_storage");
1373 } else {
1374 // Qualcomm Adreno drivers appear to have issues with texture storage.
1375 texStorageSupported = (version >= GR_GL_VER(3,0) &&
1376 kQualcomm_GrGLVendor != ctxInfo.vendor()) &&
1377 ctxInfo.hasExtension("GL_EXT_texture_storage");
1378 }
1379
1380 // TODO: remove after command buffer supports full ES 3.0
1381 if (kGLES_GrGLStandard == standard && version >= GR_GL_VER(3,0) &&
1382 kChromium_GrGLDriver == ctxInfo.driver()) {
1383 texStorageSupported = false;
1384 }
1385
cdalton74b8d322016-04-11 14:47:28 -07001386 bool texelBufferSupport = this->shaderCaps()->texelBufferSupport();
1387
bsalomon30447372015-12-21 09:03:05 -08001388 fConfigTable[kUnknown_GrPixelConfig].fFormats.fBaseInternalFormat = 0;
1389 fConfigTable[kUnknown_GrPixelConfig].fFormats.fSizedInternalFormat = 0;
bsalomon76148af2016-01-12 11:13:47 -08001390 fConfigTable[kUnknown_GrPixelConfig].fFormats.fExternalFormat[kOther_ExternalFormatUsage] = 0;
bsalomon30447372015-12-21 09:03:05 -08001391 fConfigTable[kUnknown_GrPixelConfig].fFormats.fExternalType = 0;
bsalomon7928ef62016-01-05 10:26:39 -08001392 fConfigTable[kUnknown_GrPixelConfig].fFormatType = kNormalizedFixedPoint_FormatType;
bsalomoncdee0092016-01-08 13:20:12 -08001393 fConfigTable[kUnknown_GrPixelConfig].fSwizzle = GrSwizzle::RGBA();
bsalomon30447372015-12-21 09:03:05 -08001394
1395 fConfigTable[kRGBA_8888_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_RGBA;
1396 fConfigTable[kRGBA_8888_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_RGBA8;
bsalomon76148af2016-01-12 11:13:47 -08001397 fConfigTable[kRGBA_8888_GrPixelConfig].fFormats.fExternalFormat[kOther_ExternalFormatUsage] =
1398 GR_GL_RGBA;
bsalomon30447372015-12-21 09:03:05 -08001399 fConfigTable[kRGBA_8888_GrPixelConfig].fFormats.fExternalType = GR_GL_UNSIGNED_BYTE;
bsalomon7928ef62016-01-05 10:26:39 -08001400 fConfigTable[kRGBA_8888_GrPixelConfig].fFormatType = kNormalizedFixedPoint_FormatType;
bsalomon41e4384e2016-01-08 09:12:44 -08001401 fConfigTable[kRGBA_8888_GrPixelConfig].fFlags = ConfigInfo::kTextureable_Flag;
1402 if (kGL_GrGLStandard == standard) {
1403 // We require some form of FBO support and all GLs with FBO support can render to RGBA8
1404 fConfigTable[kRGBA_8888_GrPixelConfig].fFlags |= allRenderFlags;
egdaniel4999df82016-01-07 17:06:04 -08001405 } else {
bsalomon41e4384e2016-01-08 09:12:44 -08001406 if (version >= GR_GL_VER(3,0) || ctxInfo.hasExtension("GL_OES_rgb8_rgba8") ||
1407 ctxInfo.hasExtension("GL_ARM_rgba8")) {
1408 fConfigTable[kRGBA_8888_GrPixelConfig].fFlags |= allRenderFlags;
1409 }
egdaniel4999df82016-01-07 17:06:04 -08001410 }
cblume790d5132016-02-29 11:13:29 -08001411 if (texStorageSupported) {
1412 fConfigTable[kRGBA_8888_GrPixelConfig].fFlags |= ConfigInfo::kCanUseTexStorage_Flag;
1413 }
cdalton74b8d322016-04-11 14:47:28 -07001414 if (texelBufferSupport) {
1415 fConfigTable[kRGBA_8888_GrPixelConfig].fFlags |= ConfigInfo::kCanUseWithTexelBuffer_Flag;
1416 }
bsalomoncdee0092016-01-08 13:20:12 -08001417 fConfigTable[kRGBA_8888_GrPixelConfig].fSwizzle = GrSwizzle::RGBA();
bsalomon41e4384e2016-01-08 09:12:44 -08001418
bsalomon76148af2016-01-12 11:13:47 -08001419 fConfigTable[kBGRA_8888_GrPixelConfig].fFormats.fExternalFormat[kOther_ExternalFormatUsage] =
1420 GR_GL_BGRA;
bsalomon30447372015-12-21 09:03:05 -08001421 fConfigTable[kBGRA_8888_GrPixelConfig].fFormats.fExternalType = GR_GL_UNSIGNED_BYTE;
bsalomon7928ef62016-01-05 10:26:39 -08001422 fConfigTable[kBGRA_8888_GrPixelConfig].fFormatType = kNormalizedFixedPoint_FormatType;
bsalomon41e4384e2016-01-08 09:12:44 -08001423 if (kGL_GrGLStandard == standard) {
1424 fConfigTable[kBGRA_8888_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_RGBA;
1425 fConfigTable[kBGRA_8888_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_RGBA8;
1426 if (version >= GR_GL_VER(1, 2) || ctxInfo.hasExtension("GL_EXT_bgra")) {
1427 // Since the internal format is RGBA8, it is also renderable.
1428 fConfigTable[kBGRA_8888_GrPixelConfig].fFlags = ConfigInfo::kTextureable_Flag |
1429 allRenderFlags;
1430 }
1431 } else {
1432 fConfigTable[kBGRA_8888_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_BGRA;
1433 fConfigTable[kBGRA_8888_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_BGRA8;
1434 if (ctxInfo.hasExtension("GL_APPLE_texture_format_BGRA8888")) {
1435 // The APPLE extension doesn't make this renderable.
1436 fConfigTable[kBGRA_8888_GrPixelConfig].fFlags = ConfigInfo::kTextureable_Flag;
1437 if (version < GR_GL_VER(3,0) && !ctxInfo.hasExtension("GL_EXT_texture_storage")) {
1438 // On ES2 the internal format of a BGRA texture is RGBA with the APPLE extension.
1439 // Though, that seems to not be the case if the texture storage extension is
1440 // present. The specs don't exactly make that clear.
1441 fConfigTable[kBGRA_8888_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_RGBA;
1442 fConfigTable[kBGRA_8888_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_RGBA8;
1443 }
1444 } else if (ctxInfo.hasExtension("GL_EXT_texture_format_BGRA8888")) {
1445 fConfigTable[kBGRA_8888_GrPixelConfig].fFlags = ConfigInfo::kTextureable_Flag |
1446 ConfigInfo::kRenderable_Flag;
1447 if (ctxInfo.hasExtension("GL_CHROMIUM_renderbuffer_format_BGRA8888") &&
kkinnunen9f63b442016-01-25 00:31:49 -08001448 (this->usesMSAARenderBuffers() || this->fMSFBOType == kMixedSamples_MSFBOType)) {
bsalomon41e4384e2016-01-08 09:12:44 -08001449 fConfigTable[kBGRA_8888_GrPixelConfig].fFlags |=
1450 ConfigInfo::kRenderableWithMSAA_Flag;
1451 }
1452 }
1453 }
cblume790d5132016-02-29 11:13:29 -08001454 if (texStorageSupported) {
1455 fConfigTable[kBGRA_8888_GrPixelConfig].fFlags |= ConfigInfo::kCanUseTexStorage_Flag;
1456 }
bsalomoncdee0092016-01-08 13:20:12 -08001457 fConfigTable[kBGRA_8888_GrPixelConfig].fSwizzle = GrSwizzle::RGBA();
bsalomon30447372015-12-21 09:03:05 -08001458
brianosmana6359362016-03-21 06:55:37 -07001459 // We only enable srgb support if both textures and FBOs support srgb,
brianosman64d094d2016-03-25 06:01:59 -07001460 // *and* we can disable sRGB decode-on-read, to support "legacy" mode,
1461 // *and* we can disable sRGB encode-on-write.
bsalomon41e4384e2016-01-08 09:12:44 -08001462 if (kGL_GrGLStandard == standard) {
1463 if (ctxInfo.version() >= GR_GL_VER(3,0)) {
brianosmana6359362016-03-21 06:55:37 -07001464 fSRGBSupport = true;
bsalomon41e4384e2016-01-08 09:12:44 -08001465 } else if (ctxInfo.hasExtension("GL_EXT_texture_sRGB")) {
1466 if (ctxInfo.hasExtension("GL_ARB_framebuffer_sRGB") ||
1467 ctxInfo.hasExtension("GL_EXT_framebuffer_sRGB")) {
brianosmana6359362016-03-21 06:55:37 -07001468 fSRGBSupport = true;
bsalomon41e4384e2016-01-08 09:12:44 -08001469 }
1470 }
1471 // All the above srgb extensions support toggling srgb writes
bsalomon41e4384e2016-01-08 09:12:44 -08001472 } else {
1473 // See https://bug.skia.org/4148 for PowerVR issue.
brianosmana6359362016-03-21 06:55:37 -07001474 fSRGBSupport = kPowerVRRogue_GrGLRenderer != ctxInfo.renderer() &&
bsalomon41e4384e2016-01-08 09:12:44 -08001475 (ctxInfo.version() >= GR_GL_VER(3,0) || ctxInfo.hasExtension("GL_EXT_sRGB"));
1476 // ES through 3.1 requires EXT_srgb_write_control to support toggling
1477 // sRGB writing for destinations.
brianosman64d094d2016-03-25 06:01:59 -07001478 fSRGBSupport = fSRGBSupport && ctxInfo.hasExtension("GL_EXT_sRGB_write_control");
bsalomon41e4384e2016-01-08 09:12:44 -08001479 }
brianosmana6359362016-03-21 06:55:37 -07001480 if (!ctxInfo.hasExtension("GL_EXT_texture_sRGB_decode")) {
1481 // To support "legacy" L32 mode, we require the ability to turn off sRGB decode:
1482 fSRGBSupport = false;
1483 }
bsalomon30447372015-12-21 09:03:05 -08001484 fConfigTable[kSRGBA_8888_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_SRGB_ALPHA;
1485 fConfigTable[kSRGBA_8888_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_SRGB8_ALPHA8;
1486 // GL does not do srgb<->rgb conversions when transferring between cpu and gpu. Thus, the
1487 // external format is GL_RGBA. See below for note about ES2.0 and glTex[Sub]Image.
bsalomon76148af2016-01-12 11:13:47 -08001488 fConfigTable[kSRGBA_8888_GrPixelConfig].fFormats.fExternalFormat[kOther_ExternalFormatUsage] =
1489 GR_GL_RGBA;
bsalomon30447372015-12-21 09:03:05 -08001490 fConfigTable[kSRGBA_8888_GrPixelConfig].fFormats.fExternalType = GR_GL_UNSIGNED_BYTE;
bsalomon7928ef62016-01-05 10:26:39 -08001491 fConfigTable[kSRGBA_8888_GrPixelConfig].fFormatType = kNormalizedFixedPoint_FormatType;
brianosmana6359362016-03-21 06:55:37 -07001492 if (fSRGBSupport) {
bsalomon41e4384e2016-01-08 09:12:44 -08001493 fConfigTable[kSRGBA_8888_GrPixelConfig].fFlags = ConfigInfo::kTextureable_Flag |
1494 allRenderFlags;
1495 }
cblume790d5132016-02-29 11:13:29 -08001496 if (texStorageSupported) {
1497 fConfigTable[kSRGBA_8888_GrPixelConfig].fFlags |= ConfigInfo::kCanUseTexStorage_Flag;
1498 }
bsalomoncdee0092016-01-08 13:20:12 -08001499 fConfigTable[kSRGBA_8888_GrPixelConfig].fSwizzle = GrSwizzle::RGBA();
bsalomon30447372015-12-21 09:03:05 -08001500
brianosmana6359362016-03-21 06:55:37 -07001501 // sBGRA is not a "real" thing in OpenGL, but GPUs support it, and on platforms where
1502 // kN32 == BGRA, we need some way to work with it. (The default framebuffer on Windows
1503 // is in this format, for example).
1504 fConfigTable[kSBGRA_8888_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_SRGB_ALPHA;
1505 fConfigTable[kSBGRA_8888_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_SRGB8_ALPHA8;
1506 // GL does not do srgb<->rgb conversions when transferring between cpu and gpu. Thus, the
1507 // external format is GL_BGRA.
1508 fConfigTable[kSBGRA_8888_GrPixelConfig].fFormats.fExternalFormat[kOther_ExternalFormatUsage] =
1509 GR_GL_BGRA;
1510 fConfigTable[kSBGRA_8888_GrPixelConfig].fFormats.fExternalType = GR_GL_UNSIGNED_BYTE;
1511 fConfigTable[kSBGRA_8888_GrPixelConfig].fFormatType = kNormalizedFixedPoint_FormatType;
1512 if (fSRGBSupport) {
1513 fConfigTable[kSBGRA_8888_GrPixelConfig].fFlags = ConfigInfo::kTextureable_Flag |
1514 allRenderFlags;
1515 }
1516 if (texStorageSupported) {
1517 fConfigTable[kSBGRA_8888_GrPixelConfig].fFlags |= ConfigInfo::kCanUseTexStorage_Flag;
1518 }
1519 fConfigTable[kSBGRA_8888_GrPixelConfig].fSwizzle = GrSwizzle::RGBA();
1520
bsalomon30447372015-12-21 09:03:05 -08001521 fConfigTable[kRGB_565_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_RGB;
1522 if (this->ES2CompatibilitySupport()) {
1523 fConfigTable[kRGB_565_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_RGB565;
1524 } else {
1525 fConfigTable[kRGB_565_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_RGB5;
1526 }
bsalomon76148af2016-01-12 11:13:47 -08001527 fConfigTable[kRGB_565_GrPixelConfig].fFormats.fExternalFormat[kOther_ExternalFormatUsage] =
1528 GR_GL_RGB;
bsalomon30447372015-12-21 09:03:05 -08001529 fConfigTable[kRGB_565_GrPixelConfig].fFormats.fExternalType = GR_GL_UNSIGNED_SHORT_5_6_5;
bsalomon7928ef62016-01-05 10:26:39 -08001530 fConfigTable[kRGB_565_GrPixelConfig].fFormatType = kNormalizedFixedPoint_FormatType;
bsalomon41e4384e2016-01-08 09:12:44 -08001531 fConfigTable[kRGB_565_GrPixelConfig].fFlags = ConfigInfo::kTextureable_Flag;
1532 if (kGL_GrGLStandard == standard) {
1533 if (version >= GR_GL_VER(4, 2) || ctxInfo.hasExtension("GL_ES2_compatibility")) {
1534 fConfigTable[kRGB_565_GrPixelConfig].fFlags |= allRenderFlags;
1535 }
1536 } else {
1537 fConfigTable[kRGB_565_GrPixelConfig].fFlags |= allRenderFlags;
1538 }
cblume790d5132016-02-29 11:13:29 -08001539 // 565 is not a sized internal format on desktop GL. So on desktop with
1540 // 565 we always use an unsized internal format to let the system pick
1541 // the best sized format to convert the 565 data to. Since TexStorage
1542 // only allows sized internal formats we disallow it.
1543 //
1544 // TODO: As of 4.2, regular GL supports 565. This logic is due for an
1545 // update.
1546 if (texStorageSupported && kGL_GrGLStandard != standard) {
1547 fConfigTable[kRGB_565_GrPixelConfig].fFlags |= ConfigInfo::kCanUseTexStorage_Flag;
1548 }
bsalomoncdee0092016-01-08 13:20:12 -08001549 fConfigTable[kRGB_565_GrPixelConfig].fSwizzle = GrSwizzle::RGBA();
bsalomon30447372015-12-21 09:03:05 -08001550
1551 fConfigTable[kRGBA_4444_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_RGBA;
1552 fConfigTable[kRGBA_4444_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_RGBA4;
bsalomon76148af2016-01-12 11:13:47 -08001553 fConfigTable[kRGBA_4444_GrPixelConfig].fFormats.fExternalFormat[kOther_ExternalFormatUsage] =
1554 GR_GL_RGBA;
bsalomon30447372015-12-21 09:03:05 -08001555 fConfigTable[kRGBA_4444_GrPixelConfig].fFormats.fExternalType = GR_GL_UNSIGNED_SHORT_4_4_4_4;
bsalomon7928ef62016-01-05 10:26:39 -08001556 fConfigTable[kRGBA_4444_GrPixelConfig].fFormatType = kNormalizedFixedPoint_FormatType;
bsalomon41e4384e2016-01-08 09:12:44 -08001557 fConfigTable[kRGBA_4444_GrPixelConfig].fFlags = ConfigInfo::kTextureable_Flag;
1558 if (kGL_GrGLStandard == standard) {
1559 if (version >= GR_GL_VER(4, 2)) {
1560 fConfigTable[kRGBA_4444_GrPixelConfig].fFlags |= allRenderFlags;
1561 }
1562 } else {
1563 fConfigTable[kRGBA_4444_GrPixelConfig].fFlags |= allRenderFlags;
1564 }
cblume790d5132016-02-29 11:13:29 -08001565 if (texStorageSupported) {
1566 fConfigTable[kRGBA_4444_GrPixelConfig].fFlags |= ConfigInfo::kCanUseTexStorage_Flag;
1567 }
bsalomoncdee0092016-01-08 13:20:12 -08001568 fConfigTable[kRGBA_4444_GrPixelConfig].fSwizzle = GrSwizzle::RGBA();
bsalomon30447372015-12-21 09:03:05 -08001569
1570 if (this->textureRedSupport()) {
1571 fConfigTable[kAlpha_8_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_RED;
1572 fConfigTable[kAlpha_8_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_R8;
bsalomon76148af2016-01-12 11:13:47 -08001573 fConfigTable[kAlpha_8_GrPixelConfig].fFormats.fExternalFormat[kOther_ExternalFormatUsage] =
1574 GR_GL_RED;
bsalomoncdee0092016-01-08 13:20:12 -08001575 fConfigTable[kAlpha_8_GrPixelConfig].fSwizzle = GrSwizzle::RRRR();
cdalton74b8d322016-04-11 14:47:28 -07001576 if (texelBufferSupport) {
1577 fConfigTable[kAlpha_8_GrPixelConfig].fFlags |= ConfigInfo::kCanUseWithTexelBuffer_Flag;
1578 }
bsalomon30447372015-12-21 09:03:05 -08001579 } else {
1580 fConfigTable[kAlpha_8_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_ALPHA;
1581 fConfigTable[kAlpha_8_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_ALPHA8;
bsalomon76148af2016-01-12 11:13:47 -08001582 fConfigTable[kAlpha_8_GrPixelConfig].fFormats.fExternalFormat[kOther_ExternalFormatUsage] =
1583 GR_GL_ALPHA;
bsalomoncdee0092016-01-08 13:20:12 -08001584 fConfigTable[kAlpha_8_GrPixelConfig].fSwizzle = GrSwizzle::AAAA();
bsalomon30447372015-12-21 09:03:05 -08001585 }
1586 fConfigTable[kAlpha_8_GrPixelConfig].fFormats.fExternalType = GR_GL_UNSIGNED_BYTE;
bsalomon7928ef62016-01-05 10:26:39 -08001587 fConfigTable[kAlpha_8_GrPixelConfig].fFormatType = kNormalizedFixedPoint_FormatType;
bsalomon41e4384e2016-01-08 09:12:44 -08001588 fConfigTable[kAlpha_8_GrPixelConfig].fFlags = ConfigInfo::kTextureable_Flag;
1589 if (this->textureRedSupport() || kDesktop_ARB_MSFBOType == this->msFBOType()) {
1590 // desktop ARB extension/3.0+ supports ALPHA8 as renderable.
1591 // Core profile removes ALPHA8 support, but we should have chosen R8 in that case.
1592 fConfigTable[kAlpha_8_GrPixelConfig].fFlags |= allRenderFlags;
1593 }
cblume790d5132016-02-29 11:13:29 -08001594 if (texStorageSupported) {
1595 fConfigTable[kAlpha_8_GrPixelConfig].fFlags |= ConfigInfo::kCanUseTexStorage_Flag;
1596 }
bsalomon41e4384e2016-01-08 09:12:44 -08001597
1598 // Check for [half] floating point texture support
1599 // NOTE: We disallow floating point textures on ES devices if linear filtering modes are not
1600 // supported. This is for simplicity, but a more granular approach is possible. Coincidentally,
1601 // [half] floating point textures became part of the standard in ES3.1 / OGL 3.0.
1602 bool hasFPTextures = false;
1603 bool hasHalfFPTextures = false;
1604 // for now we don't support floating point MSAA on ES
1605 uint32_t fpRenderFlags = (kGL_GrGLStandard == standard) ?
1606 allRenderFlags : (uint32_t)ConfigInfo::kRenderable_Flag;
1607
1608 if (kGL_GrGLStandard == standard) {
1609 if (version >= GR_GL_VER(3, 0) || ctxInfo.hasExtension("GL_ARB_texture_float")) {
1610 hasFPTextures = true;
1611 hasHalfFPTextures = true;
1612 }
1613 } else {
1614 if (version >= GR_GL_VER(3, 1)) {
1615 hasFPTextures = true;
1616 hasHalfFPTextures = true;
1617 } else {
1618 if (ctxInfo.hasExtension("GL_OES_texture_float_linear") &&
1619 ctxInfo.hasExtension("GL_OES_texture_float")) {
1620 hasFPTextures = true;
1621 }
1622 if (ctxInfo.hasExtension("GL_OES_texture_half_float_linear") &&
1623 ctxInfo.hasExtension("GL_OES_texture_half_float")) {
1624 hasHalfFPTextures = true;
1625 }
1626 }
1627 }
bsalomon30447372015-12-21 09:03:05 -08001628
1629 fConfigTable[kRGBA_float_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_RGBA;
1630 fConfigTable[kRGBA_float_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_RGBA32F;
bsalomon76148af2016-01-12 11:13:47 -08001631 fConfigTable[kRGBA_float_GrPixelConfig].fFormats.fExternalFormat[kOther_ExternalFormatUsage] =
1632 GR_GL_RGBA;
bsalomon30447372015-12-21 09:03:05 -08001633 fConfigTable[kRGBA_float_GrPixelConfig].fFormats.fExternalType = GR_GL_FLOAT;
bsalomon7928ef62016-01-05 10:26:39 -08001634 fConfigTable[kRGBA_float_GrPixelConfig].fFormatType = kFloat_FormatType;
bsalomon41e4384e2016-01-08 09:12:44 -08001635 if (hasFPTextures) {
1636 fConfigTable[kRGBA_float_GrPixelConfig].fFlags = ConfigInfo::kTextureable_Flag;
1637 // For now we only enable rendering to float on desktop, because on ES we'd have to solve
1638 // many precision issues and no clients actually want this yet.
1639 if (kGL_GrGLStandard == standard /* || version >= GR_GL_VER(3,2) ||
1640 ctxInfo.hasExtension("GL_EXT_color_buffer_float")*/) {
1641 fConfigTable[kRGBA_float_GrPixelConfig].fFlags |= fpRenderFlags;
1642 }
1643 }
cblume790d5132016-02-29 11:13:29 -08001644 if (texStorageSupported) {
1645 fConfigTable[kRGBA_float_GrPixelConfig].fFlags |= ConfigInfo::kCanUseTexStorage_Flag;
1646 }
cdalton74b8d322016-04-11 14:47:28 -07001647 if (texelBufferSupport) {
1648 fConfigTable[kRGBA_float_GrPixelConfig].fFlags |= ConfigInfo::kCanUseWithTexelBuffer_Flag;
1649 }
bsalomoncdee0092016-01-08 13:20:12 -08001650 fConfigTable[kRGBA_float_GrPixelConfig].fSwizzle = GrSwizzle::RGBA();
bsalomon30447372015-12-21 09:03:05 -08001651
1652 if (this->textureRedSupport()) {
1653 fConfigTable[kAlpha_half_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_RED;
1654 fConfigTable[kAlpha_half_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_R16F;
bsalomon76148af2016-01-12 11:13:47 -08001655 fConfigTable[kAlpha_half_GrPixelConfig].fFormats.fExternalFormat[kOther_ExternalFormatUsage]
1656 = GR_GL_RED;
bsalomoncdee0092016-01-08 13:20:12 -08001657 fConfigTable[kAlpha_half_GrPixelConfig].fSwizzle = GrSwizzle::RRRR();
cdalton74b8d322016-04-11 14:47:28 -07001658 if (texelBufferSupport) {
1659 fConfigTable[kAlpha_half_GrPixelConfig].fFlags |=
1660 ConfigInfo::kCanUseWithTexelBuffer_Flag;
1661 }
bsalomon30447372015-12-21 09:03:05 -08001662 } else {
1663 fConfigTable[kAlpha_half_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_ALPHA;
1664 fConfigTable[kAlpha_half_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_ALPHA16F;
bsalomon76148af2016-01-12 11:13:47 -08001665 fConfigTable[kAlpha_half_GrPixelConfig].fFormats.fExternalFormat[kOther_ExternalFormatUsage]
1666 = GR_GL_ALPHA;
bsalomoncdee0092016-01-08 13:20:12 -08001667 fConfigTable[kAlpha_half_GrPixelConfig].fSwizzle = GrSwizzle::AAAA();
bsalomon30447372015-12-21 09:03:05 -08001668 }
1669 if (kGL_GrGLStandard == ctxInfo.standard() || ctxInfo.version() >= GR_GL_VER(3, 0)) {
1670 fConfigTable[kAlpha_half_GrPixelConfig].fFormats.fExternalType = GR_GL_HALF_FLOAT;
1671 } else {
1672 fConfigTable[kAlpha_half_GrPixelConfig].fFormats.fExternalType = GR_GL_HALF_FLOAT_OES;
1673 }
bsalomon7928ef62016-01-05 10:26:39 -08001674 fConfigTable[kAlpha_half_GrPixelConfig].fFormatType = kFloat_FormatType;
bsalomon41e4384e2016-01-08 09:12:44 -08001675 if (hasHalfFPTextures) {
1676 fConfigTable[kAlpha_half_GrPixelConfig].fFlags = ConfigInfo::kTextureable_Flag;
1677 // ES requires either 3.2 or the combination of EXT_color_buffer_half_float and support for
1678 // GL_RED internal format.
1679 if (kGL_GrGLStandard == standard || version >= GR_GL_VER(3,2) ||
1680 (this->textureRedSupport() &&
1681 ctxInfo.hasExtension("GL_EXT_color_buffer_half_float"))) {
1682 fConfigTable[kAlpha_half_GrPixelConfig].fFlags |= fpRenderFlags;
1683 }
1684 }
cblume790d5132016-02-29 11:13:29 -08001685 if (texStorageSupported) {
1686 fConfigTable[kAlpha_half_GrPixelConfig].fFlags |= ConfigInfo::kCanUseTexStorage_Flag;
1687 }
bsalomon30447372015-12-21 09:03:05 -08001688
1689 fConfigTable[kRGBA_half_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_RGBA;
1690 fConfigTable[kRGBA_half_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_RGBA16F;
bsalomon76148af2016-01-12 11:13:47 -08001691 fConfigTable[kRGBA_half_GrPixelConfig].fFormats.fExternalFormat[kOther_ExternalFormatUsage] =
1692 GR_GL_RGBA;
bsalomon30447372015-12-21 09:03:05 -08001693 if (kGL_GrGLStandard == ctxInfo.standard() || ctxInfo.version() >= GR_GL_VER(3, 0)) {
1694 fConfigTable[kRGBA_half_GrPixelConfig].fFormats.fExternalType = GR_GL_HALF_FLOAT;
1695 } else {
1696 fConfigTable[kRGBA_half_GrPixelConfig].fFormats.fExternalType = GR_GL_HALF_FLOAT_OES;
1697 }
bsalomon7928ef62016-01-05 10:26:39 -08001698 fConfigTable[kRGBA_half_GrPixelConfig].fFormatType = kFloat_FormatType;
bsalomon41e4384e2016-01-08 09:12:44 -08001699 if (hasHalfFPTextures) {
1700 fConfigTable[kRGBA_half_GrPixelConfig].fFlags = ConfigInfo::kTextureable_Flag;
1701 // ES requires 3.2 or EXT_color_buffer_half_float.
1702 if (kGL_GrGLStandard == standard || version >= GR_GL_VER(3,2) ||
1703 ctxInfo.hasExtension("GL_EXT_color_buffer_half_float")) {
1704 fConfigTable[kRGBA_half_GrPixelConfig].fFlags |= fpRenderFlags;
1705 }
1706 }
cblume790d5132016-02-29 11:13:29 -08001707 if (texStorageSupported) {
1708 fConfigTable[kRGBA_half_GrPixelConfig].fFlags |= ConfigInfo::kCanUseTexStorage_Flag;
1709 }
cdalton74b8d322016-04-11 14:47:28 -07001710 if (texelBufferSupport) {
1711 fConfigTable[kRGBA_half_GrPixelConfig].fFlags |= ConfigInfo::kCanUseWithTexelBuffer_Flag;
1712 }
bsalomoncdee0092016-01-08 13:20:12 -08001713 fConfigTable[kRGBA_half_GrPixelConfig].fSwizzle = GrSwizzle::RGBA();
bsalomon41e4384e2016-01-08 09:12:44 -08001714
1715 // Compressed texture support
1716
1717 // glCompressedTexImage2D is available on all OpenGL ES devices. It is available on standard
1718 // OpenGL after version 1.3. We'll assume at least that level of OpenGL support.
1719
1720 // TODO: Fix command buffer bindings and remove this.
1721 fCompressedTexSubImageSupport = SkToBool(gli->fFunctions.fCompressedTexSubImage2D);
bsalomon30447372015-12-21 09:03:05 -08001722
1723 // No sized/unsized internal format distinction for compressed formats, no external format.
bsalomon41e4384e2016-01-08 09:12:44 -08001724 // Below we set the external formats and types to 0.
bsalomon30447372015-12-21 09:03:05 -08001725
1726 fConfigTable[kIndex_8_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_PALETTE8_RGBA8;
1727 fConfigTable[kIndex_8_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_PALETTE8_RGBA8;
bsalomon76148af2016-01-12 11:13:47 -08001728 fConfigTable[kIndex_8_GrPixelConfig].fFormats.fExternalFormat[kOther_ExternalFormatUsage] = 0;
bsalomon30447372015-12-21 09:03:05 -08001729 fConfigTable[kIndex_8_GrPixelConfig].fFormats.fExternalType = 0;
bsalomon7928ef62016-01-05 10:26:39 -08001730 fConfigTable[kIndex_8_GrPixelConfig].fFormatType = kNormalizedFixedPoint_FormatType;
bsalomon41e4384e2016-01-08 09:12:44 -08001731 // Disable this for now, while we investigate https://bug.skia.org/4333
1732 if (false) {
1733 // Check for 8-bit palette..
1734 GrGLint numFormats;
1735 GR_GL_GetIntegerv(gli, GR_GL_NUM_COMPRESSED_TEXTURE_FORMATS, &numFormats);
1736 if (numFormats) {
1737 SkAutoSTMalloc<10, GrGLint> formats(numFormats);
1738 GR_GL_GetIntegerv(gli, GR_GL_COMPRESSED_TEXTURE_FORMATS, formats);
1739 for (int i = 0; i < numFormats; ++i) {
1740 if (GR_GL_PALETTE8_RGBA8 == formats[i]) {
1741 fConfigTable[kIndex_8_GrPixelConfig].fFlags = ConfigInfo::kTextureable_Flag;
1742 break;
1743 }
1744 }
1745 }
1746 }
bsalomoncdee0092016-01-08 13:20:12 -08001747 fConfigTable[kIndex_8_GrPixelConfig].fSwizzle = GrSwizzle::RGBA();
bsalomon30447372015-12-21 09:03:05 -08001748
bsalomon41e4384e2016-01-08 09:12:44 -08001749 // May change the internal format based on extensions.
1750 fConfigTable[kLATC_GrPixelConfig].fFormats.fBaseInternalFormat =
1751 GR_GL_COMPRESSED_LUMINANCE_LATC1;
1752 fConfigTable[kLATC_GrPixelConfig].fFormats.fSizedInternalFormat =
1753 GR_GL_COMPRESSED_LUMINANCE_LATC1;
1754 if (ctxInfo.hasExtension("GL_EXT_texture_compression_latc") ||
1755 ctxInfo.hasExtension("GL_NV_texture_compression_latc")) {
1756 fConfigTable[kLATC_GrPixelConfig].fFlags = ConfigInfo::kTextureable_Flag;
1757 } else if ((kGL_GrGLStandard == standard && version >= GR_GL_VER(3, 0)) ||
1758 ctxInfo.hasExtension("GL_EXT_texture_compression_rgtc") ||
1759 ctxInfo.hasExtension("GL_ARB_texture_compression_rgtc")) {
1760 // RGTC is identical and available on OpenGL 3.0+ as well as with extensions
1761 fConfigTable[kLATC_GrPixelConfig].fFlags = ConfigInfo::kTextureable_Flag;
1762 fConfigTable[kLATC_GrPixelConfig].fFormats.fBaseInternalFormat =
1763 GR_GL_COMPRESSED_RED_RGTC1;
1764 fConfigTable[kLATC_GrPixelConfig].fFormats.fSizedInternalFormat =
1765 GR_GL_COMPRESSED_RED_RGTC1;
1766 } else if (ctxInfo.hasExtension("GL_AMD_compressed_3DC_texture")) {
1767 fConfigTable[kLATC_GrPixelConfig].fFlags = ConfigInfo::kTextureable_Flag;
1768 fConfigTable[kLATC_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_COMPRESSED_3DC_X;
1769 fConfigTable[kLATC_GrPixelConfig].fFormats.fSizedInternalFormat =
1770 GR_GL_COMPRESSED_3DC_X;
1771
bsalomon30447372015-12-21 09:03:05 -08001772 }
bsalomon76148af2016-01-12 11:13:47 -08001773 fConfigTable[kLATC_GrPixelConfig].fFormats.fExternalFormat[kOther_ExternalFormatUsage] = 0;
bsalomon30447372015-12-21 09:03:05 -08001774 fConfigTable[kLATC_GrPixelConfig].fFormats.fExternalType = 0;
bsalomon7928ef62016-01-05 10:26:39 -08001775 fConfigTable[kLATC_GrPixelConfig].fFormatType = kNormalizedFixedPoint_FormatType;
bsalomoncdee0092016-01-08 13:20:12 -08001776 fConfigTable[kLATC_GrPixelConfig].fSwizzle = GrSwizzle::RRRR();
bsalomon30447372015-12-21 09:03:05 -08001777
1778 fConfigTable[kETC1_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_COMPRESSED_ETC1_RGB8;
1779 fConfigTable[kETC1_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_COMPRESSED_ETC1_RGB8;
bsalomon76148af2016-01-12 11:13:47 -08001780 fConfigTable[kETC1_GrPixelConfig].fFormats.fExternalFormat[kOther_ExternalFormatUsage] = 0;
bsalomon30447372015-12-21 09:03:05 -08001781 fConfigTable[kETC1_GrPixelConfig].fFormats.fExternalType = 0;
bsalomon7928ef62016-01-05 10:26:39 -08001782 fConfigTable[kETC1_GrPixelConfig].fFormatType = kNormalizedFixedPoint_FormatType;
bsalomon41e4384e2016-01-08 09:12:44 -08001783 if (kGL_GrGLStandard == standard) {
1784 if (version >= GR_GL_VER(4, 3) || ctxInfo.hasExtension("GL_ARB_ES3_compatibility")) {
1785 fConfigTable[kETC1_GrPixelConfig].fFlags = ConfigInfo::kTextureable_Flag;
1786 }
1787 } else {
1788 if (version >= GR_GL_VER(3, 0) ||
1789 ctxInfo.hasExtension("GL_OES_compressed_ETC1_RGB8_texture") ||
1790 // ETC2 is a superset of ETC1, so we can just check for that, too.
1791 (ctxInfo.hasExtension("GL_OES_compressed_ETC2_RGB8_texture") &&
1792 ctxInfo.hasExtension("GL_OES_compressed_ETC2_RGBA8_texture"))) {
1793 fConfigTable[kETC1_GrPixelConfig].fFlags = ConfigInfo::kTextureable_Flag;
1794 }
1795 }
bsalomoncdee0092016-01-08 13:20:12 -08001796 fConfigTable[kETC1_GrPixelConfig].fSwizzle = GrSwizzle::RGBA();
bsalomon30447372015-12-21 09:03:05 -08001797
1798 fConfigTable[kR11_EAC_GrPixelConfig].fFormats.fBaseInternalFormat = GR_GL_COMPRESSED_R11_EAC;
1799 fConfigTable[kR11_EAC_GrPixelConfig].fFormats.fSizedInternalFormat = GR_GL_COMPRESSED_R11_EAC;
bsalomon76148af2016-01-12 11:13:47 -08001800 fConfigTable[kR11_EAC_GrPixelConfig].fFormats.fExternalFormat[kOther_ExternalFormatUsage] = 0;
bsalomon30447372015-12-21 09:03:05 -08001801 fConfigTable[kR11_EAC_GrPixelConfig].fFormats.fExternalType = 0;
bsalomon7928ef62016-01-05 10:26:39 -08001802 fConfigTable[kR11_EAC_GrPixelConfig].fFormatType = kNormalizedFixedPoint_FormatType;
bsalomon41e4384e2016-01-08 09:12:44 -08001803 // Check for R11_EAC. We don't support R11_EAC on desktop, as most cards default to
1804 // decompressing the textures in the driver, and is generally slower.
1805 if (kGLES_GrGLStandard == standard && version >= GR_GL_VER(3,0)) {
1806 fConfigTable[kR11_EAC_GrPixelConfig].fFlags = ConfigInfo::kTextureable_Flag;
1807 }
bsalomoncdee0092016-01-08 13:20:12 -08001808 fConfigTable[kR11_EAC_GrPixelConfig].fSwizzle = GrSwizzle::RRRR();
bsalomon30447372015-12-21 09:03:05 -08001809
1810 fConfigTable[kASTC_12x12_GrPixelConfig].fFormats.fBaseInternalFormat =
1811 GR_GL_COMPRESSED_RGBA_ASTC_12x12;
1812 fConfigTable[kASTC_12x12_GrPixelConfig].fFormats.fSizedInternalFormat =
1813 GR_GL_COMPRESSED_RGBA_ASTC_12x12;
bsalomon76148af2016-01-12 11:13:47 -08001814 fConfigTable[kASTC_12x12_GrPixelConfig].fFormats.fExternalFormat[kOther_ExternalFormatUsage] =
1815 0;
bsalomon30447372015-12-21 09:03:05 -08001816 fConfigTable[kASTC_12x12_GrPixelConfig].fFormats.fExternalType = 0;
bsalomon7928ef62016-01-05 10:26:39 -08001817 fConfigTable[kASTC_12x12_GrPixelConfig].fFormatType = kNormalizedFixedPoint_FormatType;
bsalomon41e4384e2016-01-08 09:12:44 -08001818 if (ctxInfo.hasExtension("GL_KHR_texture_compression_astc_hdr") ||
1819 ctxInfo.hasExtension("GL_KHR_texture_compression_astc_ldr") ||
1820 ctxInfo.hasExtension("GL_OES_texture_compression_astc")) {
1821 fConfigTable[kASTC_12x12_GrPixelConfig].fFlags = ConfigInfo::kTextureable_Flag;
1822 }
bsalomoncdee0092016-01-08 13:20:12 -08001823 fConfigTable[kASTC_12x12_GrPixelConfig].fSwizzle = GrSwizzle::RGBA();
bsalomon30447372015-12-21 09:03:05 -08001824
1825 // Bulk populate the texture internal/external formats here and then deal with exceptions below.
1826
1827 // ES 2.0 requires that the internal/external formats match.
bsalomon76148af2016-01-12 11:13:47 -08001828 bool useSizedTexFormats = (kGL_GrGLStandard == ctxInfo.standard() ||
1829 ctxInfo.version() >= GR_GL_VER(3,0));
1830 // All ES versions (thus far) require sized internal formats for render buffers.
1831 // TODO: Always use sized internal format?
1832 bool useSizedRbFormats = kGLES_GrGLStandard == ctxInfo.standard();
1833
bsalomon30447372015-12-21 09:03:05 -08001834 for (int i = 0; i < kGrPixelConfigCnt; ++i) {
bsalomon76148af2016-01-12 11:13:47 -08001835 // Almost always we want to pass fExternalFormat[kOther_ExternalFormatUsage] as the <format>
1836 // param to glTex[Sub]Image.
1837 fConfigTable[i].fFormats.fExternalFormat[kTexImage_ExternalFormatUsage] =
1838 fConfigTable[i].fFormats.fExternalFormat[kOther_ExternalFormatUsage];
1839 fConfigTable[i].fFormats.fInternalFormatTexImage = useSizedTexFormats ?
1840 fConfigTable[i].fFormats.fSizedInternalFormat :
1841 fConfigTable[i].fFormats.fBaseInternalFormat;
1842 fConfigTable[i].fFormats.fInternalFormatRenderbuffer = useSizedRbFormats ?
bsalomon30447372015-12-21 09:03:05 -08001843 fConfigTable[i].fFormats.fSizedInternalFormat :
1844 fConfigTable[i].fFormats.fBaseInternalFormat;
1845 }
1846 // OpenGL ES 2.0 + GL_EXT_sRGB allows GL_SRGB_ALPHA to be specified as the <format>
1847 // param to Tex(Sub)Image. ES 2.0 requires the <internalFormat> and <format> params to match.
1848 // Thus, on ES 2.0 we will use GL_SRGB_ALPHA as the <format> param.
1849 // On OpenGL and ES 3.0+ GL_SRGB_ALPHA does not work for the <format> param to glTexImage.
1850 if (ctxInfo.standard() == kGLES_GrGLStandard && ctxInfo.version() == GR_GL_VER(2,0)) {
bsalomon76148af2016-01-12 11:13:47 -08001851 fConfigTable[kSRGBA_8888_GrPixelConfig].fFormats.fExternalFormat[kTexImage_ExternalFormatUsage] =
bsalomon30447372015-12-21 09:03:05 -08001852 GR_GL_SRGB_ALPHA;
brianosmana6359362016-03-21 06:55:37 -07001853
1854 // Additionally, because we had to "invent" sBGRA, there is no way to make it work
1855 // in ES 2.0, because there is no <internalFormat> we can use. So just make that format
1856 // unsupported. (If we have no sRGB support at all, this will get overwritten below).
1857 fConfigTable[kSBGRA_8888_GrPixelConfig].fFlags = 0;
bsalomon30447372015-12-21 09:03:05 -08001858 }
1859
1860 // If BGRA is supported as an internal format it must always be specified to glTex[Sub]Image
1861 // as a base format.
1862 // GL_EXT_texture_format_BGRA8888:
1863 // This extension GL_BGRA as an unsized internal format. However, it is written against ES
1864 // 2.0 and therefore doesn't define a value for GL_BGRA8 as ES 2.0 uses unsized internal
1865 // formats.
halcanary9d524f22016-03-29 09:03:52 -07001866 // GL_APPLE_texture_format_BGRA8888:
bsalomon30447372015-12-21 09:03:05 -08001867 // ES 2.0: the extension makes BGRA an external format but not an internal format.
1868 // ES 3.0: the extension explicitly states GL_BGRA8 is not a valid internal format for
1869 // glTexImage (just for glTexStorage).
bsalomon76148af2016-01-12 11:13:47 -08001870 if (useSizedTexFormats && this->bgraIsInternalFormat()) {
bsalomon30447372015-12-21 09:03:05 -08001871 fConfigTable[kBGRA_8888_GrPixelConfig].fFormats.fInternalFormatTexImage = GR_GL_BGRA;
1872 }
1873
bsalomoncdee0092016-01-08 13:20:12 -08001874 // If we don't have texture swizzle support then the shader generator must insert the
1875 // swizzle into shader code.
1876 if (!this->textureSwizzleSupport()) {
1877 for (int i = 0; i < kGrPixelConfigCnt; ++i) {
1878 glslCaps->fConfigTextureSwizzle[i] = fConfigTable[i].fSwizzle;
1879 }
1880 }
1881
bsalomon7f9b2e42016-01-12 13:29:26 -08001882 // Shader output swizzles will default to RGBA. When we've use GL_RED instead of GL_ALPHA to
1883 // implement kAlpha_8_GrPixelConfig we need to swizzle the shader outputs so the alpha channel
1884 // gets written to the single component.
1885 if (this->textureRedSupport()) {
1886 for (int i = 0; i < kGrPixelConfigCnt; ++i) {
1887 GrPixelConfig config = static_cast<GrPixelConfig>(i);
1888 if (GrPixelConfigIsAlphaOnly(config) &&
1889 fConfigTable[i].fFormats.fBaseInternalFormat == GR_GL_RED) {
1890 glslCaps->fConfigOutputSwizzle[i] = GrSwizzle::AAAA();
1891 }
1892 }
1893 }
1894
bsalomon30447372015-12-21 09:03:05 -08001895#ifdef SK_DEBUG
1896 // Make sure we initialized everything.
bsalomon76148af2016-01-12 11:13:47 -08001897 ConfigInfo defaultEntry;
bsalomon30447372015-12-21 09:03:05 -08001898 for (int i = 0; i < kGrPixelConfigCnt; ++i) {
bsalomon76148af2016-01-12 11:13:47 -08001899 SkASSERT(defaultEntry.fFormats.fBaseInternalFormat !=
1900 fConfigTable[i].fFormats.fBaseInternalFormat);
1901 SkASSERT(defaultEntry.fFormats.fSizedInternalFormat !=
bsalomon30447372015-12-21 09:03:05 -08001902 fConfigTable[i].fFormats.fSizedInternalFormat);
bsalomon76148af2016-01-12 11:13:47 -08001903 for (int j = 0; j < kExternalFormatUsageCnt; ++j) {
1904 SkASSERT(defaultEntry.fFormats.fExternalFormat[j] !=
1905 fConfigTable[i].fFormats.fExternalFormat[j]);
1906 }
1907 SkASSERT(defaultEntry.fFormats.fExternalType != fConfigTable[i].fFormats.fExternalType);
bsalomon30447372015-12-21 09:03:05 -08001908 }
1909#endif
1910}
1911
egdanielb7e7d572015-11-04 04:23:53 -08001912void GrGLCaps::onApplyOptionsOverrides(const GrContextOptions& options) {}