blob: b98014d5a49ff613f0ff05b390c52772713d9652 [file] [log] [blame]
* Copyright 2021 Google LLC
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
#include "src/gpu/graphite/DrawPass.h"
#include "include/gpu/graphite/GraphiteTypes.h"
#include "include/gpu/graphite/Recorder.h"
#include "src/gpu/graphite/Buffer.h"
#include "src/gpu/graphite/BufferManager.h"
#include "src/gpu/graphite/Caps.h"
#include "src/gpu/graphite/ContextPriv.h"
#include "src/gpu/graphite/ContextUtils.h"
#include "src/gpu/graphite/DrawContext.h"
#include "src/gpu/graphite/DrawList.h"
#include "src/gpu/graphite/DrawWriter.h"
#include "src/gpu/graphite/GlobalCache.h"
#include "src/gpu/graphite/GraphicsPipeline.h"
#include "src/gpu/graphite/GraphicsPipelineDesc.h"
#include "src/gpu/graphite/Log.h"
#include "src/gpu/graphite/PaintParamsKey.h"
#include "src/gpu/graphite/PipelineData.h"
#include "src/gpu/graphite/PipelineDataCache.h"
#include "src/gpu/graphite/RecorderPriv.h"
#include "src/gpu/graphite/Renderer.h"
#include "src/gpu/graphite/ResourceProvider.h"
#include "src/gpu/graphite/Sampler.h"
#include "src/gpu/graphite/Texture.h"
#include "src/gpu/graphite/TextureProxy.h"
#include "src/gpu/graphite/UniformManager.h"
#include "src/gpu/graphite/geom/BoundsManager.h"
#include "src/base/SkMathPriv.h"
#include "src/base/SkTBlockList.h"
#include <algorithm>
#include <unordered_map>
namespace skgpu::graphite {
namespace {
// Helper to manage packed fields within a uint64_t
template <uint64_t Bits, uint64_t Offset>
struct Bitfield {
static constexpr uint64_t kMask = ((uint64_t) 1 << Bits) - 1;
static constexpr uint64_t kOffset = Offset;
static constexpr uint64_t kBits = Bits;
static uint32_t get(uint64_t v) { return static_cast<uint32_t>((v >> kOffset) & kMask); }
static uint64_t set(uint32_t v) { return (v & kMask) << kOffset; }
// This class maps objects to a dense index which can then be used to look them up later
template <typename T, typename V = T, typename C = V>
class DenseBiMap {
using Index = uint32_t;
// See note below in GeometryUniformField. This value can be round-tripped within the SortKey
// packing for all fields but will not be produced when recording actual draw data.
static constexpr Index kInvalidIndex{1 << SkNextLog2_portable(Renderer::kMaxRenderSteps *
bool empty() const { return fIndexToData.empty(); }
size_t size() const { return fIndexToData.size(); }
Index insert(const T& data) {
Index* index = fDataToIndex.find(data);
if (!index) {
SkASSERT(SkToU32(fIndexToData.size()) < kInvalidIndex - 1);
index = fDataToIndex.set(data, (Index) fIndexToData.size());
return *index;
const V& lookup(Index index) {
SkASSERT(index < kInvalidIndex);
return fIndexToData[index];
SkSpan<V> data() { return {, fIndexToData.size()}; }
SkTArray<V>&& detach() { return std::move(fIndexToData); }
SkTHashMap<T, Index> fDataToIndex;
SkTArray<V> fIndexToData;
// Tracks uniform data on the CPU and then its transition to storage in a GPU buffer (ubo or ssbo).
struct CpuOrGpuData {
union {
const UniformDataBlock* fCpuData;
BindBufferInfo fGpuData;
// Can only start from CPU data
CpuOrGpuData(const UniformDataBlock* cpuData) : fCpuData(cpuData) {}
// Tracks the combination of textures from the paint and from the RenderStep to describe the full
// binding that needs to be in the command list.
struct TextureBinding {
const TextureDataBlock* fPaintTextures;
const TextureDataBlock* fStepTextures;
bool operator==(const TextureBinding& other) const {
return fPaintTextures == other.fPaintTextures &&
fStepTextures == other.fStepTextures;
bool operator!=(const TextureBinding& other) const { return !(*this == other); }
int numTextures() const {
return (fPaintTextures ? fPaintTextures->numTextures() : 0) +
(fStepTextures ? fStepTextures->numTextures() : 0);
using UniformSsboCache = DenseBiMap<const UniformDataBlock*, CpuOrGpuData>;
using TextureBindingCache = DenseBiMap<TextureBinding>;
using GraphicsPipelineCache = DenseBiMap<GraphicsPipelineDesc>;
// Automatically merges and manages texture bindings and uniform bindings sourced from either the
// paint or the RenderStep. Tracks the bound state based on last-provided unique index to write
// Bind commands to a CommandList when necessary.
class TextureBindingTracker {
TextureBindingCache::Index trackTextures(const TextureDataBlock* paintTextures,
const TextureDataBlock* stepTextures) {
if (!paintTextures && !stepTextures) {
return TextureBindingCache::kInvalidIndex;
return fBindingCache.insert({paintTextures, stepTextures});
bool setCurrentTextureBindings(TextureBindingCache::Index bindingIndex) {
if (bindingIndex < TextureBindingCache::kInvalidIndex && fLastIndex != bindingIndex) {
fLastIndex = bindingIndex;
return true;
// No binding change
return false;
void bindTextures(DrawPassCommands::List* commandList) {
SkASSERT(fLastIndex < TextureBindingCache::kInvalidIndex);
const TextureBinding& binding = fBindingCache.lookup(fLastIndex);
auto [texIndices, samplerIndices] =
if (binding.fPaintTextures) {
for (int i = 0; i < binding.fPaintTextures->numTextures(); ++i) {
auto [tex, sampler] = binding.fPaintTextures->texture(i);
*texIndices++ = fProxyCache.insert(tex.get());
*samplerIndices++ = fSamplerCache.insert(sampler);
if (binding.fStepTextures) {
for (int i = 0; i < binding.fStepTextures->numTextures(); ++i) {
auto [tex, sampler] = binding.fStepTextures->texture(i);
*texIndices++ = fProxyCache.insert(tex.get());
*samplerIndices++ = fSamplerCache.insert(sampler);
SkTArray<sk_sp<TextureProxy>>&& detachTextures() { return fProxyCache.detach(); }
SkTArray<SamplerDesc>&& detachSamplers() { return fSamplerCache.detach(); }
struct ProxyRef {
const TextureProxy* fProxy;
operator sk_sp<TextureProxy>() const { return sk_ref_sp(fProxy); }
using TextureProxyCache = DenseBiMap<const TextureProxy*, sk_sp<TextureProxy>, ProxyRef>;
using SamplerDescCache = DenseBiMap<SamplerDesc>;
TextureBindingCache fBindingCache;
TextureProxyCache fProxyCache;
SamplerDescCache fSamplerCache;
TextureBindingCache::Index fLastIndex = TextureBindingCache::kInvalidIndex;
// Collects and writes uniform data either to uniform buffers or to shared storage buffers, and
// tracks when bindings need to change between draws.
class UniformSsboTracker {
UniformSsboTracker(bool useStorageBuffers) : fUseStorageBuffers(useStorageBuffers) {}
// Maps a given {pipeline index, uniform data cache index} pair to an SSBO index within the
// pipeline's accumulated array of uniforms.
UniformSsboCache::Index trackUniforms(GraphicsPipelineCache::Index pipelineIndex,
const UniformDataBlock* cpuData) {
if (!cpuData) {
return UniformSsboCache::kInvalidIndex;
if (pipelineIndex >= SkToU32(fPerPipelineCaches.size())) {
fPerPipelineCaches.resize(pipelineIndex + 1);
return fPerPipelineCaches[pipelineIndex].insert(cpuData);
// Writes all tracked uniform data into buffers, tracking the bindings for the written buffers
// by GraphicsPipelineCache::Index and possibly the UniformSsboCache::Index (when not using
// SSBOs). When using SSBos, the buffer is the same for all UniformSsboCache::Indices that share
// the same pipeline (and is stored in index 0).
void writeUniforms(DrawBufferManager* bufferMgr) {
for (UniformSsboCache& cache : fPerPipelineCaches) {
if (cache.empty()) {
// All data blocks for the same pipeline have the same size, so peek the first
// to determine the total buffer size
size_t udbSize = cache.lookup(0).fCpuData->size();
size_t udbDataSize = udbSize;
if (!fUseStorageBuffers) {
udbSize = bufferMgr->alignUniformBlockSize(udbSize);
auto [writer, bufferInfo] =
fUseStorageBuffers ? bufferMgr->getSsboWriter(udbSize * cache.size())
: bufferMgr->getUniformWriter(udbSize * cache.size());
for (CpuOrGpuData& dataBlock : {
SkASSERT(dataBlock.fCpuData->size() == udbDataSize);
writer.write(dataBlock.fCpuData->data(), udbDataSize);
// Swap from tracking the CPU data to the location of the GPU data
dataBlock.fGpuData = bufferInfo;
if (!fUseStorageBuffers) {
bufferInfo.fOffset += udbSize;
writer.skipBytes(udbSize - udbDataSize);
} // else keep bufferInfo pointing to the start of the array
// Updates the current tracked pipeline and ssbo index and returns whether or not bindBuffers()
// needs to be called, depending on if 'fUseStorageBuffers' is true or not.
bool setCurrentUniforms(GraphicsPipelineCache::Index pipelineIndex,
UniformSsboCache::Index ssboIndex) {
if (ssboIndex >= UniformSsboCache::kInvalidIndex) {
return false;
SkASSERT(pipelineIndex < SkToU32(fPerPipelineCaches.size()) &&
ssboIndex < fPerPipelineCaches[pipelineIndex].size());
if (fUseStorageBuffers) {
ssboIndex = 0; // The specific index has no effect on binding
if (fLastPipeline != pipelineIndex || fLastIndex != ssboIndex) {
fLastPipeline = pipelineIndex;
fLastIndex = ssboIndex;
return true;
} else {
return false;
// Binds a new uniform or storage buffer, based on most recently provided batch key and uniform
// data cache index.
void bindUniforms(UniformSlot slot, DrawPassCommands::List* commandList) {
SkASSERT(fLastPipeline < GraphicsPipelineCache::kInvalidIndex &&
fLastIndex < UniformSsboCache::kInvalidIndex);
SkASSERT(!fUseStorageBuffers || fLastIndex == 0);
const BindBufferInfo& binding =
commandList->bindUniformBuffer(binding, slot);
// Access first by pipeline index. The final UniformSsboCache::Index is either used to select
// the BindBufferInfo for a draw using UBOs, or it's the real index into a packed array of
// uniforms in a storage buffer object (whose binding is stored in index 0).
SkTArray<UniformSsboCache> fPerPipelineCaches;
const bool fUseStorageBuffers;
GraphicsPipelineCache::Index fLastPipeline = GraphicsPipelineCache::kInvalidIndex;
UniformSsboCache::Index fLastIndex = UniformSsboCache::kInvalidIndex;
} // namespace
* Each Draw in a DrawList might be processed by multiple RenderSteps (determined by the Draw's
* Renderer), which can be sorted independently. Each (step, draw) pair produces its own SortKey.
* The goal of sorting draws for the DrawPass is to minimize pipeline transitions and dynamic binds
* within a pipeline, while still respecting the overall painter's order. This decreases the number
* of low-level draw commands in a command buffer and increases the size of those, allowing the GPU
* to operate more efficiently and have fewer bubbles within its own instruction stream.
* The Draw's CompresssedPaintersOrder and DisjointStencilINdex represent the most significant bits
* of the key, and are shared by all SortKeys produced by the same draw. Next, the pipeline
* description is encoded in two steps:
* 1. The index of the RenderStep packed in the high bits to ensure each step for a draw is
* ordered correctly.
* 2. An index into a cache of pipeline descriptions is used to encode the identity of the
* pipeline (SortKeys that differ in the bits from #1 necessarily would have different
* descriptions, but then the specific ordering of the RenderSteps isn't enforced).
* Last, the SortKey encodes an index into the set of uniform bindings accumulated for a DrawPass.
* This allows the SortKey to cluster draw steps that have both a compatible pipeline and do not
* require rebinding uniform data or other state (e.g. scissor). Since the uniform data index and
* the pipeline description index are packed into indices and not actual pointers, a given SortKey
* is only valid for the a specific DrawList->DrawPass conversion.
class DrawPass::SortKey {
SortKey(const DrawList::Draw* draw,
int renderStep,
GraphicsPipelineCache::Index pipelineIndex,
UniformSsboCache::Index geomSsboIndex,
UniformSsboCache::Index shadingSsboIndex,
TextureBindingCache::Index textureBindingIndex)
: fPipelineKey(ColorDepthOrderField::set(draw->fDrawParams.order().paintOrder().bits()) |
StencilIndexField::set(draw->fDrawParams.order().stencilIndex().bits()) |
RenderStepField::set(static_cast<uint32_t>(renderStep)) |
, fUniformKey(GeometryUniformField::set(geomSsboIndex) |
ShadingUniformField::set(shadingSsboIndex) |
, fDraw(draw) {
SkASSERT(pipelineIndex < GraphicsPipelineCache::kInvalidIndex);
SkASSERT(renderStep <= draw->fRenderer->numRenderSteps());
bool operator<(const SortKey& k) const {
return fPipelineKey < k.fPipelineKey ||
(fPipelineKey == k.fPipelineKey && fUniformKey < k.fUniformKey);
const RenderStep& renderStep() const {
return fDraw->fRenderer->step(RenderStepField::get(fPipelineKey));
const DrawList::Draw& draw() const { return *fDraw; }
GraphicsPipelineCache::Index pipelineIndex() const {
return PipelineField::get(fPipelineKey);
UniformSsboCache::Index geometrySsboIndex() const {
return GeometryUniformField::get(fUniformKey);
UniformSsboCache::Index shadingSsboIndex() const {
return ShadingUniformField::get(fUniformKey);
TextureBindingCache::Index textureBindingIndex() const {
return TextureBindingsField::get(fUniformKey);
// Fields are ordered from most-significant to least when sorting by 128-bit value.
// NOTE: We don't use C++ bit fields because field ordering is implementation defined and we
// need to sort consistently.
using ColorDepthOrderField = Bitfield<16, 48>; // sizeof(CompressedPaintersOrder)
using StencilIndexField = Bitfield<16, 32>; // sizeof(DisjointStencilIndex)
using RenderStepField = Bitfield<2, 30>; // bits >= log2(Renderer::kMaxRenderSteps)
using PipelineField = Bitfield<30, 0>; // bits >= log2(max steps*DrawList::kMaxDraws)
uint64_t fPipelineKey;
// The uniform/texture index fields need 1 extra bit to encode "no-data". Values that are
// greater than or equal to 2^(bits-1) represent "no-data", while values between
// [0, 2^(bits-1)-1] can access data arrays without extra logic.
using GeometryUniformField = Bitfield<22, 42>; // bits >= 1+log2(max steps * max draw count)
using ShadingUniformField = Bitfield<21, 21>; // bits >= 1+log2(max steps * max draw count)
using TextureBindingsField = Bitfield<21, 0>; // bits >= 1+log2(max steps * max draw count)
uint64_t fUniformKey;
// Backpointer to the draw that produced the sort key
const DrawList::Draw* fDraw;
static_assert(ColorDepthOrderField::kBits >= sizeof(CompressedPaintersOrder));
static_assert(StencilIndexField::kBits >= sizeof(DisjointStencilIndex));
static_assert(RenderStepField::kBits >= SkNextLog2_portable(Renderer::kMaxRenderSteps));
static_assert(PipelineField::kBits >=
SkNextLog2_portable(Renderer::kMaxRenderSteps * DrawList::kMaxDraws));
static_assert(GeometryUniformField::kBits >=
1 + SkNextLog2_portable(Renderer::kMaxRenderSteps * DrawList::kMaxDraws));
static_assert(ShadingUniformField::kBits >=
1 + SkNextLog2_portable(Renderer::kMaxRenderSteps * DrawList::kMaxDraws));
static_assert(TextureBindingsField::kBits >=
1 + SkNextLog2_portable(Renderer::kMaxRenderSteps * DrawList::kMaxDraws));
DrawPass::DrawPass(sk_sp<TextureProxy> target,
std::pair<LoadOp, StoreOp> ops,
std::array<float, 4> clearColor)
: fTarget(std::move(target))
, fBounds(SkIRect::MakeEmpty())
, fOps(ops)
, fClearColor(clearColor) {}
DrawPass::~DrawPass() = default;
std::unique_ptr<DrawPass> 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) {
// 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) == 16 + sizeof(void*));
// 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(std::move(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();
GraphicsPipelineCache pipelineCache;
// Geometry uniforms are currently always UBO-backed.
const ResourceBindingRequirements& bindingReqs =
Layout geometryUniformLayout = bindingReqs.fUniformBufferLayout;
UniformSsboTracker geometrySsboTracker(/*useStorageBuffers=*/false);
bool useStorageBuffers = recorder->priv().caps()->storageBufferPreferred();
Layout shadingUniformLayout =
useStorageBuffers ? bindingReqs.fStorageBufferLayout : bindingReqs.fUniformBufferLayout;
UniformSsboTracker shadingSsboTracker(useStorageBuffers);
TextureBindingTracker textureBindingTracker;
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(shadingUniformLayout);
std::vector<SortKey> keys;
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()) {
std::tie(shaderID, shadingUniforms, paintTextures) =
} // 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,
UniformSsboCache::Index geomSsboIndex = geometrySsboTracker.trackUniforms(
pipelineIndex, geometryUniforms);
UniformSsboCache::Index shadingSsboIndex = shadingSsboTracker.trackUniforms(
pipelineIndex, performsShading ? shadingUniforms : nullptr);
TextureBindingCache::Index textureIndex = textureBindingTracker.trackTextures(
performsShading ? paintTextures : nullptr, stepTextures);
keys.push_back({&draw, stepIndex, pipelineIndex,
geomSsboIndex, shadingSsboIndex, textureIndex});
drawPass->fDepthStencilFlags |= draw.fRenderer->depthStencilFlags();
drawPass->fRequiresMSAA |= draw.fRenderer->requiresMSAA();
// 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->isInstantiated() ||
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 = geometrySsboTracker.setCurrentUniforms(
key.pipelineIndex(), key.geometrySsboIndex());
const bool shadingBindingChange = shadingSsboTracker.setCurrentUniforms(
key.pipelineIndex(), key.shadingSsboIndex());
const bool textureBindingsChange = textureBindingTracker.setCurrentTextureBindings(
const SkIRect* newScissor = draw.fDrawParams.clip().scissor() != lastScissor ?
&draw.fDrawParams.clip().scissor() : nullptr;
const bool stateChange = geomBindingChange ||
shadingBindingChange ||
textureBindingsChange ||
// Update DrawWriter *before* we actually change any state so that accumulated draws from
// the previous state use the proper state.
if (pipelineChange) {
} else if (stateChange) {
// Make state changes before accumulating new draw data
if (pipelineChange) {
lastPipeline = key.pipelineIndex();
if (stateChange) {
if (geomBindingChange) {
geometrySsboTracker.bindUniforms(UniformSlot::kRenderStep, &drawPass->fCommandList);
if (shadingBindingChange) {
shadingSsboTracker.bindUniforms(UniformSlot::kPaint, &drawPass->fCommandList);
if (textureBindingsChange) {
if (newScissor) {
lastScissor = *newScissor;
renderStep.writeVertices(&drawWriter, draw.fDrawParams, key.shadingSsboIndex());
// Finish recording draw calls for any collected data at the end of the loop
drawPass->fPipelineDescs = pipelineCache.detach();
drawPass->fSamplerDescs = textureBindingTracker.detachSamplers();
drawPass->fSampledTextures = textureBindingTracker.detachTextures();
return drawPass;
bool DrawPass::prepareResources(ResourceProvider* resourceProvider,
const RuntimeEffectDictionary* runtimeDict,
const RenderPassDesc& renderPassDesc) {
for (const GraphicsPipelineDesc& pipelineDesc : fPipelineDescs) {
auto pipeline = resourceProvider->findOrCreateGraphicsPipeline(runtimeDict,
if (!pipeline) {
SKGPU_LOG_W("Failed to create GraphicsPipeline for draw in RenderPass. Dropping pass!");
return false;
// 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.
for (int i = 0; i < fSampledTextures.size(); ++i) {
// TODO: We need to remove this check once we are creating valid SkImages from things like
// snapshot, save layers, etc. Right now we only support SkImages directly made for graphite
// and all others have a TextureProxy with an invalid TextureInfo.
if (!fSampledTextures[i]->textureInfo().isValid()) {
SKGPU_LOG_W("Failed to validate sampled texture. Will not create renderpass!");
return false;
if (!TextureProxy::InstantiateIfNotLazy(resourceProvider, fSampledTextures[i].get())) {
SKGPU_LOG_W("Failed to instantiate sampled texture. Will not create renderpass!");
return false;
for (int i = 0; i < fSamplerDescs.size(); ++i) {
sk_sp<Sampler> sampler = resourceProvider->findOrCreateCompatibleSampler(
if (!sampler) {
SKGPU_LOG_W("Failed to create sampler. Will not create renderpass!");
return false;
// 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.
return true;
void DrawPass::addResourceRefs(CommandBuffer* commandBuffer) const {
for (int i = 0; i < fFullPipelines.size(); ++i) {
for (int i = 0; i < fSampledTextures.size(); ++i) {
for (int i = 0; i < fSamplers.size(); ++i) {
const Texture* DrawPass::getTexture(size_t index) const {
SkASSERT(index < SkToSizeT(fSampledTextures.size()));
return fSampledTextures[index]->texture();
const Sampler* DrawPass::getSampler(size_t index) const {
SkASSERT(index < SkToSizeT(fSamplers.size()));
return fSamplers[index].get();
} // namespace skgpu::graphite