void GrGLCaps::init(const GrGLContextInfo& ctxInfo) { this->reset(); if (!ctxInfo.isInitialized()) { return; } const GrGLInterface* gli = ctxInfo.interface(); GrGLBinding binding = ctxInfo.binding(); GrGLVersion version = ctxInfo.version(); if (kES2_GrGLBinding == binding) { GR_GL_GetIntegerv(gli, GR_GL_MAX_FRAGMENT_UNIFORM_VECTORS, &fMaxFragmentUniformVectors); } else { GrAssert(kDesktop_GrGLBinding == binding); GrGLint max; GR_GL_GetIntegerv(gli, GR_GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, &max); fMaxFragmentUniformVectors = max / 4; } if (kDesktop_GrGLBinding == binding) { fRGBA8RenderbufferSupport = true; } else { fRGBA8RenderbufferSupport = ctxInfo.hasExtension("GL_OES_rgb8_rgba8") || ctxInfo.hasExtension("GL_ARM_rgba8"); } if (kDesktop_GrGLBinding == binding) { fBGRAFormatSupport = version >= GR_GL_VER(1,2) || ctxInfo.hasExtension("GL_EXT_bgra"); } else { bool hasBGRAExt = false; if (ctxInfo.hasExtension("GL_APPLE_texture_format_BGRA8888")) { fBGRAFormatSupport = true; } else if (ctxInfo.hasExtension("GL_EXT_texture_format_BGRA8888")) { fBGRAFormatSupport = true; fBGRAIsInternalFormat = true; } GrAssert(fBGRAFormatSupport || kSkia8888_PM_GrPixelConfig != kBGRA_8888_PM_GrPixelConfig); } if (kDesktop_GrGLBinding == binding) { fTextureSwizzleSupport = version >= GR_GL_VER(3,3) || ctxInfo.hasExtension("GL_ARB_texture_swizzle"); } else { fTextureSwizzleSupport = false; } if (kDesktop_GrGLBinding == binding) { fUnpackRowLengthSupport = true; fUnpackFlipYSupport = false; fPackRowLengthSupport = true; fPackFlipYSupport = false; } else { fUnpackRowLengthSupport =ctxInfo.hasExtension("GL_EXT_unpack_subimage"); fUnpackFlipYSupport = ctxInfo.hasExtension("GL_CHROMIUM_flipy"); // no extension for pack row length fPackRowLengthSupport = false; fPackFlipYSupport = ctxInfo.hasExtension("GL_ANGLE_pack_reverse_row_order"); } fTextureUsageSupport = (kES2_GrGLBinding == binding) && ctxInfo.hasExtension("GL_ANGLE_texture_usage"); // Tex storage is in desktop 4.2 and can be an extension to desktop or ES. fTexStorageSupport = (kDesktop_GrGLBinding == binding && version >= GR_GL_VER(4,2)) || ctxInfo.hasExtension("GL_ARB_texture_storage") || ctxInfo.hasExtension("GL_EXT_texture_storage"); // ARB_texture_rg is part of OpenGL 3.0 if (kDesktop_GrGLBinding == binding) { fTextureRedSupport = version >= GR_GL_VER(3,0) || ctxInfo.hasExtension("GL_ARB_texture_rg"); } else { fTextureRedSupport = ctxInfo.hasExtension("GL_ARB_texture_rg"); } this->initFSAASupport(ctxInfo); this->initStencilFormats(ctxInfo); }
bool GrGLCaps::init(const GrGLContextInfo& ctxInfo, const GrGLInterface* gli) { this->reset(); if (!ctxInfo.isInitialized()) { return false; } GrGLStandard standard = ctxInfo.standard(); GrGLVersion version = ctxInfo.version(); /************************************************************************** * Caps specific to GrGLCaps **************************************************************************/ if (kGLES_GrGLStandard == standard) { GR_GL_GetIntegerv(gli, GR_GL_MAX_FRAGMENT_UNIFORM_VECTORS, &fMaxFragmentUniformVectors); } else { SkASSERT(kGL_GrGLStandard == standard); GrGLint max; GR_GL_GetIntegerv(gli, GR_GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, &max); fMaxFragmentUniformVectors = max / 4; if (version >= GR_GL_VER(3, 2)) { GrGLint profileMask; GR_GL_GetIntegerv(gli, GR_GL_CONTEXT_PROFILE_MASK, &profileMask); fIsCoreProfile = SkToBool(profileMask & GR_GL_CONTEXT_CORE_PROFILE_BIT); } if (!fIsCoreProfile) { GR_GL_GetIntegerv(gli, GR_GL_MAX_TEXTURE_COORDS, &fMaxFixedFunctionTextureCoords); // Sanity check SkASSERT(fMaxFixedFunctionTextureCoords > 0 && fMaxFixedFunctionTextureCoords < 128); } } GR_GL_GetIntegerv(gli, GR_GL_MAX_VERTEX_ATTRIBS, &fMaxVertexAttributes); GR_GL_GetIntegerv(gli, GR_GL_MAX_TEXTURE_IMAGE_UNITS, &fMaxFragmentTextureUnits); if (kGL_GrGLStandard == standard) { fRGBA8RenderbufferSupport = true; } else { fRGBA8RenderbufferSupport = version >= GR_GL_VER(3,0) || ctxInfo.hasExtension("GL_OES_rgb8_rgba8") || ctxInfo.hasExtension("GL_ARM_rgba8"); } if (kGL_GrGLStandard == standard) { fTextureSwizzleSupport = version >= GR_GL_VER(3,3) || ctxInfo.hasExtension("GL_ARB_texture_swizzle"); } else { fTextureSwizzleSupport = version >= GR_GL_VER(3,0); } if (kGL_GrGLStandard == standard) { fUnpackRowLengthSupport = true; fUnpackFlipYSupport = false; fPackRowLengthSupport = true; fPackFlipYSupport = false; } else { fUnpackRowLengthSupport = version >= GR_GL_VER(3,0) || ctxInfo.hasExtension("GL_EXT_unpack_subimage"); fUnpackFlipYSupport = ctxInfo.hasExtension("GL_CHROMIUM_flipy"); fPackRowLengthSupport = version >= GR_GL_VER(3,0) || ctxInfo.hasExtension("GL_NV_pack_subimage"); fPackFlipYSupport = ctxInfo.hasExtension("GL_ANGLE_pack_reverse_row_order"); } fTextureUsageSupport = (kGLES_GrGLStandard == standard) && ctxInfo.hasExtension("GL_ANGLE_texture_usage"); if (kGL_GrGLStandard == standard) { // The EXT version can apply to either GL or GLES. fTexStorageSupport = version >= GR_GL_VER(4,2) || ctxInfo.hasExtension("GL_ARB_texture_storage") || ctxInfo.hasExtension("GL_EXT_texture_storage"); } else { // Qualcomm Adreno drivers appear to have issues with texture storage. fTexStorageSupport = (version >= GR_GL_VER(3,0) && kQualcomm_GrGLVendor != ctxInfo.vendor()) || ctxInfo.hasExtension("GL_EXT_texture_storage"); } // ARB_texture_rg is part of OpenGL 3.0, but mesa doesn't support it if // it doesn't have ARB_texture_rg extension. if (kGL_GrGLStandard == standard) { if (ctxInfo.isMesa()) { fTextureRedSupport = ctxInfo.hasExtension("GL_ARB_texture_rg"); } else { fTextureRedSupport = version >= GR_GL_VER(3,0) || ctxInfo.hasExtension("GL_ARB_texture_rg"); } } else { fTextureRedSupport = version >= GR_GL_VER(3,0) || ctxInfo.hasExtension("GL_EXT_texture_rg"); } fImagingSupport = kGL_GrGLStandard == standard && ctxInfo.hasExtension("GL_ARB_imaging"); // ES 2 only guarantees RGBA/uchar + one other format/type combo for // ReadPixels. The other format has to checked at run-time since it // can change based on which render target is bound fTwoFormatLimit = kGLES_GrGLStandard == standard; // Known issue on at least some Intel platforms: // http://code.google.com/p/skia/issues/detail?id=946 if (kIntel_GrGLVendor != ctxInfo.vendor()) { fFragCoordsConventionSupport = ctxInfo.glslGeneration() >= k150_GrGLSLGeneration || ctxInfo.hasExtension("GL_ARB_fragment_coord_conventions"); } // SGX and Mali GPUs that are based on a tiled-deferred architecture that have trouble with // frequently changing VBOs. We've measured a performance increase using non-VBO vertex // data for dynamic content on these GPUs. Perhaps we should read the renderer string and // limit this decision to specific GPU families rather than basing it on the vendor alone. if (!GR_GL_MUST_USE_VBO && (kARM_GrGLVendor == ctxInfo.vendor() || kImagination_GrGLVendor == ctxInfo.vendor())) { fUseNonVBOVertexAndIndexDynamicData = true; } if ((kGL_GrGLStandard == standard && version >= GR_GL_VER(4,3)) || (kGLES_GrGLStandard == standard && version >= GR_GL_VER(3,0)) || ctxInfo.hasExtension("GL_ARB_invalidate_subdata")) { fDiscardRenderTargetSupport = true; fInvalidateFBType = kInvalidate_InvalidateFBType; } else if (ctxInfo.hasExtension("GL_EXT_discard_framebuffer")) { fDiscardRenderTargetSupport = true; fInvalidateFBType = kDiscard_InvalidateFBType; } if (kARM_GrGLVendor == ctxInfo.vendor() || kImagination_GrGLVendor == ctxInfo.vendor()) { fFullClearIsFree = true; } if (kGL_GrGLStandard == standard) { fVertexArrayObjectSupport = version >= GR_GL_VER(3, 0) || ctxInfo.hasExtension("GL_ARB_vertex_array_object"); } else { fVertexArrayObjectSupport = version >= GR_GL_VER(3, 0) || ctxInfo.hasExtension("GL_OES_vertex_array_object"); } if (kGLES_GrGLStandard == standard) { if (ctxInfo.hasExtension("GL_EXT_shader_framebuffer_fetch")) { fFBFetchType = kEXT_FBFetchType; } else if (ctxInfo.hasExtension("GL_NV_shader_framebuffer_fetch")) { fFBFetchType = kNV_FBFetchType; } } // Adreno GPUs have a tendency to drop tiles when there is a divide-by-zero in a shader fDropsTileOnZeroDivide = kQualcomm_GrGLVendor == ctxInfo.vendor(); this->initFSAASupport(ctxInfo, gli); this->initStencilFormats(ctxInfo); /************************************************************************** * GrDrawTargetCaps fields **************************************************************************/ if (kGL_GrGLStandard == standard) { // we could also look for GL_ATI_separate_stencil extension or // GL_EXT_stencil_two_side but they use different function signatures // than GL2.0+ (and than each other). fTwoSidedStencilSupport = (ctxInfo.version() >= GR_GL_VER(2,0)); // supported on GL 1.4 and higher or by extension fStencilWrapOpsSupport = (ctxInfo.version() >= GR_GL_VER(1,4)) || ctxInfo.hasExtension("GL_EXT_stencil_wrap"); } else { // ES 2 has two sided stencil and stencil wrap fTwoSidedStencilSupport = true; fStencilWrapOpsSupport = true; } if (kGL_GrGLStandard == standard) { fMapBufferFlags = kCanMap_MapFlag; // we require VBO support and the desktop VBO // extension includes glMapBuffer. if (version >= GR_GL_VER(3, 0) || ctxInfo.hasExtension("GL_ARB_map_buffer_range")) { fMapBufferFlags |= kSubset_MapFlag; fMapBufferType = kMapBufferRange_MapBufferType; } else { fMapBufferType = kMapBuffer_MapBufferType; } } else { // Unextended GLES2 doesn't have any buffer mapping. fMapBufferFlags = kNone_MapBufferType; if (ctxInfo.hasExtension("GL_CHROMIUM_map_sub")) { fMapBufferFlags = kCanMap_MapFlag | kSubset_MapFlag; fMapBufferType = kChromium_MapBufferType; } else if (version >= GR_GL_VER(3, 0) || ctxInfo.hasExtension("GL_EXT_map_buffer_range")) { fMapBufferFlags = kCanMap_MapFlag | kSubset_MapFlag; fMapBufferType = kMapBufferRange_MapBufferType; } else if (ctxInfo.hasExtension("GL_OES_mapbuffer")) { fMapBufferFlags = kCanMap_MapFlag; fMapBufferType = kMapBuffer_MapBufferType; } } if (kGL_GrGLStandard == standard) { SkASSERT(ctxInfo.version() >= GR_GL_VER(2,0) || ctxInfo.hasExtension("GL_ARB_texture_non_power_of_two")); fNPOTTextureTileSupport = true; fMipMapSupport = true; } else { // Unextended ES2 supports NPOT textures with clamp_to_edge and non-mip filters only // ES3 has no limitations. fNPOTTextureTileSupport = ctxInfo.version() >= GR_GL_VER(3,0) || ctxInfo.hasExtension("GL_OES_texture_npot"); // ES2 supports MIP mapping for POT textures but our caps don't allow for limited MIP // support. The OES extension or ES 3.0 allow for MIPS on NPOT textures. So, apparently, // does the undocumented GL_IMG_texture_npot extension. This extension does not seem to // to alllow arbitrary wrap modes, however. fMipMapSupport = fNPOTTextureTileSupport || ctxInfo.hasExtension("GL_IMG_texture_npot"); } fHWAALineSupport = (kGL_GrGLStandard == standard); GR_GL_GetIntegerv(gli, GR_GL_MAX_TEXTURE_SIZE, &fMaxTextureSize); GR_GL_GetIntegerv(gli, GR_GL_MAX_RENDERBUFFER_SIZE, &fMaxRenderTargetSize); // Our render targets are always created with textures as the color // attachment, hence this min: fMaxRenderTargetSize = SkTMin(fMaxTextureSize, fMaxRenderTargetSize); fPathRenderingSupport = ctxInfo.hasExtension("GL_NV_path_rendering") && ctxInfo.hasExtension("GL_EXT_direct_state_access"); fGpuTracingSupport = ctxInfo.hasExtension("GL_EXT_debug_marker"); fDstReadInShaderSupport = kNone_FBFetchType != fFBFetchType; // Disable scratch texture reuse on Mali and Adreno devices fReuseScratchTextures = kARM_GrGLVendor != ctxInfo.vendor() && kQualcomm_GrGLVendor != ctxInfo.vendor(); // Enable supported shader-related caps if (kGL_GrGLStandard == standard) { fDualSourceBlendingSupport = ctxInfo.version() >= GR_GL_VER(3,3) || ctxInfo.hasExtension("GL_ARB_blend_func_extended"); fShaderDerivativeSupport = true; // we don't support GL_ARB_geometry_shader4, just GL 3.2+ GS fGeometryShaderSupport = ctxInfo.version() >= GR_GL_VER(3,2) && ctxInfo.glslGeneration() >= k150_GrGLSLGeneration; } else { fShaderDerivativeSupport = ctxInfo.hasExtension("GL_OES_standard_derivatives"); } if (GrGLCaps::kES_IMG_MsToTexture_MSFBOType == fMSFBOType) { GR_GL_GetIntegerv(gli, GR_GL_MAX_SAMPLES_IMG, &fMaxSampleCount); } else if (GrGLCaps::kNone_MSFBOType != fMSFBOType) { GR_GL_GetIntegerv(gli, GR_GL_MAX_SAMPLES, &fMaxSampleCount); } this->initConfigTexturableTable(ctxInfo, gli); this->initConfigRenderableTable(ctxInfo); return true; }
void GrGLCaps::init(const GrGLContextInfo& ctxInfo) { this->reset(); if (!ctxInfo.isInitialized()) { return; } const GrGLInterface* gli = ctxInfo.interface(); GrGLBinding binding = ctxInfo.binding(); GrGLVersion version = ctxInfo.version(); if (kES2_GrGLBinding == binding) { GR_GL_GetIntegerv(gli, GR_GL_MAX_FRAGMENT_UNIFORM_VECTORS, &fMaxFragmentUniformVectors); } else { GrAssert(kDesktop_GrGLBinding == binding); GrGLint max; GR_GL_GetIntegerv(gli, GR_GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, &max); fMaxFragmentUniformVectors = max / 4; } GR_GL_GetIntegerv(gli, GR_GL_MAX_VERTEX_ATTRIBS, &fMaxVertexAttributes); if (kDesktop_GrGLBinding == binding) { fRGBA8RenderbufferSupport = true; } else { fRGBA8RenderbufferSupport = ctxInfo.hasExtension("GL_OES_rgb8_rgba8") || ctxInfo.hasExtension("GL_ARM_rgba8"); } if (kDesktop_GrGLBinding == binding) { fBGRAFormatSupport = version >= GR_GL_VER(1,2) || ctxInfo.hasExtension("GL_EXT_bgra"); } else { if (ctxInfo.hasExtension("GL_APPLE_texture_format_BGRA8888")) { fBGRAFormatSupport = true; } else if (ctxInfo.hasExtension("GL_EXT_texture_format_BGRA8888")) { fBGRAFormatSupport = true; fBGRAIsInternalFormat = true; } GrAssert(fBGRAFormatSupport || kSkia8888_GrPixelConfig != kBGRA_8888_GrPixelConfig); } if (kDesktop_GrGLBinding == binding) { fTextureSwizzleSupport = version >= GR_GL_VER(3,3) || ctxInfo.hasExtension("GL_ARB_texture_swizzle"); } else { fTextureSwizzleSupport = false; } if (kDesktop_GrGLBinding == binding) { fUnpackRowLengthSupport = true; fUnpackFlipYSupport = false; fPackRowLengthSupport = true; fPackFlipYSupport = false; } else { fUnpackRowLengthSupport =ctxInfo.hasExtension("GL_EXT_unpack_subimage"); fUnpackFlipYSupport = ctxInfo.hasExtension("GL_CHROMIUM_flipy"); // no extension for pack row length fPackRowLengthSupport = false; fPackFlipYSupport = ctxInfo.hasExtension("GL_ANGLE_pack_reverse_row_order"); } fTextureUsageSupport = (kES2_GrGLBinding == binding) && ctxInfo.hasExtension("GL_ANGLE_texture_usage"); // Tex storage is in desktop 4.2 and can be an extension to desktop or ES. fTexStorageSupport = (kDesktop_GrGLBinding == binding && version >= GR_GL_VER(4,2)) || ctxInfo.hasExtension("GL_ARB_texture_storage") || ctxInfo.hasExtension("GL_EXT_texture_storage"); // ARB_texture_rg is part of OpenGL 3.0 if (kDesktop_GrGLBinding == binding) { fTextureRedSupport = version >= GR_GL_VER(3,0) || ctxInfo.hasExtension("GL_ARB_texture_rg"); } else { fTextureRedSupport = ctxInfo.hasExtension("GL_EXT_texture_rg"); } fImagingSupport = kDesktop_GrGLBinding == binding && ctxInfo.hasExtension("GL_ARB_imaging"); // ES 2 only guarantees RGBA/uchar + one other format/type combo for // ReadPixels. The other format has to checked at run-time since it // can change based on which render target is bound fTwoFormatLimit = kES2_GrGLBinding == binding; // Known issue on at least some Intel platforms: // http://code.google.com/p/skia/issues/detail?id=946 if (kIntel_GrGLVendor != ctxInfo.vendor()) { fFragCoordsConventionSupport = ctxInfo.glslGeneration() >= k150_GrGLSLGeneration || ctxInfo.hasExtension("GL_ARB_fragment_coord_conventions"); } this->initFSAASupport(ctxInfo); this->initStencilFormats(ctxInfo); }
bool GrGLSLCaps::init(const GrGLContextInfo& ctxInfo, const GrGLInterface* gli, const GrGLCaps& glCaps) { this->reset(); if (!ctxInfo.isInitialized()) { return false; } GrGLStandard standard = ctxInfo.standard(); GrGLVersion version = ctxInfo.version(); /************************************************************************** * Caps specific to GrGLSLCaps **************************************************************************/ if (kGLES_GrGLStandard == standard) { if (ctxInfo.hasExtension("GL_EXT_shader_framebuffer_fetch")) { fFBFetchNeedsCustomOutput = (version >= GR_GL_VER(3, 0)); fFBFetchSupport = true; fFBFetchColorName = "gl_LastFragData[0]"; fFBFetchExtensionString = "GL_EXT_shader_framebuffer_fetch"; } else if (ctxInfo.hasExtension("GL_NV_shader_framebuffer_fetch")) { // Actually, we haven't seen an ES3.0 device with this extension yet, so we don't know fFBFetchNeedsCustomOutput = false; fFBFetchSupport = true; fFBFetchColorName = "gl_LastFragData[0]"; fFBFetchExtensionString = "GL_NV_shader_framebuffer_fetch"; } else if (ctxInfo.hasExtension("GL_ARM_shader_framebuffer_fetch")) { // The arm extension also requires an additional flag which we will set onResetContext fFBFetchNeedsCustomOutput = false; fFBFetchSupport = true; fFBFetchColorName = "gl_LastFragColorARM"; fFBFetchExtensionString = "GL_ARM_shader_framebuffer_fetch"; } } // Adreno GPUs have a tendency to drop tiles when there is a divide-by-zero in a shader fDropsTileOnZeroDivide = kQualcomm_GrGLVendor == ctxInfo.vendor(); /************************************************************************** * GrShaderCaps fields **************************************************************************/ fPathRenderingSupport = ctxInfo.hasExtension("GL_NV_path_rendering"); if (fPathRenderingSupport) { if (kGL_GrGLStandard == standard) { // We only support v1.3+ of GL_NV_path_rendering which allows us to // set individual fragment inputs with ProgramPathFragmentInputGen. The API // additions are detected by checking the existence of the function. fPathRenderingSupport = ctxInfo.hasExtension("GL_EXT_direct_state_access") && ((ctxInfo.version() >= GR_GL_VER(4, 3) || ctxInfo.hasExtension("GL_ARB_program_interface_query")) && gli->fFunctions.fProgramPathFragmentInputGen); } else { fPathRenderingSupport = ctxInfo.version() >= GR_GL_VER(3, 1); } } // For now these two are equivalent but we could have dst read in shader via some other method fDstReadInShaderSupport = fFBFetchSupport; // Enable supported shader-related caps if (kGL_GrGLStandard == standard) { fDualSourceBlendingSupport = ctxInfo.version() >= GR_GL_VER(3, 3) || ctxInfo.hasExtension("GL_ARB_blend_func_extended"); fShaderDerivativeSupport = true; // we don't support GL_ARB_geometry_shader4, just GL 3.2+ GS fGeometryShaderSupport = ctxInfo.version() >= GR_GL_VER(3, 2) && ctxInfo.glslGeneration() >= k150_GrGLSLGeneration; } else { fShaderDerivativeSupport = ctxInfo.version() >= GR_GL_VER(3, 0) || ctxInfo.hasExtension("GL_OES_standard_derivatives"); } if (glCaps.advancedBlendEquationSupport()) { bool coherent = glCaps.advancedCoherentBlendEquationSupport(); if (ctxInfo.hasExtension(coherent ? "GL_NV_blend_equation_advanced_coherent" : "GL_NV_blend_equation_advanced")) { fAdvBlendEqInteraction = kAutomatic_AdvBlendEqInteraction; } else { fAdvBlendEqInteraction = kGeneralEnable_AdvBlendEqInteraction; // TODO: Use the following on any platform where "blend_support_all_equations" is slow. //fAdvBlendEqInteraction = kSpecificEnables_AdvBlendEqInteraction; } } this->initShaderPrecisionTable(ctxInfo, gli); return true; }
void GrGLCaps::init(const GrGLContextInfo& ctxInfo, const GrGLInterface* gli) { this->reset(); if (!ctxInfo.isInitialized()) { return; } GrGLBinding binding = ctxInfo.binding(); GrGLVersion version = ctxInfo.version(); /************************************************************************** * Caps specific to GrGLCaps **************************************************************************/ if (kES2_GrGLBinding == binding) { GR_GL_GetIntegerv(gli, GR_GL_MAX_FRAGMENT_UNIFORM_VECTORS, &fMaxFragmentUniformVectors); } else { GrAssert(kDesktop_GrGLBinding == binding); GrGLint max; GR_GL_GetIntegerv(gli, GR_GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, &max); fMaxFragmentUniformVectors = max / 4; } GR_GL_GetIntegerv(gli, GR_GL_MAX_VERTEX_ATTRIBS, &fMaxVertexAttributes); if (kDesktop_GrGLBinding == binding) { fRGBA8RenderbufferSupport = true; } else { fRGBA8RenderbufferSupport = ctxInfo.hasExtension("GL_OES_rgb8_rgba8") || ctxInfo.hasExtension("GL_ARM_rgba8"); } if (kDesktop_GrGLBinding == binding) { fBGRAFormatSupport = version >= GR_GL_VER(1,2) || ctxInfo.hasExtension("GL_EXT_bgra"); } else { if (ctxInfo.hasExtension("GL_APPLE_texture_format_BGRA8888")) { fBGRAFormatSupport = true; } else if (ctxInfo.hasExtension("GL_EXT_texture_format_BGRA8888")) { fBGRAFormatSupport = true; fBGRAIsInternalFormat = true; } GrAssert(fBGRAFormatSupport || kSkia8888_GrPixelConfig != kBGRA_8888_GrPixelConfig); } if (kDesktop_GrGLBinding == binding) { fTextureSwizzleSupport = version >= GR_GL_VER(3,3) || ctxInfo.hasExtension("GL_ARB_texture_swizzle"); } else { fTextureSwizzleSupport = false; } if (kDesktop_GrGLBinding == binding) { fUnpackRowLengthSupport = true; fUnpackFlipYSupport = false; fPackRowLengthSupport = true; fPackFlipYSupport = false; } else { fUnpackRowLengthSupport =ctxInfo.hasExtension("GL_EXT_unpack_subimage"); fUnpackFlipYSupport = ctxInfo.hasExtension("GL_CHROMIUM_flipy"); // no extension for pack row length fPackRowLengthSupport = false; fPackFlipYSupport = ctxInfo.hasExtension("GL_ANGLE_pack_reverse_row_order"); } fTextureUsageSupport = (kES2_GrGLBinding == binding) && ctxInfo.hasExtension("GL_ANGLE_texture_usage"); // Tex storage is in desktop 4.2 and can be an extension to desktop or ES. fTexStorageSupport = (kDesktop_GrGLBinding == binding && version >= GR_GL_VER(4,2)) || ctxInfo.hasExtension("GL_ARB_texture_storage") || ctxInfo.hasExtension("GL_EXT_texture_storage"); // ARB_texture_rg is part of OpenGL 3.0 if (kDesktop_GrGLBinding == binding) { fTextureRedSupport = version >= GR_GL_VER(3,0) || ctxInfo.hasExtension("GL_ARB_texture_rg"); } else { fTextureRedSupport = ctxInfo.hasExtension("GL_EXT_texture_rg"); } fImagingSupport = kDesktop_GrGLBinding == binding && ctxInfo.hasExtension("GL_ARB_imaging"); // ES 2 only guarantees RGBA/uchar + one other format/type combo for // ReadPixels. The other format has to checked at run-time since it // can change based on which render target is bound fTwoFormatLimit = kES2_GrGLBinding == binding; // Known issue on at least some Intel platforms: // http://code.google.com/p/skia/issues/detail?id=946 if (kIntel_GrGLVendor != ctxInfo.vendor()) { fFragCoordsConventionSupport = ctxInfo.glslGeneration() >= k150_GrGLSLGeneration || ctxInfo.hasExtension("GL_ARB_fragment_coord_conventions"); } // SGX and Mali GPUs that are based on a tiled-deferred architecture that have trouble with // frequently changing VBOs. We've measured a performance increase using non-VBO vertex // data for dynamic content on these GPUs. Perhaps we should read the renderer string and // limit this decision to specific GPU families rather than basing it on the vendor alone. if (!GR_GL_MUST_USE_VBO && (kARM_GrGLVendor == ctxInfo.vendor() || kImagination_GrGLVendor == ctxInfo.vendor())) { fUseNonVBOVertexAndIndexDynamicData = true; } if (kDesktop_GrGLBinding == binding && version >= GR_GL_VER(3, 2)) { GrGLint profileMask; GR_GL_GetIntegerv(gli, GR_GL_CONTEXT_PROFILE_MASK, &profileMask); fIsCoreProfile = SkToBool(profileMask & GR_GL_CONTEXT_CORE_PROFILE_BIT); } fDiscardFBSupport = ctxInfo.hasExtension("GL_EXT_discard_framebuffer"); if (kDesktop_GrGLBinding == binding) { fVertexArrayObjectSupport = version >= GR_GL_VER(3, 0) || ctxInfo.hasExtension("GL_ARB_vertex_array_object"); } else { fVertexArrayObjectSupport = ctxInfo.hasExtension("GL_OES_vertex_array_object"); } this->initFSAASupport(ctxInfo, gli); this->initStencilFormats(ctxInfo); /************************************************************************** * GrDrawTargetCaps fields **************************************************************************/ GrGLint maxTextureUnits; // check FS and fixed-function texture unit limits // we only use textures in the fragment stage currently. // checks are > to make sure we have a spare unit. GR_GL_GetIntegerv(gli, GR_GL_MAX_TEXTURE_IMAGE_UNITS, &maxTextureUnits); GrGLint numFormats; GR_GL_GetIntegerv(gli, GR_GL_NUM_COMPRESSED_TEXTURE_FORMATS, &numFormats); SkAutoSTMalloc<10, GrGLint> formats(numFormats); GR_GL_GetIntegerv(gli, GR_GL_COMPRESSED_TEXTURE_FORMATS, formats); for (int i = 0; i < numFormats; ++i) { if (formats[i] == GR_GL_PALETTE8_RGBA8) { f8BitPaletteSupport = true; break; } } if (kDesktop_GrGLBinding == binding) { // we could also look for GL_ATI_separate_stencil extension or // GL_EXT_stencil_two_side but they use different function signatures // than GL2.0+ (and than each other). fTwoSidedStencilSupport = (ctxInfo.version() >= GR_GL_VER(2,0)); // supported on GL 1.4 and higher or by extension fStencilWrapOpsSupport = (ctxInfo.version() >= GR_GL_VER(1,4)) || ctxInfo.hasExtension("GL_EXT_stencil_wrap"); } else { // ES 2 has two sided stencil and stencil wrap fTwoSidedStencilSupport = true; fStencilWrapOpsSupport = true; } if (kDesktop_GrGLBinding == binding) { fBufferLockSupport = true; // we require VBO support and the desktop VBO extension includes // glMapBuffer. } else { fBufferLockSupport = ctxInfo.hasExtension("GL_OES_mapbuffer"); } if (kDesktop_GrGLBinding == binding) { if (ctxInfo.version() >= GR_GL_VER(2,0) || ctxInfo.hasExtension("GL_ARB_texture_non_power_of_two")) { fNPOTTextureTileSupport = true; } else { fNPOTTextureTileSupport = false; } } else { // Unextended ES2 supports NPOT textures with clamp_to_edge and non-mip filters only fNPOTTextureTileSupport = ctxInfo.hasExtension("GL_OES_texture_npot"); } fHWAALineSupport = (kDesktop_GrGLBinding == binding); GR_GL_GetIntegerv(gli, GR_GL_MAX_TEXTURE_SIZE, &fMaxTextureSize); GR_GL_GetIntegerv(gli, GR_GL_MAX_RENDERBUFFER_SIZE, &fMaxRenderTargetSize); // Our render targets are always created with textures as the color // attachment, hence this min: fMaxRenderTargetSize = GrMin(fMaxTextureSize, fMaxRenderTargetSize); fPathStencilingSupport = GR_GL_USE_NV_PATH_RENDERING && ctxInfo.hasExtension("GL_NV_path_rendering"); // Enable supported shader-related caps if (kDesktop_GrGLBinding == binding) { fDualSourceBlendingSupport = ctxInfo.version() >= GR_GL_VER(3,3) || ctxInfo.hasExtension("GL_ARB_blend_func_extended"); fShaderDerivativeSupport = true; // we don't support GL_ARB_geometry_shader4, just GL 3.2+ GS fGeometryShaderSupport = ctxInfo.version() >= GR_GL_VER(3,2) && ctxInfo.glslGeneration() >= k150_GrGLSLGeneration; } else { fShaderDerivativeSupport = ctxInfo.hasExtension("GL_OES_standard_derivatives"); } if (GrGLCaps::kImaginationES_MSFBOType == fMSFBOType) { GR_GL_GetIntegerv(gli, GR_GL_MAX_SAMPLES_IMG, &fMaxSampleCount); } else if (GrGLCaps::kNone_MSFBOType != fMSFBOType) { GR_GL_GetIntegerv(gli, GR_GL_MAX_SAMPLES, &fMaxSampleCount); } }