skgpu::graphite::DrawList Class Reference

#include <DrawList.h>

Classes
struct	Draw

Public Member Functions
void	recordDraw (const Renderer *renderer, const Transform &localToDevice, const Geometry &geometry, const Clip &clip, DrawOrder ordering, const PaintParams *paint, const StrokeStyle *stroke)
int	renderStepCount () const
const Rect &	dstCopyBounds () const
const Transform &	deduplicateTransform (const Transform &)

Public Attributes
SkTBlockList< Transform, 16 >	fTransforms {SkBlockAllocator::GrowthPolicy::kFibonacci}
SkTBlockList< Draw, 16 >	fDraws {SkBlockAllocator::GrowthPolicy::kFibonacci}
int	fRenderStepCount = 0
Rect	fDstCopyBounds = Rect::InfiniteInverted()

Static Public Attributes
static constexpr int	kMaxRenderSteps = 4096

Detailed Description

A DrawList represents a collection of drawing commands (and related clip/shading state) in a form that closely mirrors what can be rendered efficiently and directly by the GPU backend (while balancing how much pre-processing to do for draws that might get eliminated later due to occlusion culling).

A draw command combines:

• a shape
• a transform
• a primitive clip (not affected by the transform)
• optional shading description (shader, color filter, blend mode, etc)
• a draw ordering (compressed painters index, stencil set, and write/test depth)

Commands are accumulated in an arbitrary order and then sorted by increasing sort z when the list is prepared into an actual command buffer. The result of a draw command is the rasterization of the transformed shape, restricted by its primitive clip (e.g. a scissor rect) and a depth test of "GREATER" vs. its write/test z. (A test of GREATER, as opposed to GEQUAL, avoids double hits for draws that may have overlapping geometry, e.g. stroking.) If the command has a shading description, the color buffer will be modified; if not, it will be a depth-only draw.

In addition to sorting the collected commands, the command list can be optimized during preparation. Commands that are fully occluded by later operations can be skipped entirely without affecting the final results. Adjacent commands (post sort) that would use equivalent GPU pipelines are merged to produce fewer (but larger) operations on the GPU.

Other than flush-time optimizations (sort, cull, and merge), the command list does what you tell it to. Draw-specific simplification, style application, and advanced clipping should be handled at a higher layer.

Definition at line 57 of file DrawList.h.

Member Function Documentation

deduplicateTransform()

const Transform & skgpu::graphite::DrawList::deduplicateTransform

(

const Transform &

localToDevice

)

Definition at line 16 of file DrawList.cpp.

                                                                              {
    // TODO: This is a pretty simple deduplication strategy and doesn't take advantage of the stack
    // knowledge that Device has.
    if (fTransforms.empty() || fTransforms.back() != localToDevice) {
        fTransforms.push_back(localToDevice);
    }
    return fTransforms.back();
}

dstCopyBounds()

const Rect & skgpu::graphite::DrawList::dstCopyBounds ( ) const

inline

Definition at line 87 of file DrawList.h.

{ return fDstCopyBounds; }

recordDraw()

void skgpu::graphite::DrawList::recordDraw	(	const Renderer *	renderer,
		const Transform &	localToDevice,
		const Geometry &	geometry,
		const Clip &	clip,
		DrawOrder	ordering,
		const PaintParams *	paint,
		const StrokeStyle *	stroke
	)

Definition at line 25 of file DrawList.cpp.

                                                     {
    SkASSERT(localToDevice.valid());
    SkASSERT(!geometry.isEmpty() && !clip.drawBounds().isEmptyNegativeOrNaN());
    SkASSERT(!(renderer->depthStencilFlags() & DepthStencilFlags::kStencil) ||
             ordering.stencilIndex() != DrawOrder::kUnassigned);
 
    // TODO: Add validation that the renderer's expected shape type and stroke params match provided
 
    fDraws.emplace_back(renderer, this->deduplicateTransform(localToDevice),
                        geometry, clip, ordering, paint, stroke);
    fRenderStepCount += renderer->numRenderSteps();
 
#if defined(SK_DEBUG)
    if (geometry.isCoverageMaskShape()) {
        fCoverageMaskShapeDrawCount++;
    }
#endif
 
    if (paint && paint->dstReadRequirement() == DstReadRequirement::kTextureCopy) {
        fDstCopyBounds.join(clip.drawBounds());
    }
}

renderStepCount()

int skgpu::graphite::DrawList::renderStepCount ( ) const

inline

Definition at line 84 of file DrawList.h.

{ return fRenderStepCount; }

Member Data Documentation

fDraws

SkTBlockList<Draw, 16> skgpu::graphite::DrawList::fDraws {SkBlockAllocator::GrowthPolicy::kFibonacci}

Definition at line 111 of file DrawList.h.

fDstCopyBounds

Rect skgpu::graphite::DrawList::fDstCopyBounds = Rect::InfiniteInverted()

Definition at line 121 of file DrawList.h.

fRenderStepCount

int skgpu::graphite::DrawList::fRenderStepCount = 0

Definition at line 114 of file DrawList.h.

fTransforms

SkTBlockList<Transform, 16> skgpu::graphite::DrawList::fTransforms {SkBlockAllocator::GrowthPolicy::kFibonacci}

Definition at line 110 of file DrawList.h.

kMaxRenderSteps

constexpr int skgpu::graphite::DrawList::kMaxRenderSteps = 4096

staticconstexpr

Definition at line 68 of file DrawList.h.

---

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

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