Home | History | Annotate | Download | only in gl 
      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      */
    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      */
    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      */
    138     MSFBOType msFBOType() const { return fMSFBOType; }
    139 
    140     /**
    141      * Reports the maximum number of samples supported.
    142      */
    143     int maxSampleCount() const { return fMaxSampleCount; }
    144 
    145     /**
    146      * Reports the type of coverage sample AA support.
    147      */
    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      */
    169     const SkTArray<StencilFormat, true>& stencilFormats() const {
    170         return fStencilFormats;
    171     }
    172 
    173     /// The maximum number of fragment uniform vectors (GLES has min. 16).
    174     int maxFragmentUniformVectors() const { return fMaxFragmentUniformVectors; }
    175 
    176     // maximum number of attribute values per vertex
    177     int maxVertexAttributes() const { return fMaxVertexAttributes; }
    178 
    179     /// ES requires an extension to support RGBA8 in RenderBufferStorage
    180     bool rgba8RenderbufferSupport() const { return fRGBA8RenderbufferSupport; }
    181 
    182     /// Is GL_BGRA supported
    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      */
    190     bool bgraIsInternalFormat() const { return fBGRAIsInternalFormat; }
    191 
    192     /// GL_ARB_texture_swizzle support
    193     bool textureSwizzleSupport() const { return fTextureSwizzleSupport; }
    194 
    195     /// Is there support for GL_UNPACK_ROW_LENGTH
    196     bool unpackRowLengthSupport() const { return fUnpackRowLengthSupport; }
    197 
    198     /// Is there support for GL_UNPACK_FLIP_Y
    199     bool unpackFlipYSupport() const { return fUnpackFlipYSupport; }
    200 
    201     /// Is there support for GL_PACK_ROW_LENGTH
    202     bool packRowLengthSupport() const { return fPackRowLengthSupport; }
    203 
    204     /// Is there support for GL_PACK_REVERSE_ROW_ORDER
    205     bool packFlipYSupport() const { return fPackFlipYSupport; }
    206 
    207     /// Is there support for texture parameter GL_TEXTURE_USAGE
    208     bool textureUsageSupport() const { return fTextureUsageSupport; }
    209 
    210     /// Is there support for glTexStorage
    211     bool texStorageSupport() const { return fTexStorageSupport; }
    212 
    213     /// Is there support for GL_RED and GL_R8
    214     bool textureRedSupport() const { return fTextureRedSupport; }
    215 
    216     /// Is GL_ARB_IMAGING supported
    217     bool imagingSupport() const { return fImagingSupport; }
    218 
    219     /// Is GL_ARB_fragment_coord_conventions supported?
    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 {
    233         VerifiedColorConfigs() {
    234             this->reset();
    235         }
    236 
    237         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 
    246         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 
    255         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