skgpu::graphite::ClipStack Class Reference

#include <ClipStack_graphite.h>

Classes
struct	Element
class	ElementIter
struct	TransformedShape

Public Types
enum class	ClipState : uint8_t {   kEmpty , kWideOpen , kDeviceRect , kDeviceRRect ,   kComplex }
using	ElementList = skia_private::STArray< 4, const Element * >

Public Member Functions
	ClipStack (Device *owningDevice)
	~ClipStack ()
	ClipStack (const ClipStack &)=delete
ClipStack &	operator= (const ClipStack &)=delete
ClipState	clipState () const
int	maxDeferredClipDraws () const
Rect	conservativeBounds () const
ElementIter	begin () const
ElementIter	end () const
void	save ()
void	restore ()
void	clipShape (const Transform &localToDevice, const Shape &shape, SkClipOp op)
void	clipShader (sk_sp< SkShader > shader)
Clip	visitClipStackForDraw (const Transform &, const Geometry &, const SkStrokeRec &, bool outsetBoundsForAA, ElementList *outEffectiveElements) const
CompressedPaintersOrder	updateClipStateForDraw (const Clip &clip, const ElementList &effectiveElements, const BoundsManager *, PaintersDepth z)
void	recordDeferredClipDraws ()

Detailed Description

Definition at line 30 of file ClipStack_graphite.h.

Member Typedef Documentation

ElementList

using skgpu::graphite::ClipStack::ElementList = skia_private::STArray<4, const Element*>

Definition at line 87 of file ClipStack_graphite.h.

Member Enumeration Documentation

ClipState

enum class skgpu::graphite::ClipStack::ClipState : uint8_t

strong

Enumerator
kEmpty
kWideOpen
kDeviceRect
kDeviceRRect
kComplex

Definition at line 34 of file ClipStack_graphite.h.

                         : uint8_t {
        kEmpty, kWideOpen, kDeviceRect, kDeviceRRect, kComplex
    };

Constructor & Destructor Documentation

ClipStack() [1/2]

skgpu::graphite::ClipStack::ClipStack

(

Device *

owningDevice

)

Definition at line 966 of file ClipStack_graphite.cpp.

        : fElements(kElementStackIncrement)
        , fSaves(kSaveStackIncrement)
        , fDevice(owningDevice) {
    // Start with a save record that is wide open
    fSaves.emplace_back(this->deviceBounds());
}

~ClipStack()

skgpu::graphite::ClipStack::~ClipStack ( )

default

ClipStack() [2/2]

skgpu::graphite::ClipStack::ClipStack ( const ClipStack &  )

delete

Member Function Documentation

begin()

ClipStack::ElementIter skgpu::graphite::ClipStack::begin ( ) const

inline

Definition at line 369 of file ClipStack_graphite.h.

                                            {
    if (this->currentSaveRecord().state() == ClipState::kEmpty ||
        this->currentSaveRecord().state() == ClipState::kWideOpen) {
        // No visible clip elements when empty or wide open
        return this->end();
    }
    int count = fElements.count() - this->currentSaveRecord().oldestElementIndex();
    return ElementIter(fElements.ritems().begin(), count);
}

clipShader()

void skgpu::graphite::ClipStack::clipShader

(

sk_sp< SkShader >

shader

)

Definition at line 1034 of file ClipStack_graphite.cpp.

                                                 {
    // Shaders can't bring additional coverage
    if (this->currentSaveRecord().state() == ClipState::kEmpty) {
        return;
    }
 
    bool wasDeferred;
    this->writableSaveRecord(&wasDeferred).addShader(std::move(shader));
    // Geometry elements are not invalidated by updating the clip shader
    // TODO(b/238763003): Integrating clipShader into graphite needs more thought, particularly how
    // to handle the shader explosion and where to put the effects in the GraphicsPipelineDesc.
    // One idea is to use sample locations and draw the clipShader into the depth buffer.
    // Another is resolve the clip shader into an alpha mask image that is sampled by the draw.
}

clipShape()

void skgpu::graphite::ClipStack::clipShape	(	const Transform &	localToDevice,
		const Shape &	shape,
		SkClipOp	op
	)

Definition at line 1049 of file ClipStack_graphite.cpp.

                                       {
    if (this->currentSaveRecord().state() == ClipState::kEmpty) {
        return;
    }
 
    // This will apply the transform if it's shape-type preserving, and clip the element's bounds
    // to the device bounds (NOT the conservative clip bounds, since those are based on the net
    // effect of all elements while device bounds clipping happens implicitly. During addElement,
    // we may still be able to invalidate some older elements).
    // NOTE: Does not try to simplify the shape type by inspecting the SkPath.
    RawElement element{this->deviceBounds(), localToDevice, shape, op};
 
    // An empty op means do nothing (for difference), or close the save record, so we try and detect
    // that early before doing additional unnecessary save record allocation.
    if (element.shape().isEmpty()) {
        if (element.op() == SkClipOp::kDifference) {
            // If the shape is empty and we're subtracting, this has no effect on the clip
            return;
        }
        // else we will make the clip empty, but we need a new save record to record that change
        // in the clip state; fall through to below and updateForElement() will handle it.
    }
 
    bool wasDeferred;
    SaveRecord& save = this->writableSaveRecord(&wasDeferred);
    SkDEBUGCODE(int elementCount = fElements.count();)
    if (!save.addElement(std::move(element), &fElements, fDevice)) {
        if (wasDeferred) {
            // We made a new save record, but ended up not adding an element to the stack.
            // So instead of keeping an empty save record around, pop it off and restore the counter
            SkASSERT(elementCount == fElements.count());
            fSaves.pop_back();
            fSaves.back().pushSave();
        }
    }
}

clipState()

ClipState skgpu::graphite::ClipStack::clipState ( ) const

inline

Definition at line 53 of file ClipStack_graphite.h.

{ return this->currentSaveRecord().state(); }

conservativeBounds()

Rect skgpu::graphite::ClipStack::conservativeBounds

(

)

const

Definition at line 1002 of file ClipStack_graphite.cpp.

                                         {
    const SaveRecord& current = this->currentSaveRecord();
    if (current.state() == ClipState::kEmpty) {
        return Rect::InfiniteInverted();
    } else if (current.state() == ClipState::kWideOpen) {
        return this->deviceBounds();
    } else {
        if (current.op() == SkClipOp::kDifference) {
            // The outer/inner bounds represent what's cut out, so full bounds remains the device
            // bounds, minus any fully clipped content that spans the device edge.
            return subtract(this->deviceBounds(), current.innerBounds(), /* exact */ true);
        } else {
            SkASSERT(this->deviceBounds().contains(current.outerBounds()));
            return current.outerBounds();
        }
    }
}

end()

ClipStack::ElementIter skgpu::graphite::ClipStack::end ( ) const

inline

Definition at line 379 of file ClipStack_graphite.h.

                                          {
    return ElementIter(fElements.ritems().end(), 0);
}

maxDeferredClipDraws()

int skgpu::graphite::ClipStack::maxDeferredClipDraws ( ) const

inline

Definition at line 54 of file ClipStack_graphite.h.

{ return fElements.count(); }

operator=()

ClipStack & skgpu::graphite::ClipStack::operator= ( const ClipStack &  )

delete

recordDeferredClipDraws()

void skgpu::graphite::ClipStack::recordDeferredClipDraws

(

)

Definition at line 1275 of file ClipStack_graphite.cpp.

                                        {
    for (auto& e : fElements.items()) {
        // When a Device requires all clip elements to be recorded, we have to iterate all elements,
        // and will draw clip shapes for elements that are still marked as invalid from the clip
        // stack, including those that are older than the current save record's oldest valid index,
        // because they could have accumulated draw usage prior to being invalidated, but weren't
        // flushed when they were invalidated because of an intervening save.
        e.drawClip(fDevice);
    }
}

restore()

void skgpu::graphite::ClipStack::restore

(

)

Definition at line 981 of file ClipStack_graphite.cpp.

                        {
    SkASSERT(!fSaves.empty());
    SaveRecord& current = fSaves.back();
    if (current.popSave()) {
        // This was just a deferred save being undone, so the record doesn't need to be removed yet
        return;
    }
 
    // When we remove a save record, we delete all elements >= its starting index and any masks
    // that were rasterized for it.
    current.removeElements(&fElements, fDevice);
 
    fSaves.pop_back();
    // Restore any remaining elements that were only invalidated by the now-removed save record.
    fSaves.back().restoreElements(&fElements);
}

save()

void skgpu::graphite::ClipStack::save

(

)

Definition at line 976 of file ClipStack_graphite.cpp.

                     {
    SkASSERT(!fSaves.empty());
    fSaves.back().pushSave();
}

updateClipStateForDraw()

CompressedPaintersOrder skgpu::graphite::ClipStack::updateClipStateForDraw	(	const Clip &	clip,
		const ElementList &	effectiveElements,
		const BoundsManager *	boundsManager,
		PaintersDepth	z
	)

Definition at line 1249 of file ClipStack_graphite.cpp.

                                                                           {
    if (clip.isClippedOut()) {
        return DrawOrder::kNoIntersection;
    }
 
    SkDEBUGCODE(const SaveRecord& cs = this->currentSaveRecord();)
    SkASSERT(cs.state() != ClipState::kEmpty);
 
    CompressedPaintersOrder maxClipOrder = DrawOrder::kNoIntersection;
    for (int i = 0; i < effectiveElements.size(); ++i) {
        // ClipStack owns the elements in the `clipState` so it's OK to downcast and cast away
        // const.
        // TODO: Enforce the ownership? In debug builds we could invalidate a `ClipStateForDraw` if
        // its element pointers become dangling and assert validity here.
        const RawElement* e = static_cast<const RawElement*>(effectiveElements[i]);
        CompressedPaintersOrder order =
                const_cast<RawElement*>(e)->updateForDraw(boundsManager, clip.drawBounds(), z);
        maxClipOrder = std::max(order, maxClipOrder);
    }
 
    return maxClipOrder;
}

visitClipStackForDraw()

Clip skgpu::graphite::ClipStack::visitClipStackForDraw	(	const Transform &	localToDevice,
		const Geometry &	geometry,
		const SkStrokeRec &	style,
		bool	outsetBoundsForAA,
		ClipStack::ElementList *	outEffectiveElements
	)		const

Definition at line 1088 of file ClipStack_graphite.cpp.

                                                                                        {
    static const Clip kClippedOut = {
            Rect::InfiniteInverted(), Rect::InfiniteInverted(), SkIRect::MakeEmpty(), nullptr};
 
    const SaveRecord& cs = this->currentSaveRecord();
    if (cs.state() == ClipState::kEmpty) {
        // We know the draw is clipped out so don't bother computing the base draw bounds.
        return kClippedOut;
    }
    // Compute draw bounds, clipped only to our device bounds since we need to return that even if
    // the clip stack is known to be wide-open.
    const Rect deviceBounds = this->deviceBounds();
 
    // When 'style' isn't fill, 'shape' describes the pre-stroke shape so we can't use it to check
    // against clip elements and so 'styledShape' will be set to the bounds post-stroking.
    SkTCopyOnFirstWrite<Shape> styledShape;
    if (geometry.isShape()) {
        styledShape.init(geometry.shape());
    } else {
        // The geometry is something special like text or vertices, in which case it's definitely
        // not a shape that could simplify cleanly with the clip stack.
        styledShape.initIfNeeded(geometry.bounds());
    }
 
    auto origSize = geometry.bounds().size();
    if (!SkIsFinite(origSize.x(), origSize.y())) {
        // Discard all non-finite geometry as if it were clipped out
        return kClippedOut;
    }
 
    // Inverse-filled shapes always fill the entire device (restricted to the clip).
    // Query the invertedness of the shape before any of the `setRect` calls below, which can
    // modify it.
    bool infiniteBounds = styledShape->inverted();
 
    // Discard fills and strokes that cannot produce any coverage: an empty fill, or a
    // zero-length stroke that has butt caps. Otherwise the stroke style applies to a vertical
    // or horizontal line (making it non-empty), or it's a zero-length path segment that
    // must produce round or square caps (making it non-empty):
    //     https://www.w3.org/TR/SVG11/implnote.html#PathElementImplementationNotes
    if (!infiniteBounds && (styledShape->isLine() || any(origSize == 0.f))) {
        if (style.isFillStyle() || (style.getCap() == SkPaint::kButt_Cap && all(origSize == 0.f))) {
            return kClippedOut;
        }
    }
 
    Rect transformedShapeBounds;
    bool shapeInDeviceSpace = false;
 
    // Some renderers make the drawn area larger than the geometry for anti-aliasing
    float rendererOutset = outsetBoundsForAA ? localToDevice.localAARadius(styledShape->bounds())
                                             : 0.f;
    if (!SkIsFinite(rendererOutset)) {
        transformedShapeBounds = deviceBounds;
        infiniteBounds = true;
    } else {
        // Will be in device space once style/AA outsets and the localToDevice transform are
        // applied.
        transformedShapeBounds = styledShape->bounds();
 
        // Regular filled shapes and strokes get larger based on style and transform
        if (!style.isHairlineStyle() || rendererOutset != 0.0f) {
            float localStyleOutset = style.getInflationRadius() + rendererOutset;
            transformedShapeBounds.outset(localStyleOutset);
 
            if (!style.isFillStyle() || rendererOutset != 0.0f) {
                // While this loses any shape type, the bounds remain local so hopefully tests are
                // fairly accurate.
                styledShape.writable()->setRect(transformedShapeBounds);
            }
        }
 
        transformedShapeBounds = localToDevice.mapRect(transformedShapeBounds);
 
        // Hairlines get an extra pixel *after* transforming to device space, unless the renderer
        // has already defined an outset
        if (style.isHairlineStyle() && rendererOutset == 0.0f) {
            transformedShapeBounds.outset(0.5f);
            // and the associated transform must be kIdentity since the bounds have been mapped by
            // localToDevice already.
            styledShape.writable()->setRect(transformedShapeBounds);
            shapeInDeviceSpace = true;
        }
 
        // Restrict bounds to the device limits.
        transformedShapeBounds.intersect(deviceBounds);
    }
 
    Rect drawBounds;  // defined in device space
    if (infiniteBounds) {
        drawBounds = deviceBounds;
        styledShape.writable()->setRect(drawBounds);
        shapeInDeviceSpace = true;
    } else {
        drawBounds = transformedShapeBounds;
    }
 
    if (drawBounds.isEmptyNegativeOrNaN() || cs.state() == ClipState::kWideOpen) {
        // Either the draw is off screen, so it's clipped out regardless of the state of the
        // SaveRecord, or there are no elements to apply to the draw. In both cases, 'drawBounds'
        // has the correct value, the scissor is the device bounds (ignored if clipped-out).
        return Clip(drawBounds, transformedShapeBounds, deviceBounds.asSkIRect(), cs.shader());
    }
 
    // We don't evaluate Simplify() on the SaveRecord and the draw because a reduced version of
    // Simplify is effectively performed in computing the scissor rect.
    // Given that, we can skip iterating over the clip elements when:
    //  - the draw's *scissored* bounds are empty, which happens when the draw was clipped out.
    //  - the scissored bounds are contained in our inner bounds, which happens if all we need to
    //    apply to the draw is the computed scissor rect.
    // TODO: The Clip's scissor is defined in terms of integer pixel coords, but if we move to
    // clip plane distances in the vertex shader, it can be defined in terms of the original float
    // coordinates.
    Rect scissor = cs.scissor(deviceBounds, drawBounds).makeRoundOut();
    drawBounds.intersect(scissor);
    transformedShapeBounds.intersect(scissor);
    if (drawBounds.isEmptyNegativeOrNaN() || cs.innerBounds().contains(drawBounds)) {
        // Like above, in both cases drawBounds holds the right value.
        return Clip(drawBounds, transformedShapeBounds, scissor.asSkIRect(), cs.shader());
    }
 
    // If we made it here, the clip stack affects the draw in a complex way so iterate each element.
    // A draw is a transformed shape that "intersects" the clip. We use empty inner bounds because
    // there's currently no way to re-write the draw as the clip's geometry, so there's no need to
    // check if the draw contains the clip (vice versa is still checked and represents an unclipped
    // draw so is very useful to identify).
    TransformedShape draw{shapeInDeviceSpace ? kIdentity : localToDevice,
                          *styledShape,
                          /*outerBounds=*/drawBounds,
                          /*innerBounds=*/Rect::InfiniteInverted(),
                          /*op=*/SkClipOp::kIntersect,
                          /*containsChecksOnlyBounds=*/true};
 
    SkASSERT(outEffectiveElements);
    SkASSERT(outEffectiveElements->empty());
    int i = fElements.count();
    for (const RawElement& e : fElements.ritems()) {
        --i;
        if (i < cs.oldestElementIndex()) {
            // All earlier elements have been invalidated by elements already processed so the draw
            // can't be affected by them and cannot contribute to their usage bounds.
            break;
        }
 
        auto influence = e.testForDraw(draw);
        if (influence == RawElement::DrawInfluence::kClipOut) {
            outEffectiveElements->clear();
            return kClippedOut;
        }
        if (influence == RawElement::DrawInfluence::kIntersect) {
            outEffectiveElements->push_back(&e);
        }
    }
 
    return Clip(drawBounds, transformedShapeBounds, scissor.asSkIRect(), cs.shader());
}

---

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

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