skgpu::graphite::IntersectionTree::LeafNode Class Reference

Inherits skgpu::graphite::IntersectionTree::Node.

Public Member Functions
	LeafNode ()
void	popAll ()
bool	intersects (Rect rect) override
Node *	addNonIntersecting (Rect rect, SkArenaAlloc *arena) override

Static Public Attributes
static constexpr int	kMaxRectsInList = 64

Detailed Description

Definition at line 61 of file IntersectionTree.cpp.

Constructor & Destructor Documentation

LeafNode()

skgpu::graphite::IntersectionTree::LeafNode::LeafNode ( )

inline

Definition at line 67 of file IntersectionTree.cpp.

               {
        this->popAll();
        // Initialize our arrays with maximally negative rects. These have the advantage of always
        // failing intersection tests, thus allowing us to test for intersection beyond fNumRects
        // without failing.
        constexpr static float infinity = std::numeric_limits<float>::infinity();
        std::fill_n(fLefts, kMaxRectsInList, infinity);
        std::fill_n(fTops, kMaxRectsInList, infinity);
        std::fill_n(fNegRights, kMaxRectsInList, infinity);
        std::fill_n(fNegBots, kMaxRectsInList, infinity);
    }

Member Function Documentation

addNonIntersecting()

Node * skgpu::graphite::IntersectionTree::LeafNode::addNonIntersecting ( Rect  rect, SkArenaAlloc *  arena  )

inlineoverride

Definition at line 110 of file IntersectionTree.cpp.

                                                                      {
        if (fNumRects == kMaxRectsInList) {
            // The new rect doesn't fit. Split our rect list first and then add.
            return this->split(arena)->addNonIntersecting(rect, arena);
        }
        this->appendToList(rect);
        return this;
    }

intersects()

bool skgpu::graphite::IntersectionTree::LeafNode::intersects ( Rect  rect )

inlineoverride

Definition at line 88 of file IntersectionTree.cpp.

                                        {
        // Test for intersection in sets of 4. Since all the data in our rect arrays is either
        // maximally negative, or valid from somewhere else in the tree, we can test beyond
        // fNumRects without failing.
        static_assert(kMaxRectsInList % 4 == 0);
        SkASSERT(fNumRects <= kMaxRectsInList);
        auto comp = Rect::ComplementRect(rect).fVals;
        for (int i = 0; i < fNumRects; i += 4) {
            auto l = skvx::float4::Load(fLefts + i);
            auto t = skvx::float4::Load(fTops + i);
            auto nr = skvx::float4::Load(fNegRights + i);
            auto nb = skvx::float4::Load(fNegBots + i);
            if (any((l < comp[0]) &
                    (t < comp[1]) &
                    (nr < comp[2]) &
                    (nb < comp[3]))) {
                return true;
            }
        }
        return false;
    }

popAll()

void skgpu::graphite::IntersectionTree::LeafNode::popAll ( )

inline

Definition at line 79 of file IntersectionTree.cpp.

                  {
        fNumRects = 0;
        fSplittableBounds = -std::numeric_limits<float>::infinity();
        fRectValsSum = 0;
        // Leave the rect arrays untouched. Since we know they are either already valid in the tree,
        // or else maximally negative, this allows the future list to check for intersection beyond
        // fNumRects without failing.
    }

Member Data Documentation

kMaxRectsInList

constexpr int skgpu::graphite::IntersectionTree::LeafNode::kMaxRectsInList = 64

staticconstexpr

Definition at line 65 of file IntersectionTree.cpp.

---

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

• third_party/skia/src/gpu/graphite/geom/IntersectionTree.cpp