GrTypesPriv.h File Reference

#include "include/core/SkColor.h"
#include "include/core/SkColorType.h"
#include "include/core/SkData.h"
#include "include/core/SkPath.h"
#include "include/core/SkPathTypes.h"
#include "include/core/SkRefCnt.h"
#include "include/gpu/GrTypes.h"
#include "include/private/base/SkAssert.h"
#include "include/private/base/SkMacros.h"
#include "include/private/base/SkTypeTraits.h"
#include <cstddef>
#include <cstdint>
#include <functional>
#include <type_traits>

Go to the source code of this file.

Classes
struct	GrMipLevel
class	GrColorFormatDesc

Namespaces
namespace	skgpu

Macros
#define	GrCapsDebugf(caps, ...)   do {} while (0)

Typedefs
using	GrVisitProxyFunc = std::function< void(GrSurfaceProxy *, skgpu::Mipmapped)>

Enumerations
enum class	GrPrimitiveType : uint8_t {   kTriangles , kTriangleStrip , kPoints , kLines ,   kLineStrip }
enum class	GrPrimitiveRestart : bool { kNo = false , kYes = true }
enum class	GrTexturable : bool { kNo = false , kYes = true }
enum class	GrDDLProvider : bool { kNo = false , kYes = true }
enum	GrWrapOwnership { kBorrow_GrWrapOwnership , kAdopt_GrWrapOwnership }
enum class	GrWrapCacheable : bool { kNo = false , kYes = true }
enum class	GrBudgetedType : uint8_t { kBudgeted , kUnbudgetedUncacheable , kUnbudgetedCacheable }
enum class	GrScissorTest : bool { kDisabled = false , kEnabled = true }
enum class	GrMemoryless : bool { kNo = false , kYes = true }
enum class	GrSemaphoreWrapType { kWillSignal , kWillWait }
enum class	GrLoadOp { kLoad , kClear , kDiscard }
enum class	GrStoreOp { kStore , kDiscard }
enum class	GrAA : bool { kNo = false , kYes = true }
enum class	GrFillRule : bool { kNonzero , kEvenOdd }
enum class	GrAAType : unsigned { kNone , kCoverage , kMSAA , kLast = kMSAA }
enum class	GrClampType { kAuto , kManual , kNone }
enum class	GrQuadAAFlags {   kLeft = 0b0001 , kTop = 0b0010 , kRight = 0b0100 , kBottom = 0b1000 ,   kNone = 0b0000 , kAll = 0b1111 }
enum class	GrTextureType { kNone , k2D , kRectangle , kExternal }
enum	GrShaderType { kVertex_GrShaderType , kFragment_GrShaderType , kLast_GrShaderType = kFragment_GrShaderType }
enum	GrShaderFlags { kNone_GrShaderFlags = 0 , kVertex_GrShaderFlag = 1 << 0 , kFragment_GrShaderFlag = 1 << 1 }
enum	GrVertexAttribType {   kFloat_GrVertexAttribType = 0 , kFloat2_GrVertexAttribType , kFloat3_GrVertexAttribType , kFloat4_GrVertexAttribType ,   kHalf_GrVertexAttribType , kHalf2_GrVertexAttribType , kHalf4_GrVertexAttribType , kInt2_GrVertexAttribType ,   kInt3_GrVertexAttribType , kInt4_GrVertexAttribType , kByte_GrVertexAttribType , kByte2_GrVertexAttribType ,   kByte4_GrVertexAttribType , kUByte_GrVertexAttribType , kUByte2_GrVertexAttribType , kUByte4_GrVertexAttribType ,   kUByte_norm_GrVertexAttribType , kUByte4_norm_GrVertexAttribType , kShort2_GrVertexAttribType , kShort4_GrVertexAttribType ,   kUShort2_GrVertexAttribType , kUShort2_norm_GrVertexAttribType , kInt_GrVertexAttribType , kUInt_GrVertexAttribType ,   kUShort_norm_GrVertexAttribType , kUShort4_norm_GrVertexAttribType , kLast_GrVertexAttribType = kUShort4_norm_GrVertexAttribType }
enum class	GrClipEdgeType {   kFillBW , kFillAA , kInverseFillBW , kInverseFillAA ,   kLast = kInverseFillAA }
enum	GrIOType { kRead_GrIOType , kWrite_GrIOType , kRW_GrIOType }
enum class	GrGpuBufferType {   kVertex , kIndex , kDrawIndirect , kXferCpuToGpu ,   kXferGpuToCpu , kUniform }
enum	GrAccessPattern { kDynamic_GrAccessPattern , kStatic_GrAccessPattern , kStream_GrAccessPattern , kLast_GrAccessPattern = kStream_GrAccessPattern }
enum class	GrInternalSurfaceFlags {   kNone = 0 , kReadOnly = 1 << 0 , kGLRTFBOIDIs0 = 1 << 1 , kRequiresManualMSAAResolve = 1 << 2 ,   kFramebufferOnly = 1 << 3 , kVkRTSupportsInputAttachment = 1 << 4 }
enum class	GrBackendObjectOwnership : bool { kBorrowed = false , kOwned = true }
enum class	GpuPathRenderers {   kNone = 0 , kDashLine = 1 << 0 , kAtlas = 1 << 1 , kTessellation = 1 << 2 ,   kCoverageCounting = 1 << 3 , kAAHairline = 1 << 4 , kAAConvex = 1 << 5 , kAALinearizing = 1 << 6 ,   kSmall = 1 << 7 , kTriangulating = 1 << 8 , kDefault = ((1 << 9) - 1) }
enum class	GrMipmapStatus { kNotAllocated , kDirty , kValid }
enum class	GrColorType {   kUnknown , kAlpha_8 , kBGR_565 , kRGB_565 ,   kABGR_4444 , kRGBA_8888 , kRGBA_8888_SRGB , kRGB_888x ,   kRG_88 , kBGRA_8888 , kRGBA_1010102 , kBGRA_1010102 ,   kRGBA_10x6 , kGray_8 , kGrayAlpha_88 , kAlpha_F16 ,   kRGBA_F16 , kRGBA_F16_Clamped , kRGBA_F32 , kAlpha_16 ,   kRG_1616 , kRG_F16 , kRGBA_16161616 , kAlpha_8xxx ,   kAlpha_F32xxx , kGray_8xxx , kR_8xxx , kRGB_888 ,   kR_8 , kR_16 , kR_F16 , kGray_F16 ,   kBGRA_4444 , kARGB_4444 , kLast = kARGB_4444 }
enum class	GrColorTypeEncoding { kUnorm , kSRGBUnorm , kFloat }
enum class	GrDstSampleFlags { kNone = 0 , kRequiresTextureBarrier = 1 << 0 , kAsInputAttachment = 1 << 1 }

Functions
static constexpr size_t	GrSizeDivRoundUp (size_t x, size_t y)
static constexpr bool	GrIsPrimTypeLines (GrPrimitiveType type)
GrFillRule	GrFillRuleForPathFillType (SkPathFillType fillType)
GrFillRule	GrFillRuleForSkPath (const SkPath &path)
static constexpr bool	GrAATypeIsHW (GrAAType type)
static GrQuadAAFlags	SkToGrQuadAAFlags (unsigned flags)
static bool	GrTextureTypeHasRestrictedSampling (GrTextureType type)
static constexpr bool	GrClipEdgeTypeIsFill (const GrClipEdgeType edgeType)
static constexpr bool	GrClipEdgeTypeIsInverseFill (const GrClipEdgeType edgeType)
static constexpr bool	GrClipEdgeTypeIsAA (const GrClipEdgeType edgeType)
static GrClipEdgeType	GrInvertClipEdgeType (const GrClipEdgeType edgeType)
static constexpr SkColorType	GrColorTypeToSkColorType (GrColorType ct)
static constexpr GrColorType	SkColorTypeToGrColorType (SkColorType ct)
static constexpr uint32_t	GrColorTypeChannelFlags (GrColorType ct)
static constexpr GrColorFormatDesc	GrGetColorTypeDesc (GrColorType ct)
static constexpr GrClampType	GrColorTypeClampType (GrColorType colorType)
static constexpr bool	GrColorTypeIsWiderThan (GrColorType colorType, int n)
static constexpr bool	GrColorTypeIsAlphaOnly (GrColorType ct)
static constexpr bool	GrColorTypeHasAlpha (GrColorType ct)
static constexpr size_t	GrColorTypeBytesPerPixel (GrColorType ct)

Variables
static constexpr int	kNumGrPrimitiveTypes = (int)GrPrimitiveType::kLineStrip + 1
static const int	kGrAATypeCount = static_cast<int>(GrAAType::kLast) + 1
static const int	kGrShaderTypeCount = kLast_GrShaderType + 1
static const int	kGrVertexAttribTypeCount = kLast_GrVertexAttribType + 1
static const int	kGrClipEdgeTypeCnt = (int) GrClipEdgeType::kLast + 1
static const constexpr int	kGrGpuBufferTypeCount = static_cast<int>(GrGpuBufferType::kUniform) + 1
static constexpr int	kGrInternalTextureFlagsMask
static constexpr int	kGrInternalRenderTargetFlagsMask
static constexpr int	kGrInternalTextureRenderTargetFlagsMask
static const int	kGrColorTypeCnt = static_cast<int>(GrColorType::kLast) + 1

Macro Definition Documentation

GrCapsDebugf

#define GrCapsDebugf	(		caps,
			...
	)		do {} while (0)

Definition at line 489 of file GrTypesPriv.h.

Typedef Documentation

GrVisitProxyFunc

using GrVisitProxyFunc = std::function<void(GrSurfaceProxy*, skgpu::Mipmapped)>

Definition at line 942 of file GrTypesPriv.h.

Enumeration Type Documentation

GpuPathRenderers

enum class GpuPathRenderers

strong

Used to include or exclude specific GPU path renderers for testing purposes.

Enumerator
kNone
kDashLine
kAtlas
kTessellation
kCoverageCounting
kAAHairline
kAAConvex
kAALinearizing
kSmall
kTriangulating
kDefault

Definition at line 505 of file GrTypesPriv.h.

                            {
    kNone              =   0,  // Always use software masks and/or DefaultPathRenderer.
    kDashLine          =   1 << 0,
    kAtlas             =   1 << 1,
    kTessellation      =   1 << 2,
    kCoverageCounting  =   1 << 3,
    kAAHairline        =   1 << 4,
    kAAConvex          =   1 << 5,
    kAALinearizing     =   1 << 6,
    kSmall             =   1 << 7,
    kTriangulating     =   1 << 8,
    kDefault           = ((1 << 9) - 1)  // All path renderers.
};

GrAA

enum class GrAA : bool

strong

Used to control antialiasing in draw calls.

Enumerator
kNo
kYes

Definition at line 172 of file GrTypesPriv.h.

                : bool {
    kNo = false,
    kYes = true
};

GrAAType

enum class GrAAType : unsigned

strong

This enum indicates the type of antialiasing to be performed.

Enumerator
kNone	No antialiasing
kCoverage	Use fragment shader code to blend with a fractional pixel coverage.
kMSAA	Use normal MSAA.
kLast

Definition at line 199 of file GrTypesPriv.h.

                    : unsigned {
    /** No antialiasing */
    kNone,
    /** Use fragment shader code to blend with a fractional pixel coverage. */
    kCoverage,
    /** Use normal MSAA. */
    kMSAA,
 
    kLast = kMSAA
};

GrAccessPattern

enum GrAccessPattern

Provides a performance hint regarding the frequency at which a data store will be accessed.

Enumerator
kDynamic_GrAccessPattern	Data store will be respecified repeatedly and used many times.
kStatic_GrAccessPattern	Data store will be specified once and used many times. (Thus disqualified from caching.)
kStream_GrAccessPattern	Data store will be specified once and used at most a few times. (Also can't be cached.)
kLast_GrAccessPattern

Definition at line 423 of file GrTypesPriv.h.

                     {
    /** Data store will be respecified repeatedly and used many times. */
    kDynamic_GrAccessPattern,
    /** Data store will be specified once and used many times. (Thus disqualified from caching.) */
    kStatic_GrAccessPattern,
    /** Data store will be specified once and used at most a few times. (Also can't be cached.) */
    kStream_GrAccessPattern,
 
    kLast_GrAccessPattern = kStream_GrAccessPattern
};

GrBackendObjectOwnership

enum class GrBackendObjectOwnership : bool

strong

Specifies if the holder owns the backend, OpenGL or Vulkan, object.

Enumerator
kBorrowed	Holder does not destroy the backend object.
kOwned	Holder destroys the backend object.

Definition at line 495 of file GrTypesPriv.h.

                                    : bool {
    /** Holder does not destroy the backend object. */
    kBorrowed = false,
    /** Holder destroys the backend object. */
    kOwned = true
};

GrBudgetedType

enum class GrBudgetedType : uint8_t

strong

Enumerator
kBudgeted	The resource is budgeted and is subject to purging under budget pressure.
kUnbudgetedUncacheable	The resource is unbudgeted and is purged as soon as it has no refs regardless of whether it has a unique or scratch key.
kUnbudgetedCacheable	The resource is unbudgeted and is allowed to remain in the cache with no refs if it has a unique key. Scratch keys are ignored.

Definition at line 99 of file GrTypesPriv.h.

                          : uint8_t {
    /** The resource is budgeted and is subject to purging under budget pressure. */
    kBudgeted,
    /**
     * The resource is unbudgeted and is purged as soon as it has no refs regardless of whether
     * it has a unique or scratch key.
     */
    kUnbudgetedUncacheable,
    /**
     * The resource is unbudgeted and is allowed to remain in the cache with no refs if it
     * has a unique key. Scratch keys are ignored.
     */
    kUnbudgetedCacheable,
};

GrClampType

enum class GrClampType

strong

Some pixel configs are inherently clamped to [0,1], some are allowed to go outside that range, and some are FP but manually clamped in the XP.

Enumerator
kAuto
kManual
kNone

Definition at line 227 of file GrTypesPriv.h.

                       {
    kAuto,    // Normalized, fixed-point configs
    kManual,  // Clamped FP configs
    kNone,    // Normal (unclamped) FP configs
};

GrClipEdgeType

enum class GrClipEdgeType

strong

We have coverage effects that clip rendering to the edge of some geometric primitive. This enum specifies how that clipping is performed. Not all factories that take a GrClipEdgeType will succeed with all values and it is up to the caller to verify success.

Enumerator
kFillBW
kFillAA
kInverseFillBW
kInverseFillAA
kLast

Definition at line 360 of file GrTypesPriv.h.

                          {
    kFillBW,
    kFillAA,
    kInverseFillBW,
    kInverseFillAA,
 
    kLast = kInverseFillAA
};

GrColorType

enum class GrColorType

strong

Like SkColorType this describes a layout of pixel data in CPU memory. It specifies the channels, their type, and width. This exists so that the GPU backend can have private types that have no analog in the public facing SkColorType enum and omit types not implemented in the GPU backend. It does not refer to a texture format and the mapping to texture formats may be many-to-many. It does not specify the sRGB encoding of the stored values. The components are listed in order of where they appear in memory. In other words the first component listed is in the low bits and the last component in the high bits.

Enumerator
kUnknown
kAlpha_8
kBGR_565
kRGB_565
kABGR_4444
kRGBA_8888
kRGBA_8888_SRGB
kRGB_888x
kRG_88
kBGRA_8888
kRGBA_1010102
kBGRA_1010102
kRGBA_10x6
kGray_8
kGrayAlpha_88
kAlpha_F16
kRGBA_F16
kRGBA_F16_Clamped
kRGBA_F32
kAlpha_16
kRG_1616
kRG_F16
kRGBA_16161616
kAlpha_8xxx
kAlpha_F32xxx
kGray_8xxx
kR_8xxx
kRGB_888
kR_8
kR_16
kR_F16
kGray_F16
kBGRA_4444
kARGB_4444
kLast

Definition at line 539 of file GrTypesPriv.h.

                       {
    kUnknown,
    kAlpha_8,
    kBGR_565,
    kRGB_565,
    kABGR_4444,  // This name differs from SkColorType. kARGB_4444_SkColorType is misnamed.
    kRGBA_8888,
    kRGBA_8888_SRGB,
    kRGB_888x,
    kRG_88,
    kBGRA_8888,
    kRGBA_1010102,
    kBGRA_1010102,
    kRGBA_10x6,
    kGray_8,
    kGrayAlpha_88,
    kAlpha_F16,
    kRGBA_F16,
    kRGBA_F16_Clamped,
    kRGBA_F32,
 
    kAlpha_16,
    kRG_1616,
    kRG_F16,
    kRGBA_16161616,
 
    // Unusual types that come up after reading back in cases where we are reassigning the meaning
    // of a texture format's channels to use for a particular color format but have to read back the
    // data to a full RGBA quadruple. (e.g. using a R8 texture format as A8 color type but the API
    // only supports reading to RGBA8.) None of these have SkColorType equivalents.
    kAlpha_8xxx,
    kAlpha_F32xxx,
    kGray_8xxx,
    kR_8xxx,
 
    // Types used to initialize backend textures.
    kRGB_888,
    kR_8,
    kR_16,
    kR_F16,
    kGray_F16,
    kBGRA_4444,
    kARGB_4444,
 
    kLast = kARGB_4444
};

GrColorTypeEncoding

enum class GrColorTypeEncoding

strong

Describes the encoding of channel data in a GrColorType.

Enumerator
kUnorm
kSRGBUnorm
kFloat

Definition at line 703 of file GrTypesPriv.h.

                               {
    kUnorm,
    kSRGBUnorm,
    // kSnorm,
    kFloat,
    // kSint
    // kUint
};

GrDDLProvider

enum class GrDDLProvider : bool

strong

Enumerator
kNo
kYes

Definition at line 70 of file GrTypesPriv.h.

                         : bool {
    kNo = false,
    kYes = true
};

GrDstSampleFlags

enum class GrDstSampleFlags

strong

Enumerator
kNone
kRequiresTextureBarrier
kAsInputAttachment

Definition at line 935 of file GrTypesPriv.h.

                            {
    kNone = 0,
    kRequiresTextureBarrier =   1 << 0,
    kAsInputAttachment = 1 << 1,
};

GrFillRule

enum class GrFillRule : bool

strong

Enumerator
kNonzero
kEvenOdd

Definition at line 177 of file GrTypesPriv.h.

                      : bool {
    kNonzero,
    kEvenOdd
};

GrGpuBufferType

enum class GrGpuBufferType

strong

Indicates the type of data that a GPU buffer will be used for.

Enumerator
kVertex
kIndex
kDrawIndirect
kXferCpuToGpu
kXferGpuToCpu
kUniform

Definition at line 410 of file GrTypesPriv.h.

                           {
    kVertex,
    kIndex,
    kDrawIndirect,
    kXferCpuToGpu,
    kXferGpuToCpu,
    kUniform,
};

GrInternalSurfaceFlags

enum class GrInternalSurfaceFlags

strong

Enumerator
kNone
kReadOnly
kGLRTFBOIDIs0
kRequiresManualMSAAResolve
kFramebufferOnly
kVkRTSupportsInputAttachment

Definition at line 435 of file GrTypesPriv.h.

                                  {
    kNone                           = 0,
 
    // Texture-level
 
    // Means the pixels in the texture are read-only. Cannot also be a GrRenderTarget[Proxy].
    kReadOnly                       = 1 << 0,
 
    // RT-level
 
    // This flag is for use with GL only. It tells us that the internal render target wraps FBO 0.
    kGLRTFBOIDIs0                   = 1 << 1,
 
    // This means the render target is multisampled, and internally holds a non-msaa texture for
    // resolving into. The render target resolves itself by blitting into this internal texture.
    // (asTexture() might or might not return the internal texture, but if it does, we always
    // resolve the render target before accessing this texture's data.)
    kRequiresManualMSAAResolve      = 1 << 2,
 
    // This means the pixels in the render target are write-only. This is used for Dawn and Metal
    // swap chain targets which can be rendered to, but not read or copied.
    kFramebufferOnly                = 1 << 3,
 
    // This is a Vulkan only flag. If set the surface can be used as an input attachment in a
    // shader. This is used for doing in shader blending where we want to sample from the same
    // image we are drawing to.
    kVkRTSupportsInputAttachment    = 1 << 4,
};

GrIOType

enum GrIOType

Indicates the type of pending IO operations that can be recorded for gpu resources.

Enumerator
kRead_GrIOType
kWrite_GrIOType
kRW_GrIOType

Definition at line 401 of file GrTypesPriv.h.

              {
    kRead_GrIOType,
    kWrite_GrIOType,
    kRW_GrIOType
};

GrLoadOp

enum class GrLoadOp

strong

This enum is used to specify the load operation to be used when an OpsTask/GrOpsRenderPass begins execution.

Enumerator
kLoad
kClear
kDiscard

Definition at line 154 of file GrTypesPriv.h.

                    {
    kLoad,
    kClear,
    kDiscard,
};

GrMemoryless

enum class GrMemoryless : bool

strong

Enumerator
kNo	The texture will be allocated normally and will affect memory budgets.
kYes	The texture will be not use GPU memory and will not affect memory budgets.

Definition at line 122 of file GrTypesPriv.h.

                        : bool {
    /**
     * The texture will be allocated normally and will affect memory budgets.
     */
    kNo = false,
    /**
     * The texture will be not use GPU memory and will not affect memory budgets.
     */
    kYes = true
};

GrMipmapStatus

enum class GrMipmapStatus

strong

Used to describe the current state of Mips on a GrTexture

Enumerator
kNotAllocated
kDirty
kValid

Definition at line 522 of file GrTypesPriv.h.

                          {
    kNotAllocated, // Mips have not been allocated
    kDirty,        // Mips are allocated but the full mip tree does not have valid data
    kValid,        // All levels fully allocated and have valid data in them
};

GrPrimitiveRestart

enum class GrPrimitiveRestart : bool

strong

Enumerator
kNo
kYes

Definition at line 55 of file GrTypesPriv.h.

                              : bool {
    kNo = false,
    kYes = true
};

GrPrimitiveType

enum class GrPrimitiveType : uint8_t

strong

Geometric primitives used for drawing.

Enumerator
kTriangles
kTriangleStrip
kPoints
kLines
kLineStrip

Definition at line 42 of file GrTypesPriv.h.

                           : uint8_t {
    kTriangles,
    kTriangleStrip,
    kPoints,
    kLines,          // 1 pix wide only
    kLineStrip,      // 1 pix wide only
};

GrQuadAAFlags

enum class GrQuadAAFlags

strong

A number of rectangle/quadrilateral drawing APIs can control anti-aliasing on a per edge basis. These masks specify which edges are AA'ed. The intent for this is to support tiling with seamless boundaries, where the inner edges are non-AA and the outer edges are AA. Regular rectangle draws simply use kAll or kNone depending on if they want anti-aliasing or not.

In APIs that support per-edge AA, GrQuadAAFlags is the only AA-control parameter that is provided (compared to the typical GrAA parameter). kNone is equivalent to GrAA::kNo, and any other set of edge flags would require GrAA::kYes (with rendering output dependent on how that maps to GrAAType for a given SurfaceDrawContext).

These values are identical to SkCanvas::QuadAAFlags.

Enumerator
kLeft
kTop
kRight
kBottom
kNone
kAll

Definition at line 246 of file GrTypesPriv.h.

                         {
    kLeft   = 0b0001,
    kTop    = 0b0010,
    kRight  = 0b0100,
    kBottom = 0b1000,
 
    kNone = 0b0000,
    kAll  = 0b1111,
};

GrScissorTest

enum class GrScissorTest : bool

strong

Enumerator
kDisabled
kEnabled

Definition at line 114 of file GrTypesPriv.h.

                         : bool {
    kDisabled = false,
    kEnabled = true
};

GrSemaphoreWrapType

enum class GrSemaphoreWrapType

strong

Enumerator
kWillSignal
kWillWait

Definition at line 145 of file GrTypesPriv.h.

                               {
    kWillSignal,
    kWillWait,
};

GrShaderFlags

enum GrShaderFlags

Enumerator
kNone_GrShaderFlags
kVertex_GrShaderFlag
kFragment_GrShaderFlag

Definition at line 283 of file GrTypesPriv.h.

                   {
    kNone_GrShaderFlags          = 0,
    kVertex_GrShaderFlag         = 1 << 0,
    kFragment_GrShaderFlag       = 1 << 1
};

GrShaderType

enum GrShaderType

Enumerator
kVertex_GrShaderType
kFragment_GrShaderType
kLast_GrShaderType

Definition at line 275 of file GrTypesPriv.h.

                  {
    kVertex_GrShaderType,
    kFragment_GrShaderType,
 
    kLast_GrShaderType = kFragment_GrShaderType
};

GrStoreOp

enum class GrStoreOp

strong

This enum is used to specify the store operation to be used when an OpsTask/GrOpsRenderPass ends execution.

Enumerator
kStore
kDiscard

Definition at line 164 of file GrTypesPriv.h.

                     {
    kStore,
    kDiscard,
};

GrTexturable

enum class GrTexturable : bool

strong

Should a created surface be texturable?

Enumerator
kNo
kYes

Definition at line 63 of file GrTypesPriv.h.

                        : bool {
    kNo = false,
    kYes = true
};

GrTextureType

enum class GrTextureType

strong

The type of texture. Backends other than GL currently only use the 2D value but the type must still be known at the API-neutral layer as it used to determine whether MIP maps, renderability, and sampling parameters are legal for proxies that will be instantiated with wrapped textures.

Enumerator
kNone
k2D
kRectangle
kExternal

Definition at line 267 of file GrTypesPriv.h.

                         {
    kNone,
    k2D,
    /* Rectangle uses unnormalized texture coordinates. */
    kRectangle,
    kExternal
};

GrVertexAttribType

enum GrVertexAttribType

Types used to describe format of vertices in arrays.

Enumerator
kFloat_GrVertexAttribType
kFloat2_GrVertexAttribType
kFloat3_GrVertexAttribType
kFloat4_GrVertexAttribType
kHalf_GrVertexAttribType
kHalf2_GrVertexAttribType
kHalf4_GrVertexAttribType
kInt2_GrVertexAttribType
kInt3_GrVertexAttribType
kInt4_GrVertexAttribType
kByte_GrVertexAttribType
kByte2_GrVertexAttribType
kByte4_GrVertexAttribType
kUByte_GrVertexAttribType
kUByte2_GrVertexAttribType
kUByte4_GrVertexAttribType
kUByte_norm_GrVertexAttribType
kUByte4_norm_GrVertexAttribType
kShort2_GrVertexAttribType
kShort4_GrVertexAttribType
kUShort2_GrVertexAttribType
kUShort2_norm_GrVertexAttribType
kInt_GrVertexAttribType
kUInt_GrVertexAttribType
kUShort_norm_GrVertexAttribType
kUShort4_norm_GrVertexAttribType
kLast_GrVertexAttribType

Definition at line 311 of file GrTypesPriv.h.

                        {
    kFloat_GrVertexAttribType = 0,
    kFloat2_GrVertexAttribType,
    kFloat3_GrVertexAttribType,
    kFloat4_GrVertexAttribType,
    kHalf_GrVertexAttribType,
    kHalf2_GrVertexAttribType,
    kHalf4_GrVertexAttribType,
 
    kInt2_GrVertexAttribType,   // vector of 2 32-bit ints
    kInt3_GrVertexAttribType,   // vector of 3 32-bit ints
    kInt4_GrVertexAttribType,   // vector of 4 32-bit ints
 
 
    kByte_GrVertexAttribType,  // signed byte
    kByte2_GrVertexAttribType, // vector of 2 8-bit signed bytes
    kByte4_GrVertexAttribType, // vector of 4 8-bit signed bytes
    kUByte_GrVertexAttribType,  // unsigned byte
    kUByte2_GrVertexAttribType, // vector of 2 8-bit unsigned bytes
    kUByte4_GrVertexAttribType, // vector of 4 8-bit unsigned bytes
 
    kUByte_norm_GrVertexAttribType,  // unsigned byte, e.g. coverage, 0 -> 0.0f, 255 -> 1.0f.
    kUByte4_norm_GrVertexAttribType, // vector of 4 unsigned bytes, e.g. colors, 0 -> 0.0f,
                                     // 255 -> 1.0f.
 
    kShort2_GrVertexAttribType,       // vector of 2 16-bit shorts.
    kShort4_GrVertexAttribType,       // vector of 4 16-bit shorts.
 
    kUShort2_GrVertexAttribType,      // vector of 2 unsigned shorts. 0 -> 0, 65535 -> 65535.
    kUShort2_norm_GrVertexAttribType, // vector of 2 unsigned shorts. 0 -> 0.0f, 65535 -> 1.0f.
 
    kInt_GrVertexAttribType,
    kUInt_GrVertexAttribType,
 
    kUShort_norm_GrVertexAttribType,
 
    kUShort4_norm_GrVertexAttribType, // vector of 4 unsigned shorts. 0 -> 0.0f, 65535 -> 1.0f.
 
    kLast_GrVertexAttribType = kUShort4_norm_GrVertexAttribType
};

GrWrapCacheable

enum class GrWrapCacheable : bool

strong

Enumerator
kNo	The wrapped resource will be removed from the cache as soon as it becomes purgeable. It may still be assigned and found by a unique key, but the presence of the key will not be used to keep the resource alive when it has no references.
kYes	The wrapped resource is allowed to remain in the GrResourceCache when it has no references but has a unique key. Such resources should only be given unique keys when it is known that the key will eventually be removed from the resource or invalidated via the message bus.

Definition at line 84 of file GrTypesPriv.h.

                           : bool {
    /**
     * The wrapped resource will be removed from the cache as soon as it becomes purgeable. It may
     * still be assigned and found by a unique key, but the presence of the key will not be used to
     * keep the resource alive when it has no references.
     */
    kNo = false,
    /**
     * The wrapped resource is allowed to remain in the GrResourceCache when it has no references
     * but has a unique key. Such resources should only be given unique keys when it is known that
     * the key will eventually be removed from the resource or invalidated via the message bus.
     */
    kYes = true
};

GrWrapOwnership

enum GrWrapOwnership

Ownership rules for external GPU resources imported into Skia.

Enumerator
kBorrow_GrWrapOwnership	Skia will assume the client will keep the resource alive and Skia will not free it.
kAdopt_GrWrapOwnership	Skia will assume ownership of the resource and free it.

Definition at line 76 of file GrTypesPriv.h.

                     {
    /** Skia will assume the client will keep the resource alive and Skia will not free it. */
    kBorrow_GrWrapOwnership,
 
    /** Skia will assume ownership of the resource and free it. */
    kAdopt_GrWrapOwnership,
};

Function Documentation

GrAATypeIsHW()

static constexpr bool GrAATypeIsHW ( GrAAType  type )

staticconstexpr

Definition at line 211 of file GrTypesPriv.h.

                                                  {
    switch (type) {
        case GrAAType::kNone:
            return false;
        case GrAAType::kCoverage:
            return false;
        case GrAAType::kMSAA:
            return true;
    }
    SkUNREACHABLE;
}

GrClipEdgeTypeIsAA()

static constexpr bool GrClipEdgeTypeIsAA ( const GrClipEdgeType  edgeType )

staticconstexpr

Definition at line 379 of file GrTypesPriv.h.

                                                                        {
    return (GrClipEdgeType::kFillBW != edgeType &&
            GrClipEdgeType::kInverseFillBW != edgeType);
}

GrClipEdgeTypeIsFill()

static constexpr bool GrClipEdgeTypeIsFill ( const GrClipEdgeType  edgeType )

staticconstexpr

Definition at line 370 of file GrTypesPriv.h.

                                                                          {
    return (GrClipEdgeType::kFillAA == edgeType || GrClipEdgeType::kFillBW == edgeType);
}

GrClipEdgeTypeIsInverseFill()

static constexpr bool GrClipEdgeTypeIsInverseFill ( const GrClipEdgeType  edgeType )

staticconstexpr

Definition at line 374 of file GrTypesPriv.h.

                                                                                 {
    return (GrClipEdgeType::kInverseFillAA == edgeType ||
            GrClipEdgeType::kInverseFillBW == edgeType);
}

GrColorTypeBytesPerPixel()

static constexpr size_t GrColorTypeBytesPerPixel ( GrColorType  ct )

staticconstexpr

Definition at line 895 of file GrTypesPriv.h.

                                                                 {
    switch (ct) {
        case GrColorType::kUnknown:          return 0;
        case GrColorType::kAlpha_8:          return 1;
        case GrColorType::kBGR_565:          return 2;
        case GrColorType::kRGB_565:          return 2;
        case GrColorType::kABGR_4444:        return 2;
        case GrColorType::kRGBA_8888:        return 4;
        case GrColorType::kRGBA_8888_SRGB:   return 4;
        case GrColorType::kRGB_888x:         return 4;
        case GrColorType::kRG_88:            return 2;
        case GrColorType::kBGRA_8888:        return 4;
        case GrColorType::kRGBA_1010102:     return 4;
        case GrColorType::kBGRA_1010102:     return 4;
        case GrColorType::kRGBA_10x6:        return 8;
        case GrColorType::kGray_8:           return 1;
        case GrColorType::kGrayAlpha_88:     return 2;
        case GrColorType::kAlpha_F16:        return 2;
        case GrColorType::kRGBA_F16:         return 8;
        case GrColorType::kRGBA_F16_Clamped: return 8;
        case GrColorType::kRGBA_F32:         return 16;
        case GrColorType::kAlpha_8xxx:       return 4;
        case GrColorType::kAlpha_F32xxx:     return 16;
        case GrColorType::kGray_8xxx:        return 4;
        case GrColorType::kR_8xxx:           return 4;
        case GrColorType::kAlpha_16:         return 2;
        case GrColorType::kRG_1616:          return 4;
        case GrColorType::kRGBA_16161616:    return 8;
        case GrColorType::kRG_F16:           return 4;
        case GrColorType::kRGB_888:          return 3;
        case GrColorType::kR_8:              return 1;
        case GrColorType::kR_16:             return 2;
        case GrColorType::kR_F16:            return 2;
        case GrColorType::kGray_F16:         return 2;
        case GrColorType::kARGB_4444:        return 2;
        case GrColorType::kBGRA_4444:        return 2;
    }
    SkUNREACHABLE;
}

GrColorTypeChannelFlags()

static constexpr uint32_t GrColorTypeChannelFlags ( GrColorType  ct )

staticconstexpr

Definition at line 660 of file GrTypesPriv.h.

                                                                  {
    switch (ct) {
        case GrColorType::kUnknown:          return 0;
        case GrColorType::kAlpha_8:          return kAlpha_SkColorChannelFlag;
        case GrColorType::kBGR_565:          return kRGB_SkColorChannelFlags;
        case GrColorType::kRGB_565:          return kRGB_SkColorChannelFlags;
        case GrColorType::kABGR_4444:        return kRGBA_SkColorChannelFlags;
        case GrColorType::kRGBA_8888:        return kRGBA_SkColorChannelFlags;
        case GrColorType::kRGBA_8888_SRGB:   return kRGBA_SkColorChannelFlags;
        case GrColorType::kRGB_888x:         return kRGB_SkColorChannelFlags;
        case GrColorType::kRG_88:            return kRG_SkColorChannelFlags;
        case GrColorType::kBGRA_8888:        return kRGBA_SkColorChannelFlags;
        case GrColorType::kRGBA_1010102:     return kRGBA_SkColorChannelFlags;
        case GrColorType::kBGRA_1010102:     return kRGBA_SkColorChannelFlags;
        case GrColorType::kRGBA_10x6:        return kRGBA_SkColorChannelFlags;
        case GrColorType::kGray_8:           return kGray_SkColorChannelFlag;
        case GrColorType::kGrayAlpha_88:     return kGrayAlpha_SkColorChannelFlags;
        case GrColorType::kAlpha_F16:        return kAlpha_SkColorChannelFlag;
        case GrColorType::kRGBA_F16:         return kRGBA_SkColorChannelFlags;
        case GrColorType::kRGBA_F16_Clamped: return kRGBA_SkColorChannelFlags;
        case GrColorType::kRGBA_F32:         return kRGBA_SkColorChannelFlags;
        case GrColorType::kAlpha_8xxx:       return kAlpha_SkColorChannelFlag;
        case GrColorType::kAlpha_F32xxx:     return kAlpha_SkColorChannelFlag;
        case GrColorType::kGray_8xxx:        return kGray_SkColorChannelFlag;
        case GrColorType::kR_8xxx:           return kRed_SkColorChannelFlag;
        case GrColorType::kAlpha_16:         return kAlpha_SkColorChannelFlag;
        case GrColorType::kRG_1616:          return kRG_SkColorChannelFlags;
        case GrColorType::kRGBA_16161616:    return kRGBA_SkColorChannelFlags;
        case GrColorType::kRG_F16:           return kRG_SkColorChannelFlags;
        case GrColorType::kRGB_888:          return kRGB_SkColorChannelFlags;
        case GrColorType::kR_8:              return kRed_SkColorChannelFlag;
        case GrColorType::kR_16:             return kRed_SkColorChannelFlag;
        case GrColorType::kR_F16:            return kRed_SkColorChannelFlag;
        case GrColorType::kGray_F16:         return kGray_SkColorChannelFlag;
        case GrColorType::kARGB_4444:        return kRGBA_SkColorChannelFlags;
        case GrColorType::kBGRA_4444:        return kRGBA_SkColorChannelFlags;
    }
    SkUNREACHABLE;
}

GrColorTypeClampType()

static constexpr GrClampType GrColorTypeClampType ( GrColorType  colorType )

staticconstexpr

Definition at line 867 of file GrTypesPriv.h.

                                                                         {
    if (GrGetColorTypeDesc(colorType).encoding() == GrColorTypeEncoding::kUnorm ||
        GrGetColorTypeDesc(colorType).encoding() == GrColorTypeEncoding::kSRGBUnorm) {
        return GrClampType::kAuto;
    }
    return GrColorType::kRGBA_F16_Clamped == colorType ? GrClampType::kManual : GrClampType::kNone;
}

GrColorTypeHasAlpha()

static constexpr bool GrColorTypeHasAlpha ( GrColorType  ct )

staticconstexpr

Definition at line 891 of file GrTypesPriv.h.

                                                          {
    return GrColorTypeChannelFlags(ct) & kAlpha_SkColorChannelFlag;
}

GrColorTypeIsAlphaOnly()

static constexpr bool GrColorTypeIsAlphaOnly ( GrColorType  ct )

staticconstexpr

Definition at line 887 of file GrTypesPriv.h.

                                                             {
    return GrColorTypeChannelFlags(ct) == kAlpha_SkColorChannelFlag;
}

GrColorTypeIsWiderThan()

static constexpr bool GrColorTypeIsWiderThan ( GrColorType  colorType, int  n  )

staticconstexpr

Definition at line 877 of file GrTypesPriv.h.

                                                                           {
    SkASSERT(n > 0);
    auto desc = GrGetColorTypeDesc(colorType);
    return (desc.r() && desc.r() > n )||
           (desc.g() && desc.g() > n) ||
           (desc.b() && desc.b() > n) ||
           (desc.a() && desc.a() > n) ||
           (desc.gray() && desc.gray() > n);
}

GrColorTypeToSkColorType()

static constexpr SkColorType GrColorTypeToSkColorType ( GrColorType  ct )

staticconstexpr

Definition at line 588 of file GrTypesPriv.h.

                                                                      {
    switch (ct) {
        case GrColorType::kUnknown:          return kUnknown_SkColorType;
        case GrColorType::kAlpha_8:          return kAlpha_8_SkColorType;
        case GrColorType::kBGR_565:          return kRGB_565_SkColorType;
        case GrColorType::kRGB_565:          return kUnknown_SkColorType;
        case GrColorType::kABGR_4444:        return kARGB_4444_SkColorType;
        case GrColorType::kRGBA_8888:        return kRGBA_8888_SkColorType;
        case GrColorType::kRGBA_8888_SRGB:   return kSRGBA_8888_SkColorType;
        case GrColorType::kRGB_888x:         return kRGB_888x_SkColorType;
        case GrColorType::kRG_88:            return kR8G8_unorm_SkColorType;
        case GrColorType::kBGRA_8888:        return kBGRA_8888_SkColorType;
        case GrColorType::kRGBA_1010102:     return kRGBA_1010102_SkColorType;
        case GrColorType::kBGRA_1010102:     return kBGRA_1010102_SkColorType;
        case GrColorType::kRGBA_10x6:        return kRGBA_10x6_SkColorType;
        case GrColorType::kGray_8:           return kGray_8_SkColorType;
        case GrColorType::kGrayAlpha_88:     return kUnknown_SkColorType;
        case GrColorType::kAlpha_F16:        return kA16_float_SkColorType;
        case GrColorType::kRGBA_F16:         return kRGBA_F16_SkColorType;
        case GrColorType::kRGBA_F16_Clamped: return kRGBA_F16Norm_SkColorType;
        case GrColorType::kRGBA_F32:         return kRGBA_F32_SkColorType;
        case GrColorType::kAlpha_8xxx:       return kUnknown_SkColorType;
        case GrColorType::kAlpha_F32xxx:     return kUnknown_SkColorType;
        case GrColorType::kGray_8xxx:        return kUnknown_SkColorType;
        case GrColorType::kR_8xxx:           return kUnknown_SkColorType;
        case GrColorType::kAlpha_16:         return kA16_unorm_SkColorType;
        case GrColorType::kRG_1616:          return kR16G16_unorm_SkColorType;
        case GrColorType::kRGBA_16161616:    return kR16G16B16A16_unorm_SkColorType;
        case GrColorType::kRG_F16:           return kR16G16_float_SkColorType;
        case GrColorType::kRGB_888:          return kUnknown_SkColorType;
        case GrColorType::kR_8:              return kR8_unorm_SkColorType;
        case GrColorType::kR_16:             return kUnknown_SkColorType;
        case GrColorType::kR_F16:            return kUnknown_SkColorType;
        case GrColorType::kGray_F16:         return kUnknown_SkColorType;
        case GrColorType::kARGB_4444:        return kUnknown_SkColorType;
        case GrColorType::kBGRA_4444:        return kUnknown_SkColorType;
    }
    SkUNREACHABLE;
}

GrFillRuleForPathFillType()

GrFillRule GrFillRuleForPathFillType ( SkPathFillType  fillType )

inline

Definition at line 182 of file GrTypesPriv.h.

                                                                     {
    switch (fillType) {
        case SkPathFillType::kWinding:
        case SkPathFillType::kInverseWinding:
            return GrFillRule::kNonzero;
        case SkPathFillType::kEvenOdd:
        case SkPathFillType::kInverseEvenOdd:
            return GrFillRule::kEvenOdd;
    }
    SkUNREACHABLE;
}

GrFillRuleForSkPath()

GrFillRule GrFillRuleForSkPath ( const SkPath &  path )

inline

Definition at line 194 of file GrTypesPriv.h.

                                                          {
    return GrFillRuleForPathFillType(path.getFillType());
}

GrGetColorTypeDesc()

static constexpr GrColorFormatDesc GrGetColorTypeDesc ( GrColorType  ct )

staticconstexpr

Definition at line 793 of file GrTypesPriv.h.

                                                                      {
    switch (ct) {
        case GrColorType::kUnknown:
            return GrColorFormatDesc::MakeInvalid();
        case GrColorType::kAlpha_8:
            return GrColorFormatDesc::MakeAlpha(8, GrColorTypeEncoding::kUnorm);
        case GrColorType::kBGR_565:
            return GrColorFormatDesc::MakeRGB(5, 6, 5, GrColorTypeEncoding::kUnorm);
        case GrColorType::kRGB_565:
            return GrColorFormatDesc::MakeRGB(5, 6, 5, GrColorTypeEncoding::kUnorm);
        case GrColorType::kABGR_4444:
            return GrColorFormatDesc::MakeRGBA(4, GrColorTypeEncoding::kUnorm);
        case GrColorType::kRGBA_8888:
            return GrColorFormatDesc::MakeRGBA(8, GrColorTypeEncoding::kUnorm);
        case GrColorType::kRGBA_8888_SRGB:
            return GrColorFormatDesc::MakeRGBA(8, GrColorTypeEncoding::kSRGBUnorm);
        case GrColorType::kRGB_888x:
            return GrColorFormatDesc::MakeRGB(8, GrColorTypeEncoding::kUnorm);
        case GrColorType::kRG_88:
            return GrColorFormatDesc::MakeRG(8, GrColorTypeEncoding::kUnorm);
        case GrColorType::kBGRA_8888:
            return GrColorFormatDesc::MakeRGBA(8, GrColorTypeEncoding::kUnorm);
        case GrColorType::kRGBA_1010102:
            return GrColorFormatDesc::MakeRGBA(10, 2, GrColorTypeEncoding::kUnorm);
        case GrColorType::kBGRA_1010102:
            return GrColorFormatDesc::MakeRGBA(10, 2, GrColorTypeEncoding::kUnorm);
        case GrColorType::kRGBA_10x6:
            return GrColorFormatDesc::MakeRGBA(10, GrColorTypeEncoding::kUnorm);
        case GrColorType::kGray_8:
            return GrColorFormatDesc::MakeGray(8, GrColorTypeEncoding::kUnorm);
        case GrColorType::kGrayAlpha_88:
            return GrColorFormatDesc::MakeGrayAlpha(8, GrColorTypeEncoding::kUnorm);
        case GrColorType::kAlpha_F16:
            return GrColorFormatDesc::MakeAlpha(16, GrColorTypeEncoding::kFloat);
        case GrColorType::kRGBA_F16:
            return GrColorFormatDesc::MakeRGBA(16, GrColorTypeEncoding::kFloat);
        case GrColorType::kRGBA_F16_Clamped:
            return GrColorFormatDesc::MakeRGBA(16, GrColorTypeEncoding::kFloat);
        case GrColorType::kRGBA_F32:
            return GrColorFormatDesc::MakeRGBA(32, GrColorTypeEncoding::kFloat);
        case GrColorType::kAlpha_8xxx:
            return GrColorFormatDesc::MakeAlpha(8, GrColorTypeEncoding::kUnorm);
        case GrColorType::kAlpha_F32xxx:
            return GrColorFormatDesc::MakeAlpha(32, GrColorTypeEncoding::kFloat);
        case GrColorType::kGray_8xxx:
            return GrColorFormatDesc::MakeGray(8, GrColorTypeEncoding::kUnorm);
        case GrColorType::kR_8xxx:
            return GrColorFormatDesc::MakeR(8, GrColorTypeEncoding::kUnorm);
        case GrColorType::kAlpha_16:
            return GrColorFormatDesc::MakeAlpha(16, GrColorTypeEncoding::kUnorm);
        case GrColorType::kRG_1616:
            return GrColorFormatDesc::MakeRG(16, GrColorTypeEncoding::kUnorm);
        case GrColorType::kRGBA_16161616:
            return GrColorFormatDesc::MakeRGBA(16, GrColorTypeEncoding::kUnorm);
        case GrColorType::kRG_F16:
            return GrColorFormatDesc::MakeRG(16, GrColorTypeEncoding::kFloat);
        case GrColorType::kRGB_888:
            return GrColorFormatDesc::MakeRGB(8, GrColorTypeEncoding::kUnorm);
        case GrColorType::kR_8:
            return GrColorFormatDesc::MakeR(8, GrColorTypeEncoding::kUnorm);
        case GrColorType::kR_16:
            return GrColorFormatDesc::MakeR(16, GrColorTypeEncoding::kUnorm);
        case GrColorType::kR_F16:
            return GrColorFormatDesc::MakeR(16, GrColorTypeEncoding::kFloat);
        case GrColorType::kGray_F16:
            return GrColorFormatDesc::MakeGray(16, GrColorTypeEncoding::kFloat);
        case GrColorType::kARGB_4444:
            return GrColorFormatDesc::MakeRGBA(4, GrColorTypeEncoding::kUnorm);
        case GrColorType::kBGRA_4444:
            return GrColorFormatDesc::MakeRGBA(4, GrColorTypeEncoding::kUnorm);
    }
    SkUNREACHABLE;
}

GrInvertClipEdgeType()

static GrClipEdgeType GrInvertClipEdgeType ( const GrClipEdgeType  edgeType )

inlinestatic

Definition at line 384 of file GrTypesPriv.h.

                                                                                 {
    switch (edgeType) {
        case GrClipEdgeType::kFillBW:
            return GrClipEdgeType::kInverseFillBW;
        case GrClipEdgeType::kFillAA:
            return GrClipEdgeType::kInverseFillAA;
        case GrClipEdgeType::kInverseFillBW:
            return GrClipEdgeType::kFillBW;
        case GrClipEdgeType::kInverseFillAA:
            return GrClipEdgeType::kFillAA;
    }
    SkUNREACHABLE;
}

GrIsPrimTypeLines()

static constexpr bool GrIsPrimTypeLines ( GrPrimitiveType  type )

staticconstexpr

Definition at line 51 of file GrTypesPriv.h.

                                                              {
    return GrPrimitiveType::kLines == type || GrPrimitiveType::kLineStrip == type;
}

GrSizeDivRoundUp()

static constexpr size_t GrSizeDivRoundUp ( size_t  x, size_t  y  )

inlinestaticconstexpr

divide, rounding up

Definition at line 37 of file GrTypesPriv.h.

{ return (x + (y - 1)) / y; }

GrTextureTypeHasRestrictedSampling()

static bool GrTextureTypeHasRestrictedSampling ( GrTextureType  type )

inlinestatic

Rectangle and external textures only support the clamp wrap mode and do not support MIP maps.

Definition at line 293 of file GrTypesPriv.h.

                                                                          {
    switch (type) {
        case GrTextureType::k2D:
            return false;
        case GrTextureType::kRectangle:
            return true;
        case GrTextureType::kExternal:
            return true;
        default:
            SK_ABORT("Unexpected texture type");
    }
}

SkColorTypeToGrColorType()

static constexpr GrColorType SkColorTypeToGrColorType ( SkColorType  ct )

staticconstexpr

Definition at line 628 of file GrTypesPriv.h.

                                                                      {
    switch (ct) {
        case kUnknown_SkColorType:            return GrColorType::kUnknown;
        case kAlpha_8_SkColorType:            return GrColorType::kAlpha_8;
        case kRGB_565_SkColorType:            return GrColorType::kBGR_565;
        case kARGB_4444_SkColorType:          return GrColorType::kABGR_4444;
        case kRGBA_8888_SkColorType:          return GrColorType::kRGBA_8888;
        case kSRGBA_8888_SkColorType:         return GrColorType::kRGBA_8888_SRGB;
        case kRGB_888x_SkColorType:           return GrColorType::kRGB_888x;
        case kBGRA_8888_SkColorType:          return GrColorType::kBGRA_8888;
        case kGray_8_SkColorType:             return GrColorType::kGray_8;
        case kRGBA_F16Norm_SkColorType:       return GrColorType::kRGBA_F16_Clamped;
        case kRGBA_F16_SkColorType:           return GrColorType::kRGBA_F16;
        case kRGBA_1010102_SkColorType:       return GrColorType::kRGBA_1010102;
        case kRGB_101010x_SkColorType:        return GrColorType::kUnknown;
        case kBGRA_1010102_SkColorType:       return GrColorType::kBGRA_1010102;
        case kBGR_101010x_SkColorType:        return GrColorType::kUnknown;
        case kBGR_101010x_XR_SkColorType:     return GrColorType::kUnknown;
        case kBGRA_10101010_XR_SkColorType:   return GrColorType::kUnknown;
        case kRGBA_10x6_SkColorType:          return GrColorType::kRGBA_10x6;
        case kRGBA_F32_SkColorType:           return GrColorType::kRGBA_F32;
        case kR8G8_unorm_SkColorType:         return GrColorType::kRG_88;
        case kA16_unorm_SkColorType:          return GrColorType::kAlpha_16;
        case kR16G16_unorm_SkColorType:       return GrColorType::kRG_1616;
        case kA16_float_SkColorType:          return GrColorType::kAlpha_F16;
        case kR16G16_float_SkColorType:       return GrColorType::kRG_F16;
        case kR16G16B16A16_unorm_SkColorType: return GrColorType::kRGBA_16161616;
        case kR8_unorm_SkColorType:           return GrColorType::kR_8;
    }
    SkUNREACHABLE;
}

SkToGrQuadAAFlags()

static GrQuadAAFlags SkToGrQuadAAFlags ( unsigned  flags )

inlinestatic

Definition at line 258 of file GrTypesPriv.h.

                                                              {
    return static_cast<GrQuadAAFlags>(flags);
}

Variable Documentation

kGrAATypeCount

const int kGrAATypeCount = static_cast<int>(GrAAType::kLast) + 1

static

Definition at line 209 of file GrTypesPriv.h.

kGrClipEdgeTypeCnt

const int kGrClipEdgeTypeCnt = (int) GrClipEdgeType::kLast + 1

static

Definition at line 368 of file GrTypesPriv.h.

kGrColorTypeCnt

const int kGrColorTypeCnt = static_cast<int>(GrColorType::kLast) + 1

static

Definition at line 586 of file GrTypesPriv.h.

kGrGpuBufferTypeCount

const constexpr int kGrGpuBufferTypeCount = static_cast<int>(GrGpuBufferType::kUniform) + 1

staticconstexpr

Definition at line 418 of file GrTypesPriv.h.

kGrInternalRenderTargetFlagsMask

constexpr int kGrInternalRenderTargetFlagsMask

staticconstexpr

Initial value:

= static_cast<int>(
        GrInternalSurfaceFlags::kGLRTFBOIDIs0 |
        GrInternalSurfaceFlags::kRequiresManualMSAAResolve)

Definition at line 477 of file GrTypesPriv.h.

kGrInternalTextureFlagsMask

constexpr int kGrInternalTextureFlagsMask

staticconstexpr

Initial value:

= static_cast<int>(
        GrInternalSurfaceFlags::kReadOnly)

Definition at line 468 of file GrTypesPriv.h.

kGrInternalTextureRenderTargetFlagsMask

constexpr int kGrInternalTextureRenderTargetFlagsMask

staticconstexpr

Initial value:

=
        kGrInternalTextureFlagsMask | kGrInternalRenderTargetFlagsMask

Definition at line 482 of file GrTypesPriv.h.

kGrShaderTypeCount

const int kGrShaderTypeCount = kLast_GrShaderType + 1

static

Definition at line 281 of file GrTypesPriv.h.

kGrVertexAttribTypeCount

const int kGrVertexAttribTypeCount = kLast_GrVertexAttribType + 1

static

Definition at line 351 of file GrTypesPriv.h.

kNumGrPrimitiveTypes

constexpr int kNumGrPrimitiveTypes = (int)GrPrimitiveType::kLineStrip + 1

staticconstexpr

Definition at line 49 of file GrTypesPriv.h.