skgpu::graphite::ClipStack::TransformedShape Struct Reference

Public Member Functions
bool	intersects (const TransformedShape &) const
bool	contains (const TransformedShape &) const

Public Attributes
const Transform &	fLocalToDevice
const Shape &	fShape
const Rect &	fOuterBounds
const Rect &	fInnerBounds
SkClipOp	fOp
bool	fContainsChecksOnlyBounds = false

Detailed Description

Definition at line 94 of file ClipStack_graphite.cpp.

Member Function Documentation

contains()

bool skgpu::graphite::ClipStack::TransformedShape::contains

(

const TransformedShape &

o

)

const

Definition at line 146 of file ClipStack_graphite.cpp.

                                                                        {
    if (fInnerBounds.contains(o.fOuterBounds)) {
        return true;
    }
    // Skip more expensive contains() checks if configured not to, or if the extent of 'o' exceeds
    // this shape's outer bounds. When that happens there must be some part of 'o' that cannot be
    // contained in this shape.
    if (fContainsChecksOnlyBounds || !fOuterBounds.contains(o.fOuterBounds)) {
        return false;
    }
 
    if (fContainsChecksOnlyBounds) {
        return false; // don't do any more work
    }
 
    if (fLocalToDevice == o.fLocalToDevice) {
        // Test the shapes directly against each other, with a special check for a rrect+rrect
        // containment (a intersect b == a implies b contains a) and paths (same gen ID, or same
        // path for small paths means they contain each other).
        static constexpr int kMaxPathComparePoints = 16;
        if (fShape.isRRect() && o.fShape.isRRect()) {
            return SkRRectPriv::ConservativeIntersect(fShape.rrect(), o.fShape.rrect())
                    == o.fShape.rrect();
        } else if (fShape.isPath() && o.fShape.isPath()) {
            // TODO: Is this worth doing still if clips only cost as much as a single draw?
            return (fShape.path().getGenerationID() == o.fShape.path().getGenerationID()) ||
                    (fShape.path().countPoints() <= kMaxPathComparePoints &&
                    fShape.path() == o.fShape.path());
        } else {
            return fShape.conservativeContains(o.fShape.bounds());
        }
    } else if (fLocalToDevice.type() <= Transform::Type::kRectStaysRect &&
               o.fLocalToDevice.type() <= Transform::Type::kRectStaysRect) {
        // Optimize the common case where o's bounds can be mapped tightly into this coordinate
        // space and then tested against our shape.
        Rect localBounds = fLocalToDevice.inverseMapRect(
                o.fLocalToDevice.mapRect(o.fShape.bounds()));
        return fShape.conservativeContains(localBounds);
    } else if (fShape.convex()) {
        // Since this shape is convex, if all four corners of o's bounding box are inside it
        // then the entirety of o is also guaranteed to be inside it.
        SkV4 deviceQuad[4];
        o.fLocalToDevice.mapPoints(o.fShape.bounds(), deviceQuad);
        SkV4 localQuad[4];
        fLocalToDevice.inverseMapPoints(deviceQuad, localQuad, 4);
        for (int i = 0; i < 4; ++i) {
            // TODO: Would be nice to make this consistent with how the GPU clips NDC w.
            if (deviceQuad[i].w < SkPathPriv::kW0PlaneDistance ||
                localQuad[i].w < SkPathPriv::kW0PlaneDistance) {
                // Something in O actually projects behind the W = 0 plane and would be clipped
                // to infinity, so it's extremely unlikely that this contains O.
                return false;
            }
            if (!fShape.conservativeContains(skvx::float2::Load(localQuad + i) / localQuad[i].w)) {
                return false;
            }
        }
        return true;
    }
 
    // Else not an easily comparable pair of shapes so assume this doesn't contain O
    return false;
}

intersects()

bool skgpu::graphite::ClipStack::TransformedShape::intersects

(

const TransformedShape &

o

)

const

Definition at line 113 of file ClipStack_graphite.cpp.

                                                                          {
    if (!fOuterBounds.intersects(o.fOuterBounds)) {
        return false;
    }
 
    if (fLocalToDevice.type() <= Transform::Type::kRectStaysRect &&
        o.fLocalToDevice.type() <= Transform::Type::kRectStaysRect) {
        // The two shape's coordinate spaces are different but both rect-stays-rect or simpler.
        // This means, though, that their outer bounds approximations are tight to their transormed
        // shape bounds. There's no point to do further tests given that and that we already found
        // that these outer bounds *do* intersect.
        return true;
    } else if (fLocalToDevice == o.fLocalToDevice) {
        // Since the two shape's local coordinate spaces are the same, we can compare shape
        // bounds directly for a more accurate intersection test. We intentionally do not go
        // further and do shape-specific intersection tests since these could have unknown
        // complexity (for paths) and limited utility (e.g. two round rects that are disjoint
        // solely from their corner curves).
        return fShape.bounds().intersects(o.fShape.bounds());
    } else if (fLocalToDevice.type() != Transform::Type::kPerspective &&
               o.fLocalToDevice.type() != Transform::Type::kPerspective) {
        // The shapes don't share the same coordinate system, and their approximate 'outer'
        // bounds in device space could have substantial outsetting to contain the transformed
        // shape (e.g. 45 degree rotation). Perform a more detailed check on their oriented
        // bounding boxes.
        return oriented_bbox_intersection(fShape.bounds(), fLocalToDevice,
                                          o.fShape.bounds(), o.fLocalToDevice);
    }
    // Else multiple perspective transforms are involved, so assume intersection and allow the
    // rasterizer to handle perspective clipping.
    return true;
}

Member Data Documentation

fContainsChecksOnlyBounds

bool skgpu::graphite::ClipStack::TransformedShape::fContainsChecksOnlyBounds = false

Definition at line 107 of file ClipStack_graphite.cpp.

fInnerBounds

const Rect& skgpu::graphite::ClipStack::TransformedShape::fInnerBounds

Definition at line 98 of file ClipStack_graphite.cpp.

fLocalToDevice

const Transform& skgpu::graphite::ClipStack::TransformedShape::fLocalToDevice

Definition at line 95 of file ClipStack_graphite.cpp.

fOp

SkClipOp skgpu::graphite::ClipStack::TransformedShape::fOp

Definition at line 100 of file ClipStack_graphite.cpp.

fOuterBounds

const Rect& skgpu::graphite::ClipStack::TransformedShape::fOuterBounds

Definition at line 97 of file ClipStack_graphite.cpp.

fShape

const Shape& skgpu::graphite::ClipStack::TransformedShape::fShape

Definition at line 96 of file ClipStack_graphite.cpp.

---

The documentation for this struct was generated from the following file:

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