GrGLCaps.cpp File Reference

#include "src/gpu/ganesh/gl/GrGLCaps.h"
#include "include/core/SkColor.h"
#include "include/core/SkRect.h"
#include "include/core/SkSize.h"
#include "include/core/SkTextureCompressionType.h"
#include "include/gpu/GpuTypes.h"
#include "include/gpu/GrContextOptions.h"
#include "include/gpu/GrDriverBugWorkarounds.h"
#include "include/gpu/GrTypes.h"
#include "include/gpu/ganesh/gl/GrGLBackendSurface.h"
#include "include/gpu/gl/GrGLFunctions.h"
#include "include/gpu/gl/GrGLInterface.h"
#include "include/private/base/SkMath.h"
#include "include/private/base/SkTemplates.h"
#include "include/private/base/SkTo.h"
#include "src/core/SkCompressedDataUtils.h"
#include "src/gpu/Blend.h"
#include "src/gpu/ganesh/GrBackendUtils.h"
#include "src/gpu/ganesh/GrProgramDesc.h"
#include "src/gpu/ganesh/GrRenderTarget.h"
#include "src/gpu/ganesh/GrRenderTargetProxy.h"
#include "src/gpu/ganesh/GrShaderCaps.h"
#include "src/gpu/ganesh/GrSurface.h"
#include "src/gpu/ganesh/GrSurfaceProxy.h"
#include "src/gpu/ganesh/GrSurfaceProxyPriv.h"
#include "src/gpu/ganesh/GrTextureProxy.h"
#include "src/gpu/ganesh/TestFormatColorTypeCombination.h"
#include "src/gpu/ganesh/gl/GrGLContext.h"
#include "src/gpu/ganesh/gl/GrGLDefines.h"
#include "src/gpu/ganesh/gl/GrGLRenderTarget.h"
#include "src/gpu/ganesh/gl/GrGLTexture.h"
#include "src/gpu/ganesh/gl/GrGLUtil.h"
#include "src/sksl/SkSLGLSL.h"
#include <algorithm>
#include <cstddef>
#include <initializer_list>
#include <memory>

Go to the source code of this file.

Functions
static bool	angle_backend_is_d3d (GrGLANGLEBackend backend)
static bool	angle_backend_is_metal (GrGLANGLEBackend backend)
const char *	get_glsl_version_decl_string (GrGLStandard standard, SkSL::GLSLGeneration generation, bool isCoreProfile)
bool	is_float_fp32 (const GrGLContextInfo &ctxInfo, const GrGLInterface *gli, GrGLenum precision)
static bool	has_msaa_render_buffer (const GrSurfaceProxy *surf, const GrGLCaps &glCaps)
size_t	offset_alignment_for_transfer_buffer (GrGLenum externalType)

Function Documentation

angle_backend_is_d3d()

static bool angle_backend_is_d3d ( GrGLANGLEBackend  backend )

static

Definition at line 109 of file GrGLCaps.cpp.

                                                           {
    return backend == GrGLANGLEBackend::kD3D9 || backend == GrGLANGLEBackend::kD3D11;
}

angle_backend_is_metal()

static bool angle_backend_is_metal ( GrGLANGLEBackend  backend )

static

Definition at line 113 of file GrGLCaps.cpp.

                                                             {
    return backend == GrGLANGLEBackend::kMetal;
}

get_glsl_version_decl_string()

const char * get_glsl_version_decl_string	(	GrGLStandard	standard,
		SkSL::GLSLGeneration	generation,
		bool	isCoreProfile
	)

Definition at line 863 of file GrGLCaps.cpp.

                                                             {
    if (GR_IS_GR_GL(standard)) {
        switch (generation) {
            case SkSL::GLSLGeneration::k110:
                return "#version 110\n";
            case SkSL::GLSLGeneration::k130:
                return "#version 130\n";
            case SkSL::GLSLGeneration::k140:
                return "#version 140\n";
            case SkSL::GLSLGeneration::k150:
                if (isCoreProfile) {
                    return "#version 150\n";
                } else {
                    return "#version 150 compatibility\n";
                }
            case SkSL::GLSLGeneration::k330:
                if (isCoreProfile) {
                    return "#version 330\n";
                } else {
                    return "#version 330 compatibility\n";
                }
            case SkSL::GLSLGeneration::k400:
                if (isCoreProfile) {
                    return "#version 400\n";
                } else {
                    return "#version 400 compatibility\n";
                }
            case SkSL::GLSLGeneration::k420:
                if (isCoreProfile) {
                    return "#version 420\n";
                } else {
                    return "#version 420 compatibility\n";
                }
            default:
                break;
        }
    } else if (GR_IS_GR_GL_ES(standard) || GR_IS_GR_WEBGL(standard)) {
        switch (generation) {
            case SkSL::GLSLGeneration::k100es:
                return "#version 100\n";
            case SkSL::GLSLGeneration::k300es:
                return "#version 300 es\n";
            case SkSL::GLSLGeneration::k310es:
                return "#version 310 es\n";
            case SkSL::GLSLGeneration::k320es:
                return "#version 320 es\n";
            default:
                break;
        }
    }
    return "<no version>";
}

has_msaa_render_buffer()

static bool has_msaa_render_buffer ( const GrSurfaceProxy *  surf, const GrGLCaps &  glCaps  )

static

Definition at line 3685 of file GrGLCaps.cpp.

                                                                                       {
    const GrRenderTargetProxy* rt = surf->asRenderTargetProxy();
    if (!rt) {
        return false;
    }
    // A RT has a separate MSAA renderbuffer if:
    // 1) It's multisampled
    // 2) We're using an extension with separate MSAA renderbuffers
    // 3) It's not FBO 0, which is special and always auto-resolves
    return rt->numSamples() > 1 &&
           glCaps.usesMSAARenderBuffers() &&
           !rt->glRTFBOIDIs0();
}

is_float_fp32()

bool is_float_fp32	(	const GrGLContextInfo &	ctxInfo,
		const GrGLInterface *	gli,
		GrGLenum	precision
	)

Definition at line 917 of file GrGLCaps.cpp.

                                                                                                 {
    if (GR_IS_GR_GL(ctxInfo.standard()) &&
        ctxInfo.version() < GR_GL_VER(4,1) &&
        !ctxInfo.hasExtension("GL_ARB_ES2_compatibility")) {
        // We're on a desktop GL that doesn't have precision info. Assume they're all 32bit float.
        return true;
    }
    // glGetShaderPrecisionFormat doesn't accept GL_GEOMETRY_SHADER as a shader type. Hopefully the
    // geometry shaders don't have lower precision than vertex and fragment.
    for (GrGLenum shader : {GR_GL_FRAGMENT_SHADER, GR_GL_VERTEX_SHADER}) {
        GrGLint range[2];
        GrGLint bits;
        GR_GL_GetShaderPrecisionFormat(gli, shader, precision, range, &bits);
        if (range[0] < 127 || range[1] < 127 || bits < 23) {
            return false;
        }
    }
    return true;
}

offset_alignment_for_transfer_buffer()

size_t offset_alignment_for_transfer_buffer

(

GrGLenum

externalType

)

Definition at line 4770 of file GrGLCaps.cpp.

                                                                   {
    // This switch is derived from a table titled "Pixel data type parameter values and the
    // corresponding GL data types" in the OpenGL spec (Table 8.2 in OpenGL 4.5).
    switch (externalType) {
        case GR_GL_UNSIGNED_BYTE:                   return sizeof(GrGLubyte);
        case GR_GL_BYTE:                            return sizeof(GrGLbyte);
        case GR_GL_UNSIGNED_SHORT:                  return sizeof(GrGLushort);
        case GR_GL_SHORT:                           return sizeof(GrGLshort);
        case GR_GL_UNSIGNED_INT:                    return sizeof(GrGLuint);
        case GR_GL_INT:                             return sizeof(GrGLint);
        case GR_GL_HALF_FLOAT:                      return sizeof(GrGLhalf);
        case GR_GL_HALF_FLOAT_OES:                  return sizeof(GrGLhalf);
        case GR_GL_FLOAT:                           return sizeof(GrGLfloat);
        case GR_GL_UNSIGNED_SHORT_5_6_5:            return sizeof(GrGLushort);
        case GR_GL_UNSIGNED_SHORT_4_4_4_4:          return sizeof(GrGLushort);
        case GR_GL_UNSIGNED_SHORT_5_5_5_1:          return sizeof(GrGLushort);
        case GR_GL_UNSIGNED_INT_2_10_10_10_REV:     return sizeof(GrGLuint);
#if 0  // GL types we currently don't use. Here for future reference.
        case GR_GL_UNSIGNED_BYTE_3_3_2:             return sizeof(GrGLubyte);
        case GR_GL_UNSIGNED_BYTE_2_3_3_REV:         return sizeof(GrGLubyte);
        case GR_GL_UNSIGNED_SHORT_5_6_5_REV:        return sizeof(GrGLushort);
        case GR_GL_UNSIGNED_SHORT_4_4_4_4_REV:      return sizeof(GrGLushort);
        case GR_GL_UNSIGNED_SHORT_1_5_5_5_REV:      return sizeof(GrGLushort);
        case GR_GL_UNSIGNED_INT_8_8_8_8:            return sizeof(GrGLuint);
        case GR_GL_UNSIGNED_INT_8_8_8_8_REV:        return sizeof(GrGLuint);
        case GR_GL_UNSIGNED_INT_10_10_10_2:         return sizeof(GrGLuint);
        case GR_GL_UNSIGNED_INT_24_8:               return sizeof(GrGLuint);
        case GR_GL_UNSIGNED_INT_10F_11F_11F_REV:    return sizeof(GrGLuint);
        case GR_GL_UNSIGNED_INT_5_9_9_9_REV:        return sizeof(GrGLuint);
        // This one is not corresponding to a GL data type and the spec just says it is 4.
        case GR_GL_FLOAT_32_UNSIGNED_INT_24_8_REV:  return 4;
#endif
        default:                                    return 0;
    }
}