Namespaces
namespace	ContextFactory

namespace	DrawPassCommands

namespace	LayoutRules

namespace	PrecompileBlenders

namespace	PrecompileColorFilters

namespace	PrecompileColorFiltersPriv

namespace	PrecompileImageFilters

namespace	PrecompileMaskFilters

namespace	PrecompileShaders

namespace	PrecompileShadersPriv

namespace	ycbcrPackaging

Classes
struct	AlphaOnlyPaintColorBlock

class	AnalyticBlurMask

class	AnalyticBlurRenderStep

class	AnalyticRRectRenderStep

class	AtlasProvider

struct	AttachmentDesc

class	Attribute

class	AutoDeinstantiateTextureProxy

class	AutoLockBuilderAsKey

class	BackendSemaphore

class	BackendTexture

struct	BindBufferInfo

struct	BindUniformBufferInfo

class	BitmapTextRenderStep

struct	BlendModeBlenderBlock

struct	BlendShaderBlock

class	BoundsManager

class	BoundsManagerBench

class	BruteForceBoundsManager

class	Buffer

struct	BufferTextureCopyData

struct	BufferView

class	Caps

struct	ClearBufferInfo

class	ClearBuffersTask

class	ClientMappedBufferManager

class	Clip

struct	ClipShaderBlock

class	ClipStack

struct	CoeffBlenderBlock

struct	ColorSpaceTransformBlock

class	CommandBuffer

struct	ComposeBlock

struct	CompressedPaintersOrderSequence

class	ComputePathAtlas

class	ComputePipeline

class	ComputePipelineDesc

class	ComputeStep

class	ComputeTask

class	ConditionalUploadContext

class	Context

class	ContextCtorAccessor

struct	ContextOptions

struct	ContextOptionsPriv

class	ContextPriv

struct	CoordClampShaderBlock

class	CopyBufferToBufferTask

class	CopyTextureToBufferTask

class	CopyTextureToTextureTask

class	CoverageMaskRenderStep

class	CoverageMaskShape

class	CoverBoundsRenderStep

class	DawnAsyncResult

class	DawnAsyncWait

struct	DawnBackendContext

class	DawnBuffer

class	DawnCaps

class	DawnCommandBuffer

class	DawnComputePipeline

class	DawnErrorChecker

class	DawnGraphicsPipeline

class	DawnQueueManager

class	DawnResourceProvider

class	DawnSampler

class	DawnSharedContext

class	DawnTexture

struct	DawnTextureInfo

struct	DawnTextureSpec

class	DefaultImageProvider

struct	DepthStencilSettings

struct	DescriptorData

class	Device

struct	DisjointStencilIndexSequence

class	DispatchGroup

struct	DitherShaderBlock

class	DrawAtlas

class	DrawAtlasConfig

class	DrawBufferManager

class	DrawContext

class	DrawList

class	DrawOrder

class	DrawParams

class	DrawPass

class	DrawTask

class	DrawWriter

struct	DstReadSampleBlock

class	DynamicInstancesPatchAllocator

class	EdgeAAQuad

struct	Expectation

class	FileBoundsManagerBench

class	FileIntersectionBench

struct	FragSkSLInfo

class	Geometry

class	GlobalCache

class	GpuWorkSubmission

struct	GradientShaderBlocks

class	GraphicsPipeline

class	GraphicsPipelineDesc

class	GraphiteResourceKey

class	GridBoundsManager

class	HybridBoundsManager

class	Image

class	Image_Base

class	Image_YUVA

class	ImageProvider

struct	ImageShaderBlock

class	ImageUploadContext

struct	ImmutableSamplerInfo

struct	IndirectDispatchArgs

struct	InsertFinishInfo

struct	InsertRecordingInfo

class	IntersectionTree

class	IntersectionTreeBench

class	KeyContext

class	KeyContextWithColorInfo

class	KeyContextWithCoordClamp

class	KeyContextWithLocalMatrix

class	KeyContextWithScope

struct	LayoutTraits

struct	LocalMatrixShaderBlock

struct	MatrixColorFilterBlock

class	MiddleOutFanRenderStep

struct	MipLevel

class	MonotonicValue

struct	MtlBackendContext

class	MtlBlitCommandEncoder

class	MtlBuffer

class	MtlCaps

class	MtlCommandBuffer

class	MtlComputeCommandEncoder

class	MtlComputePipeline

class	MtlGraphicsPipeline

class	MtlQueueManager

class	MtlRenderCommandEncoder

class	MtlResourceProvider

class	MtlSampler

class	MtlSharedContext

class	MtlTexture

struct	MtlTextureInfo

struct	MtlTextureSpec

class	MtlWorkSubmission

class	NaiveBoundsManager

struct	PaintersDepthSequence

class	PaintOption

class	PaintOptions

class	PaintOptionsPriv

class	PaintParams

class	PaintParamsKey

class	PaintParamsKeyBuilder

class	PathAtlas

class	PerEdgeAAQuadRenderStep

struct	PerlinNoiseShaderBlock

class	PipelineDataCache

class	PipelineDataGatherer

class	PrecompileBase

class	PrecompileBasePriv

class	PrecompileBlender

class	PrecompileBlenderPriv

class	PrecompileBlendFilterImageFilter

class	PrecompileBlendModeBlender

class	PrecompileBlendModeColorFilter

class	PrecompileBlendShader

class	PrecompileBlurImageFilter

class	PrecompileBlurMaskFilter

class	PrecompileBlurShader

class	PrecompileChildPtr

class	PrecompileColorFilter

class	PrecompileColorFilterImageFilter

class	PrecompileColorFilterShader

class	PrecompileColorShader

class	PrecompileColorSpaceXformColorFilter

class	PrecompileComposeColorFilter

class	PrecompileCoordClampShader

class	PrecompileCTMShader

class	PrecompileDisplacementMapImageFilter

class	PrecompileDisplacementShader

class	PrecompileEmptyShader

class	PrecompileGaussianColorFilter

class	PrecompileGradientShader

class	PrecompileImageFilter

class	PrecompileImageShader

class	PrecompileLightingImageFilter

class	PrecompileLightingShader

class	PrecompileLocalMatrixShader

class	PrecompileMaskFilter

class	PrecompileMatrixColorFilter

class	PrecompileMatrixConvolutionImageFilter

class	PrecompileMatrixConvolutionShader

class	PrecompileMorphologyImageFilter

class	PrecompileMorphologyShader

class	PrecompilePerlinNoiseShader

class	PrecompileRTEffect

class	PrecompileShader

class	PrecompileShaderPriv

class	PrecompileTableColorFilter

class	PrecompileWithWorkingFormatColorFilter

class	PrecompileWorkingColorSpaceShader

class	PrecompileYUVImageShader

class	ProxyCache

class	ProxyReadCountMap

class	QueueManager

class	RandomBoundsManagerBench

class	RandomIntersectionBench

class	RasterMaskHelper

class	RasterPathAtlas

class	Recorder

struct	RecorderOptions

class	RecorderPriv

class	Recording

class	RecordingPriv

class	Rect

class	Renderer

class	RendererProvider

struct	RenderPassDesc

class	RenderPassTask

class	RenderStep

class	Resource

struct	ResourceBinding

struct	ResourceBindingRequirements

class	ResourceCache

class	ResourceProvider

struct	RGBPaintColorBlock

struct	RuntimeEffectBlock

class	RuntimeEffectDictionary

class	Sampler

struct	SamplerDesc

struct	SamplerIndex

class	ScratchBuffer

class	ScratchResourceManager

class	SDFTextLCDRenderStep

class	SDFTextRenderStep

class	ShaderCodeDictionary

class	ShaderInfo

class	ShaderNode

struct	ShaderSnippet

class	Shape

class	SharedContext

class	SimpleIntersectionTree

struct	SolidColorShaderBlock

class	SpecialImage

class	StaticBufferManager

class	StrokeStyle

class	SubRunData

class	Surface

class	SynchronizeToCpuTask

struct	TableColorFilterBlock

class	Task

class	TaskList

class	TessellateCurvesRenderStep

class	TessellateStrokesRenderStep

class	TessellateWedgesRenderStep

class	TestResource

class	TextAtlasManager

class	Texture

class	TextureAndSampler

class	TextureDataBlock

struct	TextureIndex

class	TextureInfo

class	TextureProxy

class	TextureProxyView

class	Transform

class	Uniform

class	UniformDataBlock

class	UniformManager

class	UniformOffsetCalculator

class	UniquePaintParamsID

class	UploadBufferManager

class	UploadInstance

class	UploadList

class	UploadTask

struct	Varying

class	VelloFineAreaAlpha8Step

class	VelloFineAreaStep

class	VelloFineMsaa16Alpha8Step

class	VelloFineMsaa16Step

class	VelloFineMsaa8Alpha8Step

class	VelloFineMsaa8Step

class	VelloFineMsaaStepBase

class	VelloFineStepBase

class	VelloRenderer

class	VelloScene

class	VelloStep

struct	Vertex

class	VerticesRenderStep

struct	VertSkSLInfo

class	VulkanBuffer

class	VulkanCaps

class	VulkanCommandBuffer

class	VulkanDescriptorPool

class	VulkanDescriptorSet

class	VulkanFramebuffer

class	VulkanGraphicsPipeline

class	VulkanImageView

class	VulkanQueueManager

class	VulkanRenderPass

class	VulkanResourceProvider

class	VulkanSampler

class	VulkanSharedContext

class	VulkanTexture

struct	VulkanTextureInfo

struct	VulkanTextureSpec

class	VulkanWorkSubmission

class	VulkanYcbcrConversion

struct	WorkgroupSize

class	YUVABackendTextureInfo

class	YUVABackendTextures

struct	YUVImageShaderBlock

Typedefs
using	DawnTickFunction = void(const wgpu::Instance &device)

using	GpuFinishedContext = void *

using	GpuFinishedProc = void(*)(GpuFinishedContext finishedContext, CallbackResult)

using	MtlPixelFormat = unsigned int

using	MtlTextureUsage = unsigned int

using	MtlStorageMode = unsigned int

using	UniformDataCache = PipelineDataCache< UniformDataBlock >

using	TextureDataCache = PipelineDataCache< TextureDataBlock >

using	Builder = DispatchGroup::Builder

using	BindingIndex = uint32_t

using	DispatchResource = std::variant< BufferView, TextureIndex, SamplerIndex >

using	DispatchResourceOptional = std::variant< std::monostate, BufferView, TextureIndex, SamplerIndex >

using	CompressedPaintersOrder = MonotonicValue< CompressedPaintersOrderSequence >

using	DisjointStencilIndex = MonotonicValue< DisjointStencilIndexSequence >

using	PaintersDepth = MonotonicValue< PaintersDepthSequence >

using	PrecompileChildOptions = SkSpan< const PrecompileChildPtr >

using	AddToKeyFn = std::function< void()>

using	AAFlags = EdgeAAQuad::Flags

using	ResourceType = uint32_t

using	Status = Task::Status

using	DrawCallback = std::function< void(SkCanvas *)>

Enumerations
enum class	SyncToCpu : bool { kYes = true , kNo = false }

enum class	Volatile : bool { kNo = false , kYes = true }

enum	DrawTypeFlags : uint8_t { kNone = 0b0000 , kText = 0b0001 , kDrawVertices = 0b0010 , kSimpleShape = 0b0100 , kNonSimpleShape = 0b1000 , kShape = kSimpleShape \| kNonSimpleShape , kMostCommon = kText \| kShape , kAll = kText \| kDrawVertices \| kShape }

enum class	PathRendererStrategy { kDefault , kComputeAnalyticAA , kComputeMSAA16 , kComputeMSAA8 , kRasterAA , kTessellation }

enum class	BuiltInCodeSnippetID : int32_t { kError , kPriorOutput , kSolidColorShader , kRGBPaintColor , kAlphaOnlyPaintColor , kLinearGradientShader4 , kLinearGradientShader8 , kLinearGradientShaderTexture , kLinearGradientShaderBuffer , kRadialGradientShader4 , kRadialGradientShader8 , kRadialGradientShaderTexture , kRadialGradientShaderBuffer , kSweepGradientShader4 , kSweepGradientShader8 , kSweepGradientShaderTexture , kSweepGradientShaderBuffer , kConicalGradientShader4 , kConicalGradientShader8 , kConicalGradientShaderTexture , kConicalGradientShaderBuffer , kLocalMatrixShader , kImageShader , kCubicImageShader , kHWImageShader , kYUVImageShader , kCubicYUVImageShader , kHWYUVImageShader , kCoordClampShader , kDitherShader , kPerlinNoiseShader , kRuntimeShader , kMatrixColorFilter , kTableColorFilter , kGaussianColorFilter , kColorSpaceXformColorFilter , kBlendShader , kBlendModeBlender , kCoeffBlender , kPrimitiveColor , kDstReadSample , kDstReadFetch , kClipShader , kCompose , kFixedFunctionClearBlendMode , kFixedFunctionSrcBlendMode , kFixedFunctionDstBlendMode , kFixedFunctionSrcOverBlendMode , kFixedFunctionDstOverBlendMode , kFixedFunctionSrcInBlendMode , kFixedFunctionDstInBlendMode , kFixedFunctionSrcOutBlendMode , kFixedFunctionDstOutBlendMode , kFixedFunctionSrcATopBlendMode , kFixedFunctionDstATopBlendMode , kFixedFunctionXorBlendMode , kFixedFunctionPlusBlendMode , kFixedFunctionModulateBlendMode , kFixedFunctionScreenBlendMode , kFirstFixedFunctionBlendMode = kFixedFunctionClearBlendMode , kLast = kFixedFunctionScreenBlendMode }

enum class	DstReadRequirement { kNone , kTextureCopy , kTextureSample , kFramebufferFetch }

enum class	VelloAaConfig { kAnalyticArea , kMSAA16 , kMSAA8 }

enum class	DawnErrorType : uint32_t { kNoError = 0b00000000 , kValidation = 0b00000001 , kOutOfMemory = 0b00000010 , kInternal = 0b00000100 }

enum class	DescriptorType : uint8_t { kUniformBuffer = 0 , kTextureSampler , kTexture , kCombinedTextureSampler , kStorageBuffer , kInputAttachment , kLast = kInputAttachment }

enum class	PipelineStageFlags : uint8_t { kVertexShader = 0b001 , kFragmentShader = 0b010 , kCompute = 0b100 }

enum class	PrimitiveType : uint8_t { kTriangles , kTriangleStrip , kPoints }

enum class	VertexAttribType : uint8_t { kFloat = 0 , kFloat2 , kFloat3 , kFloat4 , kHalf , kHalf2 , kHalf4 , kInt2 , kInt3 , kInt4 , kByte , kByte2 , kByte4 , kUByte , kUByte2 , kUByte4 , kUByte_norm , kUByte4_norm , kShort2 , kShort4 , kUShort2 , kUShort2_norm , kInt , kUInt , kUShort_norm , kUShort4_norm , kLast = kUShort4_norm }

enum class	UniformSlot { kRenderStep , kPaint , kGradient }

enum class	CompareOp : uint8_t { kAlways , kNever , kGreater , kGEqual , kLess , kLEqual , kEqual , kNotEqual }

enum class	StencilOp : uint8_t { kKeep , kZero , kReplace , kInvert , kIncWrap , kDecWrap , kIncClamp , kDecClamp }

enum class	DstColorType { kSurface , kPrimitive , kChildOutput }

enum class	Priority : int { kFatal = 0 , kError = 1 , kWarning = 2 , kDebug = 3 }

enum class	PrecompileImageShaderFlags { kNone = 0b00 , kExcludeAlpha = 0b01 , kExcludeCubic = 0b10 }

enum class	ReadSwizzle { kRGBA , kRGB1 , kRRR1 , kBGRA , k000R }

enum class	Coverage { kNone , kSingleChannel , kLCD }

enum class	DepthStencilFlags : int { kNone = 0b000 , kDepth = 0b001 , kStencil = 0b010 , kDepthStencil = kDepth \| kStencil }

enum class	LoadOp : uint8_t { kLoad , kClear , kDiscard , kLast = kDiscard }

enum class	StoreOp : uint8_t { kStore , kDiscard , kLast = kDiscard }

enum class	BufferType : int { kVertex , kIndex , kXferCpuToGpu , kXferGpuToCpu , kUniform , kStorage , kIndirect , kVertexStorage , kIndexStorage , kLast = kIndexStorage }

enum class	Layout { kInvalid = 0 , kStd140 , kStd430 , kMetal }

enum class	AccessPattern : int { kGpuOnly , kHostVisible }

enum class	ClearBuffer : bool { kNo = false , kYes = true }

enum class	Discardable : bool { kNo = false , kYes = true }

enum class	Ownership { kOwned , kWrapped }

enum class	Shareable : bool { kNo = false , kYes = true }

enum class	LastRemovedRef { kUsage , kCommandBuffer , kCache }

enum class	SnippetRequirementFlags : uint32_t { kNone = 0x0 , kLocalCoords = 0x1 , kPriorStageOutput = 0x2 , kBlenderDstColor = 0x4 , kSurfaceColor = 0x8 , kGradientBuffer = 0x10 , kStoresData = 0x20 }

Functions
SK_API void	DawnNativeProcessEventsFunction (const wgpu::Instance &instance)

void	Precompile (Context *context, const PaintOptions &paintOptions, DrawTypeFlags drawTypes=kMostCommon)

DawnTextureInfo	DawnTextureSpecToTextureInfo (const DawnTextureSpec &dawnSpec, uint32_t sampleCount, Mipmapped mipmapped)

DawnTextureInfo	DawnTextureInfoFromWGPUTexture (WGPUTexture texture)

MtlTextureInfo	MtlTextureSpecToTextureInfo (const MtlTextureSpec &mtlSpec, uint32_t sampleCount, Mipmapped mipmapped)

VulkanTextureInfo	VulkanTextureSpecToTextureInfo (const VulkanTextureSpec &vkSpec, uint32_t sampleCount, Mipmapped mipmapped)

static SkColorType	color_type_fallback (SkColorType ct)

bool	SkShouldPostMessageToBus (const ClientMappedBufferManager::BufferFinishedMessage &, Context::ContextID potentialRecipient)

std::string_view	VelloStageName (vello_cpp::ShaderStage stage)

WorkgroupSize	VelloStageLocalSize (vello_cpp::ShaderStage stage)

skia_private::TArray< ComputeStep::WorkgroupBufferDesc >	VelloWorkgroupBuffers (vello_cpp::ShaderStage stage)

ComputeStep::NativeShaderSource	VelloNativeShaderSource (vello_cpp::ShaderStage stage, ComputeStep::NativeShaderFormat format)

	VELLO_COMPUTE_STEP (BackdropDyn)

	VELLO_COMPUTE_STEP (BboxClear)

	VELLO_COMPUTE_STEP (Binning)

	VELLO_COMPUTE_STEP (ClipLeaf)

	VELLO_COMPUTE_STEP (ClipReduce)

	VELLO_COMPUTE_STEP (Coarse)

	VELLO_COMPUTE_STEP (Flatten)

	VELLO_COMPUTE_STEP (DrawLeaf)

	VELLO_COMPUTE_STEP (DrawReduce)

	VELLO_COMPUTE_STEP (PathCount)

	VELLO_COMPUTE_STEP (PathCountSetup)

	VELLO_COMPUTE_STEP (PathTiling)

	VELLO_COMPUTE_STEP (PathTilingSetup)

	VELLO_COMPUTE_STEP (PathtagReduce)

	VELLO_COMPUTE_STEP (PathtagReduce2)

	VELLO_COMPUTE_STEP (PathtagScan1)

	VELLO_COMPUTE_STEP (PathtagScanLarge)

	VELLO_COMPUTE_STEP (PathtagScanSmall)

	VELLO_COMPUTE_STEP (TileAlloc)

std::tuple< UniquePaintParamsID, const UniformDataBlock , const TextureDataBlock >	ExtractPaintData (Recorder recorder, PipelineDataGatherer gatherer, PaintParamsKeyBuilder *builder, const Layout layout, const SkM44 &local2Dev, const PaintParams &p, const Geometry &geometry, sk_sp< TextureProxy > dstTexture, SkIPoint dstOffset, const SkColorInfo &targetColorInfo)

std::tuple< const UniformDataBlock , const TextureDataBlock >	ExtractRenderStepData (UniformDataCache uniformDataCache, TextureDataCache textureDataCache, PipelineDataGatherer gatherer, const Layout layout, const RenderStep step, const DrawParams &params)

DstReadRequirement	GetDstReadRequirement (const Caps *caps, std::optional< SkBlendMode > blendMode, Coverage coverage)

std::string	EmitPaintParamsUniforms (int bufferID, const Layout layout, SkSpan< const ShaderNode * > nodes, int numUniforms, int uniformsTotalBytes, bool *wrotePaintColor)

std::string	EmitRenderStepUniforms (int bufferID, const Layout layout, SkSpan< const Uniform > uniforms, int *renderStepUniformsTotalBytes)

std::string	EmitPaintParamsStorageBuffer (int bufferID, SkSpan< const ShaderNode * > nodes, int numUniforms, bool wrotePaintColor)

std::string	EmitRenderStepStorageBuffer (int bufferID, SkSpan< const Uniform > uniforms)

std::string	EmitUniformsFromStorageBuffer (const char bufferNamePrefix, const char ssboIndex, SkSpan< const Uniform > uniforms)

std::string	EmitStorageBufferAccess (const char bufferNamePrefix, const char ssboIndex, const char *uniformName)

std::string	EmitTexturesAndSamplers (const ResourceBindingRequirements &bindingReqs, SkSpan< const ShaderNode * > nodes, int *binding)

std::string	EmitSamplerLayout (const ResourceBindingRequirements &bindingReqs, int *binding)

std::string	EmitVaryings (const RenderStep step, const char direction, bool emitSsboIndicesVarying, bool emitLocalCoordsVarying)

VertSkSLInfo	BuildVertexSkSL (const ResourceBindingRequirements &bindingReqs, const RenderStep *step, bool useStorageBuffers, bool defineLocalCoordsVarying)

FragSkSLInfo	BuildFragmentSkSL (const Caps caps, const ShaderCodeDictionary dict, const RuntimeEffectDictionary rteDict, const RenderStep step, UniquePaintParamsID paintID, bool useStorageBuffers, skgpu::Swizzle writeSwizzle)

std::string	GetPipelineLabel (const ShaderCodeDictionary dict, const RenderPassDesc &renderPassDesc, const RenderStep renderStep, UniquePaintParamsID paintID)

std::string	BuildComputeSkSL (const Caps caps, const ComputeStep step)

	SK_MAKE_BITMASK_OPS (DawnErrorType)

bool	DawnFormatIsDepthOrStencil (wgpu::TextureFormat format)

bool	DawnFormatIsDepth (wgpu::TextureFormat format)

bool	DawnFormatIsStencil (wgpu::TextureFormat format)

wgpu::TextureFormat	DawnDepthStencilFlagsToFormat (SkEnumBitMask< DepthStencilFlags > mask)

static bool	check_shader_module (const DawnSharedContext sharedContext, wgpu::ShaderModule module, const char shaderText, ShaderErrorHandler errorHandler)

bool	DawnCompileWGSLShaderModule (const DawnSharedContext sharedContext, const char label, const std::string &wgsl, wgpu::ShaderModule module, ShaderErrorHandler errorHandler)

static wgpu::AddressMode	tile_mode_to_dawn_address_mode (SkTileMode tileMode)

size_t	DawnFormatBytesPerBlock (wgpu::TextureFormat format)

SkTextureCompressionType	DawnFormatToCompressionType (wgpu::TextureFormat format)

uint32_t	DawnFormatChannels (wgpu::TextureFormat format)

	SK_MAKE_BITMASK_OPS (PipelineStageFlags)

static uint32_t	next_id ()

static constexpr size_t	VertexAttribTypeSize (VertexAttribType type)

sk_sp< PrecompileShader >	MakePrecompileShader (sk_sp< SkRuntimeEffect > effect, SkSpan< const PrecompileChildOptions > childOptions)

sk_sp< PrecompileColorFilter >	MakePrecompileColorFilter (sk_sp< SkRuntimeEffect > effect, SkSpan< const PrecompileChildOptions > childOptions)

sk_sp< PrecompileBlender >	MakePrecompileBlender (sk_sp< SkRuntimeEffect > effect, SkSpan< const PrecompileChildOptions > childOptions)

static float	quantize (float deviceSpaceFloat)

static int	write_color_and_offset_bufdata (int numStops, const SkPMColor4f colors, const float offsets, const SkGradientBaseShader shader, PipelineDataGatherer gatherer)

static bool	can_do_yuv_tiling_in_hw (const Caps *caps, const YUVImageShaderBlock::ImageData &imgData)

void	AddBlendModeColorFilter (const KeyContext &keyContext, PaintParamsKeyBuilder builder, PipelineDataGatherer gatherer, SkBlendMode bm, const SkPMColor4f &srcColor)

static bool	skdata_matches (const SkData a, const SkData b)

static void	gather_runtime_effect_uniforms (const KeyContext &keyContext, const SkRuntimeEffect effect, SkSpan< const Uniform > graphiteUniforms, const SkData uniformData, PipelineDataGatherer *gatherer)

void	AddToKey (const KeyContext &keyContext, PaintParamsKeyBuilder builder, PipelineDataGatherer gatherer, const SkBlender *blender)

void	NotifyImagesInUse (Recorder recorder, DrawContext drawContext, const SkBlender *blender)

static SkPMColor4f	map_color (const SkColor4f &c, SkColorSpace src, SkColorSpace dst)

static void	add_to_key (const KeyContext &keyContext, PaintParamsKeyBuilder builder, PipelineDataGatherer gatherer, const SkBlendModeColorFilter *filter)

static void	add_to_key (const KeyContext &keyContext, PaintParamsKeyBuilder builder, PipelineDataGatherer gatherer, const SkColorSpaceXformColorFilter *filter)

static void	add_to_key (const KeyContext &keyContext, PaintParamsKeyBuilder keyBuilder, PipelineDataGatherer gatherer, const SkComposeColorFilter *filter)

static void	add_to_key (const KeyContext &keyContext, PaintParamsKeyBuilder builder, PipelineDataGatherer gatherer, const SkGaussianColorFilter *)

static void	add_to_key (const KeyContext &keyContext, PaintParamsKeyBuilder builder, PipelineDataGatherer gatherer, const SkMatrixColorFilter *filter)

static void	add_to_key (const KeyContext &keyContext, PaintParamsKeyBuilder builder, PipelineDataGatherer gatherer, const SkRuntimeColorFilter *filter)

static void	add_to_key (const KeyContext &keyContext, PaintParamsKeyBuilder builder, PipelineDataGatherer gatherer, const SkTableColorFilter *filter)

static void	add_to_key (const KeyContext &keyContext, PaintParamsKeyBuilder builder, PipelineDataGatherer gatherer, const SkWorkingFormatColorFilter *filter)

void	AddToKey (const KeyContext &keyContext, PaintParamsKeyBuilder builder, PipelineDataGatherer gatherer, const SkColorFilter *filter)

void	NotifyImagesInUse (Recorder recorder, DrawContext drawContext, const SkColorFilter *filter)

static void	add_to_key (const KeyContext &keyContext, PaintParamsKeyBuilder builder, PipelineDataGatherer gatherer, const SkBlendShader *shader)

static void	notify_in_use (Recorder recorder, DrawContext drawContext, const SkBlendShader *shader)

static void	add_to_key (const KeyContext &keyContext, PaintParamsKeyBuilder builder, PipelineDataGatherer gatherer, const SkCTMShader *shader)

static void	notify_in_use (Recorder recorder, DrawContext drawContext, const SkCTMShader *shader)

static void	add_to_key (const KeyContext &keyContext, PaintParamsKeyBuilder builder, PipelineDataGatherer gatherer, const SkColorShader *shader)

static void	notify_in_use (Recorder , DrawContext , const SkColorShader *)

static void	add_to_key (const KeyContext &keyContext, PaintParamsKeyBuilder builder, PipelineDataGatherer gatherer, const SkColor4Shader *shader)

static void	notify_in_use (Recorder , DrawContext , const SkColor4Shader *)

static void	add_to_key (const KeyContext &keyContext, PaintParamsKeyBuilder builder, PipelineDataGatherer gatherer, const SkColorFilterShader *shader)

static void	notify_in_use (Recorder recorder, DrawContext drawContext, const SkColorFilterShader *shader)

static void	add_to_key (const KeyContext &keyContext, PaintParamsKeyBuilder builder, PipelineDataGatherer gatherer, const SkCoordClampShader *shader)

static void	notify_in_use (Recorder recorder, DrawContext drawContext, const SkCoordClampShader *shader)

static void	add_to_key (const KeyContext &keyContext, PaintParamsKeyBuilder builder, PipelineDataGatherer gatherer, const SkEmptyShader *)

static void	notify_in_use (Recorder , DrawContext , const SkEmptyShader *)

static void	add_yuv_image_to_key (const KeyContext &keyContext, PaintParamsKeyBuilder builder, PipelineDataGatherer gatherer, const SkImageShader *origShader, sk_sp< const SkImage > imageToDraw, SkSamplingOptions sampling)

static skgpu::graphite::ReadSwizzle	swizzle_class_to_read_enum (const skgpu::Swizzle &swizzle)

static void	add_to_key (const KeyContext &keyContext, PaintParamsKeyBuilder builder, PipelineDataGatherer gatherer, const SkImageShader *shader)

static void	notify_in_use (Recorder recorder, DrawContext drawContext, const SkImageShader *shader)

static void	add_to_key (const KeyContext &keyContext, PaintParamsKeyBuilder builder, PipelineDataGatherer gatherer, const SkLocalMatrixShader *shader)

static void	notify_in_use (Recorder recorder, DrawContext drawContext, const SkLocalMatrixShader *shader)

static void	add_to_key (const KeyContext &keyContext, PaintParamsKeyBuilder builder, PipelineDataGatherer gatherer, const SkPerlinNoiseShader *shader)

static void	notify_in_use (Recorder , DrawContext , const SkPerlinNoiseShader *)

static void	add_to_key (const KeyContext &keyContext, PaintParamsKeyBuilder builder, PipelineDataGatherer gatherer, const SkPictureShader *shader)

static void	notify_in_use (Recorder , DrawContext , const SkPictureShader *)

static void	add_to_key (const KeyContext &keyContext, PaintParamsKeyBuilder builder, PipelineDataGatherer gatherer, const SkRuntimeShader *shader)

static void	notify_in_use (Recorder recorder, DrawContext drawContext, const SkRuntimeShader *shader)

static void	add_to_key (const KeyContext &keyContext, PaintParamsKeyBuilder builder, PipelineDataGatherer gatherer, const SkTransformShader *shader)

static void	notify_in_use (Recorder , DrawContext , const SkTransformShader *)

static void	add_to_key (const KeyContext &keyContext, PaintParamsKeyBuilder builder, PipelineDataGatherer gatherer, const SkTriColorShader *shader)

static void	notify_in_use (Recorder , DrawContext , const SkTriColorShader *)

static void	add_to_key (const KeyContext &keyContext, PaintParamsKeyBuilder builder, PipelineDataGatherer gatherer, const SkWorkingColorSpaceShader *shader)

static void	notify_in_use (Recorder recorder, DrawContext drawContext, const SkWorkingColorSpaceShader *shader)

static SkBitmap	create_color_and_offset_bitmap (int numStops, const SkPMColor4f colors, const float offsets)

static void	make_interpolated_to_dst (const KeyContext &keyContext, PaintParamsKeyBuilder builder, PipelineDataGatherer gatherer, const GradientShaderBlocks::GradientData &gradData, const SkGradientShader::Interpolation &interp, SkColorSpace *intermediateCS)

static void	add_gradient_to_key (const KeyContext &keyContext, PaintParamsKeyBuilder builder, PipelineDataGatherer gatherer, const SkGradientBaseShader *shader, SkPoint point0, SkPoint point1, float radius0, float radius1, float bias, float scale)

static void	add_gradient_to_key (const KeyContext &keyContext, PaintParamsKeyBuilder builder, PipelineDataGatherer gatherer, const SkConicalGradient *shader)

static void	add_gradient_to_key (const KeyContext &keyContext, PaintParamsKeyBuilder builder, PipelineDataGatherer gatherer, const SkLinearGradient *shader)

static void	add_gradient_to_key (const KeyContext &keyContext, PaintParamsKeyBuilder builder, PipelineDataGatherer gatherer, const SkRadialGradient *shader)

static void	add_gradient_to_key (const KeyContext &keyContext, PaintParamsKeyBuilder builder, PipelineDataGatherer gatherer, const SkSweepGradient *shader)

static void	add_to_key (const KeyContext &keyContext, PaintParamsKeyBuilder builder, PipelineDataGatherer gatherer, const SkGradientBaseShader *shader)

static void	notify_in_use (Recorder , DrawContext , const SkGradientBaseShader *)

void	AddToKey (const KeyContext &keyContext, PaintParamsKeyBuilder builder, PipelineDataGatherer gatherer, const SkShader *shader)

void	NotifyImagesInUse (Recorder recorder, DrawContext drawContext, const SkShader *shader)

static MTLPrimitiveType	graphite_to_mtl_primitive (PrimitiveType primitiveType)

static bool	check_max_blit_width (int widthInPixels)

sk_cfp< id< MTLLibrary > >	MtlCompileShaderLibrary (const MtlSharedContext sharedContext, std::string_view label, std::string_view msl, ShaderErrorHandler errorHandler)

size_t	MtlFormatBytesPerBlock (MtlPixelFormat format)

SkTextureCompressionType	MtlFormatToCompressionType (MtlPixelFormat format)

static MTLSamplerAddressMode	tile_mode_to_mtl_sampler_address (SkTileMode tileMode, const Caps &caps)

void	Blend (const KeyContext &keyContext, PaintParamsKeyBuilder keyBuilder, PipelineDataGatherer gatherer, AddToKeyFn addBlendToKey, AddToKeyFn addSrcToKey, AddToKeyFn addDstToKey)

void	Compose (const KeyContext &keyContext, PaintParamsKeyBuilder keyBuilder, PipelineDataGatherer gatherer, AddToKeyFn addInnerToKey, AddToKeyFn addOuterToKey)

void	AddKnownModeBlend (const KeyContext &keyContext, PaintParamsKeyBuilder builder, PipelineDataGatherer gatherer, SkBlendMode bm)

void	AddModeBlend (const KeyContext &keyContext, PaintParamsKeyBuilder builder, PipelineDataGatherer gatherer, SkBlendMode bm)

void	AddDstReadBlock (const KeyContext &keyContext, PaintParamsKeyBuilder builder, PipelineDataGatherer gatherer, DstReadRequirement dstReadReq)

void	AddDitherBlock (const KeyContext &keyContext, PaintParamsKeyBuilder builder, PipelineDataGatherer gatherer, SkColorType ct)

static int	key_to_string (SkString str, const ShaderCodeDictionary dict, SkSpan< const uint32_t > keyData, int currentIndex, bool includeData)

void	PrecompileCombinations (Context *context, const PaintOptions &options, const KeyContext &keyContext, DrawTypeFlags drawTypes, bool withPrimitiveBlender, Coverage coverage)

bool	Precompile (Context context, RuntimeEffectDictionary rteDict, const GraphicsPipelineDesc &pipelineDesc, const RenderPassDesc &renderPassDesc)

skgpu::UniqueKey	GeneratePathMaskKey (const Shape &shape, const Transform &transform, const SkStrokeRec &strokeRec, skvx::half2 maskSize)

static uint32_t	next_id ()

static skvx::float4	load_x_radii (const SkRRect &rrect)

static skvx::float4	load_y_radii (const SkRRect &rrect)

static bool	opposite_insets_intersect (const SkRRect &rrect, float strokeRadius, float aaRadius)

static bool	opposite_insets_intersect (const Rect &rect, float strokeRadius, float aaRadius)

static bool	opposite_insets_intersect (const Geometry &geometry, float strokeRadius, float aaRadius)

static bool	is_clockwise (const EdgeAAQuad &quad)

static skvx::float2	quad_center (const EdgeAAQuad &quad)

static void	write_index_buffer (VertexWriter writer)

static void	write_vertex_buffer (VertexWriter writer)

static skvx::float2	get_device_translation (const SkM44 &localToDevice)

static bool	is_clockwise (const EdgeAAQuad &quad)

static void	write_index_buffer (VertexWriter writer)

static void	write_vertex_buffer (VertexWriter writer)

static uint32_t	next_id ()

static std::string	to_str (const SharedContext *ctx, const GraphicsPipelineDesc &gpDesc, const RenderPassDesc &rpDesc)

static constexpr const char *	LayoutString (Layout layout)

void	append_color_output (std::string mainBody, BlendFormula::OutputType outputType, const char outColor, const char *inColor)

static SkSLType	uniform_type_to_sksl_type (const SkRuntimeEffect::Uniform &u)

void	Flush (sk_sp< SkSurface > surface)

void	Flush (SkSurface *surface)

std::pair< size_t, size_t >	compute_combined_buffer_size (const Caps caps, int mipLevelCount, size_t bytesPerBlock, const SkISize &baseDimensions, SkTextureCompressionType compressionType, TArray< std::pair< size_t, size_t > > levelOffsetsAndRowBytes)

template<typename INT_TYPE >
static void	expand_bits (INT_TYPE dst, const uint8_t src, int width, int height, int dstRowBytes, int srcRowBytes)

static void	get_packed_glyph_image (const SkGlyph &glyph, int dstRB, MaskFormat expectedMaskFormat, void *dst)

std::tuple< TextureProxyView, SkColorType >	MakeBitmapProxyView (Recorder *recorder, const SkBitmap &bitmap, sk_sp< SkMipmap > mipmapsIn, Mipmapped mipmapped, Budgeted budgeted, std::string_view label)

sk_sp< TextureProxy >	MakePromiseImageLazyProxy (const Caps *caps, SkISize dimensions, TextureInfo textureInfo, Volatile isVolatile, sk_sp< RefCntedCallback > releaseHelper, GraphitePromiseTextureFulfillProc fulfillProc, GraphitePromiseTextureFulfillContext fulfillContext, GraphitePromiseTextureReleaseProc textureReleaseProc, std::string_view label)

sk_sp< SkImage >	MakeFromBitmap (Recorder *recorder, const SkColorInfo &colorInfo, const SkBitmap &bitmap, sk_sp< SkMipmap > mipmaps, Budgeted budgeted, SkImage::RequiredProperties requiredProps, std::string_view label)

size_t	ComputeSize (SkISize dimensions, const TextureInfo &info)

sk_sp< Image >	CopyAsDraw (Recorder recorder, const SkImage image, const SkIRect &subset, const SkColorInfo &dstColorInfo, Budgeted budgeted, Mipmapped mipmapped, SkBackingFit backingFit, std::string_view label)

sk_sp< SkImage >	RescaleImage (Recorder recorder, const SkImage srcImage, SkIRect srcIRect, const SkImageInfo &dstInfo, SkImage::RescaleGamma rescaleGamma, SkImage::RescaleMode rescaleMode)

bool	GenerateMipmaps (Recorder *recorder, sk_sp< TextureProxy > texture, const SkColorInfo &colorInfo)

std::pair< sk_sp< SkImage >, SkSamplingOptions >	GetGraphiteBacked (Recorder recorder, const SkImage imageIn, SkSamplingOptions sampling)

TextureProxyView	AsView (const SkImage *image)

SkColorType	ComputeShaderCoverageMaskTargetFormat (const Caps *caps)

sk_sp< TextureProxy >	MakePromiseImageLazyProxy (const Caps *, SkISize dimensions, TextureInfo, Volatile, sk_sp< skgpu::RefCntedCallback > releaseHelper, SkImages::GraphitePromiseTextureFulfillProc, SkImages::GraphitePromiseTextureFulfillContext, SkImages::GraphitePromiseTextureReleaseProc, std::string_view label)

TextureProxyView	AsView (sk_sp< SkImage > image)

static std::pair< SkSLType, int >	adjust_for_matrix_type (SkSLType type, int count)

static bool	submit_to_queue (const VulkanSharedContext sharedContext, VkQueue queue, VkFence fence, uint32_t waitCount, const VkSemaphore waitSemaphores, const VkPipelineStageFlags waitStages, uint32_t commandBufferCount, const VkCommandBuffer commandBuffers, uint32_t signalCount, const VkSemaphore *signalSemaphores, Protected protectedContext)

static VkFormat	attrib_type_to_vkformat (VertexAttribType type)

static void	setup_vertex_input_state (const SkSpan< const Attribute > &vertexAttrs, const SkSpan< const Attribute > &instanceAttrs, VkPipelineVertexInputStateCreateInfo vertexInputInfo, skia_private::STArray< 2, VkVertexInputBindingDescription, true > bindingDescs, skia_private::STArray< 16, VkVertexInputAttributeDescription > *attributeDescs)

static VkPrimitiveTopology	primitive_type_to_vk_topology (PrimitiveType primitiveType)

static void	setup_input_assembly_state (PrimitiveType primitiveType, VkPipelineInputAssemblyStateCreateInfo *inputAssemblyInfo)

static VkStencilOp	stencil_op_to_vk_stencil_op (StencilOp op)

static VkCompareOp	compare_op_to_vk_compare_op (CompareOp op)

static void	setup_stencil_op_state (VkStencilOpState *opState, const DepthStencilSettings::Face &face, uint32_t referenceValue)

static void	setup_depth_stencil_state (const DepthStencilSettings &stencilSettings, VkPipelineDepthStencilStateCreateInfo *stencilInfo)

static void	setup_viewport_scissor_state (VkPipelineViewportStateCreateInfo *viewportInfo)

static void	setup_multisample_state (int numSamples, VkPipelineMultisampleStateCreateInfo *multisampleInfo)

static VkBlendFactor	blend_coeff_to_vk_blend (skgpu::BlendCoeff coeff)

static VkBlendOp	blend_equation_to_vk_blend_op (skgpu::BlendEquation equation)

static void	setup_color_blend_state (const skgpu::BlendInfo &blendInfo, VkPipelineColorBlendStateCreateInfo colorBlendInfo, VkPipelineColorBlendAttachmentState attachmentState)

static void	setup_raster_state (bool isWireframe, VkPipelineRasterizationStateCreateInfo *rasterInfo)

static void	setup_shader_stage_info (VkShaderStageFlagBits stage, VkShaderModule shaderModule, VkPipelineShaderStageCreateInfo *shaderStageInfo)

static VkDescriptorSetLayout	descriptor_data_to_layout (const VulkanSharedContext *sharedContext, const SkSpan< DescriptorData > &descriptorData)

static void	destroy_desc_set_layouts (const VulkanSharedContext *sharedContext, skia_private::TArray< VkDescriptorSetLayout > &setLayouts)

static VkPipelineLayout	setup_pipeline_layout (const VulkanSharedContext *sharedContext, bool usesIntrinsicConstantUbo, bool hasStepUniforms, int numPaintUniforms, int numTextureSamplers, int numInputAttachments)

static void	destroy_shader_modules (const VulkanSharedContext *sharedContext, VkShaderModule vsModule, VkShaderModule fsModule)

static void	setup_dynamic_state (VkPipelineDynamicStateCreateInfo dynamicInfo, VkDynamicState dynamicStates)

VkShaderModule	createVulkanShaderModule (const VulkanSharedContext *context, const std::string &spirv, VkShaderStageFlagBits stage)

void	DescriptorDataToVkDescSetLayout (const VulkanSharedContext ctxt, const SkSpan< DescriptorData > &requestedDescriptors, VkDescriptorSetLayout outLayout)

VkDescriptorType	DsTypeEnumToVkDs (DescriptorType type)

bool	vkFormatIsSupported (VkFormat format)

VkShaderStageFlags	PipelineStageFlagsToVkShaderStageFlags (SkEnumBitMask< PipelineStageFlags > stageFlags)

static VkSamplerAddressMode	tile_mode_to_vk_sampler_address (SkTileMode tileMode)

VkImageAspectFlags	vk_format_to_aspect_flags (VkFormat format)

	DEF_TEST (BoundsManager, r)

	DEF_GRAPHITE_TEST_FOR_RENDERING_CONTEXTS (BufferManagerGpuOnlyBufferTest, reporter, context, CtsEnforcement::kNextRelease)

	DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS (DeviceTestVertexTransparency, reporter, context, CtsEnforcement::kNextRelease)

	DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS (DrawPassTestFailedDstCopy, reporter, context, CtsEnforcement::kNextRelease)

static sk_sp< SkData >	create_image_data (const SkImageInfo &info)

static skgpu::graphite::TextureProxy *	top_device_graphite_target_proxy (SkCanvas *canvas)

	DEF_CONDITIONAL_GRAPHITE_TEST_FOR_ALL_CONTEXTS (GraphiteBudgetedResourcesTest, reporter, context, testContext, true, CtsEnforcement::kNextRelease)

	DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS (GraphitePurgeAsNeededResourcesTest, reporter, context, CtsEnforcement::kNextRelease)

	DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS (GraphiteZeroSizedResourcesTest, reporter, context, CtsEnforcement::kNextRelease)

	DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS (GraphitePurgeNotUsedSinceResourcesTest, reporter, context, CtsEnforcement::kNextRelease)

	DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS (GraphitePurgeNotUsedOverBudgetTest, reporter, context, CtsEnforcement::kNextRelease)

	DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS (GraphitePurgeResourcesTest, reporter, context, CtsEnforcement::kNextRelease)

	DEF_GRAPHITE_TEST_FOR_RENDERING_CONTEXTS (ImageOriginTest_drawImage_Graphite, reporter, context, CtsEnforcement::kNextRelease)

	DEF_GRAPHITE_TEST_FOR_RENDERING_CONTEXTS (ImageOriginTest_imageShader_Graphite, reporter, context, CtsEnforcement::kNextRelease)

	DEF_GRAPHITE_TEST_FOR_RENDERING_CONTEXTS (ImageShaderTest, reporter, context, CtsEnforcement::kNextRelease)

	DEF_GRAPHITE_TEST (skgpu_IntersectionTree, reporter, CtsEnforcement::kNextRelease)

	DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS (MultisampleRetainTest, reporter, context, CtsEnforcement::kNever)

	DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS (ProxyCacheTest1, r, context, CtsEnforcement::kNextRelease)

	DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS (ProxyCacheTest2, r, context, CtsEnforcement::kNextRelease)

	DEF_CONDITIONAL_GRAPHITE_TEST_FOR_ALL_CONTEXTS (ProxyCacheTest4, r, context, testContext, true, CtsEnforcement::kNextRelease)

	DEF_CONDITIONAL_GRAPHITE_TEST_FOR_ALL_CONTEXTS (ProxyCacheTest5, r, context, testContext, true, CtsEnforcement::kNextRelease)

	DEF_CONDITIONAL_GRAPHITE_TEST_FOR_ALL_CONTEXTS (ProxyCacheTest6, r, context, testContext, true, CtsEnforcement::kNextRelease)

	DEF_CONDITIONAL_GRAPHITE_TEST_FOR_ALL_CONTEXTS (ProxyCacheTest7, r, context, testContext, true, CtsEnforcement::kNextRelease)

	DEF_CONDITIONAL_GRAPHITE_TEST_FOR_ALL_CONTEXTS (ProxyCacheTest8, r, context, testContext, true, CtsEnforcement::kNextRelease)

	DEF_CONDITIONAL_GRAPHITE_TEST_FOR_ALL_CONTEXTS (ProxyCacheTest9, r, context, testContext, true, CtsEnforcement::kNextRelease)

static sk_sp< TextureProxy >	find_or_create_by_key (Recorder recorder, int id, bool regenerated)

	DEF_CONDITIONAL_GRAPHITE_TEST_FOR_ALL_CONTEXTS (ProxyCacheTest10, r, context, testContext, true, CtsEnforcement::kNextRelease)

void	run_test (skiatest::Reporter reporter, Context context, SkISize surfaceSize, SkISize recordingSize, SkISize replayOffset, DrawCallback draw, const std::vector< Expectation > &expectations)

	DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS (RecordingSurfacesTestClear, reporter, context, CtsEnforcement::kNextRelease)

	DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS (RecordingSurfacesTestWritePixels, reporter, context, CtsEnforcement::kNextRelease)

	DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS (RecordingSurfacesTestWritePixelsOffscreen, reporter, context, CtsEnforcement::kNextRelease)

	DEF_GRAPHITE_TEST (skgpu_Rect, reporter, CtsEnforcement::kNextRelease)

	DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS (GraphiteTextureProxyTest, reporter, context, CtsEnforcement::kNextRelease)

	DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS (GraphiteTextureTooLargeTest, reporter, context, CtsEnforcement::kNextRelease)

	DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS (GraphiteLazyTextureInvalidDimensions, reporter, context, CtsEnforcement::kNextRelease)

	DEF_GRAPHITE_TEST_FOR_RENDERING_CONTEXTS (UploadBufferManagerTest, reporter, context, CtsEnforcement::kNextRelease)

skgpu::BackendApi	ContextTypeBackend (skgpu::ContextType type)

Variables
static constexpr int	kBuiltInCodeSnippetIDCount = static_cast<int>(BuiltInCodeSnippetID::kLast)+1

static constexpr int	kFixedFunctionBlendModeIDOffset

static constexpr int	kElementStackIncrement = 8

static constexpr int	kSaveStackIncrement = 8

static constexpr ComputeStep::ResourceDesc	kFineAreaResources []

static constexpr ComputeStep::ResourceDesc	kFineMsaaResources []

constexpr int	kVelloSlot_ConfigUniform = 0

constexpr int	kVelloSlot_Scene = 1

constexpr int	kVelloSlot_TagMonoid = 2

constexpr int	kVelloSlot_PathtagReduceOutput = 3

constexpr int	kVelloSlot_LargePathtagReduceFirstPassOutput = kVelloSlot_PathtagReduceOutput

constexpr int	kVelloSlot_LargePathtagReduceSecondPassOutput = 4

constexpr int	kVelloSlot_LargePathtagScanFirstPassOutput = 5

constexpr int	kVelloSlot_PathBBoxes = 6

constexpr int	kVelloSlot_Lines = 7

constexpr int	kVelloSlot_DrawReduceOutput = 8

constexpr int	kVelloSlot_DrawMonoid = 9

constexpr int	kVelloSlot_InfoBinData = 10

constexpr int	kVelloSlot_ClipInput = 11

constexpr int	kVelloSlot_ClipBicyclic = 12

constexpr int	kVelloSlot_ClipElement = 13

constexpr int	kVelloSlot_ClipBBoxes = 14

constexpr int	kVelloSlot_DrawBBoxes = 15

constexpr int	kVelloSlot_BumpAlloc = 16

constexpr int	kVelloSlot_BinHeader = 17

constexpr int	kVelloSlot_Path = 18

constexpr int	kVelloSlot_Tile = 19

constexpr int	kVelloSlot_SegmentCounts = 20

constexpr int	kVelloSlot_Segments = 21

constexpr int	kVelloSlot_PTCL = 22

constexpr int	kVelloSlot_OutputImage = 23

constexpr int	kVelloSlot_GradientImage = 24

constexpr int	kVelloSlot_ImageAtlas = 25

constexpr int	kVelloSlot_IndirectCount = 26

constexpr int	kVelloSlot_MaskLUT = 27

constexpr int	kMaxComputeDataFlowSlots = 28

constexpr size_t	kIndirectDispatchArgumentSize = sizeof(IndirectDispatchArgs)

static constexpr int	kDescriptorTypeCount = (int)(DescriptorType::kLast) + 1

static constexpr int	kGridCellSize = 16

static constexpr int	kMaxBruteForceN = 64

static constexpr int	kMaxGridSize = 32

static const constexpr bool	kDumpAtlasData = false

static constexpr auto	kPlotRecentlyUsedCount = 32

static constexpr auto	kAtlasRecentlyUsedCount = 128

static const int	kVertexAttribTypeCount = (int)(VertexAttribType::kLast) + 1

static constexpr int	kCompareOpCount = 1 + (int)CompareOp::kNotEqual

static constexpr int	kStencilOpCount = 1 + (int)StencilOp::kDecClamp

static constexpr MTLPixelFormat	kMtlFormats []

static const skgpu::UniqueKey::Domain	kGraphicsPipelineDomain = UniqueKey::GenerateDomain()

static const int	kGraphicsPipelineKeyData32Count = 5

static constexpr int	kDefaultOutstandingAllocCnt = 8

static constexpr uint32_t	kDefaultAtlasDim = 4096

static constexpr uint32_t	kSmallPathPlotWidth = 512

static constexpr uint32_t	kSmallPathPlotHeight = 256

static constexpr float	kSolidInterior = 1.f

static constexpr float	kStrokeInterior = 0.f

static constexpr float	kFilledStrokeInterior = -1.f

static constexpr float	kComplexAAInsets = -1.f

static constexpr int	kCornerVertexCount = 9

static constexpr int	kVertexCount = 4 * kCornerVertexCount

static constexpr int	kIndexCount = 69

static constexpr DepthStencilSettings	kDirectDepthGreaterPass

static constexpr DepthStencilSettings	kDirectDepthGEqualPass

constexpr DepthStencilSettings::Face	kIncrementCW

constexpr DepthStencilSettings::Face	kDecrementCCW

constexpr DepthStencilSettings::Face	kToggle

constexpr DepthStencilSettings	kWindingStencilPass

constexpr DepthStencilSettings	kEvenOddStencilPass

constexpr DepthStencilSettings::Face	kPassNonZero

constexpr DepthStencilSettings::Face	kPassZero

constexpr DepthStencilSettings	kRegularCoverPass

constexpr DepthStencilSettings	kInverseCoverPass

static constexpr int	kCornerVertexCount = 4

static constexpr int	kVertexCount = 4 * kCornerVertexCount

static constexpr int	kIndexCount = 29

static constexpr int	kLoadOpCount = (int)(LoadOp::kLast) + 1

static constexpr int	kStoreOpCount = (int)(StoreOp::kLast) + 1

static const int	kBufferTypeCount = static_cast<int>(BufferType::kLast) + 1

static constexpr int	kNoChildren = 0

static constexpr char	kRuntimeShaderName [] = "RuntimeEffect"

static constexpr Uniform	kRuntimeEffectColorSpaceTransformUniforms []

static constexpr size_t	kReusedBufferSize = 64 << 10

static constexpr VkFormat	kVkFormats []

static constexpr VkFormat	kDepthStencilVkFormats []

static const VkAttachmentStoreOp	vkStoreOp []

static const VkAttachmentLoadOp	vkLoadOp []

constexpr int	kMaxNumberOfCachedBufferDescSets = 1024

Typedef Documentation

◆ AAFlags

typedef EdgeAAQuad::Flags skgpu::graphite::AAFlags

Definition at line 137 of file AnalyticRRectRenderStep.cpp.

◆ AddToKeyFn

using skgpu::graphite::AddToKeyFn = typedef std::function<void()>

Definition at line 97 of file PaintParams.h.

◆ BindingIndex

using skgpu::graphite::BindingIndex = typedef uint32_t

Definition at line 29 of file DispatchGroup.h.

◆ Builder

using skgpu::graphite::Builder = typedef DispatchGroup::Builder

Definition at line 95 of file DispatchGroup.cpp.

◆ CompressedPaintersOrder

using skgpu::graphite::CompressedPaintersOrder = typedef MonotonicValue<CompressedPaintersOrderSequence>

Definition at line 58 of file DrawOrder.h.

◆ DawnTickFunction

using skgpu::graphite::DawnTickFunction = typedef void(const wgpu::Instance& device)

WebGPU needs to allow the main thread loop to run to detect GPU progress. Dawn native has a function wgpu::Instance::ProcessEvents, not (currently) present in WebGPU, that can be used to detect GPU progress.

When compiling using Emscripten/WASM the -s ASYNCIFY option can be used to yield. E.g.:

EM_ASYNC_JS(void, asyncSleep, (), { await new Promise((resolve, _) = > { setTimeout(resolve, 0); }) });

WebGPUTickFunction(wgpu::Device&) { asyncSleep(); }

If no DawnTickFunction is provided then the graphite::Context will be "non-yielding". This implies the following restrictions on the Context:

1) SyncToCpu::kYes is disallowed as a parameter to Context::submit. 2) The client must guarantee that GPU work has completed before destroying Context as Context cannot await the work completion in its destructor. Context reports whether it is awaiting GPU work completion via Context::hasUnfinishedGpuWork().

Using a non-yielding Context makes it possible to build and run Graphite/Dawn on WebGPU without -s ASYNCIFY.

Definition at line 42 of file DawnBackendContext.h.

◆ DisjointStencilIndex

using skgpu::graphite::DisjointStencilIndex = typedef MonotonicValue<DisjointStencilIndexSequence>

Definition at line 75 of file DrawOrder.h.

◆ DispatchResource

using skgpu::graphite::DispatchResource = typedef std::variant<BufferView, TextureIndex, SamplerIndex>

Definition at line 38 of file DispatchGroup.h.

◆ DispatchResourceOptional

using skgpu::graphite::DispatchResourceOptional = typedef std::variant<std::monostate, BufferView, TextureIndex, SamplerIndex>

Definition at line 39 of file DispatchGroup.h.

◆ DrawCallback

using skgpu::graphite::DrawCallback = typedef std::function<void(SkCanvas*)>

Definition at line 22 of file RecordingSurfacesTest.cpp.

◆ GpuFinishedContext

using skgpu::graphite::GpuFinishedContext = typedef void*

Definition at line 29 of file GraphiteTypes.h.

◆ GpuFinishedProc

using skgpu::graphite::GpuFinishedProc = typedef void (*)(GpuFinishedContext finishedContext, CallbackResult)

Definition at line 30 of file GraphiteTypes.h.

◆ MtlPixelFormat

using skgpu::graphite::MtlPixelFormat = typedef unsigned int

Declares typedefs for Metal types used in Graphite cpp code

Definition at line 35 of file MtlGraphiteTypes.h.

◆ MtlStorageMode

using skgpu::graphite::MtlStorageMode = typedef unsigned int

Definition at line 37 of file MtlGraphiteTypes.h.

◆ MtlTextureUsage

using skgpu::graphite::MtlTextureUsage = typedef unsigned int

Definition at line 36 of file MtlGraphiteTypes.h.

◆ PaintersDepth

using skgpu::graphite::PaintersDepth = typedef MonotonicValue<PaintersDepthSequence>

Definition at line 86 of file DrawOrder.h.

◆ PrecompileChildOptions

using skgpu::graphite::PrecompileChildOptions = typedef SkSpan<const PrecompileChildPtr>

Definition at line 110 of file FactoryFunctions.h.

◆ ResourceType

using skgpu::graphite::ResourceType = typedef uint32_t

Uniquely identifies the type of resource that is cached with a GraphiteResourceKey.

Definition at line 134 of file ResourceTypes.h.

◆ Status

using skgpu::graphite::Status = typedef Task::Status

Definition at line 15 of file TaskList.cpp.

◆ TextureDataCache

typedef PipelineDataCache< TextureDataBlock > skgpu::graphite::TextureDataCache

Definition at line 61 of file Recorder.h.

◆ UniformDataCache

typedef PipelineDataCache< UniformDataBlock > skgpu::graphite::UniformDataCache

Definition at line 60 of file Recorder.h.

Enumeration Type Documentation

◆ AccessPattern

enum class skgpu::graphite::AccessPattern : int

strong

Indicates the intended access pattern over resource memory. This is used to select the most efficient memory type during resource creation based on the capabilities of the platform.

This is only a hint and the actual memory type will be determined based on the resource type and backend capabilities.

Enumerator
kGpuOnly
kHostVisible

Definition at line 101 of file ResourceTypes.h.

                         : int {
    // GPU-only memory does not need to support reads/writes from the CPU. GPU-private memory will
    // be preferred if the backend supports an efficient private memory type.
    kGpuOnly,
 
    // The resource needs to be CPU visible, e.g. for read-back or as a copy/upload source.
    kHostVisible,
};

◆ BufferType

enum class skgpu::graphite::BufferType : int

strong

What a GPU buffer will be used for

Enumerator
kVertex
kIndex
kXferCpuToGpu
kXferGpuToCpu
kUniform
kStorage
kIndirect
kVertexStorage
kIndexStorage
kLast

Definition at line 57 of file ResourceTypes.h.

                      : int {
    kVertex,
    kIndex,
    kXferCpuToGpu,
    kXferGpuToCpu,
    kUniform,
    kStorage,
 
    // GPU-only buffer types
    kIndirect,
    kVertexStorage,
    kIndexStorage,
 
    kLast = kIndexStorage,
};

◆ BuiltInCodeSnippetID

enum class skgpu::graphite::BuiltInCodeSnippetID : int32_t

strong

Enumerator
kError
kPriorOutput
kSolidColorShader
kRGBPaintColor
kAlphaOnlyPaintColor
kLinearGradientShader4
kLinearGradientShader8
kLinearGradientShaderTexture
kLinearGradientShaderBuffer
kRadialGradientShader4
kRadialGradientShader8
kRadialGradientShaderTexture
kRadialGradientShaderBuffer
kSweepGradientShader4
kSweepGradientShader8
kSweepGradientShaderTexture
kSweepGradientShaderBuffer
kConicalGradientShader4
kConicalGradientShader8
kConicalGradientShaderTexture
kConicalGradientShaderBuffer
kLocalMatrixShader
kImageShader
kCubicImageShader
kHWImageShader
kYUVImageShader
kCubicYUVImageShader
kHWYUVImageShader
kCoordClampShader
kDitherShader
kPerlinNoiseShader
kRuntimeShader
kMatrixColorFilter
kTableColorFilter
kGaussianColorFilter
kColorSpaceXformColorFilter
kBlendShader
kBlendModeBlender
kCoeffBlender
kPrimitiveColor
kDstReadSample
kDstReadFetch
kClipShader
kCompose
kFixedFunctionClearBlendMode
kFixedFunctionSrcBlendMode
kFixedFunctionDstBlendMode
kFixedFunctionSrcOverBlendMode
kFixedFunctionDstOverBlendMode
kFixedFunctionSrcInBlendMode
kFixedFunctionDstInBlendMode
kFixedFunctionSrcOutBlendMode
kFixedFunctionDstOutBlendMode
kFixedFunctionSrcATopBlendMode
kFixedFunctionDstATopBlendMode
kFixedFunctionXorBlendMode
kFixedFunctionPlusBlendMode
kFixedFunctionModulateBlendMode
kFixedFunctionScreenBlendMode
kFirstFixedFunctionBlendMode
kLast

Definition at line 15 of file BuiltInCodeSnippetID.h.

                                : int32_t {
    // This isn't just a signal for a failure during paintparams key creation. It also actually
    // implements the default behavior for an erroneous draw. Currently it just draws solid
    // magenta.
    kError,
 
    // Snippet that passes through prior stage output
    kPriorOutput,
 
    // SkShader code snippets
    kSolidColorShader,
    kRGBPaintColor,
    kAlphaOnlyPaintColor,
    kLinearGradientShader4,
    kLinearGradientShader8,
    kLinearGradientShaderTexture,
    kLinearGradientShaderBuffer,
    kRadialGradientShader4,
    kRadialGradientShader8,
    kRadialGradientShaderTexture,
    kRadialGradientShaderBuffer,
    kSweepGradientShader4,
    kSweepGradientShader8,
    kSweepGradientShaderTexture,
    kSweepGradientShaderBuffer,
    kConicalGradientShader4,
    kConicalGradientShader8,
    kConicalGradientShaderTexture,
    kConicalGradientShaderBuffer,
 
    kLocalMatrixShader,
    kImageShader,
    kCubicImageShader,
    kHWImageShader,
    kYUVImageShader,
    kCubicYUVImageShader,
    kHWYUVImageShader,
    kCoordClampShader,
    kDitherShader,
    kPerlinNoiseShader,
    kRuntimeShader,
 
    // SkColorFilter code snippets
    kMatrixColorFilter,
    kTableColorFilter,
    kGaussianColorFilter,
    kColorSpaceXformColorFilter,
 
    // SkBlender code snippets
    kBlendShader,
    kBlendModeBlender,
    kCoeffBlender,
 
    // Emits special variable holding the primitiveColor emitted by a RenderStep
    kPrimitiveColor,
 
    // Dest Read code snippets
    kDstReadSample,
    kDstReadFetch,
 
    // Clip shader snippet
    // TODO(b/238763003): Avoid incorporating clip shaders into the actual shader code.
    kClipShader,
 
    kCompose,
 
    // Fixed-function blend modes are used for the final blend with the dst buffer's color when the
    // SkPaint is using a coefficient-based SkBlendMode. The actual coefficients are extracted into
    // the SkBlendInfo associated with each pipeline, but a unique code snippet ID is assigned so
    // that the pipeline keys remain distinct. They are ordered to match SkBlendMode such
    // that (id - kFirstFixedFunctionBlendMode) == SkBlendMode).
    //
    // NOTE: Pipeline code generation depends on the fixed-function code IDs being contiguous and
    // be defined last in the enum.
    kFixedFunctionClearBlendMode,
    kFixedFunctionSrcBlendMode,
    kFixedFunctionDstBlendMode,
    kFixedFunctionSrcOverBlendMode,
    kFixedFunctionDstOverBlendMode,
    kFixedFunctionSrcInBlendMode,
    kFixedFunctionDstInBlendMode,
    kFixedFunctionSrcOutBlendMode,
    kFixedFunctionDstOutBlendMode,
    kFixedFunctionSrcATopBlendMode,
    kFixedFunctionDstATopBlendMode,
    kFixedFunctionXorBlendMode,
    kFixedFunctionPlusBlendMode,
    kFixedFunctionModulateBlendMode,
    kFixedFunctionScreenBlendMode,
 
    kFirstFixedFunctionBlendMode = kFixedFunctionClearBlendMode,
    kLast = kFixedFunctionScreenBlendMode
};

◆ ClearBuffer

enum class skgpu::graphite::ClearBuffer : bool

strong

Determines whether the contents of a GPU buffer sub-allocation gets cleared to 0 before being used in a GPU command submission.

Enumerator
kNo
kYes

Definition at line 114 of file ResourceTypes.h.

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

◆ CompareOp

enum class skgpu::graphite::CompareOp : uint8_t

strong

Enumerator
kAlways
kNever
kGreater
kGEqual
kLess
kLEqual
kEqual
kNotEqual

Definition at line 149 of file DrawTypes.h.

                     : uint8_t {
    kAlways,
    kNever,
    kGreater,
    kGEqual,
    kLess,
    kLEqual,
    kEqual,
    kNotEqual
};

◆ Coverage

enum class skgpu::graphite::Coverage

strong

Enumerator
kNone
kSingleChannel
kLCD

Definition at line 43 of file Renderer.h.

43{ kNone, kSingleChannel, kLCD };

GrProcessorAnalysisCoverage::kSingleChannel

@ kSingleChannel

GrProcessorAnalysisCoverage::kLCD

@ kLCD

flutter::kNone

@ kNone

Definition: layer.h:53

◆ DawnErrorType

enum class skgpu::graphite::DawnErrorType : uint32_t

strong

Enumerator
kNoError
kValidation
kOutOfMemory
kInternal

Definition at line 21 of file DawnErrorChecker.h.

                         : uint32_t {
    kNoError     = 0b00000000,
    kValidation  = 0b00000001,
    kOutOfMemory = 0b00000010,
    kInternal    = 0b00000100,
};

◆ DepthStencilFlags

enum class skgpu::graphite::DepthStencilFlags : int

strong

Enumerator
kNone
kDepth
kStencil
kDepthStencil

Definition at line 23 of file ResourceTypes.h.

                             : int {
    kNone = 0b000,
    kDepth = 0b001,
    kStencil = 0b010,
    kDepthStencil = kDepth | kStencil,
};

◆ DescriptorType

enum class skgpu::graphite::DescriptorType : uint8_t

strong

Types of descriptors supported within graphite

Enumerator
kUniformBuffer
kTextureSampler
kTexture
kCombinedTextureSampler
kStorageBuffer
kInputAttachment
kLast

Definition at line 20 of file DescriptorData.h.

                          : uint8_t {
    kUniformBuffer = 0,
    kTextureSampler,
    kTexture,
    kCombinedTextureSampler,
    kStorageBuffer,
    kInputAttachment,
 
    kLast = kInputAttachment,
};

◆ Discardable

enum class skgpu::graphite::Discardable : bool

strong

Must the contents of the Resource be preserved af a render pass or can a more efficient representation be chosen when supported by hardware.

Enumerator
kNo
kYes

Definition at line 123 of file ResourceTypes.h.

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

◆ DrawTypeFlags

enum skgpu::graphite::DrawTypeFlags : uint8_t

Enumerator
kNone
kText
kDrawVertices
kSimpleShape
kNonSimpleShape
kShape
kMostCommon
kAll

Definition at line 110 of file GraphiteTypes.h.

                   : uint8_t {
 
    kNone           = 0b0000,
 
    // SkCanvas:: drawSimpleText, drawString, drawGlyphs, drawTextBlob, drawSlug
    kText           = 0b0001,
 
    // SkCanvas::drawVertices
    kDrawVertices   = 0b0010,
 
    // SkCanvas::experimental_DrawEdgeAAQuad, experimental_DrawEdgeAAImageSet
    // SkCanvas:: drawRect, drawRRect, drawLine for:
    //    regular filled and hairline [r]rects,
    //    stroked rects,
    //    stroked and hairline lines,
    //    stroked circular rrects
    // Note: clipping can bump a draw out of the simple shape path
    kSimpleShape    = 0b0100,
    // All other shapes (e.g., any strokeAndFill shape, non-circular-stroked RRects, SkPaths, ...)
    kNonSimpleShape = 0b1000,
 
    kShape          = kSimpleShape | kNonSimpleShape,
 
    kMostCommon     = kText | kShape,
    kAll            = kText | kDrawVertices | kShape
};

◆ DstColorType

enum class skgpu::graphite::DstColorType

strong

Enumerator
kSurface
kPrimitive
kChildOutput

Definition at line 42 of file KeyHelpers.h.

                        {
    // A color read from the framebuffer.
    kSurface,
    // A color provided by geometry.
    kPrimitive,
    // A color evaluated by a child shader.
    kChildOutput,
};

◆ DstReadRequirement

enum class skgpu::graphite::DstReadRequirement

strong

Enumerator
kNone
kTextureCopy
kTextureSample
kFramebufferFetch

Definition at line 64 of file Caps.h.

                              {
    kNone,
    kTextureCopy,
    kTextureSample,
    kFramebufferFetch,
};

◆ LastRemovedRef

enum class skgpu::graphite::LastRemovedRef

strong

This enum is used to notify the ResourceCache which type of ref just dropped to zero on a Resource.

Enumerator
kUsage
kCommandBuffer
kCache

Definition at line 149 of file ResourceTypes.h.

                          {
    kUsage,
    kCommandBuffer,
    kCache,
};

◆ Layout

enum class skgpu::graphite::Layout

strong

Data layout requirements on host-shareable buffer contents.

Enumerator
kInvalid
kStd140
kStd430
kMetal

Definition at line 77 of file ResourceTypes.h.

                  {
    kInvalid = 0,
    kStd140,
    kStd430,
    kMetal,
};

◆ LoadOp

enum class skgpu::graphite::LoadOp : uint8_t

strong

This enum is used to specify the load operation to be used when a RenderPass begins execution

Enumerator
kLoad
kClear
kDiscard
kLast

Definition at line 34 of file ResourceTypes.h.

                  : uint8_t {
    kLoad,
    kClear,
    kDiscard,
 
    kLast = kDiscard
};

◆ Ownership

enum class skgpu::graphite::Ownership

strong

Enumerator
kOwned
kWrapped

Definition at line 128 of file ResourceTypes.h.

                     {
    kOwned,
    kWrapped,
};

◆ PathRendererStrategy

enum class skgpu::graphite::PathRendererStrategy

strong

Used to include or exclude a specific path rendering technique for testing purposes.

Enumerator
kDefault	Graphite selects the best path rendering technique for each shape. This is the default behavior.
kComputeAnalyticAA	All paths are rasterized into coverage masks using a GPU compute approach. This method always uses analytic anti-aliasing.
kComputeMSAA16	All paths are rasterized into coverage masks using a GPU compute approach. This method supports 16 and 8 sample multi-sampled anti-aliasing.
kComputeMSAA8
kRasterAA	All paths are rasterized into coverage masks using the CPU raster backend.
kTessellation	Render paths using tessellation and stencil-and-cover.

Definition at line 16 of file ContextOptionsPriv.h.

                                {
    /**
     * Graphite selects the best path rendering technique for each shape. This is the default
     * behavior.
     */
    kDefault,
 
    /**
     * All paths are rasterized into coverage masks using a GPU compute approach. This method
     * always uses analytic anti-aliasing.
     */
    kComputeAnalyticAA,
 
    /**
     * All paths are rasterized into coverage masks using a GPU compute approach. This method
     * supports 16 and 8 sample multi-sampled anti-aliasing.
     */
    kComputeMSAA16,
    kComputeMSAA8,
 
    /**
     * All paths are rasterized into coverage masks using the CPU raster backend.
     */
    kRasterAA,
 
    /**
     * Render paths using tessellation and stencil-and-cover.
     */
    kTessellation,
};

◆ PipelineStageFlags

enum class skgpu::graphite::PipelineStageFlags : uint8_t

strong

Enumerator
kVertexShader
kFragmentShader
kCompute

Definition at line 32 of file DescriptorData.h.

                              : uint8_t {
    kVertexShader = 0b001,
    kFragmentShader = 0b010,
    kCompute = 0b100,
};

◆ PrecompileImageShaderFlags

enum class skgpu::graphite::PrecompileImageShaderFlags

strong

Enumerator
kNone
kExcludeAlpha
kExcludeCubic

Definition at line 18 of file PrecompileShadersPriv.h.

                                      {
    kNone         = 0b00,
    kExcludeAlpha = 0b01,
    kExcludeCubic = 0b10
};

◆ PrimitiveType

enum class skgpu::graphite::PrimitiveType : uint8_t

strong

Geometric primitives used for drawing.

Enumerator
kTriangles
kTriangleStrip
kPoints

Definition at line 24 of file DrawTypes.h.

                         : uint8_t {
    kTriangles,
    kTriangleStrip,
    kPoints,
};

◆ Priority

enum class skgpu::graphite::Priority : int

strong

Enumerator
kFatal
kError
kWarning
kDebug

Definition at line 12 of file Log.h.

                    : int {
    kFatal = 0,
    kError = 1,
    kWarning = 2,
    kDebug = 3,
};

◆ ReadSwizzle

enum class skgpu::graphite::ReadSwizzle

strong

Enumerate the few possible read and write swizzle options for smaller storage.

Enumerator
kRGBA
kRGB1
kRRR1
kBGRA
k000R

Definition at line 15 of file ReadSwizzle.h.

                       {
    kRGBA, // Default
    kRGB1,
    kRRR1,
    kBGRA,
    k000R,
};

◆ Shareable

enum class skgpu::graphite::Shareable : bool

strong

Can the resource be held by multiple users at the same time? For example, stencil buffers, pipelines, etc.

Enumerator
kNo
kYes

Definition at line 140 of file ResourceTypes.h.

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

◆ SnippetRequirementFlags

enum class skgpu::graphite::SnippetRequirementFlags : uint32_t

strong

Enumerator
kNone
kLocalCoords
kPriorStageOutput
kBlenderDstColor
kSurfaceColor
kGradientBuffer
kStoresData

Definition at line 59 of file ShaderCodeDictionary.h.

                                   : uint32_t {
    kNone             = 0x0,
    kLocalCoords      = 0x1,
    kPriorStageOutput = 0x2,  // AKA the "input" color, or the "src" argument for a blender
    kBlenderDstColor  = 0x4,  // The "dst" argument for a blender
    kSurfaceColor     = 0x8,
    kGradientBuffer   = 0x10,
    kStoresData       = 0x20, // Indicates that the node stores numerical data
};

◆ StencilOp

enum class skgpu::graphite::StencilOp : uint8_t

strong

Enumerator
kKeep
kZero
kReplace
kInvert
kIncWrap
kDecWrap
kIncClamp
kDecClamp

Definition at line 161 of file DrawTypes.h.

                     : uint8_t {
    kKeep,
    kZero,
    kReplace, // Replace stencil value with reference (only the bits enabled in fWriteMask).
    kInvert,
    kIncWrap,
    kDecWrap,
    // NOTE: clamping occurs before the write mask. So if the MSB is zero and masked out, stencil
    // values will still wrap when using clamping ops.
    kIncClamp,
    kDecClamp
};

◆ StoreOp

enum class skgpu::graphite::StoreOp : uint8_t

strong

This enum is used to specify the store operation to be used when a RenderPass ends execution.

Enumerator
kStore
kDiscard
kLast

Definition at line 46 of file ResourceTypes.h.

                   : uint8_t {
    kStore,
    kDiscard,
 
    kLast = kDiscard
};

◆ SyncToCpu

enum class skgpu::graphite::SyncToCpu : bool

strong

Actually submit work to the GPU and track its completion

Enumerator
kYes
kNo

Definition at line 92 of file GraphiteTypes.h.

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

◆ UniformSlot

enum class skgpu::graphite::UniformSlot

strong

Enumerator
kRenderStep
kPaint
kGradient

Definition at line 134 of file DrawTypes.h.

                       {
    // TODO: Want this?
    // Meant for uniforms that change rarely to never over the course of a render pass
    // kStatic,
    // Meant for uniforms that are defined and used by the RenderStep portion of the pipeline shader
    kRenderStep,
    // Meant for uniforms that are defined and used by the paint parameters (ie SkPaint subset)
    kPaint,
    // Meant for gradient storage buffer.
    kGradient
};

◆ VelloAaConfig

enum class skgpu::graphite::VelloAaConfig

strong

Enumerator
kAnalyticArea
kMSAA16
kMSAA8

Definition at line 65 of file VelloRenderer.h.

                         {
    kAnalyticArea,
    kMSAA16,
    kMSAA8,
};

◆ VertexAttribType

enum class skgpu::graphite::VertexAttribType : uint8_t

strong

Types used to describe format of vertices in buffers.

Enumerator
kFloat
kFloat2
kFloat3
kFloat4
kHalf
kHalf2
kHalf4
kInt2
kInt3
kInt4
kByte
kByte2
kByte4
kUByte
kUByte2
kUByte4
kUByte_norm
kUByte4_norm
kShort2
kShort4
kUShort2
kUShort2_norm
kInt
kUInt
kUShort_norm
kUShort4_norm
kLast

Definition at line 33 of file DrawTypes.h.

                            : uint8_t {
    kFloat = 0,
    kFloat2,
    kFloat3,
    kFloat4,
    kHalf,
    kHalf2,
    kHalf4,
 
    kInt2,   // vector of 2 32-bit ints
    kInt3,   // vector of 3 32-bit ints
    kInt4,   // vector of 4 32-bit ints
 
    kByte,  // signed byte
    kByte2, // vector of 2 8-bit signed bytes
    kByte4, // vector of 4 8-bit signed bytes
    kUByte,  // unsigned byte
    kUByte2, // vector of 2 8-bit unsigned bytes
    kUByte4, // vector of 4 8-bit unsigned bytes
 
    kUByte_norm,  // unsigned byte, e.g. coverage, 0 -> 0.0f, 255 -> 1.0f.
    kUByte4_norm, // vector of 4 unsigned bytes, e.g. colors, 0 -> 0.0f, 255 -> 1.0f.
 
    kShort2,       // vector of 2 16-bit shorts.
    kShort4,       // vector of 4 16-bit shorts.
 
    kUShort2,      // vector of 2 unsigned shorts. 0 -> 0, 65535 -> 65535.
    kUShort2_norm, // vector of 2 unsigned shorts. 0 -> 0.0f, 65535 -> 1.0f.
 
    kInt,
    kUInt,
 
    kUShort_norm,  // unsigned short, e.g. depth, 0 -> 0.0f, 65535 -> 1.0f.
 
    kUShort4_norm, // vector of 4 unsigned shorts. 0 -> 0.0f, 65535 -> 1.0f.
 
    kLast = kUShort4_norm
};

◆ Volatile

enum class skgpu::graphite::Volatile : bool

strong

Enumerator
kNo
kYes

Definition at line 101 of file GraphiteTypes.h.

                    : bool {
    kNo = false,              // only fulfilled once
    kYes = true               // fulfilled on every insertion call
};

Function Documentation

◆ add_gradient_to_key() [1/5]

static void skgpu::graphite::add_gradient_to_key	(	const KeyContext &	keyContext,
		PaintParamsKeyBuilder *	builder,
		PipelineDataGatherer *	gatherer,
		const SkConicalGradient *	shader
	)

static

Definition at line 2327 of file KeyHelpers.cpp.

                                                                 {
    SkScalar r0 = shader->getStartRadius();
    SkScalar r1 = shader->getEndRadius();
 
    if (shader->getType() != SkConicalGradient::Type::kRadial) {
        // Since we map the centers to be (0,0) and (1,0) in the gradient matrix,
        // there is a scale of 1/distance-between-centers that has to be applied to the radii.
        r0 /= shader->getCenterX1();
        r1 /= shader->getCenterX1();
    } else {
        r0 /= shader->getDiffRadius();
        r1 /= shader->getDiffRadius();
    }
 
    add_gradient_to_key(keyContext,
                        builder,
                        gatherer,
                        shader,
                        shader->getStartCenter(),
                        shader->getEndCenter(),
                        r0,
                        r1,
                        0.0f,
                        0.0f);
}

◆ add_gradient_to_key() [2/5]

static void skgpu::graphite::add_gradient_to_key	(	const KeyContext &	keyContext,
		PaintParamsKeyBuilder *	builder,
		PipelineDataGatherer *	gatherer,
		const SkGradientBaseShader *	shader,
		SkPoint	point0,
		SkPoint	point1,
		float	radius0,
		float	radius1,
		float	bias,
		float	scale
	)

static

Definition at line 2262 of file KeyHelpers.cpp.

                                             {
    SkColor4fXformer xformedColors(shader, keyContext.dstColorInfo().colorSpace());
    const SkPMColor4f* colors = xformedColors.fColors.begin();
    const float* positions = xformedColors.fPositions;
    const int colorCount = xformedColors.fColors.size();
 
    sk_sp<TextureProxy> proxy;
 
    bool useStorageBuffer = keyContext.caps()->storageBufferSupport() &&
                            keyContext.caps()->storageBufferPreferred();
    if (colorCount > GradientShaderBlocks::GradientData::kNumInternalStorageStops
            && !useStorageBuffer) {
        if (shader->cachedBitmap().empty()) {
            SkBitmap colorsAndOffsetsBitmap =
                    create_color_and_offset_bitmap(colorCount, colors, positions);
            if (colorsAndOffsetsBitmap.empty()) {
                SKGPU_LOG_W("Couldn't create GradientShader's color and offset bitmap");
                builder->addBlock(BuiltInCodeSnippetID::kError);
                return;
            }
            shader->setCachedBitmap(colorsAndOffsetsBitmap);
        }
 
        proxy = RecorderPriv::CreateCachedProxy(keyContext.recorder(), shader->cachedBitmap(),
                                                "GradientTexture");
        if (!proxy) {
            SKGPU_LOG_W("Couldn't create GradientShader's color and offset bitmap proxy");
            builder->addBlock(BuiltInCodeSnippetID::kError);
            return;
        }
    }
 
    GradientShaderBlocks::GradientData data(shader->asGradient(),
                                            point0,
                                            point1,
                                            radius0,
                                            radius1,
                                            bias,
                                            scale,
                                            shader->getTileMode(),
                                            colorCount,
                                            colors,
                                            positions,
                                            shader,
                                            std::move(proxy),
                                            useStorageBuffer,
                                            shader->getInterpolation());
 
    make_interpolated_to_dst(keyContext,
                             builder,
                             gatherer,
                             data,
                             shader->getInterpolation(),
                             xformedColors.fIntermediateColorSpace.get());
}

◆ add_gradient_to_key() [3/5]

static void skgpu::graphite::add_gradient_to_key	(	const KeyContext &	keyContext,
		PaintParamsKeyBuilder *	builder,
		PipelineDataGatherer *	gatherer,
		const SkLinearGradient *	shader
	)

static

Definition at line 2356 of file KeyHelpers.cpp.

                                                                {
    add_gradient_to_key(keyContext,
                        builder,
                        gatherer,
                        shader,
                        shader->start(),
                        shader->end(),
                        0.0f,
                        0.0f,
                        0.0f,
                        0.0f);
}

◆ add_gradient_to_key() [4/5]

static void skgpu::graphite::add_gradient_to_key	(	const KeyContext &	keyContext,
		PaintParamsKeyBuilder *	builder,
		PipelineDataGatherer *	gatherer,
		const SkRadialGradient *	shader
	)

static

Definition at line 2372 of file KeyHelpers.cpp.

                                                                {
    add_gradient_to_key(keyContext,
                        builder,
                        gatherer,
                        shader,
                        shader->center(),
                        { 0.0f, 0.0f },
                        shader->radius(),
                        0.0f,
                        0.0f,
                        0.0f);
}

◆ add_gradient_to_key() [5/5]

static void skgpu::graphite::add_gradient_to_key	(	const KeyContext &	keyContext,
		PaintParamsKeyBuilder *	builder,
		PipelineDataGatherer *	gatherer,
		const SkSweepGradient *	shader
	)

static

Definition at line 2388 of file KeyHelpers.cpp.

                                                               {
    add_gradient_to_key(keyContext,
                        builder,
                        gatherer,
                        shader,
                        shader->center(),
                        { 0.0f, 0.0f },
                        0.0f,
                        0.0f,
                        shader->tBias(),
                        shader->tScale());
}

◆ add_to_key() [1/24]

static void skgpu::graphite::add_to_key	(	const KeyContext &	keyContext,
		PaintParamsKeyBuilder *	builder,
		PipelineDataGatherer *	gatherer,
		const SkBlendModeColorFilter *	filter
	)

static

Definition at line 1307 of file KeyHelpers.cpp.

                                                             {
    SkASSERT(filter);
 
    SkPMColor4f color = map_color(filter->color(), sk_srgb_singleton(),
                                  keyContext.dstColorInfo().colorSpace());
 
    AddBlendModeColorFilter(keyContext, builder, gatherer, filter->mode(), color);
}

◆ add_to_key() [2/24]

static void skgpu::graphite::add_to_key	(	const KeyContext &	keyContext,
		PaintParamsKeyBuilder *	builder,
		PipelineDataGatherer *	gatherer,
		const SkBlendShader *	shader
	)

static

Definition at line 1497 of file KeyHelpers.cpp.

                                                    {
    SkASSERT(shader);
 
    Blend(keyContext, builder, gatherer,
            /* addBlendToKey= */ [&] () -> void {
                AddModeBlend(keyContext, builder, gatherer, shader->mode());
            },
            /* addSrcToKey= */ [&]() -> void {
                AddToKey(keyContext, builder, gatherer, shader->src().get());
            },
            /* addDstToKey= */ [&]() -> void {
                AddToKey(keyContext, builder, gatherer, shader->dst().get());
            });
}

◆ add_to_key() [3/24]

static void skgpu::graphite::add_to_key	(	const KeyContext &	keyContext,
		PaintParamsKeyBuilder *	builder,
		PipelineDataGatherer *	gatherer,
		const SkColor4Shader *	shader
	)

static

Definition at line 1555 of file KeyHelpers.cpp.

                                                     {
    SkASSERT(shader);
 
    SkPMColor4f color = map_color(shader->color(), shader->colorSpace().get(),
                                  keyContext.dstColorInfo().colorSpace());
 
    SolidColorShaderBlock::AddBlock(keyContext, builder, gatherer, color);
}

◆ add_to_key() [4/24]

static void skgpu::graphite::add_to_key	(	const KeyContext &	keyContext,
		PaintParamsKeyBuilder *	builder,
		PipelineDataGatherer *	gatherer,
		const SkColorFilterShader *	shader
	)

static

Definition at line 1570 of file KeyHelpers.cpp.

                                                          {
    SkASSERT(shader);
 
    Compose(keyContext, builder, gatherer,
            /* addInnerToKey= */ [&]() -> void {
                AddToKey(keyContext, builder, gatherer, shader->shader().get());
            },
            /* addOuterToKey= */ [&]() -> void {
                AddToKey(keyContext, builder, gatherer, shader->filter().get());
            });
}

◆ add_to_key() [5/24]

static void skgpu::graphite::add_to_key	(	const KeyContext &	keyContext,
		PaintParamsKeyBuilder *	builder,
		PipelineDataGatherer *	gatherer,
		const SkColorShader *	shader
	)

static

Definition at line 1542 of file KeyHelpers.cpp.

                                                    {
    SkASSERT(shader);
 
    SolidColorShaderBlock::AddBlock(keyContext, builder, gatherer,
                                    SkColor4f::FromColor(shader->color()).premul());
}

◆ add_to_key() [6/24]

static void skgpu::graphite::add_to_key	(	const KeyContext &	keyContext,
		PaintParamsKeyBuilder *	builder,
		PipelineDataGatherer *	gatherer,
		const SkColorSpaceXformColorFilter *	filter
	)

static

Definition at line 1319 of file KeyHelpers.cpp.

                                                                   {
    SkASSERT(filter);
 
    constexpr SkAlphaType kAlphaType = kPremul_SkAlphaType;
    ColorSpaceTransformBlock::ColorSpaceTransformData csData(filter->src().get(), kAlphaType,
                                                             filter->dst().get(), kAlphaType);
    ColorSpaceTransformBlock::AddBlock(keyContext, builder, gatherer, csData);
}

◆ add_to_key() [7/24]

static void skgpu::graphite::add_to_key	(	const KeyContext &	keyContext,
		PaintParamsKeyBuilder *	builder,
		PipelineDataGatherer *	gatherer,
		const SkCoordClampShader *	shader
	)

static

Definition at line 1591 of file KeyHelpers.cpp.

                                                         {
    SkASSERT(shader);
 
    CoordClampShaderBlock::CoordClampData data(shader->subset());
 
    KeyContextWithCoordClamp childContext(keyContext);
    CoordClampShaderBlock::BeginBlock(keyContext, builder, gatherer, data);
    AddToKey(childContext, builder, gatherer, shader->shader().get());
    builder->endBlock();
}

◆ add_to_key() [8/24]

static void skgpu::graphite::add_to_key	(	const KeyContext &	keyContext,
		PaintParamsKeyBuilder *	builder,
		PipelineDataGatherer *	gatherer,
		const SkCTMShader *	shader
	)

static

Definition at line 1522 of file KeyHelpers.cpp.

                                                  {
    // CTM shaders are always given device coordinates, so we don't have to modify the CTM itself
    // with keyContext's local transform.
    LocalMatrixShaderBlock::LMShaderData lmShaderData(shader->ctm());
 
    KeyContextWithLocalMatrix newContext(keyContext, shader->ctm());
 
    LocalMatrixShaderBlock::BeginBlock(newContext, builder, gatherer, lmShaderData);
 
        AddToKey(newContext, builder, gatherer, shader->proxyShader().get());
 
    builder->endBlock();
}

◆ add_to_key() [9/24]

static void skgpu::graphite::add_to_key	(	const KeyContext &	keyContext,
		PaintParamsKeyBuilder *	builder,
		PipelineDataGatherer *	gatherer,
		const SkEmptyShader *
	)

static

Definition at line 1610 of file KeyHelpers.cpp.

                                             {
    builder->addBlock(BuiltInCodeSnippetID::kPriorOutput);
}

◆ add_to_key() [10/24]

static void skgpu::graphite::add_to_key	(	const KeyContext &	keyContext,
		PaintParamsKeyBuilder *	builder,
		PipelineDataGatherer *	gatherer,
		const SkGaussianColorFilter *
	)

static

Definition at line 1346 of file KeyHelpers.cpp.

                                                     {
    builder->addBlock(BuiltInCodeSnippetID::kGaussianColorFilter);
}

◆ add_to_key() [11/24]

static void skgpu::graphite::add_to_key	(	const KeyContext &	keyContext,
		PaintParamsKeyBuilder *	builder,
		PipelineDataGatherer *	gatherer,
		const SkGradientBaseShader *	shader
	)

static

Definition at line 2404 of file KeyHelpers.cpp.

                                                           {
    SkASSERT(shader);
    switch (shader->asGradient()) {
#define M(type)                                                               \
    case SkShaderBase::GradientType::k##type:                                 \
        add_gradient_to_key(keyContext,                                       \
                            builder,                                          \
                            gatherer,                                         \
                            static_cast<const Sk##type##Gradient*>(shader));  \
        return;
        SK_ALL_GRADIENTS(M)
#undef M
        case SkShaderBase::GradientType::kNone:
            SkDEBUGFAIL("Gradient shader says its type is none");
            return;
    }
    SkUNREACHABLE;
}

◆ add_to_key() [12/24]

static void skgpu::graphite::add_to_key	(	const KeyContext &	keyContext,
		PaintParamsKeyBuilder *	builder,
		PipelineDataGatherer *	gatherer,
		const SkImageShader *	shader
	)

static

Definition at line 1775 of file KeyHelpers.cpp.

                                                    {
    SkASSERT(shader);
 
    auto [ imageToDraw, newSampling ] = GetGraphiteBacked(keyContext.recorder(),
                                                          shader->image().get(),
                                                          shader->sampling());
    if (!imageToDraw) {
        SKGPU_LOG_W("Couldn't convert ImageShader's image to a Graphite-backed image");
        builder->addBlock(BuiltInCodeSnippetID::kError);
        return;
    }
    if (!as_IB(shader->image())->isGraphiteBacked()) {
        // GetGraphiteBacked() created a new image (or fetched a cached image) from the client
        // image provider. This image was not available when NotifyInUse() visited the shader tree,
        // so call notify again. These images shouldn't really be producing new tasks since it's
        // unlikely that a client will be fulfilling with a dynamic image that wraps a long-lived
        // SkSurface. However, the images can be linked to a surface that rendered the initial
        // content and not calling notifyInUse() prevents unlinking the image from the Device.
        // If the client image provider then holds on to many of these images, the leaked Device and
        // DrawContext memory can be surprisingly high. b/338453542.
        // TODO (b/330864257): Once paint keys are extracted at draw time, AddToKey() will be
        // fully responsible for notifyInUse() calls and then we can simply always call this on
        // `imageToDraw`. The DrawContext that samples the image will also be available to AddToKey
        // so we won't have to pass in nullptr.
        SkASSERT(as_IB(imageToDraw)->isGraphiteBacked());
        static_cast<Image_Base*>(imageToDraw.get())->notifyInUse(keyContext.recorder(),
                                                                 /*drawContext=*/nullptr);
    }
    if (as_IB(imageToDraw)->isYUVA()) {
        return add_yuv_image_to_key(keyContext,
                                      builder,
                                      gatherer,
                                      shader,
                                      std::move(imageToDraw),
                                      newSampling);
    }
 
    auto view = AsView(imageToDraw.get());
    SkASSERT(newSampling.mipmap == SkMipmapMode::kNone || view.mipmapped() == Mipmapped::kYes);
 
    ImageShaderBlock::ImageData imgData(shader->sampling(),
                                        shader->tileModeX(),
                                        shader->tileModeY(),
                                        view.proxy()->dimensions(),
                                        shader->subset(),
                                        ReadSwizzle::kRGBA);
 
    // Here we detect pixel aligned blit-like image draws. Some devices have low precision filtering
    // and will produce degraded (blurry) images unexpectedly for sequential exact pixel blits when
    // not using nearest filtering. This is common for canvas scrolling implementations. Forcing
    // nearest filtering when possible can also be a minor perf/power optimization depending on the
    // hardware.
    bool samplingHasNoEffect = false;
    // Cubic sampling is will not filter the same as nearest even when pixel aligned.
    if (keyContext.optimizeSampling() == KeyContext::OptimizeSampling::kYes &&
        !newSampling.useCubic) {
        SkMatrix totalM = keyContext.local2Dev().asM33();
        if (keyContext.localMatrix()) {
            totalM.preConcat(*keyContext.localMatrix());
        }
        totalM.normalizePerspective();
        // The matrix should be translation with only pixel aligned 2d translation.
        samplingHasNoEffect = totalM.isTranslate() && SkScalarIsInt(totalM.getTranslateX()) &&
                              SkScalarIsInt(totalM.getTranslateY());
    }
 
    imgData.fSampling = samplingHasNoEffect ? SkFilterMode::kNearest : newSampling;
    imgData.fTextureProxy = view.refProxy();
    skgpu::Swizzle readSwizzle = view.swizzle();
    // If the color type is alpha-only, propagate the alpha value to the other channels.
    if (imageToDraw->isAlphaOnly()) {
        readSwizzle = skgpu::Swizzle::Concat(readSwizzle, skgpu::Swizzle("000a"));
    }
    imgData.fReadSwizzle = swizzle_class_to_read_enum(readSwizzle);
 
    if (!shader->isRaw()) {
        imgData.fSteps = SkColorSpaceXformSteps(imageToDraw->colorSpace(),
                                                imageToDraw->alphaType(),
                                                keyContext.dstColorInfo().colorSpace(),
                                                keyContext.dstColorInfo().alphaType());
 
        if (imageToDraw->isAlphaOnly() && keyContext.scope() != KeyContext::Scope::kRuntimeEffect) {
            Blend(keyContext, builder, gatherer,
                  /* addBlendToKey= */ [&] () -> void {
                      AddKnownModeBlend(keyContext, builder, gatherer, SkBlendMode::kDstIn);
                  },
                  /* addSrcToKey= */ [&] () -> void {
                      ImageShaderBlock::AddBlock(keyContext, builder, gatherer, imgData);
                  },
                  /* addDstToKey= */ [&]() -> void {
                      RGBPaintColorBlock::AddBlock(keyContext, builder, gatherer);
                  });
            return;
        }
    }
 
    ImageShaderBlock::AddBlock(keyContext, builder, gatherer, imgData);
}

◆ add_to_key() [13/24]

static void skgpu::graphite::add_to_key	(	const KeyContext &	keyContext,
		PaintParamsKeyBuilder *	builder,
		PipelineDataGatherer *	gatherer,
		const SkLocalMatrixShader *	shader
	)

static

Definition at line 1888 of file KeyHelpers.cpp.

                                                          {
    SkASSERT(shader);
    auto wrappedShader = shader->wrappedShader().get();
 
    // Fold the texture's origin flip into the local matrix so that the image shader doesn't need
    // additional state
    SkMatrix matrix;
    SkShaderBase* wrappedShaderBase = as_SB(wrappedShader);
    if (wrappedShaderBase->type() == SkShaderBase::ShaderType::kImage) {
        auto imgShader = static_cast<const SkImageShader*>(wrappedShader);
        // If the image is not graphite backed then we can assume the origin will be TopLeft as we
        // require that in the ImageProvider utility. Also Graphite YUV images are assumed to be
        // TopLeft origin.
        // TODO (b/336788317): Fold YUVAImage's origin into this matrix as well.
        auto imgBase = as_IB(imgShader->image());
        if (imgBase->isGraphiteBacked() && !imgBase->isYUVA()) {
            auto imgGraphite = static_cast<Image*>(imgBase);
            SkASSERT(imgGraphite);
            const auto& view = imgGraphite->textureProxyView();
            if (view.origin() == Origin::kBottomLeft) {
                matrix.setScaleY(-1);
                matrix.setTranslateY(view.height());
            }
        }
    } else if (wrappedShaderBase->type() == SkShaderBase::ShaderType::kGradientBase) {
        auto gradShader = static_cast<const SkGradientBaseShader*>(wrappedShader);
        auto gradMatrix = gradShader->getGradientMatrix();
 
        // Override the conical gradient matrix since graphite uses a different algorithm
        // than the ganesh and raster backends.
        if (gradShader->asGradient() == SkShaderBase::GradientType::kConical) {
            auto conicalShader = static_cast<const SkConicalGradient*>(gradShader);
 
            SkMatrix conicalMatrix;
            if (conicalShader->getType() == SkConicalGradient::Type::kRadial) {
                SkPoint center = conicalShader->getStartCenter();
                conicalMatrix.postTranslate(-center.fX, -center.fY);
 
                float scale = sk_ieee_float_divide(1, conicalShader->getDiffRadius());
                conicalMatrix.postScale(scale, scale);
            } else {
                SkAssertResult(SkConicalGradient::MapToUnitX(conicalShader->getStartCenter(),
                                                             conicalShader->getEndCenter(),
                                                             &conicalMatrix));
            }
            gradMatrix = conicalMatrix;
        }
 
        SkMatrix invGradMatrix;
        SkAssertResult(gradMatrix.invert(&invGradMatrix));
 
        matrix.postConcat(invGradMatrix);
    }
 
    matrix.postConcat(shader->localMatrix());
    LocalMatrixShaderBlock::LMShaderData lmShaderData(matrix);
 
    KeyContextWithLocalMatrix newContext(keyContext, matrix);
 
    LocalMatrixShaderBlock::BeginBlock(newContext, builder, gatherer, lmShaderData);
 
    AddToKey(newContext, builder, gatherer, wrappedShader);
 
    builder->endBlock();
}

◆ add_to_key() [14/24]

static void skgpu::graphite::add_to_key	(	const KeyContext &	keyContext,
		PaintParamsKeyBuilder *	builder,
		PipelineDataGatherer *	gatherer,
		const SkMatrixColorFilter *	filter
	)

static

Definition at line 1353 of file KeyHelpers.cpp.

                                                          {
    SkASSERT(filter);
 
    bool inHSLA = filter->domain() == SkMatrixColorFilter::Domain::kHSLA;
    MatrixColorFilterBlock::MatrixColorFilterData matrixCFData(filter->matrix(), inHSLA);
 
    MatrixColorFilterBlock::AddBlock(keyContext, builder, gatherer, matrixCFData);
}

◆ add_to_key() [15/24]

static void skgpu::graphite::add_to_key	(	const KeyContext &	keyContext,
		PaintParamsKeyBuilder *	builder,
		PipelineDataGatherer *	gatherer,
		const SkPerlinNoiseShader *	shader
	)

static

Definition at line 1969 of file KeyHelpers.cpp.

                                                          {
    SkASSERT(shader);
    SkASSERT(shader->numOctaves());
 
    std::unique_ptr<SkPerlinNoiseShader::PaintingData> paintingData = shader->getPaintingData();
    paintingData->generateBitmaps();
 
    sk_sp<TextureProxy> perm =
            RecorderPriv::CreateCachedProxy(keyContext.recorder(),
                                            paintingData->getPermutationsBitmap(),
                                            "PerlinNoisePermTable");
 
    sk_sp<TextureProxy> noise =
            RecorderPriv::CreateCachedProxy(keyContext.recorder(), paintingData->getNoiseBitmap(),
                                            "PerlinNoiseNoiseTable");
 
    if (!perm || !noise) {
        SKGPU_LOG_W("Couldn't create tables for PerlinNoiseShader");
        builder->addBlock(BuiltInCodeSnippetID::kError);
        return;
    }
 
    PerlinNoiseShaderBlock::PerlinNoiseData perlinData(
            static_cast<PerlinNoiseShaderBlock::Type>(shader->noiseType()),
            paintingData->fBaseFrequency,
            shader->numOctaves(),
            {paintingData->fStitchDataInit.fWidth, paintingData->fStitchDataInit.fHeight});
 
    perlinData.fPermutationsProxy = std::move(perm);
    perlinData.fNoiseProxy = std::move(noise);
 
    PerlinNoiseShaderBlock::AddBlock(keyContext, builder, gatherer, perlinData);
}

◆ add_to_key() [16/24]

static void skgpu::graphite::add_to_key	(	const KeyContext &	keyContext,
		PaintParamsKeyBuilder *	builder,
		PipelineDataGatherer *	gatherer,
		const SkPictureShader *	shader
	)

static

Definition at line 2009 of file KeyHelpers.cpp.

                                                      {
    SkASSERT(shader);
 
    Recorder* recorder = keyContext.recorder();
    const Caps* caps = recorder->priv().caps();
 
    // TODO: We'll need additional plumbing to get the correct props from our callers. In
    // particular we'll need to expand the keyContext to have the surfaceProps.
    SkSurfaceProps props{};
 
    SkMatrix totalM = keyContext.local2Dev().asM33();
    if (keyContext.localMatrix()) {
        totalM.preConcat(*keyContext.localMatrix());
    }
    auto info = SkPictureShader::CachedImageInfo::Make(shader->tile(),
                                                       totalM,
                                                       keyContext.dstColorInfo().colorType(),
                                                       keyContext.dstColorInfo().colorSpace(),
                                                       caps->maxTextureSize(),
                                                       props);
    if (!info.success) {
        SKGPU_LOG_W("Couldn't access PictureShaders' Image info");
        builder->addBlock(BuiltInCodeSnippetID::kError);
        return;
    }
 
    // NOTE: While this is intended to be a "scratch" surface, we don't use MakeScratch() because
    // the SkPicture could contain arbitrary operations that rely on the Recorder's atlases, which
    // means the Surface's device has to participate in flushing when the atlas fills up.
    // TODO: Can this be an approx-fit image that's generated?
    // TODO: right now we're explicitly not caching here. We could expand the ImageProvider
    // API to include already Graphite-backed images, add a Recorder-local cache or add
    // rendered-picture images to the global cache.
    sk_sp<Surface> surface = Surface::Make(recorder,
                                           info.imageInfo,
                                           "PictureShaderTexture",
                                           Budgeted::kYes,
                                           Mipmapped::kNo,
                                           SkBackingFit::kExact,
                                           &info.props);
    if (!surface) {
        SKGPU_LOG_W("Could not create surface to render PictureShader");
        builder->addBlock(BuiltInCodeSnippetID::kError);
        return;
    }
 
    // NOTE: Don't call CachedImageInfo::makeImage() since that uses the legacy makeImageSnapshot()
    // API, which results in an extra texture copy on a Graphite Surface.
    surface->getCanvas()->concat(info.matrixForDraw);
    surface->getCanvas()->drawPicture(shader->picture().get());
    sk_sp<SkImage> img = SkSurfaces::AsImage(std::move(surface));
    // TODO: 'img' did not exist when notify_in_use() was called, but ideally the DrawTask to render
    // into 'surface' would be a child of the current device. While we push all tasks to the root
    // list this works out okay, but will need to be addressed before we move off that system.
    if (!img) {
        SKGPU_LOG_W("Couldn't create SkImage for PictureShader");
        builder->addBlock(BuiltInCodeSnippetID::kError);
        return;
    }
 
    const auto shaderLM = SkMatrix::Scale(1.f/info.tileScale.width(), 1.f/info.tileScale.height());
    sk_sp<SkShader> imgShader = img->makeShader(shader->tileModeX(), shader->tileModeY(),
                                                SkSamplingOptions(shader->filter()), &shaderLM);
    if (!imgShader) {
        SKGPU_LOG_W("Couldn't create SkImageShader for PictureShader");
        builder->addBlock(BuiltInCodeSnippetID::kError);
        return;
    }
 
    AddToKey(keyContext, builder, gatherer, imgShader.get());
}

◆ add_to_key() [17/24]

static void skgpu::graphite::add_to_key	(	const KeyContext &	keyContext,
		PaintParamsKeyBuilder *	builder,
		PipelineDataGatherer *	gatherer,
		const SkRuntimeColorFilter *	filter
	)

static

Definition at line 1365 of file KeyHelpers.cpp.

                                                           {
    SkASSERT(filter);
 
    sk_sp<SkRuntimeEffect> effect = filter->effect();
    sk_sp<const SkData> uniforms = SkRuntimeEffectPriv::TransformUniforms(
            effect->uniforms(), filter->uniforms(), keyContext.dstColorInfo().colorSpace());
    SkASSERT(uniforms);
 
    RuntimeEffectBlock::BeginBlock(keyContext, builder, gatherer, {effect, std::move(uniforms)});
 
    add_children_to_key(keyContext, builder, gatherer,
                        filter->children(), effect->children());
 
    builder->endBlock();
}

◆ add_to_key() [18/24]

static void skgpu::graphite::add_to_key	(	const KeyContext &	keyContext,
		PaintParamsKeyBuilder *	builder,
		PipelineDataGatherer *	gatherer,
		const SkRuntimeShader *	shader
	)

static

Definition at line 2088 of file KeyHelpers.cpp.

                                                      {
    SkASSERT(shader);
    sk_sp<SkRuntimeEffect> effect = shader->effect();
    sk_sp<const SkData> uniforms = SkRuntimeEffectPriv::TransformUniforms(
            effect->uniforms(),
            shader->uniformData(keyContext.dstColorInfo().colorSpace()),
            keyContext.dstColorInfo().colorSpace());
    SkASSERT(uniforms);
 
    RuntimeEffectBlock::BeginBlock(keyContext, builder, gatherer,
                                   {effect, std::move(uniforms)});
 
    add_children_to_key(keyContext, builder, gatherer,
                        shader->children(), effect->children());
 
    builder->endBlock();
}

◆ add_to_key() [19/24]

static void skgpu::graphite::add_to_key	(	const KeyContext &	keyContext,
		PaintParamsKeyBuilder *	builder,
		PipelineDataGatherer *	gatherer,
		const SkTableColorFilter *	filter
	)

static

Definition at line 1384 of file KeyHelpers.cpp.

                                                         {
    SkASSERT(filter);
 
    sk_sp<TextureProxy> proxy = RecorderPriv::CreateCachedProxy(keyContext.recorder(),
                                                                filter->bitmap(),
                                                                "TableColorFilterTexture");
    if (!proxy) {
        SKGPU_LOG_W("Couldn't create TableColorFilter's table");
 
        // Return the input color as-is.
        builder->addBlock(BuiltInCodeSnippetID::kPriorOutput);
        return;
    }
 
    TableColorFilterBlock::TableColorFilterData data(std::move(proxy));
 
    TableColorFilterBlock::AddBlock(keyContext, builder, gatherer, data);
}

◆ add_to_key() [20/24]

static void skgpu::graphite::add_to_key	(	const KeyContext &	keyContext,
		PaintParamsKeyBuilder *	builder,
		PipelineDataGatherer *	gatherer,
		const SkTransformShader *	shader
	)

static

Definition at line 2114 of file KeyHelpers.cpp.

                                                        {
    SKGPU_LOG_W("Raster-only SkShader (SkTransformShader) encountered");
    builder->addBlock(BuiltInCodeSnippetID::kError);
}

◆ add_to_key() [21/24]

static void skgpu::graphite::add_to_key	(	const KeyContext &	keyContext,
		PaintParamsKeyBuilder *	builder,
		PipelineDataGatherer *	gatherer,
		const SkTriColorShader *	shader
	)

static

Definition at line 2125 of file KeyHelpers.cpp.

                                                       {
    SKGPU_LOG_W("Raster-only SkShader (SkTriColorShader) encountered");
    builder->addBlock(BuiltInCodeSnippetID::kError);
}

◆ add_to_key() [22/24]

static void skgpu::graphite::add_to_key	(	const KeyContext &	keyContext,
		PaintParamsKeyBuilder *	builder,
		PipelineDataGatherer *	gatherer,
		const SkWorkingColorSpaceShader *	shader
	)

static

Definition at line 2136 of file KeyHelpers.cpp.

                                                                {
    SkASSERT(shader);
 
    const SkColorInfo& dstInfo = keyContext.dstColorInfo();
    const SkAlphaType dstAT = dstInfo.alphaType();
    sk_sp<SkColorSpace> dstCS = dstInfo.refColorSpace();
    if (!dstCS) {
        dstCS = SkColorSpace::MakeSRGB();
    }
 
    sk_sp<SkColorSpace> workingCS = shader->workingSpace();
    SkColorInfo workingInfo(dstInfo.colorType(), dstAT, workingCS);
    KeyContextWithColorInfo workingContext(keyContext, workingInfo);
 
    // Compose the inner shader (in the working space) with a (working->dst) transform:
    Compose(keyContext, builder, gatherer,
        /* addInnerToKey= */ [&]() -> void {
            AddToKey(workingContext, builder, gatherer, shader->shader().get());
        },
        /* addOuterToKey= */ [&]() -> void {
            ColorSpaceTransformBlock::ColorSpaceTransformData data(
                    workingCS.get(), dstAT, dstCS.get(), dstAT);
            ColorSpaceTransformBlock::AddBlock(keyContext, builder, gatherer, data);
        });
}

◆ add_to_key() [23/24]

static void skgpu::graphite::add_to_key	(	const KeyContext &	keyContext,
		PaintParamsKeyBuilder *	builder,
		PipelineDataGatherer *	gatherer,
		const SkWorkingFormatColorFilter *	filter
	)

static

Definition at line 1406 of file KeyHelpers.cpp.

                                                                 {
    SkASSERT(filter);
 
    const SkColorInfo& dstInfo = keyContext.dstColorInfo();
    const SkAlphaType dstAT = dstInfo.alphaType();
    sk_sp<SkColorSpace> dstCS = dstInfo.refColorSpace();
    if (!dstCS) {
        dstCS = SkColorSpace::MakeSRGB();
    }
 
    SkAlphaType workingAT;
    sk_sp<SkColorSpace> workingCS = filter->workingFormat(dstCS, &workingAT);
    SkColorInfo workingInfo(dstInfo.colorType(), workingAT, workingCS);
    KeyContextWithColorInfo workingContext(keyContext, workingInfo);
 
    // Use two nested compose blocks to chain (dst->working), child, and (working->dst) together
    // while appearing as one block to the parent node.
    Compose(keyContext, builder, gatherer,
            /* addInnerToKey= */ [&]() -> void {
                // Inner compose
                Compose(keyContext, builder, gatherer,
                        /* addInnerToKey= */ [&]() -> void {
                            // Innermost (inner of inner compose)
                            ColorSpaceTransformBlock::ColorSpaceTransformData data1(
                                    dstCS.get(), dstAT, workingCS.get(), workingAT);
                            ColorSpaceTransformBlock::AddBlock(keyContext, builder, gatherer,
                                                               data1);
                        },
                        /* addOuterToKey= */ [&]() -> void {
                            // Middle (outer of inner compose)
                            AddToKey(workingContext, builder, gatherer, filter->child().get());
                        });
            },
            /* addOuterToKey= */ [&]() -> void {
                // Outermost (outer of outer compose)
                ColorSpaceTransformBlock::ColorSpaceTransformData data2(
                        workingCS.get(), workingAT, dstCS.get(), dstAT);
                ColorSpaceTransformBlock::AddBlock(keyContext, builder, gatherer, data2);
            });
}

◆ add_to_key() [24/24]

static void skgpu::graphite::add_to_key	(	const KeyContext &	keyContext,
		PaintParamsKeyBuilder *	keyBuilder,
		PipelineDataGatherer *	gatherer,
		const SkComposeColorFilter *	filter
	)

static

Definition at line 1331 of file KeyHelpers.cpp.

                                                           {
    SkASSERT(filter);
 
    Compose(keyContext, keyBuilder, gatherer,
            /* addInnerToKey= */ [&]() -> void {
                AddToKey(keyContext, keyBuilder, gatherer, filter->inner().get());
            },
            /* addOuterToKey= */ [&]() -> void {
                AddToKey(keyContext, keyBuilder, gatherer, filter->outer().get());
            });
}

◆ add_yuv_image_to_key()

static void skgpu::graphite::add_yuv_image_to_key	(	const KeyContext &	keyContext,
		PaintParamsKeyBuilder *	builder,
		PipelineDataGatherer *	gatherer,
		const SkImageShader *	origShader,
		sk_sp< const SkImage >	imageToDraw,
		SkSamplingOptions	sampling
	)

static

Definition at line 1620 of file KeyHelpers.cpp.

                                                             {
    SkASSERT(!imageToDraw->isAlphaOnly());
 
    const Image_YUVA* yuvaImage = static_cast<const Image_YUVA*>(imageToDraw.get());
    const SkYUVAInfo& yuvaInfo = yuvaImage->yuvaInfo();
    // We would want to add a translation to the local matrix to handle other sitings.
    SkASSERT(yuvaInfo.sitingX() == SkYUVAInfo::Siting::kCentered);
    SkASSERT(yuvaInfo.sitingY() == SkYUVAInfo::Siting::kCentered);
    YUVImageShaderBlock::ImageData imgData(sampling,
                                           origShader->tileModeX(),
                                           origShader->tileModeY(),
                                           imageToDraw->dimensions(),
                                           origShader->subset());
    for (int locIndex = 0; locIndex < SkYUVAInfo::kYUVAChannelCount; ++locIndex) {
        const TextureProxyView& view = yuvaImage->proxyView(locIndex);
        if (view) {
            imgData.fTextureProxies[locIndex] = view.refProxy();
            // The view's swizzle has the data channel for the YUVA location in all slots, so read
            // the 0th slot to determine fChannelSelect
            switch(view.swizzle()[0]) {
                case 'r': imgData.fChannelSelect[locIndex] = {1.f, 0.f, 0.f, 0.f}; break;
                case 'g': imgData.fChannelSelect[locIndex] = {0.f, 1.f, 0.f, 0.f}; break;
                case 'b': imgData.fChannelSelect[locIndex] = {0.f, 0.f, 1.f, 0.f}; break;
                case 'a': imgData.fChannelSelect[locIndex] = {0.f, 0.f, 0.f, 1.f}; break;
                default:
                    imgData.fChannelSelect[locIndex] = {0.f, 0.f, 0.f, 0.f};
                    SkDEBUGFAILF("Unexpected swizzle for YUVA data: %c", view.swizzle()[0]);
                    break;
            }
        } else {
            // Only the A proxy view should be null, in which case we bind the Y proxy view to
            // pass validation and send all 1s for the channel selection to signal opaque alpha.
            SkASSERT(locIndex == 3);
            imgData.fTextureProxies[locIndex] = yuvaImage->proxyView(SkYUVAInfo::kY).refProxy();
            imgData.fChannelSelect[locIndex] = {1.f, 1.f, 1.f, 1.f};
        }
    }
 
    auto [ssx, ssy] = yuvaImage->uvSubsampleFactors();
    if (ssx > 1 || ssy > 1) {
        // We need to adjust the image size we use for sampling to reflect the actual image size of
        // the UV planes. However, since our coordinates are in Y's texel space we need to scale
        // accordingly.
        const TextureProxyView& view = yuvaImage->proxyView(SkYUVAInfo::kU);
        imgData.fImgSizeUV = {view.dimensions().width()*ssx, view.dimensions().height()*ssy};
        // This promotion of nearest to linear filtering for UV planes exists to mimic
        // libjpeg[-turbo]'s do_fancy_upsampling option. We will filter the subsampled plane,
        // however we want to filter at a fixed point for each logical image pixel to simulate
        // nearest neighbor. In the shader we detect that the UV filtermode doesn't match the Y
        // filtermode, and snap to Y pixel centers.
        if (imgData.fSampling.filter == SkFilterMode::kNearest) {
            imgData.fSamplingUV = SkSamplingOptions(SkFilterMode::kLinear,
                                                    imgData.fSampling.mipmap);
            // Consider a logical image pixel at the edge of the subset. When computing the logical
            // pixel color value we should use a blend of two values from the subsampled plane.
            // Depending on where the subset edge falls in actual subsampled plane, one of those
            // values may come from outside the subset. Hence, we will use the default inset
            // in Y texel space of 1/2. This applies the wrap mode to the subset but allows
            // linear filtering to read pixels that are just outside the subset.
            imgData.fLinearFilterUVInset.fX = 0.5f;
            imgData.fLinearFilterUVInset.fY = 0.5f;
        } else if (imgData.fSampling.filter == SkFilterMode::kLinear) {
            // We need to inset so that we aren't sampling outside the subset, but no farther.
            // Start by mapping the subset to UV texel space
            float scaleX = 1.f/ssx;
            float scaleY = 1.f/ssy;
            SkRect subsetUV = {imgData.fSubset.fLeft  *scaleX,
                               imgData.fSubset.fTop   *scaleY,
                               imgData.fSubset.fRight *scaleX,
                               imgData.fSubset.fBottom*scaleY};
            // Round to UV texel borders
            SkIRect iSubsetUV = subsetUV.roundOut();
            // Inset in UV and map back to Y texel space. This gives us the largest possible
            // inset rectangle that will not sample outside of the subset texels in UV space.
            SkRect insetRectUV = {(iSubsetUV.fLeft  +0.5f)*ssx,
                                  (iSubsetUV.fTop   +0.5f)*ssy,
                                  (iSubsetUV.fRight -0.5f)*ssx,
                                  (iSubsetUV.fBottom-0.5f)*ssy};
            // Compute intersection with original inset
            SkRect insetRect = imgData.fSubset.makeOutset(-0.5f, -0.5f);
            (void) insetRect.intersect(insetRectUV);
            // Compute max inset values to ensure we always remain within the subset.
            imgData.fLinearFilterUVInset = {std::max(insetRect.fLeft - imgData.fSubset.fLeft,
                                                     imgData.fSubset.fRight - insetRect.fRight),
                                            std::max(insetRect.fTop - imgData.fSubset.fTop,
                                                     imgData.fSubset.fBottom - insetRect.fBottom)};
        }
    }
 
    float yuvM[20];
    SkColorMatrix_YUV2RGB(yuvaInfo.yuvColorSpace(), yuvM);
    // We drop the fourth column entirely since the transformation
    // should not depend on alpha. The fifth column is sent as a separate
    // vector. The fourth row is also dropped entirely because alpha should
    // never be modified.
    SkASSERT(yuvM[3] == 0 && yuvM[8] == 0 && yuvM[13] == 0 && yuvM[18] == 1);
    SkASSERT(yuvM[15] == 0 && yuvM[16] == 0 && yuvM[17] == 0 && yuvM[19] == 0);
    imgData.fYUVtoRGBMatrix.setAll(
        yuvM[ 0], yuvM[ 1], yuvM[ 2],
        yuvM[ 5], yuvM[ 6], yuvM[ 7],
        yuvM[10], yuvM[11], yuvM[12]
    );
    imgData.fYUVtoRGBTranslate = {yuvM[4], yuvM[9], yuvM[14]};
 
    // The YUV formats can encode their own origin including reflection and rotation,
    // so we need to wrap our block in an additional local matrix transform.
    SkMatrix originMatrix = yuvaInfo.originMatrix();
    LocalMatrixShaderBlock::LMShaderData lmShaderData(originMatrix);
 
    KeyContextWithLocalMatrix newContext(keyContext, originMatrix);
 
    SkColorSpaceXformSteps steps;
    SkASSERT(steps.flags.mask() == 0);   // By default, the colorspace should have no effect
    if (!origShader->isRaw()) {
        steps = SkColorSpaceXformSteps(imageToDraw->colorSpace(),
                                       imageToDraw->alphaType(),
                                       keyContext.dstColorInfo().colorSpace(),
                                       keyContext.dstColorInfo().alphaType());
    }
    ColorSpaceTransformBlock::ColorSpaceTransformData data(steps);
 
    Compose(keyContext, builder, gatherer,
            /* addInnerToKey= */ [&]() -> void {
                LocalMatrixShaderBlock::BeginBlock(newContext, builder, gatherer, lmShaderData);
                    YUVImageShaderBlock::AddBlock(newContext, builder, gatherer, imgData);
                builder->endBlock();
            },
            /* addOuterToKey= */ [&]() -> void {
                ColorSpaceTransformBlock::AddBlock(keyContext, builder, gatherer, data);
            });
}

◆ AddBlendModeColorFilter()

void skgpu::graphite::AddBlendModeColorFilter	(	const KeyContext &	,
		PaintParamsKeyBuilder *	,
		PipelineDataGatherer *	,
		SkBlendMode	,
		const SkPMColor4f &	srcColor
	)

Blend mode color filters blend their input (as the dst color) with some given color (supplied via a uniform) as the src color.

Definition at line 1058 of file KeyHelpers.cpp.

                                                          {
    Blend(keyContext, builder, gatherer,
          /* addBlendToKey= */ [&] () -> void {
              // Note, we're playing a bit of a game here. By explicitly adding a
              // BlendModeBlenderBlock we're always forcing the SkSL to call 'sk_blend'
              // rather than allowing it to sometimes call 'blend_porter_duff'. This reduces
              // the number of shader combinations and allows the pre-compilation system to more
              // easily match the rendering path.
              BlendModeBlenderBlock::AddBlock(keyContext, builder, gatherer, bm);
          },
          /* addSrcToKey= */ [&]() -> void {
              SolidColorShaderBlock::AddBlock(keyContext, builder, gatherer, srcColor);
          },
          /* addDstToKey= */ [&]() -> void {
              builder->addBlock(BuiltInCodeSnippetID::kPriorOutput);
          });
}

◆ AddDitherBlock()

void skgpu::graphite::AddDitherBlock	(	const KeyContext &	keyContext,
		PaintParamsKeyBuilder *	builder,
		PipelineDataGatherer *	gatherer,
		SkColorType	ct
	)

Definition at line 168 of file PaintParams.cpp.

                                    {
    static const SkBitmap gLUT = skgpu::MakeDitherLUT();
 
    sk_sp<TextureProxy> proxy = RecorderPriv::CreateCachedProxy(keyContext.recorder(), gLUT,
                                                                "DitherLUT");
    if (keyContext.recorder() && !proxy) {
        SKGPU_LOG_W("Couldn't create dither shader's LUT");
        builder->addBlock(BuiltInCodeSnippetID::kPriorOutput);
        return;
    }
 
    DitherShaderBlock::DitherData data(skgpu::DitherRangeForConfig(ct), std::move(proxy));
 
    DitherShaderBlock::AddBlock(keyContext, builder, gatherer, data);
}

◆ AddDstReadBlock()

void skgpu::graphite::AddDstReadBlock	(	const KeyContext &	keyContext,
		PaintParamsKeyBuilder *	builder,
		PipelineDataGatherer *	gatherer,
		DstReadRequirement	dstReadReq
	)

Definition at line 148 of file PaintParams.cpp.

                                                    {
    switch(dstReadReq) {
        case DstReadRequirement::kNone:
            SkASSERT(false);            // This should never be reached
            return;
        case DstReadRequirement::kTextureCopy:
            [[fallthrough]];
        case DstReadRequirement::kTextureSample:
            DstReadSampleBlock::AddBlock(keyContext, builder, gatherer, keyContext.dstTexture(),
                                         keyContext.dstOffset());
            break;
        case DstReadRequirement::kFramebufferFetch:
            builder->addBlock(BuiltInCodeSnippetID::kDstReadFetch);
            break;
    }
}

◆ AddKnownModeBlend()

void skgpu::graphite::AddKnownModeBlend	(	const KeyContext &	keyContext,
		PaintParamsKeyBuilder *	builder,
		PipelineDataGatherer *	gatherer,
		SkBlendMode	bm
	)

Definition at line 126 of file PaintParams.cpp.

                                       {
    SkASSERT(bm <= SkBlendMode::kLastCoeffMode);
    BuiltInCodeSnippetID id = static_cast<BuiltInCodeSnippetID>(kFixedFunctionBlendModeIDOffset +
                                                                static_cast<int>(bm));
    builder->addBlock(id);
}

◆ AddModeBlend()

void skgpu::graphite::AddModeBlend	(	const KeyContext &	keyContext,
		PaintParamsKeyBuilder *	builder,
		PipelineDataGatherer *	gatherer,
		SkBlendMode	bm
	)

Definition at line 136 of file PaintParams.cpp.

                                  {
    SkSpan<const float> coeffs = skgpu::GetPorterDuffBlendConstants(bm);
    if (!coeffs.empty()) {
        CoeffBlenderBlock::AddBlock(keyContext, builder, gatherer, coeffs);
    } else {
        BlendModeBlenderBlock::AddBlock(keyContext, builder, gatherer, bm);
    }
}

◆ AddToKey() [1/3]

void skgpu::graphite::AddToKey	(	const KeyContext &	keyContext,
		PaintParamsKeyBuilder *	builder,
		PipelineDataGatherer *	gatherer,
		const SkBlender *	blender
	)

Definition at line 1269 of file KeyHelpers.cpp.

                                        {
    if (!blender) {
        return;
    }
    switch (as_BB(blender)->type()) {
#define M(type)                                                     \
    case SkBlenderBase::BlenderType::k##type:                       \
        add_to_key(keyContext,                                      \
                   builder,                                         \
                   gatherer,                                        \
                   static_cast<const Sk##type##Blender*>(blender)); \
        return;
        SK_ALL_BLENDERS(M)
#undef M
    }
    SkUNREACHABLE;
}

◆ AddToKey() [2/3]

void skgpu::graphite::AddToKey	(	const KeyContext &	keyContext,
		PaintParamsKeyBuilder *	builder,
		PipelineDataGatherer *	gatherer,
		const SkColorFilter *	filter
	)

Add implementation details, for the specified backend, of this SkColorFilter to the provided key.

Parameters

keyContext	backend context for key creation
builder	builder for creating the key for this SkShader
gatherer	if non-null, storage for this colorFilter's data
filter	This function is a no-op if filter is null.

Definition at line 1450 of file KeyHelpers.cpp.

                                           {
    if (!filter) {
        return;
    }
    switch (as_CFB(filter)->type()) {
    case SkColorFilterBase::Type::kNoop:
        // Return the input color as-is.
        builder->addBlock(BuiltInCodeSnippetID::kPriorOutput);
        return;
#define M(type)                                                        \
    case SkColorFilterBase::Type::k##type:                             \
        add_to_key(keyContext,                                         \
                   builder,                                            \
                   gatherer,                                           \
                   static_cast<const Sk##type##ColorFilter*>(filter)); \
        return;
        SK_ALL_COLOR_FILTERS(M)
#undef M
    }
    SkUNREACHABLE;
}

◆ AddToKey() [3/3]

void skgpu::graphite::AddToKey	(	const KeyContext &	keyContext,
		PaintParamsKeyBuilder *	builder,
		PipelineDataGatherer *	gatherer,
		const SkShader *	shader
	)

Add implementation details, for the specified backend, of this SkShader to the provided key.

Parameters

keyContext	backend context for key creation
builder	builder for creating the key for this SkShader
gatherer	if non-null, storage for this colorFilter's data
shader	This function is a no-op if shader is null.

Definition at line 2429 of file KeyHelpers.cpp.

                                      {
    if (!shader) {
        return;
    }
    switch (as_SB(shader)->type()) {
#define M(type)                                                        \
    case SkShaderBase::ShaderType::k##type:                            \
        add_to_key(keyContext,                                         \
                   builder,                                            \
                   gatherer,                                           \
                   static_cast<const Sk##type##Shader*>(shader)); \
        return;
        SK_ALL_SHADERS(M)
#undef M
    }
    SkUNREACHABLE;
}

◆ adjust_for_matrix_type()

static std::pair< SkSLType, int > skgpu::graphite::adjust_for_matrix_type	(	SkSLType	type,
		int	count
	)

static

Definition at line 74 of file UniformManager.cpp.

                                                                               {
    // All Layouts flatten matrices and arrays of matrices into arrays of columns, so update
    // 'type' to be the column type and either multiply 'count' by the number of columns for
    // arrays of matrices, or set to exactly the number of columns for a "non-array" matrix.
    switch(type) {
        case SkSLType::kFloat2x2: return {SkSLType::kFloat2, 2*std::max(1, count)};
        case SkSLType::kFloat3x3: return {SkSLType::kFloat3, 3*std::max(1, count)};
        case SkSLType::kFloat4x4: return {SkSLType::kFloat4, 4*std::max(1, count)};
 
        case SkSLType::kHalf2x2:  return {SkSLType::kHalf2,  2*std::max(1, count)};
        case SkSLType::kHalf3x3:  return {SkSLType::kHalf3,  3*std::max(1, count)};
        case SkSLType::kHalf4x4:  return {SkSLType::kHalf4,  4*std::max(1, count)};
 
        // Otherwise leave type and count alone.
        default:                  return {type, count};
    }
}

◆ append_color_output()

void skgpu::graphite::append_color_output	(	std::string *	mainBody,
		BlendFormula::OutputType	outputType,
		const char *	outColor,
		const char *	inColor
	)

Definition at line 242 of file ShaderCodeDictionary.cpp.

                                              {
    switch (outputType) {
        case BlendFormula::kNone_OutputType:
            SkSL::String::appendf(mainBody, "%s = half4(0.0);", outColor);
            break;
        case BlendFormula::kCoverage_OutputType:
            SkSL::String::appendf(mainBody, "%s = outputCoverage;", outColor);
            break;
        case BlendFormula::kModulate_OutputType:
            SkSL::String::appendf(mainBody, "%s = %s * outputCoverage;", outColor, inColor);
            break;
        case BlendFormula::kSAModulate_OutputType:
            SkSL::String::appendf(mainBody, "%s = %s.a * outputCoverage;", outColor, inColor);
            break;
        case BlendFormula::kISAModulate_OutputType:
            SkSL::String::appendf(
                    mainBody, "%s = (1.0 - %s.a) * outputCoverage;", outColor, inColor);
            break;
        case BlendFormula::kISCModulate_OutputType:
            SkSL::String::appendf(
                    mainBody, "%s = (half4(1.0) - %s) * outputCoverage;", outColor, inColor);
            break;
        default:
            SkUNREACHABLE;
            break;
    }
}

◆ AsView() [1/2]

TextureProxyView skgpu::graphite::AsView ( const SkImage * image )

Definition at line 839 of file TextureUtils.cpp.

                                              {
    if (!image) {
        return {};
    }
    if (!as_IB(image)->isGraphiteBacked()) {
        return {};
    }
    // A YUVA image (even if backed by graphite textures) is not a single texture
    if (as_IB(image)->isYUVA()) {
        return {};
    }
 
    auto gi = reinterpret_cast<const Image*>(image);
    return gi->textureProxyView();
}

◆ AsView() [2/2]

TextureProxyView skgpu::graphite::AsView ( sk_sp< SkImage > image )

inline

Definition at line 88 of file TextureUtils.h.

88{ return AsView(image.get()); }

skgpu::graphite::AsView

TextureProxyView AsView(sk_sp< SkImage > image)

Definition: TextureUtils.h:88

◆ attrib_type_to_vkformat()

static VkFormat skgpu::graphite::attrib_type_to_vkformat ( VertexAttribType type )

inlinestatic

Definition at line 34 of file VulkanGraphicsPipeline.cpp.

                                                                      {
    switch (type) {
        case VertexAttribType::kFloat:
            return VK_FORMAT_R32_SFLOAT;
        case VertexAttribType::kFloat2:
            return VK_FORMAT_R32G32_SFLOAT;
        case VertexAttribType::kFloat3:
            return VK_FORMAT_R32G32B32_SFLOAT;
        case VertexAttribType::kFloat4:
            return VK_FORMAT_R32G32B32A32_SFLOAT;
        case VertexAttribType::kHalf:
            return VK_FORMAT_R16_SFLOAT;
        case VertexAttribType::kHalf2:
            return VK_FORMAT_R16G16_SFLOAT;
        case VertexAttribType::kHalf4:
            return VK_FORMAT_R16G16B16A16_SFLOAT;
        case VertexAttribType::kInt2:
            return VK_FORMAT_R32G32_SINT;
        case VertexAttribType::kInt3:
            return VK_FORMAT_R32G32B32_SINT;
        case VertexAttribType::kInt4:
            return VK_FORMAT_R32G32B32A32_SINT;
        case VertexAttribType::kByte:
            return VK_FORMAT_R8_SINT;
        case VertexAttribType::kByte2:
            return VK_FORMAT_R8G8_SINT;
        case VertexAttribType::kByte4:
            return VK_FORMAT_R8G8B8A8_SINT;
        case VertexAttribType::kUByte:
            return VK_FORMAT_R8_UINT;
        case VertexAttribType::kUByte2:
            return VK_FORMAT_R8G8_UINT;
        case VertexAttribType::kUByte4:
            return VK_FORMAT_R8G8B8A8_UINT;
        case VertexAttribType::kUByte_norm:
            return VK_FORMAT_R8_UNORM;
        case VertexAttribType::kUByte4_norm:
            return VK_FORMAT_R8G8B8A8_UNORM;
        case VertexAttribType::kShort2:
            return VK_FORMAT_R16G16_SINT;
        case VertexAttribType::kShort4:
            return VK_FORMAT_R16G16B16A16_SINT;
        case VertexAttribType::kUShort2:
            return VK_FORMAT_R16G16_UINT;
        case VertexAttribType::kUShort2_norm:
            return VK_FORMAT_R16G16_UNORM;
        case VertexAttribType::kInt:
            return VK_FORMAT_R32_SINT;
        case VertexAttribType::kUInt:
            return VK_FORMAT_R32_UINT;
        case VertexAttribType::kUShort_norm:
            return VK_FORMAT_R16_UNORM;
        case VertexAttribType::kUShort4_norm:
            return VK_FORMAT_R16G16B16A16_UNORM;
    }
    SK_ABORT("Unknown vertex attrib type");
}

◆ Blend()

void skgpu::graphite::Blend	(	const KeyContext &	keyContext,
		PaintParamsKeyBuilder *	keyBuilder,
		PipelineDataGatherer *	gatherer,
		AddToKeyFn	addBlendToKey,
		AddToKeyFn	addSrcToKey,
		AddToKeyFn	addDstToKey
	)

Definition at line 95 of file PaintParams.cpp.

                                   {
    BlendShaderBlock::BeginBlock(keyContext, keyBuilder, gatherer);
 
        addSrcToKey();
 
        addDstToKey();
 
        addBlendToKey();
 
    keyBuilder->endBlock();  // BlendShaderBlock
}

◆ blend_coeff_to_vk_blend()

static VkBlendFactor skgpu::graphite::blend_coeff_to_vk_blend ( skgpu::BlendCoeff coeff )

static

Definition at line 288 of file VulkanGraphicsPipeline.cpp.

                                                                    {
    switch (coeff) {
        case skgpu::BlendCoeff::kZero:
            return VK_BLEND_FACTOR_ZERO;
        case skgpu::BlendCoeff::kOne:
            return VK_BLEND_FACTOR_ONE;
        case skgpu::BlendCoeff::kSC:
            return VK_BLEND_FACTOR_SRC_COLOR;
        case skgpu::BlendCoeff::kISC:
            return VK_BLEND_FACTOR_ONE_MINUS_SRC_COLOR;
        case skgpu::BlendCoeff::kDC:
            return VK_BLEND_FACTOR_DST_COLOR;
        case skgpu::BlendCoeff::kIDC:
            return VK_BLEND_FACTOR_ONE_MINUS_DST_COLOR;
        case skgpu::BlendCoeff::kSA:
            return VK_BLEND_FACTOR_SRC_ALPHA;
        case skgpu::BlendCoeff::kISA:
            return VK_BLEND_FACTOR_ONE_MINUS_SRC_ALPHA;
        case skgpu::BlendCoeff::kDA:
            return VK_BLEND_FACTOR_DST_ALPHA;
        case skgpu::BlendCoeff::kIDA:
            return VK_BLEND_FACTOR_ONE_MINUS_DST_ALPHA;
        case skgpu::BlendCoeff::kConstC:
            return VK_BLEND_FACTOR_CONSTANT_COLOR;
        case skgpu::BlendCoeff::kIConstC:
            return VK_BLEND_FACTOR_ONE_MINUS_CONSTANT_COLOR;
        case skgpu::BlendCoeff::kS2C:
            return VK_BLEND_FACTOR_SRC1_COLOR;
        case skgpu::BlendCoeff::kIS2C:
            return VK_BLEND_FACTOR_ONE_MINUS_SRC1_COLOR;
        case skgpu::BlendCoeff::kS2A:
            return VK_BLEND_FACTOR_SRC1_ALPHA;
        case skgpu::BlendCoeff::kIS2A:
            return VK_BLEND_FACTOR_ONE_MINUS_SRC1_ALPHA;
        case skgpu::BlendCoeff::kIllegal:
            return VK_BLEND_FACTOR_ZERO;
    }
    SkUNREACHABLE;
}

◆ blend_equation_to_vk_blend_op()

static VkBlendOp skgpu::graphite::blend_equation_to_vk_blend_op ( skgpu::BlendEquation equation )

static

Definition at line 328 of file VulkanGraphicsPipeline.cpp.

                                                                            {
    static const VkBlendOp gTable[] = {
        // Basic blend ops
        VK_BLEND_OP_ADD,
        VK_BLEND_OP_SUBTRACT,
        VK_BLEND_OP_REVERSE_SUBTRACT,
 
        // Advanced blend ops
        VK_BLEND_OP_SCREEN_EXT,
        VK_BLEND_OP_OVERLAY_EXT,
        VK_BLEND_OP_DARKEN_EXT,
        VK_BLEND_OP_LIGHTEN_EXT,
        VK_BLEND_OP_COLORDODGE_EXT,
        VK_BLEND_OP_COLORBURN_EXT,
        VK_BLEND_OP_HARDLIGHT_EXT,
        VK_BLEND_OP_SOFTLIGHT_EXT,
        VK_BLEND_OP_DIFFERENCE_EXT,
        VK_BLEND_OP_EXCLUSION_EXT,
        VK_BLEND_OP_MULTIPLY_EXT,
        VK_BLEND_OP_HSL_HUE_EXT,
        VK_BLEND_OP_HSL_SATURATION_EXT,
        VK_BLEND_OP_HSL_COLOR_EXT,
        VK_BLEND_OP_HSL_LUMINOSITY_EXT,
 
        // Illegal.
        VK_BLEND_OP_ADD,
    };
    static_assert(0 == (int)skgpu::BlendEquation::kAdd);
    static_assert(1 == (int)skgpu::BlendEquation::kSubtract);
    static_assert(2 == (int)skgpu::BlendEquation::kReverseSubtract);
    static_assert(3 == (int)skgpu::BlendEquation::kScreen);
    static_assert(4 == (int)skgpu::BlendEquation::kOverlay);
    static_assert(5 == (int)skgpu::BlendEquation::kDarken);
    static_assert(6 == (int)skgpu::BlendEquation::kLighten);
    static_assert(7 == (int)skgpu::BlendEquation::kColorDodge);
    static_assert(8 == (int)skgpu::BlendEquation::kColorBurn);
    static_assert(9 == (int)skgpu::BlendEquation::kHardLight);
    static_assert(10 == (int)skgpu::BlendEquation::kSoftLight);
    static_assert(11 == (int)skgpu::BlendEquation::kDifference);
    static_assert(12 == (int)skgpu::BlendEquation::kExclusion);
    static_assert(13 == (int)skgpu::BlendEquation::kMultiply);
    static_assert(14 == (int)skgpu::BlendEquation::kHSLHue);
    static_assert(15 == (int)skgpu::BlendEquation::kHSLSaturation);
    static_assert(16 == (int)skgpu::BlendEquation::kHSLColor);
    static_assert(17 == (int)skgpu::BlendEquation::kHSLLuminosity);
    static_assert(std::size(gTable) == skgpu::kBlendEquationCnt);
 
    SkASSERT((unsigned)equation < skgpu::kBlendEquationCnt);
    return gTable[(int)equation];
}

◆ BuildComputeSkSL()

std::string skgpu::graphite::BuildComputeSkSL	(	const Caps *	caps,
		const ComputeStep *	step
	)

Definition at line 605 of file ContextUtils.cpp.

                                                                      {
    std::string sksl =
            SkSL::String::printf("layout(local_size_x=%u, local_size_y=%u, local_size_z=%u) in;\n",
                                 step->localDispatchSize().fWidth,
                                 step->localDispatchSize().fHeight,
                                 step->localDispatchSize().fDepth);
 
    const auto& bindingReqs = caps->resourceBindingRequirements();
    bool distinctRanges = bindingReqs.fDistinctIndexRanges;
    bool separateSampler = bindingReqs.fSeparateTextureAndSamplerBinding;
 
    int index = 0;
    int texIdx = 0;
    // NOTE: SkSL Metal codegen always assigns the same binding index to a texture and its sampler.
    // TODO: This could cause sampler indices to not be tightly packed if the sampler2D declaration
    // comes after 1 or more storage texture declarations (which don't have samplers). An optional
    // "layout(msl, sampler=T, texture=T)" syntax to count them separately (like we do for WGSL)
    // could come in handy here but it's not supported in MSL codegen yet.
 
    for (const ComputeStep::ResourceDesc& r : step->resources()) {
        using Type = ComputeStep::ResourceType;
        switch (r.fType) {
            case Type::kUniformBuffer:
                SkSL::String::appendf(&sksl, "layout(binding=%d) uniform ", index++);
                sksl += r.fSkSL;
                break;
            case Type::kStorageBuffer:
            case Type::kIndirectBuffer:
                SkSL::String::appendf(&sksl, "layout(binding=%d) buffer ", index++);
                sksl += r.fSkSL;
                break;
            case Type::kReadOnlyStorageBuffer:
                SkSL::String::appendf(&sksl, "layout(binding=%d) readonly buffer ", index++);
                sksl += r.fSkSL;
                break;
            case Type::kWriteOnlyStorageTexture:
                SkSL::String::appendf(&sksl, "layout(binding=%d, rgba8) writeonly texture2D ",
                                      distinctRanges ? texIdx++ : index++);
                sksl += r.fSkSL;
                break;
            case Type::kReadOnlyTexture:
                SkSL::String::appendf(&sksl, "layout(binding=%d, rgba8) readonly texture2D ",
                                      distinctRanges ? texIdx++ : index++);
                sksl += r.fSkSL;
                break;
            case Type::kSampledTexture:
                if (distinctRanges) {
                    SkSL::String::appendf(&sksl, "layout(metal, binding=%d) ", texIdx++);
                } else if (separateSampler) {
                    SkSL::String::appendf(
                            &sksl, "layout(webgpu, sampler=%d, texture=%d) ", index, index + 1);
                    index += 2;
                } else {
                    SkSL::String::appendf(&sksl, "layout(binding=%d) ", index++);
                }
                sksl += "sampler2D ";
                sksl += r.fSkSL;
                break;
        }
        sksl += ";\n";
    }
 
    sksl += step->computeSkSL();
    return sksl;
}

◆ BuildFragmentSkSL()

FragSkSLInfo skgpu::graphite::BuildFragmentSkSL	(	const Caps *	caps,
		const ShaderCodeDictionary *	dict,
		const RuntimeEffectDictionary *	rteDict,
		const RenderStep *	step,
		UniquePaintParamsID	paintID,
		bool	useStorageBuffers,
		skgpu::Swizzle	writeSwizzle
	)

Definition at line 552 of file ContextUtils.cpp.

                                                          {
    FragSkSLInfo result;
    if (!paintID.isValid()) {
        // Depth-only draw so no fragment shader to compile
        return {};
    }
 
    const char* shadingSsboIndex =
            useStorageBuffers && step->performsShading() ? "shadingSsboIndex" : nullptr;
    ShaderInfo shaderInfo(paintID, dict, rteDict, shadingSsboIndex);
 
    result.fSkSL = shaderInfo.toSkSL(caps,
                                     step,
                                     useStorageBuffers,
                                     &result.fNumTexturesAndSamplers,
                                     &result.fNumPaintUniforms,
                                     &result.fRenderStepUniformsTotalBytes,
                                     &result.fPaintUniformsTotalBytes,
                                     &result.fHasGradientBuffer,
                                     writeSwizzle);
 
    // Extract blend info after integrating the RenderStep into the final fragment shader in case
    // that changes the HW blending choice to handle analytic coverage.
    result.fBlendInfo = shaderInfo.blendInfo();
    result.fRequiresLocalCoords = shaderInfo.needsLocalCoords();
    result.fData = {shaderInfo.data()};
    result.fLabel = writeSwizzle.asString().c_str();
    result.fLabel += " + ";
    result.fLabel = step->name();
    result.fLabel += " + ";
    result.fLabel += dict->idToString(paintID).c_str();
 
    return result;
}

◆ BuildVertexSkSL()

VertSkSLInfo skgpu::graphite::BuildVertexSkSL	(	const ResourceBindingRequirements &	bindingReqs,
		const RenderStep *	step,
		bool	useStorageBuffers,
		bool	defineLocalCoordsVarying
	)

Definition at line 466 of file ContextUtils.cpp.

                                                           {
    VertSkSLInfo result;
 
    const bool hasStepUniforms = step->numUniforms() > 0;
    const bool useStepStorageBuffer = useStorageBuffers && hasStepUniforms;
    const bool useShadingStorageBuffer = useStorageBuffers && step->performsShading();
 
    // TODO: To more completely support end-to-end rendering, this will need to be updated so that
    // the RenderStep shader snippet can produce a device coord, a local coord, and depth.
    // If the paint combination doesn't need the local coord it can be ignored, otherwise we need
    // a varying for it. The fragment function's output will need to be updated to have a color and
    // the depth, or when there's no combination, just the depth. Lastly, we also should add the
    // static/intrinsic uniform binding point so that we can handle normalizing the device position
    // produced by the RenderStep automatically.
 
    // Fixed program header
    std::string sksl =
        "layout (binding=0) uniform intrinsicUniforms {\n"
        "    layout(offset=0) float4 rtAdjust;\n"
        "};\n"
        "\n";
 
    if (step->numVertexAttributes() > 0 || step->numInstanceAttributes() > 0) {
        sksl += emit_attributes(step->vertexAttributes(), step->instanceAttributes());
    }
 
    // Uniforms needed by RenderStep
    // The uniforms are mangled by having their index in 'fEntries' as a suffix (i.e., "_%d")
    // TODO: replace hard-coded bufferID with the backend's renderstep uniform-buffer index.
    if (hasStepUniforms) {
        if (useStepStorageBuffer) {
            sksl += EmitRenderStepStorageBuffer(/* bufferID= */ 1, step->uniforms());
        } else {
            sksl += EmitRenderStepUniforms(/* bufferID= */ 1,
                                           bindingReqs.fUniformBufferLayout,
                                           step->uniforms(),
                                           &result.fRenderStepUniformsTotalBytes);
        }
    }
 
    // Varyings needed by RenderStep
    sksl += EmitVaryings(step, "out", useShadingStorageBuffer, defineLocalCoordsVarying);
 
    // Vertex shader function declaration
    sksl += "void main() {";
    // Create stepLocalCoords which render steps can write to.
    sksl += "float2 stepLocalCoords = float2(0);";
    // Vertex shader body
    if (useStepStorageBuffer) {
        // Extract out render step uniforms from SSBO, declaring local variables with the expected
        // uniform names so that RenderStep SkSL is independent of storage choice.
        SkSL::String::appendf(
                &sksl, "uint stepSsboIndex = %s.x;\n", RenderStep::ssboIndicesAttribute());
        sksl += EmitUniformsFromStorageBuffer("step", "stepSsboIndex", step->uniforms());
    }
 
    sksl += step->vertexSkSL();
    sksl += "sk_Position = float4(devPosition.xy * rtAdjust.xy + devPosition.ww * rtAdjust.zw,"
            "devPosition.zw);";
 
    if (useShadingStorageBuffer) {
        // Assign SSBO index values to the SSBO index varying.
        SkSL::String::appendf(&sksl,
                              "%s = %s;",
                              RenderStep::ssboIndicesVarying(),
                              RenderStep::ssboIndicesAttribute());
    }
 
    if (defineLocalCoordsVarying) {
        // Assign Render Step's stepLocalCoords to the localCoordsVar varying.
        sksl += "localCoordsVar = stepLocalCoords;";
    }
    sksl += "}";
 
    result.fSkSL = std::move(sksl);
    result.fLabel = step->name();
    if (defineLocalCoordsVarying) {
        result.fLabel += " (w/ local coords)";
    }
 
    return result;
}

◆ can_do_yuv_tiling_in_hw()

static bool skgpu::graphite::can_do_yuv_tiling_in_hw	(	const Caps *	caps,
		const YUVImageShaderBlock::ImageData &	imgData
	)

static

Definition at line 784 of file KeyHelpers.cpp.

                                                                                 {
    if (!caps->clampToBorderSupport() && (imgData.fTileModes[0] == SkTileMode::kDecal ||
                                          imgData.fTileModes[1] == SkTileMode::kDecal)) {
        return false;
    }
    // We depend on the subset code to handle cases where the UV dimensions times the
    // subsample factors are not equal to the Y dimensions.
    if (imgData.fImgSize != imgData.fImgSizeUV) {
        return false;
    }
    // For nearest filtering when the Y texture size is larger than the UV texture size,
    // we use linear filtering for the UV texture. In this case we also adjust pixel centers
    // which may affect dependent texture reads.
    if (imgData.fSampling.filter != imgData.fSamplingUV.filter) {
        return false;
    }
    return imgData.fSubset.contains(SkRect::Make(imgData.fImgSize));
}

◆ check_max_blit_width()

static bool skgpu::graphite::check_max_blit_width ( int widthInPixels )

static

Definition at line 779 of file MtlCommandBuffer.mm.

                                                    {
    if (widthInPixels > 32767) {
        SkASSERT(false); // surfaces should not be this wide anyway
        return false;
    }
    return true;
}

◆ check_shader_module()

static bool skgpu::graphite::check_shader_module	(	const DawnSharedContext *	sharedContext,
		wgpu::ShaderModule *	module,
		const char *	shaderText,
		ShaderErrorHandler *	errorHandler
	)

static

Definition at line 94 of file DawnGraphiteUtils.cpp.

                                                                  {
    // Prior to emsdk 3.1.51 wgpu::ShaderModule::GetCompilationInfo is unimplemented.
#if defined(__EMSCRIPTEN__)                                      &&  \
        ((__EMSCRIPTEN_major__ <  3                               || \
         (__EMSCRIPTEN_major__ == 3 && __EMSCRIPTEN_minor__ <  1) || \
         (__EMSCRIPTEN_major__ == 3 && __EMSCRIPTEN_minor__ == 1 && __EMSCRIPTEN_tiny__ < 51)))
    return true;
#else
    struct Handler {
        static void Fn(WGPUCompilationInfoRequestStatus status,
                       const WGPUCompilationInfo* info,
                       void* userdata) {
            Handler* self = reinterpret_cast<Handler*>(userdata);
            SkASSERT(status == WGPUCompilationInfoRequestStatus_Success);
 
            // Walk the message list and check for hard errors.
            self->fSuccess = true;
            for (size_t index = 0; index < info->messageCount; ++index) {
                const WGPUCompilationMessage& entry = info->messages[index];
                if (entry.type == WGPUCompilationMessageType_Error) {
                    self->fSuccess = false;
                    break;
                }
            }
 
            // If we found a hard error, report the compilation messages to the error handler.
            if (!self->fSuccess) {
                std::string errors;
                for (size_t index = 0; index < info->messageCount; ++index) {
                    const WGPUCompilationMessage& entry = info->messages[index];
                    errors += "line " +
                              std::to_string(entry.lineNum) + ':' +
                              std::to_string(entry.linePos) + ' ' +
                              entry.message + '\n';
                }
                self->fErrorHandler->compileError(
                        self->fShaderText, errors.c_str(), /*shaderWasCached=*/false);
            }
        }
 
        const char* fShaderText;
        ShaderErrorHandler* fErrorHandler;
        bool fSuccess = false;
    };
 
    Handler handler;
    handler.fShaderText = shaderText;
    handler.fErrorHandler = errorHandler;
#if defined(__EMSCRIPTEN__)
    // Deprecated function.
    module->GetCompilationInfo(&Handler::Fn, &handler);
#else
    // New API.
    wgpu::FutureWaitInfo waitInfo{};
    waitInfo.future = module->GetCompilationInfo(
            wgpu::CallbackMode::WaitAnyOnly,
            [handlerPtr = &handler](wgpu::CompilationInfoRequestStatus status,
                                    const wgpu::CompilationInfo* info) {
                Handler::Fn(static_cast<WGPUCompilationInfoRequestStatus>(status),
                            reinterpret_cast<const WGPUCompilationInfo*>(info),
                            handlerPtr);
            });
 
    const auto& instance = static_cast<const DawnSharedContext*>(sharedContext)
                                   ->device()
                                   .GetAdapter()
                                   .GetInstance();
    [[maybe_unused]] auto status =
            instance.WaitAny(1, &waitInfo, /*timeoutNS=*/std::numeric_limits<uint64_t>::max());
    SkASSERT(status == wgpu::WaitStatus::Success);
#endif  // defined(__EMSCRIPTEN__)
 
    return handler.fSuccess;
#endif
}

◆ color_type_fallback()

static SkColorType skgpu::graphite::color_type_fallback ( SkColorType ct )

inlinestatic

Definition at line 92 of file Caps.cpp.

                                                              {
    switch (ct) {
        // kRGBA_8888 is our default fallback for many color types that may not have renderable
        // backend formats.
        case kAlpha_8_SkColorType:
        case kRGB_565_SkColorType:
        case kARGB_4444_SkColorType:
        case kBGRA_8888_SkColorType:
        case kRGBA_1010102_SkColorType:
        case kBGRA_1010102_SkColorType:
        case kRGBA_F16_SkColorType:
        case kRGBA_F16Norm_SkColorType:
            return kRGBA_8888_SkColorType;
        case kA16_float_SkColorType:
            return kRGBA_F16_SkColorType;
        case kGray_8_SkColorType:
            return kRGB_888x_SkColorType;
        default:
            return kUnknown_SkColorType;
    }
}

◆ compare_op_to_vk_compare_op()

static VkCompareOp skgpu::graphite::compare_op_to_vk_compare_op ( CompareOp op )

static

Definition at line 195 of file VulkanGraphicsPipeline.cpp.

                                                             {
    static const VkCompareOp gTable[] = {
        VK_COMPARE_OP_ALWAYS,              // kAlways
        VK_COMPARE_OP_NEVER,               // kNever
        VK_COMPARE_OP_GREATER,             // kGreater
        VK_COMPARE_OP_GREATER_OR_EQUAL,    // kGEqual
        VK_COMPARE_OP_LESS,                // kLess
        VK_COMPARE_OP_LESS_OR_EQUAL,       // kLEqual
        VK_COMPARE_OP_EQUAL,               // kEqual
        VK_COMPARE_OP_NOT_EQUAL,           // kNotEqual
    };
    static_assert(std::size(gTable) == kCompareOpCount);
    static_assert(0 == (int)CompareOp::kAlways);
    static_assert(1 == (int)CompareOp::kNever);
    static_assert(2 == (int)CompareOp::kGreater);
    static_assert(3 == (int)CompareOp::kGEqual);
    static_assert(4 == (int)CompareOp::kLess);
    static_assert(5 == (int)CompareOp::kLEqual);
    static_assert(6 == (int)CompareOp::kEqual);
    static_assert(7 == (int)CompareOp::kNotEqual);
    SkASSERT(op < (CompareOp)kCompareOpCount);
 
    return gTable[(int)op];
}

◆ Compose()

void skgpu::graphite::Compose	(	const KeyContext &	keyContext,
		PaintParamsKeyBuilder *	keyBuilder,
		PipelineDataGatherer *	gatherer,
		AddToKeyFn	addInnerToKey,
		AddToKeyFn	addOuterToKey
	)

Definition at line 112 of file PaintParams.cpp.

                                       {
    ComposeBlock::BeginBlock(keyContext, keyBuilder, gatherer);
 
        addInnerToKey();
 
        addOuterToKey();
 
    keyBuilder->endBlock();  // ComposeBlock
}

◆ compute_combined_buffer_size()

std::pair< size_t, size_t > skgpu::graphite::compute_combined_buffer_size	(	const Caps *	caps,
		int	mipLevelCount,
		size_t	bytesPerBlock,
		const SkISize &	baseDimensions,
		SkTextureCompressionType	compressionType,
		TArray< std::pair< size_t, size_t > > *	levelOffsetsAndRowBytes
	)

Definition at line 49 of file UploadTask.cpp.

                                                                  {
    SkASSERT(levelOffsetsAndRowBytes && !levelOffsetsAndRowBytes->size());
    SkASSERT(mipLevelCount >= 1);
 
    SkISize compressedBlockDimensions = CompressedDimensionsInBlocks(compressionType,
                                                                     baseDimensions);
 
    size_t minTransferBufferAlignment =
            std::max(bytesPerBlock, caps->requiredTransferBufferAlignment());
    size_t alignedBytesPerRow =
            caps->getAlignedTextureDataRowBytes(compressedBlockDimensions.width() * bytesPerBlock);
 
    levelOffsetsAndRowBytes->push_back({0, alignedBytesPerRow});
    size_t combinedBufferSize = SkAlignTo(alignedBytesPerRow * baseDimensions.height(),
                                          minTransferBufferAlignment);
    SkISize levelDimensions = baseDimensions;
 
    for (int currentMipLevel = 1; currentMipLevel < mipLevelCount; ++currentMipLevel) {
        levelDimensions = {std::max(1, levelDimensions.width() / 2),
                           std::max(1, levelDimensions.height() / 2)};
        compressedBlockDimensions = CompressedDimensionsInBlocks(compressionType, levelDimensions);
        alignedBytesPerRow = caps->getAlignedTextureDataRowBytes(
                compressedBlockDimensions.width() * bytesPerBlock);
        size_t alignedSize = SkAlignTo(alignedBytesPerRow * compressedBlockDimensions.height(),
                                       minTransferBufferAlignment);
        SkASSERT(combinedBufferSize % minTransferBufferAlignment == 0);
 
        levelOffsetsAndRowBytes->push_back({combinedBufferSize, alignedBytesPerRow});
        combinedBufferSize += alignedSize;
    }
 
    SkASSERT(levelOffsetsAndRowBytes->size() == mipLevelCount);
    SkASSERT(combinedBufferSize % minTransferBufferAlignment == 0);
    return {combinedBufferSize, minTransferBufferAlignment};
}

◆ ComputeShaderCoverageMaskTargetFormat()

SkColorType skgpu::graphite::ComputeShaderCoverageMaskTargetFormat ( const Caps * caps )

Definition at line 855 of file TextureUtils.cpp.

                                                                    {
    // GPU compute coverage mask renderers need to bind the mask texture as a storage binding, which
    // support a limited set of color formats. In general, we use RGBA8 if Alpha8 can't be
    // supported.
    if (caps->isStorage(caps->getDefaultStorageTextureInfo(kAlpha_8_SkColorType))) {
        return kAlpha_8_SkColorType;
    }
    return kRGBA_8888_SkColorType;
}

◆ ComputeSize()

size_t skgpu::graphite::ComputeSize	(	SkISize	dimensions,
		const TextureInfo &	info
	)

Definition at line 535 of file TextureUtils.cpp.

                                            {
 
    SkTextureCompressionType compression = info.compressionType();
 
    size_t colorSize = 0;
 
    if (compression != SkTextureCompressionType::kNone) {
        colorSize =  SkCompressedFormatDataSize(compression,
                                                dimensions,
                                                info.mipmapped() == Mipmapped::kYes);
    } else {
        // TODO: Should we make sure the backends return zero here if the TextureInfo is for a
        // memoryless texture?
        size_t bytesPerPixel = info.bytesPerPixel();
 
        colorSize = (size_t)dimensions.width() * dimensions.height() * bytesPerPixel;
    }
 
    size_t finalSize = colorSize * info.numSamples();
 
    if (info.mipmapped() == Mipmapped::kYes) {
        finalSize += colorSize/3;
    }
    return finalSize;
}

◆ ContextTypeBackend()

skgpu::BackendApi skgpu::graphite::ContextTypeBackend ( skgpu::ContextType type )

Definition at line 128 of file ContextType.cpp.

                                                                  {
    switch (type) {
        case skgpu::ContextType::kGL:
        case skgpu::ContextType::kGLES:
        case skgpu::ContextType::kANGLE_D3D9_ES2:
        case skgpu::ContextType::kANGLE_D3D11_ES2:
        case skgpu::ContextType::kANGLE_D3D11_ES3:
        case skgpu::ContextType::kANGLE_GL_ES2:
        case skgpu::ContextType::kANGLE_GL_ES3:
        case skgpu::ContextType::kANGLE_Metal_ES2:
        case skgpu::ContextType::kANGLE_Metal_ES3:
        case skgpu::ContextType::kDirect3D:
            return BackendApi::kUnsupported;
 
        case ContextType::kVulkan:
            return BackendApi::kVulkan;
 
        case ContextType::kMetal:
            return BackendApi::kMetal;
 
        case ContextType::kDawn_D3D11:
        case ContextType::kDawn_D3D12:
        case ContextType::kDawn_Metal:
        case ContextType::kDawn_Vulkan:
        case ContextType::kDawn_OpenGL:
        case ContextType::kDawn_OpenGLES:
            return BackendApi::kDawn;
 
        case ContextType::kMock:
            return BackendApi::kMock;
    }
    SkUNREACHABLE;
}

◆ CopyAsDraw()

sk_sp< Image > skgpu::graphite::CopyAsDraw	(	Recorder *	recorder,
		const SkImage *	image,
		const SkIRect &	subset,
		const SkColorInfo &	dstColorInfo,
		Budgeted	budgeted,
		Mipmapped	mipmapped,
		SkBackingFit	backingFit,
		std::string_view	label
	)

Definition at line 562 of file TextureUtils.cpp.

                                              {
    SkColorType ct = recorder->priv().caps()->getRenderableColorType(dstColorInfo.colorType());
    if (ct == kUnknown_SkColorType) {
        return nullptr;
    }
    SkImageInfo dstInfo = SkImageInfo::Make(subset.size(),
                                            dstColorInfo.makeColorType(ct)
                                                        .makeAlphaType(kPremul_SkAlphaType));
    // The surface goes out of scope when we return, so it can be scratch, but it may or may
    // not be budgeted depending on how the copied image is used (or returned to the client).
    auto surface = Surface::MakeScratch(recorder,
                                        dstInfo,
                                        std::move(label),
                                        budgeted,
                                        mipmapped,
                                        backingFit);
    if (!surface) {
        return nullptr;
    }
 
    SkPaint paint;
    paint.setBlendMode(SkBlendMode::kSrc);
    surface->getCanvas()->drawImage(image, -subset.left(), -subset.top(),
                                    SkFilterMode::kNearest, &paint);
    // And the image draw into `surface` is flushed when it goes out of scope
    return surface->asImage();
}

◆ create_color_and_offset_bitmap()

static SkBitmap skgpu::graphite::create_color_and_offset_bitmap	(	int	numStops,
		const SkPMColor4f *	colors,
		const float *	offsets
	)

static

Definition at line 2170 of file KeyHelpers.cpp.

                                                                     {
    SkBitmap colorsAndOffsetsBitmap;
 
    colorsAndOffsetsBitmap.allocPixels(
            SkImageInfo::Make(numStops, 2, kRGBA_F16_SkColorType, kPremul_SkAlphaType));
 
    for (int i = 0; i < numStops; i++) {
        // TODO: there should be a way to directly set a premul pixel in a bitmap with
        // a premul color.
        SkColor4f unpremulColor = colors[i].unpremul();
        colorsAndOffsetsBitmap.erase(unpremulColor, SkIRect::MakeXYWH(i, 0, 1, 1));
 
        float offset = offsets ? offsets[i] : SkIntToFloat(i) / (numStops - 1);
        SkASSERT(offset >= 0.0f && offset <= 1.0f);
 
        int exponent;
        float mantissa = frexp(offset, &exponent);
 
        SkHalf halfE = SkFloatToHalf(exponent);
        if ((int)SkHalfToFloat(halfE) != exponent) {
            SKGPU_LOG_W("Encoding gradient to f16 failed");
            return {};
        }
 
#if defined(SK_DEBUG)
        SkHalf halfM = SkFloatToHalf(mantissa);
 
        float restored = ldexp(SkHalfToFloat(halfM), (int)SkHalfToFloat(halfE));
        float error = abs(restored - offset);
        SkASSERT(error < 0.001f);
#endif
 
        // TODO: we're only using 2 of the f16s here. The encoding could be altered to better
        // preserve precision. This encoding yields < 0.001f error for 2^20 evenly spaced stops.
        colorsAndOffsetsBitmap.erase(SkColor4f{mantissa, (float)exponent, 0, 1},
                                     SkIRect::MakeXYWH(i, 1, 1, 1));
    }
 
    return colorsAndOffsetsBitmap;
}

◆ create_image_data()

static sk_sp< SkData > skgpu::graphite::create_image_data ( const SkImageInfo & info )

static

Definition at line 81 of file GraphiteResourceCacheTest.cpp.

                                                                {
    const size_t rowBytes = info.minRowBytes();
    sk_sp<SkData> data(SkData::MakeUninitialized(rowBytes * info.height()));
    {
        SkBitmap bm;
        bm.installPixels(info, data->writable_data(), rowBytes);
        SkCanvas canvas(bm);
        canvas.clear(SK_ColorRED);
    }
    return data;
}

◆ createVulkanShaderModule()

VkShaderModule skgpu::graphite::createVulkanShaderModule	(	const VulkanSharedContext *	context,
		const std::string &	spirv,
		VkShaderStageFlagBits	stage
	)

Definition at line 44 of file VulkanGraphiteUtils.cpp.

                                                                     {
    TRACE_EVENT0("skia.shaders", "InstallVkShaderModule");
    VkShaderModuleCreateInfo moduleCreateInfo;
    memset(&moduleCreateInfo, 0, sizeof(VkShaderModuleCreateInfo));
    moduleCreateInfo.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
    moduleCreateInfo.pNext = nullptr;
    moduleCreateInfo.flags = 0;
    moduleCreateInfo.codeSize = spirv.size();
    moduleCreateInfo.pCode = (const uint32_t*)spirv.c_str();
 
    VkShaderModule shaderModule;
    VkResult result;
    VULKAN_CALL_RESULT(context,
                       result,
                       CreateShaderModule(context->device(),
                                          &moduleCreateInfo,
                                          /*const VkAllocationCallbacks*=*/nullptr,
                                          &shaderModule));
    if (result != VK_SUCCESS) {
        SKGPU_LOG_E("Failed to create VkShaderModule");
        return VK_NULL_HANDLE;
    }
    return shaderModule;
}

◆ DawnCompileWGSLShaderModule()

bool skgpu::graphite::DawnCompileWGSLShaderModule	(	const DawnSharedContext *	sharedContext,
		const char *	label,
		const std::string &	wgsl,
		wgpu::ShaderModule *	module,
		ShaderErrorHandler *	errorHandler
	)

Definition at line 173 of file DawnGraphiteUtils.cpp.

                                                                   {
    wgpu::ShaderModuleWGSLDescriptor wgslDesc;
    wgslDesc.code = wgsl.c_str();
 
    wgpu::ShaderModuleDescriptor desc;
    desc.nextInChain = &wgslDesc;
    if (sharedContext->caps()->setBackendLabels()) {
        desc.label = label;
    }
 
    *module = sharedContext->device().CreateShaderModule(&desc);
 
    return check_shader_module(sharedContext, module, wgsl.c_str(), errorHandler);
}

◆ DawnDepthStencilFlagsToFormat()

wgpu::TextureFormat skgpu::graphite::DawnDepthStencilFlagsToFormat ( SkEnumBitMask< DepthStencilFlags > mask )

Definition at line 78 of file DawnGraphiteUtils.cpp.

                                                                                       {
    // TODO: Decide if we want to change this to always return a combined depth and stencil format
    // to allow more sharing of depth stencil allocations.
    if (mask == DepthStencilFlags::kDepth) {
        // If needed for workarounds or performance, Depth32Float is also available but requires 2x
        // the amount of memory.
        return wgpu::TextureFormat::Depth16Unorm;
    } else if (mask == DepthStencilFlags::kStencil) {
        return wgpu::TextureFormat::Stencil8;
    } else if (mask == DepthStencilFlags::kDepthStencil) {
        return wgpu::TextureFormat::Depth24PlusStencil8;
    }
    SkASSERT(false);
    return wgpu::TextureFormat::Undefined;
}

◆ DawnFormatBytesPerBlock()

size_t skgpu::graphite::DawnFormatBytesPerBlock ( wgpu::TextureFormat format )

Definition at line 21 of file DawnUtils.cpp.

                                                         {
    switch (format) {
        case wgpu::TextureFormat::RGBA8Unorm:            return 4;
        case wgpu::TextureFormat::BGRA8Unorm:            return 4;
        case wgpu::TextureFormat::R8Unorm:               return 1;
        case wgpu::TextureFormat::RGBA16Float:           return 8;
        case wgpu::TextureFormat::R16Float:              return 2;
        case wgpu::TextureFormat::RG8Unorm:              return 2;
        case wgpu::TextureFormat::RGB10A2Unorm:          return 4;
        case wgpu::TextureFormat::RG16Float:             return 4;
        // The depth stencil values are not neccessarily correct in Dawn since Dawn is allowed to
        // implement Stencil8 as a real stencil8 or depth24stencil8 format. Similarly the depth in
        // Depth24PlusStencil8 can either be a 24 bit value or Depth32Float value. There is also
        // currently no way to query this in WebGPU so we just use the highest values here.
        case wgpu::TextureFormat::Stencil8:              return 4; // could be backed by d24s8
        case wgpu::TextureFormat::Depth16Unorm:          return 2;
        case wgpu::TextureFormat::Depth32Float:          return 4;
        case wgpu::TextureFormat::Depth32FloatStencil8:  return 5;
        case wgpu::TextureFormat::Depth24PlusStencil8:   return 5; // could be backed by d32s8
 
#if !defined(__EMSCRIPTEN__)
        case wgpu::TextureFormat::R16Unorm:              return 2;
        case wgpu::TextureFormat::RG16Unorm:             return 4;
        // Note: We don't actually know the size of external formats, so this
        // is an arbitrary value. We will see external formats only in wrapped
        // SkImages, so this won't impact Skia's internal budgeting.
        case wgpu::TextureFormat::External:
            return 4;
#endif
        default:
            SkUNREACHABLE;
    }
}

◆ DawnFormatChannels()

uint32_t skgpu::graphite::DawnFormatChannels ( wgpu::TextureFormat format )

Definition at line 63 of file DawnUtils.cpp.

                                                      {
    switch (format) {
        case wgpu::TextureFormat::RGBA8Unorm:   return kRGBA_SkColorChannelFlags;
        case wgpu::TextureFormat::BGRA8Unorm:   return kRGBA_SkColorChannelFlags;
        case wgpu::TextureFormat::R8Unorm:      return kRed_SkColorChannelFlag;
        case wgpu::TextureFormat::RGBA16Float:  return kRGBA_SkColorChannelFlags;
        case wgpu::TextureFormat::R16Float:     return kRed_SkColorChannelFlag;
        case wgpu::TextureFormat::RG8Unorm:     return kRG_SkColorChannelFlags;
        case wgpu::TextureFormat::RGB10A2Unorm: return kRGBA_SkColorChannelFlags;
        case wgpu::TextureFormat::RG16Float:    return kRG_SkColorChannelFlags;
 
#if !defined(__EMSCRIPTEN__)
        case wgpu::TextureFormat::R16Unorm:     return kRed_SkColorChannelFlag;
        case wgpu::TextureFormat::RG16Unorm:    return kRG_SkColorChannelFlags;
#endif
 
        default:                                return 0;
    }
    SkUNREACHABLE;
}

◆ DawnFormatIsDepth()

bool skgpu::graphite::DawnFormatIsDepth ( wgpu::TextureFormat format )

Definition at line 55 of file DawnGraphiteUtils.cpp.

                                                 {
    switch (format) {
        case wgpu::TextureFormat::Depth16Unorm:         [[fallthrough]];
        case wgpu::TextureFormat::Depth32Float:
        case wgpu::TextureFormat::Depth24PlusStencil8:
        case wgpu::TextureFormat::Depth32FloatStencil8:
            return true;
        default:
            return false;
    }
}

◆ DawnFormatIsDepthOrStencil()

bool skgpu::graphite::DawnFormatIsDepthOrStencil ( wgpu::TextureFormat format )

Definition at line 42 of file DawnGraphiteUtils.cpp.

                                                          {
    switch (format) {
        case wgpu::TextureFormat::Stencil8:             [[fallthrough]];
        case wgpu::TextureFormat::Depth16Unorm:
        case wgpu::TextureFormat::Depth32Float:
        case wgpu::TextureFormat::Depth24PlusStencil8:
        case wgpu::TextureFormat::Depth32FloatStencil8:
            return true;
        default:
            return false;
    }
}

◆ DawnFormatIsStencil()

bool skgpu::graphite::DawnFormatIsStencil ( wgpu::TextureFormat format )

Definition at line 67 of file DawnGraphiteUtils.cpp.

                                                   {
    switch (format) {
        case wgpu::TextureFormat::Stencil8:             [[fallthrough]];
        case wgpu::TextureFormat::Depth24PlusStencil8:
        case wgpu::TextureFormat::Depth32FloatStencil8:
            return true;
        default:
            return false;
    }
}

◆ DawnFormatToCompressionType()

SkTextureCompressionType skgpu::graphite::DawnFormatToCompressionType ( wgpu::TextureFormat format )

Definition at line 55 of file DawnUtils.cpp.

                                                                               {
    switch (format) {
        case wgpu::TextureFormat::ETC2RGB8Unorm: return SkTextureCompressionType::kETC2_RGB8_UNORM;
        case wgpu::TextureFormat::BC1RGBAUnorm:  return SkTextureCompressionType::kBC1_RGBA8_UNORM;
        default:                                 return SkTextureCompressionType::kNone;
    }
}

◆ DawnNativeProcessEventsFunction()

SK_API void skgpu::graphite::DawnNativeProcessEventsFunction ( const wgpu::Instance & instance )

inline

Definition at line 45 of file DawnBackendContext.h.

                                                                                 {
    instance.ProcessEvents();
}

◆ DawnTextureInfoFromWGPUTexture()

DawnTextureInfo skgpu::graphite::DawnTextureInfoFromWGPUTexture ( WGPUTexture texture )

Definition at line 21 of file DawnTypesPriv.cpp.

                                                                    {
    SkASSERT(texture);
    return DawnTextureInfo(
            wgpuTextureGetSampleCount(texture),
            wgpuTextureGetMipLevelCount(texture) > 1 ? Mipmapped::kYes : Mipmapped::kNo,
            /*format=*/static_cast<wgpu::TextureFormat>(wgpuTextureGetFormat(texture)),
            /*viewFormat=*/static_cast<wgpu::TextureFormat>(wgpuTextureGetFormat(texture)),
            static_cast<wgpu::TextureUsage>(wgpuTextureGetUsage(texture)),
            wgpu::TextureAspect::All, /*slice=*/0);
}

◆ DawnTextureSpecToTextureInfo()

DawnTextureInfo skgpu::graphite::DawnTextureSpecToTextureInfo	(	const DawnTextureSpec &	dawnSpec,
		uint32_t	sampleCount,
		Mipmapped	mipmapped
	)

Definition at line 32 of file DawnTypesPriv.cpp.

                                                                  {
    DawnTextureInfo info;
    // Shared info
    info.fSampleCount = sampleCount;
    info.fMipmapped = mipmapped;
 
    // Dawn info
    info.fFormat = dawnSpec.fFormat;
    info.fViewFormat = dawnSpec.fViewFormat;
    info.fUsage = dawnSpec.fUsage;
    info.fAspect = dawnSpec.fAspect;
#if !defined(__EMSCRIPTEN__)
    info.fYcbcrVkDescriptor = dawnSpec.fYcbcrVkDescriptor;
#endif
 
    return info;
}

◆ DEF_CONDITIONAL_GRAPHITE_TEST_FOR_ALL_CONTEXTS() [1/8]

skgpu::graphite::DEF_CONDITIONAL_GRAPHITE_TEST_FOR_ALL_CONTEXTS	(	GraphiteBudgetedResourcesTest	,
		reporter	,
		context	,
		testContext	,
		true	,
		CtsEnforcement::kNextRelease
	)

Definition at line 100 of file GraphiteResourceCacheTest.cpp.

                                                                           {
    std::unique_ptr<Recorder> recorder = context->makeRecorder();
    ResourceProvider* resourceProvider = recorder->priv().resourceProvider();
    ResourceCache* resourceCache = resourceProvider->resourceCache();
    const SharedContext* sharedContext = resourceProvider->sharedContext();
 
    REPORTER_ASSERT(reporter, resourceCache->getResourceCount() == 0);
    REPORTER_ASSERT(reporter, resourceCache->numFindableResources() == 0);
 
    // Test making a non budgeted, non shareable resource.
    auto resource = TestResource::Make(
            sharedContext, Ownership::kOwned, skgpu::Budgeted::kNo, Shareable::kNo);
    if (!resource) {
        ERRORF(reporter, "Failed to make TestResource");
        return;
    }
    Resource* resourcePtr = resource.get();
 
    REPORTER_ASSERT(reporter, resource->budgeted() == skgpu::Budgeted::kNo);
    resourceCache->insertResource(resourcePtr);
    REPORTER_ASSERT(reporter, resourceCache->getResourceCount() == 1);
    // Resource is not shareable and we have a ref on it. Thus it shouldn't ben findable in the
    // cache.
    REPORTER_ASSERT(reporter, resourceCache->numFindableResources() == 0);
 
    // When we reset our TestResource it should go back into the cache since it can be used as a
    // scratch texture (since it is not shareable). At that point the budget should be changed to
    // skgpu::Budgeted::kYes.
    resource.reset();
    resourceCache->forceProcessReturnedResources();
    REPORTER_ASSERT(reporter, resourceCache->getResourceCount() == 1);
    REPORTER_ASSERT(reporter, resourceCache->numFindableResources() == 1);
    // Even though we reset our ref on the resource we still have the ptr to it and should be the
    // resource in the cache. So in general this is dangerous it should be safe for this test to
    // directly access the texture.
    REPORTER_ASSERT(reporter, resourcePtr->budgeted() == skgpu::Budgeted::kYes);
 
    GraphiteResourceKey key;
    TestResource::CreateKey(&key, Shareable::kNo);
    Resource* resourcePtr2 = resourceCache->findAndRefResource(key, skgpu::Budgeted::kNo);
    REPORTER_ASSERT(reporter, resourcePtr == resourcePtr2);
    REPORTER_ASSERT(reporter, resourceCache->getResourceCount() == 1);
    REPORTER_ASSERT(reporter, resourceCache->numFindableResources() == 0);
    REPORTER_ASSERT(reporter, resourcePtr2->budgeted() == skgpu::Budgeted::kNo);
    resourcePtr2->unref();
    resourceCache->forceProcessReturnedResources();
 
    // Test making a budgeted, shareable resource.
    resource = TestResource::Make(
            sharedContext, Ownership::kOwned, skgpu::Budgeted::kYes, Shareable::kYes);
    if (!resource) {
        ERRORF(reporter, "Failed to make TestResource");
        return;
    }
    resourcePtr = resource.get();
    REPORTER_ASSERT(reporter, resource->budgeted() == skgpu::Budgeted::kYes);
    resourceCache->insertResource(resourcePtr);
    REPORTER_ASSERT(reporter, resourceCache->getResourceCount() == 2);
    REPORTER_ASSERT(reporter, resourceCache->numFindableResources() == 2);
 
    resource.reset();
    resourceCache->forceProcessReturnedResources();
    REPORTER_ASSERT(reporter, resourceCache->getResourceCount() == 2);
    REPORTER_ASSERT(reporter, resourceCache->numFindableResources() == 2);
    REPORTER_ASSERT(reporter, resourcePtr->budgeted() == skgpu::Budgeted::kYes);
 
    TestResource::CreateKey(&key, Shareable::kYes);
    resourcePtr2 = resourceCache->findAndRefResource(key, skgpu::Budgeted::kYes);
    REPORTER_ASSERT(reporter, resourcePtr == resourcePtr2);
    REPORTER_ASSERT(reporter, resourceCache->getResourceCount() == 2);
    REPORTER_ASSERT(reporter, resourceCache->numFindableResources() == 2);
    REPORTER_ASSERT(reporter, resourcePtr2->budgeted() == skgpu::Budgeted::kYes);
    resourcePtr2->unref();
 
    ///////////////////////////////////////////////////////////////////////////////////////////////
    // Test that SkImage's and SkSurface's underlying Resource's follow the expected budgeted
    // system.
    auto info = SkImageInfo::Make(10, 10, kRGBA_8888_SkColorType, kPremul_SkAlphaType);
 
    // First test SkImages. Since we can't directly create a Graphite SkImage we first have to make
    // a raster SkImage than convert that to a Graphite SkImage via makeTextureImage.
    sk_sp<SkData> data(create_image_data(info));
    sk_sp<SkImage> image = SkImages::RasterFromData(info, std::move(data), info.minRowBytes());
    REPORTER_ASSERT(reporter, image);
 
    sk_sp<SkImage> imageGpu = SkImages::TextureFromImage(recorder.get(), image, {});
    REPORTER_ASSERT(reporter, imageGpu);
 
    TextureProxy* imageProxy = nullptr;
    {
        // We don't want the view holding a ref to the Proxy or else we can't send things back to
        // the cache.
        auto view = skgpu::graphite::AsView(imageGpu.get());
        REPORTER_ASSERT(reporter, view);
        imageProxy = view.proxy();
    }
    // Make sure the proxy is instantiated
    if (!imageProxy->instantiate(resourceProvider)) {
        ERRORF(reporter, "Failed to instantiate Proxy");
        return;
    }
    const Resource* imageResourcePtr = imageProxy->texture();
    REPORTER_ASSERT(reporter, imageResourcePtr);
    // There is an extra resource for the buffer that is uploading the data to the texture
    REPORTER_ASSERT(reporter, resourceCache->getResourceCount() == 4);
    REPORTER_ASSERT(reporter, resourceCache->numFindableResources() == 2);
    REPORTER_ASSERT(reporter, imageResourcePtr->budgeted() == skgpu::Budgeted::kNo);
 
    // Submit all upload work so we can drop refs to the image and get it returned to the cache.
    std::unique_ptr<Recording> recording = recorder->snap();
    if (!recording) {
        ERRORF(reporter, "Failed to make recording");
        return;
    }
    InsertRecordingInfo insertInfo;
    insertInfo.fRecording = recording.get();
    context->insertRecording(insertInfo);
    testContext->syncedSubmit(context);
    recording.reset();
    imageGpu.reset();
    resourceCache->forceProcessReturnedResources();
 
    REPORTER_ASSERT(reporter, resourceCache->getResourceCount() == 4);
    // Remapping async buffers before returning them to the cache can extend buffer lifetime.
    if (!context->priv().caps()->bufferMapsAreAsync()) {
        REPORTER_ASSERT(reporter, resourceCache->numFindableResources() == 4);
    }
    REPORTER_ASSERT(reporter, imageResourcePtr->budgeted() == skgpu::Budgeted::kYes);
 
    // Now try an SkSurface. This is simpler since we can directly create Graphite SkSurface's.
    sk_sp<SkSurface> surface = SkSurfaces::RenderTarget(recorder.get(), info);
    if (!surface) {
        ERRORF(reporter, "Failed to make surface");
        return;
    }
 
    TextureProxy* surfaceProxy = top_device_graphite_target_proxy(surface->getCanvas());
    if (!surfaceProxy) {
        ERRORF(reporter, "Failed to get surface proxy");
        return;
    }
 
    // Make sure the proxy is instantiated
    if (!surfaceProxy->instantiate(resourceProvider)) {
        ERRORF(reporter, "Failed to instantiate surface proxy");
        return;
    }
    const Resource* surfaceResourcePtr = surfaceProxy->texture();
 
    REPORTER_ASSERT(reporter, resourceCache->getResourceCount() == 5);
    // Remapping async buffers before returning them to the cache can extend buffer lifetime.
    if (!context->priv().caps()->bufferMapsAreAsync()) {
        REPORTER_ASSERT(reporter, resourceCache->numFindableResources() == 4);
    }
    REPORTER_ASSERT(reporter, surfaceResourcePtr->budgeted() == skgpu::Budgeted::kNo);
 
    // The creation of the surface may have added an initial clear to it. Thus if we just reset the
    // surface it will flush the clean on the device and we don't be dropping all our refs to the
    // surface. So we force all the work to happen first.
    recording = recorder->snap();
    insertInfo.fRecording = recording.get();
    context->insertRecording(insertInfo);
    testContext->syncedSubmit(context);
    recording.reset();
 
    surface.reset();
    resourceCache->forceProcessReturnedResources();
    REPORTER_ASSERT(reporter, surfaceResourcePtr->budgeted() == skgpu::Budgeted::kYes);
}

◆ DEF_CONDITIONAL_GRAPHITE_TEST_FOR_ALL_CONTEXTS() [2/8]

skgpu::graphite::DEF_CONDITIONAL_GRAPHITE_TEST_FOR_ALL_CONTEXTS	(	ProxyCacheTest10	,
		r	,
		context	,
		testContext	,
		true	,
		CtsEnforcement::kNextRelease
	)

Definition at line 446 of file ProxyCacheTest.cpp.

                                                                           {
    std::unique_ptr<Recorder> recorder = context->makeRecorder();
    ProxyCache* proxyCache = recorder->priv().proxyCache();
 
    REPORTER_ASSERT(r, proxyCache->numCached() == 0);
 
    bool regenerated;
    sk_sp<TextureProxy> proxy1 = find_or_create_by_key(recorder.get(), 1, &regenerated);
    REPORTER_ASSERT(r, proxy1 && proxy1->dimensions().width() == 32);
    REPORTER_ASSERT(r, regenerated);
 
    sk_sp<TextureProxy> proxy2 = find_or_create_by_key(recorder.get(), 2, &regenerated);
    REPORTER_ASSERT(r, proxy2 && proxy2->dimensions().width() == 64);
    REPORTER_ASSERT(r, regenerated);
 
    REPORTER_ASSERT(r, proxyCache->numCached() == 2);
 
    // These cached proxies shouldn't be deleted because we hold local refs still
    proxyCache->forceFreeUniquelyHeld();
    REPORTER_ASSERT(r, proxyCache->numCached() == 2);
 
    // Cache hit should not invoke the bitmap generation function.
    sk_sp<TextureProxy> proxy1b = find_or_create_by_key(recorder.get(), 1, &regenerated);
    REPORTER_ASSERT(r, proxy1.get() == proxy1b.get());
    REPORTER_ASSERT(r, !regenerated);
 
    proxy1.reset();
    proxy1b.reset();
    proxy2.reset();
    (void) recorder->snap(); // Dump pending commands to release internal refs to the cached proxies
 
    // Now the cache should clean the cache entries up
    proxyCache->forceFreeUniquelyHeld();
    REPORTER_ASSERT(r, proxyCache->numCached() == 0);
 
    // And regeneration functions as expected
    proxy1 = find_or_create_by_key(recorder.get(), 1, &regenerated);
    REPORTER_ASSERT(r, proxy1 && proxy1->dimensions().width() == 32);
    REPORTER_ASSERT(r, regenerated);
}

◆ DEF_CONDITIONAL_GRAPHITE_TEST_FOR_ALL_CONTEXTS() [3/8]

skgpu::graphite::DEF_CONDITIONAL_GRAPHITE_TEST_FOR_ALL_CONTEXTS	(	ProxyCacheTest4	,
		r	,
		context	,
		testContext	,
		true	,
		CtsEnforcement::kNextRelease
	)

Definition at line 160 of file ProxyCacheTest.cpp.

                                                                           {
    std::unique_ptr<Recorder> recorder = context->makeRecorder();
    ProxyCache* proxyCache = recorder->priv().proxyCache();
 
    ProxyCacheSetup setup = setup_test(context, testContext, recorder.get(), r);
    REPORTER_ASSERT(r, setup.valid());
    if (!setup.valid()) {
        return;
    }
 
    proxyCache->forceFreeUniquelyHeld();
    REPORTER_ASSERT(r, proxyCache->numCached() == 2);
 
    setup.fProxy1.reset();
    proxyCache->forceFreeUniquelyHeld();
    REPORTER_ASSERT(r, proxyCache->numCached() == 1);
 
    setup.fProxy2.reset();
    proxyCache->forceFreeUniquelyHeld();
    REPORTER_ASSERT(r, proxyCache->numCached() == 0);
}

◆ DEF_CONDITIONAL_GRAPHITE_TEST_FOR_ALL_CONTEXTS() [4/8]

skgpu::graphite::DEF_CONDITIONAL_GRAPHITE_TEST_FOR_ALL_CONTEXTS	(	ProxyCacheTest5	,
		r	,
		context	,
		testContext	,
		true	,
		CtsEnforcement::kNextRelease
	)

Definition at line 188 of file ProxyCacheTest.cpp.

                                                                           {
    std::unique_ptr<Recorder> recorder = context->makeRecorder();
    ProxyCache* proxyCache = recorder->priv().proxyCache();
 
    ProxyCacheSetup setup = setup_test(context, testContext, recorder.get(), r);
    REPORTER_ASSERT(r, setup.valid());
    if (!setup.valid()) {
        return;
    }
 
    REPORTER_ASSERT(r, !setup.fProxy1->texture()->testingShouldDeleteASAP());
    REPORTER_ASSERT(r, !setup.fProxy2->texture()->testingShouldDeleteASAP());
 
    proxyCache->forcePurgeProxiesNotUsedSince(setup.fTimeBetweenProxyCreation);
    REPORTER_ASSERT(r, proxyCache->numCached() == 1);
    REPORTER_ASSERT(r, setup.fProxy1->texture()->testingShouldDeleteASAP());
    REPORTER_ASSERT(r, !setup.fProxy2->texture()->testingShouldDeleteASAP());
 
    sk_sp<TextureProxy> test = proxyCache->find(setup.fBitmap1);
    REPORTER_ASSERT(r, !test);   // proxy1 should've been purged
 
    proxyCache->forcePurgeProxiesNotUsedSince(setup.fTimeAfterAllProxyCreation);
    REPORTER_ASSERT(r, proxyCache->numCached() == 0);
    REPORTER_ASSERT(r, setup.fProxy1->texture()->testingShouldDeleteASAP());
    REPORTER_ASSERT(r, setup.fProxy2->texture()->testingShouldDeleteASAP());
}

◆ DEF_CONDITIONAL_GRAPHITE_TEST_FOR_ALL_CONTEXTS() [5/8]

skgpu::graphite::DEF_CONDITIONAL_GRAPHITE_TEST_FOR_ALL_CONTEXTS	(	ProxyCacheTest6	,
		r	,
		context	,
		testContext	,
		true	,
		CtsEnforcement::kNextRelease
	)

Definition at line 222 of file ProxyCacheTest.cpp.

                                                                           {
    std::unique_ptr<Recorder> recorder = context->makeRecorder();
    ProxyCache* proxyCache = recorder->priv().proxyCache();
 
    ProxyCacheSetup setup = setup_test(context, testContext, recorder.get(), r);
    REPORTER_ASSERT(r, setup.valid());
    if (!setup.valid()) {
        return;
    }
 
    REPORTER_ASSERT(r, !setup.fProxy1->texture()->testingShouldDeleteASAP());
    REPORTER_ASSERT(r, !setup.fProxy2->texture()->testingShouldDeleteASAP());
 
    // update proxy1's timestamp
    sk_sp<TextureProxy> test = proxyCache->findOrCreateCachedProxy(recorder.get(), setup.fBitmap1,
                                                                   "ProxyCacheTestTexture");
    REPORTER_ASSERT(r, test == setup.fProxy1);
 
    std::this_thread::sleep_for(std::chrono::milliseconds(2));
    auto timeAfterProxy1Update = skgpu::StdSteadyClock::now();
 
    proxyCache->forcePurgeProxiesNotUsedSince(setup.fTimeBetweenProxyCreation);
    REPORTER_ASSERT(r, proxyCache->numCached() == 2);
    REPORTER_ASSERT(r, !setup.fProxy1->texture()->testingShouldDeleteASAP());
    REPORTER_ASSERT(r, !setup.fProxy2->texture()->testingShouldDeleteASAP());
 
    proxyCache->forcePurgeProxiesNotUsedSince(setup.fTimeAfterAllProxyCreation);
    REPORTER_ASSERT(r, proxyCache->numCached() == 1);
    REPORTER_ASSERT(r, !setup.fProxy1->texture()->testingShouldDeleteASAP());
    REPORTER_ASSERT(r, setup.fProxy2->texture()->testingShouldDeleteASAP());
 
    test = proxyCache->find(setup.fBitmap2);
    REPORTER_ASSERT(r, !test);   // proxy2 should've been purged
 
    proxyCache->forcePurgeProxiesNotUsedSince(timeAfterProxy1Update);
    REPORTER_ASSERT(r, proxyCache->numCached() == 0);
    REPORTER_ASSERT(r, setup.fProxy1->texture()->testingShouldDeleteASAP());
    REPORTER_ASSERT(r, setup.fProxy2->texture()->testingShouldDeleteASAP());
}

◆ DEF_CONDITIONAL_GRAPHITE_TEST_FOR_ALL_CONTEXTS() [6/8]

skgpu::graphite::DEF_CONDITIONAL_GRAPHITE_TEST_FOR_ALL_CONTEXTS	(	ProxyCacheTest7	,
		r	,
		context	,
		testContext	,
		true	,
		CtsEnforcement::kNextRelease
	)

Definition at line 268 of file ProxyCacheTest.cpp.

                                                                           {
    std::unique_ptr<Recorder> recorder = context->makeRecorder();
    ProxyCache* proxyCache = recorder->priv().proxyCache();
 
    ProxyCacheSetup setup = setup_test(context, testContext, recorder.get(), r);
    REPORTER_ASSERT(r, setup.valid());
    if (!setup.valid()) {
        return;
    }
 
    REPORTER_ASSERT(r, !setup.fProxy1->texture()->testingShouldDeleteASAP());
    REPORTER_ASSERT(r, !setup.fProxy2->texture()->testingShouldDeleteASAP());
 
    proxyCache->forcePurgeProxiesNotUsedSince(setup.fTimeAfterAllProxyCreation);
    REPORTER_ASSERT(r, proxyCache->numCached() == 0);
    REPORTER_ASSERT(r, setup.fProxy1->texture()->testingShouldDeleteASAP());
    REPORTER_ASSERT(r, setup.fProxy2->texture()->testingShouldDeleteASAP());
}

◆ DEF_CONDITIONAL_GRAPHITE_TEST_FOR_ALL_CONTEXTS() [7/8]

skgpu::graphite::DEF_CONDITIONAL_GRAPHITE_TEST_FOR_ALL_CONTEXTS	(	ProxyCacheTest8	,
		r	,
		context	,
		testContext	,
		true	,
		CtsEnforcement::kNextRelease
	)

Definition at line 293 of file ProxyCacheTest.cpp.

                                                                           {
    std::unique_ptr<Recorder> recorder = context->makeRecorder();
    ResourceCache* resourceCache = recorder->priv().resourceCache();
    ProxyCache* proxyCache = recorder->priv().proxyCache();
 
    resourceCache->setMaxBudget(0);
 
    ProxyCacheSetup setup = setup_test(context, testContext, recorder.get(), r);
    REPORTER_ASSERT(r, setup.valid());
    if (!setup.valid()) {
        return;
    }
 
    resourceCache->forcePurgeAsNeeded();
 
    REPORTER_ASSERT(r, proxyCache->numCached() == 2);
 
    setup.fProxy1.reset();
    proxyCache->forceProcessInvalidKeyMsgs();
 
    // unreffing fProxy1 and forcing message processing shouldn't purge proxy1 from the cache
    sk_sp<TextureProxy> test = proxyCache->find(setup.fBitmap1);
    REPORTER_ASSERT(r, test);
    test.reset();
 
    resourceCache->forcePurgeAsNeeded();
 
    REPORTER_ASSERT(r, proxyCache->numCached() == 1);
    test = proxyCache->find(setup.fBitmap1);
    REPORTER_ASSERT(r, !test);   // proxy1 should've been purged
 
    setup.fProxy2.reset();
    proxyCache->forceProcessInvalidKeyMsgs();
 
    // unreffing fProxy2 and forcing message processing shouldn't purge proxy2 from the cache
    test = proxyCache->find(setup.fBitmap2);
    REPORTER_ASSERT(r, test);
    test.reset();
 
    resourceCache->forcePurgeAsNeeded();
 
    REPORTER_ASSERT(r, proxyCache->numCached() == 0);
}

◆ DEF_CONDITIONAL_GRAPHITE_TEST_FOR_ALL_CONTEXTS() [8/8]

skgpu::graphite::DEF_CONDITIONAL_GRAPHITE_TEST_FOR_ALL_CONTEXTS	(	ProxyCacheTest9	,
		r	,
		context	,
		testContext	,
		true	,
		CtsEnforcement::kNextRelease
	)

Definition at line 344 of file ProxyCacheTest.cpp.

                                                                           {
    std::unique_ptr<Recorder> recorder = context->makeRecorder();
    ResourceCache* resourceCache = recorder->priv().resourceCache();
    ProxyCache* proxyCache = recorder->priv().proxyCache();
 
    ProxyCacheSetup setup = setup_test(context, testContext, recorder.get(), r);
    REPORTER_ASSERT(r, setup.valid());
    if (!setup.valid()) {
        return;
    }
 
    REPORTER_ASSERT(r, setup.fProxy1->isInstantiated());
    REPORTER_ASSERT(r, setup.fProxy2->isInstantiated());
 
    if (!setup.fProxy1->texture() || !setup.fProxy2->texture()) {
        return;
    }
 
    // Clear out resources used to setup bitmap proxies so we can track things easier.
    resourceCache->setMaxBudget(0);
    resourceCache->setMaxBudget(256 * (1 << 20));
 
    REPORTER_ASSERT(r, proxyCache->numCached() == 2);
    int baselineResourceCount = resourceCache->getResourceCount();
    // When buffer maps are async it can take extra time for buffers to be returned to the cache.
    if (context->priv().caps()->bufferMapsAreAsync()) {
        // We expect at least 2 textures (and possibly buffers).
        REPORTER_ASSERT(r, baselineResourceCount >= 2);
    } else {
        REPORTER_ASSERT(r, baselineResourceCount == 2);
    }
    // Force a command buffer ref on the second proxy in the cache so it can't be purged immediately
    setup.fProxy2->texture()->refCommandBuffer();
 
    Resource* proxy2ResourcePtr = setup.fProxy2->texture();
 
    setup.fProxy1.reset();
    setup.fProxy2.reset();
    REPORTER_ASSERT(r, proxyCache->numCached() == 2);
 
    auto timeAfterProxyCreation = skgpu::StdSteadyClock::now();
 
    // This should trigger both proxies to be purged from the ProxyCache. The first proxy should
    // immediately be purged from the ResourceCache as well since it has not other refs. The second
    // proxy will not be purged from the ResourceCache since it still has a command buffer ref.
    // However, that resource should have its deleteASAP flag set.
    resourceCache->purgeResourcesNotUsedSince(timeAfterProxyCreation);
 
    REPORTER_ASSERT(r, proxyCache->numCached() == 0);
    REPORTER_ASSERT(r, resourceCache->getResourceCount() == baselineResourceCount - 1);
    REPORTER_ASSERT(r, resourceCache->topOfPurgeableQueue() == nullptr);
    REPORTER_ASSERT(r, proxy2ResourcePtr->testingShouldDeleteASAP());
 
    // Removing the command buffer ref and returning proxy2Resource to the cache should cause it to
    // immediately get deleted without going in the purgeable queue.
    proxy2ResourcePtr->unrefCommandBuffer();
    resourceCache->forceProcessReturnedResources();
 
    REPORTER_ASSERT(r, proxyCache->numCached() == 0);
    REPORTER_ASSERT(r, resourceCache->getResourceCount() == baselineResourceCount - 2);
    REPORTER_ASSERT(r, resourceCache->topOfPurgeableQueue() == nullptr);
}

◆ DEF_GRAPHITE_TEST() [1/2]

skgpu::graphite::DEF_GRAPHITE_TEST	(	skgpu_IntersectionTree	,
		reporter	,
		CtsEnforcement::kNextRelease
	)

Definition at line 32 of file IntersectionTreeTest.cpp.

                                                                                {
    SkRandom rand;
    {
        SimpleIntersectionTree simpleTree;
        IntersectionTree tree;
        for (int i = 0; i < 1000; ++i) {
            Rect rect = Rect::XYWH(rand.nextRangeF(0, 500),
                                                       rand.nextRangeF(0, 500),
                                                       rand.nextRangeF(0, 70),
                                                       rand.nextRangeF(0, 70));
            CHECK(tree.add(rect) == simpleTree.add({rect.left(),
                                                   rect.top(),
                                                   rect.right(),
                                                   rect.bot()}));
        }
    }
    {
        SimpleIntersectionTree simpleTree;
        IntersectionTree tree;
        for (int i = 0; i < 100; ++i) {
            Rect rect = Rect::XYWH(rand.nextRangeF(0, 500),
                                   rand.nextRangeF(0, 500),
                                   rand.nextRangeF(0, 200),
                                   rand.nextRangeF(0, 200));
            CHECK(tree.add(rect) == simpleTree.add({rect.left(),
                                                   rect.top(),
                                                   rect.right(),
                                                   rect.bot()}));
        }
    }
    {
        SimpleIntersectionTree simpleTree;
        IntersectionTree tree;
        CHECK(tree.add(Rect::Infinite()));
        CHECK(!tree.add(Rect::WH(1,1)));
        CHECK(!tree.add(Rect::WH(1,std::numeric_limits<float>::infinity())));
        CHECK(tree.add(Rect::WH(0, 0)));
        CHECK(tree.add(Rect::WH(-1, 1)));
        CHECK(tree.add(Rect::WH(1, std::numeric_limits<float>::quiet_NaN())));
    }
}

◆ DEF_GRAPHITE_TEST() [2/2]

skgpu::graphite::DEF_GRAPHITE_TEST	(	skgpu_Rect	,
		reporter	,
		CtsEnforcement::kNextRelease
	)

Definition at line 15 of file RectTest.cpp.

                                                                    {
    using float2 = skvx::float2;
    using float4 = skvx::float4;
 
    const SkRect skRect = SkRect::MakeLTRB(1,-3,4,0);
    const Rect rect = skRect;
    CHECK(rect == rect);
    CHECK(rect == skRect); // promotes 'skRect' to a Rect for ==
    CHECK(rect.asSkRect() == skRect); // converts 'rect' to SkRect for ==
 
    for (const float l : {0,1,2}) {
    for (const float t : {-4,-3,-2}) {
    for (const float r : {3,4,5}) {
    for (const float b : {-1,0,1}) {
        const Rect rect2(l,t,r,b);
        const SkRect skRect2{l,t,r,b};
 
        CHECK(rect2 == rect2);
        CHECK(rect2 == Rect(float2(l,t), float2(r,b)));
        CHECK(rect2 == Rect(skRect2));
        CHECK(rect2.asSkRect() == skRect2);
 
        CHECK((rect2 == rect) == (rect == rect2));
        CHECK((rect2 != rect) == (rect != rect2));
        CHECK((rect != rect2) == !(rect == rect2));
 
        CHECK(rect2 == Rect::XYWH(l, t, r - l, b - t));
        CHECK(rect2 == Rect::XYWH(float2(l, t), float2(r - l, b - t)));
        if (l == 0 && t == 0) {
            CHECK(rect2 == Rect::WH(r - l, b - t));
            CHECK(rect2 == Rect::WH(float2(r - l, b - t)));
        }
        CHECK(rect2 == Rect::FromVals(rect2.vals()));
 
        CHECK(rect2.x() == l);
        CHECK(rect2.y() == t);
        CHECK(rect2.left() == l);
        CHECK(rect2.top() == t);
        CHECK(rect2.right() == r);
        CHECK(rect2.bot() == b);
        CHECK(all(rect2.topLeft() == float2(l,t)));
        CHECK(all(rect2.botRight() == float2(r,b)));
        CHECK(all(rect2.ltrb() == float4(l,t,r,b)));
        CHECK(all(rect2.vals() == float4(l,t,-r,-b)));
 
        Rect setTest(-99,-99,99,99);
        CHECK(setTest != rect2);
        setTest.setLeft(l);
        setTest.setTop(t);
        setTest.setRight(r);
        setTest.setBot(b);
        CHECK(setTest == rect2);
 
        setTest = Rect(-99,-99,99,99);
        CHECK(setTest != rect2);
        setTest.setTopLeft({l,t});
        setTest.setBotRight({r,b});
        CHECK(setTest == rect2);
 
        for (int i = 0; i < 4; ++i) {
            Rect rnan = rect2;
            CHECK(!rnan.isEmptyNegativeOrNaN());
            rnan.vals()[i] = std::numeric_limits<float>::quiet_NaN();
            CHECK(rnan.isEmptyNegativeOrNaN());
        }
 
        CHECK(all(rect2.size() == float2(skRect2.width(), skRect2.height())));
        CHECK(all(rect2.center() == float2(skRect2.centerX(), skRect2.centerY())));
        CHECK(rect2.area() == skRect2.height() * skRect2.width());
 
        CHECK(rect.intersects(rect2) == rect2.intersects(rect));
        CHECK(rect.intersects(rect2) == skRect.intersects(skRect2));
        CHECK(rect.contains(rect2) == skRect.contains(skRect2));
        CHECK(rect2.contains(rect) == skRect2.contains(skRect));
 
        CHECK(rect2.makeRoundIn() == SkRect::Make(skRect2.roundIn()));
        CHECK(rect2.makeRoundOut() == SkRect::Make(skRect2.roundOut()));
        CHECK(rect2.makeInset(.5f) == skRect2.makeInset(.5f, .5f));
        CHECK(rect2.makeInset({.5f, -.25f}) == skRect2.makeInset(.5f, -.25f));
        CHECK(rect2.makeOutset(.5f) == skRect2.makeOutset(.5f, .5f));
        CHECK(rect2.makeOutset({.5f, -.25f}) == skRect2.makeOutset(.5f, -.25f));
        CHECK(rect2.makeOffset({.5f, -.25f}) == skRect2.makeOffset(.5f, -.25f));
 
        SkRect skJoin = skRect;
        skJoin.join(skRect2);
        CHECK(rect.makeJoin(rect2) == skJoin);
        CHECK(rect.makeJoin(rect2) == rect2.makeJoin(rect));
 
        CHECK(rect.intersects(rect2) == !rect.makeIntersect(rect2).isEmptyNegativeOrNaN());
        CHECK(rect.makeIntersect(rect2) == rect2.makeIntersect(rect));
        if (rect.intersects(rect2)) {
            CHECK(skRect.intersects(skRect2));
            SkRect skIsect;
            CHECK(skIsect.intersect(skRect, skRect2));
            CHECK(rect.makeIntersect(rect2) == Rect(skIsect));
        }
 
        const Rect rect3{r,b,l,t}; // intentionally out of order
        const SkRect skRect3{r,b,l,t};
        CHECK(rect3.isEmptyNegativeOrNaN());
        CHECK(skRect3.isEmpty());
        CHECK(rect3.makeSorted() == skRect3.makeSorted());
        CHECK(rect3.makeSorted() == rect2);
    }}}}
}

◆ DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS() [1/16]

skgpu::graphite::DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS	(	DeviceTestVertexTransparency	,
		reporter	,
		context	,
		CtsEnforcement::kNextRelease
	)

Definition at line 21 of file DeviceTest.cpp.

                                                               {
    // Set up transparent vertices, in a 5px wide by 10px tall rectangle.
    static constexpr int kVertexCount = 5;
    SkPoint positions[kVertexCount];
    positions[0].set(2.5, 5);
    positions[1].set(0, 0);
    positions[2].set(5, 0);
    positions[3].set(5, 10);
    positions[4].set(0, 10);
 
    static constexpr int kIndexCount = 6;
    static constexpr uint16_t kIndices[kIndexCount] = {0, 1, 2, 3, 4, 1};
 
    SkColor colors[kVertexCount];
    for (size_t i = 0; i < kVertexCount; ++i) {
        colors[i] = 0x7F00FF00;
    }
 
    auto v = SkVertices::MakeCopy(SkVertices::kTriangleFan_VertexMode,
                                  kVertexCount,
                                  positions,
                                  nullptr,
                                  colors,
                                  kIndexCount,
                                  kIndices);
 
    // Draw vertices at x = 0.
    std::unique_ptr<Recorder> recorder = context->makeRecorder();
    SkImageInfo ii = SkImageInfo::Make(SkISize::Make(10, 10),
                                       SkColorType::kRGBA_8888_SkColorType,
                                       SkAlphaType::kPremul_SkAlphaType);
    sk_sp<SkSurface> surface = SkSurfaces::RenderTarget(recorder.get(), ii);
    SkCanvas* canvas = surface->getCanvas();
    canvas->drawVertices(v, SkBlendMode::kDst, SkPaint());
 
    // Draw a square that will overlap both vertex draws.
    SkPaint redPaint;
    redPaint.setColor(SK_ColorRED);
    canvas->drawRect(SkRect::MakeXYWH(0, 0, 10, 10), redPaint);
 
    // Draw vertices at x = 5.
    canvas->translate(5, 0);
    canvas->drawVertices(v, SkBlendMode::kDst, SkPaint());
 
    // Read pixels.
    SkBitmap bitmap;
    SkPixmap pixmap;
    bitmap.allocPixels(ii);
    SkAssertResult(bitmap.peekPixels(&pixmap));
    if (!surface->readPixels(pixmap, 0, 0)) {
        ERRORF(reporter, "readPixels failed");
        return;
    }
 
    // Check that draws weren't reordered to put vertex draws together.
    // The second vertex draw should have been 50% green on top of red.
    SkColor color = pixmap.getColor(9, 5);
    SkColor expected = 0xFF807F00;
    REPORTER_ASSERT(
            reporter, color == expected, "Wrong color, expected %08x, found %08x", expected, color);
}

◆ DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS() [2/16]

skgpu::graphite::DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS	(	DrawPassTestFailedDstCopy	,
		reporter	,
		context	,
		CtsEnforcement::kNextRelease
	)

Definition at line 19 of file DrawPassTest.cpp.

                                                               {
    const Caps* caps = context->priv().caps();
    std::unique_ptr<Recorder> recorder = context->makeRecorder();
 
    // Define a paint that requires a dst copy.
    SkPaint paint;
    PaintParams paintParams{paint, nullptr, nullptr, DstReadRequirement::kTextureCopy, false};
 
    // Define a draw that uses the paint, but is larger than the max texture size. In this case the
    // dst copy will fail.
    const SkIRect drawSize = SkIRect::MakeWH(caps->maxTextureSize() + 1, 1);
    std::unique_ptr<DrawList> drawList = std::make_unique<DrawList>();
    drawList->recordDraw(recorder->priv().rendererProvider()->analyticRRect(),
                         Transform::Identity(),
                         Geometry(Shape(SkRect::Make(drawSize))),
                         Clip(Rect::Infinite(), Rect::Infinite(), drawSize, nullptr),
                         DrawOrder(DrawOrder::kClearDepth.next()),
                         &paintParams,
                         nullptr);
 
    // Attempt to make a draw pass with the draw.
    static constexpr SkISize targetSize = SkISize::Make(1, 1);
    static constexpr SkColorType targetColorType = kN32_SkColorType;
    static constexpr SkAlphaType targetAlphaType = kPremul_SkAlphaType;
    const SkImageInfo targetInfo = SkImageInfo::Make(targetSize, targetColorType, targetAlphaType);
    sk_sp<TextureProxy> target = TextureProxy::Make(
            caps,
            recorder->priv().resourceProvider(),
            targetSize,
            caps->getDefaultSampledTextureInfo(
                    targetColorType, Mipmapped::kNo,
                    recorder->priv().isProtected(), Renderable::kYes),
            "DrawPassTestTargetProxy",
            Budgeted::kYes);
    std::unique_ptr<DrawPass> drawPass = DrawPass::Make(recorder.get(),
                                                        std::move(drawList),
                                                        target,
                                                        targetInfo,
                                                        {LoadOp::kClear, StoreOp::kStore},
                                                        {0.0f, 0.0f, 0.0f, 0.0f},
                                                        /*dstCopy=*/nullptr,
                                                        /*dstCopyOffset=*/{0,0});
 
    // Make sure creating the draw pass failed.
    REPORTER_ASSERT(reporter, !drawPass);
}

◆ DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS() [3/16]

skgpu::graphite::DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS	(	GraphiteLazyTextureInvalidDimensions	,
		reporter	,
		context	,
		CtsEnforcement::kNextRelease
	)

Definition at line 223 of file TextureProxyTest.cpp.

                                                               {
    class FulfillContext {
    public:
        FulfillContext(BackendTexture backendTexture) : fBackendTexture(backendTexture) {}
 
        static std::tuple<BackendTexture, void*> Fulfill(void* ctx) {
            FulfillContext* self = reinterpret_cast<FulfillContext*>(ctx);
            return {self->fBackendTexture, nullptr};
        }
 
        BackendTexture fBackendTexture;
    };
 
    std::unique_ptr<Recorder> recorder = context->makeRecorder();
    const Caps* caps = context->priv().caps();
 
    // Try to create textures with invalid dimensions.
    SkISize largeDimensions = SkISize::Make(caps->maxTextureSize() + 1, 1);
    SkISize negativeDimensions = SkISize::Make(-1, -1);
 
    for (const SkISize& dimensions : {largeDimensions, negativeDimensions}) {
        SkImageInfo imageInfo = SkImageInfo::Make(
                dimensions, SkColorType::kRGBA_8888_SkColorType, SkAlphaType::kPremul_SkAlphaType);
        TextureInfo textureInfo = caps->getDefaultSampledTextureInfo(
                imageInfo.colorInfo().colorType(), Mipmapped::kNo, Protected::kNo, Renderable::kNo);
 
        // The created BackendTexture should be invalid, so an invalid texture would be used to
        // fulfill the promise image created later, if we were to attempt to draw it.
        BackendTexture backendTexture =
                recorder->createBackendTexture(imageInfo.dimensions(), textureInfo);
        FulfillContext fulfillContext(backendTexture);
        REPORTER_ASSERT(reporter, !backendTexture.isValid());
 
        // Drawing should still succeed, as no image draw should actually be attempted with this
        // texture.
        SkImageInfo surfaceImageInfo = SkImageInfo::Make(
                1, 1, SkColorType::kRGBA_8888_SkColorType, SkAlphaType::kPremul_SkAlphaType);
        sk_sp<SkSurface> surface = SkSurfaces::RenderTarget(recorder.get(), surfaceImageInfo);
        sk_sp<SkImage> promiseImage = SkImages::PromiseTextureFrom(recorder.get(),
                                                                   imageInfo.dimensions(),
                                                                   textureInfo,
                                                                   imageInfo.colorInfo(),
                                                                   Volatile::kNo,
                                                                   FulfillContext::Fulfill,
                                                                   nullptr,
                                                                   nullptr,
                                                                   &fulfillContext);
 
        surface->getCanvas()->drawImage(promiseImage, 0.0f, 0.0f);
        std::unique_ptr<Recording> recording = recorder->snap();
        REPORTER_ASSERT(reporter, context->insertRecording({recording.get()}));
        // Clean up backend texture
        context->deleteBackendTexture(fulfillContext.fBackendTexture);
    }
}

◆ DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS() [4/16]

skgpu::graphite::DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS	(	GraphitePurgeAsNeededResourcesTest	,
		reporter	,
		context	,
		CtsEnforcement::kNextRelease
	)

Definition at line 310 of file GraphiteResourceCacheTest.cpp.

                                                               {
    std::unique_ptr<Recorder> recorder = context->makeRecorder();
    ResourceProvider* resourceProvider = recorder->priv().resourceProvider();
    ResourceCache* resourceCache = resourceProvider->resourceCache();
    const SharedContext* sharedContext = resourceProvider->sharedContext();
 
    resourceCache->setMaxBudget(10);
 
    auto resourceSize10 = add_new_resource(reporter,
                                           sharedContext,
                                           resourceCache,
                                           /*gpuMemorySize=*/10);
 
    REPORTER_ASSERT(reporter, resourceCache->getResourceCount() == 1);
    REPORTER_ASSERT(reporter, resourceCache->topOfPurgeableQueue() == nullptr);
    REPORTER_ASSERT(reporter, resourceCache->currentBudgetedBytes() == 10);
 
    auto resourceSize1 = add_new_resource(reporter,
                                          sharedContext,
                                          resourceCache,
                                          /*gpuMemorySize=*/1);
 
    // We should now be over budget, but nothing should be purged since neither resource is
    // purgeable.
    REPORTER_ASSERT(reporter, resourceCache->getResourceCount() == 2);
    REPORTER_ASSERT(reporter, resourceCache->topOfPurgeableQueue() == nullptr);
    REPORTER_ASSERT(reporter, resourceCache->currentBudgetedBytes() == 11);
 
    // Dropping the ref to the size 1 resource should cause it to get purged when we add a new
    // resource to the cache.
    resourceSize1.reset();
 
    auto resourceSize2 = add_new_resource(reporter,
                                          sharedContext,
                                          resourceCache,
                                          /*gpuMemorySize=*/2);
 
    // The purging should have happened when we return the resource above so we also shouldn't
    // see anything in the purgeable queue.
    REPORTER_ASSERT(reporter, resourceCache->getResourceCount() == 2);
    REPORTER_ASSERT(reporter, resourceCache->topOfPurgeableQueue() == nullptr);
    REPORTER_ASSERT(reporter, resourceCache->currentBudgetedBytes() == 12);
 
    // Reset the cache back to no resources by setting budget to 0.
    resourceSize10.reset();
    resourceSize2.reset();
    resourceCache->forceProcessReturnedResources();
    resourceCache->setMaxBudget(0);
 
    REPORTER_ASSERT(reporter, resourceCache->getResourceCount() == 0);
    REPORTER_ASSERT(reporter, resourceCache->topOfPurgeableQueue() == nullptr);
    REPORTER_ASSERT(reporter, resourceCache->currentBudgetedBytes() == 0);
 
    // Add a bunch of purgeable resources that keeps us under budget. Nothing should ever get purged.
    resourceCache->setMaxBudget(10);
    auto resourceSize1Ptr = add_new_purgeable_resource(reporter,
                                                       sharedContext,
                                                       resourceCache,
                                                       /*gpuMemorySize=*/1);
    /*auto resourceSize2Ptr=*/ add_new_purgeable_resource(reporter,
                                                          sharedContext,
                                                          resourceCache,
                                                          /*gpuMemorySize=*/2);
    auto resourceSize3Ptr = add_new_purgeable_resource(reporter,
                                                       sharedContext,
                                                       resourceCache,
                                                       /*gpuMemorySize=*/3);
    auto resourceSize4Ptr = add_new_purgeable_resource(reporter,
                                                       sharedContext,
                                                       resourceCache,
                                                       /*gpuMemorySize=*/4);
 
    REPORTER_ASSERT(reporter, resourceCache->getResourceCount() == 4);
    REPORTER_ASSERT(reporter, resourceCache->topOfPurgeableQueue() == resourceSize1Ptr);
    REPORTER_ASSERT(reporter, resourceCache->currentBudgetedBytes() == 10);
 
    // Now add some resources that should cause things to get purged.
    // Add a size 2 resource should purge the original size 1 and size 2
    add_new_purgeable_resource(reporter,
                               sharedContext,
                               resourceCache,
                               /*gpuMemorySize=*/2);
 
    REPORTER_ASSERT(reporter, resourceCache->getResourceCount() == 3);
    REPORTER_ASSERT(reporter, resourceCache->topOfPurgeableQueue() == resourceSize3Ptr);
    REPORTER_ASSERT(reporter, resourceCache->currentBudgetedBytes() == 9);
 
    // Adding a non-purgeable resource should also trigger resources to be purged from purgeable
    // queue.
    resourceSize10 = add_new_resource(reporter,
                                      sharedContext,
                                      resourceCache,
                                      /*gpuMemorySize=*/10);
 
    REPORTER_ASSERT(reporter, resourceCache->getResourceCount() == 1);
    REPORTER_ASSERT(reporter, resourceCache->topOfPurgeableQueue() == nullptr);
    REPORTER_ASSERT(reporter, resourceCache->currentBudgetedBytes() == 10);
 
    // Adding a resources that is purgeable back to the cache shouldn't trigger the previous
    // non-purgeable resource or itself to be purged yet (since processing our return mailbox
    // doesn't trigger the purgeAsNeeded call)
    resourceSize4Ptr = add_new_purgeable_resource(reporter,
                                                  sharedContext,
                                                  resourceCache,
                                                  /*gpuMemorySize=*/4);
 
    REPORTER_ASSERT(reporter, resourceCache->getResourceCount() == 2);
    REPORTER_ASSERT(reporter, resourceCache->topOfPurgeableQueue() == resourceSize4Ptr);
    REPORTER_ASSERT(reporter, resourceCache->currentBudgetedBytes() == 14);
 
    // Resetting the budget to 0 should trigger purging the size 4 purgeable resource but should
    // leave the non purgeable size 10 alone.
    resourceCache->setMaxBudget(0);
    REPORTER_ASSERT(reporter, resourceCache->getResourceCount() == 1);
    REPORTER_ASSERT(reporter, resourceCache->topOfPurgeableQueue() == nullptr);
    REPORTER_ASSERT(reporter, resourceCache->currentBudgetedBytes() == 10);
 
    resourceSize10.reset();
    resourceCache->forceProcessReturnedResources();
    resourceCache->forcePurgeAsNeeded();
 
    REPORTER_ASSERT(reporter, resourceCache->getResourceCount() == 0);
    REPORTER_ASSERT(reporter, resourceCache->topOfPurgeableQueue() == nullptr);
    REPORTER_ASSERT(reporter, resourceCache->currentBudgetedBytes() == 0);
}

◆ DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS() [5/16]

skgpu::graphite::DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS	(	GraphitePurgeNotUsedOverBudgetTest	,
		reporter	,
		context	,
		CtsEnforcement::kNextRelease
	)

Definition at line 615 of file GraphiteResourceCacheTest.cpp.

                                                               {
    std::unique_ptr<Recorder> recorder = context->makeRecorder();
    ResourceProvider* resourceProvider = recorder->priv().resourceProvider();
    ResourceCache* resourceCache = resourceProvider->resourceCache();
    const SharedContext* sharedContext = resourceProvider->sharedContext();
 
    // set resourceCache budget to 10 for testing.
    resourceCache->setMaxBudget(10);
 
    // First make a purgeable resources
    auto resourcePtr = add_new_purgeable_resource(reporter,
                                                  sharedContext,
                                                  resourceCache,
                                                  /*gpuMemorySize=*/1);
    if (!resourcePtr) {
        return;
    }
 
    // Now create a bunch of non purgeable (yet) resources that are not budgeted (i.e. in real world
    // they would be wrapped in an SkSurface or SkImage), but will cause us to go over our budget
    // limit when they do return to cache.
 
    auto resource1 = add_new_resource(reporter,
                                      sharedContext,
                                      resourceCache,
                                      /*gpuMemorySize=*/15,
                                      skgpu::Budgeted::kNo);
 
    auto resource2 = add_new_resource(reporter,
                                      sharedContext,
                                      resourceCache,
                                      /*gpuMemorySize=*/16,
                                      skgpu::Budgeted::kNo);
 
    auto resource3 = add_new_resource(reporter,
                                      sharedContext,
                                      resourceCache,
                                      /*gpuMemorySize=*/3,
                                      skgpu::Budgeted::kNo);
 
    auto resource1Ptr = resource1.get();
    auto resource2Ptr = resource2.get();
    auto resource3Ptr = resource3.get();
 
    REPORTER_ASSERT(reporter, resourceCache->getResourceCount() == 4);
    REPORTER_ASSERT(reporter, resourceCache->currentBudgetedBytes() == 1);
 
    auto timeBeforeReturningToCache = skgpu::StdSteadyClock::now();
 
    // Now reset all the non budgeted resources so they return to the cache and become budgeted.
    // Returning to the cache will not immedidately trigger a purgeAsNeededCall.
    resource1.reset();
    resource2.reset();
    resource3.reset();
 
    resourceCache->forceProcessReturnedResources();
 
    REPORTER_ASSERT(reporter, resourceCache->getResourceCount() == 4);
    REPORTER_ASSERT(reporter, resourceCache->currentBudgetedBytes() == 35);
    REPORTER_ASSERT(reporter, resourceCache->testingInPurgeableQueue(resourcePtr));
    REPORTER_ASSERT(reporter, resourceCache->testingInPurgeableQueue(resource1Ptr));
    REPORTER_ASSERT(reporter, resourceCache->testingInPurgeableQueue(resource2Ptr));
    REPORTER_ASSERT(reporter, resourceCache->testingInPurgeableQueue(resource3Ptr));
 
    // Now we call purgeNotUsedSince with timeBeforeReturnToCache. The original resource should get
    // purged because it is older than this time. The three originally non budgeted resources are
    // newer than this time so they won't be purged by the time on this call. However, since we are
    // overbudget it should trigger us to purge the first two of these resources to get us back
    // under.
    resourceCache->purgeResourcesNotUsedSince(timeBeforeReturningToCache);
    REPORTER_ASSERT(reporter, resourceCache->getResourceCount() == 1);
    REPORTER_ASSERT(reporter, resourceCache->currentBudgetedBytes() == 3);
    REPORTER_ASSERT(reporter, resourceCache->testingInPurgeableQueue(resource3Ptr));
}

◆ DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS() [6/16]

skgpu::graphite::DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS	(	GraphitePurgeNotUsedSinceResourcesTest	,
		reporter	,
		context	,
		CtsEnforcement::kNextRelease
	)

Definition at line 524 of file GraphiteResourceCacheTest.cpp.

                                                               {
    std::unique_ptr<Recorder> recorder = context->makeRecorder();
    ResourceProvider* resourceProvider = recorder->priv().resourceProvider();
    ResourceCache* resourceCache = resourceProvider->resourceCache();
    const SharedContext* sharedContext = resourceProvider->sharedContext();
 
    // Basic test where we purge 1 resource
    auto beforeTime = skgpu::StdSteadyClock::now();
 
    auto resourcePtr = add_new_purgeable_resource(reporter,
                                                  sharedContext,
                                                  resourceCache,
                                                  /*gpuMemorySize=*/1);
    if (!resourcePtr) {
        return;
    }
 
    REPORTER_ASSERT(reporter, resourceCache->getResourceCount() == 1);
 
    auto afterTime = skgpu::StdSteadyClock::now();
 
    // purging beforeTime should not get rid of the resource
    resourceCache->purgeResourcesNotUsedSince(beforeTime);
 
    REPORTER_ASSERT(reporter, resourceCache->getResourceCount() == 1);
 
    // purging at afterTime which is after resource became purgeable should purge it.
    resourceCache->purgeResourcesNotUsedSince(afterTime);
 
    REPORTER_ASSERT(reporter, resourceCache->getResourceCount() == 0);
 
    // Test making 2 purgeable resources, but asking to purge on a time between the two.
    Resource* resourcePtr1 = add_new_purgeable_resource(reporter,
                                                       sharedContext,
                                                       resourceCache,
                                                       /*gpuMemorySize=*/1);
 
    auto betweenTime = skgpu::StdSteadyClock::now();
 
    Resource* resourcePtr2 = add_new_purgeable_resource(reporter,
                                                        sharedContext,
                                                        resourceCache,
                                                        /*gpuMemorySize=*/1);
 
    afterTime = skgpu::StdSteadyClock::now();
 
    REPORTER_ASSERT(reporter, resourceCache->getResourceCount() == 2);
    REPORTER_ASSERT(reporter, resourceCache->testingInPurgeableQueue(resourcePtr1));
    REPORTER_ASSERT(reporter, resourceCache->testingInPurgeableQueue(resourcePtr2));
 
    resourceCache->purgeResourcesNotUsedSince(betweenTime);
 
    REPORTER_ASSERT(reporter, resourceCache->getResourceCount() == 1);
    REPORTER_ASSERT(reporter, resourceCache->testingInPurgeableQueue(resourcePtr2));
 
    resourceCache->purgeResourcesNotUsedSince(afterTime);
    REPORTER_ASSERT(reporter, resourceCache->getResourceCount() == 0);
 
    // purgeResourcesNotUsedSince should have no impact on non-purgeable resources
    auto resource = add_new_resource(reporter,
                                     sharedContext,
                                     resourceCache,
                                     /*gpuMemorySize=*/1);
    if (!resource) {
        return;
    }
    resourcePtr = resource.get();
 
    REPORTER_ASSERT(reporter, resourceCache->getResourceCount() == 1);
 
    afterTime = skgpu::StdSteadyClock::now();
    resourceCache->purgeResourcesNotUsedSince(afterTime);
    REPORTER_ASSERT(reporter, resourceCache->getResourceCount() == 1);
    REPORTER_ASSERT(reporter, !resourceCache->testingInPurgeableQueue(resourcePtr));
 
    resource.reset();
    // purgeResourcesNotUsedSince should check the mailbox for the returned resource. Though the
    // time is set before that happens so nothing should purge.
    resourceCache->purgeResourcesNotUsedSince(skgpu::StdSteadyClock::now());
    REPORTER_ASSERT(reporter, resourceCache->getResourceCount() == 1);
    REPORTER_ASSERT(reporter, resourceCache->testingInPurgeableQueue(resourcePtr));
 
    // Now it should be purged since it is already purgeable
    resourceCache->purgeResourcesNotUsedSince(skgpu::StdSteadyClock::now());
    REPORTER_ASSERT(reporter, resourceCache->getResourceCount() == 0);
}

◆ DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS() [7/16]

skgpu::graphite::DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS	(	GraphitePurgeResourcesTest	,
		reporter	,
		context	,
		CtsEnforcement::kNextRelease
	)

Definition at line 693 of file GraphiteResourceCacheTest.cpp.

                                                               {
    std::unique_ptr<Recorder> recorder = context->makeRecorder();
    ResourceProvider* resourceProvider = recorder->priv().resourceProvider();
    ResourceCache* resourceCache = resourceProvider->resourceCache();
    const SharedContext* sharedContext = resourceProvider->sharedContext();
 
    // set resourceCache budget to 10 for testing.
    resourceCache->setMaxBudget(10);
 
    // Basic test where we purge 1 resource
    auto resourcePtr = add_new_purgeable_resource(reporter,
                                                  sharedContext,
                                                  resourceCache,
                                                  /*gpuMemorySize=*/1);
    if (!resourcePtr) {
        return;
    }
 
    REPORTER_ASSERT(reporter, resourceCache->getResourceCount() == 1);
 
    // purging should purge the one unlocked resource.
    resourceCache->purgeResources();
    REPORTER_ASSERT(reporter, resourceCache->getResourceCount() == 0);
 
    // Test making 2 purgeable resources
    Resource* resourcePtr1 = add_new_purgeable_resource(reporter,
                                                        sharedContext,
                                                        resourceCache,
                                                        /*gpuMemorySize=*/1);
 
    Resource* resourcePtr2 = add_new_purgeable_resource(reporter,
                                                        sharedContext,
                                                        resourceCache,
                                                        /*gpuMemorySize=*/1);
    if (!resourcePtr1 || !resourcePtr2) {
        return;
    }
 
    REPORTER_ASSERT(reporter, resourceCache->getResourceCount() == 2);
    REPORTER_ASSERT(reporter, resourceCache->testingInPurgeableQueue(resourcePtr1));
    REPORTER_ASSERT(reporter, resourceCache->testingInPurgeableQueue(resourcePtr2));
 
    resourceCache->purgeResources();
    REPORTER_ASSERT(reporter, resourceCache->getResourceCount() == 0);
 
    // purgeResources should have no impact on non-purgeable resources
    auto resource = add_new_resource(reporter,
                                     sharedContext,
                                     resourceCache,
                                     /*gpuMemorySize=*/1);
    if (!resource) {
        return;
    }
    resourcePtr = resource.get();
 
    REPORTER_ASSERT(reporter, resourceCache->getResourceCount() == 1);
 
    resourceCache->purgeResources();
    REPORTER_ASSERT(reporter, resourceCache->getResourceCount() == 1);
    REPORTER_ASSERT(reporter, !resourceCache->testingInPurgeableQueue(resourcePtr));
 
    resource.reset();
    resourceCache->purgeResources();
    REPORTER_ASSERT(reporter, resourceCache->getResourceCount() == 0);
}

◆ DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS() [8/16]

skgpu::graphite::DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS	(	GraphiteTextureProxyTest	,
		reporter	,
		context	,
		CtsEnforcement::kNextRelease
	)

Definition at line 27 of file TextureProxyTest.cpp.

                                                               {
    const Caps* caps = context->priv().caps();
    constexpr SkISize kValidSize = SkISize::Make(1, 1);
    constexpr SkISize kInvalidSize = SkISize::MakeEmpty();
    constexpr SkColorType kValidColorType = kRGBA_8888_SkColorType;
    constexpr SkColorType kInvalidColorType = kUnknown_SkColorType;
 
    Protected isProtected = Protected(caps->protectedSupport());
 
    std::unique_ptr<Recorder> recorder = context->makeRecorder();
    ResourceProvider* resourceProvider = recorder->priv().resourceProvider();
    const TextureInfo textureInfo = caps->getDefaultSampledTextureInfo(
            kValidColorType, Mipmapped::kNo, isProtected, Renderable::kNo);
    BackendTexture backendTexture = recorder->createBackendTexture(kValidSize, textureInfo);
    sk_sp<Texture> texture = resourceProvider->createWrappedTexture(backendTexture,
                                                                    "TextureProxyTestWrappedTex");
 
    auto makeProxy = [&](SkISize dimensions, SkColorType colorType, Mipmapped mipmapped,
                         Protected isProtected, Renderable renderable, Budgeted budgeted) {
        auto textureInfo = caps->getDefaultSampledTextureInfo(colorType, mipmapped,
                                                              isProtected, renderable);
        return TextureProxy::Make(caps, recorder->priv().resourceProvider(),
                                  dimensions, textureInfo, "TextureProxyTestTexture", budgeted);
    };
 
    auto nullCallback = [](ResourceProvider*) -> sk_sp<Texture> { return nullptr; };
    auto callback = [texture](ResourceProvider*) -> sk_sp<Texture> { return texture; };
 
    // Assign to assignableTexture before instantiating with this callback.
    sk_sp<Texture> assignableTexture;
    auto assignableCallback = [&assignableTexture](ResourceProvider*) -> sk_sp<Texture> {
        return assignableTexture;
    };
 
    // Invalid parameters.
    sk_sp<TextureProxy> textureProxy;
    textureProxy = makeProxy(kInvalidSize,
                             kValidColorType,
                             Mipmapped::kNo,
                             isProtected,
                             Renderable::kNo,
                             skgpu::Budgeted::kNo);
    REPORTER_ASSERT(reporter, textureProxy == nullptr);
    textureProxy = makeProxy(kValidSize,
                             kInvalidColorType,
                             Mipmapped::kNo,
                             isProtected,
                             Renderable::kNo,
                             skgpu::Budgeted::kNo);
    REPORTER_ASSERT(reporter, textureProxy == nullptr);
 
    // Non-budgeted, non-lazy TextureProxy is instantiated on return
    textureProxy = makeProxy(kValidSize,
                             kValidColorType,
                             Mipmapped::kNo,
                             isProtected,
                             Renderable::kNo,
                             skgpu::Budgeted::kNo);
    REPORTER_ASSERT(reporter, !textureProxy->isLazy());
    REPORTER_ASSERT(reporter, !textureProxy->isFullyLazy());
    REPORTER_ASSERT(reporter, !textureProxy->isVolatile());
    REPORTER_ASSERT(reporter, textureProxy->isInstantiated());
    REPORTER_ASSERT(reporter, textureProxy->dimensions() == kValidSize);
 
    // Budgeted, non-lazy TextureProxy, successful instantiation later on
    textureProxy = makeProxy(kValidSize,
                             kValidColorType,
                             Mipmapped::kNo,
                             isProtected,
                             Renderable::kNo,
                             skgpu::Budgeted::kYes);
    REPORTER_ASSERT(reporter, !textureProxy->isLazy());
    REPORTER_ASSERT(reporter, !textureProxy->isFullyLazy());
    REPORTER_ASSERT(reporter, !textureProxy->isVolatile());
    REPORTER_ASSERT(reporter, !textureProxy->isInstantiated());
    REPORTER_ASSERT(reporter, textureProxy->dimensions() == kValidSize);
 
    bool instantiateSuccess = textureProxy->instantiate(resourceProvider);
    REPORTER_ASSERT(reporter, instantiateSuccess);
    REPORTER_ASSERT(reporter, textureProxy->isInstantiated());
    REPORTER_ASSERT(reporter, textureProxy->dimensions() == kValidSize);
    const Texture* createdTexture = textureProxy->texture();
 
    instantiateSuccess = textureProxy->instantiate(resourceProvider);
    REPORTER_ASSERT(reporter, instantiateSuccess);
    REPORTER_ASSERT(reporter, textureProxy->texture() == createdTexture);
 
    // Lazy, non-volatile TextureProxy, unsuccessful instantiation.
    textureProxy = TextureProxy::MakeLazy(
            caps, kValidSize, textureInfo, skgpu::Budgeted::kNo, Volatile::kNo, nullCallback);
    REPORTER_ASSERT(reporter, textureProxy->isLazy());
    REPORTER_ASSERT(reporter, !textureProxy->isFullyLazy());
    REPORTER_ASSERT(reporter, !textureProxy->isVolatile());
 
    instantiateSuccess = textureProxy->lazyInstantiate(resourceProvider);
    REPORTER_ASSERT(reporter, !instantiateSuccess);
    REPORTER_ASSERT(reporter, !textureProxy->isInstantiated());
 
    // Lazy, non-volatile TextureProxy, successful instantiation.
    textureProxy = TextureProxy::MakeLazy(
            caps, kValidSize, textureInfo, skgpu::Budgeted::kNo, Volatile::kNo, callback);
 
    instantiateSuccess = textureProxy->lazyInstantiate(resourceProvider);
    REPORTER_ASSERT(reporter, instantiateSuccess);
    REPORTER_ASSERT(reporter, textureProxy->texture() == texture.get());
 
    // Lazy, volatile TextureProxy, unsuccessful instantiation.
    textureProxy = TextureProxy::MakeLazy(
            caps, kValidSize, textureInfo, skgpu::Budgeted::kNo, Volatile::kYes, nullCallback);
    REPORTER_ASSERT(reporter, textureProxy->isLazy());
    REPORTER_ASSERT(reporter, !textureProxy->isFullyLazy());
    REPORTER_ASSERT(reporter, textureProxy->isVolatile());
 
    instantiateSuccess = textureProxy->lazyInstantiate(resourceProvider);
    REPORTER_ASSERT(reporter, !instantiateSuccess);
    REPORTER_ASSERT(reporter, !textureProxy->isInstantiated());
 
    // Lazy, volatile TextureProxy, successful instantiation.
    textureProxy = TextureProxy::MakeLazy(
            caps, kValidSize, textureInfo, skgpu::Budgeted::kNo, Volatile::kYes, callback);
 
    instantiateSuccess = textureProxy->lazyInstantiate(resourceProvider);
    REPORTER_ASSERT(reporter, instantiateSuccess);
    REPORTER_ASSERT(reporter, textureProxy->texture() == texture.get());
 
    textureProxy->deinstantiate();
    REPORTER_ASSERT(reporter, !textureProxy->isInstantiated());
 
    // Fully-lazy TextureProxy.
    textureProxy = TextureProxy::MakeFullyLazy(
            textureInfo, skgpu::Budgeted::kNo, Volatile::kYes, assignableCallback);
    REPORTER_ASSERT(reporter, textureProxy->isLazy());
    REPORTER_ASSERT(reporter, textureProxy->isFullyLazy());
    REPORTER_ASSERT(reporter, textureProxy->isVolatile());
 
    assignableTexture = texture;
    instantiateSuccess = textureProxy->lazyInstantiate(resourceProvider);
    REPORTER_ASSERT(reporter, instantiateSuccess);
    REPORTER_ASSERT(reporter, textureProxy->isInstantiated());
    REPORTER_ASSERT(reporter, textureProxy->isFullyLazy());
    REPORTER_ASSERT(reporter, textureProxy->dimensions() == kValidSize);
 
    textureProxy->deinstantiate();
    REPORTER_ASSERT(reporter, !textureProxy->isInstantiated());
    REPORTER_ASSERT(reporter, textureProxy->isFullyLazy());
 
    constexpr SkISize kLargerSize = SkISize::Make(2, 2);
    BackendTexture largerBackendTexture =
            recorder->createBackendTexture(kLargerSize, textureInfo);
    assignableTexture = resourceProvider->createWrappedTexture(largerBackendTexture,
                                                               "TextureProxyTestWrappedTex");
    instantiateSuccess = textureProxy->lazyInstantiate(resourceProvider);
    REPORTER_ASSERT(reporter, instantiateSuccess);
    REPORTER_ASSERT(reporter, textureProxy->dimensions() == kLargerSize);
 
    // InstantiateIfNotLazy tests.
    textureProxy = makeProxy(kValidSize,
                             kValidColorType,
                             Mipmapped::kNo,
                             isProtected,
                             Renderable::kNo,
                             skgpu::Budgeted::kYes);
    instantiateSuccess = TextureProxy::InstantiateIfNotLazy(resourceProvider, textureProxy.get());
    REPORTER_ASSERT(reporter, instantiateSuccess);
 
    textureProxy = TextureProxy::MakeLazy(
            caps, kValidSize, textureInfo, skgpu::Budgeted::kNo, Volatile::kNo, nullCallback);
    instantiateSuccess = TextureProxy::InstantiateIfNotLazy(resourceProvider, textureProxy.get());
    REPORTER_ASSERT(reporter, instantiateSuccess);
    // Clean up the backend textures.
    recorder->deleteBackendTexture(backendTexture);
    recorder->deleteBackendTexture(largerBackendTexture);
}

◆ DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS() [9/16]

skgpu::graphite::DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS	(	GraphiteTextureTooLargeTest	,
		reporter	,
		context	,
		CtsEnforcement::kNextRelease
	)

Definition at line 202 of file TextureProxyTest.cpp.

                                                               {
    std::unique_ptr<Recorder> recorder = context->makeRecorder();
    const Caps* caps = context->priv().caps();
 
    // Try to create a texture that is too large for the backend.
    SkBitmap bitmap;
    SkISize dimensions = SkISize::Make(caps->maxTextureSize() + 1, 1);
    bitmap.allocPixels(SkImageInfo::Make(
            dimensions, SkColorType::kRGBA_8888_SkColorType, SkAlphaType::kPremul_SkAlphaType));
    sk_sp<SkImage> rasterImage = SkImages::RasterFromBitmap(bitmap);
    sk_sp<SkImage> graphiteImage =
            SkImages::TextureFromImage(recorder.get(), rasterImage.get(), /*requiredProps=*/{});
 
    // Image creation should have failed.
    REPORTER_ASSERT(reporter, !graphiteImage);
 
    // Snapping should still succeed, no texture upload should actually be attempted.
    REPORTER_ASSERT(reporter, recorder->snap());
}

◆ DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS() [10/16]

skgpu::graphite::DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS	(	GraphiteZeroSizedResourcesTest	,
		reporter	,
		context	,
		CtsEnforcement::kNextRelease
	)

Definition at line 437 of file GraphiteResourceCacheTest.cpp.

                                                               {
    std::unique_ptr<Recorder> recorder = context->makeRecorder();
    ResourceProvider* resourceProvider = recorder->priv().resourceProvider();
    ResourceCache* resourceCache = resourceProvider->resourceCache();
    const SharedContext* sharedContext = resourceProvider->sharedContext();
 
    // First make a normal resource that has a non zero size
    Resource* resourcePtr = add_new_purgeable_resource(reporter,
                                                       sharedContext,
                                                       resourceCache,
                                                       /*gpuMemorySize=*/1);
    if (!resourcePtr) {
        return;
    }
 
    REPORTER_ASSERT(reporter, resourceCache->getResourceCount() == 1);
    REPORTER_ASSERT(reporter, resourceCache->numFindableResources() == 1);
    REPORTER_ASSERT(reporter, resourceCache->topOfPurgeableQueue() == resourcePtr);
 
    // First confirm if we set the max budget to zero, this sized resource is removed.
    resourceCache->setMaxBudget(0);
    REPORTER_ASSERT(reporter, resourceCache->getResourceCount() == 0);
    REPORTER_ASSERT(reporter, resourceCache->numFindableResources() == 0);
    REPORTER_ASSERT(reporter, resourceCache->topOfPurgeableQueue() == nullptr);
 
    // Set the budget back to something higher
    resourceCache->setMaxBudget(100);
 
    // Now create a zero sized resource and add it to the cache.
    resourcePtr = add_new_purgeable_resource(reporter,
                                             sharedContext,
                                             resourceCache,
                                             /*gpuMemorySize=*/0);
    if (!resourcePtr) {
        return;
    }
 
    REPORTER_ASSERT(reporter, resourceCache->getResourceCount() == 1);
    REPORTER_ASSERT(reporter, resourceCache->numFindableResources() == 1);
    REPORTER_ASSERT(reporter, resourceCache->topOfPurgeableQueue() == resourcePtr);
 
    // Setting the budget down to 0 should not cause the zero sized resource to be purged
    resourceCache->setMaxBudget(0);
    REPORTER_ASSERT(reporter, resourceCache->getResourceCount() == 1);
    REPORTER_ASSERT(reporter, resourceCache->numFindableResources() == 1);
    REPORTER_ASSERT(reporter, resourceCache->topOfPurgeableQueue() == resourcePtr);
 
    // Now add a sized resource to cache. Set budget higher again so that it fits
    resourceCache->setMaxBudget(100);
 
    Resource* sizedResourcePtr = add_new_purgeable_resource(reporter,
                                                            sharedContext,
                                                            resourceCache,
                                                            /*gpuMemorySize=*/1);
    if (!resourcePtr) {
        return;
    }
 
    REPORTER_ASSERT(reporter, resourceCache->getResourceCount() == 2);
    REPORTER_ASSERT(reporter, resourceCache->numFindableResources() == 2);
    // Even though the zero sized resource was added to the cache first, the top of the purgeable
    // stack should be the sized resource.
    REPORTER_ASSERT(reporter, resourceCache->topOfPurgeableQueue() == sizedResourcePtr);
 
    // Add another zero sized resource
    resourcePtr = add_new_purgeable_resource(reporter,
                                             sharedContext,
                                             resourceCache,
                                             /*gpuMemorySize=*/0);
    if (!resourcePtr) {
        return;
    }
 
    REPORTER_ASSERT(reporter, resourceCache->getResourceCount() == 3);
    REPORTER_ASSERT(reporter, resourceCache->numFindableResources() == 3);
    // Again the sized resource should still be the top of the purgeable queue
    REPORTER_ASSERT(reporter, resourceCache->topOfPurgeableQueue() == sizedResourcePtr);
 
    // If we set the cache budget to 0, it should clear out the sized resource but leave the two
    // zero-sized resources.
    resourceCache->setMaxBudget(0);
    REPORTER_ASSERT(reporter, resourceCache->getResourceCount() == 2);
    REPORTER_ASSERT(reporter, resourceCache->numFindableResources() == 2);
    REPORTER_ASSERT(reporter, resourceCache->topOfPurgeableQueue()->gpuMemorySize() == 0);
}

◆ DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS() [11/16]

skgpu::graphite::DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS	(	MultisampleRetainTest	,
		reporter	,
		context	,
		CtsEnforcement::kNever
	)

Definition at line 25 of file MultisampleTest.cpp.

                                                         {
    const SkImageInfo surfaceImageInfo = SkImageInfo::Make(
            16, 16, SkColorType::kRGBA_8888_SkColorType, SkAlphaType::kPremul_SkAlphaType);
 
    std::unique_ptr<Recorder> surfaceRecorder = context->makeRecorder();
    sk_sp<SkSurface> surface = SkSurfaces::RenderTarget(surfaceRecorder.get(), surfaceImageInfo);
 
    // Clear entire surface to red
    SkCanvas* surfaceCanvas = surface->getCanvas();
    surfaceCanvas->clear(SkColors::kRed);
    std::unique_ptr<Recording> surfaceRecording = surfaceRecorder->snap();
    // Flush the clearing
    context->insertRecording({surfaceRecording.get()});
 
    // Draw a blue path. The old red background should be retained between recordings.
    SkPaint paint;
    paint.setStrokeWidth(3);
    paint.setColor(SkColors::kBlue);
    paint.setStyle(SkPaint::Style::kStroke_Style);
 
    SkPath path;
    constexpr int kPathPoints[][2] = {
        {3, 2},
        {3, 4},
        {6, 8},
        {3, 15},
    };
 
    for (size_t i = 0; i < std::size(kPathPoints); ++i) {
        path.lineTo(kPathPoints[i][0], kPathPoints[i][1]);
    }
 
    surfaceCanvas->drawPath(path, paint);
 
    std::unique_ptr<Recording> surfaceRecording2 = surfaceRecorder->snap();
    // Play back recording.
    context->insertRecording({surfaceRecording2.get()});
 
    // Read pixels.
    SkBitmap bitmap;
    bitmap.allocPixels(surfaceImageInfo);
    if (!surface->readPixels(bitmap, 0, 0)) {
        ERRORF(reporter, "readPixels failed");
        return;
    }
 
    // Verify recording was replayed.
    REPORTER_ASSERT(reporter, bitmap.getColor4f(8, 0) == SkColors::kRed);
    REPORTER_ASSERT(reporter, bitmap.getColor4f(0, 8) == SkColors::kRed);
    REPORTER_ASSERT(reporter, bitmap.getColor4f(15, 14) == SkColors::kRed);
 
    // Verify points on the path have blue color. We don't verify last point because it is on the
    // edge of the path thus might have blurry color.
    for (size_t i = 0; i < std::size(kPathPoints) - 1; ++i) {
        REPORTER_ASSERT(reporter,
                        bitmap.getColor4f(kPathPoints[i][0], kPathPoints[i][1]) == SkColors::kBlue);
    }
}

◆ DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS() [12/16]

skgpu::graphite::DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS	(	ProxyCacheTest1	,
		r	,
		context	,
		CtsEnforcement::kNextRelease
	)

Definition at line 32 of file ProxyCacheTest.cpp.

                                                                                            {
    std::unique_ptr<Recorder> recorder = context->makeRecorder();
    ProxyCache* proxyCache = recorder->priv().proxyCache();
 
    SkBitmap bitmap;
    bool success = ToolUtils::GetResourceAsBitmap("images/mandrill_128.png", &bitmap);
    REPORTER_ASSERT(r, success);
    if (!success) {
        return;
    }
 
    REPORTER_ASSERT(r, proxyCache->numCached() == 0);
 
    sk_sp<TextureProxy> proxy = proxyCache->findOrCreateCachedProxy(recorder.get(), bitmap,
                                                                    "ProxyCacheTestTexture");
 
    REPORTER_ASSERT(r, proxyCache->numCached() == 1);
 
    bitmap.eraseColor(SK_ColorBLACK);
 
    proxyCache->forceProcessInvalidKeyMsgs();
 
    REPORTER_ASSERT(r, proxyCache->numCached() == 0);
}

◆ DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS() [13/16]

skgpu::graphite::DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS	(	ProxyCacheTest2	,
		r	,
		context	,
		CtsEnforcement::kNextRelease
	)

Definition at line 59 of file ProxyCacheTest.cpp.

                                                                                            {
    std::unique_ptr<Recorder> recorder1 = context->makeRecorder();
    ProxyCache* proxyCache1 = recorder1->priv().proxyCache();
    std::unique_ptr<Recorder> recorder2 = context->makeRecorder();
    ProxyCache* proxyCache2 = recorder2->priv().proxyCache();
 
    SkBitmap bitmap;
    bool success = ToolUtils::GetResourceAsBitmap("images/mandrill_128.png", &bitmap);
    REPORTER_ASSERT(r, success);
    if (!success) {
        return;
    }
 
    REPORTER_ASSERT(r, proxyCache1->numCached() == 0);
    REPORTER_ASSERT(r, proxyCache2->numCached() == 0);
 
    sk_sp<TextureProxy> proxy1 = proxyCache1->findOrCreateCachedProxy(recorder1.get(), bitmap,
                                                                      "ProxyCacheTestTexture");
    sk_sp<TextureProxy> proxy2 = proxyCache2->findOrCreateCachedProxy(recorder2.get(), bitmap,
                                                                      "ProxyCacheTestTexture");
 
    REPORTER_ASSERT(r, proxyCache1->numCached() == 1);
    REPORTER_ASSERT(r, proxyCache2->numCached() == 1);
 
    bitmap.eraseColor(SK_ColorBLACK);
 
    proxyCache1->forceProcessInvalidKeyMsgs();
    proxyCache2->forceProcessInvalidKeyMsgs();
 
    REPORTER_ASSERT(r, proxyCache1->numCached() == 0);
    REPORTER_ASSERT(r, proxyCache2->numCached() == 0);
}

◆ DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS() [14/16]

skgpu::graphite::DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS	(	RecordingSurfacesTestClear	,
		reporter	,
		context	,
		CtsEnforcement::kNextRelease
	)

Definition at line 96 of file RecordingSurfacesTest.cpp.

                                                               {
    SkISize surfaceSize = SkISize::Make(8, 4);
    SkISize recordingSize = SkISize::Make(4, 4);
    SkISize replayOffset = SkISize::Make(0, 0);
 
    auto draw = [](SkCanvas* canvas) { canvas->clear(SkColors::kRed); };
 
    std::vector<Expectation> expectations = {{0, 0, SkColors::kRed},
                                             {4, 0, SkColors::kTransparent}};
 
    run_test(reporter, context, surfaceSize, recordingSize, replayOffset, draw, expectations);
}

◆ DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS() [15/16]

skgpu::graphite::DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS	(	RecordingSurfacesTestWritePixels	,
		reporter	,
		context	,
		CtsEnforcement::kNextRelease
	)

Definition at line 111 of file RecordingSurfacesTest.cpp.

                                                               {
    SkBitmap bitmap;
    bitmap.allocN32Pixels(4, 4, true);
    SkCanvas bitmapCanvas(bitmap);
    SkPaint paint;
    paint.setColor(SkColors::kRed);
    bitmapCanvas.drawIRect(SkIRect::MakeXYWH(0, 0, 4, 4), paint);
 
    SkISize surfaceSize = SkISize::Make(8, 4);
    SkISize recordingSize = SkISize::Make(4, 4);
    SkISize replayOffset = SkISize::Make(4, 0);
 
    auto draw = [&bitmap](SkCanvas* canvas) { canvas->writePixels(bitmap, 0, 0); };
 
    std::vector<Expectation> expectations = {{0, 0, SkColors::kTransparent},
                                             {4, 0, SkColors::kRed}};
 
    run_test(reporter, context, surfaceSize, recordingSize, replayOffset, draw, expectations);
}

◆ DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS() [16/16]

skgpu::graphite::DEF_GRAPHITE_TEST_FOR_ALL_CONTEXTS	(	RecordingSurfacesTestWritePixelsOffscreen	,
		reporter	,
		context	,
		CtsEnforcement::kNextRelease
	)

Definition at line 133 of file RecordingSurfacesTest.cpp.

                                                               {
    SkBitmap bitmap;
    bitmap.allocN32Pixels(4, 4, true);
    SkCanvas bitmapCanvas(bitmap);
    SkPaint paint;
    paint.setColor(SkColors::kRed);
    bitmapCanvas.drawIRect(SkIRect::MakeXYWH(0, 0, 4, 4), paint);
    paint.setColor(SkColors::kGreen);
    bitmapCanvas.drawIRect(SkIRect::MakeXYWH(2, 2, 2, 2), paint);
 
    SkISize surfaceSize = SkISize::Make(4, 4);
    SkISize recordingSize = SkISize::Make(4, 4);
    SkISize replayOffset = SkISize::Make(-2, -2);
 
    auto draw = [&bitmap](SkCanvas* canvas) { canvas->writePixels(bitmap, 0, 0); };
 
    std::vector<Expectation> expectations = {{0, 0, SkColors::kGreen}};
 
    run_test(reporter, context, surfaceSize, recordingSize, replayOffset, draw, expectations);
}

◆ DEF_GRAPHITE_TEST_FOR_RENDERING_CONTEXTS() [1/5]

skgpu::graphite::DEF_GRAPHITE_TEST_FOR_RENDERING_CONTEXTS	(	BufferManagerGpuOnlyBufferTest	,
		reporter	,
		context	,
		CtsEnforcement::kNextRelease
	)

Definition at line 29 of file BufferManagerTest.cpp.

                                                                     {
    std::unique_ptr<Recorder> recorder = context->makeRecorder();
    DrawBufferManager* mgr = recorder->priv().drawBufferManager();
 
    // Allocate a series of GPU-only buffers. These buffers should not be mapped before and after
    // they get transferred to the recording.
    auto ssbo = mgr->getStorage(10);
    auto vertex = mgr->getVertexStorage(10);
    auto index = mgr->getIndexStorage(10);
    auto indirect = mgr->getIndirectStorage(10);
 
    REPORTER_ASSERT(reporter, !ssbo.fBuffer->isMapped());
    REPORTER_ASSERT(reporter, !vertex.fBuffer->isMapped());
    REPORTER_ASSERT(reporter, !index.fBuffer->isMapped());
    REPORTER_ASSERT(reporter, !indirect.fBuffer->isMapped());
 
    // Ensure that the buffers' starting alignment matches the required storage buffer alignment.
    size_t requiredAlignment = context->priv().caps()->requiredStorageBufferAlignment();
    REPORTER_ASSERT(reporter, is_offset_aligned(ssbo.fOffset, requiredAlignment));
    REPORTER_ASSERT(reporter, is_offset_aligned(vertex.fOffset, requiredAlignment));
    REPORTER_ASSERT(reporter, is_offset_aligned(index.fOffset, requiredAlignment));
    REPORTER_ASSERT(reporter, is_offset_aligned(indirect.fOffset, requiredAlignment));
 
    // Transfers the ownership of used buffers to a Recording.
    auto recording = recorder->snap();
 
    // Ensure that the buffers are still unmapped.
    REPORTER_ASSERT(reporter, !ssbo.fBuffer->isMapped());
    REPORTER_ASSERT(reporter, !vertex.fBuffer->isMapped());
    REPORTER_ASSERT(reporter, !index.fBuffer->isMapped());
    REPORTER_ASSERT(reporter, !indirect.fBuffer->isMapped());
 
    // Since these buffers never need their contents to be host-visible, no buffer transfer/copy
    // tasks should have been created for them.
    REPORTER_ASSERT(reporter, !recording->priv().hasTasks());
 
    // Request a mapped ssbo followed by an unmapped one. The two buffers should be distinct.
    auto [ssboPtr, mappedSsbo] = mgr->getStoragePointer(10);
    ssbo = mgr->getStorage(10);
    REPORTER_ASSERT(reporter, !ssbo.fBuffer->isMapped());
    REPORTER_ASSERT(reporter, ssbo.fBuffer != mappedSsbo.fBuffer);
}

◆ DEF_GRAPHITE_TEST_FOR_RENDERING_CONTEXTS() [2/5]

skgpu::graphite::DEF_GRAPHITE_TEST_FOR_RENDERING_CONTEXTS	(	ImageOriginTest_drawImage_Graphite	,
		reporter	,
		context	,
		CtsEnforcement::kNextRelease
	)

Definition at line 172 of file ImageOriginTest.cpp.

                                                                     {
    test_draw_fn(reporter, context, draw_image);
}

◆ DEF_GRAPHITE_TEST_FOR_RENDERING_CONTEXTS() [3/5]

skgpu::graphite::DEF_GRAPHITE_TEST_FOR_RENDERING_CONTEXTS	(	ImageOriginTest_imageShader_Graphite	,
		reporter	,
		context	,
		CtsEnforcement::kNextRelease
	)

Definition at line 177 of file ImageOriginTest.cpp.

                                                                     {
    test_draw_fn(reporter, context, draw_image_with_shader);
}

◆ DEF_GRAPHITE_TEST_FOR_RENDERING_CONTEXTS() [4/5]

skgpu::graphite::DEF_GRAPHITE_TEST_FOR_RENDERING_CONTEXTS	(	ImageShaderTest	,
		reporter	,
		context	,
		CtsEnforcement::kNextRelease
	)

Definition at line 85 of file ImageShaderTest.cpp.

                                                                     {
    // Test that a subset bound covering less than half of a pixel causes that pixel not to be
    // drawn when using decal tiling and nearest-neighbor filtering. In this case we have a subset
    // that covers 3/4 the pixel column at y=1, all of the y=2 column, and 1/4 the y=3 column.
    test_draw(reporter,
              context,
              /*canvasSize=*/SkISize::Make(100, 100),
              /*imageSize=*/SkISize::Make(4, 4),
              /*srcRect=*/SkRect::MakeLTRB(1.25, 0.0f, 3.25f, 2.0f),
              /*dstRect=*/SkRect::MakeLTRB(0, 0, 80, 80),
              SkTileMode::kDecal,
              SkSamplingOptions(),
 
              // Pixel that should sample the image at y=1, since that's where the subset starts.
              {{{0, 40}, kRectColor},
               // Pixel that would sample the image at y=3, but the subset bound at y=3.25 prevents
               // us from sampling the image.
               {{75, 40}, kBgColor}});
}

◆ DEF_GRAPHITE_TEST_FOR_RENDERING_CONTEXTS() [5/5]

skgpu::graphite::DEF_GRAPHITE_TEST_FOR_RENDERING_CONTEXTS	(	UploadBufferManagerTest	,
		reporter	,
		context	,
		CtsEnforcement::kNextRelease
	)

Definition at line 19 of file UploadBufferManagerTest.cpp.

                                                                     {
    std::unique_ptr<Recorder> recorder = context->makeRecorder();
    UploadBufferManager* bufferManager = recorder->priv().uploadBufferManager();
 
    // The test source data.
    char src[8] = {
            1, 2, 3, 4,
            5, 6, 7, 8,
    };
 
    // Test multiple small writes to a reused buffer.
    auto [smWriter0, smBufferInfo0] = bufferManager->getTextureUploadWriter(10, 1);
    smWriter0.write(/*offset=*/0, src, /*srcRowBytes=*/4, /*dstRowBytes=*/3, /*trimRowBytes=*/3,
                    /*rowCount=*/2);
    smWriter0.write(/*offset=*/6, src, /*srcRowBytes=*/4, /*dstRowBytes=*/2, /*trimRowBytes=*/2,
                    /*rowCount=*/2);
 
    auto [smWriter1, smBufferInfo1] = bufferManager->getTextureUploadWriter(4, 1);
    smWriter1.write(/*offset=*/0, src, /*srcRowBytes=*/4, /*dstRowBytes=*/2, /*trimRowBytes=*/2,
                    /*rowCount=*/2);
 
    REPORTER_ASSERT(reporter, smBufferInfo0.fBuffer == smBufferInfo1.fBuffer);
    REPORTER_ASSERT(reporter, smBufferInfo0.fOffset == 0);
    REPORTER_ASSERT(reporter, smBufferInfo1.fOffset >= 10);
 
    // Test a large write, which should get its own dedicated buffer.
    auto [lgWriter, lgBufferInfo] = bufferManager->getTextureUploadWriter((64 << 10) + 1, 1);
    lgWriter.write(/*offset=*/0, src, /*srcRowBytes=*/4, /*dstRowBytes=*/2, /*trimRowBytes=*/2,
                   /*rowCount=*/2);
 
    REPORTER_ASSERT(reporter, lgBufferInfo.fBuffer != smBufferInfo0.fBuffer);
    REPORTER_ASSERT(reporter, lgBufferInfo.fOffset == 0);
    REPORTER_ASSERT(reporter, lgBufferInfo.fBuffer->isMapped());
    const void* lgBufferMap = const_cast<Buffer*>(lgBufferInfo.fBuffer)->map();
    const char expectedLgBufferMap[4] = {
            1, 2,
            5, 6,
    };
    REPORTER_ASSERT(reporter,
                    memcmp(lgBufferMap, expectedLgBufferMap, sizeof(expectedLgBufferMap)) == 0);
 
    // Test another small write after the large write.
    auto [smWriter2, smBufferInfo2] = bufferManager->getTextureUploadWriter(2, 1);
    smWriter2.write(/*offset=*/0, src, /*srcRowBytes=*/4, /*dstRowBytes=*/2, /*trimRowBytes=*/2,
                    /*rowCount=*/1);
 
    REPORTER_ASSERT(reporter, smBufferInfo2.fBuffer == smBufferInfo0.fBuffer);
    REPORTER_ASSERT(reporter, smBufferInfo2.fOffset >= 4 + smBufferInfo1.fOffset);
 
    REPORTER_ASSERT(reporter, smBufferInfo0.fBuffer->isMapped());
    const char* smBufferMap =
                reinterpret_cast<const char*>(const_cast<Buffer*>(smBufferInfo0.fBuffer)->map());
    // Each section of written data could be offset and aligned by GPU-required rules, so we can't
    // easily validate the contents of the buffer in one go, and instead test at each of the three
    // reported offsets.
    const char expectedSmBuffer0[10] = { 1, 2, 3, 5, 6, 7, 1, 2, 5, 6 };
    const char expectedSmBuffer1[4] = { 1, 2, 5, 6 };
    const char expectedSmBuffer2[2] = { 1, 2};
    REPORTER_ASSERT(reporter, memcmp(smBufferMap + smBufferInfo0.fOffset,
                                     expectedSmBuffer0,
                                     sizeof(expectedSmBuffer0)) == 0);
    REPORTER_ASSERT(reporter, memcmp(smBufferMap + smBufferInfo1.fOffset,
                                     expectedSmBuffer1,
                                     sizeof(expectedSmBuffer1)) == 0);
    REPORTER_ASSERT(reporter, memcmp(smBufferMap + smBufferInfo2.fOffset,
                                     expectedSmBuffer1,
                                     sizeof(expectedSmBuffer2)) == 0);
 
    // Snap a Recording from the Recorder. This will transfer resources from the UploadBufferManager
    // to the Recording.
    auto recording = recorder->snap();
 
    // Test writes with a required alignment.
    auto [alWriter0, alBufferInfo0] = bufferManager->getTextureUploadWriter(6, 4);
    alWriter0.write(/*offset=*/0, src, /*srcRowBytes=*/4, /*dstRowBytes=*/3, /*trimRowBytes=*/3,
                    /*rowCount=*/2);
 
    auto [alWriter1, alBufferInfo1] = bufferManager->getTextureUploadWriter(2, 4);
    alWriter1.write(/*offset=*/0, src, /*srcRowBytes=*/4, /*dstRowBytes=*/2, /*trimRowBytes=*/2,
                    /*rowCount=*/1);
 
    // Should not share a buffer with earlier small writes, since we've transferred previously-
    // allocated resources to the command buffer.
    REPORTER_ASSERT(reporter, alBufferInfo0.fBuffer != smBufferInfo0.fBuffer);
    REPORTER_ASSERT(reporter, alBufferInfo0.fBuffer == alBufferInfo1.fBuffer);
    REPORTER_ASSERT(reporter, alBufferInfo0.fOffset == 0);
    REPORTER_ASSERT(reporter, alBufferInfo1.fOffset == 8);
 
    // From alWriter0.
    const char expectedAlBufferMap0[6] = {
            1, 2, 3,
            5, 6, 7,
    };
    // From alWriter1.
    const char expectedAlBufferMap1[2] = {
            1, 2,
    };
 
    REPORTER_ASSERT(reporter, alBufferInfo0.fBuffer->isMapped());
    const void* alBufferMap = const_cast<Buffer*>(alBufferInfo0.fBuffer)->map();
    REPORTER_ASSERT(reporter,
                    memcmp(alBufferMap, expectedAlBufferMap0, sizeof(expectedAlBufferMap0)) == 0);
 
    alBufferMap = SkTAddOffset<const void>(alBufferMap, 8);
    REPORTER_ASSERT(reporter,
                    memcmp(alBufferMap, expectedAlBufferMap1, sizeof(expectedAlBufferMap1)) == 0);
}

◆ DEF_TEST()

skgpu::graphite::DEF_TEST	(	BoundsManager	,
		r
	)

Definition at line 14 of file BoundsManagerTest.cpp.

                           {
    // 64 grid cells, each 16x16
    const int n = 8;
    const int w = 16;
    std::unique_ptr<BoundsManager> bm = GridBoundsManager::Make({n * w, n * w}, n);
 
    CompressedPaintersOrder order = CompressedPaintersOrder::First();
    for (int y = 0; y < n; ++y) {
        for (int x = 0; x < n; ++x) {
            order = order.next();
 
            // Should only modify a single cell
            Rect b = Rect::XYWH((x + 0.1f) * w, (y + 0.1f) * w, 0.8f * w, 0.8f * w);
            bm->recordDraw(b, order);
        }
    }
 
    // TODO: repeat these queries using bounds that intersect across levels as well
    order = CompressedPaintersOrder::First();
    for (int y = 0; y < n; ++y) {
        for (int x = 0; x < n; ++x) {
            order = order.next();
 
            // Should only read a single cell
            Rect b = Rect::XYWH((x + 0.2f) * w, (y + 0.2f) * w, 0.6f * w, 0.6f * w);
 
            CompressedPaintersOrder actual = bm->getMostRecentDraw(b);
            REPORTER_ASSERT(r, actual == order);
        }
    }
 
    // TODO: Then call recordDraw with new values that write to multiple cells
 
    // TODO: Then test calls where the new value is not larger than the current max
}

◆ descriptor_data_to_layout()

static VkDescriptorSetLayout skgpu::graphite::descriptor_data_to_layout	(	const VulkanSharedContext *	sharedContext,
		const SkSpan< DescriptorData > &	descriptorData
	)

static

Definition at line 447 of file VulkanGraphicsPipeline.cpp.

                                                      {
    if (descriptorData.size() == 0) { return VK_NULL_HANDLE; }
 
    VkDescriptorSetLayout setLayout;
    DescriptorDataToVkDescSetLayout(sharedContext, descriptorData, &setLayout);
    if (setLayout == VK_NULL_HANDLE) {
        SKGPU_LOG_E("Failed to create descriptor set layout; pipeline creation will fail.\n");
        return VK_NULL_HANDLE;
    }
    return setLayout;
}

◆ DescriptorDataToVkDescSetLayout()

void skgpu::graphite::DescriptorDataToVkDescSetLayout	(	const VulkanSharedContext *	ctxt,
		const SkSpan< DescriptorData > &	requestedDescriptors,
		VkDescriptorSetLayout *	outLayout
	)

Definition at line 71 of file VulkanGraphiteUtils.cpp.

                                                                       {
    skia_private::STArray<kDescriptorTypeCount, VkDescriptorSetLayoutBinding> bindingLayouts;
    for (size_t i = 0; i < requestedDescriptors.size(); i++) {
        if (requestedDescriptors[i].fCount != 0) {
            const DescriptorData& currDescriptor = requestedDescriptors[i];
            VkDescriptorSetLayoutBinding& layoutBinding = bindingLayouts.push_back();
            memset(&layoutBinding, 0, sizeof(VkDescriptorSetLayoutBinding));
            layoutBinding.binding = currDescriptor.fBindingIndex;
            layoutBinding.descriptorType = DsTypeEnumToVkDs(currDescriptor.fType);
            layoutBinding.descriptorCount = currDescriptor.fCount;
            layoutBinding.stageFlags =
                    PipelineStageFlagsToVkShaderStageFlags(currDescriptor.fPipelineStageFlags);
            // TODO(b/302126498): Set pImmutableSampler to currDescriptor.fImmutableSampler once
            // immutable samplers are created and used within graphite.
            layoutBinding.pImmutableSamplers = nullptr;
        }
    }
 
    VkDescriptorSetLayoutCreateInfo layoutCreateInfo;
    memset(&layoutCreateInfo, 0, sizeof(VkDescriptorSetLayoutCreateInfo));
    layoutCreateInfo.sType = VK_STRUCTURE_TYPE_DESCRIPTOR_SET_LAYOUT_CREATE_INFO;
    layoutCreateInfo.pNext = nullptr;
    layoutCreateInfo.flags = 0;
    layoutCreateInfo.bindingCount = bindingLayouts.size();
    layoutCreateInfo.pBindings = &bindingLayouts.front();
 
    VkResult result;
    VULKAN_CALL_RESULT(
            ctxt,
            result,
            CreateDescriptorSetLayout(ctxt->device(), &layoutCreateInfo, nullptr, outLayout));
    if (result != VK_SUCCESS) {
        SkDebugf("Failed to create VkDescriptorSetLayout\n");
        outLayout = VK_NULL_HANDLE;
    }
}

◆ destroy_desc_set_layouts()

static void skgpu::graphite::destroy_desc_set_layouts	(	const VulkanSharedContext *	sharedContext,
		skia_private::TArray< VkDescriptorSetLayout > &	setLayouts
	)

static

Definition at line 460 of file VulkanGraphicsPipeline.cpp.

                                                                                            {
    for (int i = 0; i < setLayouts.size(); i++) {
        if (setLayouts[i] != VK_NULL_HANDLE) {
            VULKAN_CALL(sharedContext->interface(),
            DestroyDescriptorSetLayout(sharedContext->device(),
                                       setLayouts[i],
                                       nullptr));
        }
    }
}

◆ destroy_shader_modules()

static void skgpu::graphite::destroy_shader_modules	(	const VulkanSharedContext *	sharedContext,
		VkShaderModule	vsModule,
		VkShaderModule	fsModule
	)

static

Definition at line 566 of file VulkanGraphicsPipeline.cpp.

                                                            {
    if (vsModule != VK_NULL_HANDLE) {
        VULKAN_CALL(sharedContext->interface(),
                    DestroyShaderModule(sharedContext->device(), vsModule, nullptr));
    }
    if (fsModule != VK_NULL_HANDLE) {
        VULKAN_CALL(sharedContext->interface(),
                    DestroyShaderModule(sharedContext->device(), fsModule, nullptr));
    }
}

◆ DsTypeEnumToVkDs()

VkDescriptorType skgpu::graphite::DsTypeEnumToVkDs ( DescriptorType type )

Definition at line 110 of file VulkanGraphiteUtils.cpp.

                                                       {
    switch (type) {
        case DescriptorType::kUniformBuffer:
            return VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER_DYNAMIC;
        case DescriptorType::kTextureSampler:
            return VK_DESCRIPTOR_TYPE_SAMPLER;
        case DescriptorType::kTexture:
            return VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE;
        case DescriptorType::kCombinedTextureSampler:
            return VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER;
        case DescriptorType::kStorageBuffer:
            return VK_DESCRIPTOR_TYPE_STORAGE_BUFFER;
        case DescriptorType::kInputAttachment:
            return VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT;
    }
    SkUNREACHABLE;
}

◆ EmitPaintParamsStorageBuffer()

std::string skgpu::graphite::EmitPaintParamsStorageBuffer	(	int	bufferID,
		SkSpan< const ShaderNode * >	nodes,
		int *	numUniforms,
		bool *	wrotePaintColor
	)

Definition at line 309 of file ContextUtils.cpp.

                               {
 
    std::string result;
    result += "struct FSUniformData {\n";
    for (const ShaderNode* n : nodes) {
        result += get_node_ssbo_fields(n, numUniforms, wrotePaintColor);
    }
    result += "};\n\n";
 
    if (!*numUniforms) {
        // No uniforms were added
        return {};
    }
 
    SkSL::String::appendf(&result,
                          "layout (binding=%d) readonly buffer FSUniforms {\n"
                          "    FSUniformData fsUniformData[];\n"
                          "};\n",
                          bufferID);
    return result;
}

◆ EmitPaintParamsUniforms()

std::string skgpu::graphite::EmitPaintParamsUniforms	(	int	bufferID,
		const Layout	layout,
		SkSpan< const ShaderNode * >	nodes,
		int *	numUniforms,
		int *	uniformsTotalBytes,
		bool *	wrotePaintColor
	)

Definition at line 266 of file ContextUtils.cpp.

                                                           {
    int offset = 0;
 
    std::string result = get_uniform_header(bufferID, "FS");
    for (const ShaderNode* n : nodes) {
        result += get_node_uniforms(layout, n, &offset, numUniforms, wrotePaintColor);
    }
    result.append("};\n\n");
 
    if (!*numUniforms) {
        // No uniforms were added
        return {};
    }
 
    if (uniformsTotalBytes) {
        *uniformsTotalBytes = offset;
    }
 
    return result;
}

◆ EmitRenderStepStorageBuffer()

std::string skgpu::graphite::EmitRenderStepStorageBuffer	(	int	bufferID,
		SkSpan< const Uniform >	uniforms
	)

Definition at line 335 of file ContextUtils.cpp.

                                        {
 
    std::string result;
    result += "struct StepUniformData {\n" +
              get_ssbo_fields(uniforms, -1, /* wrotePaintColor= */ nullptr) +
              "};\n\n";
 
    SkSL::String::appendf(&result,
                          "layout (binding=%d) readonly buffer StepUniforms {\n"
                          "    StepUniformData stepUniformData[];\n"
                          "};\n",
                          bufferID);
    return result;
}

◆ EmitRenderStepUniforms()

std::string skgpu::graphite::EmitRenderStepUniforms	(	int	bufferID,
		const Layout	layout,
		SkSpan< const Uniform >	uniforms,
		int *	renderStepUniformsTotalBytes
	)

Definition at line 292 of file ContextUtils.cpp.

                                                                      {
    int offset = 0;
 
    std::string result = get_uniform_header(bufferID, "Step");
    result += get_uniforms(layout, uniforms, &offset, -1, /* wrotePaintColor= */ nullptr);
    result.append("};\n\n");
 
    if (renderStepUniformsTotalBytes) {
        *renderStepUniformsTotalBytes = offset;
    }
 
    return result;
}

◆ EmitSamplerLayout()

std::string skgpu::graphite::EmitSamplerLayout	(	const ResourceBindingRequirements &	bindingReqs,
		int *	binding
	)

Definition at line 385 of file ContextUtils.cpp.

                                                                                          {
    std::string result;
 
    // If fDistinctIndexRanges is false, then texture and sampler indices may clash with other
    // resource indices. Graphite assumes that they will be placed in descriptor set (Vulkan) and
    // bind group (Dawn) index 1.
    const char* distinctIndexRange = bindingReqs.fDistinctIndexRanges ? "" : "set=1, ";
 
    if (bindingReqs.fSeparateTextureAndSamplerBinding) {
        int samplerIndex = (*binding)++;
        int textureIndex = (*binding)++;
        result = SkSL::String::printf("layout(webgpu, %ssampler=%d, texture=%d)",
                                      distinctIndexRange,
                                      samplerIndex,
                                      textureIndex);
    } else {
        int samplerIndex = (*binding)++;
        result = SkSL::String::printf("layout(%sbinding=%d)",
                                      distinctIndexRange,
                                      samplerIndex);
    }
    return result;
}

◆ EmitStorageBufferAccess()

std::string skgpu::graphite::EmitStorageBufferAccess	(	const char *	bufferNamePrefix,
		const char *	ssboIndex,
		const char *	uniformName
	)

Definition at line 369 of file ContextUtils.cpp.

                                                             {
    return SkSL::String::printf("%sUniformData[%s].%s", bufferNamePrefix, ssboIndex, uniformName);
}

◆ EmitTexturesAndSamplers()

std::string skgpu::graphite::EmitTexturesAndSamplers	(	const ResourceBindingRequirements &	bindingReqs,
		SkSpan< const ShaderNode * >	nodes,
		int *	binding
	)

Definition at line 375 of file ContextUtils.cpp.

                                                  {
    std::string result;
    for (const ShaderNode* n : nodes) {
        result += get_node_texture_samplers(bindingReqs, n, binding);
    }
    return result;
}

◆ EmitUniformsFromStorageBuffer()

std::string skgpu::graphite::EmitUniformsFromStorageBuffer	(	const char *	bufferNamePrefix,
		const char *	ssboIndex,
		SkSpan< const Uniform >	uniforms
	)

Definition at line 352 of file ContextUtils.cpp.

                                                                          {
    std::string result;
 
    for (const Uniform& u : uniforms) {
        SkSL::String::appendf(&result, "%s %s", SkSLTypeString(u.type()), u.name());
        if (u.count()) {
            SkSL::String::appendf(&result, "[%d]", u.count());
        }
        SkSL::String::appendf(
                &result, " = %sUniformData[%s].%s;\n", bufferNamePrefix, ssboIndex, u.name());
    }
 
    return result;
}

◆ EmitVaryings()

std::string skgpu::graphite::EmitVaryings	(	const RenderStep *	step,
		const char *	direction,
		bool	emitSsboIndicesVarying,
		bool	emitLocalCoordsVarying
	)

Definition at line 436 of file ContextUtils.cpp.

                                                      {
    std::string result;
    int location = 0;
 
    if (emitSsboIndicesVarying) {
        SkSL::String::appendf(&result,
                              "    layout(location=%d) %s flat ushort2 %s;\n",
                              location++,
                              direction,
                              RenderStep::ssboIndicesVarying());
    }
 
    if (emitLocalCoordsVarying) {
        SkSL::String::appendf(&result, "    layout(location=%d) %s ", location++, direction);
        result.append(SkSLTypeString(SkSLType::kFloat2));
        SkSL::String::appendf(&result, " localCoordsVar;\n");
    }
 
    for (auto v : step->varyings()) {
        SkSL::String::appendf(&result, "    layout(location=%d) %s ", location++, direction);
        result.append(SkSLTypeString(v.fType));
        SkSL::String::appendf(&result, " %s;\n", v.fName);
    }
 
    return result;
}

◆ expand_bits()

template<typename INT_TYPE >

static void skgpu::graphite::expand_bits	(	INT_TYPE *	dst,
		const uint8_t *	src,
		int	width,
		int	height,
		int	dstRowBytes,
		int	srcRowBytes
	)

static

Definition at line 57 of file TextAtlasManager.cpp.

                                         {
    for (int y = 0; y < height; ++y) {
        int rowWritesLeft = width;
        const uint8_t* s = src;
        INT_TYPE* d = dst;
        while (rowWritesLeft > 0) {
            unsigned mask = *s++;
            for (int x = 7; x >= 0 && rowWritesLeft; --x, --rowWritesLeft) {
                *d++ = (mask & (1 << x)) ? (INT_TYPE)(~0UL) : 0;
            }
        }
        dst = reinterpret_cast<INT_TYPE*>(reinterpret_cast<intptr_t>(dst) + dstRowBytes);
        src += srcRowBytes;
    }
}

◆ ExtractPaintData()

std::tuple< UniquePaintParamsID, const UniformDataBlock , const TextureDataBlock > skgpu::graphite::ExtractPaintData	(	Recorder *	recorder,
		PipelineDataGatherer *	gatherer,
		PaintParamsKeyBuilder *	builder,
		const Layout	layout,
		const SkM44 &	local2Dev,
		const PaintParams &	p,
		const Geometry &	geometry,
		sk_sp< TextureProxy >	dstTexture,
		SkIPoint	dstOffset,
		const SkColorInfo &	targetColorInfo
	)

Definition at line 32 of file ContextUtils.cpp.

                                            {
    SkDEBUGCODE(builder->checkReset());
 
    gatherer->resetWithNewLayout(layout);
 
    KeyContext keyContext(recorder,
                          local2Dev,
                          targetColorInfo,
                          geometry.isShape() || geometry.isEdgeAAQuad()
                                  ? KeyContext::OptimizeSampling::kYes
                                  : KeyContext::OptimizeSampling::kNo,
                          p.color(),
                          std::move(dstTexture),
                          dstOffset);
    p.toKey(keyContext, builder, gatherer);
 
    UniquePaintParamsID paintID = recorder->priv().shaderCodeDictionary()->findOrCreate(builder);
    const UniformDataBlock* uniforms = nullptr;
    const TextureDataBlock* textures = nullptr;
    if (paintID.isValid()) {
        if (gatherer->hasUniforms()) {
            UniformDataCache* uniformDataCache = recorder->priv().uniformDataCache();
            uniforms = uniformDataCache->insert(gatherer->finishUniformDataBlock());
        }
        if (gatherer->hasTextures()) {
            TextureDataCache* textureDataCache = recorder->priv().textureDataCache();
            textures = textureDataCache->insert(gatherer->textureDataBlock());
        }
    }
 
    return { paintID, uniforms, textures };
}

◆ ExtractRenderStepData()

std::tuple< const UniformDataBlock , const TextureDataBlock > skgpu::graphite::ExtractRenderStepData	(	UniformDataCache *	uniformDataCache,
		TextureDataCache *	textureDataCache,
		PipelineDataGatherer *	gatherer,
		const Layout	layout,
		const RenderStep *	step,
		const DrawParams &	params
	)

Definition at line 75 of file ContextUtils.cpp.

                                  {
    gatherer->resetWithNewLayout(layout);
    step->writeUniformsAndTextures(params, gatherer);
 
    const UniformDataBlock* uniforms =
            gatherer->hasUniforms() ? uniformDataCache->insert(gatherer->finishUniformDataBlock())
                                    : nullptr;
    const TextureDataBlock* textures =
            gatherer->hasTextures() ? textureDataCache->insert(gatherer->textureDataBlock())
                                    : nullptr;
 
    return { uniforms, textures };
}

◆ find_or_create_by_key()

static sk_sp< TextureProxy > skgpu::graphite::find_or_create_by_key	(	Recorder *	recorder,
		int	id,
		bool *	regenerated
	)

static

Definition at line 412 of file ProxyCacheTest.cpp.

                                                                                                {
    *regenerated = false;
 
    skgpu::UniqueKey key;
    {
        static const skgpu::UniqueKey::Domain kTestDomain = UniqueKey::GenerateDomain();
        UniqueKey::Builder builder(&key, kTestDomain, 1, "TestExplicitKey");
        builder[0] = id;
    }
 
    struct Context {
        int id;
        bool* regenerated;
    } params { id, regenerated };
 
    return recorder->priv().proxyCache()->findOrCreateCachedProxy(
            recorder, key, &params,
            [](const void* context) {
                const Context* params = static_cast<const Context*>(context);
                *params->regenerated = true;
 
                SkBitmap bm;
                if (params->id == 1) {
                    if (!ToolUtils::GetResourceAsBitmap("images/mandrill_32.png", &bm)) {
                        return SkBitmap();
                    }
                } else if (!ToolUtils::GetResourceAsBitmap("images/mandrill_64.png", &bm)) {
                    return SkBitmap();
                }
                return bm;
            });
}

◆ Flush() [1/2]

void skgpu::graphite::Flush ( sk_sp< SkSurface > surface )

Definition at line 141 of file Surface_Graphite.cpp.

                                     {
    return Flush(surface.get());
}

◆ Flush() [2/2]

void skgpu::graphite::Flush ( SkSurface * surface )

Definition at line 145 of file Surface_Graphite.cpp.

                               {
    if (!surface) {
        return;
    }
    auto sb = asSB(surface);
    if (!sb->isGraphiteBacked()) {
        return;
    }
    auto gs = static_cast<Surface*>(surface);
    gs->fDevice->flushPendingWorkToRecorder();
}

◆ gather_runtime_effect_uniforms()

static void skgpu::graphite::gather_runtime_effect_uniforms	(	const KeyContext &	keyContext,
		const SkRuntimeEffect *	effect,
		SkSpan< const Uniform >	graphiteUniforms,
		const SkData *	uniformData,
		PipelineDataGatherer *	gatherer
	)

static

Definition at line 1098 of file KeyHelpers.cpp.

                                                                           {
    if (!uniformData) {
        return;  // precompiling
    }
 
    SkDEBUGCODE(UniformExpectationsValidator uev(gatherer, graphiteUniforms);)
 
    SkSpan<const SkRuntimeEffect::Uniform> rtsUniforms = effect->uniforms();
 
    if (!rtsUniforms.empty() && uniformData) {
        // Collect all the other uniforms from the provided SkData.
        const uint8_t* uniformBase = uniformData->bytes();
        for (size_t index = 0; index < rtsUniforms.size(); ++index) {
            const Uniform& uniform = graphiteUniforms[index];
            // Get a pointer to the offset in our data for this uniform.
            const uint8_t* uniformPtr = uniformBase + rtsUniforms[index].offset;
            // Pass the uniform data to the gatherer.
            gatherer->write(uniform, uniformPtr);
        }
    }
 
    if (SkRuntimeEffectPriv::UsesColorTransform(effect)) {
        SkColorSpace* dstCS = keyContext.dstColorInfo().colorSpace();
        if (!dstCS) {
            dstCS = sk_srgb_linear_singleton(); // turn colorspace conversion into a noop
        }
 
        // TODO(b/332565302): If the runtime shader only uses one of these
        // transforms, we could upload only one set of uniforms.
        ColorSpaceTransformBlock::ColorSpaceTransformData dstToLinear(dstCS,
                                                                      kUnpremul_SkAlphaType,
                                                                      sk_srgb_linear_singleton(),
                                                                      kUnpremul_SkAlphaType);
        ColorSpaceTransformBlock::ColorSpaceTransformData linearToDst(sk_srgb_linear_singleton(),
                                                                      kUnpremul_SkAlphaType,
                                                                      dstCS,
                                                                      kUnpremul_SkAlphaType);
 
        add_color_space_uniforms(dstToLinear.fSteps, ReadSwizzle::kRGBA, gatherer);
        add_color_space_uniforms(linearToDst.fSteps, ReadSwizzle::kRGBA, gatherer);
    }
}

◆ GenerateMipmaps()

bool skgpu::graphite::GenerateMipmaps	(	Recorder *	recorder,
		sk_sp< TextureProxy >	texture,
		const SkColorInfo &	colorInfo
	)

Definition at line 727 of file TextureUtils.cpp.

                                                   {
    constexpr SkSamplingOptions kSamplingOptions = SkSamplingOptions(SkFilterMode::kLinear);
 
    SkASSERT(texture->mipmapped() == Mipmapped::kYes);
 
    // Within a rescaling pass scratchImg is read from and a scratch surface is written to.
    // At the end of the pass the scratch surface's texture is wrapped and assigned to scratchImg.
 
    // The scratch surface we create below will use a write swizzle derived from SkColorType and
    // pixel format. We have to be consistent and swizzle on the read.
    auto imgSwizzle = recorder->priv().caps()->getReadSwizzle(colorInfo.colorType(),
                                                              texture->textureInfo());
    sk_sp<SkImage> scratchImg(new Image(TextureProxyView(texture, imgSwizzle), colorInfo));
 
    SkISize srcSize = texture->dimensions();
    const SkColorInfo outColorInfo = colorInfo.makeAlphaType(kPremul_SkAlphaType);
 
    // Alternate between two scratch surfaces to avoid reading from and writing to a texture in the
    // same pass. The dimensions of the first usages of the two scratch textures will be 1/2 and 1/4
    // those of the original texture, respectively.
    sk_sp<Surface> scratchSurfaces[2];
    for (int i = 0; i < 2; ++i) {
        scratchSurfaces[i] = make_renderable_scratch_surface(
                recorder,
                SkImageInfo::Make(SkISize::Make(std::max(1, srcSize.width() >> (i + 1)),
                                                std::max(1, srcSize.height() >> (i + 1))),
                                  outColorInfo),
                SkBackingFit::kApprox,
                "GenerateMipmapsScratchTexture");
        if (!scratchSurfaces[i]) {
            return false;
        }
    }
 
    for (int mipLevel = 1; srcSize.width() > 1 || srcSize.height() > 1; ++mipLevel) {
        const SkISize dstSize = SkISize::Make(std::max(srcSize.width() >> 1, 1),
                                              std::max(srcSize.height() >> 1, 1));
 
        Surface* scratchSurface = scratchSurfaces[(mipLevel - 1) & 1].get();
 
        SkPaint paint;
        paint.setBlendMode(SkBlendMode::kSrc);
        scratchSurface->getCanvas()->drawImageRect(scratchImg,
                                                   SkRect::Make(srcSize),
                                                   SkRect::Make(dstSize),
                                                   kSamplingOptions,
                                                   &paint,
                                                   SkCanvas::kStrict_SrcRectConstraint);
 
        // Make sure the rescaling draw finishes before copying the results.
        Flush(scratchSurface);
 
        sk_sp<CopyTextureToTextureTask> copyTask = CopyTextureToTextureTask::Make(
                static_cast<const Surface*>(scratchSurface)->readSurfaceView().refProxy(),
                SkIRect::MakeSize(dstSize),
                texture,
                {0, 0},
                mipLevel);
        if (!copyTask) {
            return false;
        }
        recorder->priv().add(std::move(copyTask));
 
        scratchImg = scratchSurface->asImage();
        srcSize = dstSize;
    }
 
    return true;
}

◆ GeneratePathMaskKey()

skgpu::UniqueKey skgpu::graphite::GeneratePathMaskKey	(	const Shape &	shape,
		const Transform &	transform,
		const SkStrokeRec &	strokeRec,
		skvx::half2	maskSize
	)

Definition at line 69 of file RasterPathUtils.cpp.

                                                         {
    skgpu::UniqueKey maskKey;
    {
        static const skgpu::UniqueKey::Domain kDomain = skgpu::UniqueKey::GenerateDomain();
        int styleKeySize = 6;
        if (!strokeRec.isHairlineStyle() && !strokeRec.isFillStyle()) {
            // Add space for width and miter if needed
            styleKeySize += 2;
        }
        skgpu::UniqueKey::Builder builder(&maskKey, kDomain, styleKeySize + shape.keySize(),
                                          "Raster Path Mask");
        builder[0] = maskSize.x() | (maskSize.y() << 16);
 
        // We require the upper left 2x2 of the matrix to match exactly for a cache hit.
        SkMatrix mat = transform.matrix().asM33();
        SkScalar sx = mat.get(SkMatrix::kMScaleX);
        SkScalar sy = mat.get(SkMatrix::kMScaleY);
        SkScalar kx = mat.get(SkMatrix::kMSkewX);
        SkScalar ky = mat.get(SkMatrix::kMSkewY);
#ifdef SK_BUILD_FOR_ANDROID_FRAMEWORK
        // Fractional translate does not affect caching on Android. This is done for better cache
        // hit ratio and speed and is matching HWUI behavior, which didn't consider the matrix
        // at all when caching paths.
        SkFixed fracX = 0;
        SkFixed fracY = 0;
#else
        SkScalar tx = mat.get(SkMatrix::kMTransX);
        SkScalar ty = mat.get(SkMatrix::kMTransY);
        // Allow 8 bits each in x and y of subpixel positioning.
        SkFixed fracX = SkScalarToFixed(SkScalarFraction(tx)) & 0x0000FF00;
        SkFixed fracY = SkScalarToFixed(SkScalarFraction(ty)) & 0x0000FF00;
#endif
        builder[1] = SkFloat2Bits(sx);
        builder[2] = SkFloat2Bits(sy);
        builder[3] = SkFloat2Bits(kx);
        builder[4] = SkFloat2Bits(ky);
        // FracX and fracY are &ed with 0x0000ff00, so need to shift one down to fill 16 bits.
        uint32_t fracBits = fracX | (fracY >> 8);
        // Distinguish between path styles. For anything but fill, we also need to include
        // the cap. (SW grows hairlines by 0.5 pixel with round and square caps). For stroke
        // or fill-and-stroke we need to include the join, width, and miter.
        static_assert(SkStrokeRec::kStyleCount <= (1 << 2));
        static_assert(SkPaint::kCapCount <= (1 << 2));
        static_assert(SkPaint::kJoinCount <= (1 << 2));
        uint32_t styleBits = strokeRec.getStyle();
        if (!strokeRec.isFillStyle()) {
            styleBits |= (strokeRec.getCap() << 2);
        }
        if (!strokeRec.isHairlineStyle() && !strokeRec.isFillStyle()) {
            styleBits |= (strokeRec.getJoin() << 4);
            builder[5] = SkFloat2Bits(strokeRec.getWidth());
            builder[6] = SkFloat2Bits(strokeRec.getMiter());
        }
        builder[styleKeySize-1] = fracBits | (styleBits << 16);
        shape.writeKey(&builder[styleKeySize], /*includeInverted=*/false);
    }
    return maskKey;
}

◆ get_device_translation()

static skvx::float2 skgpu::graphite::get_device_translation ( const SkM44 & localToDevice )

static

Definition at line 21 of file CoverageMaskRenderStep.cpp.

                                                                     {
    float m00 = localToDevice.rc(0,0), m01 = localToDevice.rc(0,1);
    float m10 = localToDevice.rc(1,0), m11 = localToDevice.rc(1,1);
 
    float det = m00*m11 - m01*m10;
    if (SkScalarNearlyZero(det)) {
        // We can't extract any pre-translation, since the upper 2x2 is not invertible. Return (0,0)
        // so that the maskToDeviceRemainder matrix remains the full transform.
        return {0.f, 0.f};
    }
 
    // Calculate inv([[m00,m01][m10,m11]])*[[m30][m31]] to get the pre-remainder device translation.
    float tx = localToDevice.rc(0,3), ty = localToDevice.rc(1,3);
    skvx::float4 invT = skvx::float4{m11, -m10, -m01, m00} * skvx::float4{tx,tx,ty,ty};
    return (invT.xy() + invT.zw()) / det;
}

◆ get_packed_glyph_image()

static void skgpu::graphite::get_packed_glyph_image	(	const SkGlyph &	glyph,
		int	dstRB,
		MaskFormat	expectedMaskFormat,
		void *	dst
	)

static

Definition at line 78 of file TextAtlasManager.cpp.

                                                                                   {
    const int width = glyph.width();
    const int height = glyph.height();
    const void* src = glyph.image();
    SkASSERT(src != nullptr);
 
    MaskFormat maskFormat = Glyph::FormatFromSkGlyph(glyph.maskFormat());
    if (maskFormat == expectedMaskFormat) {
        int srcRB = glyph.rowBytes();
        // Notice this comparison is with the glyphs raw mask format, and not its MaskFormat.
        if (glyph.maskFormat() != SkMask::kBW_Format) {
            if (srcRB != dstRB) {
                const int bbp = MaskFormatBytesPerPixel(expectedMaskFormat);
                for (int y = 0; y < height; y++) {
                    memcpy(dst, src, width * bbp);
                    src = (const char*) src + srcRB;
                    dst = (char*) dst + dstRB;
                }
            } else {
                memcpy(dst, src, dstRB * height);
            }
        } else {
            // Handle 8-bit format by expanding the mask to the expected format.
            const uint8_t* bits = reinterpret_cast<const uint8_t*>(src);
            switch (expectedMaskFormat) {
                case MaskFormat::kA8: {
                    uint8_t* bytes = reinterpret_cast<uint8_t*>(dst);
                    expand_bits(bytes, bits, width, height, dstRB, srcRB);
                    break;
                }
                case MaskFormat::kA565: {
                    uint16_t* rgb565 = reinterpret_cast<uint16_t*>(dst);
                    expand_bits(rgb565, bits, width, height, dstRB, srcRB);
                    break;
                }
                default:
                    SK_ABORT("Invalid MaskFormat");
            }
        }
    } else if (maskFormat == MaskFormat::kA565 &&
               expectedMaskFormat == MaskFormat::kARGB) {
        // Convert if the glyph uses a 565 mask format since it is using LCD text rendering
        // but the expected format is 8888 (will happen on Intel MacOS with Metal since that
        // combination does not support 565).
        static constexpr SkMasks masks{
                {0b1111'1000'0000'0000, 11, 5},  // Red
                {0b0000'0111'1110'0000,  5, 6},  // Green
                {0b0000'0000'0001'1111,  0, 5},  // Blue
                {0, 0, 0}                        // Alpha
        };
        constexpr int a565Bpp = MaskFormatBytesPerPixel(MaskFormat::kA565);
        constexpr int argbBpp = MaskFormatBytesPerPixel(MaskFormat::kARGB);
        constexpr bool kBGRAIsNative = kN32_SkColorType == kBGRA_8888_SkColorType;
        char* dstRow = (char*)dst;
        for (int y = 0; y < height; y++) {
            dst = dstRow;
            for (int x = 0; x < width; x++) {
                uint16_t color565 = 0;
                memcpy(&color565, src, a565Bpp);
                uint32_t color8888;
                // On Windows (and possibly others), font data is stored as BGR.
                // So we need to swizzle the data to reflect that.
                if (kBGRAIsNative) {
                    color8888 = masks.getBlue(color565) |
                                (masks.getGreen(color565) << 8) |
                                (masks.getRed(color565) << 16) |
                                (0xFF << 24);
                } else {
                    color8888 = masks.getRed(color565) |
                                (masks.getGreen(color565) << 8) |
                                (masks.getBlue(color565) << 16) |
                                (0xFF << 24);
                }
                memcpy(dst, &color8888, argbBpp);
                src = (const char*)src + a565Bpp;
                dst = (      char*)dst + argbBpp;
            }
            dstRow += dstRB;
        }
    } else {
        SkUNREACHABLE;
    }
}

◆ GetDstReadRequirement()

DstReadRequirement skgpu::graphite::GetDstReadRequirement	(	const Caps *	caps,
		std::optional< SkBlendMode >	blendMode,
		Coverage	coverage
	)

Definition at line 95 of file ContextUtils.cpp.

                                                            {
    // If the blend mode is absent, this is assumed to be for a runtime blender, for which we always
    // do a dst read.
    if (!blendMode || *blendMode > SkBlendMode::kLastCoeffMode) {
        return caps->getDstReadRequirement();
    }
 
    const bool isLCD = coverage == Coverage::kLCD;
    const bool hasCoverage = coverage != Coverage::kNone;
    BlendFormula blendFormula = isLCD ? skgpu::GetLCDBlendFormula(*blendMode)
                                      : skgpu::GetBlendFormula(false, hasCoverage, *blendMode);
    if ((blendFormula.hasSecondaryOutput() && !caps->shaderCaps()->fDualSourceBlendingSupport) ||
        (coverage == Coverage::kLCD && blendMode != SkBlendMode::kSrcOver)) {
        return caps->getDstReadRequirement();
    }
 
    return DstReadRequirement::kNone;
}

◆ GetGraphiteBacked()

std::pair< sk_sp< SkImage >, SkSamplingOptions > skgpu::graphite::GetGraphiteBacked	(	Recorder *	recorder,
		const SkImage *	imageIn,
		SkSamplingOptions	sampling
	)

Definition at line 799 of file TextureUtils.cpp.

                                                                                           {
    Mipmapped mipmapped = (sampling.mipmap != SkMipmapMode::kNone)
                                     ? Mipmapped::kYes : Mipmapped::kNo;
 
    if (imageIn->dimensions().area() <= 1 && mipmapped == Mipmapped::kYes) {
        mipmapped = Mipmapped::kNo;
        sampling = SkSamplingOptions(SkFilterMode::kLinear, SkMipmapMode::kNone);
    }
 
    sk_sp<SkImage> result;
    if (as_IB(imageIn)->isGraphiteBacked()) {
        result = sk_ref_sp(imageIn);
 
        // If the preexisting Graphite-backed image doesn't have the required mipmaps we will drop
        // down the sampling
        if (mipmapped == Mipmapped::kYes && !result->hasMipmaps()) {
            mipmapped = Mipmapped::kNo;
            sampling = SkSamplingOptions(SkFilterMode::kLinear, SkMipmapMode::kNone);
        }
    } else {
        auto clientImageProvider = recorder->clientImageProvider();
        result = clientImageProvider->findOrCreate(
                recorder, imageIn, {mipmapped == Mipmapped::kYes});
 
        if (!valid_client_provided_image(
                    result.get(), imageIn, {mipmapped == Mipmapped::kYes})) {
            // The client did not fulfill the ImageProvider contract so drop the image.
            result = nullptr;
        }
    }
 
    if (sampling.isAniso() && result) {
        sampling = SkSamplingPriv::AnisoFallback(result->hasMipmaps());
    }
 
    return { result, sampling };
}

◆ GetPipelineLabel()

std::string skgpu::graphite::GetPipelineLabel	(	const ShaderCodeDictionary *	dict,
		const RenderPassDesc &	renderPassDesc,
		const RenderStep *	renderStep,
		UniquePaintParamsID	paintID
	)

Definition at line 593 of file ContextUtils.cpp.

                                                          {
    std::string label = renderPassDesc.toPipelineLabel().c_str(); // includes the write swizzle
    label += " + ";
    label += renderStep->name();
    label += " + ";
    label += dict->idToString(paintID).c_str(); // will be "(empty)" for depth-only draws
    return label;
}

◆ graphite_to_mtl_primitive()

static MTLPrimitiveType skgpu::graphite::graphite_to_mtl_primitive ( PrimitiveType primitiveType )

static

Definition at line 615 of file MtlCommandBuffer.mm.

                                                                               {
    const static MTLPrimitiveType mtlPrimitiveType[] {
        MTLPrimitiveTypeTriangle,
        MTLPrimitiveTypeTriangleStrip,
        MTLPrimitiveTypePoint,
    };
    static_assert((int)PrimitiveType::kTriangles == 0);
    static_assert((int)PrimitiveType::kTriangleStrip == 1);
    static_assert((int)PrimitiveType::kPoints == 2);
 
    SkASSERT(primitiveType <= PrimitiveType::kPoints);
    return mtlPrimitiveType[static_cast<int>(primitiveType)];
}

◆ is_clockwise() [1/2]

static bool skgpu::graphite::is_clockwise ( const EdgeAAQuad & quad )

static

Definition at line 206 of file AnalyticRRectRenderStep.cpp.

                                                 {
    if (quad.isRect()) {
        return true; // by construction, these are always locally clockwise
    }
 
    // This assumes that each corner has a consistent winding, which is the case for convex inputs,
    // which is an assumption of the per-edge AA API. Check the sign of cross product between the
    // first two edges.
    const skvx::float4& xs = quad.xs();
    const skvx::float4& ys = quad.ys();
 
    float winding = (xs[0] - xs[3])*(ys[1] - ys[0]) - (ys[0] - ys[3])*(xs[1] - xs[0]);
    if (winding == 0.f) {
        // The input possibly forms a triangle with duplicate vertices, so check the opposite corner
        winding = (xs[2] - xs[1])*(ys[3] - ys[2]) - (ys[2] - ys[1])*(xs[3] - xs[2]);
    }
 
    // At this point if winding is < 0, the quad's vertices are CCW. If it's still 0, the vertices
    // form a line, in which case the vertex shader constructs a correct CW winding. Otherwise,
    // the quad or triangle vertices produce a positive winding and are CW.
    return winding >= 0.f;
}

◆ is_clockwise() [2/2]

static bool skgpu::graphite::is_clockwise ( const EdgeAAQuad & quad )

static

Definition at line 96 of file PerEdgeAAQuadRenderStep.cpp.

                                                 {
    if (quad.isRect()) {
        return true; // by construction, these are always locally clockwise
    }
 
    // This assumes that each corner has a consistent winding, which is the case for convex inputs,
    // which is an assumption of the per-edge AA API. Check the sign of cross product between the
    // first two edges.
    const skvx::float4& xs = quad.xs();
    const skvx::float4& ys = quad.ys();
 
    float winding = (xs[0] - xs[3])*(ys[1] - ys[0]) - (ys[0] - ys[3])*(xs[1] - xs[0]);
    if (winding == 0.f) {
        // The input possibly forms a triangle with duplicate vertices, so check the opposite corner
        winding = (xs[2] - xs[1])*(ys[3] - ys[2]) - (ys[2] - ys[1])*(xs[3] - xs[2]);
    }
 
    // At this point if winding is < 0, the quad's vertices are CCW. If it's still 0, the vertices
    // form a line, in which case the vertex shader constructs a correct CW winding. Otherwise,
    // the quad or triangle vertices produce a positive winding and are CW.
    return winding >= 0.f;
}

◆ key_to_string()

static int skgpu::graphite::key_to_string	(	SkString *	str,
		const ShaderCodeDictionary *	dict,
		SkSpan< const uint32_t >	keyData,
		int	currentIndex,
		bool	includeData
	)

static

Definition at line 133 of file PaintParamsKey.cpp.

                                           {
    SkASSERT(currentIndex < SkTo<int>(keyData.size()));
 
    uint32_t id = keyData[currentIndex++];
    auto entry = dict->getEntry(id);
    if (!entry) {
        str->append("UnknownCodeSnippetID:");
        str->appendS32(id);
        str->append(" ");
        return currentIndex;
    }
 
    std::string_view name = entry->fName;
    if (skstd::ends_with(name, "Shader")) {
        name.remove_suffix(6);
    }
    str->append(name);
 
    if (entry->storesData()) {
        SkASSERT(currentIndex + 1 < SkTo<int>(keyData.size()));
        const int dataLength = keyData[currentIndex++];
        SkASSERT(currentIndex + dataLength < SkTo<int>(keyData.size()));
 
        str->append(" fData(size: ");
        str->appendU32(dataLength);
        str->append(")");
 
        if (includeData) {
            str->append(":[");
            for (int i = 0; i < dataLength; i++) {
                str->append(" ");
                str->appendU32(keyData[currentIndex + i]);
            }
            str->append(" ]");
        }
 
        currentIndex += dataLength;
    }
 
    if (entry->fNumChildren > 0) {
        str->append(" [ ");
        for (int i = 0; i < entry->fNumChildren; ++i) {
            currentIndex = key_to_string(str, dict, keyData, currentIndex, includeData);
        }
        str->append("]");
    }
 
    str->append(" ");
    return currentIndex;
}

◆ LayoutString()

static constexpr const char * skgpu::graphite::LayoutString ( Layout layout )

staticconstexpr

Definition at line 84 of file ResourceTypes.h.

                                                         {
    switch(layout) {
        case Layout::kStd140:  return "std140";
        case Layout::kStd430:  return "std430";
        case Layout::kMetal:   return "metal";
        case Layout::kInvalid: return "invalid";
    }
    SkUNREACHABLE;
}

◆ load_x_radii()

static skvx::float4 skgpu::graphite::load_x_radii ( const SkRRect & rrect )

static

Definition at line 139 of file AnalyticRRectRenderStep.cpp.

                                                     {
    return skvx::float4{rrect.radii(SkRRect::kUpperLeft_Corner).fX,
                        rrect.radii(SkRRect::kUpperRight_Corner).fX,
                        rrect.radii(SkRRect::kLowerRight_Corner).fX,
                        rrect.radii(SkRRect::kLowerLeft_Corner).fX};
}

◆ load_y_radii()

static skvx::float4 skgpu::graphite::load_y_radii ( const SkRRect & rrect )

static

Definition at line 145 of file AnalyticRRectRenderStep.cpp.

                                                     {
    return skvx::float4{rrect.radii(SkRRect::kUpperLeft_Corner).fY,
                        rrect.radii(SkRRect::kUpperRight_Corner).fY,
                        rrect.radii(SkRRect::kLowerRight_Corner).fY,
                        rrect.radii(SkRRect::kLowerLeft_Corner).fY};
}

◆ make_interpolated_to_dst()

static void skgpu::graphite::make_interpolated_to_dst	(	const KeyContext &	keyContext,
		PaintParamsKeyBuilder *	builder,
		PipelineDataGatherer *	gatherer,
		const GradientShaderBlocks::GradientData &	gradData,
		const SkGradientShader::Interpolation &	interp,
		SkColorSpace *	intermediateCS
	)

static

Definition at line 2215 of file KeyHelpers.cpp.

                                                                   {
    using ColorSpace = SkGradientShader::Interpolation::ColorSpace;
 
    bool inputPremul = static_cast<bool>(interp.fInPremul);
 
    switch (interp.fColorSpace) {
        case ColorSpace::kLab:
        case ColorSpace::kOKLab:
        case ColorSpace::kOKLabGamutMap:
        case ColorSpace::kLCH:
        case ColorSpace::kOKLCH:
        case ColorSpace::kOKLCHGamutMap:
        case ColorSpace::kHSL:
        case ColorSpace::kHWB:
            inputPremul = false;
            break;
        default:
            break;
    }
 
    const SkColorInfo& dstColorInfo = keyContext.dstColorInfo();
 
    SkColorSpace* dstColorSpace =
            dstColorInfo.colorSpace() ? dstColorInfo.colorSpace() : sk_srgb_singleton();
 
    SkAlphaType intermediateAlphaType = inputPremul ? kPremul_SkAlphaType : kUnpremul_SkAlphaType;
 
    ColorSpaceTransformBlock::ColorSpaceTransformData data(
            intermediateCS, intermediateAlphaType, dstColorSpace, dstColorInfo.alphaType());
 
    // The gradient block and colorSpace conversion block need to be combined
    // (via the Compose block) so that the localMatrix block can treat them as
    // one child.
    Compose(keyContext, builder, gatherer,
            /* addInnerToKey= */ [&]() -> void {
                GradientShaderBlocks::AddBlock(keyContext, builder, gatherer, gradData);
            },
            /* addOuterToKey= */ [&]() -> void {
                ColorSpaceTransformBlock::AddBlock(keyContext, builder, gatherer, data);
            });
}

◆ MakeBitmapProxyView()

std::tuple< TextureProxyView, SkColorType > skgpu::graphite::MakeBitmapProxyView	(	Recorder *	recorder,
		const SkBitmap &	bitmap,
		sk_sp< SkMipmap >	mipmapsIn,
		Mipmapped	mipmapped,
		Budgeted	budgeted,
		std::string_view	label
	)

Definition at line 380 of file TextureUtils.cpp.

                                                                                    {
    // Adjust params based on input and Caps
    const Caps* caps = recorder->priv().caps();
    SkColorType ct = bitmap.info().colorType();
 
    if (bitmap.dimensions().area() <= 1) {
        mipmapped = Mipmapped::kNo;
    }
 
    Protected isProtected = recorder->priv().isProtected();
    auto textureInfo = caps->getDefaultSampledTextureInfo(ct, mipmapped, isProtected,
                                                          Renderable::kNo);
    if (!textureInfo.isValid()) {
        ct = kRGBA_8888_SkColorType;
        textureInfo = caps->getDefaultSampledTextureInfo(ct, mipmapped, isProtected,
                                                         Renderable::kNo);
    }
    SkASSERT(textureInfo.isValid());
 
    // Convert bitmap to texture colortype if necessary
    SkBitmap bmpToUpload;
    if (ct != bitmap.info().colorType()) {
        if (!bmpToUpload.tryAllocPixels(bitmap.info().makeColorType(ct)) ||
            !bitmap.readPixels(bmpToUpload.pixmap())) {
            return {};
        }
        bmpToUpload.setImmutable();
    } else {
        bmpToUpload = bitmap;
    }
 
    if (!SkImageInfoIsValid(bmpToUpload.info())) {
        return {};
    }
 
    int mipLevelCount = (mipmapped == Mipmapped::kYes) ?
            SkMipmap::ComputeLevelCount(bitmap.width(), bitmap.height()) + 1 : 1;
 
 
    // setup MipLevels
    sk_sp<SkMipmap> mipmaps;
    std::vector<MipLevel> texels;
    if (mipLevelCount == 1) {
        texels.resize(mipLevelCount);
        texels[0].fPixels = bmpToUpload.getPixels();
        texels[0].fRowBytes = bmpToUpload.rowBytes();
    } else {
        mipmaps = SkToBool(mipmapsIn)
                          ? mipmapsIn
                          : sk_sp<SkMipmap>(SkMipmap::Build(bmpToUpload.pixmap(), nullptr));
        if (!mipmaps) {
            return {};
        }
 
        SkASSERT(mipLevelCount == mipmaps->countLevels() + 1);
        texels.resize(mipLevelCount);
 
        texels[0].fPixels = bmpToUpload.getPixels();
        texels[0].fRowBytes = bmpToUpload.rowBytes();
 
        for (int i = 1; i < mipLevelCount; ++i) {
            SkMipmap::Level generatedMipLevel;
            mipmaps->getLevel(i - 1, &generatedMipLevel);
            texels[i].fPixels = generatedMipLevel.fPixmap.addr();
            texels[i].fRowBytes = generatedMipLevel.fPixmap.rowBytes();
            SkASSERT(texels[i].fPixels);
            SkASSERT(generatedMipLevel.fPixmap.colorType() == bmpToUpload.colorType());
        }
    }
 
    // Create proxy
    sk_sp<TextureProxy> proxy = TextureProxy::Make(caps,
                                                   recorder->priv().resourceProvider(),
                                                   bmpToUpload.dimensions(),
                                                   textureInfo,
                                                   std::move(label),
                                                   budgeted);
    if (!proxy) {
        return {};
    }
    SkASSERT(caps->areColorTypeAndTextureInfoCompatible(ct, proxy->textureInfo()));
    SkASSERT(mipmapped == Mipmapped::kNo || proxy->mipmapped() == Mipmapped::kYes);
 
    // Src and dst colorInfo are the same
    const SkColorInfo& colorInfo = bmpToUpload.info().colorInfo();
    // Add UploadTask to Recorder
    UploadInstance upload = UploadInstance::Make(
            recorder, proxy, colorInfo, colorInfo, texels,
            SkIRect::MakeSize(bmpToUpload.dimensions()), std::make_unique<ImageUploadContext>());
    if (!upload.isValid()) {
        SKGPU_LOG_E("MakeBitmapProxyView: Could not create UploadInstance");
        return {};
    }
    recorder->priv().add(UploadTask::Make(std::move(upload)));
 
    Swizzle swizzle = caps->getReadSwizzle(ct, textureInfo);
    // If the color type is alpha-only, propagate the alpha value to the other channels.
    if (SkColorTypeIsAlphaOnly(colorInfo.colorType())) {
        swizzle = Swizzle::Concat(swizzle, Swizzle("aaaa"));
    }
    return {{std::move(proxy), swizzle}, ct};
}

◆ MakeFromBitmap()

sk_sp< SkImage > skgpu::graphite::MakeFromBitmap	(	Recorder *	recorder,
		const SkColorInfo &	colorInfo,
		const SkBitmap &	bitmap,
		sk_sp< SkMipmap >	mipmaps,
		Budgeted	budgeted,
		SkImage::RequiredProperties	requiredProps,
		std::string_view	label
	)

Definition at line 513 of file TextureUtils.cpp.

                                                    {
    auto mm = requiredProps.fMipmapped ? Mipmapped::kYes : Mipmapped::kNo;
    auto [view, ct] = MakeBitmapProxyView(recorder,
                                          bitmap,
                                          std::move(mipmaps),
                                          mm,
                                          budgeted,
                                          std::move(label));
    if (!view) {
        return nullptr;
    }
 
    SkASSERT(!requiredProps.fMipmapped || view.proxy()->mipmapped() == Mipmapped::kYes);
    return sk_make_sp<skgpu::graphite::Image>(std::move(view), colorInfo.makeColorType(ct));
}

◆ MakePrecompileBlender()

sk_sp< PrecompileBlender > skgpu::graphite::MakePrecompileBlender	(	sk_sp< SkRuntimeEffect >	effect,
		SkSpan< const PrecompileChildOptions >	childOptions
	)

Definition at line 661 of file FactoryFunctions.cpp.

                                                           {
    // TODO: check that 'effect' has the kAllowBlender_Flag bit set and:
    //  for each entry in childOptions:
    //    all the SkPrecompileChildPtrs have the same type as the corresponding child in the effect
    return sk_make_sp<PrecompileRTEffect<PrecompileBlender>>(std::move(effect), childOptions);
}

◆ MakePrecompileColorFilter()

sk_sp< PrecompileColorFilter > skgpu::graphite::MakePrecompileColorFilter	(	sk_sp< SkRuntimeEffect >	effect,
		SkSpan< const PrecompileChildOptions >	childOptions
	)

Definition at line 652 of file FactoryFunctions.cpp.

                                                           {
    // TODO: check that 'effect' has the kAllowColorFilter_Flag bit set and:
    //  for each entry in childOptions:
    //    all the SkPrecompileChildPtrs have the same type as the corresponding child in the effect
    return sk_make_sp<PrecompileRTEffect<PrecompileColorFilter>>(std::move(effect), childOptions);
}

◆ MakePrecompileShader()

sk_sp< PrecompileShader > skgpu::graphite::MakePrecompileShader	(	sk_sp< SkRuntimeEffect >	effect,
		SkSpan< const PrecompileChildOptions >	childOptions
	)

Definition at line 643 of file FactoryFunctions.cpp.

                                                           {
    // TODO: check that 'effect' has the kAllowShader_Flag bit set and:
    //  for each entry in childOptions:
    //    all the SkPrecompileChildPtrs have the same type as the corresponding child in the effect
    return sk_make_sp<PrecompileRTEffect<PrecompileShader>>(std::move(effect), childOptions);
}

◆ MakePromiseImageLazyProxy() [1/2]

sk_sp< TextureProxy > skgpu::graphite::MakePromiseImageLazyProxy	(	const Caps *	,
		SkISize	dimensions,
		TextureInfo	,
		Volatile	,
		sk_sp< skgpu::RefCntedCallback >	releaseHelper,
		SkImages::GraphitePromiseTextureFulfillProc	,
		SkImages::GraphitePromiseTextureFulfillContext	,
		SkImages::GraphitePromiseTextureReleaseProc	,
		std::string_view	label
	)

◆ MakePromiseImageLazyProxy() [2/2]

sk_sp< TextureProxy > skgpu::graphite::MakePromiseImageLazyProxy	(	const Caps *	caps,
		SkISize	dimensions,
		TextureInfo	textureInfo,
		Volatile	isVolatile,
		sk_sp< RefCntedCallback >	releaseHelper,
		GraphitePromiseTextureFulfillProc	fulfillProc,
		GraphitePromiseTextureFulfillContext	fulfillContext,
		GraphitePromiseTextureReleaseProc	textureReleaseProc,
		std::string_view	label
	)

Definition at line 488 of file TextureUtils.cpp.

                              {
    SkASSERT(!dimensions.isEmpty());
    SkASSERT(releaseHelper);
 
    if (!fulfillProc) {
        return nullptr;
    }
 
    PromiseLazyInstantiateCallback callback{std::move(releaseHelper), fulfillProc,
                                            fulfillContext, textureReleaseProc, std::move(label)};
    // Proxies for promise images are assumed to always be destined for a client's SkImage so
    // are never considered budgeted.
    return TextureProxy::MakeLazy(caps, dimensions, textureInfo, Budgeted::kNo, isVolatile,
                                  std::move(callback));
}

◆ map_color()

static SkPMColor4f skgpu::graphite::map_color	(	const SkColor4f &	c,
		SkColorSpace *	src,
		SkColorSpace *	dst
	)

static

Definition at line 1302 of file KeyHelpers.cpp.

                                                                                       {
    SkPMColor4f color = {c.fR, c.fG, c.fB, c.fA};
    SkColorSpaceXformSteps(src, kUnpremul_SkAlphaType, dst, kPremul_SkAlphaType).apply(color.vec());
    return color;
}

◆ MtlCompileShaderLibrary()

sk_cfp< id< MTLLibrary > > skgpu::graphite::MtlCompileShaderLibrary	(	const MtlSharedContext *	sharedContext,
		std::string_view	label,
		std::string_view	msl,
		ShaderErrorHandler *	errorHandler
	)

Definition at line 44 of file MtlGraphiteUtils.mm.

                                                                                 {
    TRACE_EVENT0("skia.shaders", "driver_compile_shader");
    NSString* nsSource = [[NSString alloc] initWithBytesNoCopy:const_cast<char*>(msl.data())
                                                        length:msl.size()
                                                      encoding:NSUTF8StringEncoding
                                                  freeWhenDone:NO];
    if (!nsSource) {
        return nil;
    }
    MTLCompileOptions* options = [[MTLCompileOptions alloc] init];
 
    // Framebuffer fetch is supported in MSL 2.3 in MacOS 11+.
    if (@available(macOS 11.0, iOS 14.0, tvOS 14.0, *)) {
        options.languageVersion = MTLLanguageVersion2_3;
 
    // array<> is supported in MSL 2.0 on MacOS 10.13+ and iOS 11+,
    // and in MSL 1.2 on iOS 10+ (but not MacOS).
    } else if (@available(macOS 10.13, iOS 11.0, tvOS 11.0, *)) {
        options.languageVersion = MTLLanguageVersion2_0;
#if defined(SK_BUILD_FOR_IOS)
    } else if (@available(macOS 10.12, iOS 10.0, tvOS 10.0, *)) {
        options.languageVersion = MTLLanguageVersion1_2;
#endif
    }
 
    NSError* error = nil;
    // TODO: do we need a version with a timeout?
    sk_cfp<id<MTLLibrary>> compiledLibrary(
            [sharedContext->device() newLibraryWithSource:(NSString* _Nonnull)nsSource
                                                  options:options
                                                    error:&error]);
    if (!compiledLibrary) {
        std::string mslStr(msl);
        errorHandler->compileError(
                mslStr.c_str(), error.debugDescription.UTF8String, /*shaderWasCached=*/false);
        return nil;
    }
 
    NSString* nsLabel = [[NSString alloc] initWithBytesNoCopy:const_cast<char*>(label.data())
                                                       length:label.size()
                                                     encoding:NSUTF8StringEncoding
                                                 freeWhenDone:NO];
    compiledLibrary.get().label = nsLabel;
    return compiledLibrary;
}

◆ MtlFormatBytesPerBlock()

size_t skgpu::graphite::MtlFormatBytesPerBlock ( MtlPixelFormat format )

Definition at line 93 of file MtlGraphiteUtils.mm.

                                                     {
    return skgpu::MtlFormatBytesPerBlock((MTLPixelFormat) format);
}

◆ MtlFormatToCompressionType()

SkTextureCompressionType skgpu::graphite::MtlFormatToCompressionType ( MtlPixelFormat format )

Definition at line 97 of file MtlGraphiteUtils.mm.

                                                                           {
    return skgpu::MtlFormatToCompressionType((MTLPixelFormat) format);
}

◆ MtlTextureSpecToTextureInfo()

MtlTextureInfo skgpu::graphite::MtlTextureSpecToTextureInfo	(	const MtlTextureSpec &	mtlSpec,
		uint32_t	sampleCount,
		Mipmapped	mipmapped
	)

Definition at line 27 of file MtlGraphiteTypes.mm.

                                                                {
    MtlTextureInfo info;
    // Shared info
    info.fSampleCount = sampleCount;
    info.fMipmapped = mipmapped;
 
    // Mtl info
    info.fFormat = mtlSpec.fFormat;
    info.fUsage = mtlSpec.fUsage;
    info.fStorageMode = mtlSpec.fStorageMode;
    info.fFramebufferOnly = mtlSpec.fFramebufferOnly;
 
    return info;
}

◆ next_id() [1/3]

static uint32_t skgpu::graphite::next_id ( )

static

Definition at line 70 of file DrawAtlas.cpp.

                          {
    static std::atomic<uint32_t> nextID{1};
    uint32_t id;
    do {
        id = nextID.fetch_add(1, std::memory_order_relaxed);
    } while (id == SK_InvalidGenID);
    return id;
}

◆ next_id() [2/3]

static uint32_t skgpu::graphite::next_id ( )

static

Definition at line 88 of file Recorder.cpp.

                          {
    static std::atomic<uint32_t> nextID{1};
    uint32_t id;
    do {
        id = nextID.fetch_add(1, std::memory_order_relaxed);
    } while (id == SK_InvalidGenID);
    return id;
}

◆ next_id() [3/3]

static uint32_t skgpu::graphite::next_id ( )

static

Definition at line 12 of file Renderer.cpp.

                          {
    static std::atomic<uint32_t> nextID{0};
    // Not worried about overflow since each Context won't have that many RenderSteps, so even if
    // it wraps back to 0, that RenderStep will not be in the same Context as the original 0.
    return nextID.fetch_add(1, std::memory_order_relaxed);
}

◆ notify_in_use() [1/16]

static void skgpu::graphite::notify_in_use	(	Recorder *	,
		DrawContext *	,
		const SkColor4Shader *
	)

static

Definition at line 1566 of file KeyHelpers.cpp.

                                                                          {
    // No-op
}

◆ notify_in_use() [2/16]

static void skgpu::graphite::notify_in_use	(	Recorder *	,
		DrawContext *	,
		const SkColorShader *
	)

static

Definition at line 1551 of file KeyHelpers.cpp.

                                                                         {
    // No-op
}

◆ notify_in_use() [3/16]

static void skgpu::graphite::notify_in_use	(	Recorder *	,
		DrawContext *	,
		const SkEmptyShader *
	)

static

Definition at line 1616 of file KeyHelpers.cpp.

                                                                         {
    // No-op
}

◆ notify_in_use() [4/16]

static void skgpu::graphite::notify_in_use	(	Recorder *	,
		DrawContext *	,
		const SkGradientBaseShader *
	)

static

Definition at line 2425 of file KeyHelpers.cpp.

                                                                                {
    // Gradients do not have children, so no images to notify
}

◆ notify_in_use() [5/16]

static void skgpu::graphite::notify_in_use	(	Recorder *	,
		DrawContext *	,
		const SkPerlinNoiseShader *
	)

static

Definition at line 2005 of file KeyHelpers.cpp.

                                                                               {
    // No-op, perlin noise has no children.
}

◆ notify_in_use() [6/16]

static void skgpu::graphite::notify_in_use	(	Recorder *	,
		DrawContext *	,
		const SkPictureShader *
	)

static

Definition at line 2083 of file KeyHelpers.cpp.

                                                                           {
    // While the SkPicture the shader points to, may have Graphite-backed shaders that need to be
    // notified, that will happen when the picture is rendered into an image in add_to_key
}

◆ notify_in_use() [7/16]

static void skgpu::graphite::notify_in_use	(	Recorder *	,
		DrawContext *	,
		const SkTransformShader *
	)

static

Definition at line 2121 of file KeyHelpers.cpp.

                                                                             {
    // no-op
}

◆ notify_in_use() [8/16]

static void skgpu::graphite::notify_in_use	(	Recorder *	,
		DrawContext *	,
		const SkTriColorShader *
	)

static

Definition at line 2132 of file KeyHelpers.cpp.

                                                                            {
    // no-op
}

◆ notify_in_use() [9/16]

static void skgpu::graphite::notify_in_use	(	Recorder *	recorder,
		DrawContext *	drawContext,
		const SkBlendShader *	shader
	)

static

Definition at line 1514 of file KeyHelpers.cpp.

                                                       {
    // SkBlendShader uses a fixed blend mode, so there's no blender to recurse through
    NotifyImagesInUse(recorder, drawContext, shader->src().get());
    NotifyImagesInUse(recorder, drawContext, shader->dst().get());
}

◆ notify_in_use() [10/16]

static void skgpu::graphite::notify_in_use	(	Recorder *	recorder,
		DrawContext *	drawContext,
		const SkColorFilterShader *	shader
	)

static

Definition at line 1584 of file KeyHelpers.cpp.

                                                             {
    NotifyImagesInUse(recorder, drawContext, shader->shader().get());
    NotifyImagesInUse(recorder, drawContext, shader->filter().get());
}

◆ notify_in_use() [11/16]

static void skgpu::graphite::notify_in_use	(	Recorder *	recorder,
		DrawContext *	drawContext,
		const SkCoordClampShader *	shader
	)

static

Definition at line 1604 of file KeyHelpers.cpp.

                                                            {
    NotifyImagesInUse(recorder, drawContext, shader->shader().get());
}

◆ notify_in_use() [12/16]

static void skgpu::graphite::notify_in_use	(	Recorder *	recorder,
		DrawContext *	drawContext,
		const SkCTMShader *	shader
	)

static

Definition at line 1538 of file KeyHelpers.cpp.

                                                                                                   {
    NotifyImagesInUse(recorder, drawContext, shader->proxyShader().get());
}

◆ notify_in_use() [13/16]

static void skgpu::graphite::notify_in_use	(	Recorder *	recorder,
		DrawContext *	drawContext,
		const SkImageShader *	shader
	)

static

Definition at line 1876 of file KeyHelpers.cpp.

                                                       {
    auto image = as_IB(shader->image());
    if (!image->isGraphiteBacked()) {
        // If it's not graphite-backed, there's no pending graphite work.
        return;
    }
 
    static_cast<Image_Base*>(image)->notifyInUse(recorder, drawContext);
}

◆ notify_in_use() [14/16]

static void skgpu::graphite::notify_in_use	(	Recorder *	recorder,
		DrawContext *	drawContext,
		const SkLocalMatrixShader *	shader
	)

static

Definition at line 1957 of file KeyHelpers.cpp.

                                                             {
    NotifyImagesInUse(recorder, drawContext, shader->wrappedShader().get());
}

◆ notify_in_use() [15/16]

static void skgpu::graphite::notify_in_use	(	Recorder *	recorder,
		DrawContext *	drawContext,
		const SkRuntimeShader *	shader
	)

static

Definition at line 2108 of file KeyHelpers.cpp.

                                                         {
    notify_in_use(recorder, drawContext, shader->children());
}

◆ notify_in_use() [16/16]

static void skgpu::graphite::notify_in_use	(	Recorder *	recorder,
		DrawContext *	drawContext,
		const SkWorkingColorSpaceShader *	shader
	)

static

Definition at line 2164 of file KeyHelpers.cpp.

                                                                   {
    NotifyImagesInUse(recorder, drawContext, shader->shader().get());
}

◆ NotifyImagesInUse() [1/3]

void skgpu::graphite::NotifyImagesInUse	(	Recorder *	recorder,
		DrawContext *	drawContext,
		const SkBlender *	blender
	)

Definition at line 1290 of file KeyHelpers.cpp.

                                                                                               {
    if (!blender) {
        return;
    }
    if (as_BB(blender)->type() == SkBlenderBase::BlenderType::kRuntime) {
        const auto* rbb = static_cast<const SkRuntimeBlender*>(blender);
        notify_in_use(recorder, drawContext, rbb->children());
    } // else blend mode doesn't reference images
}

◆ NotifyImagesInUse() [2/3]

void skgpu::graphite::NotifyImagesInUse	(	Recorder *	recorder,
		DrawContext *	drawContext,
		const SkColorFilter *	filter
	)

Definition at line 1475 of file KeyHelpers.cpp.

                                                                                                  {
    if (!filter) {
        return;
    }
    if (as_CFB(filter)->type() == SkColorFilterBase::Type::kCompose) {
        // Recurse to two children
        const auto* cf = static_cast<const SkComposeColorFilter*>(filter);
        NotifyImagesInUse(recorder, drawContext, cf->inner().get());
        NotifyImagesInUse(recorder, drawContext, cf->outer().get());
    } else if (as_CFB(filter)->type() == SkColorFilterBase::Type::kWorkingFormat) {
        // Recurse to one child
        const auto* wfcf = static_cast<const SkWorkingFormatColorFilter*>(filter);
        NotifyImagesInUse(recorder, drawContext, wfcf->child().get());
    } else if (as_CFB(filter)->type() == SkColorFilterBase::Type::kRuntime) {
        // Recurse to all children
        const auto* rcf = static_cast<const SkRuntimeColorFilter*>(filter);
        notify_in_use(recorder, drawContext, rcf->children());
    } // else other color filters do not rely on SkImages
}

◆ NotifyImagesInUse() [3/3]

void skgpu::graphite::NotifyImagesInUse	(	Recorder *	recorder,
		DrawContext *	drawContext,
		const SkShader *	shader
	)

Definition at line 2450 of file KeyHelpers.cpp.

                                               {
    if (!shader) {
        return;
    }
    switch (as_SB(shader)->type()) {
#define M(type)                                                      \
    case SkShaderBase::ShaderType::k##type:                          \
        notify_in_use(recorder,                                      \
                      drawContext,                                   \
                      static_cast<const Sk##type##Shader*>(shader)); \
        return;
        SK_ALL_SHADERS(M)
#undef M
    }
    SkUNREACHABLE;
}

◆ opposite_insets_intersect() [1/3]

static bool skgpu::graphite::opposite_insets_intersect	(	const Geometry &	geometry,
		float	strokeRadius,
		float	aaRadius
	)

static

Definition at line 171 of file AnalyticRRectRenderStep.cpp.

                                                      {
    if (geometry.isEdgeAAQuad()) {
        SkASSERT(strokeRadius == 0.f);
        const EdgeAAQuad& quad = geometry.edgeAAQuad();
        if (quad.edgeFlags() == AAFlags::kNone) {
            // If all edges are non-AA, there won't be any insetting. This allows completely non-AA
            // quads to use the fill triangles for simpler fragment shader work.
            return false;
        } else if (quad.isRect() && quad.edgeFlags() == AAFlags::kAll) {
            return opposite_insets_intersect(quad.bounds(), 0.f, aaRadius);
        } else {
            // Quads with mixed AA edges are tiles where non-AA edges must seam perfectly together.
            // If we were to inset along just the axis with AA at a corner, two adjacent quads could
            // arrive at slightly different inset coordinates and then we wouldn't have a perfect
            // mesh. Forcing insets to snap to the center means all non-AA edges are formed solely
            // by the original quad coordinates and should seam perfectly assuming perfect input.
            // The only downside to this is the fill triangles cannot be used since they would
            // partially extend into the coverage ramp from adjacent AA edges.
            return true;
        }
    } else {
        const Shape& shape = geometry.shape();
        if (shape.isLine()) {
            return strokeRadius <= aaRadius;
        } else if (shape.isRect()) {
            return opposite_insets_intersect(shape.rect(), strokeRadius, aaRadius);
        } else {
            SkASSERT(shape.isRRect());
            return opposite_insets_intersect(shape.rrect(), strokeRadius, aaRadius);
        }
    }
}

◆ opposite_insets_intersect() [2/3]

static bool skgpu::graphite::opposite_insets_intersect	(	const Rect &	rect,
		float	strokeRadius,
		float	aaRadius
	)

static

Definition at line 167 of file AnalyticRRectRenderStep.cpp.

                                                                                            {
    return any(rect.size() <= 2.f * (strokeRadius + aaRadius));
}

◆ opposite_insets_intersect() [3/3]

static bool skgpu::graphite::opposite_insets_intersect	(	const SkRRect &	rrect,
		float	strokeRadius,
		float	aaRadius
	)

static

Definition at line 152 of file AnalyticRRectRenderStep.cpp.

                                                                                                {
    // One AA inset per side
    const float maxInset = strokeRadius + 2.f * aaRadius;
    return // Horizontal insets would intersect opposite corner's curve
           maxInset >= rrect.width() - rrect.radii(SkRRect::kLowerLeft_Corner).fX   ||
           maxInset >= rrect.width() - rrect.radii(SkRRect::kLowerRight_Corner).fX  ||
           maxInset >= rrect.width() - rrect.radii(SkRRect::kUpperLeft_Corner).fX   ||
           maxInset >= rrect.width() - rrect.radii(SkRRect::kUpperRight_Corner).fX  ||
           // Vertical insets would intersect opposite corner's curve
           maxInset >= rrect.height() - rrect.radii(SkRRect::kLowerLeft_Corner).fY  ||
           maxInset >= rrect.height() - rrect.radii(SkRRect::kLowerRight_Corner).fY ||
           maxInset >= rrect.height() - rrect.radii(SkRRect::kUpperLeft_Corner).fY  ||
           maxInset >= rrect.height() - rrect.radii(SkRRect::kUpperRight_Corner).fY;
}

◆ PipelineStageFlagsToVkShaderStageFlags()

VkShaderStageFlags skgpu::graphite::PipelineStageFlagsToVkShaderStageFlags ( SkEnumBitMask< PipelineStageFlags > stageFlags )

Definition at line 163 of file VulkanGraphiteUtils.cpp.

                                                      {
    VkShaderStageFlags vkStageFlags = 0;
    if (stageFlags & PipelineStageFlags::kVertexShader) {
        vkStageFlags |= VK_SHADER_STAGE_VERTEX_BIT;
    }
    if (stageFlags & PipelineStageFlags::kFragmentShader) {
        vkStageFlags |= VK_SHADER_STAGE_FRAGMENT_BIT;
    }
    if (stageFlags & PipelineStageFlags::kCompute) {
        vkStageFlags |= VK_SHADER_STAGE_COMPUTE_BIT;
    }
    return vkStageFlags;
}

◆ Precompile() [1/2]

void skgpu::graphite::Precompile	(	Context *	context,
		const PaintOptions &	paintOptions,
		DrawTypeFlags	drawTypes = `kMostCommon`
	)

Precompilation allows clients to create pipelines ahead of time based on what they expect to draw. This can reduce performance hitches, due to inline compilation, during the actual drawing. Graphite will always be able to perform an inline compilation if some SkPaint combination was omitted from precompilation.

Parameters

context	the Context to which the actual draws will be submitted
paintOptions	captures a set of SkPaints that will be drawn
drawTypes	communicates which primitives those paints will be drawn with

Definition at line 102 of file PublicPrecompile.cpp.

                                                                                        {
 
    ShaderCodeDictionary* dict = context->priv().shaderCodeDictionary();
    const Caps* caps = context->priv().caps();
 
    auto rtEffectDict = std::make_unique<RuntimeEffectDictionary>();
 
    SkColorInfo ci(kRGBA_8888_SkColorType, kPremul_SkAlphaType, nullptr);
    KeyContext keyContext(
            caps, dict, rtEffectDict.get(), ci, /* dstTexture= */ nullptr, /* dstOffset= */ {0, 0});
 
    for (Coverage coverage : { Coverage::kNone, Coverage::kSingleChannel, Coverage::kLCD }) {
        PrecompileCombinations(
                context, options, keyContext,
                static_cast<DrawTypeFlags>(drawTypes & ~DrawTypeFlags::kDrawVertices),
                /* withPrimitiveBlender= */ false,
                coverage);
    }
 
    if (drawTypes & DrawTypeFlags::kDrawVertices) {
        for (Coverage coverage: { Coverage::kNone, Coverage::kSingleChannel, Coverage::kLCD }) {
            // drawVertices w/ colors use a primitiveBlender while those w/o don't
            for (bool withPrimitiveBlender : { true, false }) {
                PrecompileCombinations(context, options, keyContext,
                                       DrawTypeFlags::kDrawVertices,
                                       withPrimitiveBlender,
                                       coverage);
            }
        }
    }
}

◆ Precompile() [2/2]

bool skgpu::graphite::Precompile	(	Context *	context,
		RuntimeEffectDictionary *	rteDict,
		const GraphicsPipelineDesc &	pipelineDesc,
		const RenderPassDesc &	renderPassDesc
	)

Definition at line 84 of file PublicPrecompile.cpp.

                                                      {
    ResourceProvider* resourceProvider = context->priv().resourceProvider();
 
    sk_sp<GraphicsPipeline> pipeline = resourceProvider->findOrCreateGraphicsPipeline(
            rteDict,
            pipelineDesc,
            renderPassDesc);
    if (!pipeline) {
        SKGPU_LOG_W("Failed to create GraphicsPipeline in precompile!");
        return false;
    }
 
    return true;
}

◆ PrecompileCombinations()

void skgpu::graphite::PrecompileCombinations	(	Context *	context,
		const PaintOptions &	options,
		const KeyContext &	keyContext,
		DrawTypeFlags	drawTypes,
		bool	withPrimitiveBlender,
		Coverage	coverage
	)

Definition at line 134 of file PublicPrecompile.cpp.

                                               {
    const Caps* caps = keyContext.caps();
    // Since the precompilation path's uniforms aren't used and don't change the key,
    // the exact layout doesn't matter
    PipelineDataGatherer gatherer(Layout::kMetal);
 
    SkColorType destCT = keyContext.dstColorInfo().colorType();
    // TODO: we need iterate over a broader set of TextureInfos here. Perhaps, allow the client
    // to pass in colorType, mipmapping and protection.
    TextureInfo info = caps->getDefaultSampledTextureInfo(destCT,
                                                          Mipmapped::kNo,
                                                          Protected::kNo,
                                                          Renderable::kYes);
 
    Swizzle writeSwizzle = caps->getWriteSwizzle(destCT, info);
    // Note: at least on Metal, the LoadOp, StoreOp and clearColor fields don't influence the
    // actual RenderPassDescKey.
    // TODO: if all of the Renderers associated w/ the requested drawTypes require MSAA we
    // do not need to generate the combinations w/ the non-MSAA RenderPassDescs.
    const RenderPassDesc renderPassDescs[] = {
        RenderPassDesc::Make(caps,
                             info,
                             LoadOp::kClear,
                             StoreOp::kStore,
                             DepthStencilFlags::kDepth,
                             /* clearColor= */ { .0f, .0f, .0f, .0f },
                             /* requiresMSAA= */ true,
                             writeSwizzle),
        RenderPassDesc::Make(caps,
                             info,
                             LoadOp::kClear,
                             StoreOp::kStore,
                             DepthStencilFlags::kDepthStencil,
                             /* clearColor= */ { .0f, .0f, .0f, .0f },
                             /* requiresMSAA= */ true,
                             writeSwizzle),
        RenderPassDesc::Make(caps,
                             info,
                             LoadOp::kClear,
                             StoreOp::kStore,
                             DepthStencilFlags::kDepth,
                             /* clearColor= */ { .0f, .0f, .0f, .0f },
                             /* requiresMSAA= */ false,
                             writeSwizzle),
        RenderPassDesc::Make(caps,
                             info,
                             LoadOp::kClear,
                             StoreOp::kStore,
                             DepthStencilFlags::kDepthStencil,
                             /* clearColor= */ { .0f, .0f, .0f, .0f },
                             /* requiresMSAA= */ false,
                             writeSwizzle),
    };
 
    options.priv().buildCombinations(
        keyContext,
        &gatherer,
        drawTypes,
        withPrimitiveBlender,
        coverage,
        [context, &keyContext, &renderPassDescs](UniquePaintParamsID uniqueID,
                                                 DrawTypeFlags drawTypes,
                                                 bool withPrimitiveBlender,
                                                 Coverage coverage) {
               compile(context->priv().rendererProvider(),
                       context->priv().resourceProvider(),
                       keyContext,
                       uniqueID,
                       drawTypes,
                       renderPassDescs,
                       withPrimitiveBlender,
                       coverage);
        });
}

◆ primitive_type_to_vk_topology()

static VkPrimitiveTopology skgpu::graphite::primitive_type_to_vk_topology ( PrimitiveType primitiveType )

static

Definition at line 149 of file VulkanGraphicsPipeline.cpp.

                                                                                      {
    switch (primitiveType) {
        case PrimitiveType::kTriangles:
            return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
        case PrimitiveType::kTriangleStrip:
            return VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP;
        case PrimitiveType::kPoints:
            return VK_PRIMITIVE_TOPOLOGY_POINT_LIST;
    }
    SkUNREACHABLE;
}

◆ quad_center()

static skvx::float2 skgpu::graphite::quad_center ( const EdgeAAQuad & quad )

static

Definition at line 229 of file AnalyticRRectRenderStep.cpp.

                                                      {
    // The center of the bounding box is *not* a good center to use. Take the average of the
    // four points instead (which is slightly biased if they form a triangle, but still okay).
    return skvx::float2(dot(quad.xs(), skvx::float4(0.25f)),
                        dot(quad.ys(), skvx::float4(0.25f)));
}

◆ quantize()

static float skgpu::graphite::quantize ( float deviceSpaceFloat )

static

Definition at line 180 of file AnalyticBlurMask.cpp.

                                              {
    // Snap the device-space value to the nearest 1/32 to increase cache hits w/o impacting the
    // visible output since it should be hard to see a change limited to 1/32 of a pixel.
    return SkScalarRoundToInt(deviceSpaceFloat * 32.f) / 32.f;
}

◆ RescaleImage()

sk_sp< SkImage > skgpu::graphite::RescaleImage	(	Recorder *	recorder,
		const SkImage *	srcImage,
		SkIRect	srcIRect,
		const SkImageInfo &	dstInfo,
		SkImage::RescaleGamma	rescaleGamma,
		SkImage::RescaleMode	rescaleMode
	)

Definition at line 597 of file TextureUtils.cpp.

                                                            {
    TRACE_EVENT0("skia.gpu", TRACE_FUNC);
    TRACE_EVENT_INSTANT2("skia.gpu", "RescaleImage Src", TRACE_EVENT_SCOPE_THREAD,
                         "width", srcIRect.width(), "height", srcIRect.height());
    TRACE_EVENT_INSTANT2("skia.gpu", "RescaleImage Dst", TRACE_EVENT_SCOPE_THREAD,
                         "width", dstInfo.width(), "height", dstInfo.height());
 
    // RescaleImage() should only be called when we already know that srcImage is graphite-backed
    SkASSERT(srcImage && as_IB(srcImage)->isGraphiteBacked());
 
    // For now this needs to be texturable because we can't depend on copies to scale.
    // NOTE: srcView may be empty if srcImage is YUVA.
    const TextureProxyView srcView = AsView(srcImage);
    if (srcView && !recorder->priv().caps()->isTexturable(srcView.proxy()->textureInfo())) {
        // With the current definition of SkImage, this shouldn't happen. If we allow non-texturable
        // formats for compute, we'll need to copy to a texturable format.
        SkASSERT(false);
        return nullptr;
    }
 
    // make a Surface *exactly* matching dstInfo to rescale into
    SkSurfaceProps surfaceProps = {};
    sk_sp<SkSurface> dst = make_renderable_scratch_surface(recorder,
                                                           dstInfo,
                                                           SkBackingFit::kExact,
                                                           "RescaleDstTexture",
                                                           &surfaceProps);
    if (!dst) {
        return nullptr;
    }
 
    SkRect srcRect = SkRect::Make(srcIRect);
    SkRect dstRect = SkRect::Make(dstInfo.dimensions());
 
    SkISize finalSize = SkISize::Make(dstRect.width(), dstRect.height());
    if (finalSize == srcIRect.size()) {
        rescaleGamma = Image::RescaleGamma::kSrc;
        rescaleMode = Image::RescaleMode::kNearest;
    }
 
    // Within a rescaling pass tempInput is read from and tempOutput is written to.
    // At the end of the pass tempOutput's texture is wrapped and assigned to tempInput.
    sk_sp<SkImage> tempInput = sk_ref_sp(srcImage);
    sk_sp<SkSurface> tempOutput;
 
    // Assume we should ignore the rescale linear request if the surface has no color space since
    // it's unclear how we'd linearize from an unknown color space.
    const SkImageInfo& srcImageInfo = srcImage->imageInfo();
    if (rescaleGamma == Image::RescaleGamma::kLinear &&
        srcImageInfo.colorSpace() &&
        !srcImageInfo.colorSpace()->gammaIsLinear()) {
        // Draw the src image into a new surface with linear gamma, and make that the new tempInput
        sk_sp<SkColorSpace> linearGamma = srcImageInfo.colorSpace()->makeLinearGamma();
        SkImageInfo gammaDstInfo = SkImageInfo::Make(srcIRect.size(),
                                                     tempInput->imageInfo().colorType(),
                                                     kPremul_SkAlphaType,
                                                     std::move(linearGamma));
        tempOutput = make_renderable_scratch_surface(recorder, gammaDstInfo, SkBackingFit::kApprox,
                                                     "RescaleLinearGammaTexture", &surfaceProps);
        if (!tempOutput) {
            return nullptr;
        }
        SkCanvas* gammaDst = tempOutput->getCanvas();
        SkRect gammaDstRect = SkRect::Make(srcIRect.size());
 
        SkPaint paint;
        paint.setBlendMode(SkBlendMode::kSrc);
        gammaDst->drawImageRect(tempInput, srcRect, gammaDstRect,
                                SkSamplingOptions(SkFilterMode::kNearest), &paint,
                                SkCanvas::kStrict_SrcRectConstraint);
        tempInput = SkSurfaces::AsImage(std::move(tempOutput));
        srcRect = gammaDstRect;
    }
 
    SkImageInfo outImageInfo = tempInput->imageInfo().makeAlphaType(kPremul_SkAlphaType);
    do {
        SkISize nextDims = finalSize;
        if (rescaleMode != Image::RescaleMode::kNearest &&
            rescaleMode != Image::RescaleMode::kLinear) {
            if (srcRect.width() > finalSize.width()) {
                nextDims.fWidth = std::max((srcRect.width() + 1)/2, (float)finalSize.width());
            } else if (srcRect.width() < finalSize.width()) {
                nextDims.fWidth = std::min(srcRect.width()*2, (float)finalSize.width());
            }
            if (srcRect.height() > finalSize.height()) {
                nextDims.fHeight = std::max((srcRect.height() + 1)/2, (float)finalSize.height());
            } else if (srcRect.height() < finalSize.height()) {
                nextDims.fHeight = std::min(srcRect.height()*2, (float)finalSize.height());
            }
        }
 
        SkRect stepDstRect;
        if (nextDims == finalSize) {
            tempOutput = dst;
            stepDstRect = dstRect;
        } else {
            SkImageInfo nextInfo = outImageInfo.makeDimensions(nextDims);
            tempOutput = make_renderable_scratch_surface(recorder, nextInfo, SkBackingFit::kApprox,
                                                         "RescaleImageTempTexture", &surfaceProps);
            if (!tempOutput) {
                return nullptr;
            }
            stepDstRect = SkRect::Make(tempOutput->imageInfo().dimensions());
        }
 
        SkSamplingOptions samplingOptions;
        if (rescaleMode == Image::RescaleMode::kRepeatedCubic) {
            samplingOptions = SkSamplingOptions(SkCubicResampler::CatmullRom());
        } else {
            samplingOptions = (rescaleMode == Image::RescaleMode::kNearest) ?
                               SkSamplingOptions(SkFilterMode::kNearest) :
                               SkSamplingOptions(SkFilterMode::kLinear);
        }
        SkPaint paint;
        paint.setBlendMode(SkBlendMode::kSrc);
        tempOutput->getCanvas()->drawImageRect(tempInput, srcRect, stepDstRect, samplingOptions,
                                               &paint, SkCanvas::kStrict_SrcRectConstraint);
 
        tempInput = SkSurfaces::AsImage(std::move(tempOutput));
        srcRect = SkRect::Make(nextDims);
    } while (srcRect.width() != finalSize.width() || srcRect.height() != finalSize.height());
 
    return SkSurfaces::AsImage(std::move(dst));
}

◆ run_test()

void skgpu::graphite::run_test	(	skiatest::Reporter *	reporter,
		Context *	context,
		SkISize	surfaceSize,
		SkISize	recordingSize,
		SkISize	replayOffset,
		DrawCallback	draw,
		const std::vector< Expectation > &	expectations
	)

Definition at line 30 of file RecordingSurfacesTest.cpp.

                                                          {
    const SkImageInfo surfaceImageInfo = SkImageInfo::Make(
            surfaceSize, SkColorType::kRGBA_8888_SkColorType, SkAlphaType::kPremul_SkAlphaType);
 
    std::unique_ptr<Recorder> surfaceRecorder = context->makeRecorder();
    sk_sp<SkSurface> surface = SkSurfaces::RenderTarget(surfaceRecorder.get(), surfaceImageInfo);
    Surface* graphiteSurface = static_cast<Surface*>(surface.get());
    const TextureInfo& textureInfo = graphiteSurface->backingTextureProxy()->textureInfo();
 
    // Flush the initial clear added by MakeGraphite.
    std::unique_ptr<skgpu::graphite::Recording> surfaceRecording = surfaceRecorder->snap();
    context->insertRecording({surfaceRecording.get()});
 
    // Snap a recording without a bound target.
    const SkImageInfo recordingImageInfo = surfaceImageInfo.makeDimensions(recordingSize);
    std::unique_ptr<Recorder> recorder = context->makeRecorder();
    SkCanvas* canvas = recorder->makeDeferredCanvas(recordingImageInfo, textureInfo);
    draw(canvas);
 
    // Can't make another canvas before snapping.
    REPORTER_ASSERT(reporter,
                    recorder->makeDeferredCanvas(recordingImageInfo, textureInfo) == nullptr);
    std::unique_ptr<Recording> recording = recorder->snap();
 
    // Play back recording.
    context->insertRecording(
            {recording.get(), surface.get(), {replayOffset.fWidth, replayOffset.fHeight}});
 
    // Read pixels.
    SkBitmap bitmap;
    SkPixmap pixmap;
    bitmap.allocPixels(surfaceImageInfo);
    SkAssertResult(bitmap.peekPixels(&pixmap));
    if (!surface->readPixels(pixmap, 0, 0)) {
        ERRORF(reporter, "readPixels failed");
        return;
    }
 
    // Veryify expectations are met and recording is uninstantiated.
    REPORTER_ASSERT(reporter, !recording->priv().isTargetProxyInstantiated());
    for (const Expectation& e : expectations) {
        SkColor4f color = pixmap.getColor4f(e.fX, e.fY);
#ifdef SK_DEBUG
        if (color != e.fColor) {
            SkDebugf("Wrong color\n\texpected: %f %f %f %f\n\tactual: %f %f %f %f",
                     e.fColor.fR,
                     e.fColor.fG,
                     e.fColor.fB,
                     e.fColor.fA,
                     color.fR,
                     color.fG,
                     color.fB,
                     color.fA);
        }
#endif
        REPORTER_ASSERT(reporter, color == e.fColor);
    }
}

◆ setup_color_blend_state()

static void skgpu::graphite::setup_color_blend_state	(	const skgpu::BlendInfo &	blendInfo,
		VkPipelineColorBlendStateCreateInfo *	colorBlendInfo,
		VkPipelineColorBlendAttachmentState *	attachmentState
	)

static

Definition at line 379 of file VulkanGraphicsPipeline.cpp.

                                                                                          {
    skgpu::BlendEquation equation = blendInfo.fEquation;
    skgpu::BlendCoeff srcCoeff = blendInfo.fSrcBlend;
    skgpu::BlendCoeff dstCoeff = blendInfo.fDstBlend;
    bool blendOff = skgpu::BlendShouldDisable(equation, srcCoeff, dstCoeff);
 
    memset(attachmentState, 0, sizeof(VkPipelineColorBlendAttachmentState));
    attachmentState->blendEnable = !blendOff;
    if (!blendOff) {
        attachmentState->srcColorBlendFactor = blend_coeff_to_vk_blend(srcCoeff);
        attachmentState->dstColorBlendFactor = blend_coeff_to_vk_blend(dstCoeff);
        attachmentState->colorBlendOp = blend_equation_to_vk_blend_op(equation);
        attachmentState->srcAlphaBlendFactor = blend_coeff_to_vk_blend(srcCoeff);
        attachmentState->dstAlphaBlendFactor = blend_coeff_to_vk_blend(dstCoeff);
        attachmentState->alphaBlendOp = blend_equation_to_vk_blend_op(equation);
    }
 
    if (!blendInfo.fWritesColor) {
        attachmentState->colorWriteMask = 0;
    } else {
        attachmentState->colorWriteMask = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT |
                                          VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
    }
 
    memset(colorBlendInfo, 0, sizeof(VkPipelineColorBlendStateCreateInfo));
    colorBlendInfo->sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
    colorBlendInfo->pNext = nullptr;
    colorBlendInfo->flags = 0;
    colorBlendInfo->logicOpEnable = VK_FALSE;
    colorBlendInfo->attachmentCount = 1;
    colorBlendInfo->pAttachments = attachmentState;
    // colorBlendInfo->blendConstants is set dynamically
}

◆ setup_depth_stencil_state()

static void skgpu::graphite::setup_depth_stencil_state	(	const DepthStencilSettings &	stencilSettings,
		VkPipelineDepthStencilStateCreateInfo *	stencilInfo
	)

static

Definition at line 232 of file VulkanGraphicsPipeline.cpp.

                                                                                          {
    SkASSERT(stencilSettings.fDepthTestEnabled ||
             stencilSettings.fDepthCompareOp == CompareOp::kAlways);
 
    memset(stencilInfo, 0, sizeof(VkPipelineDepthStencilStateCreateInfo));
    stencilInfo->sType = VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO;
    stencilInfo->pNext = nullptr;
    stencilInfo->flags = 0;
    stencilInfo->depthTestEnable = stencilSettings.fDepthTestEnabled;
    stencilInfo->depthWriteEnable = stencilSettings.fDepthWriteEnabled;
    stencilInfo->depthCompareOp = compare_op_to_vk_compare_op(stencilSettings.fDepthCompareOp);
    stencilInfo->depthBoundsTestEnable = VK_FALSE; // Default value TODO - Confirm
    stencilInfo->stencilTestEnable = stencilSettings.fStencilTestEnabled;
    if (stencilSettings.fStencilTestEnabled) {
        setup_stencil_op_state(&stencilInfo->front,
                               stencilSettings.fFrontStencil,
                               stencilSettings.fStencilReferenceValue);
        setup_stencil_op_state(&stencilInfo->back,
                               stencilSettings.fBackStencil,
                               stencilSettings.fStencilReferenceValue);
    }
    stencilInfo->minDepthBounds = 0.0f;
    stencilInfo->maxDepthBounds = 1.0f;
}

◆ setup_dynamic_state()

static void skgpu::graphite::setup_dynamic_state	(	VkPipelineDynamicStateCreateInfo *	dynamicInfo,
		VkDynamicState *	dynamicStates
	)

static

Definition at line 579 of file VulkanGraphicsPipeline.cpp.

                                                               {
    memset(dynamicInfo, 0, sizeof(VkPipelineDynamicStateCreateInfo));
    dynamicInfo->sType = VK_STRUCTURE_TYPE_PIPELINE_DYNAMIC_STATE_CREATE_INFO;
    dynamicInfo->pNext = VK_NULL_HANDLE;
    dynamicInfo->flags = 0;
    dynamicStates[0] = VK_DYNAMIC_STATE_VIEWPORT;
    dynamicStates[1] = VK_DYNAMIC_STATE_SCISSOR;
    dynamicStates[2] = VK_DYNAMIC_STATE_BLEND_CONSTANTS;
    dynamicInfo->dynamicStateCount = 3;
    dynamicInfo->pDynamicStates = dynamicStates;
}

◆ setup_input_assembly_state()

static void skgpu::graphite::setup_input_assembly_state	(	PrimitiveType	primitiveType,
		VkPipelineInputAssemblyStateCreateInfo *	inputAssemblyInfo
	)

static

Definition at line 161 of file VulkanGraphicsPipeline.cpp.

                                                                                                  {
    memset(inputAssemblyInfo, 0, sizeof(VkPipelineInputAssemblyStateCreateInfo));
    inputAssemblyInfo->sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
    inputAssemblyInfo->pNext = nullptr;
    inputAssemblyInfo->flags = 0;
    inputAssemblyInfo->primitiveRestartEnable = false;
    inputAssemblyInfo->topology = primitive_type_to_vk_topology(primitiveType);
}

◆ setup_multisample_state()

static void skgpu::graphite::setup_multisample_state	(	int	numSamples,
		VkPipelineMultisampleStateCreateInfo *	multisampleInfo
	)

static

Definition at line 273 of file VulkanGraphicsPipeline.cpp.

                                                                                           {
    memset(multisampleInfo, 0, sizeof(VkPipelineMultisampleStateCreateInfo));
    multisampleInfo->sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
    multisampleInfo->pNext = nullptr;
    multisampleInfo->flags = 0;
    SkAssertResult(skgpu::SampleCountToVkSampleCount(numSamples,
                                                     &multisampleInfo->rasterizationSamples));
    multisampleInfo->sampleShadingEnable = VK_FALSE;
    multisampleInfo->minSampleShading = 0.0f;
    multisampleInfo->pSampleMask = nullptr;
    multisampleInfo->alphaToCoverageEnable = VK_FALSE;
    multisampleInfo->alphaToOneEnable = VK_FALSE;
}

◆ setup_pipeline_layout()

static VkPipelineLayout skgpu::graphite::setup_pipeline_layout	(	const VulkanSharedContext *	sharedContext,
		bool	usesIntrinsicConstantUbo,
		bool	hasStepUniforms,
		int	numPaintUniforms,
		int	numTextureSamplers,
		int	numInputAttachments
	)

static

Definition at line 472 of file VulkanGraphicsPipeline.cpp.

                                                                       {
    // Determine descriptor set layouts for this pipeline based upon render pass information.
    skia_private::STArray<3, VkDescriptorSetLayout> setLayouts;
 
    // Determine uniform descriptor set layout
    skia_private::STArray<VulkanGraphicsPipeline::kNumUniformBuffers, DescriptorData>
            uniformDescriptors;
    if (usesIntrinsicConstantUbo) {
        uniformDescriptors.push_back(VulkanGraphicsPipeline::kIntrinsicUniformBufferDescriptor);
    }
    if (hasStepUniforms) {
        uniformDescriptors.push_back(VulkanGraphicsPipeline::kRenderStepUniformDescriptor);
    }
    if (numPaintUniforms > 0) {
        uniformDescriptors.push_back(VulkanGraphicsPipeline::kPaintUniformDescriptor);
    }
 
    if (!uniformDescriptors.empty()) {
        VkDescriptorSetLayout uniformSetLayout =
                descriptor_data_to_layout(sharedContext, {uniformDescriptors});
        if (uniformSetLayout == VK_NULL_HANDLE) { return VK_NULL_HANDLE; }
        setLayouts.push_back(uniformSetLayout);
    }
 
    // Determine input attachment descriptor set layout
    if (numInputAttachments > 0) {
        // For now, we only expect to have up to 1 input attachment. We also share that descriptor
        // set number with uniform descriptors for normal graphics pipeline usages, so verify that
        // we are not using any uniform descriptors to avoid conflicts.
        SkASSERT(numInputAttachments == 1 && uniformDescriptors.empty());
        skia_private::TArray<DescriptorData> inputAttachmentDescriptors(numInputAttachments);
        inputAttachmentDescriptors.push_back(VulkanGraphicsPipeline::kInputAttachmentDescriptor);
 
        VkDescriptorSetLayout inputAttachmentDescSetLayout =
                descriptor_data_to_layout(sharedContext, {inputAttachmentDescriptors});
 
        if (inputAttachmentDescSetLayout == VK_NULL_HANDLE) {
            destroy_desc_set_layouts(sharedContext, setLayouts);
            return VK_NULL_HANDLE;
        }
        setLayouts.push_back(inputAttachmentDescSetLayout);
    }
 
    // Determine texture/sampler descriptor set layout
    if (numTextureSamplers > 0) {
        skia_private::TArray<DescriptorData> textureSamplerDescs(numTextureSamplers);
        for (int i = 0; i < numTextureSamplers; i++) {
            textureSamplerDescs.push_back({DescriptorType::kCombinedTextureSampler,
                                            /*count=*/1,
                                            /*bindingIdx=*/i,
                                            PipelineStageFlags::kFragmentShader});
        }
        VkDescriptorSetLayout textureSamplerDescSetLayout =
                descriptor_data_to_layout(sharedContext, {textureSamplerDescs});
 
        if (textureSamplerDescSetLayout == VK_NULL_HANDLE) {
            destroy_desc_set_layouts(sharedContext, setLayouts);
            return VK_NULL_HANDLE;
        }
        setLayouts.push_back(textureSamplerDescSetLayout);
    }
 
    // Generate a pipeline layout using the now-populated descriptor set layout array
    VkPipelineLayoutCreateInfo layoutCreateInfo;
    memset(&layoutCreateInfo, 0, sizeof(VkPipelineLayoutCreateFlags));
    layoutCreateInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
    layoutCreateInfo.pNext = nullptr;
    layoutCreateInfo.flags = 0;
    layoutCreateInfo.setLayoutCount = setLayouts.size();
    layoutCreateInfo.pSetLayouts = setLayouts.begin();
    // TODO: Add support for push constants.
    layoutCreateInfo.pushConstantRangeCount = 0;
    layoutCreateInfo.pPushConstantRanges = nullptr;
 
    VkResult result;
    VkPipelineLayout layout;
    VULKAN_CALL_RESULT(sharedContext,
                       result,
                       CreatePipelineLayout(sharedContext->device(),
                                            &layoutCreateInfo,
                                            /*const VkAllocationCallbacks*=*/nullptr,
                                            &layout));
 
    // DescriptorSetLayouts can be deleted after the pipeline layout is created.
    destroy_desc_set_layouts(sharedContext, setLayouts);
 
    return result == VK_SUCCESS ? layout : VK_NULL_HANDLE;
}

◆ setup_raster_state()

static void skgpu::graphite::setup_raster_state	(	bool	isWireframe,
		VkPipelineRasterizationStateCreateInfo *	rasterInfo
	)

static

Definition at line 415 of file VulkanGraphicsPipeline.cpp.

                                                                                   {
    memset(rasterInfo, 0, sizeof(VkPipelineRasterizationStateCreateInfo));
    rasterInfo->sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
    rasterInfo->pNext = nullptr;
    rasterInfo->flags = 0;
    rasterInfo->depthClampEnable = VK_FALSE;
    rasterInfo->rasterizerDiscardEnable = VK_FALSE;
    rasterInfo->polygonMode = isWireframe ? VK_POLYGON_MODE_LINE : VK_POLYGON_MODE_FILL;
    rasterInfo->cullMode = VK_CULL_MODE_NONE;
    rasterInfo->frontFace = VK_FRONT_FACE_COUNTER_CLOCKWISE;
    rasterInfo->depthBiasEnable = VK_FALSE;
    rasterInfo->depthBiasConstantFactor = 0.0f;
    rasterInfo->depthBiasClamp = 0.0f;
    rasterInfo->depthBiasSlopeFactor = 0.0f;
    rasterInfo->lineWidth = 1.0f;
}

◆ setup_shader_stage_info()

static void skgpu::graphite::setup_shader_stage_info	(	VkShaderStageFlagBits	stage,
		VkShaderModule	shaderModule,
		VkPipelineShaderStageCreateInfo *	shaderStageInfo
	)

static

Definition at line 433 of file VulkanGraphicsPipeline.cpp.

                                                                                      {
    memset(shaderStageInfo, 0, sizeof(VkPipelineShaderStageCreateInfo));
    shaderStageInfo->sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
    shaderStageInfo->pNext = nullptr;
    shaderStageInfo->flags = 0;
    shaderStageInfo->stage = stage;
    shaderStageInfo->module = shaderModule;
    shaderStageInfo->pName = "main";
    shaderStageInfo->pSpecializationInfo = nullptr;
}

◆ setup_stencil_op_state()

static void skgpu::graphite::setup_stencil_op_state	(	VkStencilOpState *	opState,
		const DepthStencilSettings::Face &	face,
		uint32_t	referenceValue
	)

static

Definition at line 220 of file VulkanGraphicsPipeline.cpp.

                                                            {
    opState->failOp = stencil_op_to_vk_stencil_op(face.fStencilFailOp);
    opState->passOp = stencil_op_to_vk_stencil_op(face.fDepthStencilPassOp);
    opState->depthFailOp = stencil_op_to_vk_stencil_op(face.fDepthFailOp);
    opState->compareOp = compare_op_to_vk_compare_op(face.fCompareOp);
    opState->compareMask = face.fReadMask; // TODO - check this.
    opState->writeMask = face.fWriteMask;
    opState->reference = referenceValue;
}

◆ setup_vertex_input_state()

static void skgpu::graphite::setup_vertex_input_state	(	const SkSpan< const Attribute > &	vertexAttrs,
		const SkSpan< const Attribute > &	instanceAttrs,
		VkPipelineVertexInputStateCreateInfo *	vertexInputInfo,
		skia_private::STArray< 2, VkVertexInputBindingDescription, true > *	bindingDescs,
		skia_private::STArray< 16, VkVertexInputAttributeDescription > *	attributeDescs
	)

static

Definition at line 92 of file VulkanGraphicsPipeline.cpp.

                                                                                    {
    // Setup attribute & binding descriptions
    int attribIndex = 0;
    size_t vertexAttributeOffset = 0;
    for (auto attrib : vertexAttrs) {
        VkVertexInputAttributeDescription vkAttrib;
        vkAttrib.location = attribIndex++;
        vkAttrib.binding = VulkanGraphicsPipeline::kVertexBufferIndex;
        vkAttrib.format = attrib_type_to_vkformat(attrib.cpuType());
        vkAttrib.offset = vertexAttributeOffset;
        vertexAttributeOffset += attrib.sizeAlign4();
        attributeDescs->push_back(vkAttrib);
    }
 
    size_t instanceAttributeOffset = 0;
    for (auto attrib : instanceAttrs) {
        VkVertexInputAttributeDescription vkAttrib;
        vkAttrib.location = attribIndex++;
        vkAttrib.binding = VulkanGraphicsPipeline::kInstanceBufferIndex;
        vkAttrib.format = attrib_type_to_vkformat(attrib.cpuType());
        vkAttrib.offset = instanceAttributeOffset;
        instanceAttributeOffset += attrib.sizeAlign4();
        attributeDescs->push_back(vkAttrib);
    }
 
    if (bindingDescs && !vertexAttrs.empty()) {
        bindingDescs->push_back() = {
                VulkanGraphicsPipeline::kVertexBufferIndex,
                (uint32_t) vertexAttributeOffset,
                VK_VERTEX_INPUT_RATE_VERTEX
        };
    }
    if (bindingDescs && !instanceAttrs.empty()) {
        bindingDescs->push_back() = {
                VulkanGraphicsPipeline::kInstanceBufferIndex,
                (uint32_t) instanceAttributeOffset,
                VK_VERTEX_INPUT_RATE_INSTANCE
        };
    }
 
    memset(vertexInputInfo, 0, sizeof(VkPipelineVertexInputStateCreateInfo));
    vertexInputInfo->sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
    vertexInputInfo->pNext = nullptr;
    vertexInputInfo->flags = 0;
    vertexInputInfo->vertexBindingDescriptionCount = bindingDescs ? bindingDescs->size() : 0;
    vertexInputInfo->pVertexBindingDescriptions =
            bindingDescs && !bindingDescs->empty() ? bindingDescs->begin() : VK_NULL_HANDLE;
    vertexInputInfo->vertexAttributeDescriptionCount = attributeDescs ? attributeDescs->size() : 0;
    vertexInputInfo->pVertexAttributeDescriptions =
            attributeDescs && !attributeDescs->empty() ? attributeDescs->begin() : VK_NULL_HANDLE;
}

◆ setup_viewport_scissor_state()

static void skgpu::graphite::setup_viewport_scissor_state ( VkPipelineViewportStateCreateInfo * viewportInfo )

static

Definition at line 258 of file VulkanGraphicsPipeline.cpp.

                                                                                          {
    memset(viewportInfo, 0, sizeof(VkPipelineViewportStateCreateInfo));
    viewportInfo->sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
    viewportInfo->pNext = nullptr;
    viewportInfo->flags = 0;
 
    viewportInfo->viewportCount = 1;
    viewportInfo->pViewports = nullptr; // This is set dynamically with a draw pass command
 
    viewportInfo->scissorCount = 1;
    viewportInfo->pScissors = nullptr; // This is set dynamically with a draw pass command
 
    SkASSERT(viewportInfo->viewportCount == viewportInfo->scissorCount);
}

◆ SK_MAKE_BITMASK_OPS() [1/2]

skgpu::graphite::SK_MAKE_BITMASK_OPS ( DawnErrorType )

◆ SK_MAKE_BITMASK_OPS() [2/2]

skgpu::graphite::SK_MAKE_BITMASK_OPS ( PipelineStageFlags )

◆ skdata_matches()

static bool skgpu::graphite::skdata_matches	(	const SkData *	a,
		const SkData *	b
	)

static

Definition at line 1088 of file KeyHelpers.cpp.

                                                             {
    // Returns true if both SkData objects hold the same contents, or if they are both null.
    // (SkData::equals supports passing null, and returns false.)
    return a ? a->equals(b) : (a == b);
}

◆ SkShouldPostMessageToBus()

bool skgpu::graphite::SkShouldPostMessageToBus	(	const ClientMappedBufferManager::BufferFinishedMessage &	,
		Context::ContextID	potentialRecipient
	)

◆ stencil_op_to_vk_stencil_op()

static VkStencilOp skgpu::graphite::stencil_op_to_vk_stencil_op ( StencilOp op )

static

Definition at line 171 of file VulkanGraphicsPipeline.cpp.

                                                             {
    static const VkStencilOp gTable[] = {
        VK_STENCIL_OP_KEEP,                 // kKeep
        VK_STENCIL_OP_ZERO,                 // kZero
        VK_STENCIL_OP_REPLACE,              // kReplace
        VK_STENCIL_OP_INVERT,               // kInvert
        VK_STENCIL_OP_INCREMENT_AND_WRAP,   // kIncWrap
        VK_STENCIL_OP_DECREMENT_AND_WRAP,   // kDecWrap
        VK_STENCIL_OP_INCREMENT_AND_CLAMP,  // kIncClamp
        VK_STENCIL_OP_DECREMENT_AND_CLAMP,  // kDecClamp
    };
    static_assert(std::size(gTable) == kStencilOpCount);
    static_assert(0 == (int)StencilOp::kKeep);
    static_assert(1 == (int)StencilOp::kZero);
    static_assert(2 == (int)StencilOp::kReplace);
    static_assert(3 == (int)StencilOp::kInvert);
    static_assert(4 == (int)StencilOp::kIncWrap);
    static_assert(5 == (int)StencilOp::kDecWrap);
    static_assert(6 == (int)StencilOp::kIncClamp);
    static_assert(7 == (int)StencilOp::kDecClamp);
    SkASSERT(op < (StencilOp)kStencilOpCount);
    return gTable[(int)op];
}

◆ submit_to_queue()

static bool skgpu::graphite::submit_to_queue	(	const VulkanSharedContext *	sharedContext,
		VkQueue	queue,
		VkFence	fence,
		uint32_t	waitCount,
		const VkSemaphore *	waitSemaphores,
		const VkPipelineStageFlags *	waitStages,
		uint32_t	commandBufferCount,
		const VkCommandBuffer *	commandBuffers,
		uint32_t	signalCount,
		const VkSemaphore *	signalSemaphores,
		Protected	protectedContext
	)

static

Definition at line 232 of file VulkanCommandBuffer.cpp.

                                                        {
    VkProtectedSubmitInfo protectedSubmitInfo;
    if (protectedContext == Protected::kYes) {
        memset(&protectedSubmitInfo, 0, sizeof(VkProtectedSubmitInfo));
        protectedSubmitInfo.sType = VK_STRUCTURE_TYPE_PROTECTED_SUBMIT_INFO;
        protectedSubmitInfo.pNext = nullptr;
        protectedSubmitInfo.protectedSubmit = VK_TRUE;
    }
 
    VkSubmitInfo submitInfo;
    memset(&submitInfo, 0, sizeof(VkSubmitInfo));
    submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
    submitInfo.pNext = protectedContext == Protected::kYes ? &protectedSubmitInfo : nullptr;
    submitInfo.waitSemaphoreCount = waitCount;
    submitInfo.pWaitSemaphores = waitSemaphores;
    submitInfo.pWaitDstStageMask = waitStages;
    submitInfo.commandBufferCount = commandBufferCount;
    submitInfo.pCommandBuffers = commandBuffers;
    submitInfo.signalSemaphoreCount = signalCount;
    submitInfo.pSignalSemaphores = signalSemaphores;
    VkResult result;
    VULKAN_CALL_RESULT(sharedContext, result, QueueSubmit(queue, 1, &submitInfo, fence));
    return result == VK_SUCCESS;
}

◆ swizzle_class_to_read_enum()

static skgpu::graphite::ReadSwizzle skgpu::graphite::swizzle_class_to_read_enum ( const skgpu::Swizzle & swizzle )

static

Definition at line 1757 of file KeyHelpers.cpp.

                                                                                        {
    if (swizzle == skgpu::Swizzle::RGBA()) {
        return skgpu::graphite::ReadSwizzle::kRGBA;
    } else if (swizzle == skgpu::Swizzle::RGB1()) {
        return skgpu::graphite::ReadSwizzle::kRGB1;
    } else if (swizzle == skgpu::Swizzle("rrr1")) {
        return skgpu::graphite::ReadSwizzle::kRRR1;
    } else if (swizzle == skgpu::Swizzle::BGRA()) {
        return skgpu::graphite::ReadSwizzle::kBGRA;
    } else if (swizzle == skgpu::Swizzle("000r")) {
        return skgpu::graphite::ReadSwizzle::k000R;
    } else {
        SKGPU_LOG_W("%s is an unsupported read swizzle. Defaulting to RGBA.\n",
                    swizzle.asString().data());
        return skgpu::graphite::ReadSwizzle::kRGBA;
    }
}

◆ tile_mode_to_dawn_address_mode()

static wgpu::AddressMode skgpu::graphite::tile_mode_to_dawn_address_mode ( SkTileMode tileMode )

inlinestatic

Definition at line 49 of file DawnSampler.cpp.

                                                                                  {
    switch (tileMode) {
        case SkTileMode::kClamp:
            return wgpu::AddressMode::ClampToEdge;
        case SkTileMode::kRepeat:
            return wgpu::AddressMode::Repeat;
        case SkTileMode::kMirror:
            return wgpu::AddressMode::MirrorRepeat;
        case SkTileMode::kDecal:
            // Dawn doesn't support this mode.
            return wgpu::AddressMode::ClampToEdge;
    }
    SkUNREACHABLE;
}

◆ tile_mode_to_mtl_sampler_address()

static MTLSamplerAddressMode skgpu::graphite::tile_mode_to_mtl_sampler_address	(	SkTileMode	tileMode,
		const Caps &	caps
	)

inlinestatic

Definition at line 21 of file MtlSampler.mm.

                                                                                       {
    switch (tileMode) {
        case SkTileMode::kClamp:
            return MTLSamplerAddressModeClampToEdge;
        case SkTileMode::kRepeat:
            return MTLSamplerAddressModeRepeat;
        case SkTileMode::kMirror:
            return MTLSamplerAddressModeMirrorRepeat;
        case SkTileMode::kDecal:
            // For this tilemode, we should have checked that clamp-to-border support exists.
            // If it doesn't we should have fallen back to a shader instead.
            // TODO: for textures with alpha, we could use ClampToZero if there's no
            // ClampToBorderColor as they'll clamp to (0,0,0,0).
            // Unfortunately textures without alpha end up clamping to (0,0,0,1).
            if (@available(macOS 10.12, iOS 14.0, tvOS 14.0, *)) {
                SkASSERT(caps.clampToBorderSupport());
                return MTLSamplerAddressModeClampToBorderColor;
            } else {
                SkASSERT(false);
                return MTLSamplerAddressModeClampToZero;
            }
    }
    SkUNREACHABLE;
}

◆ tile_mode_to_vk_sampler_address()

static VkSamplerAddressMode skgpu::graphite::tile_mode_to_vk_sampler_address ( SkTileMode tileMode )

static

Definition at line 23 of file VulkanSampler.cpp.

                                                                                 {
    switch (tileMode) {
        case SkTileMode::kClamp:
            return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
        case SkTileMode::kRepeat:
            return VK_SAMPLER_ADDRESS_MODE_REPEAT;
        case SkTileMode::kMirror:
            return VK_SAMPLER_ADDRESS_MODE_MIRRORED_REPEAT;
        case SkTileMode::kDecal:
            return VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER;
    }
    SkUNREACHABLE;
}

◆ to_str()

static std::string skgpu::graphite::to_str	(	const SharedContext *	ctx,
		const GraphicsPipelineDesc &	gpDesc,
		const RenderPassDesc &	rpDesc
	)

static

Definition at line 35 of file ResourceProvider.cpp.

                                                                         {
    const ShaderCodeDictionary* dict = ctx->shaderCodeDictionary();
    const RenderStep* step = ctx->rendererProvider()->lookup(gpDesc.renderStepID());
    return GetPipelineLabel(dict, rpDesc, step, gpDesc.paintParamsID());
}

◆ top_device_graphite_target_proxy()

static skgpu::graphite::TextureProxy * skgpu::graphite::top_device_graphite_target_proxy ( SkCanvas * canvas )

static

Definition at line 93 of file GraphiteResourceCacheTest.cpp.

                                                                                     {
    if (auto gpuDevice = SkCanvasPriv::TopDevice(canvas)->asGraphiteDevice()) {
        return gpuDevice->target();
    }
    return nullptr;
}

◆ uniform_type_to_sksl_type()

static SkSLType skgpu::graphite::uniform_type_to_sksl_type ( const SkRuntimeEffect::Uniform & u )

static

Definition at line 1562 of file ShaderCodeDictionary.cpp.

                                                                           {
    using Type = SkRuntimeEffect::Uniform::Type;
    if (u.flags & SkRuntimeEffect::Uniform::kHalfPrecision_Flag) {
        switch (u.type) {
            case Type::kFloat:    return SkSLType::kHalf;
            case Type::kFloat2:   return SkSLType::kHalf2;
            case Type::kFloat3:   return SkSLType::kHalf3;
            case Type::kFloat4:   return SkSLType::kHalf4;
            case Type::kFloat2x2: return SkSLType::kHalf2x2;
            case Type::kFloat3x3: return SkSLType::kHalf3x3;
            case Type::kFloat4x4: return SkSLType::kHalf4x4;
            // NOTE: shorts cannot be uniforms, so we shouldn't ever get here.
            // Defensively return the full precision integer type.
            case Type::kInt:      SkDEBUGFAIL("unsupported uniform type"); return SkSLType::kInt;
            case Type::kInt2:     SkDEBUGFAIL("unsupported uniform type"); return SkSLType::kInt2;
            case Type::kInt3:     SkDEBUGFAIL("unsupported uniform type"); return SkSLType::kInt3;
            case Type::kInt4:     SkDEBUGFAIL("unsupported uniform type"); return SkSLType::kInt4;
        }
    } else {
        switch (u.type) {
            case Type::kFloat:    return SkSLType::kFloat;
            case Type::kFloat2:   return SkSLType::kFloat2;
            case Type::kFloat3:   return SkSLType::kFloat3;
            case Type::kFloat4:   return SkSLType::kFloat4;
            case Type::kFloat2x2: return SkSLType::kFloat2x2;
            case Type::kFloat3x3: return SkSLType::kFloat3x3;
            case Type::kFloat4x4: return SkSLType::kFloat4x4;
            case Type::kInt:      return SkSLType::kInt;
            case Type::kInt2:     return SkSLType::kInt2;
            case Type::kInt3:     return SkSLType::kInt3;
            case Type::kInt4:     return SkSLType::kInt4;
        }
    }
    SkUNREACHABLE;
}

◆ VELLO_COMPUTE_STEP() [1/19]

skgpu::graphite::VELLO_COMPUTE_STEP ( BackdropDyn )

◆ VELLO_COMPUTE_STEP() [2/19]

skgpu::graphite::VELLO_COMPUTE_STEP ( BboxClear )

◆ VELLO_COMPUTE_STEP() [3/19]

skgpu::graphite::VELLO_COMPUTE_STEP ( Binning )

◆ VELLO_COMPUTE_STEP() [4/19]

skgpu::graphite::VELLO_COMPUTE_STEP ( ClipLeaf )

◆ VELLO_COMPUTE_STEP() [5/19]

skgpu::graphite::VELLO_COMPUTE_STEP ( ClipReduce )

◆ VELLO_COMPUTE_STEP() [6/19]

skgpu::graphite::VELLO_COMPUTE_STEP ( Coarse )

◆ VELLO_COMPUTE_STEP() [7/19]

skgpu::graphite::VELLO_COMPUTE_STEP ( DrawLeaf )

◆ VELLO_COMPUTE_STEP() [8/19]

skgpu::graphite::VELLO_COMPUTE_STEP ( DrawReduce )

◆ VELLO_COMPUTE_STEP() [9/19]

skgpu::graphite::VELLO_COMPUTE_STEP ( Flatten )

◆ VELLO_COMPUTE_STEP() [10/19]

skgpu::graphite::VELLO_COMPUTE_STEP ( PathCount )

◆ VELLO_COMPUTE_STEP() [11/19]

skgpu::graphite::VELLO_COMPUTE_STEP ( PathCountSetup )

◆ VELLO_COMPUTE_STEP() [12/19]

skgpu::graphite::VELLO_COMPUTE_STEP ( PathtagReduce )

◆ VELLO_COMPUTE_STEP() [13/19]

skgpu::graphite::VELLO_COMPUTE_STEP ( PathtagReduce2 )

◆ VELLO_COMPUTE_STEP() [14/19]

skgpu::graphite::VELLO_COMPUTE_STEP ( PathtagScan1 )

◆ VELLO_COMPUTE_STEP() [15/19]

skgpu::graphite::VELLO_COMPUTE_STEP ( PathtagScanLarge )

◆ VELLO_COMPUTE_STEP() [16/19]

skgpu::graphite::VELLO_COMPUTE_STEP ( PathtagScanSmall )

◆ VELLO_COMPUTE_STEP() [17/19]

skgpu::graphite::VELLO_COMPUTE_STEP ( PathTiling )

◆ VELLO_COMPUTE_STEP() [18/19]

skgpu::graphite::VELLO_COMPUTE_STEP ( PathTilingSetup )

◆ VELLO_COMPUTE_STEP() [19/19]

skgpu::graphite::VELLO_COMPUTE_STEP ( TileAlloc )

◆ VelloNativeShaderSource()

ComputeStep::NativeShaderSource skgpu::graphite::VelloNativeShaderSource	(	vello_cpp::ShaderStage	stage,
		ComputeStep::NativeShaderFormat	format
	)

Definition at line 35 of file VelloComputeSteps.cpp.

                                                                                              {
    using NativeFormat = ComputeStep::NativeShaderFormat;
 
    const auto& shader = vello_cpp::shader(stage);
    ::rust::Str source;
    std::string entryPoint;
    switch (format) {
#ifdef SK_DAWN
        case NativeFormat::kWGSL:
            source = shader.wgsl();
            entryPoint = "main";
            break;
#endif
#ifdef SK_METAL
        case NativeFormat::kMSL:
            source = shader.msl();
            entryPoint = "main_";
            break;
#endif
        default:
            return {std::string_view(), ""};
    }
 
    return {{source.data(), source.length()}, std::move(entryPoint)};
}

◆ VelloStageLocalSize()

WorkgroupSize skgpu::graphite::VelloStageLocalSize ( vello_cpp::ShaderStage stage )

Definition at line 17 of file VelloComputeSteps.cpp.

                                                              {
    auto wgSize = vello_cpp::shader(stage).workgroup_size();
    return WorkgroupSize(wgSize.x, wgSize.y, wgSize.z);
}

◆ VelloStageName()

std::string_view skgpu::graphite::VelloStageName ( vello_cpp::ShaderStage stage )

Definition at line 12 of file VelloComputeSteps.cpp.

                                                          {
    auto name = vello_cpp::shader(stage).name();
    return {name.data(), name.length()};
}

◆ VelloWorkgroupBuffers()

skia_private::TArray< ComputeStep::WorkgroupBufferDesc > skgpu::graphite::VelloWorkgroupBuffers ( vello_cpp::ShaderStage stage )

Definition at line 22 of file VelloComputeSteps.cpp.

                                    {
    auto wgBuffers = vello_cpp::shader(stage).workgroup_buffers();
    skia_private::TArray<ComputeStep::WorkgroupBufferDesc> result;
    if (!wgBuffers.empty()) {
        result.reserve(wgBuffers.size());
        for (const auto& desc : wgBuffers) {
            result.push_back({desc.size_in_bytes, desc.index});
        }
    }
    return result;
}

◆ VertexAttribTypeSize()

static constexpr size_t skgpu::graphite::VertexAttribTypeSize ( VertexAttribType type )

inlinestaticconstexpr

Returns the size of the attrib type in bytes.

Definition at line 77 of file DrawTypes.h.

                                                                           {
    switch (type) {
        case VertexAttribType::kFloat:
            return sizeof(float);
        case VertexAttribType::kFloat2:
            return 2 * sizeof(float);
        case VertexAttribType::kFloat3:
            return 3 * sizeof(float);
        case VertexAttribType::kFloat4:
            return 4 * sizeof(float);
        case VertexAttribType::kHalf:
            return sizeof(uint16_t);
        case VertexAttribType::kHalf2:
            return 2 * sizeof(uint16_t);
        case VertexAttribType::kHalf4:
            return 4 * sizeof(uint16_t);
        case VertexAttribType::kInt2:
            return 2 * sizeof(int32_t);
        case VertexAttribType::kInt3:
            return 3 * sizeof(int32_t);
        case VertexAttribType::kInt4:
            return 4 * sizeof(int32_t);
        case VertexAttribType::kByte:
            return 1 * sizeof(char);
        case VertexAttribType::kByte2:
            return 2 * sizeof(char);
        case VertexAttribType::kByte4:
            return 4 * sizeof(char);
        case VertexAttribType::kUByte:
            return 1 * sizeof(char);
        case VertexAttribType::kUByte2:
            return 2 * sizeof(char);
        case VertexAttribType::kUByte4:
            return 4 * sizeof(char);
        case VertexAttribType::kUByte_norm:
            return 1 * sizeof(char);
        case VertexAttribType::kUByte4_norm:
            return 4 * sizeof(char);
        case VertexAttribType::kShort2:
            return 2 * sizeof(int16_t);
        case VertexAttribType::kShort4:
            return 4 * sizeof(int16_t);
        case VertexAttribType::kUShort2: [[fallthrough]];
        case VertexAttribType::kUShort2_norm:
            return 2 * sizeof(uint16_t);
        case VertexAttribType::kInt:
            return sizeof(int32_t);
        case VertexAttribType::kUInt:
            return sizeof(uint32_t);
        case VertexAttribType::kUShort_norm:
            return sizeof(uint16_t);
        case VertexAttribType::kUShort4_norm:
            return 4 * sizeof(uint16_t);
    }
    SkUNREACHABLE;
}

◆ vk_format_to_aspect_flags()

VkImageAspectFlags skgpu::graphite::vk_format_to_aspect_flags ( VkFormat format )

Definition at line 188 of file VulkanTexture.cpp.

                                                              {
    switch (format) {
        case VK_FORMAT_S8_UINT:
            return VK_IMAGE_ASPECT_STENCIL_BIT;
        case VK_FORMAT_D16_UNORM:
            [[fallthrough]];
        case VK_FORMAT_D32_SFLOAT:
            return VK_IMAGE_ASPECT_DEPTH_BIT;
        case VK_FORMAT_D24_UNORM_S8_UINT:
            [[fallthrough]];
        case VK_FORMAT_D32_SFLOAT_S8_UINT:
            return VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT;
        default:
            return VK_IMAGE_ASPECT_COLOR_BIT;
    }
}

◆ vkFormatIsSupported()

bool skgpu::graphite::vkFormatIsSupported ( VkFormat format )

Definition at line 128 of file VulkanGraphiteUtils.cpp.

                                          {
    switch (format) {
        case VK_FORMAT_R8G8B8A8_UNORM:
        case VK_FORMAT_B8G8R8A8_UNORM:
        case VK_FORMAT_R8G8B8A8_SRGB:
        case VK_FORMAT_R8G8B8_UNORM:
        case VK_FORMAT_R8G8_UNORM:
        case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
        case VK_FORMAT_A2R10G10B10_UNORM_PACK32:
        case VK_FORMAT_R5G6B5_UNORM_PACK16:
        case VK_FORMAT_B4G4R4A4_UNORM_PACK16:
        case VK_FORMAT_R4G4B4A4_UNORM_PACK16:
        case VK_FORMAT_R8_UNORM:
        case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK:
        case VK_FORMAT_BC1_RGB_UNORM_BLOCK:
        case VK_FORMAT_BC1_RGBA_UNORM_BLOCK:
        case VK_FORMAT_R16G16B16A16_SFLOAT:
        case VK_FORMAT_R16_SFLOAT:
        case VK_FORMAT_R16_UNORM:
        case VK_FORMAT_R16G16_UNORM:
        case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
        case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
        case VK_FORMAT_R16G16B16A16_UNORM:
        case VK_FORMAT_R16G16_SFLOAT:
        case VK_FORMAT_S8_UINT:
        case VK_FORMAT_D16_UNORM:
        case VK_FORMAT_D32_SFLOAT:
        case VK_FORMAT_D24_UNORM_S8_UINT:
        case VK_FORMAT_D32_SFLOAT_S8_UINT:
            return true;
        default:
            return false;
    }
}

◆ VulkanTextureSpecToTextureInfo()

VulkanTextureInfo skgpu::graphite::VulkanTextureSpecToTextureInfo	(	const VulkanTextureSpec &	vkSpec,
		uint32_t	sampleCount,
		Mipmapped	mipmapped
	)

Definition at line 12 of file VulkanGraphiteTypes.cpp.

                                                                      {
    return VulkanTextureInfo(sampleCount,
                             mipmapped,
                             vkSpec.fFlags,
                             vkSpec.fFormat,
                             vkSpec.fImageTiling,
                             vkSpec.fImageUsageFlags,
                             vkSpec.fSharingMode,
                             vkSpec.fAspectMask,
                             vkSpec.fYcbcrConversionInfo);
}

◆ write_color_and_offset_bufdata()

static int skgpu::graphite::write_color_and_offset_bufdata	(	int	numStops,
		const SkPMColor4f *	colors,
		const float *	offsets,
		const SkGradientBaseShader *	shader,
		PipelineDataGatherer *	gatherer
	)

static

Definition at line 313 of file KeyHelpers.cpp.

                                                                           {
    auto [dstData, bufferOffset] = gatherer->allocateGradientData(numStops, shader);
    if (dstData) {
        // Data doesn't already exist so we need to write it.
        for (int i = 0; i < numStops; i++) {
            SkColor4f unpremulColor = colors[i].unpremul();
 
            float offset = offsets ? offsets[i] : SkIntToFloat(i) / (numStops - 1);
            SkASSERT(offset >= 0.0f && offset <= 1.0f);
 
            int dataIndex = i * 5;
            dstData[dataIndex] = offset;
            dstData[dataIndex + 1] = unpremulColor.fR;
            dstData[dataIndex + 2] = unpremulColor.fG;
            dstData[dataIndex + 3] = unpremulColor.fB;
            dstData[dataIndex + 4] = unpremulColor.fA;
        }
    }
 
    return bufferOffset;
}

◆ write_index_buffer() [1/2]

static void skgpu::graphite::write_index_buffer ( VertexWriter writer )

static

Definition at line 259 of file AnalyticRRectRenderStep.cpp.

                                                    {
    static constexpr uint16_t kTL = 0 * kCornerVertexCount;
    static constexpr uint16_t kTR = 1 * kCornerVertexCount;
    static constexpr uint16_t kBR = 2 * kCornerVertexCount;
    static constexpr uint16_t kBL = 3 * kCornerVertexCount;
 
    static const uint16_t kIndices[kIndexCount] = {
        // Exterior AA ramp outset
        kTL+0,kTL+4,kTL+1,kTL+5,kTL+2,kTL+3,kTL+5,
        kTR+0,kTR+4,kTR+1,kTR+5,kTR+2,kTR+3,kTR+5,
        kBR+0,kBR+4,kBR+1,kBR+5,kBR+2,kBR+3,kBR+5,
        kBL+0,kBL+4,kBL+1,kBL+5,kBL+2,kBL+3,kBL+5,
        kTL+0,kTL+4, // close and jump to next strip
        // Outer to inner edges
        kTL+4,kTL+6,kTL+5,kTL+7,
        kTR+4,kTR+6,kTR+5,kTR+7,
        kBR+4,kBR+6,kBR+5,kBR+7,
        kBL+4,kBL+6,kBL+5,kBL+7,
        kTL+4,kTL+6, // close and jump to next strip
        // Fill triangles
        kTL+6,kTL+8,kTL+7, kTL+7,kTR+8,
        kTR+6,kTR+8,kTR+7, kTR+7,kBR+8,
        kBR+6,kBR+8,kBR+7, kBR+7,kBL+8,
        kBL+6,kBL+8,kBL+7, kBL+7,kTL+8,
        kTL+6 // close
    };
 
    if (writer) {
        writer << kIndices;
    } // otherwise static buffer creation failed, so do nothing; Context initialization will fail.
}

◆ write_index_buffer() [2/2]

static void skgpu::graphite::write_index_buffer ( VertexWriter writer )

static

Definition at line 131 of file PerEdgeAAQuadRenderStep.cpp.

                                                    {
    static constexpr uint16_t kTL = 0 * kCornerVertexCount;
    static constexpr uint16_t kTR = 1 * kCornerVertexCount;
    static constexpr uint16_t kBR = 2 * kCornerVertexCount;
    static constexpr uint16_t kBL = 3 * kCornerVertexCount;
 
    static const uint16_t kIndices[kIndexCount] = {
        // Exterior AA ramp outset
        kTL+1,kTL+2,kTL+3,kTR+0,kTR+3,kTR+1,
        kTR+1,kTR+2,kTR+3,kBR+0,kBR+3,kBR+1,
        kBR+1,kBR+2,kBR+3,kBL+0,kBL+3,kBL+1,
        kBL+1,kBL+2,kBL+3,kTL+0,kTL+3,kTL+1,
        kTL+3,
        // Fill triangles
        kTL+3,kTR+3,kBL+3,kBR+3
    };
 
    if (writer) {
        writer << kIndices;
    } // otherwise static buffer creation failed, so do nothing; Context initialization will fail.
}

◆ write_vertex_buffer() [1/2]

static void skgpu::graphite::write_vertex_buffer ( VertexWriter writer )

static

Definition at line 291 of file AnalyticRRectRenderStep.cpp.

                                                     {
    // Allowed values for the normal scale attribute. +1 signals a device-space outset along the
    // normal away from the outer edge of the stroke. 0 signals no outset, but placed on the outer
    // edge of the stroke. -1 signals a local inset along the normal from the inner edge.
    static constexpr float kOutset = 1.0;
    static constexpr float kInset  = -1.0;
 
    static constexpr float kCenter = 1.f; // "true" as a float
 
    // Zero, but named this way to help call out non-zero parameters.
    static constexpr float _______ = 0.f;
 
    static constexpr float kHR2 = 0.5f * SK_FloatSqrt2; // "half root 2"
 
    // This template is repeated 4 times in the vertex buffer, for each of the four corners.
    // The vertex ID is used to lookup per-corner instance properties such as corner radii or
    // positions, but otherwise this vertex data produces a consistent clockwise mesh from
    // TL -> TR -> BR -> BL.
    static constexpr Vertex kCornerTemplate[kCornerVertexCount] = {
        // Device-space AA outsets from outer curve
        { {1.0f, 0.0f}, {1.0f, 0.0f}, kOutset, _______ },
        { {1.0f, 0.0f}, {kHR2, kHR2}, kOutset, _______ },
        { {0.0f, 1.0f}, {kHR2, kHR2}, kOutset, _______ },
        { {0.0f, 1.0f}, {0.0f, 1.0f}, kOutset, _______ },
 
        // Outer anchors (no local or device-space normal outset)
        { {1.0f, 0.0f}, {kHR2, kHR2}, _______, _______ },
        { {0.0f, 1.0f}, {kHR2, kHR2}, _______, _______ },
 
        // Inner curve (with additional AA inset in the common case)
        { {1.0f, 0.0f}, {1.0f, 0.0f}, kInset, _______ },
        { {0.0f, 1.0f}, {0.0f, 1.0f}, kInset, _______ },
 
        // Center filling vertices (equal to inner AA insets unless 'center' triggers a fill).
        // TODO: On backends that support "cull" distances (and with SkSL support), these vertices
        // and their corresponding triangles can be completely removed. The inset vertices can
        // set their cull distance value to cause all filling triangles to be discarded or not
        // depending on the instance's style.
        { {1.0f, 0.0f}, {1.0f, 0.0f}, kInset,  kCenter },
    };
 
    if (writer) {
        writer << kCornerTemplate  // TL
               << kCornerTemplate  // TR
               << kCornerTemplate  // BR
               << kCornerTemplate; // BL
    } // otherwise static buffer creation failed, so do nothing; Context initialization will fail.
}

◆ write_vertex_buffer() [2/2]

static void skgpu::graphite::write_vertex_buffer ( VertexWriter writer )

static

Definition at line 153 of file PerEdgeAAQuadRenderStep.cpp.

                                                     {
    static constexpr float kHR2 = 0.5f * SK_FloatSqrt2; // "half root 2"
 
    // This template is repeated 4 times in the vertex buffer, for each of the four corners.
    // The vertex ID is used to lookup per-corner instance properties such as positions,
    // but otherwise this vertex data produces a consistent clockwise mesh from
    // TL -> TR -> BR -> BL.
    static constexpr Vertex kCornerTemplate[kCornerVertexCount] = {
        // Normals for device-space AA outsets from outer curve
        { {1.0f, 0.0f} },
        { {kHR2, kHR2} },
        { {0.0f, 1.0f} },
 
        // Normal for outer anchor (zero length to signal no local or device-space normal outset)
        { {0.0f, 0.0f} },
    };
 
    if (writer) {
        writer << kCornerTemplate  // TL
               << kCornerTemplate  // TR
               << kCornerTemplate  // BR
               << kCornerTemplate; // BL
    } // otherwise static buffer creation failed, so do nothing; Context initialization will fail.
}

Variable Documentation

◆ kAtlasRecentlyUsedCount

constexpr auto skgpu::graphite::kAtlasRecentlyUsedCount = 128

staticconstexpr

Definition at line 187 of file DrawAtlas.cpp.

◆ kBufferTypeCount

const int skgpu::graphite::kBufferTypeCount = static_cast<int>(BufferType::kLast) + 1

static

Definition at line 72 of file ResourceTypes.h.

◆ kBuiltInCodeSnippetIDCount

constexpr int skgpu::graphite::kBuiltInCodeSnippetIDCount = static_cast<int>(BuiltInCodeSnippetID::kLast)+1

staticconstexpr

Definition at line 108 of file BuiltInCodeSnippetID.h.

◆ kCompareOpCount

constexpr int skgpu::graphite::kCompareOpCount = 1 + (int)CompareOp::kNotEqual

staticconstexpr

Definition at line 159 of file DrawTypes.h.

◆ kComplexAAInsets

constexpr float skgpu::graphite::kComplexAAInsets = -1.f

staticconstexpr

Definition at line 253 of file AnalyticRRectRenderStep.cpp.

◆ kCornerVertexCount [1/2]

constexpr int skgpu::graphite::kCornerVertexCount = 9

staticconstexpr

Definition at line 255 of file AnalyticRRectRenderStep.cpp.

◆ kCornerVertexCount [2/2]

constexpr int skgpu::graphite::kCornerVertexCount = 4

staticconstexpr

Definition at line 127 of file PerEdgeAAQuadRenderStep.cpp.

◆ kDecrementCCW

constexpr DepthStencilSettings::Face skgpu::graphite::kDecrementCCW

constexpr

Initial value:

= {
           StencilOp::kKeep,
             StencilOp::kKeep,
                StencilOp::kDecWrap,
               CompareOp::kAlways,
              0xffffffff,
             0xffffffff
}

Definition at line 56 of file CommonDepthStencilSettings.h.

◆ kDefaultAtlasDim

constexpr uint32_t skgpu::graphite::kDefaultAtlasDim = 4096

staticconstexpr

Definition at line 21 of file RasterPathAtlas.cpp.

◆ kDefaultOutstandingAllocCnt

constexpr int skgpu::graphite::kDefaultOutstandingAllocCnt = 8

staticconstexpr

Definition at line 30 of file QueueManager.cpp.

◆ kDepthStencilVkFormats

constexpr VkFormat skgpu::graphite::kDepthStencilVkFormats[]

staticconstexpr

Initial value:

= {
    VK_FORMAT_S8_UINT,
    VK_FORMAT_D16_UNORM,
    VK_FORMAT_D32_SFLOAT,
    VK_FORMAT_D24_UNORM_S8_UINT,
    VK_FORMAT_D32_SFLOAT_S8_UINT,
}

Definition at line 215 of file VulkanCaps.cpp.

◆ kDescriptorTypeCount

constexpr int skgpu::graphite::kDescriptorTypeCount = (int)(DescriptorType::kLast) + 1

staticconstexpr

Definition at line 30 of file DescriptorData.h.

◆ kDirectDepthGEqualPass

constexpr DepthStencilSettings skgpu::graphite::kDirectDepthGEqualPass

staticconstexpr

Initial value:

= {
               {},
                {},
          0,
         false,
        CompareOp::kGEqual,
           true,
          true
}

Definition at line 30 of file CommonDepthStencilSettings.h.

◆ kDirectDepthGreaterPass

constexpr DepthStencilSettings skgpu::graphite::kDirectDepthGreaterPass

staticconstexpr

Initial value:

= {
               {},
                {},
          0,
         false,
        CompareOp::kGreater,
           true,
          true
}

DepthStencilSettings reusable by RenderSteps that can shade directly in a single pass, using GREATER or GEQUAL depth tests depending on if they allow self-intersections.

Definition at line 20 of file CommonDepthStencilSettings.h.

◆ kDumpAtlasData

const constexpr bool skgpu::graphite::kDumpAtlasData = false

staticconstexpr

Definition at line 35 of file DrawAtlas.cpp.

◆ kElementStackIncrement

constexpr int skgpu::graphite::kElementStackIncrement = 8

staticconstexpr

Definition at line 963 of file ClipStack_graphite.cpp.

◆ kEvenOddStencilPass

constexpr DepthStencilSettings skgpu::graphite::kEvenOddStencilPass

constexpr

Initial value:

= {
               kToggle,
                kToggle,
          0,
         true,
        CompareOp::kGreater,
           true,
          false 
}

Definition at line 89 of file CommonDepthStencilSettings.h.

◆ kFilledStrokeInterior

constexpr float skgpu::graphite::kFilledStrokeInterior = -1.f

staticconstexpr

Definition at line 249 of file AnalyticRRectRenderStep.cpp.

◆ kFineAreaResources

constexpr ComputeStep::ResourceDesc skgpu::graphite::kFineAreaResources[]

staticconstexpr

Initial value:

= {
        BUFFER_BINDING(ConfigUniform, Uniform,          None),
        BUFFER_BINDING(Segments,      ReadOnlyStorage,  None),
        BUFFER_BINDING(PTCL,          ReadOnlyStorage,  None),
        BUFFER_BINDING(InfoBinData,   ReadOnlyStorage,  None),
        TEXTURE_BINDING(OutputImage,  WriteOnlyStorage, None),
}

Definition at line 263 of file VelloComputeSteps.cpp.

◆ kFineMsaaResources

constexpr ComputeStep::ResourceDesc skgpu::graphite::kFineMsaaResources[]

staticconstexpr

Initial value:

= {
        BUFFER_BINDING(ConfigUniform, Uniform,          None),
        BUFFER_BINDING(Segments,      ReadOnlyStorage,  None),
        BUFFER_BINDING(PTCL,          ReadOnlyStorage,  None),
        BUFFER_BINDING(InfoBinData,   ReadOnlyStorage,  None),
        TEXTURE_BINDING(OutputImage,  WriteOnlyStorage, None),
        BUFFER_BINDING(MaskLUT, ReadOnlyStorage, Mapped),
}

Definition at line 271 of file VelloComputeSteps.cpp.

◆ kFixedFunctionBlendModeIDOffset

constexpr int skgpu::graphite::kFixedFunctionBlendModeIDOffset

staticconstexpr

Initial value:

=

static_cast<int>(BuiltInCodeSnippetID::kFirstFixedFunctionBlendMode)

Definition at line 109 of file BuiltInCodeSnippetID.h.

◆ kGraphicsPipelineDomain

const skgpu::UniqueKey::Domain skgpu::graphite::kGraphicsPipelineDomain = UniqueKey::GenerateDomain()

static

Definition at line 895 of file MtlCaps.mm.

◆ kGraphicsPipelineKeyData32Count

const int skgpu::graphite::kGraphicsPipelineKeyData32Count = 5

static

Definition at line 896 of file MtlCaps.mm.

◆ kGridCellSize

constexpr int skgpu::graphite::kGridCellSize = 16

staticconstexpr

Definition at line 321 of file Device.cpp.

◆ kIncrementCW

constexpr DepthStencilSettings::Face skgpu::graphite::kIncrementCW

constexpr

Initial value:

= {
           StencilOp::kKeep,
             StencilOp::kKeep,
                StencilOp::kIncWrap,
               CompareOp::kAlways,
              0xffffffff,
             0xffffffff
}

"stencil" pass DepthStencilSettings reusable for RenderSteps following some form of stencil-then-cover multi-pass algorithm.

Definition at line 46 of file CommonDepthStencilSettings.h.

◆ kIndexCount [1/2]

constexpr int skgpu::graphite::kIndexCount = 69

staticconstexpr

Definition at line 257 of file AnalyticRRectRenderStep.cpp.

◆ kIndexCount [2/2]

constexpr int skgpu::graphite::kIndexCount = 29

staticconstexpr

Definition at line 129 of file PerEdgeAAQuadRenderStep.cpp.

◆ kIndirectDispatchArgumentSize

constexpr size_t skgpu::graphite::kIndirectDispatchArgumentSize = sizeof(IndirectDispatchArgs)

constexpr

Definition at line 24 of file ComputeTypes.h.

◆ kInverseCoverPass

constexpr DepthStencilSettings skgpu::graphite::kInverseCoverPass

constexpr

Initial value:

= {
               kPassZero,
                kPassZero,
          0,
         true,
        CompareOp::kGreater,
           true,
          true
}

Definition at line 141 of file CommonDepthStencilSettings.h.

◆ kLoadOpCount

constexpr int skgpu::graphite::kLoadOpCount = (int)(LoadOp::kLast) + 1

inlinestaticconstexpr

Definition at line 41 of file ResourceTypes.h.

◆ kMaxBruteForceN

constexpr int skgpu::graphite::kMaxBruteForceN = 64

staticconstexpr

Definition at line 322 of file Device.cpp.

◆ kMaxComputeDataFlowSlots

constexpr int skgpu::graphite::kMaxComputeDataFlowSlots = 28

constexpr

Definition at line 16 of file ComputeTypes.h.

◆ kMaxGridSize

constexpr int skgpu::graphite::kMaxGridSize = 32

staticconstexpr

Definition at line 323 of file Device.cpp.

◆ kMaxNumberOfCachedBufferDescSets

constexpr int skgpu::graphite::kMaxNumberOfCachedBufferDescSets = 1024

constexpr

Definition at line 42 of file VulkanResourceProvider.cpp.

◆ kMtlFormats

constexpr MTLPixelFormat skgpu::graphite::kMtlFormats[]

staticconstexpr

Definition at line 228 of file MtlCaps.mm.

◆ kNoChildren

constexpr int skgpu::graphite::kNoChildren = 0

staticconstexpr

Definition at line 37 of file ShaderCodeDictionary.cpp.

◆ kPassNonZero

constexpr DepthStencilSettings::Face skgpu::graphite::kPassNonZero

constexpr

Initial value:

= {
           StencilOp::kKeep,
             StencilOp::kZero,
                StencilOp::kZero,
               CompareOp::kNotEqual,
              0xffffffff,
             0xffffffff
}

"cover" pass DepthStencilSettings reusable for RenderSteps following some form of stencil-then-cover multi-pass algorithm.

Definition at line 108 of file CommonDepthStencilSettings.h.

◆ kPassZero

constexpr DepthStencilSettings::Face skgpu::graphite::kPassZero

constexpr

Initial value:

= {
           StencilOp::kZero,
             StencilOp::kKeep,
                StencilOp::kKeep,
               CompareOp::kEqual,
              0xffffffff,
             0xffffffff
}

Definition at line 118 of file CommonDepthStencilSettings.h.

◆ kPlotRecentlyUsedCount

constexpr auto skgpu::graphite::kPlotRecentlyUsedCount = 32

staticconstexpr

Definition at line 186 of file DrawAtlas.cpp.

◆ kRegularCoverPass

constexpr DepthStencilSettings skgpu::graphite::kRegularCoverPass

constexpr

Initial value:

= {
               kPassNonZero,
                kPassNonZero,
          0,
         true,
        CompareOp::kGreater,
           true,
          true
}

Definition at line 129 of file CommonDepthStencilSettings.h.

◆ kReusedBufferSize

constexpr size_t skgpu::graphite::kReusedBufferSize = 64 << 10

staticconstexpr

Definition at line 20 of file UploadBufferManager.cpp.

◆ kRuntimeEffectColorSpaceTransformUniforms

constexpr Uniform skgpu::graphite::kRuntimeEffectColorSpaceTransformUniforms[]

staticconstexpr

Initial value:

= {
        
        { "flags_toLinear",          SkSLType::kInt },
        { "srcKind_toLinear",        SkSLType::kInt },
        { "gamutTransform_toLinear", SkSLType::kHalf3x3 },
        { "dstKind_toLinear",        SkSLType::kInt },
        { "csXformCoeffs_toLinear",  SkSLType::kHalf4x4 },
        
        { "flags_fromLinear",          SkSLType::kInt },
        { "srcKind_fromLinear",        SkSLType::kInt },
        { "gamutTransform_fromLinear", SkSLType::kHalf3x3 },
        { "dstKind_fromLinear",        SkSLType::kInt },
        { "csXformCoeffs_fromLinear",  SkSLType::kHalf4x4 },
}

Definition at line 46 of file ShaderCodeDictionary.cpp.

◆ kRuntimeShaderName

constexpr char skgpu::graphite::kRuntimeShaderName[] = "RuntimeEffect"

staticconstexpr

Definition at line 38 of file ShaderCodeDictionary.cpp.

◆ kSaveStackIncrement

constexpr int skgpu::graphite::kSaveStackIncrement = 8

staticconstexpr

Definition at line 964 of file ClipStack_graphite.cpp.

◆ kSmallPathPlotHeight

constexpr uint32_t skgpu::graphite::kSmallPathPlotHeight = 256

staticconstexpr

Definition at line 24 of file RasterPathAtlas.cpp.

◆ kSmallPathPlotWidth

constexpr uint32_t skgpu::graphite::kSmallPathPlotWidth = 512

staticconstexpr

Definition at line 23 of file RasterPathAtlas.cpp.

◆ kSolidInterior

constexpr float skgpu::graphite::kSolidInterior = 1.f

staticconstexpr

Definition at line 247 of file AnalyticRRectRenderStep.cpp.

◆ kStencilOpCount

constexpr int skgpu::graphite::kStencilOpCount = 1 + (int)StencilOp::kDecClamp

staticconstexpr

Definition at line 173 of file DrawTypes.h.

◆ kStoreOpCount

constexpr int skgpu::graphite::kStoreOpCount = (int)(StoreOp::kLast) + 1

inlinestaticconstexpr

Definition at line 52 of file ResourceTypes.h.

◆ kStrokeInterior

constexpr float skgpu::graphite::kStrokeInterior = 0.f

staticconstexpr

Definition at line 248 of file AnalyticRRectRenderStep.cpp.

◆ kToggle

constexpr DepthStencilSettings::Face skgpu::graphite::kToggle

constexpr

Initial value:

= {
           StencilOp::kKeep,
             StencilOp::kKeep,
                StencilOp::kInvert,
               CompareOp::kAlways,
              0xffffffff,
             0x00000001
}

Definition at line 66 of file CommonDepthStencilSettings.h.

◆ kVelloSlot_BinHeader

constexpr int skgpu::graphite::kVelloSlot_BinHeader = 17

constexpr

Definition at line 154 of file VelloComputeSteps.h.

◆ kVelloSlot_BumpAlloc

constexpr int skgpu::graphite::kVelloSlot_BumpAlloc = 16

constexpr

Definition at line 153 of file VelloComputeSteps.h.

◆ kVelloSlot_ClipBBoxes

constexpr int skgpu::graphite::kVelloSlot_ClipBBoxes = 14

constexpr

Definition at line 145 of file VelloComputeSteps.h.

◆ kVelloSlot_ClipBicyclic

constexpr int skgpu::graphite::kVelloSlot_ClipBicyclic = 12

constexpr

Definition at line 143 of file VelloComputeSteps.h.

◆ kVelloSlot_ClipElement

constexpr int skgpu::graphite::kVelloSlot_ClipElement = 13

constexpr

Definition at line 144 of file VelloComputeSteps.h.

◆ kVelloSlot_ClipInput

constexpr int skgpu::graphite::kVelloSlot_ClipInput = 11

constexpr

Definition at line 134 of file VelloComputeSteps.h.

◆ kVelloSlot_ConfigUniform

constexpr int skgpu::graphite::kVelloSlot_ConfigUniform = 0

constexpr

Definition at line 90 of file VelloComputeSteps.h.

◆ kVelloSlot_DrawBBoxes

constexpr int skgpu::graphite::kVelloSlot_DrawBBoxes = 15

constexpr

Definition at line 152 of file VelloComputeSteps.h.

◆ kVelloSlot_DrawMonoid

constexpr int skgpu::graphite::kVelloSlot_DrawMonoid = 9

constexpr

Definition at line 132 of file VelloComputeSteps.h.

◆ kVelloSlot_DrawReduceOutput

constexpr int skgpu::graphite::kVelloSlot_DrawReduceOutput = 8

constexpr

Definition at line 131 of file VelloComputeSteps.h.

◆ kVelloSlot_GradientImage

constexpr int skgpu::graphite::kVelloSlot_GradientImage = 24

constexpr

Definition at line 169 of file VelloComputeSteps.h.

◆ kVelloSlot_ImageAtlas

constexpr int skgpu::graphite::kVelloSlot_ImageAtlas = 25

constexpr

Definition at line 170 of file VelloComputeSteps.h.

◆ kVelloSlot_IndirectCount

constexpr int skgpu::graphite::kVelloSlot_IndirectCount = 26

constexpr

Definition at line 175 of file VelloComputeSteps.h.

◆ kVelloSlot_InfoBinData

constexpr int skgpu::graphite::kVelloSlot_InfoBinData = 10

constexpr

Definition at line 133 of file VelloComputeSteps.h.

◆ kVelloSlot_LargePathtagReduceFirstPassOutput

constexpr int skgpu::graphite::kVelloSlot_LargePathtagReduceFirstPassOutput = kVelloSlot_PathtagReduceOutput

constexpr

Definition at line 112 of file VelloComputeSteps.h.

◆ kVelloSlot_LargePathtagReduceSecondPassOutput

constexpr int skgpu::graphite::kVelloSlot_LargePathtagReduceSecondPassOutput = 4

constexpr

Definition at line 113 of file VelloComputeSteps.h.

◆ kVelloSlot_LargePathtagScanFirstPassOutput

constexpr int skgpu::graphite::kVelloSlot_LargePathtagScanFirstPassOutput = 5

constexpr

Definition at line 114 of file VelloComputeSteps.h.

◆ kVelloSlot_Lines

constexpr int skgpu::graphite::kVelloSlot_Lines = 7

constexpr

Definition at line 124 of file VelloComputeSteps.h.

◆ kVelloSlot_MaskLUT

constexpr int skgpu::graphite::kVelloSlot_MaskLUT = 27

constexpr

Definition at line 179 of file VelloComputeSteps.h.

◆ kVelloSlot_OutputImage

constexpr int skgpu::graphite::kVelloSlot_OutputImage = 23

constexpr

Definition at line 168 of file VelloComputeSteps.h.

◆ kVelloSlot_Path

constexpr int skgpu::graphite::kVelloSlot_Path = 18

constexpr

Definition at line 156 of file VelloComputeSteps.h.

◆ kVelloSlot_PathBBoxes

constexpr int skgpu::graphite::kVelloSlot_PathBBoxes = 6

constexpr

Definition at line 123 of file VelloComputeSteps.h.

◆ kVelloSlot_PathtagReduceOutput

constexpr int skgpu::graphite::kVelloSlot_PathtagReduceOutput = 3

constexpr

Definition at line 109 of file VelloComputeSteps.h.

◆ kVelloSlot_PTCL

constexpr int skgpu::graphite::kVelloSlot_PTCL = 22

constexpr

Definition at line 160 of file VelloComputeSteps.h.

◆ kVelloSlot_Scene

constexpr int skgpu::graphite::kVelloSlot_Scene = 1

constexpr

Definition at line 93 of file VelloComputeSteps.h.

◆ kVelloSlot_SegmentCounts

constexpr int skgpu::graphite::kVelloSlot_SegmentCounts = 20

constexpr

Definition at line 158 of file VelloComputeSteps.h.

◆ kVelloSlot_Segments

constexpr int skgpu::graphite::kVelloSlot_Segments = 21

constexpr

Definition at line 159 of file VelloComputeSteps.h.

◆ kVelloSlot_TagMonoid

constexpr int skgpu::graphite::kVelloSlot_TagMonoid = 2

constexpr

Definition at line 106 of file VelloComputeSteps.h.

◆ kVelloSlot_Tile

constexpr int skgpu::graphite::kVelloSlot_Tile = 19

constexpr

Definition at line 157 of file VelloComputeSteps.h.

◆ kVertexAttribTypeCount

const int skgpu::graphite::kVertexAttribTypeCount = (int)(VertexAttribType::kLast) + 1

static

Definition at line 71 of file DrawTypes.h.

◆ kVertexCount [1/2]

constexpr int skgpu::graphite::kVertexCount = 4 * kCornerVertexCount

staticconstexpr

Definition at line 256 of file AnalyticRRectRenderStep.cpp.

◆ kVertexCount [2/2]

constexpr int skgpu::graphite::kVertexCount = 4 * kCornerVertexCount

staticconstexpr

Definition at line 128 of file PerEdgeAAQuadRenderStep.cpp.

◆ kVkFormats

constexpr VkFormat skgpu::graphite::kVkFormats[]

staticconstexpr

◆ kWindingStencilPass

constexpr DepthStencilSettings skgpu::graphite::kWindingStencilPass

constexpr

Initial value:

= {
               kIncrementCW,
                kDecrementCCW,
          0,
         true,
        CompareOp::kGreater,
           true,
          false 
}

Definition at line 77 of file CommonDepthStencilSettings.h.

◆ vkLoadOp

const VkAttachmentLoadOp skgpu::graphite::vkLoadOp[]

static

Initial value:

{
    VK_ATTACHMENT_LOAD_OP_LOAD,
    VK_ATTACHMENT_LOAD_OP_CLEAR,
    VK_ATTACHMENT_LOAD_OP_DONT_CARE
}

Definition at line 27 of file VulkanRenderPass.h.

◆ vkStoreOp

const VkAttachmentStoreOp skgpu::graphite::vkStoreOp[]

static

Initial value:

{
    VK_ATTACHMENT_STORE_OP_STORE,
    VK_ATTACHMENT_STORE_OP_DONT_CARE
}

Definition at line 23 of file VulkanRenderPass.h.

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ AAFlags

◆ AddToKeyFn

◆ BindingIndex

◆ Builder

◆ CompressedPaintersOrder

◆ DawnTickFunction

◆ DisjointStencilIndex

◆ DispatchResource

◆ DispatchResourceOptional

◆ DrawCallback

◆ GpuFinishedContext

◆ GpuFinishedProc

◆ MtlPixelFormat

◆ MtlStorageMode

◆ MtlTextureUsage

◆ PaintersDepth

◆ PrecompileChildOptions

◆ ResourceType

◆ Status

◆ TextureDataCache

◆ UniformDataCache

Enumeration Type Documentation

◆ AccessPattern

◆ BufferType

◆ BuiltInCodeSnippetID

◆ ClearBuffer

◆ CompareOp

◆ Coverage

◆ DawnErrorType

◆ DepthStencilFlags

◆ DescriptorType

◆ Discardable

◆ DrawTypeFlags

◆ DstColorType

◆ DstReadRequirement

◆ LastRemovedRef

◆ Layout

◆ LoadOp

◆ Ownership

◆ PathRendererStrategy

◆ PipelineStageFlags

◆ PrecompileImageShaderFlags

◆ PrimitiveType

◆ Priority

◆ ReadSwizzle

◆ Shareable

◆ SnippetRequirementFlags

◆ StencilOp

◆ StoreOp

◆ SyncToCpu

◆ UniformSlot

◆ VelloAaConfig

◆ VertexAttribType

◆ Volatile

Function Documentation

◆ add_gradient_to_key() [1/5]

◆ add_gradient_to_key() [2/5]

◆ add_gradient_to_key() [3/5]

◆ add_gradient_to_key() [4/5]

◆ add_gradient_to_key() [5/5]

◆ add_to_key() [1/24]

◆ add_to_key() [2/24]

◆ add_to_key() [3/24]

◆ add_to_key() [4/24]

◆ add_to_key() [5/24]

◆ add_to_key() [6/24]

◆ add_to_key() [7/24]

◆ add_to_key() [8/24]

◆ add_to_key() [9/24]

◆ add_to_key() [10/24]

◆ add_to_key() [11/24]

◆ add_to_key() [12/24]

◆ add_to_key() [13/24]