SkRectPriv Class Reference

#include <SkRectPriv.h>

Static Public Member Functions
static SkIRect	MakeILarge ()
static SkIRect	MakeILargestInverted ()
static SkRect	MakeLargeS32 ()
static SkRect	MakeLargest ()
static constexpr SkRect	MakeLargestInverted ()
static void	GrowToInclude (SkRect *r, const SkPoint &pt)
static bool	FitsInFixed (const SkRect &r)
static constexpr float	HalfWidth (const SkRect &r)
static constexpr float	HalfHeight (const SkRect &r)
static bool	Subtract (const SkRect &a, const SkRect &b, SkRect *out)
static bool	Subtract (const SkIRect &a, const SkIRect &b, SkIRect *out)
static SkRect	Subtract (const SkRect &a, const SkRect &b)
static SkIRect	Subtract (const SkIRect &a, const SkIRect &b)
static bool	QuadContainsRect (const SkMatrix &m, const SkIRect &a, const SkIRect &b, float tol=0.f)
static bool	QuadContainsRect (const SkM44 &m, const SkRect &a, const SkRect &b, float tol=0.f)
static skvx::int4	QuadContainsRectMask (const SkM44 &m, const SkRect &a, const SkRect &b, float tol=0.f)
static SkIRect	ClosestDisjointEdge (const SkIRect &src, const SkIRect &dst)

Detailed Description

Definition at line 18 of file SkRectPriv.h.

Member Function Documentation

ClosestDisjointEdge()

SkIRect SkRectPriv::ClosestDisjointEdge ( const SkIRect &  src, const SkIRect &  dst  )

static

Definition at line 323 of file SkRect.cpp.

                                                                              {
    if (src.isEmpty() || dst.isEmpty()) {
        return SkIRect::MakeEmpty();
    }
 
    int l = src.fLeft;
    int r = src.fRight;
    if (r <= dst.fLeft) {
        // Select right column of pixels in crop
        l = r - 1;
    } else if (l >= dst.fRight) {
        // Left column of 'crop'
        r = l + 1;
    } else {
        // Regular intersection along X axis.
        l = SkTPin(l, dst.fLeft, dst.fRight);
        r = SkTPin(r, dst.fLeft, dst.fRight);
    }
 
    int t = src.fTop;
    int b = src.fBottom;
    if (b <= dst.fTop) {
        // Select bottom row of pixels in crop
        t = b - 1;
    } else if (t >= dst.fBottom) {
        // Top row of 'crop'
        b = t + 1;
    } else {
        t = SkTPin(t, dst.fTop, dst.fBottom);
        b = SkTPin(b, dst.fTop, dst.fBottom);
    }
 
    return SkIRect::MakeLTRB(l,t,r,b);
}

FitsInFixed()

static bool SkRectPriv::FitsInFixed ( const SkRect &  r )

inlinestatic

Definition at line 56 of file SkRectPriv.h.

                                             {
        return SkFitsInFixed(r.fLeft) && SkFitsInFixed(r.fTop) &&
               SkFitsInFixed(r.fRight) && SkFitsInFixed(r.fBottom);
    }

GrowToInclude()

static void SkRectPriv::GrowToInclude ( SkRect *  r, const SkPoint &  pt  )

inlinestatic

Definition at line 47 of file SkRectPriv.h.

                                                            {
        r->fLeft  =  std::min(pt.fX, r->fLeft);
        r->fRight =  std::max(pt.fX, r->fRight);
        r->fTop    = std::min(pt.fY, r->fTop);
        r->fBottom = std::max(pt.fY, r->fBottom);
    }

HalfHeight()

static constexpr float SkRectPriv::HalfHeight ( const SkRect &  r )

inlinestaticconstexpr

Definition at line 66 of file SkRectPriv.h.

                                                       {
        return sk_float_midpoint(-r.fTop, r.fBottom);
    }

HalfWidth()

static constexpr float SkRectPriv::HalfWidth ( const SkRect &  r )

inlinestaticconstexpr

Definition at line 62 of file SkRectPriv.h.

                                                      {
        return sk_float_midpoint(-r.fLeft, r.fRight);
    }

MakeILarge()

static SkIRect SkRectPriv::MakeILarge ( )

inlinestatic

Definition at line 22 of file SkRectPriv.h.

                                {
        // SK_MaxS32 >> 1 seemed better, but it did not survive round-trip with SkRect and rounding.
        // Also, 1 << 29 can be perfectly represented in float, while SK_MaxS32 >> 1 cannot.
        const int32_t large = 1 << 29;
        return { -large, -large, large, large };
    }

MakeILargestInverted()

static SkIRect SkRectPriv::MakeILargestInverted ( )

inlinestatic

Definition at line 29 of file SkRectPriv.h.

                                          {
        return { SK_MaxS32, SK_MaxS32, SK_MinS32, SK_MinS32 };
    }

MakeLargeS32()

static SkRect SkRectPriv::MakeLargeS32 ( )

inlinestatic

Definition at line 33 of file SkRectPriv.h.

                                 {
        SkRect r;
        r.set(MakeILarge());
        return r;
    }

MakeLargest()

static SkRect SkRectPriv::MakeLargest ( )

inlinestatic

Definition at line 39 of file SkRectPriv.h.

                                {
        return { SK_ScalarMin, SK_ScalarMin, SK_ScalarMax, SK_ScalarMax };
    }

MakeLargestInverted()

static constexpr SkRect SkRectPriv::MakeLargestInverted ( )

inlinestaticconstexpr

Definition at line 43 of file SkRectPriv.h.

                                                  {
        return { SK_ScalarMax, SK_ScalarMax, SK_ScalarMin, SK_ScalarMin };
    }

QuadContainsRect() [1/2]

bool SkRectPriv::QuadContainsRect ( const SkM44 &  m, const SkRect &  a, const SkRect &  b, float  tol = 0.f  )

static

Definition at line 268 of file SkRect.cpp.

                                                                                             {
    return all(QuadContainsRectMask(m, a, b, tol));
}

QuadContainsRect() [2/2]

bool SkRectPriv::QuadContainsRect ( const SkMatrix &  m, const SkIRect &  a, const SkIRect &  b, float  tol = 0.f  )

static

Definition at line 261 of file SkRect.cpp.

                                             {
    return QuadContainsRect(SkM44(m), SkRect::Make(a), SkRect::Make(b), tol);
}

QuadContainsRectMask()

skvx::int4 SkRectPriv::QuadContainsRectMask ( const SkM44 &  m, const SkRect &  a, const SkRect &  b, float  tol = 0.f  )

static

Definition at line 272 of file SkRect.cpp.

                                                       {
    SkDEBUGCODE(SkM44 inverse;)
    SkASSERT(m.invert(&inverse));
    // With empty rectangles, the calculated edges could give surprising results. If 'a' were not
    // sorted, its normals would point outside the sorted rectangle, so lots of potential rects
    // would be seen as "contained". If 'a' is all 0s, its edge equations are also (0,0,0) so every
    // point has a distance of 0, and would be interpreted as inside.
    if (a.isEmpty()) {
        return skvx::int4(0); // all "false"
    }
    // However, 'b' is only used to define its 4 corners to check against the transformed edges.
    // This is valid regardless of b's emptiness or sortedness.
 
    // Calculate the 4 homogenous coordinates of 'a' transformed by 'm' where Z=0 and W=1.
    auto ax = skvx::float4{a.fLeft, a.fRight, a.fRight, a.fLeft};
    auto ay = skvx::float4{a.fTop, a.fTop, a.fBottom, a.fBottom};
 
    auto max = m.rc(0,0)*ax + m.rc(0,1)*ay + m.rc(0,3);
    auto may = m.rc(1,0)*ax + m.rc(1,1)*ay + m.rc(1,3);
    auto maw = m.rc(3,0)*ax + m.rc(3,1)*ay + m.rc(3,3);
 
    if (all(maw < 0.f)) {
        // If all points of A are mapped to w < 0, then the edge equations end up representing the
        // convex hull of projected points when A should in fact be considered empty.
        return skvx::int4(0); // all "false"
    }
 
    // Cross product of adjacent vertices provides homogenous lines for the 4 sides of the quad
    auto lA = may*skvx::shuffle<1,2,3,0>(maw) - maw*skvx::shuffle<1,2,3,0>(may);
    auto lB = maw*skvx::shuffle<1,2,3,0>(max) - max*skvx::shuffle<1,2,3,0>(maw);
    auto lC = max*skvx::shuffle<1,2,3,0>(may) - may*skvx::shuffle<1,2,3,0>(max);
 
    // Before transforming, the corners of 'a' were in CW order, but afterwards they may become CCW,
    // so the sign corrects the direction of the edge normals to point inwards.
    float sign = (lA[0]*lB[1] - lB[0]*lA[1]) < 0 ? -1.f : 1.f;
 
    // Calculate distance from 'b' to each edge. Since 'b' has presumably been transformed by 'm'
    // *and* projected, this assumes W = 1.
    SkRect bInset = b.makeInset(tol, tol);
    auto d0 = sign * (lA*bInset.fLeft  + lB*bInset.fTop    + lC);
    auto d1 = sign * (lA*bInset.fRight + lB*bInset.fTop    + lC);
    auto d2 = sign * (lA*bInset.fRight + lB*bInset.fBottom + lC);
    auto d3 = sign * (lA*bInset.fLeft  + lB*bInset.fBottom + lC);
 
    // 'b' is contained in the mapped rectangle if all distances are >= 0
    return (d0 >= 0.f) & (d1 >= 0.f) & (d2 >= 0.f) & (d3 >= 0.f);
}

Subtract() [1/4]

static SkIRect SkRectPriv::Subtract ( const SkIRect &  a, const SkIRect &  b  )

inlinestatic

Definition at line 83 of file SkRectPriv.h.

                                                                {
        SkIRect diff;
        Subtract(a, b, &diff);
        return diff;
    }

Subtract() [2/4]

bool SkRectPriv::Subtract ( const SkIRect &  a, const SkIRect &  b, SkIRect *  out  )

static

Definition at line 256 of file SkRect.cpp.

                                                                          {
    return subtract<SkIRect>(a, b, out);
}

Subtract() [3/4]

static SkRect SkRectPriv::Subtract ( const SkRect &  a, const SkRect &  b  )

inlinestatic

Definition at line 78 of file SkRectPriv.h.

                                                             {
        SkRect diff;
        Subtract(a, b, &diff);
        return diff;
    }

Subtract() [4/4]

bool SkRectPriv::Subtract ( const SkRect &  a, const SkRect &  b, SkRect *  out  )

static

Definition at line 252 of file SkRect.cpp.

                                                                       {
    return subtract<SkRect>(a, b, out);
}

---

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

• third_party/skia/src/core/SkRectPriv.h
• third_party/skia/src/core/SkRect.cpp