GrMtlResourceProvider Class Reference

#include <GrMtlResourceProvider.h>

Public Member Functions
	GrMtlResourceProvider (GrMtlGpu *gpu)
GrMtlPipelineState *	findOrCreateCompatiblePipelineState (const GrProgramDesc &, const GrProgramInfo &, GrThreadSafePipelineBuilder::Stats::ProgramCacheResult *stat=nullptr)
bool	precompileShader (const SkData &key, const SkData &data)
GrMtlDepthStencil *	findOrCreateCompatibleDepthStencilState (const GrStencilSettings &, GrSurfaceOrigin)
GrMtlSampler *	findOrCreateCompatibleSampler (GrSamplerState)
const GrMtlRenderPipeline *	findOrCreateMSAALoadPipeline (MTLPixelFormat colorFormat, int sampleCount, MTLPixelFormat stencilFormat)
void	destroyResources ()

Detailed Description

Definition at line 28 of file GrMtlResourceProvider.h.

Constructor & Destructor Documentation

GrMtlResourceProvider()

GR_NORETAIN_BEGIN GrMtlResourceProvider::GrMtlResourceProvider

(

GrMtlGpu *

gpu

)

Definition at line 28 of file GrMtlResourceProvider.mm.

    : fGpu(gpu) {
    fPipelineStateCache = std::make_unique<PipelineStateCache>(gpu);
}

Member Function Documentation

destroyResources()

void GrMtlResourceProvider::destroyResources

(

)

Definition at line 157 of file GrMtlResourceProvider.mm.

                                             {
    fMSAALoadLibrary = nil;
    fMSAALoadPipelines.clear();
 
    fSamplers.foreach([&](GrMtlSampler* sampler) { sampler->unref(); });
    fSamplers.reset();
 
    fDepthStencilStates.foreach([&](GrMtlDepthStencil* stencil) { stencil->unref(); });
    fDepthStencilStates.reset();
 
    fPipelineStateCache->release();
}

findOrCreateCompatibleDepthStencilState()

GrMtlDepthStencil * GrMtlResourceProvider::findOrCreateCompatibleDepthStencilState	(	const GrStencilSettings &	stencil,
		GrSurfaceOrigin	origin
	)

Definition at line 46 of file GrMtlResourceProvider.mm.

                                                                  {
    GrMtlDepthStencil* depthStencilState;
    GrMtlDepthStencil::Key key = GrMtlDepthStencil::GenerateKey(stencil, origin);
    depthStencilState = fDepthStencilStates.find(key);
    if (!depthStencilState) {
        depthStencilState = GrMtlDepthStencil::Create(fGpu, stencil, origin);
        fDepthStencilStates.add(depthStencilState);
    }
    SkASSERT(depthStencilState);
    return depthStencilState;
}

findOrCreateCompatiblePipelineState()

GrMtlPipelineState * GrMtlResourceProvider::findOrCreateCompatiblePipelineState	(	const GrProgramDesc &	programDesc,
		const GrProgramInfo &	programInfo,
		GrThreadSafePipelineBuilder::Stats::ProgramCacheResult *	stat = nullptr
	)

Definition at line 33 of file GrMtlResourceProvider.mm.

                                                                  {
    return fPipelineStateCache->refPipelineState(programDesc, programInfo, stat);
}

findOrCreateCompatibleSampler()

GrMtlSampler * GrMtlResourceProvider::findOrCreateCompatibleSampler

(

GrSamplerState

params

)

Definition at line 59 of file GrMtlResourceProvider.mm.

                                                                                        {
    GrMtlSampler* sampler;
    sampler = fSamplers.find(GrMtlSampler::GenerateKey(params));
    if (!sampler) {
        sampler = GrMtlSampler::Create(fGpu, params);
        fSamplers.add(sampler);
    }
    SkASSERT(sampler);
    return sampler;
}

findOrCreateMSAALoadPipeline()

const GrMtlRenderPipeline * GrMtlResourceProvider::findOrCreateMSAALoadPipeline	(	MTLPixelFormat	colorFormat,
		int	sampleCount,
		MTLPixelFormat	stencilFormat
	)

Definition at line 70 of file GrMtlResourceProvider.mm.

                                                                                   {
    if (!fMSAALoadLibrary) {
        TRACE_EVENT0("skia", TRACE_FUNC);
 
        std::string shaderText;
        shaderText.append(
                "#include <metal_stdlib>\n"
                "#include <simd/simd.h>\n"
                "using namespace metal;\n"
                "\n"
                "typedef struct {\n"
                "    float4 position [[position]];\n"
                "} VertexOutput;\n"
                "\n"
                "typedef struct {\n"
                "    float4 uPosXform;\n"
                "    uint2 uTextureSize;\n"
                "} VertexUniforms;\n"
                "\n"
                "vertex VertexOutput vertexMain(constant VertexUniforms& uniforms [[buffer(0)]],\n"
                "                               uint vertexID [[vertex_id]]) {\n"
                "    VertexOutput out;\n"
                "    float2 position = float2(float(vertexID >> 1), float(vertexID & 1));\n"
                "    out.position.xy = position * uniforms.uPosXform.xy + uniforms.uPosXform.zw;\n"
                "    out.position.zw = float2(0.0, 1.0);\n"
                "    return out;\n"
                "}\n"
                "\n"
                "fragment float4 fragmentMain(VertexOutput in [[stage_in]],\n"
                "                             texture2d<half> colorMap [[texture(0)]]) {\n"
                "    uint2 coords = uint2(in.position.x, in.position.y);"
                "    half4 colorSample   = colorMap.read(coords);\n"
                "    return float4(colorSample);\n"
                "}"
        );
 
        auto errorHandler = fGpu->getContext()->priv().getShaderErrorHandler();
        fMSAALoadLibrary = GrCompileMtlShaderLibrary(fGpu, shaderText, errorHandler);
        if (!fMSAALoadLibrary) {
            return nullptr;
        }
    }
 
    for (int i = 0; i < fMSAALoadPipelines.size(); ++i) {
        if (fMSAALoadPipelines[i].fColorFormat == colorFormat &&
            fMSAALoadPipelines[i].fSampleCount == sampleCount &&
            fMSAALoadPipelines[i].fStencilFormat == stencilFormat) {
            return fMSAALoadPipelines[i].fPipeline.get();
        }
    }
 
    auto pipelineDescriptor = [[MTLRenderPipelineDescriptor alloc] init];
 
    pipelineDescriptor.label = @"loadMSAAFromResolve";
 
    pipelineDescriptor.vertexFunction =
            [fMSAALoadLibrary newFunctionWithName: @"vertexMain"];
    pipelineDescriptor.fragmentFunction =
            [fMSAALoadLibrary newFunctionWithName: @"fragmentMain"];
 
    auto mtlColorAttachment = [[MTLRenderPipelineColorAttachmentDescriptor alloc] init];
 
    mtlColorAttachment.pixelFormat = colorFormat;
    mtlColorAttachment.blendingEnabled = FALSE;
    mtlColorAttachment.writeMask = MTLColorWriteMaskAll;
 
    pipelineDescriptor.colorAttachments[0] = mtlColorAttachment;
    pipelineDescriptor.rasterSampleCount = sampleCount;
 
    pipelineDescriptor.stencilAttachmentPixelFormat = stencilFormat;
 
    NSError* error;
    auto pso =
            [fGpu->device() newRenderPipelineStateWithDescriptor: pipelineDescriptor
                                                          error: &error];
    if (!pso) {
        SkDebugf("Error creating pipeline: %s\n",
                 [[error localizedDescription] cStringUsingEncoding: NSASCIIStringEncoding]);
    }
 
    auto renderPipeline = GrMtlRenderPipeline::Make(pso);
 
    fMSAALoadPipelines.push_back({renderPipeline, colorFormat, sampleCount, stencilFormat});
    return fMSAALoadPipelines[fMSAALoadPipelines.size()-1].fPipeline.get();
}

precompileShader()

bool GrMtlResourceProvider::precompileShader	(	const SkData &	key,
		const SkData &	data
	)

Definition at line 40 of file GrMtlResourceProvider.mm.

                                                                                  {
    return fPipelineStateCache->precompileShader(key, data);
}

---

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

• third_party/skia/src/gpu/ganesh/mtl/GrMtlResourceProvider.h
• third_party/skia/src/gpu/ganesh/mtl/GrMtlResourceProvider.mm