1 /* 2 * Copyright 2012 Google Inc. 3 * 4 * Use of this source code is governed by a BSD-style license that can be 5 * found in the LICENSE file. 6 */ 7 8 9 #ifndef GrGLCaps_DEFINED 10 #define GrGLCaps_DEFINED 11 12 #include "SkTArray.h" 13 #include "SkTDArray.h" 14 #include "GrGLStencilBuffer.h" 15 16 class GrGLContextInfo; 17 18 /** 19 * Stores some capabilities of a GL context. Most are determined by the GL 20 * version and the extensions string. It also tracks formats that have passed 21 * the FBO completeness test. 22 */ 23 class GrGLCaps { 24 public: 25 typedef GrGLStencilBuffer::Format StencilFormat; 26 27 /** 28 * Represents a supported multisampling/coverage-sampling mode. 29 */ 30 struct MSAACoverageMode { 31 // "Coverage samples" includes samples that actually have color, depth, 32 // stencil, ... as well as those that don't (coverage only). All samples 33 // are coverage samples. (We're using the word "coverage sample" to 34 // match the NV extension language.) 35 int fCoverageSampleCnt; 36 37 // Color samples are samples that store data values (color, stencil, 38 // depth) rather than just representing coverage. They are a subset 39 // of coverage samples. (Again the wording was chosen to match the 40 // extension.) 41 int fColorSampleCnt; 42 }; 43 44 /** 45 * The type of MSAA for FBOs supported. Different extensions have different 46 * semantics of how / when a resolve is performed. 47 */ 48 enum MSFBOType { 49 /** 50 * no support for MSAA FBOs 51 */ 52 kNone_MSFBOType = 0, 53 /** 54 * GL3.0-style MSAA FBO (GL_ARB_framebuffer_object) 55 */ 56 kDesktopARB_MSFBOType, 57 /** 58 * earlier GL_EXT_framebuffer* extensions 59 */ 60 kDesktopEXT_MSFBOType, 61 /** 62 * GL_APPLE_framebuffer_multisample ES extension 63 */ 64 kAppleES_MSFBOType, 65 }; 66 67 enum CoverageAAType { 68 /** 69 * No coverage sample support 70 */ 71 kNone_CoverageAAType, 72 73 /** 74 * GL_NV_framebuffer_multisample_coverage 75 */ 76 kNVDesktop_CoverageAAType, 77 }; 78 79 /** 80 * Creates a GrGLCaps that advertises no support for any extensions, 81 * formats, etc. Call init to initialize from a GrGLContextInfo. 82 */ 83 GrGLCaps(); 84 85 GrGLCaps(const GrGLCaps& caps); 86 87 GrGLCaps& operator = (const GrGLCaps& caps); 88 89 /** 90 * Resets the caps such that nothing is supported. 91 */ 92 void reset(); 93 94 /** 95 * Initializes the GrGLCaps to the set of features supported in the current 96 * OpenGL context accessible via ctxInfo. 97 */ 98 void init(const GrGLContextInfo& ctxInfo); 99 100 /** 101 * Call to note that a color config has been verified as a valid color 102 * attachment. This may save future calls to glCheckFramebufferStatus 103 * using isConfigVerifiedColorAttachment(). 104 */ markConfigAsValidColorAttachment(GrPixelConfig config)105 void markConfigAsValidColorAttachment(GrPixelConfig config) { 106 fVerifiedColorConfigs.markVerified(config); 107 } 108 109 /** 110 * Call to check whether a config has been verified as a valid color 111 * attachment. 112 */ isConfigVerifiedColorAttachment(GrPixelConfig config)113 bool isConfigVerifiedColorAttachment(GrPixelConfig config) const { 114 return fVerifiedColorConfigs.isVerified(config); 115 } 116 117 /** 118 * Call to note that a color config / stencil format pair passed 119 * FBO status check. We may skip calling glCheckFramebufferStatus for 120 * this combination in the future using 121 * isColorConfigAndStencilFormatVerified(). 122 */ 123 void markColorConfigAndStencilFormatAsVerified( 124 GrPixelConfig config, 125 const GrGLStencilBuffer::Format& format); 126 127 /** 128 * Call to check whether color config / stencil format pair has already 129 * passed FBO status check. 130 */ 131 bool isColorConfigAndStencilFormatVerified( 132 GrPixelConfig config, 133 const GrGLStencilBuffer::Format& format) const; 134 135 /** 136 * Reports the type of MSAA FBO support. 137 */ msFBOType()138 MSFBOType msFBOType() const { return fMSFBOType; } 139 140 /** 141 * Reports the maximum number of samples supported. 142 */ maxSampleCount()143 int maxSampleCount() const { return fMaxSampleCount; } 144 145 /** 146 * Reports the type of coverage sample AA support. 147 */ coverageAAType()148 CoverageAAType coverageAAType() const { return fCoverageAAType; } 149 150 /** 151 * Chooses a supported coverage mode based on a desired sample count. The 152 * desired sample count is rounded up the next supported coverage sample 153 * count unless a it is larger than the max in which case it is rounded 154 * down. Once a coverage sample count is decided, the supported mode with 155 * the fewest color samples is chosen. 156 */ 157 const MSAACoverageMode& getMSAACoverageMode(int desiredSampleCount) const; 158 159 /** 160 * Prints the caps info using GrPrintf. 161 */ 162 void print() const; 163 164 /** 165 * Gets an array of legal stencil formats. These formats are not guaranteed 166 * to be supported by the driver but are legal GLenum names given the GL 167 * version and extensions supported. 168 */ stencilFormats()169 const SkTArray<StencilFormat, true>& stencilFormats() const { 170 return fStencilFormats; 171 } 172 173 /// The maximum number of fragment uniform vectors (GLES has min. 16). maxFragmentUniformVectors()174 int maxFragmentUniformVectors() const { return fMaxFragmentUniformVectors; } 175 176 // maximum number of attribute values per vertex maxVertexAttributes()177 int maxVertexAttributes() const { return fMaxVertexAttributes; } 178 179 /// ES requires an extension to support RGBA8 in RenderBufferStorage rgba8RenderbufferSupport()180 bool rgba8RenderbufferSupport() const { return fRGBA8RenderbufferSupport; } 181 182 /// Is GL_BGRA supported bgraFormatSupport()183 bool bgraFormatSupport() const { return fBGRAFormatSupport; } 184 185 /** 186 * Depending on the ES extensions present the BGRA external format may 187 * correspond either a BGRA or RGBA internalFormat. On desktop GL it is 188 * RGBA. 189 */ bgraIsInternalFormat()190 bool bgraIsInternalFormat() const { return fBGRAIsInternalFormat; } 191 192 /// GL_ARB_texture_swizzle support textureSwizzleSupport()193 bool textureSwizzleSupport() const { return fTextureSwizzleSupport; } 194 195 /// Is there support for GL_UNPACK_ROW_LENGTH unpackRowLengthSupport()196 bool unpackRowLengthSupport() const { return fUnpackRowLengthSupport; } 197 198 /// Is there support for GL_UNPACK_FLIP_Y unpackFlipYSupport()199 bool unpackFlipYSupport() const { return fUnpackFlipYSupport; } 200 201 /// Is there support for GL_PACK_ROW_LENGTH packRowLengthSupport()202 bool packRowLengthSupport() const { return fPackRowLengthSupport; } 203 204 /// Is there support for GL_PACK_REVERSE_ROW_ORDER packFlipYSupport()205 bool packFlipYSupport() const { return fPackFlipYSupport; } 206 207 /// Is there support for texture parameter GL_TEXTURE_USAGE textureUsageSupport()208 bool textureUsageSupport() const { return fTextureUsageSupport; } 209 210 /// Is there support for glTexStorage texStorageSupport()211 bool texStorageSupport() const { return fTexStorageSupport; } 212 213 /// Is there support for GL_RED and GL_R8 textureRedSupport()214 bool textureRedSupport() const { return fTextureRedSupport; } 215 216 /// Is GL_ARB_IMAGING supported imagingSupport()217 bool imagingSupport() const { return fImagingSupport; } 218 219 /// Is GL_ARB_fragment_coord_conventions supported? fragCoordConventionsSupport()220 bool fragCoordConventionsSupport() const { return fFragCoordsConventionSupport; } 221 222 // Does ReadPixels support the provided format/type combo? 223 bool readPixelsSupported(const GrGLInterface* intf, 224 GrGLenum format, 225 GrGLenum type) const; 226 227 private: 228 /** 229 * Maintains a bit per GrPixelConfig. It is used to avoid redundantly 230 * performing glCheckFrameBufferStatus for the same config. 231 */ 232 struct VerifiedColorConfigs { VerifiedColorConfigsVerifiedColorConfigs233 VerifiedColorConfigs() { 234 this->reset(); 235 } 236 resetVerifiedColorConfigs237 void reset() { 238 for (int i = 0; i < kNumUints; ++i) { 239 fVerifiedColorConfigs[i] = 0; 240 } 241 } 242 243 static const int kNumUints = (kGrPixelConfigCount + 31) / 32; 244 uint32_t fVerifiedColorConfigs[kNumUints]; 245 markVerifiedVerifiedColorConfigs246 void markVerified(GrPixelConfig config) { 247 #if !GR_GL_CHECK_FBO_STATUS_ONCE_PER_FORMAT 248 return; 249 #endif 250 int u32Idx = config / 32; 251 int bitIdx = config % 32; 252 fVerifiedColorConfigs[u32Idx] |= 1 << bitIdx; 253 } 254 isVerifiedVerifiedColorConfigs255 bool isVerified(GrPixelConfig config) const { 256 #if !GR_GL_CHECK_FBO_STATUS_ONCE_PER_FORMAT 257 return false; 258 #endif 259 int u32Idx = config / 32; 260 int bitIdx = config % 32; 261 return SkToBool(fVerifiedColorConfigs[u32Idx] & (1 << bitIdx)); 262 } 263 }; 264 265 void initFSAASupport(const GrGLContextInfo& ctxInfo); 266 void initStencilFormats(const GrGLContextInfo& ctxInfo); 267 268 // tracks configs that have been verified to pass the FBO completeness when 269 // used as a color attachment 270 VerifiedColorConfigs fVerifiedColorConfigs; 271 272 SkTArray<StencilFormat, true> fStencilFormats; 273 // tracks configs that have been verified to pass the FBO completeness when 274 // used as a color attachment when a particular stencil format is used 275 // as a stencil attachment. 276 SkTArray<VerifiedColorConfigs, true> fStencilVerifiedColorConfigs; 277 278 int fMaxFragmentUniformVectors; 279 int fMaxVertexAttributes; 280 281 MSFBOType fMSFBOType; 282 int fMaxSampleCount; 283 CoverageAAType fCoverageAAType; 284 SkTDArray<MSAACoverageMode> fMSAACoverageModes; 285 286 bool fRGBA8RenderbufferSupport : 1; 287 bool fBGRAFormatSupport : 1; 288 bool fBGRAIsInternalFormat : 1; 289 bool fTextureSwizzleSupport : 1; 290 bool fUnpackRowLengthSupport : 1; 291 bool fUnpackFlipYSupport : 1; 292 bool fPackRowLengthSupport : 1; 293 bool fPackFlipYSupport : 1; 294 bool fTextureUsageSupport : 1; 295 bool fTexStorageSupport : 1; 296 bool fTextureRedSupport : 1; 297 bool fImagingSupport : 1; 298 bool fTwoFormatLimit : 1; 299 bool fFragCoordsConventionSupport : 1; 300 }; 301 302 #endif 303