#include <GrD3DPipelineStateBuilder.h>

Inheritance diagram for GrD3DPipelineStateBuilder:

Public Member Functions
const GrCaps *	caps () const override

GrD3DGpu *	gpu () const

void	finalizeFragmentSecondaryColor (GrShaderVar &outputColor) override

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

Static Public Member Functions
static std::unique_ptr< GrD3DPipelineState >	MakePipelineState (GrD3DGpu , GrD3DRenderTarget , const GrProgramDesc &, const GrProgramInfo &)

static sk_sp< GrD3DPipeline >	MakeComputePipeline (GrD3DGpu , GrD3DRootSignature , const char *shader)

Private Member Functions
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 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 33 of file GrD3DPipelineStateBuilder.h.

Member Function Documentation

◆ caps()

const GrCaps * GrD3DPipelineStateBuilder::caps ( ) const

overridevirtual

Implements GrGLSLProgramBuilder.

Definition at line 65 of file GrD3DPipelineStateBuilder.cpp.

                                                    {
    return fGpu->caps();
}

◆ finalizeFragmentSecondaryColor()

void GrD3DPipelineStateBuilder::finalizeFragmentSecondaryColor ( GrShaderVar & outputColor )

overridevirtual

Reimplemented from GrGLSLProgramBuilder.

Definition at line 69 of file GrD3DPipelineStateBuilder.cpp.

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

◆ gpu()

GrD3DGpu * GrD3DPipelineStateBuilder::gpu ( ) const

inline

Definition at line 51 of file GrD3DPipelineStateBuilder.h.

51{ return fGpu; }

◆ MakeComputePipeline()

sk_sp< GrD3DPipeline > GrD3DPipelineStateBuilder::MakeComputePipeline	(	GrD3DGpu *	gpu,
		GrD3DRootSignature *	rootSig,
		const char *	shader
	)

static

Definition at line 638 of file GrD3DPipelineStateBuilder.cpp.

                                                                                        {
    D3D12_COMPUTE_PIPELINE_STATE_DESC psoDesc = {};
    psoDesc.pRootSignature = rootSig->rootSignature();
 
    // compile shader
    gr_cp<ID3DBlob> shaderBlob;
    {
        TRACE_EVENT0("skia.shaders", "driver_compile_shader");
        uint32_t compileFlags = 0;
#ifdef SK_DEBUG
        // Enable better shader debugging with the graphics debugging tools.
        compileFlags |= D3DCOMPILE_DEBUG | D3DCOMPILE_SKIP_OPTIMIZATION;
#endif
 
        gr_cp<ID3DBlob> errors;
        HRESULT hr = D3DCompile(shader, strlen(shader), nullptr, nullptr, nullptr, "main",
                                "cs_5_1", compileFlags, 0, &shaderBlob, &errors);
        if (!SUCCEEDED(hr)) {
            gpu->getContext()->priv().getShaderErrorHandler()->compileError(
                shader, reinterpret_cast<char*>(errors->GetBufferPointer()));
            return nullptr;
        }
        psoDesc.CS = { reinterpret_cast<UINT8*>(shaderBlob->GetBufferPointer()),
                       shaderBlob->GetBufferSize() };
    }
 
    // Only used for multi-adapter systems.
    psoDesc.NodeMask = 0;
 
    psoDesc.CachedPSO = { nullptr, 0 };
    psoDesc.Flags = D3D12_PIPELINE_STATE_FLAG_NONE;
 
    gr_cp<ID3D12PipelineState> pipelineState;
    {
        TRACE_EVENT0("skia.shaders", "CreateComputePipelineState");
        GR_D3D_CALL_ERRCHECK(
            gpu->device()->CreateComputePipelineState(&psoDesc, IID_PPV_ARGS(&pipelineState)));
    }
 
    return GrD3DPipeline::Make(std::move(pipelineState));
}

◆ MakePipelineState()

std::unique_ptr< GrD3DPipelineState > GrD3DPipelineStateBuilder::MakePipelineState	(	GrD3DGpu *	gpu,
		GrD3DRenderTarget *	renderTarget,
		const GrProgramDesc &	desc,
		const GrProgramInfo &	programInfo
	)

static

Generates a pipeline state.

The returned GrD3DPipelineState implements the supplied GrProgramInfo.

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

Definition at line 36 of file GrD3DPipelineStateBuilder.cpp.

                                          {
    // ensure that we use "." as a decimal separator when creating SkSL code
    GrAutoLocaleSetter als("C");
 
    // create a builder.  This will be handed off to effects so they can use it to add
    // uniforms, varyings, textures, etc
    GrD3DPipelineStateBuilder builder(gpu, renderTarget, desc, programInfo);
 
    if (!builder.emitAndInstallProcs()) {
        return nullptr;
    }
 
    return builder.finalize();
}