GrD3DPipelineState Class Reference

#include <GrD3DPipelineState.h>

Public Types
using	UniformInfoArray = GrD3DPipelineStateDataManager::UniformInfoArray

Public Member Functions
	GrD3DPipelineState (sk_sp< GrD3DPipeline > pipeline, sk_sp< GrD3DRootSignature > rootSignature, const GrGLSLBuiltinUniformHandles &builtinUniformHandles, const UniformInfoArray &uniforms, uint32_t uniformSize, uint32_t numSamplers, std::unique_ptr< GrGeometryProcessor::ProgramImpl > gpImpl, std::unique_ptr< GrXferProcessor::ProgramImpl > xpImpl, std::vector< std::unique_ptr< GrFragmentProcessor::ProgramImpl > > fpImpls, size_t vertexStride, size_t instanceStride)
const sk_sp< GrD3DPipeline > &	pipeline () const
const sk_sp< GrD3DRootSignature > &	rootSignature () const
void	setAndBindConstants (GrD3DGpu *, const GrRenderTarget *, const GrProgramInfo &)
void	setAndBindTextures (GrD3DGpu *, const GrGeometryProcessor &, const GrSurfaceProxy *const geomProcTextures[], const GrPipeline &)
void	bindBuffers (GrD3DGpu *, sk_sp< const GrBuffer > indexBuffer, sk_sp< const GrBuffer > instanceBuffer, sk_sp< const GrBuffer > vertexBuffer, GrD3DDirectCommandList *commandList)
void	markUniformsDirty ()

Detailed Description

Definition at line 27 of file GrD3DPipelineState.h.

Member Typedef Documentation

UniformInfoArray

using GrD3DPipelineState::UniformInfoArray = GrD3DPipelineStateDataManager::UniformInfoArray

Definition at line 29 of file GrD3DPipelineState.h.

Constructor & Destructor Documentation

GrD3DPipelineState()

GrD3DPipelineState::GrD3DPipelineState	(	sk_sp< GrD3DPipeline >	pipeline,
		sk_sp< GrD3DRootSignature >	rootSignature,
		const GrGLSLBuiltinUniformHandles &	builtinUniformHandles,
		const UniformInfoArray &	uniforms,
		uint32_t	uniformSize,
		uint32_t	numSamplers,
		std::unique_ptr< GrGeometryProcessor::ProgramImpl >	gpImpl,
		std::unique_ptr< GrXferProcessor::ProgramImpl >	xpImpl,
		std::vector< std::unique_ptr< GrFragmentProcessor::ProgramImpl > >	fpImpls,
		size_t	vertexStride,
		size_t	instanceStride
	)

Definition at line 24 of file GrD3DPipelineState.cpp.

        : fPipeline(std::move(pipeline))
        , fRootSignature(std::move(rootSignature))
        , fBuiltinUniformHandles(builtinUniformHandles)
        , fGPImpl(std::move(gpImpl))
        , fXPImpl(std::move(xpImpl))
        , fFPImpls(std::move(fpImpls))
        , fDataManager(uniforms, uniformSize)
        , fNumSamplers(numSamplers)
        , fVertexStride(vertexStride)
        , fInstanceStride(instanceStride) {}

Member Function Documentation

bindBuffers()

void GrD3DPipelineState::bindBuffers	(	GrD3DGpu *	gpu,
		sk_sp< const GrBuffer >	indexBuffer,
		sk_sp< const GrBuffer >	instanceBuffer,
		sk_sp< const GrBuffer >	vertexBuffer,
		GrD3DDirectCommandList *	commandList
	)

Definition at line 154 of file GrD3DPipelineState.cpp.

                                                                          {
    // Here our vertex and instance inputs need to match the same 0-based bindings they were
    // assigned in the PipelineState. That is, vertex first (if any) followed by instance.
    if (vertexBuffer) {
        auto* d3dVertexBuffer = static_cast<const GrD3DBuffer*>(vertexBuffer.get());
        SkASSERT(!d3dVertexBuffer->isCpuBuffer());
        SkASSERT(!d3dVertexBuffer->isMapped());
        const_cast<GrD3DBuffer*>(d3dVertexBuffer)->setResourceState(
                gpu, D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER);
    }
    if (instanceBuffer) {
        auto* d3dInstanceBuffer = static_cast<const GrD3DBuffer*>(instanceBuffer.get());
        SkASSERT(!d3dInstanceBuffer->isCpuBuffer());
        SkASSERT(!d3dInstanceBuffer->isMapped());
        const_cast<GrD3DBuffer*>(d3dInstanceBuffer)->setResourceState(
                gpu, D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER);
    }
    commandList->setVertexBuffers(0, std::move(vertexBuffer), fVertexStride,
                                  std::move(instanceBuffer), fInstanceStride);
 
    if (auto* d3dIndexBuffer = static_cast<const GrD3DBuffer*>(indexBuffer.get())) {
        SkASSERT(!d3dIndexBuffer->isCpuBuffer());
        SkASSERT(!d3dIndexBuffer->isMapped());
        const_cast<GrD3DBuffer*>(d3dIndexBuffer)->setResourceState(
                gpu, D3D12_RESOURCE_STATE_INDEX_BUFFER);
        commandList->setIndexBuffer(std::move(indexBuffer));
    }
}

markUniformsDirty()

void GrD3DPipelineState::markUniformsDirty ( )

inline

Definition at line 60 of file GrD3DPipelineState.h.

{ fDataManager.markDirty(); }

pipeline()

const sk_sp< GrD3DPipeline > & GrD3DPipelineState::pipeline ( ) const

inline

Definition at line 43 of file GrD3DPipelineState.h.

{ return fPipeline; }

rootSignature()

const sk_sp< GrD3DRootSignature > & GrD3DPipelineState::rootSignature ( ) const

inline

Definition at line 44 of file GrD3DPipelineState.h.

{ return fRootSignature; }

setAndBindConstants()

void GrD3DPipelineState::setAndBindConstants	(	GrD3DGpu *	gpu,
		const GrRenderTarget *	renderTarget,
		const GrProgramInfo &	programInfo
	)

Definition at line 47 of file GrD3DPipelineState.cpp.

                                                                               {
    this->setRenderTargetState(renderTarget, programInfo.origin());
 
    fGPImpl->setData(fDataManager, *gpu->caps()->shaderCaps(), programInfo.geomProc());
 
    for (int i = 0; i < programInfo.pipeline().numFragmentProcessors(); ++i) {
        const auto& fp = programInfo.pipeline().getFragmentProcessor(i);
        fp.visitWithImpls([&](const GrFragmentProcessor& fp,
                              GrFragmentProcessor::ProgramImpl& impl) {
            impl.setData(fDataManager, fp);
        }, *fFPImpls[i]);
    }
 
    programInfo.pipeline().setDstTextureUniforms(fDataManager, &fBuiltinUniformHandles);
    fXPImpl->setData(fDataManager, programInfo.pipeline().getXferProcessor());
 
    D3D12_GPU_VIRTUAL_ADDRESS constantsAddress = fDataManager.uploadConstants(gpu);
    gpu->currentCommandList()->setGraphicsRootConstantBufferView(
        (unsigned int)(GrD3DRootSignature::ParamIndex::kConstantBufferView),
        constantsAddress);
}

setAndBindTextures()

void GrD3DPipelineState::setAndBindTextures	(	GrD3DGpu *	gpu,
		const GrGeometryProcessor &	geomProc,
		const GrSurfaceProxy *const	geomProcTextures[],
		const GrPipeline &	pipeline
	)

Definition at line 94 of file GrD3DPipelineState.cpp.

                                                                        {
    SkASSERT(geomProcTextures || !geomProc.numTextureSamplers());
 
    std::vector<D3D12_CPU_DESCRIPTOR_HANDLE> shaderResourceViews(fNumSamplers);
    std::vector<D3D12_CPU_DESCRIPTOR_HANDLE> samplers(fNumSamplers);
    unsigned int currTextureBinding = 0;
 
    for (int i = 0; i < geomProc.numTextureSamplers(); ++i) {
        SkASSERT(geomProcTextures[i]->asTextureProxy());
        const auto& sampler = geomProc.textureSampler(i);
        auto texture = static_cast<GrD3DTexture*>(geomProcTextures[i]->peekTexture());
        shaderResourceViews[currTextureBinding] = texture->shaderResourceView();
        samplers[currTextureBinding++] =
                gpu->resourceProvider().findOrCreateCompatibleSampler(sampler.samplerState());
        gpu->currentCommandList()->addSampledTextureRef(texture);
    }
 
    if (GrTexture* dstTexture = pipeline.peekDstTexture()) {
        auto texture = static_cast<GrD3DTexture*>(dstTexture);
        shaderResourceViews[currTextureBinding] = texture->shaderResourceView();
        samplers[currTextureBinding++] = gpu->resourceProvider().findOrCreateCompatibleSampler(
                                               GrSamplerState::Filter::kNearest);
        gpu->currentCommandList()->addSampledTextureRef(texture);
    }
 
    pipeline.visitTextureEffects([&](const GrTextureEffect& te) {
        GrSamplerState samplerState = te.samplerState();
        auto* texture = static_cast<GrD3DTexture*>(te.texture());
        shaderResourceViews[currTextureBinding] = texture->shaderResourceView();
        samplers[currTextureBinding++] =
                gpu->resourceProvider().findOrCreateCompatibleSampler(samplerState);
        gpu->currentCommandList()->addSampledTextureRef(texture);
    });
 
    SkASSERT(fNumSamplers == currTextureBinding);
 
    // fill in descriptor tables and bind to root signature
    if (fNumSamplers > 0) {
        // set up descriptor tables and bind heaps
        sk_sp<GrD3DDescriptorTable> srvTable =
                gpu->resourceProvider().findOrCreateShaderViewTable(shaderResourceViews);
        sk_sp<GrD3DDescriptorTable> samplerTable =
            gpu->resourceProvider().findOrCreateSamplerTable(samplers);
        gpu->currentCommandList()->setDescriptorHeaps(srvTable->heap(), samplerTable->heap());
 
        // bind shader resource view table
        gpu->currentCommandList()->setGraphicsRootDescriptorTable(
                (unsigned int)GrD3DRootSignature::ParamIndex::kShaderViewDescriptorTable,
                srvTable->baseGpuDescriptor());
 
        // bind sampler table
        gpu->currentCommandList()->setGraphicsRootDescriptorTable(
                (unsigned int)GrD3DRootSignature::ParamIndex::kSamplerDescriptorTable,
                samplerTable->baseGpuDescriptor());
    }
}

---

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

• third_party/skia/src/gpu/ganesh/d3d/GrD3DPipelineState.h
• third_party/skia/src/gpu/ganesh/d3d/GrD3DPipelineState.cpp