#include "include/gpu/gl/GrGLInterface.h"
#include "include/private/gpu/ganesh/GrTypesPriv.h"
#include "src/core/SkImageInfoPriv.h"
#include "src/gpu/ganesh/GrDataUtils.h"
#include "src/gpu/ganesh/GrStencilSettings.h"
#include "src/gpu/ganesh/gl/GrGLDefines.h"

Classes
struct	GrGLDriverInfo

Macros
#define	GR_GL_VER(major, minor)

#define	GR_GLSL_VER(major, minor)

#define	GR_GL_DRIVER_VER(major, minor, point)

#define	GR_GL_MAJOR_VER(version) (static_cast<uint32_t>(version) >> 16)

#define	GR_GL_MINOR_VER(version) (static_cast<uint32_t>(version) & 0xFFFF)

#define	GR_GL_INVALID_VER GR_GL_VER(0, 0)

#define	GR_GLSL_INVALID_VER GR_GLSL_VER(0, 0)

#define	GR_GL_DRIVER_UNKNOWN_VER GR_GL_DRIVER_VER(0, 0, 0)

#define	GR_GL_INIT_ZERO 0

#define	GR_GL_GetIntegerv(gl, e, p)

#define	GR_GL_GetFloatv(gl, e, p)

#define	GR_GL_GetFramebufferAttachmentParameteriv(gl, t, a, pname, p)

#define	GR_GL_GetInternalformativ(gl, t, f, n, s, p)

#define	GR_GL_GetNamedFramebufferAttachmentParameteriv(gl, fb, a, pname, p)

#define	GR_GL_GetRenderbufferParameteriv(gl, t, pname, p)

#define	GR_GL_GetTexLevelParameteriv(gl, t, l, pname, p)

#define	GR_GL_GetShaderPrecisionFormat(gl, st, pt, range, precision)

#define	GR_STRING(X) GR_STRING_IMPL(X)

#define	GR_STRING_IMPL(X) #X

#define	GR_FILE_AND_LINE_STR __FILE__ "(" GR_STRING(__LINE__) ") : "

#define	GR_GL_CHECK_ERROR_IMPL(IFACE, X)

#define	GR_GL_LOG_CALLS_IMPL(X)

#define	GR_GL_CALL(IFACE, X)

#define	GR_GL_CALL_NOERRCHECK(IFACE, X)

#define	GR_GL_CALL_RET(IFACE, RET, X)

#define	GR_GL_CALL_RET_NOERRCHECK(IFACE, RET, X)

Typedefs
typedef uint32_t	GrGLVersion

typedef uint32_t	GrGLSLVersion

typedef uint64_t	GrGLDriverVersion

Enumerations
enum class	GrGLVendor { kARM , kGoogle , kImagination , kIntel , kQualcomm , kNVIDIA , kATI , kApple , kOther }

enum class	GrGLRenderer { kTegra_PreK1 , kTegra , kPowerVR54x , kPowerVRBSeries , kPowerVRRogue , kAdreno3xx , kAdreno430 , kAdreno4xx_other , kAdreno530 , kAdreno5xx_other , kAdreno615 , kAdreno620 , kAdreno630 , kAdreno640 , kAdreno6xx_other , kIntelSandyBridge , kIntelIvyBridge , kIntelValleyView , kIntelHaswell , kIntelCherryView , kIntelBroadwell , kIntelApolloLake , kIntelSkyLake , kIntelGeminiLake , kIntelKabyLake , kIntelCoffeeLake , kIntelIceLake , kIntelRocketLake , kIntelTigerLake , kIntelAlderLake , kGalliumLLVM , kMali4xx , kMaliG , kMaliT , kAMDRadeonHD7xxx , kAMDRadeonR9M3xx , kAMDRadeonR9M4xx , kAMDRadeonPro5xxx , kAMDRadeonProVegaxx , kApple , kWebGL , kOther }

enum class	GrGLDriver { kMesa , kNVIDIA , kIntel , kQualcomm , kFreedreno , kAndroidEmulator , kImagination , kARM , kApple , kUnknown }

enum class	GrGLANGLEBackend { kUnknown , kD3D9 , kD3D11 , kMetal , kOpenGL }

Functions
static constexpr uint32_t	GrGLFormatChannels (GrGLFormat format)

static constexpr GrColorFormatDesc	GrGLFormatDesc (GrGLFormat format)

GrGLStandard	GrGLGetStandardInUseFromString (const char *versionString)

GrGLSLVersion	GrGLGetVersion (const GrGLInterface *)

GrGLSLVersion	GrGLGetVersionFromString (const char *)

GrGLDriverInfo	GrGLGetDriverInfo (const GrGLInterface *)

void	GrGLCheckErr (const GrGLInterface gl, const char location, const char *call)

static constexpr GrGLFormat	GrGLFormatFromGLEnum (GrGLenum glFormat)

static constexpr GrGLenum	GrGLFormatToEnum (GrGLFormat format)

static constexpr size_t	GrGLFormatBytesPerBlock (GrGLFormat format)

static constexpr int	GrGLFormatStencilBits (GrGLFormat format)

static constexpr bool	GrGLFormatIsPackedDepthStencil (GrGLFormat format)

static constexpr bool	GrGLFormatIsSRGB (GrGLFormat format)

GrGLenum	GrToGLStencilFunc (GrStencilTest test)

bool	GrGLFormatIsCompressed (GrGLFormat)

Macro Definition Documentation

◆ GR_FILE_AND_LINE_STR

#define GR_FILE_AND_LINE_STR __FILE__ "(" GR_STRING(__LINE__) ") : "

Creates a string of the form "<filename>(<linenumber>) : "

Definition at line 348 of file GrGLUtil.h.

◆ GR_GL_CALL

#define GR_GL_CALL	(	IFACE,
		X
	)

Value:

    do {                                                        \
        GR_GL_CALL_NOERRCHECK(IFACE, X);                        \
        GR_GL_CHECK_ERROR_IMPL(IFACE, X);                       \
    } while (false)

Definition at line 381 of file GrGLUtil.h.

       {                                                        \
        GR_GL_CALL_NOERRCHECK(IFACE, X);                        \
        GR_GL_CHECK_ERROR_IMPL(IFACE, X);                       \
    } while (false)

◆ GR_GL_CALL_NOERRCHECK

#define GR_GL_CALL_NOERRCHECK	(	IFACE,
		X
	)

Value:

    do {                                                        \
        (IFACE)->fFunctions.f##X;                               \
        GR_GL_LOG_CALLS_IMPL(X);                                \
    } while (false)

Definition at line 389 of file GrGLUtil.h.

       {                                                        \
        (IFACE)->fFunctions.f##X;                               \
        GR_GL_LOG_CALLS_IMPL(X);                                \
    } while (false)

◆ GR_GL_CALL_RET

#define GR_GL_CALL_RET	(	IFACE,
		RET,
		X
	)

Value:

    do {                                                        \
        GR_GL_CALL_RET_NOERRCHECK(IFACE, RET, X);               \
        GR_GL_CHECK_ERROR_IMPL(IFACE, X);                       \
    } while (false)

Definition at line 396 of file GrGLUtil.h.

       {                                                        \
        GR_GL_CALL_RET_NOERRCHECK(IFACE, RET, X);               \
        GR_GL_CHECK_ERROR_IMPL(IFACE, X);                       \
    } while (false)

◆ GR_GL_CALL_RET_NOERRCHECK

#define GR_GL_CALL_RET_NOERRCHECK	(	IFACE,
		RET,
		X
	)

Value:

    do {                                                        \
        (RET) = (IFACE)->fFunctions.f##X;                       \
        GR_GL_LOG_CALLS_IMPL(X);                                \
    } while (false)

Definition at line 403 of file GrGLUtil.h.

       {                                                        \
        (RET) = (IFACE)->fFunctions.f##X;                       \
        GR_GL_LOG_CALLS_IMPL(X);                                \
    } while (false)

◆ GR_GL_CHECK_ERROR_IMPL

#define GR_GL_CHECK_ERROR_IMPL	(	IFACE,
		X
	)

Value:

do { \

} while (false)

Macros for using GrGLInterface to make GL calls

Definition at line 364 of file GrGLUtil.h.

365 { \

366 } while (false)

◆ GR_GL_DRIVER_UNKNOWN_VER

#define GR_GL_DRIVER_UNKNOWN_VER GR_GL_DRIVER_VER(0, 0, 0)

Definition at line 39 of file GrGLUtil.h.

◆ GR_GL_DRIVER_VER

#define GR_GL_DRIVER_VER	(	major,
		minor,
		point
	)

Value:

                                               ((static_cast<uint64_t>(major) << 32) | \
                                               (static_cast<uint64_t>(minor) << 16) | \
                                                static_cast<uint64_t>(point))

Definition at line 30 of file GrGLUtil.h.

◆ GR_GL_GetFloatv

#define GR_GL_GetFloatv	(	gl,
		e,
		p
	)

Value:

    do {                                                                       \
        *(p) = GR_GL_INIT_ZERO;                                                \
        GR_GL_CALL(gl, GetFloatv(e, p));                                       \
    } while (0)

Definition at line 251 of file GrGLUtil.h.

       {                                                                       \
        *(p) = GR_GL_INIT_ZERO;                                                \
        GR_GL_CALL(gl, GetFloatv(e, p));                                       \
    } while (0)

◆ GR_GL_GetFramebufferAttachmentParameteriv

#define GR_GL_GetFramebufferAttachmentParameteriv	(	gl,
		t,
		a,
		pname,
		p
	)

Value:

    do {                                                                       \
        *(p) = GR_GL_INIT_ZERO;                                                \
        GR_GL_CALL(gl, GetFramebufferAttachmentParameteriv(t, a, pname, p));   \
    } while (0)

Definition at line 257 of file GrGLUtil.h.

       {                                                                       \
        *(p) = GR_GL_INIT_ZERO;                                                \
        GR_GL_CALL(gl, GetFramebufferAttachmentParameteriv(t, a, pname, p));   \
    } while (0)

◆ GR_GL_GetIntegerv

#define GR_GL_GetIntegerv	(	gl,
		e,
		p
	)

Value:

    do {                                                                       \
        *(p) = GR_GL_INIT_ZERO;                                                \
        GR_GL_CALL(gl, GetIntegerv(e, p));                                     \
    } while (0)

Definition at line 245 of file GrGLUtil.h.

       {                                                                       \
        *(p) = GR_GL_INIT_ZERO;                                                \
        GR_GL_CALL(gl, GetIntegerv(e, p));                                     \
    } while (0)

◆ GR_GL_GetInternalformativ

#define GR_GL_GetInternalformativ	(	gl,
		t,
		f,
		n,
		s,
		p
	)

Value:

    do {                                                                       \
        *(p) = GR_GL_INIT_ZERO;                                                \
        GR_GL_CALL(gl, GetInternalformativ(t, f, n, s, p));                    \
    } while (0)

Definition at line 263 of file GrGLUtil.h.

       {                                                                       \
        *(p) = GR_GL_INIT_ZERO;                                                \
        GR_GL_CALL(gl, GetInternalformativ(t, f, n, s, p));                    \
    } while (0)

◆ GR_GL_GetNamedFramebufferAttachmentParameteriv

#define GR_GL_GetNamedFramebufferAttachmentParameteriv	(	gl,
		fb,
		a,
		pname,
		p
	)

Value:

    do {                                                                             \
        *(p) = GR_GL_INIT_ZERO;                                                      \
        GR_GL_CALL(gl, GetNamedFramebufferAttachmentParameteriv(fb, a, pname, p));   \
    } while (0)

Definition at line 269 of file GrGLUtil.h.

       {                                                                             \
        *(p) = GR_GL_INIT_ZERO;                                                      \
        GR_GL_CALL(gl, GetNamedFramebufferAttachmentParameteriv(fb, a, pname, p));   \
    } while (0)

◆ GR_GL_GetRenderbufferParameteriv

#define GR_GL_GetRenderbufferParameteriv	(	gl,
		t,
		pname,
		p
	)

Value:

    do {                                                                       \
        *(p) = GR_GL_INIT_ZERO;                                                \
        GR_GL_CALL(gl, GetRenderbufferParameteriv(t, pname, p));               \
    } while (0)

Definition at line 275 of file GrGLUtil.h.

       {                                                                       \
        *(p) = GR_GL_INIT_ZERO;                                                \
        GR_GL_CALL(gl, GetRenderbufferParameteriv(t, pname, p));               \
    } while (0)

◆ GR_GL_GetShaderPrecisionFormat

#define GR_GL_GetShaderPrecisionFormat	(	gl,
		st,
		pt,
		range,
		precision
	)

Value:

    do {                                                                       \
        (range)[0] = GR_GL_INIT_ZERO;                                          \
        (range)[1] = GR_GL_INIT_ZERO;                                          \
        (*precision) = GR_GL_INIT_ZERO;                                        \
        GR_GL_CALL(gl, GetShaderPrecisionFormat(st, pt, range, precision));    \
    } while (0)

Definition at line 287 of file GrGLUtil.h.

       {                                                                       \
        (range)[0] = GR_GL_INIT_ZERO;                                          \
        (range)[1] = GR_GL_INIT_ZERO;                                          \
        (*precision) = GR_GL_INIT_ZERO;                                        \
        GR_GL_CALL(gl, GetShaderPrecisionFormat(st, pt, range, precision));    \
    } while (0)

◆ GR_GL_GetTexLevelParameteriv

#define GR_GL_GetTexLevelParameteriv	(	gl,
		t,
		l,
		pname,
		p
	)

Value:

    do {                                                                       \
        *(p) = GR_GL_INIT_ZERO;                                                \
        GR_GL_CALL(gl, GetTexLevelParameteriv(t, l, pname, p));                \
    } while (0)

Definition at line 281 of file GrGLUtil.h.

       {                                                                       \
        *(p) = GR_GL_INIT_ZERO;                                                \
        GR_GL_CALL(gl, GetTexLevelParameteriv(t, l, pname, p));                \
    } while (0)

◆ GR_GL_INIT_ZERO

#define GR_GL_INIT_ZERO 0

Some drivers want the var-int arg to be zero-initialized on input.

Definition at line 244 of file GrGLUtil.h.

◆ GR_GL_INVALID_VER

#define GR_GL_INVALID_VER GR_GL_VER(0, 0)

Definition at line 37 of file GrGLUtil.h.

◆ GR_GL_LOG_CALLS_IMPL

#define GR_GL_LOG_CALLS_IMPL ( X )

Definition at line 377 of file GrGLUtil.h.

◆ GR_GL_MAJOR_VER

#define GR_GL_MAJOR_VER ( version ) (static_cast<uint32_t>(version) >> 16)

Definition at line 34 of file GrGLUtil.h.

◆ GR_GL_MINOR_VER

#define GR_GL_MINOR_VER ( version ) (static_cast<uint32_t>(version) & 0xFFFF)

Definition at line 35 of file GrGLUtil.h.

◆ GR_GL_VER

#define GR_GL_VER	(	major,
		minor
	)

Value:

((static_cast<uint32_t>(major) << 16) | \

static_cast<uint32_t>(minor))

Definition at line 26 of file GrGLUtil.h.

◆ GR_GLSL_INVALID_VER

#define GR_GLSL_INVALID_VER GR_GLSL_VER(0, 0)

Definition at line 38 of file GrGLUtil.h.

◆ GR_GLSL_VER

#define GR_GLSL_VER	(	major,
		minor
	)

Value:

((static_cast<uint32_t>(major) << 16) | \

static_cast<uint32_t>(minor))

Definition at line 28 of file GrGLUtil.h.

◆ GR_STRING

#define GR_STRING ( X ) GR_STRING_IMPL(X)

GR_STRING makes a string of X where X is expanded before conversion to a string if X itself contains macros.

Definition at line 342 of file GrGLUtil.h.

◆ GR_STRING_IMPL

#define GR_STRING_IMPL ( X ) #X

Definition at line 343 of file GrGLUtil.h.

Typedef Documentation

◆ GrGLDriverVersion

typedef uint64_t GrGLDriverVersion

Definition at line 24 of file GrGLUtil.h.

◆ GrGLSLVersion

typedef uint32_t GrGLSLVersion

Definition at line 23 of file GrGLUtil.h.

◆ GrGLVersion

typedef uint32_t GrGLVersion

Definition at line 22 of file GrGLUtil.h.

Enumeration Type Documentation

◆ GrGLANGLEBackend

enum class GrGLANGLEBackend

strong

Enumerator
kUnknown
kD3D9
kD3D11
kMetal
kOpenGL

Definition at line 231 of file GrGLUtil.h.

                            {
    kUnknown,
    kD3D9,
    kD3D11,
    kMetal,
    kOpenGL
};

◆ GrGLDriver

enum class GrGLDriver

strong

Enumerator
kMesa
kNVIDIA
kIntel
kQualcomm
kFreedreno
kAndroidEmulator
kImagination
kARM
kApple
kUnknown

Definition at line 218 of file GrGLUtil.h.

                      {
    kMesa,
    kNVIDIA,
    kIntel,
    kQualcomm,
    kFreedreno,
    kAndroidEmulator,
    kImagination,
    kARM,
    kApple,
    kUnknown
};

◆ GrGLRenderer

enum class GrGLRenderer

strong

Enumerator
kTegra_PreK1
kTegra
kPowerVR54x
kPowerVRBSeries
kPowerVRRogue
kAdreno3xx
kAdreno430
kAdreno4xx_other
kAdreno530
kAdreno5xx_other
kAdreno615
kAdreno620
kAdreno630
kAdreno640
kAdreno6xx_other
kIntelSandyBridge	Intel GPU families, ordered by generation
kIntelIvyBridge
kIntelValleyView
kIntelHaswell
kIntelCherryView
kIntelBroadwell
kIntelApolloLake
kIntelSkyLake
kIntelGeminiLake
kIntelKabyLake
kIntelCoffeeLake
kIntelIceLake
kIntelRocketLake
kIntelTigerLake
kIntelAlderLake
kGalliumLLVM
kMali4xx
kMaliG	G-3x, G-5x, or G-7x
kMaliT	T-6xx, T-7xx, or T-8xx
kAMDRadeonHD7xxx
kAMDRadeonR9M3xx
kAMDRadeonR9M4xx
kAMDRadeonPro5xxx
kAMDRadeonProVegaxx
kApple
kWebGL
kOther

Definition at line 150 of file GrGLUtil.h.

                        {
    kTegra_PreK1,  // Legacy Tegra architecture (pre-K1).
    kTegra,        // Tegra with the same architecture as NVIDIA desktop GPUs (K1+).
 
    kPowerVR54x,
    kPowerVRBSeries,
    kPowerVRRogue,
 
    kAdreno3xx,
    kAdreno430,
    kAdreno4xx_other,
    kAdreno530,
    kAdreno5xx_other,
    kAdreno615,  // Pixel3a
    kAdreno620,  // Pixel5
    kAdreno630,  // Pixel3
    kAdreno640,  // Pixel4
    kAdreno6xx_other,
 
    /** Intel GPU families, ordered by generation **/
    // 6th gen
    kIntelSandyBridge,
 
    // 7th gen
    kIntelIvyBridge,
    kIntelValleyView,  // aka BayTrail
    kIntelHaswell,
 
    // 8th gen
    kIntelCherryView,  // aka Braswell
    kIntelBroadwell,
 
    // 9th gen
    kIntelApolloLake,
    kIntelSkyLake,
    kIntelGeminiLake,
    kIntelKabyLake,
    kIntelCoffeeLake,
 
    // 11th gen
    kIntelIceLake,
 
    // 12th gen
    kIntelRocketLake,
    kIntelTigerLake,
    kIntelAlderLake,
 
    kGalliumLLVM,
 
    kMali4xx,
    /** G-3x, G-5x, or G-7x */
    kMaliG,
    /** T-6xx, T-7xx, or T-8xx */
    kMaliT,
 
    kAMDRadeonHD7xxx,     // AMD Radeon HD 7000 Series
    kAMDRadeonR9M3xx,     // AMD Radeon R9 M300 Series
    kAMDRadeonR9M4xx,     // AMD Radeon R9 M400 Series
    kAMDRadeonPro5xxx,    // AMD Radeon Pro 5000 Series
    kAMDRadeonProVegaxx,  // AMD Radeon Pro Vega
 
    kApple,
 
    kWebGL,
 
    kOther
};

◆ GrGLVendor

enum class GrGLVendor

strong

The Vendor and Renderer enum values are lazily updated as required.

Enumerator
kARM
kGoogle
kImagination
kIntel
kQualcomm
kNVIDIA
kATI
kApple
kOther

Definition at line 137 of file GrGLUtil.h.

                      {
    kARM,
    kGoogle,
    kImagination,
    kIntel,
    kQualcomm,
    kNVIDIA,
    kATI,
    kApple,
 
    kOther
};

Function Documentation

◆ GrGLCheckErr()

void GrGLCheckErr	(	const GrGLInterface *	gl,
		const char *	location,
		const char *	call
	)

Helpers for glGetError()

◆ GrGLFormatBytesPerBlock()

static constexpr size_t GrGLFormatBytesPerBlock ( GrGLFormat format )

staticconstexpr

Definition at line 479 of file GrGLUtil.h.

                                                                   {
    switch (format) {
        case GrGLFormat::kRGBA8:                return 4;
        case GrGLFormat::kR8:                   return 1;
        case GrGLFormat::kALPHA8:               return 1;
        case GrGLFormat::kLUMINANCE8:           return 1;
        case GrGLFormat::kLUMINANCE8_ALPHA8:    return 2;
        case GrGLFormat::kBGRA8:                return 4;
        case GrGLFormat::kRGB565:               return 2;
        case GrGLFormat::kRGBA16F:              return 8;
        case GrGLFormat::kLUMINANCE16F:         return 2;
        case GrGLFormat::kR16F:                 return 2;
        // We assume the GPU stores this format 4 byte aligned
        case GrGLFormat::kRGB8:                 return 4;
        case GrGLFormat::kRGBX8:                return 4;
        case GrGLFormat::kRG8:                  return 2;
        case GrGLFormat::kRGB10_A2:             return 4;
        case GrGLFormat::kRGBA4:                return 2;
        case GrGLFormat::kSRGB8_ALPHA8:         return 4;
        case GrGLFormat::kCOMPRESSED_ETC1_RGB8: return 8;
        case GrGLFormat::kCOMPRESSED_RGB8_ETC2: return 8;
        case GrGLFormat::kCOMPRESSED_RGB8_BC1:  return 8;
        case GrGLFormat::kCOMPRESSED_RGBA8_BC1: return 8;
        case GrGLFormat::kR16:                  return 2;
        case GrGLFormat::kRG16:                 return 4;
        case GrGLFormat::kRGBA16:               return 8;
        case GrGLFormat::kRG16F:                return 4;
        case GrGLFormat::kSTENCIL_INDEX8:       return 1;
        case GrGLFormat::kSTENCIL_INDEX16:      return 2;
        case GrGLFormat::kDEPTH24_STENCIL8:     return 4;
        case GrGLFormat::kUnknown:              return 0;
    }
    SkUNREACHABLE;
}

◆ GrGLFormatChannels()

static constexpr uint32_t GrGLFormatChannels ( GrGLFormat format )

staticconstexpr

Definition at line 41 of file GrGLUtil.h.

                                                                {
    switch (format) {
        case GrGLFormat::kUnknown:               return 0;
        case GrGLFormat::kRGBA8:                 return kRGBA_SkColorChannelFlags;
        case GrGLFormat::kR8:                    return kRed_SkColorChannelFlag;
        case GrGLFormat::kALPHA8:                return kAlpha_SkColorChannelFlag;
        case GrGLFormat::kLUMINANCE8:            return kGray_SkColorChannelFlag;
        case GrGLFormat::kLUMINANCE8_ALPHA8:     return kGrayAlpha_SkColorChannelFlags;
        case GrGLFormat::kBGRA8:                 return kRGBA_SkColorChannelFlags;
        case GrGLFormat::kRGB565:                return kRGB_SkColorChannelFlags;
        case GrGLFormat::kRGBA16F:               return kRGBA_SkColorChannelFlags;
        case GrGLFormat::kR16F:                  return kRed_SkColorChannelFlag;
        case GrGLFormat::kRGB8:                  return kRGB_SkColorChannelFlags;
        case GrGLFormat::kRGBX8:                 return kRGB_SkColorChannelFlags;
        case GrGLFormat::kRG8:                   return kRG_SkColorChannelFlags;
        case GrGLFormat::kRGB10_A2:              return kRGBA_SkColorChannelFlags;
        case GrGLFormat::kRGBA4:                 return kRGBA_SkColorChannelFlags;
        case GrGLFormat::kSRGB8_ALPHA8:          return kRGBA_SkColorChannelFlags;
        case GrGLFormat::kCOMPRESSED_ETC1_RGB8:  return kRGB_SkColorChannelFlags;
        case GrGLFormat::kCOMPRESSED_RGB8_ETC2:  return kRGB_SkColorChannelFlags;
        case GrGLFormat::kCOMPRESSED_RGB8_BC1:   return kRGB_SkColorChannelFlags;
        case GrGLFormat::kCOMPRESSED_RGBA8_BC1:  return kRGBA_SkColorChannelFlags;
        case GrGLFormat::kR16:                   return kRed_SkColorChannelFlag;
        case GrGLFormat::kRG16:                  return kRG_SkColorChannelFlags;
        case GrGLFormat::kRGBA16:                return kRGBA_SkColorChannelFlags;
        case GrGLFormat::kRG16F:                 return kRG_SkColorChannelFlags;
        case GrGLFormat::kLUMINANCE16F:          return kGray_SkColorChannelFlag;
        case GrGLFormat::kSTENCIL_INDEX8:        return 0;
        case GrGLFormat::kSTENCIL_INDEX16:       return 0;
        case GrGLFormat::kDEPTH24_STENCIL8:      return 0;
    }
    SkUNREACHABLE;
}

◆ GrGLFormatDesc()

static constexpr GrColorFormatDesc GrGLFormatDesc ( GrGLFormat format )

staticconstexpr

Definition at line 75 of file GrGLUtil.h.

                                                                     {
    switch (format) {
        case GrGLFormat::kUnknown: return GrColorFormatDesc::MakeInvalid();
 
        case GrGLFormat::kRGBA8:
            return GrColorFormatDesc::MakeRGBA(8, GrColorTypeEncoding::kUnorm);
        case GrGLFormat::kR8:
            return GrColorFormatDesc::MakeR(8, GrColorTypeEncoding::kUnorm);
        case GrGLFormat::kALPHA8:
            return GrColorFormatDesc::MakeAlpha(8, GrColorTypeEncoding::kUnorm);
        case GrGLFormat::kLUMINANCE8:
            return GrColorFormatDesc::MakeGray(8, GrColorTypeEncoding::kUnorm);
        case GrGLFormat::kLUMINANCE8_ALPHA8:
            return GrColorFormatDesc::MakeGrayAlpha(8, GrColorTypeEncoding::kUnorm);
        case GrGLFormat::kBGRA8:
            return GrColorFormatDesc::MakeRGBA(8, GrColorTypeEncoding::kUnorm);
        case GrGLFormat::kRGB565:
            return GrColorFormatDesc::MakeRGB(5, 6, 5, GrColorTypeEncoding::kUnorm);
        case GrGLFormat::kRGBA16F:
            return GrColorFormatDesc::MakeRGBA(16, GrColorTypeEncoding::kFloat);
        case GrGLFormat::kR16F:
            return GrColorFormatDesc::MakeR(16, GrColorTypeEncoding::kFloat);
        case GrGLFormat::kRGB8:
            return GrColorFormatDesc::MakeRGB(8, GrColorTypeEncoding::kUnorm);
        case GrGLFormat::kRGBX8:
            return GrColorFormatDesc::MakeRGB(8, GrColorTypeEncoding::kUnorm);
        case GrGLFormat::kRG8:
            return GrColorFormatDesc::MakeRG(8, GrColorTypeEncoding::kUnorm);
        case GrGLFormat::kRGB10_A2:
            return GrColorFormatDesc::MakeRGBA(10, 2, GrColorTypeEncoding::kUnorm);
        case GrGLFormat::kRGBA4:
            return GrColorFormatDesc::MakeRGBA(4, GrColorTypeEncoding::kUnorm);
        case GrGLFormat::kSRGB8_ALPHA8:
            return GrColorFormatDesc::MakeRGBA(8, GrColorTypeEncoding::kSRGBUnorm);
        case GrGLFormat::kR16:
            return GrColorFormatDesc::MakeR(16, GrColorTypeEncoding::kUnorm);
        case GrGLFormat::kRG16:
            return GrColorFormatDesc::MakeRG(16, GrColorTypeEncoding::kUnorm);
        case GrGLFormat::kRGBA16:
            return GrColorFormatDesc::MakeRGBA(16, GrColorTypeEncoding::kUnorm);
        case GrGLFormat::kRG16F:
            return GrColorFormatDesc::MakeRG(16, GrColorTypeEncoding::kFloat);
        case GrGLFormat::kLUMINANCE16F:
            return GrColorFormatDesc::MakeGray(16, GrColorTypeEncoding::kFloat);
 
        // Compressed texture formats are not expected to have a description.
        case GrGLFormat::kCOMPRESSED_ETC1_RGB8: return GrColorFormatDesc::MakeInvalid();
        case GrGLFormat::kCOMPRESSED_RGB8_ETC2: return GrColorFormatDesc::MakeInvalid();
        case GrGLFormat::kCOMPRESSED_RGB8_BC1:  return GrColorFormatDesc::MakeInvalid();
        case GrGLFormat::kCOMPRESSED_RGBA8_BC1: return GrColorFormatDesc::MakeInvalid();
 
        // This type only describes color channels.
        case GrGLFormat::kSTENCIL_INDEX8:   return GrColorFormatDesc::MakeInvalid();
        case GrGLFormat::kSTENCIL_INDEX16:  return GrColorFormatDesc::MakeInvalid();
        case GrGLFormat::kDEPTH24_STENCIL8: return GrColorFormatDesc::MakeInvalid();
    }
    SkUNREACHABLE;
}

◆ GrGLFormatFromGLEnum()

static constexpr GrGLFormat GrGLFormatFromGLEnum ( GrGLenum glFormat )

staticconstexpr

Definition at line 409 of file GrGLUtil.h.

                                                                    {
    switch (glFormat) {
        case GR_GL_RGBA8:                return GrGLFormat::kRGBA8;
        case GR_GL_R8:                   return GrGLFormat::kR8;
        case GR_GL_ALPHA8:               return GrGLFormat::kALPHA8;
        case GR_GL_LUMINANCE8:           return GrGLFormat::kLUMINANCE8;
        case GR_GL_LUMINANCE8_ALPHA8:    return GrGLFormat::kLUMINANCE8_ALPHA8;
        case GR_GL_BGRA8:                return GrGLFormat::kBGRA8;
        case GR_GL_RGB565:               return GrGLFormat::kRGB565;
        case GR_GL_RGBA16F:              return GrGLFormat::kRGBA16F;
        case GR_GL_LUMINANCE16F:         return GrGLFormat::kLUMINANCE16F;
        case GR_GL_R16F:                 return GrGLFormat::kR16F;
        case GR_GL_RGB8:                 return GrGLFormat::kRGB8;
        case GR_GL_RGBX8:                return GrGLFormat::kRGBX8;
        case GR_GL_RG8:                  return GrGLFormat::kRG8;
        case GR_GL_RGB10_A2:             return GrGLFormat::kRGB10_A2;
        case GR_GL_RGBA4:                return GrGLFormat::kRGBA4;
        case GR_GL_SRGB8_ALPHA8:         return GrGLFormat::kSRGB8_ALPHA8;
        case GR_GL_COMPRESSED_ETC1_RGB8: return GrGLFormat::kCOMPRESSED_ETC1_RGB8;
        case GR_GL_COMPRESSED_RGB8_ETC2: return GrGLFormat::kCOMPRESSED_RGB8_ETC2;
        case GR_GL_COMPRESSED_RGB_S3TC_DXT1_EXT: return GrGLFormat::kCOMPRESSED_RGB8_BC1;
        case GR_GL_COMPRESSED_RGBA_S3TC_DXT1_EXT: return GrGLFormat::kCOMPRESSED_RGBA8_BC1;
        case GR_GL_R16:                  return GrGLFormat::kR16;
        case GR_GL_RG16:                 return GrGLFormat::kRG16;
        case GR_GL_RGBA16:               return GrGLFormat::kRGBA16;
        case GR_GL_RG16F:                return GrGLFormat::kRG16F;
        case GR_GL_STENCIL_INDEX8:       return GrGLFormat::kSTENCIL_INDEX8;
        case GR_GL_STENCIL_INDEX16:      return GrGLFormat::kSTENCIL_INDEX16;
        case GR_GL_DEPTH24_STENCIL8:     return GrGLFormat::kDEPTH24_STENCIL8;
 
 
        default:                         return GrGLFormat::kUnknown;
    }
}

◆ GrGLFormatIsCompressed()

bool GrGLFormatIsCompressed ( GrGLFormat format )

Returns true if the format is compressed.

Definition at line 812 of file GrGLUtil.cpp.

                                               {
    switch (format) {
        case GrGLFormat::kCOMPRESSED_ETC1_RGB8:
        case GrGLFormat::kCOMPRESSED_RGB8_ETC2:
        case GrGLFormat::kCOMPRESSED_RGB8_BC1:
        case GrGLFormat::kCOMPRESSED_RGBA8_BC1:
            return true;
 
        case GrGLFormat::kRGBA8:
        case GrGLFormat::kR8:
        case GrGLFormat::kALPHA8:
        case GrGLFormat::kLUMINANCE8:
        case GrGLFormat::kLUMINANCE8_ALPHA8:
        case GrGLFormat::kBGRA8:
        case GrGLFormat::kRGB565:
        case GrGLFormat::kRGBA16F:
        case GrGLFormat::kR16F:
        case GrGLFormat::kLUMINANCE16F:
        case GrGLFormat::kRGB8:
        case GrGLFormat::kRGBX8:
        case GrGLFormat::kRG8:
        case GrGLFormat::kRGB10_A2:
        case GrGLFormat::kRGBA4:
        case GrGLFormat::kSRGB8_ALPHA8:
        case GrGLFormat::kR16:
        case GrGLFormat::kRG16:
        case GrGLFormat::kRGBA16:
        case GrGLFormat::kRG16F:
        case GrGLFormat::kSTENCIL_INDEX8:
        case GrGLFormat::kSTENCIL_INDEX16:
        case GrGLFormat::kDEPTH24_STENCIL8:
        case GrGLFormat::kUnknown:
            return false;
    }
    SkUNREACHABLE;
}

◆ GrGLFormatIsPackedDepthStencil()

static constexpr bool GrGLFormatIsPackedDepthStencil ( GrGLFormat format )

staticconstexpr

Definition at line 552 of file GrGLUtil.h.

                                                                        {
    switch (format) {
        case GrGLFormat::kDEPTH24_STENCIL8:
            return true;
        case GrGLFormat::kCOMPRESSED_ETC1_RGB8:
        case GrGLFormat::kCOMPRESSED_RGB8_ETC2:
        case GrGLFormat::kCOMPRESSED_RGB8_BC1:
        case GrGLFormat::kCOMPRESSED_RGBA8_BC1:
        case GrGLFormat::kRGBA8:
        case GrGLFormat::kR8:
        case GrGLFormat::kALPHA8:
        case GrGLFormat::kLUMINANCE8:
        case GrGLFormat::kLUMINANCE8_ALPHA8:
        case GrGLFormat::kBGRA8:
        case GrGLFormat::kRGB565:
        case GrGLFormat::kRGBA16F:
        case GrGLFormat::kR16F:
        case GrGLFormat::kLUMINANCE16F:
        case GrGLFormat::kRGB8:
        case GrGLFormat::kRGBX8:
        case GrGLFormat::kRG8:
        case GrGLFormat::kRGB10_A2:
        case GrGLFormat::kRGBA4:
        case GrGLFormat::kSRGB8_ALPHA8:
        case GrGLFormat::kR16:
        case GrGLFormat::kRG16:
        case GrGLFormat::kRGBA16:
        case GrGLFormat::kRG16F:
        case GrGLFormat::kSTENCIL_INDEX8:
        case GrGLFormat::kSTENCIL_INDEX16:
        case GrGLFormat::kUnknown:
            return false;
    }
    SkUNREACHABLE;
}

◆ GrGLFormatIsSRGB()

static constexpr bool GrGLFormatIsSRGB ( GrGLFormat format )

staticconstexpr

Definition at line 588 of file GrGLUtil.h.

                                                          {
    switch (format) {
    case GrGLFormat::kSRGB8_ALPHA8:
        return true;
    case GrGLFormat::kCOMPRESSED_ETC1_RGB8:
    case GrGLFormat::kCOMPRESSED_RGB8_ETC2:
    case GrGLFormat::kCOMPRESSED_RGB8_BC1:
    case GrGLFormat::kCOMPRESSED_RGBA8_BC1:
    case GrGLFormat::kRGBA8:
    case GrGLFormat::kR8:
    case GrGLFormat::kALPHA8:
    case GrGLFormat::kLUMINANCE8:
    case GrGLFormat::kLUMINANCE8_ALPHA8:
    case GrGLFormat::kBGRA8:
    case GrGLFormat::kRGB565:
    case GrGLFormat::kRGBA16F:
    case GrGLFormat::kR16F:
    case GrGLFormat::kLUMINANCE16F:
    case GrGLFormat::kRGB8:
    case GrGLFormat::kRGBX8:
    case GrGLFormat::kRG8:
    case GrGLFormat::kRGB10_A2:
    case GrGLFormat::kRGBA4:
    case GrGLFormat::kR16:
    case GrGLFormat::kRG16:
    case GrGLFormat::kRGBA16:
    case GrGLFormat::kRG16F:
    case GrGLFormat::kSTENCIL_INDEX8:
    case GrGLFormat::kSTENCIL_INDEX16:
    case GrGLFormat::kDEPTH24_STENCIL8:
    case GrGLFormat::kUnknown:
        return false;
    }
    SkUNREACHABLE;
}

◆ GrGLFormatStencilBits()

static constexpr int GrGLFormatStencilBits ( GrGLFormat format )

staticconstexpr

Definition at line 514 of file GrGLUtil.h.

                                                              {
    switch (format) {
        case GrGLFormat::kSTENCIL_INDEX8:
            return 8;
        case GrGLFormat::kSTENCIL_INDEX16:
            return 16;
        case GrGLFormat::kDEPTH24_STENCIL8:
            return 8;
        case GrGLFormat::kCOMPRESSED_ETC1_RGB8:
        case GrGLFormat::kCOMPRESSED_RGB8_ETC2:
        case GrGLFormat::kCOMPRESSED_RGB8_BC1:
        case GrGLFormat::kCOMPRESSED_RGBA8_BC1:
        case GrGLFormat::kRGBA8:
        case GrGLFormat::kR8:
        case GrGLFormat::kALPHA8:
        case GrGLFormat::kLUMINANCE8:
        case GrGLFormat::kLUMINANCE8_ALPHA8:
        case GrGLFormat::kBGRA8:
        case GrGLFormat::kRGB565:
        case GrGLFormat::kRGBA16F:
        case GrGLFormat::kR16F:
        case GrGLFormat::kLUMINANCE16F:
        case GrGLFormat::kRGB8:
        case GrGLFormat::kRGBX8:
        case GrGLFormat::kRG8:
        case GrGLFormat::kRGB10_A2:
        case GrGLFormat::kRGBA4:
        case GrGLFormat::kSRGB8_ALPHA8:
        case GrGLFormat::kR16:
        case GrGLFormat::kRG16:
        case GrGLFormat::kRGBA16:
        case GrGLFormat::kRG16F:
        case GrGLFormat::kUnknown:
            return 0;
    }
    SkUNREACHABLE;
}

◆ GrGLFormatToEnum()

static constexpr GrGLenum GrGLFormatToEnum ( GrGLFormat format )

staticconstexpr

Returns either the sized internal format or compressed internal format of the GrGLFormat.

Definition at line 445 of file GrGLUtil.h.

                                                              {
    switch (format) {
        case GrGLFormat::kRGBA8:                return GR_GL_RGBA8;
        case GrGLFormat::kR8:                   return GR_GL_R8;
        case GrGLFormat::kALPHA8:               return GR_GL_ALPHA8;
        case GrGLFormat::kLUMINANCE8:           return GR_GL_LUMINANCE8;
        case GrGLFormat::kLUMINANCE8_ALPHA8:    return GR_GL_LUMINANCE8_ALPHA8;
        case GrGLFormat::kBGRA8:                return GR_GL_BGRA8;
        case GrGLFormat::kRGB565:               return GR_GL_RGB565;
        case GrGLFormat::kRGBA16F:              return GR_GL_RGBA16F;
        case GrGLFormat::kLUMINANCE16F:         return GR_GL_LUMINANCE16F;
        case GrGLFormat::kR16F:                 return GR_GL_R16F;
        case GrGLFormat::kRGB8:                 return GR_GL_RGB8;
        case GrGLFormat::kRGBX8:                return GR_GL_RGBX8;
        case GrGLFormat::kRG8:                  return GR_GL_RG8;
        case GrGLFormat::kRGB10_A2:             return GR_GL_RGB10_A2;
        case GrGLFormat::kRGBA4:                return GR_GL_RGBA4;
        case GrGLFormat::kSRGB8_ALPHA8:         return GR_GL_SRGB8_ALPHA8;
        case GrGLFormat::kCOMPRESSED_ETC1_RGB8: return GR_GL_COMPRESSED_ETC1_RGB8;
        case GrGLFormat::kCOMPRESSED_RGB8_ETC2: return GR_GL_COMPRESSED_RGB8_ETC2;
        case GrGLFormat::kCOMPRESSED_RGB8_BC1:  return GR_GL_COMPRESSED_RGB_S3TC_DXT1_EXT;
        case GrGLFormat::kCOMPRESSED_RGBA8_BC1: return GR_GL_COMPRESSED_RGBA_S3TC_DXT1_EXT;
        case GrGLFormat::kR16:                  return GR_GL_R16;
        case GrGLFormat::kRG16:                 return GR_GL_RG16;
        case GrGLFormat::kRGBA16:               return GR_GL_RGBA16;
        case GrGLFormat::kRG16F:                return GR_GL_RG16F;
        case GrGLFormat::kSTENCIL_INDEX8:       return GR_GL_STENCIL_INDEX8;
        case GrGLFormat::kSTENCIL_INDEX16:      return GR_GL_STENCIL_INDEX16;
        case GrGLFormat::kDEPTH24_STENCIL8:     return GR_GL_DEPTH24_STENCIL8;
        case GrGLFormat::kUnknown:              return 0;
    }
    SkUNREACHABLE;
}

◆ GrGLGetDriverInfo()

GrGLDriverInfo GrGLGetDriverInfo ( const GrGLInterface * interface )

Definition at line 723 of file GrGLUtil.cpp.

                                                                 {
    if (!interface) {
        return {};
    }
    SkASSERT(interface->fStandard != kNone_GrGLStandard);
    GrGLDriverInfo info;
    info.fStandard = interface->fStandard;
 
    auto getString = [&](GrGLenum s) {
        const GrGLubyte* bytes = interface->fFunctions.fGetString(s);
        if (!bytes) {
            return "";
        }
        return reinterpret_cast<const char*>(bytes);
    };
 
    const char* const version   = getString(GR_GL_VERSION);
    const char* const slversion = getString(GR_GL_SHADING_LANGUAGE_VERSION);
    const char* const renderer  = getString(GR_GL_RENDERER);
    const char* const vendor    = getString(GR_GL_VENDOR);
 
    info.fVersion     = GrGLGetVersionFromString(version);
    info.fGLSLVersion = get_glsl_version(slversion);
    info.fVendor      = get_vendor(vendor);
    info.fRenderer    = get_renderer(renderer, interface->fExtensions);
 
    std::tie(info.fDriver, info.fDriverVersion) = get_driver_and_version(interface->fStandard,
                                                                         info.fVendor,
                                                                         vendor,
                                                                         renderer,
                                                                         version);
 
    SkString innerAngleRendererString;
    std::tie(info.fANGLEBackend, innerAngleRendererString) = get_angle_backend(renderer);
 
    if (info.fANGLEBackend == GrGLANGLEBackend::kD3D9 ||
        info.fANGLEBackend == GrGLANGLEBackend::kD3D11) {
        std::tie(info.fANGLEVendor,
                 info.fANGLERenderer,
                 info.fANGLEDriver,
                 info.fANGLEDriverVersion) =
                get_angle_d3d_vendor_and_renderer(innerAngleRendererString.c_str());
    } else if (info.fANGLEBackend == GrGLANGLEBackend::kOpenGL) {
        std::tie(info.fANGLEVendor,
                 info.fANGLERenderer,
                 info.fANGLEDriver,
                 info.fANGLEDriverVersion) =
                get_angle_gl_vendor_and_renderer(innerAngleRendererString.c_str(),
                                                 interface->fExtensions);
    }
 
    if (info.fRenderer == GrGLRenderer::kWebGL) {
        std::tie(info.fWebGLVendor,
                 info.fWebGLRenderer) =
                get_webgl_vendor_and_renderer(interface);
 
    }
 
    info.fIsOverCommandBuffer = is_commamd_buffer(renderer, version);
 
    info.fIsRunningOverVirgl = is_virgl(renderer);
 
    return info;
}

◆ GrGLGetStandardInUseFromString()

GrGLStandard GrGLGetStandardInUseFromString ( const char * versionString )

Definition at line 31 of file GrGLUtil.cpp.

                                                                       {
    if (!versionString) {
        SkDebugf("nullptr GL version string.");
        return kNone_GrGLStandard;
    }
 
    int major, minor;
 
    // check for desktop
    int n = sscanf(versionString, "%d.%d", &major, &minor);
    if (2 == n) {
        return kGL_GrGLStandard;
    }
 
    // WebGL might look like "OpenGL ES 2.0 (WebGL 1.0 (OpenGL ES 2.0 Chromium))"
    int esMajor, esMinor;
    n = sscanf(versionString, "OpenGL ES %d.%d (WebGL %d.%d", &esMajor, &esMinor, &major, &minor);
    if (4 == n) {
        return kWebGL_GrGLStandard;
    }
 
    // check for ES 1
    char profile[2];
    n = sscanf(versionString, "OpenGL ES-%c%c %d.%d", profile, profile+1, &major, &minor);
    if (4 == n) {
        // we no longer support ES1.
        return kNone_GrGLStandard;
    }
 
    // check for ES2
    n = sscanf(versionString, "OpenGL ES %d.%d", &major, &minor);
    if (2 == n) {
        return kGLES_GrGLStandard;
    }
    return kNone_GrGLStandard;
}

◆ GrGLGetVersion()

GrGLSLVersion GrGLGetVersion ( const GrGLInterface * gl )

Definition at line 109 of file GrGLUtil.cpp.

                                                    {
    SkASSERT(gl);
    const GrGLubyte* v;
    GR_GL_CALL_RET(gl, v, GetString(GR_GL_VERSION));
    return GrGLGetVersionFromString((const char*)v);
}

◆ GrGLGetVersionFromString()

GrGLSLVersion GrGLGetVersionFromString ( const char * versionString )

Definition at line 68 of file GrGLUtil.cpp.

                                                                {
    if (!versionString) {
        SkDebugf("nullptr GL version string.");
        return GR_GL_INVALID_VER;
    }
 
    int major, minor;
 
    // check for mesa
    int mesaMajor, mesaMinor;
    int n = sscanf(versionString, "%d.%d Mesa %d.%d", &major, &minor, &mesaMajor, &mesaMinor);
    if (4 == n) {
        return GR_GL_VER(major, minor);
    }
 
    n = sscanf(versionString, "%d.%d", &major, &minor);
    if (2 == n) {
        return GR_GL_VER(major, minor);
    }
 
    // WebGL might look like "OpenGL ES 2.0 (WebGL 1.0 (OpenGL ES 2.0 Chromium))"
    int esMajor, esMinor;
    n = sscanf(versionString, "OpenGL ES %d.%d (WebGL %d.%d", &esMajor, &esMinor, &major, &minor);
    if (4 == n) {
        return GR_GL_VER(major, minor);
    }
 
    char profile[2];
    n = sscanf(versionString, "OpenGL ES-%c%c %d.%d", profile, profile + 1, &major, &minor);
    if (4 == n) {
        return GR_GL_VER(major, minor);
    }
 
    n = sscanf(versionString, "OpenGL ES %d.%d", &major, &minor);
    if (2 == n) {
        return GR_GL_VER(major, minor);
    }
 
    return GR_GL_INVALID_VER;
}

◆ GrToGLStencilFunc()

GrGLenum GrToGLStencilFunc ( GrStencilTest test )

Definition at line 788 of file GrGLUtil.cpp.

                                               {
    static const GrGLenum gTable[kGrStencilTestCount] = {
        GR_GL_ALWAYS,           // kAlways
        GR_GL_NEVER,            // kNever
        GR_GL_GREATER,          // kGreater
        GR_GL_GEQUAL,           // kGEqual
        GR_GL_LESS,             // kLess
        GR_GL_LEQUAL,           // kLEqual
        GR_GL_EQUAL,            // kEqual
        GR_GL_NOTEQUAL,         // kNotEqual
    };
    static_assert(0 == (int)GrStencilTest::kAlways);
    static_assert(1 == (int)GrStencilTest::kNever);
    static_assert(2 == (int)GrStencilTest::kGreater);
    static_assert(3 == (int)GrStencilTest::kGEqual);
    static_assert(4 == (int)GrStencilTest::kLess);
    static_assert(5 == (int)GrStencilTest::kLEqual);
    static_assert(6 == (int)GrStencilTest::kEqual);
    static_assert(7 == (int)GrStencilTest::kNotEqual);
    SkASSERT(test < (GrStencilTest)kGrStencilTestCount);
 
    return gTable[(int)test];
}

Classes

Macros

Typedefs

Enumerations

Functions

Macro Definition Documentation

◆ GR_FILE_AND_LINE_STR

◆ GR_GL_CALL

◆ GR_GL_CALL_NOERRCHECK

◆ GR_GL_CALL_RET

◆ GR_GL_CALL_RET_NOERRCHECK

◆ GR_GL_CHECK_ERROR_IMPL

◆ GR_GL_DRIVER_UNKNOWN_VER

◆ GR_GL_DRIVER_VER

◆ GR_GL_GetFloatv

◆ GR_GL_GetFramebufferAttachmentParameteriv

◆ GR_GL_GetIntegerv

◆ GR_GL_GetInternalformativ

◆ GR_GL_GetNamedFramebufferAttachmentParameteriv

◆ GR_GL_GetRenderbufferParameteriv

◆ GR_GL_GetShaderPrecisionFormat

◆ GR_GL_GetTexLevelParameteriv

◆ GR_GL_INIT_ZERO

◆ GR_GL_INVALID_VER

◆ GR_GL_LOG_CALLS_IMPL

◆ GR_GL_MAJOR_VER

◆ GR_GL_MINOR_VER

◆ GR_GL_VER

◆ GR_GLSL_INVALID_VER

◆ GR_GLSL_VER

◆ GR_STRING

◆ GR_STRING_IMPL

Typedef Documentation

◆ GrGLDriverVersion

◆ GrGLSLVersion

◆ GrGLVersion

Enumeration Type Documentation

◆ GrGLANGLEBackend

◆ GrGLDriver

◆ GrGLRenderer

◆ GrGLVendor

Function Documentation

◆ GrGLCheckErr()

◆ GrGLFormatBytesPerBlock()

◆ GrGLFormatChannels()

◆ GrGLFormatDesc()

◆ GrGLFormatFromGLEnum()

◆ GrGLFormatIsCompressed()

◆ GrGLFormatIsPackedDepthStencil()

◆ GrGLFormatIsSRGB()

◆ GrGLFormatStencilBits()

◆ GrGLFormatToEnum()

◆ GrGLGetDriverInfo()

◆ GrGLGetStandardInUseFromString()

◆ GrGLGetVersion()

◆ GrGLGetVersionFromString()

◆ GrToGLStencilFunc()