skgpu::graphite::DrawPass Class Reference

#include <DrawPass.h>

Classes
class	SortKey

Public Member Functions
	~DrawPass ()
const SkIRect &	bounds () const
TextureProxy *	target () const
std::pair< LoadOp, StoreOp >	ops () const
std::array< float, 4 >	clearColor () const
bool	requiresDstTexture () const
bool	requiresMSAA () const
SkEnumBitMask< DepthStencilFlags >	depthStencilFlags () const
size_t	vertexBufferSize () const
size_t	uniformBufferSize () const
bool	prepareResources (ResourceProvider *, const RuntimeEffectDictionary *, const RenderPassDesc &)
DrawPassCommands::List::Iter	commands () const
const GraphicsPipeline *	getPipeline (size_t index) const
const Texture *	getTexture (size_t index) const
const Sampler *	getSampler (size_t index) const
skia_private::TArray< sk_sp< TextureProxy > >	sampledTextures () const
void	addResourceRefs (CommandBuffer *) const

Static Public Member Functions
static std::unique_ptr< DrawPass >	Make (Recorder *, std::unique_ptr< DrawList >, sk_sp< TextureProxy > target, const SkImageInfo &targetInfo, std::pair< LoadOp, StoreOp >, std::array< float, 4 > clearColor, sk_sp< TextureProxy > dstCopy, SkIPoint dstCopyOffset)

Detailed Description

DrawPass is analogous to a subpass, storing the drawing operations in the order they are stored in the eventual command buffer, as well as the surface proxy the operations are intended for. DrawPasses are grouped into a RenderPassTask for execution within a single render pass if the subpasses are compatible with each other.

Unlike DrawList, DrawPasses are immutable and represent as closely as possible what will be stored in the command buffer while being flexible as to how the pass is incorporated. Depending on the backend, it may even be able to write accumulated vertex and uniform data directly to mapped GPU memory, although that is the extent of the CPU->GPU work they perform before they are executed by a RenderPassTask.

Definition at line 53 of file DrawPass.h.

Constructor & Destructor Documentation

~DrawPass()

skgpu::graphite::DrawPass::~DrawPass ( )

default

Member Function Documentation

addResourceRefs()

void skgpu::graphite::DrawPass::addResourceRefs

(

CommandBuffer *

commandBuffer

)

const

Definition at line 747 of file DrawPass.cpp.

                                                                 {
    for (int i = 0; i < fFullPipelines.size(); ++i) {
        commandBuffer->trackResource(fFullPipelines[i]);
    }
    for (int i = 0; i < fSampledTextures.size(); ++i) {
        commandBuffer->trackCommandBufferResource(fSampledTextures[i]->refTexture());
    }
    for (int i = 0; i < fSamplers.size(); ++i) {
        commandBuffer->trackResource(fSamplers[i]);
    }
}

bounds()

const SkIRect & skgpu::graphite::DrawPass::bounds ( ) const

inline

Definition at line 72 of file DrawPass.h.

{ return fBounds;       }

clearColor()

std::array< float, 4 > skgpu::graphite::DrawPass::clearColor ( ) const

inline

Definition at line 75 of file DrawPass.h.

{ return fClearColor; }

commands()

DrawPassCommands::List::Iter skgpu::graphite::DrawPass::commands ( ) const

inline

Definition at line 92 of file DrawPass.h.

                                              {
        return fCommandList.commands();
    }

depthStencilFlags()

SkEnumBitMask< DepthStencilFlags > skgpu::graphite::DrawPass::depthStencilFlags ( ) const

inline

Definition at line 80 of file DrawPass.h.

{ return fDepthStencilFlags; }

getPipeline()

const GraphicsPipeline * skgpu::graphite::DrawPass::getPipeline ( size_t  index ) const

inline

Definition at line 96 of file DrawPass.h.

                                                            {
        return fFullPipelines[index].get();
    }

getSampler()

const Sampler * skgpu::graphite::DrawPass::getSampler

(

size_t

index

)

const

Definition at line 765 of file DrawPass.cpp.

                                                      {
    SkASSERT(index < SkToSizeT(fSamplers.size()));
    SkASSERT(fSamplers[index]);
    return fSamplers[index].get();
}

getTexture()

const Texture * skgpu::graphite::DrawPass::getTexture

(

size_t

index

)

const

Definition at line 759 of file DrawPass.cpp.

                                                      {
    SkASSERT(index < SkToSizeT(fSampledTextures.size()));
    SkASSERT(fSampledTextures[index]);
    SkASSERT(fSampledTextures[index]->texture());
    return fSampledTextures[index]->texture();
}

Make()

std::unique_ptr< DrawPass > skgpu::graphite::DrawPass::Make ( Recorder *  recorder, std::unique_ptr< DrawList >  draws, sk_sp< TextureProxy >  target, const SkImageInfo &  targetInfo, std::pair< LoadOp, StoreOp >  ops, std::array< float, 4 >  clearColor, sk_sp< TextureProxy >  dstCopy, SkIPoint  dstCopyOffset  )

static

Definition at line 458 of file DrawPass.cpp.

                                                                 {
    // NOTE: This assert is here to ensure SortKey is as tightly packed as possible. Any change to
    // its size should be done with care and good reason. The performance of sorting the keys is
    // heavily tied to the total size.
    //
    // At 24 bytes (current), sorting is about 30% slower than if SortKey could be packed into just
    // 16 bytes. There are several ways this could be done if necessary:
    //  - Restricting the max draw count to 16k (14-bits) and only using a single index to refer to
    //    the uniform data => 8 bytes of key, 8 bytes of pointer.
    //  - Restrict the max draw count to 32k (15-bits), use a single uniform index, and steal the
    //    4 low bits from the Draw* pointer since it's 16 byte aligned.
    //  - Compact the Draw* to an index into the original collection, although that has extra
    //    indirection and does not work as well with SkTBlockList.
    // In pseudo tests, manipulating the pointer or having to mask out indices was about 15% slower
    // than an 8 byte key and unmodified pointer.
    static_assert(sizeof(DrawPass::SortKey) ==
                  SkAlignTo(16 + sizeof(void*), alignof(DrawPass::SortKey)));
 
    TRACE_EVENT1("skia.gpu", TRACE_FUNC, "draw count", draws->fDraws.count());
 
    // The DrawList is converted directly into the DrawPass' data structures, but once the DrawPass
    // is returned from Make(), it is considered immutable.
    std::unique_ptr<DrawPass> drawPass(new DrawPass(target, ops, clearColor));
 
    Rect passBounds = Rect::InfiniteInverted();
 
    // We don't expect the uniforms from the renderSteps to reappear multiple times across a
    // recorder's lifetime so we only de-dupe them w/in a given DrawPass.
    UniformDataCache geometryUniformDataCache;
    TextureDataCache* textureDataCache = recorder->priv().textureDataCache();
    DrawBufferManager* bufferMgr = recorder->priv().drawBufferManager();
    if (bufferMgr->hasMappingFailed()) {
        SKGPU_LOG_W("Buffer mapping has already failed; dropping draw pass!");
        return nullptr;
    }
    // Ensure there's a destination copy if required
    if (!draws->dstCopyBounds().isEmptyNegativeOrNaN() && !dstCopy) {
        SKGPU_LOG_W("Failed to copy destination for reading. Dropping draw pass!");
        return nullptr;
    }
 
    GraphicsPipelineCache pipelineCache;
 
    // Geometry uniforms are currently always UBO-backed.
    const bool useStorageBuffers = recorder->priv().caps()->storageBufferPreferred();
    const ResourceBindingRequirements& bindingReqs =
            recorder->priv().caps()->resourceBindingRequirements();
    Layout uniformLayout =
            useStorageBuffers ? bindingReqs.fStorageBufferLayout : bindingReqs.fUniformBufferLayout;
 
    UniformTracker geometryUniformTracker(useStorageBuffers);
    UniformTracker shadingUniformTracker(useStorageBuffers);
    TextureBindingTracker textureBindingTracker;
    GradientBufferTracker gradientBufferTracker;
 
    ShaderCodeDictionary* dict = recorder->priv().shaderCodeDictionary();
    PaintParamsKeyBuilder builder(dict);
 
    // The initial layout we pass here is not important as it will be re-assigned when writing
    // shading and geometry uniforms below.
    PipelineDataGatherer gatherer(uniformLayout);
 
    std::vector<SortKey> keys;
    keys.reserve(draws->renderStepCount());
 
    for (const DrawList::Draw& draw : draws->fDraws.items()) {
        // If we have two different descriptors, such that the uniforms from the PaintParams can be
        // bound independently of those used by the rest of the RenderStep, then we can upload now
        // and remember the location for re-use on any RenderStep that does shading.
        UniquePaintParamsID shaderID;
        const UniformDataBlock* shadingUniforms = nullptr;
        const TextureDataBlock* paintTextures = nullptr;
 
        if (draw.fPaintParams.has_value()) {
            sk_sp<TextureProxy> curDst =
                    draw.fPaintParams->dstReadRequirement() == DstReadRequirement::kTextureCopy
                            ? dstCopy
                            : nullptr;
            std::tie(shaderID, shadingUniforms, paintTextures) =
                    ExtractPaintData(recorder,
                                     &gatherer,
                                     &builder,
                                     uniformLayout,
                                     draw.fDrawParams.transform(),
                                     draw.fPaintParams.value(),
                                     draw.fDrawParams.geometry(),
                                     curDst,
                                     dstCopyOffset,
                                     targetInfo.colorInfo());
        } // else depth-only
 
        for (int stepIndex = 0; stepIndex < draw.fRenderer->numRenderSteps(); ++stepIndex) {
            const RenderStep* const step = draw.fRenderer->steps()[stepIndex];
            const bool performsShading = draw.fPaintParams.has_value() && step->performsShading();
 
            GraphicsPipelineCache::Index pipelineIndex = pipelineCache.insert(
                    {step, performsShading ? shaderID : UniquePaintParamsID::InvalidID()});
            auto [geometryUniforms, stepTextures] = ExtractRenderStepData(&geometryUniformDataCache,
                                                                          textureDataCache,
                                                                          &gatherer,
                                                                          uniformLayout,
                                                                          step,
                                                                          draw.fDrawParams);
 
            UniformCache::Index geomUniformIndex = geometryUniformTracker.trackUniforms(
                    pipelineIndex, geometryUniforms);
            UniformCache::Index shadingUniformIndex = shadingUniformTracker.trackUniforms(
                    pipelineIndex, performsShading ? shadingUniforms : nullptr);
            TextureBindingCache::Index textureIndex = textureBindingTracker.trackTextures(
                    performsShading ? paintTextures : nullptr, stepTextures);
 
            keys.push_back({&draw, stepIndex, pipelineIndex,
                            geomUniformIndex, shadingUniformIndex, textureIndex});
        }
 
        passBounds.join(draw.fDrawParams.clip().drawBounds());
        drawPass->fDepthStencilFlags |= draw.fRenderer->depthStencilFlags();
        drawPass->fRequiresMSAA |= draw.fRenderer->requiresMSAA();
    }
 
    if (!geometryUniformTracker.writeUniforms(bufferMgr) ||
        !shadingUniformTracker.writeUniforms(bufferMgr) ||
        !gradientBufferTracker.writeData(gatherer.gradientBufferData(), bufferMgr)) {
        // The necessary uniform data couldn't be written to the GPU, so the DrawPass is invalid.
        // Early out now since the next Recording snap will fail.
        return nullptr;
    }
 
    // TODO: Explore sorting algorithms; in all likelihood this will be mostly sorted already, so
    // algorithms that approach O(n) in that condition may be favorable. Alternatively, could
    // explore radix sort that is always O(n). Brief testing suggested std::sort was faster than
    // std::stable_sort and SkTQSort on my [ml]'s Windows desktop. Also worth considering in-place
    // vs. algorithms that require an extra O(n) storage.
    // TODO: It's not strictly necessary, but would a stable sort be useful or just end up hiding
    // bugs in the DrawOrder determination code?
    std::sort(keys.begin(), keys.end());
 
    // Used to record vertex/instance data, buffer binds, and draw calls
    DrawWriter drawWriter(&drawPass->fCommandList, bufferMgr);
    GraphicsPipelineCache::Index lastPipeline = GraphicsPipelineCache::kInvalidIndex;
    SkIRect lastScissor = SkIRect::MakeSize(targetInfo.dimensions());
 
    SkASSERT(drawPass->fTarget->isFullyLazy() ||
             SkIRect::MakeSize(drawPass->fTarget->dimensions()).contains(lastScissor));
    drawPass->fCommandList.setScissor(lastScissor);
 
    // All large gradients pack their data into a single buffer throughout the draw pass,
    // therefore the gradient buffer only needs to be bound once.
    gradientBufferTracker.bindIfNeeded(&drawPass->fCommandList);
 
    for (const SortKey& key : keys) {
        const DrawList::Draw& draw = key.draw();
        const RenderStep& renderStep = key.renderStep();
 
        const bool pipelineChange = key.pipelineIndex() != lastPipeline;
 
        const bool geomBindingChange    = geometryUniformTracker.setCurrentUniforms(
                key.pipelineIndex(), key.geometryUniformIndex());
        const bool shadingBindingChange  = shadingUniformTracker.setCurrentUniforms(
                key.pipelineIndex(), key.shadingUniformIndex());
        const bool textureBindingsChange = textureBindingTracker.setCurrentTextureBindings(
                key.textureBindingIndex());
        const SkIRect* newScissor        = draw.fDrawParams.clip().scissor() != lastScissor ?
                &draw.fDrawParams.clip().scissor() : nullptr;
 
        const bool stateChange = geomBindingChange ||
                                 shadingBindingChange ||
                                 textureBindingsChange ||
                                 SkToBool(newScissor);
 
        // Update DrawWriter *before* we actually change any state so that accumulated draws from
        // the previous state use the proper state.
        if (pipelineChange) {
            drawWriter.newPipelineState(renderStep.primitiveType(),
                                        renderStep.vertexStride(),
                                        renderStep.instanceStride());
        } else if (stateChange) {
            drawWriter.newDynamicState();
        }
 
        // Make state changes before accumulating new draw data
        if (pipelineChange) {
            drawPass->fCommandList.bindGraphicsPipeline(key.pipelineIndex());
            lastPipeline = key.pipelineIndex();
        }
        if (stateChange) {
            if (geomBindingChange) {
                geometryUniformTracker.bindUniforms(UniformSlot::kRenderStep,
                                                    &drawPass->fCommandList);
            }
            if (shadingBindingChange) {
                shadingUniformTracker.bindUniforms(UniformSlot::kPaint, &drawPass->fCommandList);
            }
            if (textureBindingsChange) {
                textureBindingTracker.bindTextures(&drawPass->fCommandList);
            }
            if (newScissor) {
                drawPass->fCommandList.setScissor(*newScissor);
                lastScissor = *newScissor;
            }
        }
 
        UniformCache::Index geometrySsboIndex =
                (key.geometryUniformIndex() == UniformCache::kInvalidIndex)
                        ? 0
                        : key.geometryUniformIndex();
        UniformCache::Index shadingSsboIndex =
                (key.shadingUniformIndex() == UniformCache::kInvalidIndex)
                        ? 0
                        : key.shadingUniformIndex();
        skvx::ushort2 ssboIndices = {SkToU16(geometrySsboIndex), SkToU16(shadingSsboIndex)};
        renderStep.writeVertices(&drawWriter, draw.fDrawParams, ssboIndices);
 
        if (bufferMgr->hasMappingFailed()) {
            SKGPU_LOG_W("Failed to write necessary vertex/instance data for DrawPass, dropping!");
            return nullptr;
        }
    }
    // Finish recording draw calls for any collected data at the end of the loop
    drawWriter.flush();
 
    drawPass->fBounds = passBounds.roundOut().asSkIRect();
 
    drawPass->fPipelineDescs   = pipelineCache.detach();
    drawPass->fSamplerDescs    = textureBindingTracker.detachSamplers();
    drawPass->fSampledTextures = textureBindingTracker.detachTextures();
 
    TRACE_COUNTER1("skia.gpu", "# pipelines", drawPass->fPipelineDescs.size());
    TRACE_COUNTER1("skia.gpu", "# textures", drawPass->fSampledTextures.size());
    TRACE_COUNTER1("skia.gpu", "# commands", drawPass->fCommandList.count());
 
    return drawPass;
}

ops()

std::pair< LoadOp, StoreOp > skgpu::graphite::DrawPass::ops ( ) const

inline

Definition at line 74 of file DrawPass.h.

{ return fOps; }

prepareResources()

bool skgpu::graphite::DrawPass::prepareResources	(	ResourceProvider *	resourceProvider,
		const RuntimeEffectDictionary *	runtimeDict,
		const RenderPassDesc &	renderPassDesc
	)

Definition at line 699 of file DrawPass.cpp.

                                                                      {
    TRACE_EVENT0("skia.gpu", TRACE_FUNC);
 
    fFullPipelines.reserve(fFullPipelines.size() + fPipelineDescs.size());
    for (const GraphicsPipelineDesc& pipelineDesc : fPipelineDescs) {
        auto pipeline = resourceProvider->findOrCreateGraphicsPipeline(runtimeDict,
                                                                       pipelineDesc,
                                                                       renderPassDesc);
        if (!pipeline) {
            SKGPU_LOG_W("Failed to create GraphicsPipeline for draw in RenderPass. Dropping pass!");
            return false;
        }
        fFullPipelines.push_back(std::move(pipeline));
    }
    // The DrawPass may be long lived on a Recording and we no longer need the GraphicPipelineDescs
    // once we've created pipelines, so we drop the storage for them here.
    fPipelineDescs.clear();
 
#if defined(SK_DEBUG)
    for (int i = 0; i < fSampledTextures.size(); ++i) {
        // It should not have been possible to draw an Image that has an invalid texture info
        SkASSERT(fSampledTextures[i]->textureInfo().isValid());
        // Tasks should have been ordered to instantiate any scratch textures already, or any
        // client-owned image will have been instantiated at creation.
        SkASSERTF(fSampledTextures[i]->isInstantiated() ||
                  fSampledTextures[i]->isLazy(),
                  "proxy label = %s", fSampledTextures[i]->label());
    }
#endif
 
    fSamplers.reserve(fSamplers.size() + fSamplerDescs.size());
    for (int i = 0; i < fSamplerDescs.size(); ++i) {
        sk_sp<Sampler> sampler = resourceProvider->findOrCreateCompatibleSampler(fSamplerDescs[i]);
        if (!sampler) {
            SKGPU_LOG_W("Failed to create sampler. Will not create renderpass!");
            return false;
        }
        fSamplers.push_back(std::move(sampler));
    }
    // The DrawPass may be long lived on a Recording and we no longer need the SamplerDescs
    // once we've created Samplers, so we drop the storage for them here.
    fSamplerDescs.clear();
 
    return true;
}

requiresDstTexture()

bool skgpu::graphite::DrawPass::requiresDstTexture ( ) const

inline

Definition at line 77 of file DrawPass.h.

{ return false;            }

requiresMSAA()

bool skgpu::graphite::DrawPass::requiresMSAA ( ) const

inline

Definition at line 78 of file DrawPass.h.

{ return fRequiresMSAA;    }

sampledTextures()

skia_private::TArray< sk_sp< TextureProxy > > skgpu::graphite::DrawPass::sampledTextures ( ) const

inline

Definition at line 102 of file DrawPass.h.

{ return fSampledTextures; }

target()

TextureProxy * skgpu::graphite::DrawPass::target ( ) const

inline

Definition at line 73 of file DrawPass.h.

{ return fTarget.get(); }

uniformBufferSize()

size_t skgpu::graphite::DrawPass::uniformBufferSize ( ) const

inline

Definition at line 83 of file DrawPass.h.

{ return 0; }

vertexBufferSize()

size_t skgpu::graphite::DrawPass::vertexBufferSize ( ) const

inline

Definition at line 82 of file DrawPass.h.

{ return 0; }

---

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

• third_party/skia/src/gpu/graphite/DrawPass.h
• third_party/skia/src/gpu/graphite/DrawPass.cpp