#include <GrMtlPipelineStateBuilder.h>

Inheritance diagram for GrMtlPipelineStateBuilder:

Static Public Member Functions
static GrMtlPipelineState *	CreatePipelineState (GrMtlGpu , const GrProgramDesc &, const GrProgramInfo &, const GrMtlPrecompiledLibraries precompiledLibs=nullptr)

static bool	PrecompileShaders (GrMtlGpu , const SkData &, GrMtlPrecompiledLibraries precompiledLibs)

Private Member Functions
const GrCaps *	caps () const override

void	finalizeFragmentSecondaryColor (GrShaderVar &outputColor) override

GrGLSLUniformHandler *	uniformHandler () override

const GrGLSLUniformHandler *	uniformHandler () const override

GrGLSLVaryingHandler *	varyingHandler () override

Additional Inherited Members
Public Types inherited from GrGLSLProgramBuilder
using	UniformHandle = GrGLSLUniformHandler::UniformHandle

using	SamplerHandle = GrGLSLUniformHandler::SamplerHandle

Public Member Functions inherited from GrGLSLProgramBuilder
virtual	~GrGLSLProgramBuilder ()

const GrShaderCaps *	shaderCaps () const

GrSurfaceOrigin	origin () const

const GrPipeline &	pipeline () const

const GrGeometryProcessor &	geometryProcessor () const

bool	snapVerticesToPixelCenters () const

bool	hasPointSize () const

const GrProgramDesc &	desc () const

void	appendUniformDecls (GrShaderFlags visibility, SkString *) const

const char *	samplerVariable (SamplerHandle handle) const

skgpu::Swizzle	samplerSwizzle (SamplerHandle handle) const

const char *	inputSamplerVariable (SamplerHandle handle) const

skgpu::Swizzle	inputSamplerSwizzle (SamplerHandle handle) const

void	addRTFlipUniform (const char *name)

SkString	nameVariable (char prefix, const char *name, bool mangle=true)

bool	emitTextureSamplersForFPs (const GrFragmentProcessor &fp, GrFragmentProcessor::ProgramImpl &impl, int *samplerIndex)

void	advanceStage ()

void	writeFPFunction (const GrFragmentProcessor &fp, GrFragmentProcessor::ProgramImpl &impl)

std::string	invokeFP (const GrFragmentProcessor &fp, const GrFragmentProcessor::ProgramImpl &impl, const char inputColor, const char destColor, const char *coords) const

bool	fragmentProcessorHasCoordsParam (const GrFragmentProcessor *) const

Public Attributes inherited from GrGLSLProgramBuilder
GrGLSLVertexBuilder	fVS

GrGLSLFragmentShaderBuilder	fFS

const GrProgramDesc &	fDesc

const GrProgramInfo &	fProgramInfo

GrGLSLBuiltinUniformHandles	fUniformHandles

std::unique_ptr< GrGeometryProcessor::ProgramImpl >	fGPImpl

std::unique_ptr< GrXferProcessor::ProgramImpl >	fXPImpl

std::vector< std::unique_ptr< GrFragmentProcessor::ProgramImpl > >	fFPImpls

SamplerHandle	fDstTextureSamplerHandle

GrSurfaceOrigin	fDstTextureOrigin

Static Public Attributes inherited from GrGLSLProgramBuilder
static const int	kVarsPerBlock = 8

Protected Member Functions inherited from GrGLSLProgramBuilder
	GrGLSLProgramBuilder (const GrProgramDesc &, const GrProgramInfo &)

void	addFeature (GrShaderFlags shaders, uint32_t featureBit, const char *extensionName)

bool	emitAndInstallProcs ()

void	finalizeShaders ()

bool	fragColorIsInOut () const

Detailed Description

Definition at line 36 of file GrMtlPipelineStateBuilder.h.

Member Function Documentation

◆ caps()

const GrCaps * GrMtlPipelineStateBuilder::caps ( ) const

overrideprivatevirtual

Implements GrGLSLProgramBuilder.

Definition at line 57 of file GrMtlPipelineStateBuilder.mm.

                                                    {
    return fGpu->caps();
}

◆ CreatePipelineState()

GR_NORETAIN_BEGIN GrMtlPipelineState * GrMtlPipelineStateBuilder::CreatePipelineState	(	GrMtlGpu *	gpu,
		const GrProgramDesc &	desc,
		const GrProgramInfo &	programInfo,
		const GrMtlPrecompiledLibraries *	precompiledLibs = `nullptr`
	)

static

Generates a pipeline state.

The returned GrMtlPipelineState implements the supplied GrProgramInfo.

Returns: the created pipeline if generation was successful; nullptr otherwise

Definition at line 36 of file GrMtlPipelineStateBuilder.mm.

                                                          {
    GrAutoLocaleSetter als("C");
    GrMtlPipelineStateBuilder builder(gpu, desc, programInfo);
 
    if (!builder.emitAndInstallProcs()) {
        return nullptr;
    }
    return builder.finalize(desc, programInfo, precompiledLibs);
}

◆ finalizeFragmentSecondaryColor()

void GrMtlPipelineStateBuilder::finalizeFragmentSecondaryColor ( GrShaderVar & outputColor )

overrideprivatevirtual

Reimplemented from GrGLSLProgramBuilder.

Definition at line 61 of file GrMtlPipelineStateBuilder.mm.

                                                                                       {
    outputColor.addLayoutQualifier("location = 0, index = 1");
}

◆ PrecompileShaders()

bool GrMtlPipelineStateBuilder::PrecompileShaders	(	GrMtlGpu *	gpu,
		const SkData &	cachedData,
		GrMtlPrecompiledLibraries *	precompiledLibs
	)

static

Definition at line 710 of file GrMtlPipelineStateBuilder.mm.

                                                                                              {
    SkASSERT(precompiledLibs);
 
    SkReadBuffer reader(cachedData.data(), cachedData.size());
    SkFourByteTag shaderType = GrPersistentCacheUtils::GetType(&reader);
 
    auto errorHandler = gpu->getContext()->priv().getShaderErrorHandler();
 
    SkSL::ProgramSettings settings;
    settings.fSharpenTextures = true;
    GrPersistentCacheUtils::ShaderMetadata meta;
    meta.fSettings = &settings;
 
    std::string shaders[kGrShaderTypeCount];
    SkSL::Program::Interface interfaces[kGrShaderTypeCount];
    if (!GrPersistentCacheUtils::UnpackCachedShaders(
                &reader, shaders, interfaces, kGrShaderTypeCount, &meta)) {
        return false;
    }
 
    // skip the size
    reader.readUInt();
    auto pipelineDescriptor = read_pipeline_data(&reader);
    if (!reader.isValid()) {
        return false;
    }
 
    switch (shaderType) {
        case kMSL_Tag: {
            precompiledLibs->fVertexLibrary =
                    GrCompileMtlShaderLibrary(gpu, shaders[kVertex_GrShaderType], errorHandler);
            precompiledLibs->fFragmentLibrary =
                    GrCompileMtlShaderLibrary(gpu, shaders[kFragment_GrShaderType], errorHandler);
            break;
        }
 
        case kSKSL_Tag: {
            std::string msl[kGrShaderTypeCount];
            if (!skgpu::SkSLToMSL(gpu->caps()->shaderCaps(),
                                  shaders[kVertex_GrShaderType],
                                  SkSL::ProgramKind::kVertex,
                                  settings,
                                  &msl[kVertex_GrShaderType],
                                  &interfaces[kVertex_GrShaderType],
                                  errorHandler)) {
                return false;
            }
            if (!skgpu::SkSLToMSL(gpu->caps()->shaderCaps(),
                                  shaders[kFragment_GrShaderType],
                                  SkSL::ProgramKind::kFragment,
                                  settings,
                                  &msl[kFragment_GrShaderType],
                                  &interfaces[kFragment_GrShaderType],
                                  errorHandler)) {
                return false;
            }
            precompiledLibs->fVertexLibrary =
                    GrCompileMtlShaderLibrary(gpu, msl[kVertex_GrShaderType], errorHandler);
            precompiledLibs->fFragmentLibrary =
                    GrCompileMtlShaderLibrary(gpu, msl[kFragment_GrShaderType], errorHandler);
            break;
        }
 
        default: {
            return false;
        }
    }
 
    pipelineDescriptor.vertexFunction =
            [precompiledLibs->fVertexLibrary newFunctionWithName: @"vertexMain"];
    pipelineDescriptor.fragmentFunction =
            [precompiledLibs->fFragmentLibrary newFunctionWithName: @"fragmentMain"];
 
    {
        TRACE_EVENT0("skia.shaders", "newRenderPipelineStateWithDescriptor");
        MTLNewRenderPipelineStateCompletionHandler completionHandler =
                 ^(id<MTLRenderPipelineState> state, NSError* error) {
                     if (error) {
                         SkDebugf("Error creating pipeline: %s\n",
                                  [[error localizedDescription]
                                           cStringUsingEncoding: NSASCIIStringEncoding]);
                     }
                 };
 
        // kick off asynchronous pipeline build and depend on Apple's cache to manage it
        [gpu->device() newRenderPipelineStateWithDescriptor: pipelineDescriptor
                                          completionHandler: completionHandler];
    }
 
    precompiledLibs->fRTFlip = (interfaces[kFragment_GrShaderType].fRTFlipUniform !=
                                SkSL::Program::Interface::kRTFlip_None);
    return true;
}