skgpu::graphite::DawnResourceProvider Class Reference

#include <DawnResourceProvider.h>

Inheritance diagram for skgpu::graphite::DawnResourceProvider:

Public Member Functions
	DawnResourceProvider (SharedContext *sharedContext, SingleOwner *, uint32_t recorderID, size_t resourceBudget)
	~DawnResourceProvider () override
sk_sp< DawnTexture >	findOrCreateDiscardableMSAALoadTexture (SkISize dimensions, const TextureInfo &msaaInfo)
wgpu::RenderPipeline	findOrCreateBlitWithDrawPipeline (const RenderPassDesc &renderPassDesc)
sk_sp< DawnBuffer >	findOrCreateDawnBuffer (size_t size, BufferType type, AccessPattern, std::string_view label)
const wgpu::BindGroupLayout &	getOrCreateUniformBuffersBindGroupLayout ()
const wgpu::BindGroupLayout &	getOrCreateSingleTextureSamplerBindGroupLayout ()
const wgpu::BindGroup &	findOrCreateUniformBuffersBindGroup (const std::array< std::pair< const DawnBuffer *, uint32_t >, 4 > &boundBuffersAndSizes)
const wgpu::BindGroup &	findOrCreateSingleTextureSamplerBindGroup (const DawnSampler *sampler, const DawnTexture *texture)
const sk_sp< DawnBuffer > &	getOrCreateIntrinsicConstantBuffer ()
Public Member Functions inherited from skgpu::graphite::ResourceProvider
virtual	~ResourceProvider ()
sk_sp< GraphicsPipeline >	findOrCreateGraphicsPipeline (const RuntimeEffectDictionary *, const GraphicsPipelineDesc &, const RenderPassDesc &)
sk_sp< ComputePipeline >	findOrCreateComputePipeline (const ComputePipelineDesc &)
sk_sp< Texture >	findOrCreateScratchTexture (SkISize, const TextureInfo &, std::string_view label, skgpu::Budgeted)
sk_sp< Texture >	createWrappedTexture (const BackendTexture &, std::string_view label)
sk_sp< Texture >	findOrCreateDepthStencilAttachment (SkISize dimensions, const TextureInfo &)
sk_sp< Texture >	findOrCreateDiscardableMSAAAttachment (SkISize dimensions, const TextureInfo &)
sk_sp< Buffer >	findOrCreateBuffer (size_t size, BufferType type, AccessPattern, std::string_view label)
sk_sp< Sampler >	findOrCreateCompatibleSampler (const SamplerDesc &)
BackendTexture	createBackendTexture (SkISize dimensions, const TextureInfo &)
void	deleteBackendTexture (const BackendTexture &)
ProxyCache *	proxyCache ()
size_t	getResourceCacheLimit () const
size_t	getResourceCacheCurrentBudgetedBytes () const
void	dumpMemoryStatistics (SkTraceMemoryDump *traceMemoryDump) const
void	freeGpuResources ()
void	purgeResourcesNotUsedSince (StdSteadyClock::time_point purgeTime)

Additional Inherited Members
Protected Member Functions inherited from skgpu::graphite::ResourceProvider
	ResourceProvider (SharedContext *sharedContext, SingleOwner *singleOwner, uint32_t recorderID, size_t resourceBudget)
Protected Attributes inherited from skgpu::graphite::ResourceProvider
SharedContext *	fSharedContext
sk_sp< ResourceCache >	fResourceCache

Detailed Description

Definition at line 24 of file DawnResourceProvider.h.

Constructor & Destructor Documentation

DawnResourceProvider()

skgpu::graphite::DawnResourceProvider::DawnResourceProvider	(	SharedContext *	sharedContext,
		SingleOwner *	singleOwner,
		uint32_t	recorderID,
		size_t	resourceBudget
	)

Definition at line 152 of file DawnResourceProvider.cpp.

        : ResourceProvider(sharedContext, singleOwner, recorderID, resourceBudget)
        , fUniformBufferBindGroupCache(kMaxNumberOfCachedBufferBindGroups)
        , fSingleTextureSamplerBindGroups(kMaxNumberOfCachedTextureBindGroups) {}

~DawnResourceProvider()

skgpu::graphite::DawnResourceProvider::~DawnResourceProvider ( )

overridedefault

Member Function Documentation

findOrCreateBlitWithDrawPipeline()

wgpu::RenderPipeline skgpu::graphite::DawnResourceProvider::findOrCreateBlitWithDrawPipeline

(

const RenderPassDesc &

renderPassDesc

)

Definition at line 162 of file DawnResourceProvider.cpp.

                                              {
    uint64_t renderPassKey =
            this->dawnSharedContext()->dawnCaps()->getRenderPassDescKeyForPipeline(renderPassDesc);
    wgpu::RenderPipeline pipeline = fBlitWithDrawPipelines[renderPassKey];
    if (!pipeline) {
        static constexpr char kVertexShaderText[] = R"(
            var<private> fullscreenTriPositions : array<vec2<f32>, 3> = array<vec2<f32>, 3>(
                vec2(-1.0, -1.0), vec2(-1.0, 3.0), vec2(3.0, -1.0));
 
            @vertex
            fn main(@builtin(vertex_index) vertexIndex : u32) -> @builtin(position) vec4<f32> {
                return vec4(fullscreenTriPositions[vertexIndex], 1.0, 1.0);
            }
        )";
 
        static constexpr char kFragmentShaderText[] = R"(
            @group(0) @binding(0) var colorMap: texture_2d<f32>;
 
            @fragment
            fn main(@builtin(position) fragPosition : vec4<f32>) -> @location(0) vec4<f32> {
                var coords : vec2<i32> = vec2<i32>(i32(fragPosition.x), i32(fragPosition.y));
                return textureLoad(colorMap, coords, 0);
            }
        )";
 
        auto vsModule = create_shader_module(dawnSharedContext()->device(), kVertexShaderText);
        auto fsModule = create_shader_module(dawnSharedContext()->device(), kFragmentShaderText);
 
        pipeline = create_blit_render_pipeline(
                dawnSharedContext(),
                /*label=*/"BlitWithDraw",
                std::move(vsModule),
                std::move(fsModule),
                /*renderPassColorFormat=*/
                renderPassDesc.fColorAttachment.fTextureInfo.dawnTextureSpec().getViewFormat(),
                /*renderPassDepthStencilFormat=*/
                renderPassDesc.fDepthStencilAttachment.fTextureInfo.isValid()
                        ? renderPassDesc.fDepthStencilAttachment.fTextureInfo.dawnTextureSpec()
                                  .getViewFormat()
                        : wgpu::TextureFormat::Undefined,
                /*numSamples=*/renderPassDesc.fColorAttachment.fTextureInfo.numSamples());
 
        if (pipeline) {
            fBlitWithDrawPipelines.set(renderPassKey, pipeline);
        }
    }
 
    return pipeline;
}

findOrCreateDawnBuffer()

sk_sp< DawnBuffer > skgpu::graphite::DawnResourceProvider::findOrCreateDawnBuffer	(	size_t	size,
		BufferType	type,
		AccessPattern	accessPattern,
		std::string_view	label
	)

Definition at line 332 of file DawnResourceProvider.cpp.

                                                                                     {
    sk_sp<Buffer> buffer = this->findOrCreateBuffer(size, type, accessPattern, std::move(label));
    DawnBuffer* ptr = static_cast<DawnBuffer*>(buffer.release());
    return sk_sp<DawnBuffer>(ptr);
}

findOrCreateDiscardableMSAALoadTexture()

sk_sp< DawnTexture > skgpu::graphite::DawnResourceProvider::findOrCreateDiscardableMSAALoadTexture	(	SkISize	dimensions,
		const TextureInfo &	msaaInfo
	)

Definition at line 236 of file DawnResourceProvider.cpp.

                                                         {
    SkASSERT(msaaInfo.isValid());
 
    // Derive the load texture's info from MSAA texture's info.
    DawnTextureInfo dawnMsaaLoadTextureInfo;
    msaaInfo.getDawnTextureInfo(&dawnMsaaLoadTextureInfo);
    dawnMsaaLoadTextureInfo.fSampleCount = 1;
    dawnMsaaLoadTextureInfo.fUsage |= wgpu::TextureUsage::TextureBinding;
 
#if !defined(__EMSCRIPTEN__)
    // MSAA texture can be transient attachment (memoryless) but the load texture cannot be.
    // This is because the load texture will need to have its content retained between two passes
    // loading:
    // - first pass: the resolve texture is blitted to the load texture.
    // - 2nd pass: the actual render pass is started and the load texture is blitted to the MSAA
    // texture.
    dawnMsaaLoadTextureInfo.fUsage &= (~wgpu::TextureUsage::TransientAttachment);
#endif
 
    auto texture = this->findOrCreateDiscardableMSAAAttachment(dimensions, dawnMsaaLoadTextureInfo);
 
    return sk_sp<DawnTexture>(static_cast<DawnTexture*>(texture.release()));
}

findOrCreateSingleTextureSamplerBindGroup()

const wgpu::BindGroup & skgpu::graphite::DawnResourceProvider::findOrCreateSingleTextureSamplerBindGroup	(	const DawnSampler *	sampler,
		const DawnTexture *	texture
	)

Definition at line 499 of file DawnResourceProvider.cpp.

                                                                {
    auto key = make_texture_bind_group_key(sampler, texture);
    auto* existingBindGroup = fSingleTextureSamplerBindGroups.find(key);
    if (existingBindGroup) {
        // cache hit.
        return *existingBindGroup;
    }
 
    std::array<wgpu::BindGroupEntry, 2> entries;
 
    entries[0].binding = 0;
    entries[0].sampler = sampler->dawnSampler();
    entries[1].binding = 1;
    entries[1].textureView = texture->sampleTextureView();
 
    wgpu::BindGroupDescriptor desc;
    desc.layout = getOrCreateSingleTextureSamplerBindGroupLayout();
    desc.entryCount = entries.size();
    desc.entries = entries.data();
 
    const auto& device = this->dawnSharedContext()->device();
    auto bindGroup = device.CreateBindGroup(&desc);
 
    return *fSingleTextureSamplerBindGroups.insert(key, bindGroup);
}

findOrCreateUniformBuffersBindGroup()

const wgpu::BindGroup & skgpu::graphite::DawnResourceProvider::findOrCreateUniformBuffersBindGroup

(

const std::array< std::pair< const DawnBuffer *, uint32_t >, 4 > &

boundBuffersAndSizes

)

Definition at line 454 of file DawnResourceProvider.cpp.

                                                                                       {
    auto key = make_ubo_bind_group_key(boundBuffersAndSizes);
    auto* existingBindGroup = fUniformBufferBindGroupCache.find(key);
    if (existingBindGroup) {
        // cache hit.
        return *existingBindGroup;
    }
 
    // Translate to wgpu::BindGroupDescriptor
    std::array<wgpu::BindGroupEntry, 4> entries;
 
    constexpr uint32_t kBindingIndices[] = {
        DawnGraphicsPipeline::kIntrinsicUniformBufferIndex,
        DawnGraphicsPipeline::kRenderStepUniformBufferIndex,
        DawnGraphicsPipeline::kPaintUniformBufferIndex,
        DawnGraphicsPipeline::kGradientBufferIndex,
    };
 
    for (uint32_t i = 0; i < boundBuffersAndSizes.size(); ++i) {
        const DawnBuffer* boundBuffer = boundBuffersAndSizes[i].first;
        const uint32_t bindingSize = boundBuffersAndSizes[i].second;
 
        entries[i].binding = kBindingIndices[i];
        entries[i].offset = 0;
        if (boundBuffer) {
            entries[i].buffer = boundBuffer->dawnBuffer();
            entries[i].size = SkAlignTo(bindingSize, kBufferBindingSizeAlignment);
        } else {
            entries[i].buffer = this->getOrCreateNullBuffer();
            entries[i].size = wgpu::kWholeSize;
        }
    }
 
    wgpu::BindGroupDescriptor desc;
    desc.layout = this->getOrCreateUniformBuffersBindGroupLayout();
    desc.entryCount = entries.size();
    desc.entries = entries.data();
 
    const auto& device = this->dawnSharedContext()->device();
    auto bindGroup = device.CreateBindGroup(&desc);
 
    return *fUniformBufferBindGroupCache.insert(key, bindGroup);
}

getOrCreateIntrinsicConstantBuffer()

const sk_sp< DawnBuffer > & skgpu::graphite::DawnResourceProvider::getOrCreateIntrinsicConstantBuffer

(

)

Definition at line 442 of file DawnResourceProvider.cpp.

                                                                                  {
    if (!fIntrinsicConstantBuffer) {
        fIntrinsicConstantBuffer = findOrCreateDawnBuffer(sizeof(float[4]),
                                                          BufferType::kUniform,
                                                          AccessPattern::kGpuOnly,
                                                          "IntrinsicConstantBuffer");
        SkASSERT(fIntrinsicConstantBuffer);
    }
 
    return fIntrinsicConstantBuffer;
}

getOrCreateSingleTextureSamplerBindGroupLayout()

const wgpu::BindGroupLayout & skgpu::graphite::DawnResourceProvider::getOrCreateSingleTextureSamplerBindGroupLayout

(

)

Definition at line 394 of file DawnResourceProvider.cpp.

                                                                     {
    if (fSingleTextureSamplerBindGroupLayout) {
        return fSingleTextureSamplerBindGroupLayout;
    }
 
    std::array<wgpu::BindGroupLayoutEntry, 2> entries;
 
    entries[0].binding = 0;
    entries[0].visibility = wgpu::ShaderStage::Fragment;
    entries[0].sampler.type = wgpu::SamplerBindingType::Filtering;
 
    entries[1].binding = 1;
    entries[1].visibility = wgpu::ShaderStage::Fragment;
    entries[1].texture.sampleType = wgpu::TextureSampleType::Float;
    entries[1].texture.viewDimension = wgpu::TextureViewDimension::e2D;
    entries[1].texture.multisampled = false;
 
    wgpu::BindGroupLayoutDescriptor groupLayoutDesc;
    if (fSharedContext->caps()->setBackendLabels()) {
        groupLayoutDesc.label = "Single texture + sampler bind group layout";
    }
 
    groupLayoutDesc.entryCount = entries.size();
    groupLayoutDesc.entries = entries.data();
    fSingleTextureSamplerBindGroupLayout =
            this->dawnSharedContext()->device().CreateBindGroupLayout(&groupLayoutDesc);
 
    return fSingleTextureSamplerBindGroupLayout;
}

getOrCreateUniformBuffersBindGroupLayout()

const wgpu::BindGroupLayout & skgpu::graphite::DawnResourceProvider::getOrCreateUniformBuffersBindGroupLayout

(

)

Definition at line 341 of file DawnResourceProvider.cpp.

                                                                                          {
    if (fUniformBuffersBindGroupLayout) {
        return fUniformBuffersBindGroupLayout;
    }
 
    std::array<wgpu::BindGroupLayoutEntry, 4> entries;
    entries[0].binding = DawnGraphicsPipeline::kIntrinsicUniformBufferIndex;
    entries[0].visibility = wgpu::ShaderStage::Vertex | wgpu::ShaderStage::Fragment;
    entries[0].buffer.type = wgpu::BufferBindingType::Uniform;
    entries[0].buffer.hasDynamicOffset = true;
    entries[0].buffer.minBindingSize = 0;
 
    entries[1].binding = DawnGraphicsPipeline::kRenderStepUniformBufferIndex;
    entries[1].visibility = wgpu::ShaderStage::Vertex | wgpu::ShaderStage::Fragment;
    entries[1].buffer.type = fSharedContext->caps()->storageBufferPreferred()
                                     ? wgpu::BufferBindingType::ReadOnlyStorage
                                     : wgpu::BufferBindingType::Uniform;
    entries[1].buffer.hasDynamicOffset = true;
    entries[1].buffer.minBindingSize = 0;
 
    entries[2].binding = DawnGraphicsPipeline::kPaintUniformBufferIndex;
    entries[2].visibility = wgpu::ShaderStage::Fragment;
    entries[2].buffer.type = fSharedContext->caps()->storageBufferPreferred()
                                     ? wgpu::BufferBindingType::ReadOnlyStorage
                                     : wgpu::BufferBindingType::Uniform;
    entries[2].buffer.hasDynamicOffset = true;
    entries[2].buffer.minBindingSize = 0;
 
    // Gradient buffer will only be used when storage buffers are preferred, else large
    // gradients use a texture fallback, set binding type as a uniform when not in use to
    // satisfy any binding type restricions for non-supported ssbo devices.
    entries[3].binding = DawnGraphicsPipeline::kGradientBufferIndex;
    entries[3].visibility = wgpu::ShaderStage::Fragment;
    entries[3].buffer.type = fSharedContext->caps()->storageBufferPreferred()
                                     ? wgpu::BufferBindingType::ReadOnlyStorage
                                     : wgpu::BufferBindingType::Uniform;
    entries[3].buffer.hasDynamicOffset = true;
    entries[3].buffer.minBindingSize = 0;
 
    wgpu::BindGroupLayoutDescriptor groupLayoutDesc;
    if (fSharedContext->caps()->setBackendLabels()) {
        groupLayoutDesc.label = "Uniform buffers bind group layout";
    }
 
    groupLayoutDesc.entryCount = entries.size();
    groupLayoutDesc.entries = entries.data();
    fUniformBuffersBindGroupLayout =
            this->dawnSharedContext()->device().CreateBindGroupLayout(&groupLayoutDesc);
 
    return fUniformBuffersBindGroupLayout;
}

---

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

• third_party/skia/src/gpu/graphite/dawn/DawnResourceProvider.h
• third_party/skia/src/gpu/graphite/dawn/DawnResourceProvider.cpp