diff -r 000000000000 -r 6474c204b198 gfx/skia/trunk/src/gpu/gl/GrGLCaps.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/gfx/skia/trunk/src/gpu/gl/GrGLCaps.h Wed Dec 31 06:09:35 2014 +0100 @@ -0,0 +1,339 @@ +/* + * Copyright 2012 Google Inc. + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ + + +#ifndef GrGLCaps_DEFINED +#define GrGLCaps_DEFINED + +#include "GrDrawTargetCaps.h" +#include "GrGLStencilBuffer.h" +#include "SkTArray.h" +#include "SkTDArray.h" + +class GrGLContextInfo; + +/** + * Stores some capabilities of a GL context. Most are determined by the GL + * version and the extensions string. It also tracks formats that have passed + * the FBO completeness test. + */ +class GrGLCaps : public GrDrawTargetCaps { +public: + SK_DECLARE_INST_COUNT(GrGLCaps) + + typedef GrGLStencilBuffer::Format StencilFormat; + + /** + * The type of MSAA for FBOs supported. Different extensions have different + * semantics of how / when a resolve is performed. + */ + enum MSFBOType { + /** + * no support for MSAA FBOs + */ + kNone_MSFBOType = 0, + /** + * GL3.0-style MSAA FBO (GL_ARB_framebuffer_object). + */ + kDesktop_ARB_MSFBOType, + /** + * earlier GL_EXT_framebuffer* extensions + */ + kDesktop_EXT_MSFBOType, + /** + * Similar to kDesktop_ARB but with additional restrictions on glBlitFramebuffer. + */ + kES_3_0_MSFBOType, + /** + * GL_APPLE_framebuffer_multisample ES extension + */ + kES_Apple_MSFBOType, + /** + * GL_IMG_multisampled_render_to_texture. This variation does not have MSAA renderbuffers. + * Instead the texture is multisampled when bound to the FBO and then resolved automatically + * when read. It also defines an alternate value for GL_MAX_SAMPLES (which we call + * GR_GL_MAX_SAMPLES_IMG). + */ + kES_IMG_MsToTexture_MSFBOType, + /** + * GL_EXT_multisampled_render_to_texture. Same as the IMG one above but uses the standard + * GL_MAX_SAMPLES value. + */ + kES_EXT_MsToTexture_MSFBOType, + + kLast_MSFBOType = kES_EXT_MsToTexture_MSFBOType + }; + + enum FBFetchType { + kNone_FBFetchType, + /** GL_EXT_shader_framebuffer_fetch */ + kEXT_FBFetchType, + /** GL_NV_shader_framebuffer_fetch */ + kNV_FBFetchType, + + kLast_FBFetchType = kNV_FBFetchType, + }; + + /** + * Creates a GrGLCaps that advertises no support for any extensions, + * formats, etc. Call init to initialize from a GrGLContextInfo. + */ + GrGLCaps(); + + GrGLCaps(const GrGLCaps& caps); + + GrGLCaps& operator = (const GrGLCaps& caps); + + /** + * Resets the caps such that nothing is supported. + */ + virtual void reset() SK_OVERRIDE; + + /** + * Initializes the GrGLCaps to the set of features supported in the current + * OpenGL context accessible via ctxInfo. + */ + void init(const GrGLContextInfo& ctxInfo, const GrGLInterface* interface); + + /** + * Call to note that a color config has been verified as a valid color + * attachment. This may save future calls to glCheckFramebufferStatus + * using isConfigVerifiedColorAttachment(). + */ + void markConfigAsValidColorAttachment(GrPixelConfig config) { + fVerifiedColorConfigs.markVerified(config); + } + + /** + * Call to check whether a config has been verified as a valid color + * attachment. + */ + bool isConfigVerifiedColorAttachment(GrPixelConfig config) const { + return fVerifiedColorConfigs.isVerified(config); + } + + /** + * Call to note that a color config / stencil format pair passed + * FBO status check. We may skip calling glCheckFramebufferStatus for + * this combination in the future using + * isColorConfigAndStencilFormatVerified(). + */ + void markColorConfigAndStencilFormatAsVerified( + GrPixelConfig config, + const GrGLStencilBuffer::Format& format); + + /** + * Call to check whether color config / stencil format pair has already + * passed FBO status check. + */ + bool isColorConfigAndStencilFormatVerified( + GrPixelConfig config, + const GrGLStencilBuffer::Format& format) const; + + /** + * Reports the type of MSAA FBO support. + */ + MSFBOType msFBOType() const { return fMSFBOType; } + + /** + * Does the supported MSAA FBO extension have MSAA renderbuffers? + */ + bool usesMSAARenderBuffers() const { + return kNone_MSFBOType != fMSFBOType && + kES_IMG_MsToTexture_MSFBOType != fMSFBOType && + kES_EXT_MsToTexture_MSFBOType != fMSFBOType; + } + + /** + * Is the MSAA FBO extension one where the texture is multisampled when bound to an FBO and + * then implicitly resolved when read. + */ + bool usesImplicitMSAAResolve() const { + return kES_IMG_MsToTexture_MSFBOType == fMSFBOType || + kES_EXT_MsToTexture_MSFBOType == fMSFBOType; + } + + FBFetchType fbFetchType() const { return fFBFetchType; } + + /** + * Returs a string containeng the caps info. + */ + virtual SkString dump() const SK_OVERRIDE; + + /** + * Gets an array of legal stencil formats. These formats are not guaranteed + * to be supported by the driver but are legal GLenum names given the GL + * version and extensions supported. + */ + const SkTArray& stencilFormats() const { + return fStencilFormats; + } + + /// The maximum number of fragment uniform vectors (GLES has min. 16). + int maxFragmentUniformVectors() const { return fMaxFragmentUniformVectors; } + + /// maximum number of attribute values per vertex + int maxVertexAttributes() const { return fMaxVertexAttributes; } + + /// maximum number of texture units accessible in the fragment shader. + int maxFragmentTextureUnits() const { return fMaxFragmentTextureUnits; } + + /// maximum number of fixed-function texture coords, or zero if no fixed-function. + int maxFixedFunctionTextureCoords() const { return fMaxFixedFunctionTextureCoords; } + + /// ES requires an extension to support RGBA8 in RenderBufferStorage + bool rgba8RenderbufferSupport() const { return fRGBA8RenderbufferSupport; } + + /// Is GL_BGRA supported + bool bgraFormatSupport() const { return fBGRAFormatSupport; } + + /** + * Depending on the ES extensions present the BGRA external format may + * correspond either a BGRA or RGBA internalFormat. On desktop GL it is + * RGBA. + */ + bool bgraIsInternalFormat() const { return fBGRAIsInternalFormat; } + + /// GL_ARB_texture_swizzle support + bool textureSwizzleSupport() const { return fTextureSwizzleSupport; } + + /// Is there support for GL_UNPACK_ROW_LENGTH + bool unpackRowLengthSupport() const { return fUnpackRowLengthSupport; } + + /// Is there support for GL_UNPACK_FLIP_Y + bool unpackFlipYSupport() const { return fUnpackFlipYSupport; } + + /// Is there support for GL_PACK_ROW_LENGTH + bool packRowLengthSupport() const { return fPackRowLengthSupport; } + + /// Is there support for GL_PACK_REVERSE_ROW_ORDER + bool packFlipYSupport() const { return fPackFlipYSupport; } + + /// Is there support for texture parameter GL_TEXTURE_USAGE + bool textureUsageSupport() const { return fTextureUsageSupport; } + + /// Is there support for glTexStorage + bool texStorageSupport() const { return fTexStorageSupport; } + + /// Is there support for GL_RED and GL_R8 + bool textureRedSupport() const { return fTextureRedSupport; } + + /// Is GL_ARB_IMAGING supported + bool imagingSupport() const { return fImagingSupport; } + + /// Is GL_ARB_fragment_coord_conventions supported? + bool fragCoordConventionsSupport() const { return fFragCoordsConventionSupport; } + + /// Is there support for Vertex Array Objects? + bool vertexArrayObjectSupport() const { return fVertexArrayObjectSupport; } + + /// Use indices or vertices in CPU arrays rather than VBOs for dynamic content. + bool useNonVBOVertexAndIndexDynamicData() const { + return fUseNonVBOVertexAndIndexDynamicData; + } + + /// Does ReadPixels support the provided format/type combo? + bool readPixelsSupported(const GrGLInterface* intf, + GrGLenum format, + GrGLenum type) const; + + bool isCoreProfile() const { return fIsCoreProfile; } + + bool fixedFunctionSupport() const { return fFixedFunctionSupport; } + + /// Is there support for discarding the frame buffer + bool discardFBSupport() const { return fDiscardFBSupport; } + + bool fullClearIsFree() const { return fFullClearIsFree; } + +private: + /** + * Maintains a bit per GrPixelConfig. It is used to avoid redundantly + * performing glCheckFrameBufferStatus for the same config. + */ + struct VerifiedColorConfigs { + VerifiedColorConfigs() { + this->reset(); + } + + void reset() { + for (int i = 0; i < kNumUints; ++i) { + fVerifiedColorConfigs[i] = 0; + } + } + + static const int kNumUints = (kGrPixelConfigCnt + 31) / 32; + uint32_t fVerifiedColorConfigs[kNumUints]; + + void markVerified(GrPixelConfig config) { +#if !GR_GL_CHECK_FBO_STATUS_ONCE_PER_FORMAT + return; +#endif + int u32Idx = config / 32; + int bitIdx = config % 32; + fVerifiedColorConfigs[u32Idx] |= 1 << bitIdx; + } + + bool isVerified(GrPixelConfig config) const { +#if !GR_GL_CHECK_FBO_STATUS_ONCE_PER_FORMAT + return false; +#endif + int u32Idx = config / 32; + int bitIdx = config % 32; + return SkToBool(fVerifiedColorConfigs[u32Idx] & (1 << bitIdx)); + } + }; + + void initFSAASupport(const GrGLContextInfo&, const GrGLInterface*); + void initStencilFormats(const GrGLContextInfo&); + // This must be called after initFSAASupport(). + void initConfigRenderableTable(const GrGLContextInfo&); + + // tracks configs that have been verified to pass the FBO completeness when + // used as a color attachment + VerifiedColorConfigs fVerifiedColorConfigs; + + SkTArray fStencilFormats; + // tracks configs that have been verified to pass the FBO completeness when + // used as a color attachment when a particular stencil format is used + // as a stencil attachment. + SkTArray fStencilVerifiedColorConfigs; + + int fMaxFragmentUniformVectors; + int fMaxVertexAttributes; + int fMaxFragmentTextureUnits; + int fMaxFixedFunctionTextureCoords; + + MSFBOType fMSFBOType; + + FBFetchType fFBFetchType; + + bool fRGBA8RenderbufferSupport : 1; + bool fBGRAFormatSupport : 1; + bool fBGRAIsInternalFormat : 1; + bool fTextureSwizzleSupport : 1; + bool fUnpackRowLengthSupport : 1; + bool fUnpackFlipYSupport : 1; + bool fPackRowLengthSupport : 1; + bool fPackFlipYSupport : 1; + bool fTextureUsageSupport : 1; + bool fTexStorageSupport : 1; + bool fTextureRedSupport : 1; + bool fImagingSupport : 1; + bool fTwoFormatLimit : 1; + bool fFragCoordsConventionSupport : 1; + bool fVertexArrayObjectSupport : 1; + bool fUseNonVBOVertexAndIndexDynamicData : 1; + bool fIsCoreProfile : 1; + bool fFixedFunctionSupport : 1; + bool fDiscardFBSupport : 1; + bool fFullClearIsFree : 1; + + typedef GrDrawTargetCaps INHERITED; +}; + +#endif