/* | |

* Copyright 2018 Google Inc. | |

* | |

* Use of this source code is governed by a BSD-style license that can be | |

* found in the LICENSE file. | |

*/ | |

#ifndef SkRectPriv_DEFINED | |

#define SkRectPriv_DEFINED | |

#include "include/core/SkRect.h" | |

#include "src/base/SkMathPriv.h" | |

#include "src/base/SkVx.h" | |

class SkM44; | |

class SkMatrix; | |

class SkRectPriv { | |

public: | |

// Returns an irect that is very large, and can be safely round-trip with SkRect and still | |

// be considered non-empty (i.e. width/height > 0) even if we round-out the SkRect. | |

static SkIRect MakeILarge() { | |

// 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 }; | |

} | |

static SkIRect MakeILargestInverted() { | |

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

} | |

static SkRect MakeLargeS32() { | |

SkRect r; | |

r.set(MakeILarge()); | |

return r; | |

} | |

static SkRect MakeLargest() { | |

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

} | |

static constexpr SkRect MakeLargestInverted() { | |

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

} | |

static void GrowToInclude(SkRect* r, const SkPoint& pt) { | |

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); | |

} | |

// Conservative check if r can be expressed in fixed-point. | |

// Will return false for very large values that might have fit | |

static bool FitsInFixed(const SkRect& r) { | |

return SkFitsInFixed(r.fLeft) && SkFitsInFixed(r.fTop) && | |

SkFitsInFixed(r.fRight) && SkFitsInFixed(r.fBottom); | |

} | |

// Returns r.width()/2 but divides first to avoid width() overflowing. | |

static constexpr float HalfWidth(const SkRect& r) { | |

return sk_float_midpoint(-r.fLeft, r.fRight); | |

} | |

// Returns r.height()/2 but divides first to avoid height() overflowing. | |

static constexpr float HalfHeight(const SkRect& r) { | |

return sk_float_midpoint(-r.fTop, r.fBottom); | |

} | |

// Evaluate A-B. If the difference shape cannot be represented as a rectangle then false is | |

// returned and 'out' is set to the largest rectangle contained in said shape. If true is | |

// returned then A-B is representable as a rectangle, which is stored in 'out'. | |

static bool Subtract(const SkRect& a, const SkRect& b, SkRect* out); | |

static bool Subtract(const SkIRect& a, const SkIRect& b, SkIRect* out); | |

// Evaluate A-B, and return the largest rectangle contained in that shape (since the difference | |

// may not be representable as rectangle). The returned rectangle will not intersect B. | |

static SkRect Subtract(const SkRect& a, const SkRect& b) { | |

SkRect diff; | |

Subtract(a, b, &diff); | |

return diff; | |

} | |

static SkIRect Subtract(const SkIRect& a, const SkIRect& b) { | |

SkIRect diff; | |

Subtract(a, b, &diff); | |

return diff; | |

} | |

// Returns true if the quadrilateral formed by transforming the four corners of 'a' contains 'b' | |

// 'tol' is in the same coordinate space as 'b', to treat 'b' as 'tol' units inset. | |

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); | |

// Like QuadContainsRect() but returns the edge test masks ordered T, R, B, L. | |

static skvx::int4 QuadContainsRectMask(const SkM44& m, const SkRect& a, const SkRect& b, | |

float tol=0.f); | |

// Assuming 'src' does not intersect 'dst', returns the edge or corner of 'src' that is closest | |

// to 'dst', e.g. the pixels that would be sampled from 'src' when clamp-tiled into 'dst'. | |

// | |

// The returned rectangle will not be empty if 'src' is not empty and 'dst' is not empty. | |

// At least one of its width or height will be equal to 1 (possibly both if a corner is closest) | |

// | |

// Returns src.intersect(dst) if they do actually intersect. | |

static SkIRect ClosestDisjointEdge(const SkIRect& src, const SkIRect& dst); | |

}; | |

#endif |