GrD3DResourceProvider Class Reference

#include <GrD3DResourceProvider.h>

Public Member Functions
	GrD3DResourceProvider (GrD3DGpu *)
void	destroyResources ()
std::unique_ptr< GrD3DDirectCommandList >	findOrCreateDirectCommandList ()
void	recycleDirectCommandList (std::unique_ptr< GrD3DDirectCommandList >)
sk_sp< GrD3DRootSignature >	findOrCreateRootSignature (int numTextureSamplers, int numUAVs=0)
sk_sp< GrD3DCommandSignature >	findOrCreateCommandSignature (GrD3DCommandSignature::ForIndexed, unsigned int slot)
GrD3DDescriptorHeap::CPUHandle	createRenderTargetView (ID3D12Resource *textureResource)
void	recycleRenderTargetView (const GrD3DDescriptorHeap::CPUHandle &)
GrD3DDescriptorHeap::CPUHandle	createDepthStencilView (ID3D12Resource *textureResource)
void	recycleDepthStencilView (const GrD3DDescriptorHeap::CPUHandle &)
GrD3DDescriptorHeap::CPUHandle	createConstantBufferView (ID3D12Resource *bufferResource, size_t offset, size_t size)
GrD3DDescriptorHeap::CPUHandle	createShaderResourceView (ID3D12Resource *resource, unsigned int mostDetailedMip=0, unsigned int mipLevels=-1)
GrD3DDescriptorHeap::CPUHandle	createUnorderedAccessView (ID3D12Resource *resource, unsigned int mipSlice)
void	recycleShaderView (const GrD3DDescriptorHeap::CPUHandle &)
D3D12_CPU_DESCRIPTOR_HANDLE	findOrCreateCompatibleSampler (const GrSamplerState &params)
sk_sp< GrD3DDescriptorTable >	findOrCreateShaderViewTable (const std::vector< D3D12_CPU_DESCRIPTOR_HANDLE > &shaderViews)
sk_sp< GrD3DDescriptorTable >	findOrCreateSamplerTable (const std::vector< D3D12_CPU_DESCRIPTOR_HANDLE > &samplers)
GrD3DDescriptorTableManager *	descriptorTableMgr ()
GrD3DPipelineState *	findOrCreateCompatiblePipelineState (GrD3DRenderTarget *, const GrProgramInfo &)
sk_sp< GrD3DPipeline >	findOrCreateMipmapPipeline ()
D3D12_GPU_VIRTUAL_ADDRESS	uploadConstantData (void *data, size_t size)
void	prepForSubmit ()
void	markPipelineStateUniformsDirty ()

Detailed Description

Definition at line 34 of file GrD3DResourceProvider.h.

Constructor & Destructor Documentation

GrD3DResourceProvider()

GrD3DResourceProvider::GrD3DResourceProvider

(

GrD3DGpu *

gpu

)

Definition at line 20 of file GrD3DResourceProvider.cpp.

        : fGpu(gpu)
        , fCpuDescriptorManager(gpu)
        , fDescriptorTableManager(gpu)
        , fPipelineStateCache(new PipelineStateCache(gpu))
        , fShaderResourceDescriptorTableCache(gpu)
        , fSamplerDescriptorTableCache(gpu) {
}

Member Function Documentation

createConstantBufferView()

GrD3DDescriptorHeap::CPUHandle GrD3DResourceProvider::createConstantBufferView	(	ID3D12Resource *	bufferResource,
		size_t	offset,
		size_t	size
	)

Definition at line 103 of file GrD3DResourceProvider.cpp.

                                                                    {
    return fCpuDescriptorManager.createConstantBufferView(fGpu, bufferResource, offset, size);
}

createDepthStencilView()

GrD3DDescriptorHeap::CPUHandle GrD3DResourceProvider::createDepthStencilView

(

ID3D12Resource *

textureResource

)

Definition at line 93 of file GrD3DResourceProvider.cpp.

                                         {
    return fCpuDescriptorManager.createDepthStencilView(fGpu, textureResource);
}

createRenderTargetView()

GrD3DDescriptorHeap::CPUHandle GrD3DResourceProvider::createRenderTargetView

(

ID3D12Resource *

textureResource

)

Definition at line 83 of file GrD3DResourceProvider.cpp.

                                         {
    return fCpuDescriptorManager.createRenderTargetView(fGpu, textureResource);
}

createShaderResourceView()

GrD3DDescriptorHeap::CPUHandle GrD3DResourceProvider::createShaderResourceView	(	ID3D12Resource *	resource,
		unsigned int	mostDetailedMip = 0,
		unsigned int	mipLevels = -1
	)

Definition at line 108 of file GrD3DResourceProvider.cpp.

                                                                                   {
    return fCpuDescriptorManager.createShaderResourceView(fGpu, resource, highestMip, mipLevels);
}

createUnorderedAccessView()

GrD3DDescriptorHeap::CPUHandle GrD3DResourceProvider::createUnorderedAccessView	(	ID3D12Resource *	resource,
		unsigned int	mipSlice
	)

Definition at line 113 of file GrD3DResourceProvider.cpp.

                                                         {
    return fCpuDescriptorManager.createUnorderedAccessView(fGpu, resource, mipSlice);
}

descriptorTableMgr()

GrD3DDescriptorTableManager * GrD3DResourceProvider::descriptorTableMgr ( )

inline

Definition at line 72 of file GrD3DResourceProvider.h.

                                                      {
        return &fDescriptorTableManager;
    }

destroyResources()

void GrD3DResourceProvider::destroyResources

(

)

Definition at line 29 of file GrD3DResourceProvider.cpp.

                                             {
    fSamplers.reset();
 
    fPipelineStateCache->release();
}

findOrCreateCommandSignature()

sk_sp< GrD3DCommandSignature > GrD3DResourceProvider::findOrCreateCommandSignature	(	GrD3DCommandSignature::ForIndexed	indexed,
		unsigned int	slot
	)

Definition at line 67 of file GrD3DResourceProvider.cpp.

                                                                    {
    for (int i = 0; i < fCommandSignatures.size(); ++i) {
        if (fCommandSignatures[i]->isCompatible(indexed, slot)) {
            return fCommandSignatures[i];
        }
    }
 
    auto commandSig = GrD3DCommandSignature::Make(fGpu, indexed, slot);
    if (!commandSig) {
        return nullptr;
    }
    fCommandSignatures.push_back(commandSig);
    return commandSig;
}

findOrCreateCompatiblePipelineState()

GrD3DPipelineState * GrD3DResourceProvider::findOrCreateCompatiblePipelineState	(	GrD3DRenderTarget *	rt,
		const GrProgramInfo &	info
	)

Definition at line 201 of file GrD3DResourceProvider.cpp.

                                                          {
    return fPipelineStateCache->refPipelineState(rt, info);
}

findOrCreateCompatibleSampler()

D3D12_CPU_DESCRIPTOR_HANDLE GrD3DResourceProvider::findOrCreateCompatibleSampler

(

const GrSamplerState &

params

)

Definition at line 160 of file GrD3DResourceProvider.cpp.

                                      {
    // In D3D anisotropic filtering uses the same field (D3D12_SAMPLER_DESC::Filter) as min/mag/mip
    // settings and so is not orthogonal to them.
    uint32_t key = params.asKey(/*anisoIsOrthogonal=*/false);
    D3D12_CPU_DESCRIPTOR_HANDLE* samplerPtr = fSamplers.find(key);
    if (samplerPtr) {
        return *samplerPtr;
    }
 
    D3D12_FILTER filter = d3d_filter(params);
    // We disable MIP filtering using maxLOD. Otherwise, we want the max LOD to be unbounded.
    float maxLOD =
            params.mipmapped() == skgpu::Mipmapped::kYes ? std::numeric_limits<float>::max() : 0.f;
    D3D12_TEXTURE_ADDRESS_MODE addressModeU = wrap_mode_to_d3d_address_mode(params.wrapModeX());
    D3D12_TEXTURE_ADDRESS_MODE addressModeV = wrap_mode_to_d3d_address_mode(params.wrapModeY());
    unsigned int maxAnisotropy = params.maxAniso();
    D3D12_CPU_DESCRIPTOR_HANDLE sampler =
            fCpuDescriptorManager.createSampler(
            fGpu, filter, maxLOD, maxAnisotropy, addressModeU, addressModeV).fHandle;
    fSamplers.set(key, sampler);
    return sampler;
}

findOrCreateDirectCommandList()

std::unique_ptr< GrD3DDirectCommandList > GrD3DResourceProvider::findOrCreateDirectCommandList

(

)

Definition at line 35 of file GrD3DResourceProvider.cpp.

                                                                                           {
    if (fAvailableDirectCommandLists.size()) {
        std::unique_ptr<GrD3DDirectCommandList> list =
                std::move(fAvailableDirectCommandLists.back());
        fAvailableDirectCommandLists.pop_back();
        return list;
    }
    return GrD3DDirectCommandList::Make(fGpu);
}

findOrCreateMipmapPipeline()

sk_sp< GrD3DPipeline > GrD3DResourceProvider::findOrCreateMipmapPipeline

(

)

Definition at line 206 of file GrD3DResourceProvider.cpp.

                                                                       {
    if (!fMipmapPipeline) {
        // Note: filtering for non-even widths and heights samples at the 0.25 and 0.75
        // locations and averages the result. As the initial samples are bilerped this is
        // approximately a triangle filter. We should look into doing a better kernel but
        // this should hold us for now.
        const char* shader =
            "SamplerState textureSampler : register(s0, space1);\n"
            "Texture2D<float4> inputTexture : register(t1, space1);\n"
            "RWTexture2D<float4> outUAV : register(u2, space1);\n"
            "\n"
            "cbuffer UniformBuffer : register(b0, space0) {\n"
            "    float2 inverseDims;\n"
            "    uint mipLevel;\n"
            "    uint sampleMode;\n"
            "}\n"
            "\n"
            "[numthreads(8, 8, 1)]\n"
            "void main(uint groupIndex : SV_GroupIndex, uint3 threadID : SV_DispatchThreadID) {\n"
            "    float2 uv = inverseDims * (threadID.xy + 0.5);\n"
            "    float4 mipVal;\n"
            "    switch (sampleMode) {\n"
            "        case 0: {\n"
            "            mipVal = inputTexture.SampleLevel(textureSampler, uv, mipLevel);\n"
            "            break;\n"
            "        }\n"
            "        case 1: {\n"
            "            float2 uvdiff = inverseDims * 0.25;\n"
            "            mipVal = inputTexture.SampleLevel(textureSampler, uv-uvdiff, mipLevel);\n"
            "            mipVal += inputTexture.SampleLevel(textureSampler, uv+uvdiff, mipLevel);\n"
            "            uvdiff.y = -uvdiff.y;\n"
            "            mipVal += inputTexture.SampleLevel(textureSampler, uv-uvdiff, mipLevel);\n"
            "            mipVal += inputTexture.SampleLevel(textureSampler, uv+uvdiff, mipLevel);\n"
            "            mipVal *= 0.25;\n"
            "            break;\n"
            "        }\n"
            "        case 2: {\n"
            "            float2 uvdiff = float2(inverseDims.x * 0.25, 0);\n"
            "            mipVal = inputTexture.SampleLevel(textureSampler, uv-uvdiff, mipLevel);\n"
            "            mipVal += inputTexture.SampleLevel(textureSampler, uv+uvdiff, mipLevel);\n"
            "            mipVal *= 0.5;\n"
            "            break;\n"
            "        }\n"
            "        case 3: {\n"
            "            float2 uvdiff = float2(0, inverseDims.y * 0.25);\n"
            "            mipVal = inputTexture.SampleLevel(textureSampler, uv-uvdiff, mipLevel);\n"
            "            mipVal += inputTexture.SampleLevel(textureSampler, uv+uvdiff, mipLevel);\n"
            "            mipVal *= 0.5;\n"
            "            break;\n"
            "        }\n"
            "    }\n"
            "\n"
            "    outUAV[threadID.xy] = mipVal;\n"
            "}\n";
 
        sk_sp<GrD3DRootSignature> rootSig = this->findOrCreateRootSignature(1, 1);
 
        fMipmapPipeline =
                GrD3DPipelineStateBuilder::MakeComputePipeline(fGpu, rootSig.get(), shader);
    }
 
    return fMipmapPipeline;
}

findOrCreateRootSignature()

sk_sp< GrD3DRootSignature > GrD3DResourceProvider::findOrCreateRootSignature	(	int	numTextureSamplers,
		int	numUAVs = 0
	)

Definition at line 51 of file GrD3DResourceProvider.cpp.

                                                                                        {
    for (int i = 0; i < fRootSignatures.size(); ++i) {
        if (fRootSignatures[i]->isCompatible(numTextureSamplers, numUAVs)) {
            return fRootSignatures[i];
        }
    }
 
    auto rootSig = GrD3DRootSignature::Make(fGpu, numTextureSamplers, numUAVs);
    if (!rootSig) {
        return nullptr;
    }
    fRootSignatures.push_back(rootSig);
    return rootSig;
}

findOrCreateSamplerTable()

sk_sp< GrD3DDescriptorTable > GrD3DResourceProvider::findOrCreateSamplerTable

(

const std::vector< D3D12_CPU_DESCRIPTOR_HANDLE > &

samplers

)

Definition at line 193 of file GrD3DResourceProvider.cpp.

                                                                {
    auto createFunc = [this](GrD3DGpu* gpu, unsigned int numDesc) {
        return this->fDescriptorTableManager.createSamplerTable(gpu, numDesc);
    };
    return fShaderResourceDescriptorTableCache.findOrCreateDescTable(samplers, createFunc);
}

findOrCreateShaderViewTable()

sk_sp< GrD3DDescriptorTable > GrD3DResourceProvider::findOrCreateShaderViewTable

(

const std::vector< D3D12_CPU_DESCRIPTOR_HANDLE > &

shaderViews

)

Definition at line 184 of file GrD3DResourceProvider.cpp.

                                                               {
 
    auto createFunc = [this](GrD3DGpu* gpu, unsigned int numDesc) {
        return this->fDescriptorTableManager.createShaderViewTable(gpu, numDesc);
    };
    return fShaderResourceDescriptorTableCache.findOrCreateDescTable(shaderViews, createFunc);
}

markPipelineStateUniformsDirty()

void GrD3DResourceProvider::markPipelineStateUniformsDirty ( )

inline

Definition at line 84 of file GrD3DResourceProvider.h.

{ fPipelineStateCache->markPipelineStateUniformsDirty(); }

prepForSubmit()

void GrD3DResourceProvider::prepForSubmit

(

)

Definition at line 286 of file GrD3DResourceProvider.cpp.

                                          {
    fDescriptorTableManager.prepForSubmit(fGpu);
    // Any heap memory used for these will be returned when the command buffer finishes,
    // so we have to invalidate all entries.
    fShaderResourceDescriptorTableCache.release();
    fSamplerDescriptorTableCache.release();
}

recycleDepthStencilView()

void GrD3DResourceProvider::recycleDepthStencilView

(

const GrD3DDescriptorHeap::CPUHandle &

dsvDescriptor

)

Definition at line 98 of file GrD3DResourceProvider.cpp.

                                                           {
    fCpuDescriptorManager.recycleDepthStencilView(dsvDescriptor);
}

recycleDirectCommandList()

void GrD3DResourceProvider::recycleDirectCommandList

(

std::unique_ptr< GrD3DDirectCommandList >

commandList

)

Definition at line 45 of file GrD3DResourceProvider.cpp.

                                                           {
    commandList->reset();
    fAvailableDirectCommandLists.push_back(std::move(commandList));
}

recycleRenderTargetView()

void GrD3DResourceProvider::recycleRenderTargetView

(

const GrD3DDescriptorHeap::CPUHandle &

rtvDescriptor

)

Definition at line 88 of file GrD3DResourceProvider.cpp.

                                                           {
    fCpuDescriptorManager.recycleRenderTargetView(rtvDescriptor);
}

recycleShaderView()

void GrD3DResourceProvider::recycleShaderView

(

const GrD3DDescriptorHeap::CPUHandle &

view

)

Definition at line 118 of file GrD3DResourceProvider.cpp.

                                                  {
    fCpuDescriptorManager.recycleShaderView(view);
}

uploadConstantData()

D3D12_GPU_VIRTUAL_ADDRESS GrD3DResourceProvider::uploadConstantData	(	void *	data,
		size_t	size
	)

Definition at line 270 of file GrD3DResourceProvider.cpp.

                                                                                           {
    // constant size has to be aligned to 256
    constexpr int kConstantAlignment = 256;
 
    // upload the data
    size_t paddedSize = SkAlignTo(size, kConstantAlignment);
    GrRingBuffer::Slice slice = fGpu->uniformsRingBuffer()->suballocate(paddedSize);
    char* destPtr = static_cast<char*>(slice.fBuffer->map()) + slice.fOffset;
    memcpy(destPtr, data, size);
 
    // create the associated constant buffer view descriptor
    GrD3DBuffer* d3dBuffer = static_cast<GrD3DBuffer*>(slice.fBuffer);
    D3D12_GPU_VIRTUAL_ADDRESS gpuAddress = d3dBuffer->d3dResource()->GetGPUVirtualAddress();
    return gpuAddress + slice.fOffset;
}

---

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

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