skgpu::graphite::MtlResourceProvider Class Reference

#include <MtlResourceProvider.h>

Inheritance diagram for skgpu::graphite::MtlResourceProvider:

Public Member Functions
	MtlResourceProvider (SharedContext *sharedContext, SingleOwner *, uint32_t recorderID, size_t resourceBudget)
	~MtlResourceProvider () override
sk_sp< Texture >	createWrappedTexture (const BackendTexture &) override
sk_sp< MtlGraphicsPipeline >	findOrCreateLoadMSAAPipeline (const RenderPassDesc &)
Public Member Functions inherited from skgpu::graphite::ResourceProvider
virtual	~ResourceProvider ()
sk_sp< GraphicsPipeline >	findOrCreateGraphicsPipeline (const RuntimeEffectDictionary *, const GraphicsPipelineDesc &, const RenderPassDesc &)
sk_sp< ComputePipeline >	findOrCreateComputePipeline (const ComputePipelineDesc &)
sk_sp< Texture >	findOrCreateScratchTexture (SkISize, const TextureInfo &, skgpu::Budgeted)
sk_sp< Texture >	findOrCreateDepthStencilAttachment (SkISize dimensions, const TextureInfo &)
sk_sp< Texture >	findOrCreateDiscardableMSAAAttachment (SkISize dimensions, const TextureInfo &)
sk_sp< Buffer >	findOrCreateBuffer (size_t size, BufferType type, AccessPattern, std::string_view label)
sk_sp< Sampler >	findOrCreateCompatibleSampler (const SamplerDesc &)
BackendTexture	createBackendTexture (SkISize dimensions, const TextureInfo &)
void	deleteBackendTexture (const BackendTexture &)
ProxyCache *	proxyCache ()
size_t	getResourceCacheLimit () const
size_t	getResourceCacheCurrentBudgetedBytes () const
void	dumpMemoryStatistics (SkTraceMemoryDump *traceMemoryDump) const
void	freeGpuResources ()
void	purgeResourcesNotUsedSince (StdSteadyClock::time_point purgeTime)

Private Member Functions
sk_sp< GraphicsPipeline >	createGraphicsPipeline (const RuntimeEffectDictionary *, const GraphicsPipelineDesc &, const RenderPassDesc &) override
sk_sp< ComputePipeline >	createComputePipeline (const ComputePipelineDesc &) override
sk_sp< Texture >	createTexture (SkISize, const TextureInfo &, skgpu::Budgeted) override
sk_sp< Buffer >	createBuffer (size_t size, BufferType type, AccessPattern, std::string_view label) override
sk_sp< Sampler >	createSampler (const SamplerDesc &) override
BackendTexture	onCreateBackendTexture (SkISize dimensions, const TextureInfo &) override
void	onDeleteBackendTexture (const BackendTexture &) override

Additional Inherited Members
Protected Member Functions inherited from skgpu::graphite::ResourceProvider
	ResourceProvider (SharedContext *sharedContext, SingleOwner *singleOwner, uint32_t recorderID, size_t resourceBudget)
Protected Attributes inherited from skgpu::graphite::ResourceProvider
SharedContext *	fSharedContext
sk_sp< ResourceCache >	fResourceCache

Detailed Description

Definition at line 23 of file MtlResourceProvider.h.

Constructor & Destructor Documentation

MtlResourceProvider()

skgpu::graphite::MtlResourceProvider::MtlResourceProvider	(	SharedContext *	sharedContext,
		SingleOwner *	singleOwner,
		uint32_t	recorderID,
		size_t	resourceBudget
	)

Definition at line 43 of file MtlResourceProvider.mm.

        : ResourceProvider(sharedContext, singleOwner, recorderID, resourceBudget) {}

~MtlResourceProvider()

skgpu::graphite::MtlResourceProvider::~MtlResourceProvider ( )

inlineoverride

Definition at line 29 of file MtlResourceProvider.h.

{}

Member Function Documentation

createBuffer()

sk_sp< Buffer > skgpu::graphite::MtlResourceProvider::createBuffer ( size_t  size, BufferType  type, AccessPattern  accessPattern, std::string_view  label  )

overrideprivatevirtual

Implements skgpu::graphite::ResourceProvider.

Definition at line 258 of file MtlResourceProvider.mm.

                                                                      {

createComputePipeline()

sk_sp< ComputePipeline > skgpu::graphite::MtlResourceProvider::createComputePipeline ( const ComputePipelineDesc &  pipelineDesc )

overrideprivatevirtual

Implements skgpu::graphite::ResourceProvider.

Definition at line 197 of file MtlResourceProvider.mm.

                                                 {
    sk_cfp<id<MTLLibrary>> library;
    std::string entryPointName;
    ShaderErrorHandler* errorHandler = fSharedContext->caps()->shaderErrorHandler();
    if (pipelineDesc.computeStep()->supportsNativeShader()) {
        auto nativeShader = pipelineDesc.computeStep()->nativeShaderSource(
                ComputeStep::NativeShaderFormat::kMSL);
        library = MtlCompileShaderLibrary(this->mtlSharedContext(),
                                          pipelineDesc.computeStep()->name(),
                                          nativeShader.fSource,
                                          errorHandler);
        if (library == nil) {
            return nullptr;
        }
        entryPointName = std::move(nativeShader.fEntryPoint);
    } else {
        std::string msl;
        SkSL::Program::Interface interface;
        SkSL::ProgramSettings settings;
 
        SkSL::Compiler skslCompiler;
        std::string sksl = BuildComputeSkSL(fSharedContext->caps(), pipelineDesc.computeStep());
        if (!SkSLToMSL(fSharedContext->caps()->shaderCaps(),
                       sksl,
                       SkSL::ProgramKind::kCompute,
                       settings,
                       &msl,
                       &interface,
                       errorHandler)) {
            return nullptr;
        }
        library = MtlCompileShaderLibrary(this->mtlSharedContext(),
                                          pipelineDesc.computeStep()->name(),
                                          msl,
                                          errorHandler);
        entryPointName = "computeMain";
    }
    return MtlComputePipeline::Make(this->mtlSharedContext(),
                                    pipelineDesc.computeStep()->name(),

createGraphicsPipeline()

sk_sp< GraphicsPipeline > skgpu::graphite::MtlResourceProvider::createGraphicsPipeline ( const RuntimeEffectDictionary *  runtimeDict, const GraphicsPipelineDesc &  pipelineDesc, const RenderPassDesc &  renderPassDesc  )

overrideprivatevirtual

Implements skgpu::graphite::ResourceProvider.

Definition at line 110 of file MtlResourceProvider.mm.

                                              {
    std::string vsMSL, fsMSL;
    SkSL::Program::Interface vsInterface, fsInterface;
    SkSL::ProgramSettings settings;
 
    settings.fForceNoRTFlip = true;
 
    SkSL::Compiler skslCompiler;
    ShaderErrorHandler* errorHandler = fSharedContext->caps()->shaderErrorHandler();
 
    const RenderStep* step =
            fSharedContext->rendererProvider()->lookup(pipelineDesc.renderStepID());
    const bool useStorageBuffers = fSharedContext->caps()->storageBufferPreferred();
 
    UniquePaintParamsID paintID = pipelineDesc.paintParamsID();
    FragSkSLInfo fsSkSLInfo = BuildFragmentSkSL(fSharedContext->caps(),
                                                fSharedContext->shaderCodeDictionary(),
                                                runtimeDict,
                                                step,
                                                paintID,
                                                useStorageBuffers,
                                                renderPassDesc.fWriteSwizzle);
    std::string& fsSkSL = fsSkSLInfo.fSkSL;
    const BlendInfo& blendInfo = fsSkSLInfo.fBlendInfo;
    const bool localCoordsNeeded = fsSkSLInfo.fRequiresLocalCoords;
    if (!SkSLToMSL(fSharedContext->caps()->shaderCaps(),
                   fsSkSL,
                   SkSL::ProgramKind::kGraphiteFragment,
                   settings,
                   &fsMSL,
                   &fsInterface,
                   errorHandler)) {
        return nullptr;
    }
 
    VertSkSLInfo vsSkSLInfo = BuildVertexSkSL(fSharedContext->caps()->resourceBindingRequirements(),
                                              step,
                                              useStorageBuffers,
                                              localCoordsNeeded);
    const std::string& vsSkSL = vsSkSLInfo.fSkSL;
    if (!SkSLToMSL(fSharedContext->caps()->shaderCaps(),
                   vsSkSL,
                   SkSL::ProgramKind::kGraphiteVertex,
                   settings,
                   &vsMSL,
                   &vsInterface,
                   errorHandler)) {
        return nullptr;
    }
 
    auto vsLibrary = MtlCompileShaderLibrary(
            this->mtlSharedContext(), vsSkSLInfo.fLabel, vsMSL, errorHandler);
    auto fsLibrary = MtlCompileShaderLibrary(
            this->mtlSharedContext(), fsSkSLInfo.fLabel, fsMSL, errorHandler);
 
    sk_cfp<id<MTLDepthStencilState>> dss =
            this->findOrCreateCompatibleDepthStencilState(step->depthStencilSettings());
 
#if defined(GRAPHITE_TEST_UTILS)
    GraphicsPipeline::PipelineInfo pipelineInfo = {pipelineDesc.renderStepID(),
                                                   pipelineDesc.paintParamsID(),
                                                   std::move(vsSkSL),
                                                   std::move(fsSkSL),
                                                   std::move(vsMSL),
                                                   std::move(fsMSL) };
    GraphicsPipeline::PipelineInfo* pipelineInfoPtr = &pipelineInfo;
#else
    GraphicsPipeline::PipelineInfo* pipelineInfoPtr = nullptr;
#endif
    std::string pipelineLabel =
            GetPipelineLabel(fSharedContext->shaderCodeDictionary(), renderPassDesc, step, paintID);
    return MtlGraphicsPipeline::Make(this->mtlSharedContext(),
                                     pipelineLabel,
                                     {vsLibrary.get(), "vertexMain"},
                                     step->vertexAttributes(),
                                     step->instanceAttributes(),
                                     {fsLibrary.get(), "fragmentMain"},
                                     std::move(dss),
                                     step->depthStencilSettings().fStencilReferenceValue,
                                     blendInfo,
                                     renderPassDesc,

createSampler()

sk_sp< Sampler > skgpu::graphite::MtlResourceProvider::createSampler ( const SamplerDesc &  samplerDesc )

overrideprivatevirtual

Implements skgpu::graphite::ResourceProvider.

Definition at line 265 of file MtlResourceProvider.mm.

                                                                                {
    return MtlSampler::Make(this->mtlSharedContext(),
                            samplerDesc.samplingOptions(),
                            samplerDesc.tileModeX(),

createTexture()

sk_sp< Texture > skgpu::graphite::MtlResourceProvider::createTexture ( SkISize  dimensions, const TextureInfo &  info, skgpu::Budgeted  budgeted  )

overrideprivatevirtual

Implements skgpu::graphite::ResourceProvider.

Definition at line 240 of file MtlResourceProvider.mm.

                                                                          {

createWrappedTexture()

sk_sp< Texture > skgpu::graphite::MtlResourceProvider::createWrappedTexture ( const BackendTexture &  texture )

overridevirtual

Implements skgpu::graphite::ResourceProvider.

Definition at line 246 of file MtlResourceProvider.mm.

                                                                                      {
    CFTypeRef mtlHandleTexture = texture.getMtlTexture();
    if (!mtlHandleTexture) {
        return nullptr;
    }
    sk_cfp<id<MTLTexture>> mtlTexture = sk_ret_cfp((id<MTLTexture>)mtlHandleTexture);
    return MtlTexture::MakeWrapped(this->mtlSharedContext(),
                                   texture.dimensions(),
                                   texture.info(),

findOrCreateLoadMSAAPipeline()

sk_sp< MtlGraphicsPipeline > skgpu::graphite::MtlResourceProvider::findOrCreateLoadMSAAPipeline

(

const RenderPassDesc &

renderPassDesc

)

Definition at line 53 of file MtlResourceProvider.mm.

                                              {
    uint64_t renderPassKey =
            this->mtlSharedContext()->mtlCaps().getRenderPassDescKey(renderPassDesc);
    sk_sp<MtlGraphicsPipeline> pipeline = fLoadMSAAPipelines[renderPassKey];
    if (!pipeline) {
        static const char* kLoadMSAAShaderText = R"(
                #include <metal_stdlib>
                #include <simd/simd.h>
                using namespace metal;
 
                typedef struct {
                    float4 position [[position]];
                } VertexOutput;
 
                vertex VertexOutput vertexMain(uint vertexID [[vertex_id]]) {
                    VertexOutput out;
                    float2 position = float2(float(vertexID >> 1), float(vertexID & 1));
                    out.position = float4(2.0 * position - 1.0, 0.0, 1.0);
                    return out;
                }
 
                fragment float4 fragmentMain(VertexOutput in [[stage_in]],
                                             texture2d<half> colorMap [[texture(0)]]) {
                    uint2 coords = uint2(in.position.x, in.position.y);
                    half4 colorSample   = colorMap.read(coords);
                    return float4(colorSample);
                }
        )";
 
        auto mtlLibrary = MtlCompileShaderLibrary(this->mtlSharedContext(),
                                                  "LoadMSAAFromResolve",
                                                  kLoadMSAAShaderText,
                                                  fSharedContext->caps()->shaderErrorHandler());
        BlendInfo noBlend{}; // default is equivalent to kSrc blending
        sk_cfp<id<MTLDepthStencilState>> ignoreDS =
                this->findOrCreateCompatibleDepthStencilState({});
 
        std::string pipelineLabel = "LoadMSAAFromResolve + ";
        pipelineLabel += renderPassDesc.toString().c_str();
        pipeline = MtlGraphicsPipeline::Make(this->mtlSharedContext(),
                                             pipelineLabel,
                                             {mtlLibrary.get(), "vertexMain"},
                                             /*vertexAttrs=*/{},
                                             /*instanceAttrs=*/{},
                                             {mtlLibrary.get(), "fragmentMain"},
                                             std::move(ignoreDS),
                                             /*stencilRefValue=*/0,
                                             noBlend,
                                             renderPassDesc,
                                             /*pipelineInfo=*/nullptr);
        if (pipeline) {
            fLoadMSAAPipelines.set(renderPassKey, pipeline);
        }
    }
 

onCreateBackendTexture()

BackendTexture skgpu::graphite::MtlResourceProvider::onCreateBackendTexture ( SkISize  dimensions, const TextureInfo &  info  )

overrideprivatevirtual

Implements skgpu::graphite::ResourceProvider.

Definition at line 352 of file MtlResourceProvider.mm.

                                                                                    {
    sk_cfp<id<MTLTexture>> texture = MtlTexture::MakeMtlTexture(this->mtlSharedContext(),
                                                                dimensions,
                                                                info);
    if (!texture) {
        return {};
    }

onDeleteBackendTexture()

void skgpu::graphite::MtlResourceProvider::onDeleteBackendTexture ( const BackendTexture &  texture )

overrideprivatevirtual

Implements skgpu::graphite::ResourceProvider.

Definition at line 363 of file MtlResourceProvider.mm.

                                                                              {
    SkASSERT(texture.backend() == BackendApi::kMetal);
    CFTypeRef texHandle = texture.getMtlTexture();

---

The documentation for this class was generated from the following files:

• third_party/skia/src/gpu/graphite/mtl/MtlResourceProvider.h
• third_party/skia/src/gpu/graphite/mtl/MtlResourceProvider.mm