Flutter Engine
The Flutter Engine
SkRect.h
Go to the documentation of this file.
1/*
2 * Copyright 2006 The Android Open Source Project
3 *
4 * Use of this source code is governed by a BSD-style license that can be
5 * found in the LICENSE file.
6 */
7
8#ifndef SkRect_DEFINED
9#define SkRect_DEFINED
10
12#include "include/core/SkSize.h"
17
18#include <algorithm>
19#include <cmath>
20#include <cstdint>
21#include <cstring>
22
23struct SkRect;
24
25/** \struct SkIRect
26 SkIRect holds four 32-bit integer coordinates describing the upper and
27 lower bounds of a rectangle. SkIRect may be created from outer bounds or
28 from position, width, and height. SkIRect describes an area; if its right
29 is less than or equal to its left, or if its bottom is less than or equal to
30 its top, it is considered empty.
31*/
33 int32_t fLeft = 0; //!< smaller x-axis bounds
34 int32_t fTop = 0; //!< smaller y-axis bounds
35 int32_t fRight = 0; //!< larger x-axis bounds
36 int32_t fBottom = 0; //!< larger y-axis bounds
37
38 /** Returns constructed SkIRect set to (0, 0, 0, 0).
39 Many other rectangles are empty; if left is equal to or greater than right,
40 or if top is equal to or greater than bottom. Setting all members to zero
41 is a convenience, but does not designate a special empty rectangle.
42
43 @return bounds (0, 0, 0, 0)
44 */
45 [[nodiscard]] static constexpr SkIRect MakeEmpty() {
46 return SkIRect{0, 0, 0, 0};
47 }
48
49 /** Returns constructed SkIRect set to (0, 0, w, h). Does not validate input; w or h
50 may be negative.
51
52 @param w width of constructed SkIRect
53 @param h height of constructed SkIRect
54 @return bounds (0, 0, w, h)
55 */
56 [[nodiscard]] static constexpr SkIRect MakeWH(int32_t w, int32_t h) {
57 return SkIRect{0, 0, w, h};
58 }
59
60 /** Returns constructed SkIRect set to (0, 0, size.width(), size.height()).
61 Does not validate input; size.width() or size.height() may be negative.
62
63 @param size values for SkIRect width and height
64 @return bounds (0, 0, size.width(), size.height())
65 */
66 [[nodiscard]] static constexpr SkIRect MakeSize(const SkISize& size) {
67 return SkIRect{0, 0, size.fWidth, size.fHeight};
68 }
69
70 /** Returns constructed SkIRect set to (pt.x(), pt.y(), pt.x() + size.width(),
71 pt.y() + size.height()). Does not validate input; size.width() or size.height() may be
72 negative.
73
74 @param pt values for SkIRect fLeft and fTop
75 @param size values for SkIRect width and height
76 @return bounds at pt with width and height of size
77 */
78 [[nodiscard]] static constexpr SkIRect MakePtSize(SkIPoint pt, SkISize size) {
79 return MakeXYWH(pt.x(), pt.y(), size.width(), size.height());
80 }
81
82 /** Returns constructed SkIRect set to (l, t, r, b). Does not sort input; SkIRect may
83 result in fLeft greater than fRight, or fTop greater than fBottom.
84
85 @param l integer stored in fLeft
86 @param t integer stored in fTop
87 @param r integer stored in fRight
88 @param b integer stored in fBottom
89 @return bounds (l, t, r, b)
90 */
91 [[nodiscard]] static constexpr SkIRect MakeLTRB(int32_t l, int32_t t, int32_t r, int32_t b) {
92 return SkIRect{l, t, r, b};
93 }
94
95 /** Returns constructed SkIRect set to: (x, y, x + w, y + h).
96 Does not validate input; w or h may be negative.
97
98 @param x stored in fLeft
99 @param y stored in fTop
100 @param w added to x and stored in fRight
101 @param h added to y and stored in fBottom
102 @return bounds at (x, y) with width w and height h
103 */
104 [[nodiscard]] static constexpr SkIRect MakeXYWH(int32_t x, int32_t y, int32_t w, int32_t h) {
105 return { x, y, Sk32_sat_add(x, w), Sk32_sat_add(y, h) };
106 }
107
108 /** Returns left edge of SkIRect, if sorted.
109 Call sort() to reverse fLeft and fRight if needed.
110
111 @return fLeft
112 */
113 constexpr int32_t left() const { return fLeft; }
114
115 /** Returns top edge of SkIRect, if sorted. Call isEmpty() to see if SkIRect may be invalid,
116 and sort() to reverse fTop and fBottom if needed.
117
118 @return fTop
119 */
120 constexpr int32_t top() const { return fTop; }
121
122 /** Returns right edge of SkIRect, if sorted.
123 Call sort() to reverse fLeft and fRight if needed.
124
125 @return fRight
126 */
127 constexpr int32_t right() const { return fRight; }
128
129 /** Returns bottom edge of SkIRect, if sorted. Call isEmpty() to see if SkIRect may be invalid,
130 and sort() to reverse fTop and fBottom if needed.
131
132 @return fBottom
133 */
134 constexpr int32_t bottom() const { return fBottom; }
135
136 /** Returns left edge of SkIRect, if sorted. Call isEmpty() to see if SkIRect may be invalid,
137 and sort() to reverse fLeft and fRight if needed.
138
139 @return fLeft
140 */
141 constexpr int32_t x() const { return fLeft; }
142
143 /** Returns top edge of SkIRect, if sorted. Call isEmpty() to see if SkIRect may be invalid,
144 and sort() to reverse fTop and fBottom if needed.
145
146 @return fTop
147 */
148 constexpr int32_t y() const { return fTop; }
149
150 // Experimental
151 constexpr SkIPoint topLeft() const { return {fLeft, fTop}; }
152
153 /** Returns span on the x-axis. This does not check if SkIRect is sorted, or if
154 result fits in 32-bit signed integer; result may be negative.
155
156 @return fRight minus fLeft
157 */
158 constexpr int32_t width() const { return Sk32_can_overflow_sub(fRight, fLeft); }
159
160 /** Returns span on the y-axis. This does not check if SkIRect is sorted, or if
161 result fits in 32-bit signed integer; result may be negative.
162
163 @return fBottom minus fTop
164 */
165 constexpr int32_t height() const { return Sk32_can_overflow_sub(fBottom, fTop); }
166
167 /** Returns spans on the x-axis and y-axis. This does not check if SkIRect is sorted,
168 or if result fits in 32-bit signed integer; result may be negative.
169
170 @return SkISize (width, height)
171 */
172 constexpr SkISize size() const { return SkISize::Make(this->width(), this->height()); }
173
174 /** Returns span on the x-axis. This does not check if SkIRect is sorted, so the
175 result may be negative. This is safer than calling width() since width() might
176 overflow in its calculation.
177
178 @return fRight minus fLeft cast to int64_t
179 */
180 constexpr int64_t width64() const { return (int64_t)fRight - (int64_t)fLeft; }
181
182 /** Returns span on the y-axis. This does not check if SkIRect is sorted, so the
183 result may be negative. This is safer than calling height() since height() might
184 overflow in its calculation.
185
186 @return fBottom minus fTop cast to int64_t
187 */
188 constexpr int64_t height64() const { return (int64_t)fBottom - (int64_t)fTop; }
189
190 /** Returns true if fLeft is equal to or greater than fRight, or if fTop is equal
191 to or greater than fBottom. Call sort() to reverse rectangles with negative
192 width64() or height64().
193
194 @return true if width64() or height64() are zero or negative
195 */
196 bool isEmpty64() const { return fRight <= fLeft || fBottom <= fTop; }
197
198 /** Returns true if width() or height() are zero or negative.
199
200 @return true if width() or height() are zero or negative
201 */
202 bool isEmpty() const {
203 int64_t w = this->width64();
204 int64_t h = this->height64();
205 if (w <= 0 || h <= 0) {
206 return true;
207 }
208 // Return true if either exceeds int32_t
209 return !SkTFitsIn<int32_t>(w | h);
210 }
211
212 /** Returns true if all members in a: fLeft, fTop, fRight, and fBottom; are
213 identical to corresponding members in b.
214
215 @param a SkIRect to compare
216 @param b SkIRect to compare
217 @return true if members are equal
218 */
219 friend bool operator==(const SkIRect& a, const SkIRect& b) {
220 return a.fLeft == b.fLeft && a.fTop == b.fTop &&
221 a.fRight == b.fRight && a.fBottom == b.fBottom;
222 }
223
224 /** Returns true if any member in a: fLeft, fTop, fRight, and fBottom; is not
225 identical to the corresponding member in b.
226
227 @param a SkIRect to compare
228 @param b SkIRect to compare
229 @return true if members are not equal
230 */
231 friend bool operator!=(const SkIRect& a, const SkIRect& b) {
232 return a.fLeft != b.fLeft || a.fTop != b.fTop ||
233 a.fRight != b.fRight || a.fBottom != b.fBottom;
234 }
235
236 /** Sets SkIRect to (0, 0, 0, 0).
237
238 Many other rectangles are empty; if left is equal to or greater than right,
239 or if top is equal to or greater than bottom. Setting all members to zero
240 is a convenience, but does not designate a special empty rectangle.
241 */
242 void setEmpty() { memset(this, 0, sizeof(*this)); }
243
244 /** Sets SkIRect to (left, top, right, bottom).
245 left and right are not sorted; left is not necessarily less than right.
246 top and bottom are not sorted; top is not necessarily less than bottom.
247
248 @param left stored in fLeft
249 @param top stored in fTop
250 @param right stored in fRight
251 @param bottom stored in fBottom
252 */
253 void setLTRB(int32_t left, int32_t top, int32_t right, int32_t bottom) {
254 fLeft = left;
255 fTop = top;
256 fRight = right;
257 fBottom = bottom;
258 }
259
260 /** Sets SkIRect to: (x, y, x + width, y + height).
261 Does not validate input; width or height may be negative.
262
263 @param x stored in fLeft
264 @param y stored in fTop
265 @param width added to x and stored in fRight
266 @param height added to y and stored in fBottom
267 */
268 void setXYWH(int32_t x, int32_t y, int32_t width, int32_t height) {
269 fLeft = x;
270 fTop = y;
271 fRight = Sk32_sat_add(x, width);
272 fBottom = Sk32_sat_add(y, height);
273 }
274
275 void setWH(int32_t width, int32_t height) {
276 fLeft = 0;
277 fTop = 0;
278 fRight = width;
279 fBottom = height;
280 }
281
283 fLeft = 0;
284 fTop = 0;
285 fRight = size.width();
286 fBottom = size.height();
287 }
288
289 /** Returns SkIRect offset by (dx, dy).
290
291 If dx is negative, SkIRect returned is moved to the left.
292 If dx is positive, SkIRect returned is moved to the right.
293 If dy is negative, SkIRect returned is moved upward.
294 If dy is positive, SkIRect returned is moved downward.
295
296 @param dx offset added to fLeft and fRight
297 @param dy offset added to fTop and fBottom
298 @return SkIRect offset by dx and dy, with original width and height
299 */
300 constexpr SkIRect makeOffset(int32_t dx, int32_t dy) const {
301 return {
302 Sk32_sat_add(fLeft, dx), Sk32_sat_add(fTop, dy),
303 Sk32_sat_add(fRight, dx), Sk32_sat_add(fBottom, dy),
304 };
305 }
306
307 /** Returns SkIRect offset by (offset.x(), offset.y()).
308
309 If offset.x() is negative, SkIRect returned is moved to the left.
310 If offset.x() is positive, SkIRect returned is moved to the right.
311 If offset.y() is negative, SkIRect returned is moved upward.
312 If offset.y() is positive, SkIRect returned is moved downward.
313
314 @param offset translation vector
315 @return SkIRect translated by offset, with original width and height
316 */
318 return this->makeOffset(offset.x(), offset.y());
319 }
320
321 /** Returns SkIRect, inset by (dx, dy).
322
323 If dx is negative, SkIRect returned is wider.
324 If dx is positive, SkIRect returned is narrower.
325 If dy is negative, SkIRect returned is taller.
326 If dy is positive, SkIRect returned is shorter.
327
328 @param dx offset added to fLeft and subtracted from fRight
329 @param dy offset added to fTop and subtracted from fBottom
330 @return SkIRect inset symmetrically left and right, top and bottom
331 */
332 SkIRect makeInset(int32_t dx, int32_t dy) const {
333 return {
334 Sk32_sat_add(fLeft, dx), Sk32_sat_add(fTop, dy),
335 Sk32_sat_sub(fRight, dx), Sk32_sat_sub(fBottom, dy),
336 };
337 }
338
339 /** Returns SkIRect, outset by (dx, dy).
340
341 If dx is negative, SkIRect returned is narrower.
342 If dx is positive, SkIRect returned is wider.
343 If dy is negative, SkIRect returned is shorter.
344 If dy is positive, SkIRect returned is taller.
345
346 @param dx offset subtracted to fLeft and added from fRight
347 @param dy offset subtracted to fTop and added from fBottom
348 @return SkIRect outset symmetrically left and right, top and bottom
349 */
350 SkIRect makeOutset(int32_t dx, int32_t dy) const {
351 return {
352 Sk32_sat_sub(fLeft, dx), Sk32_sat_sub(fTop, dy),
353 Sk32_sat_add(fRight, dx), Sk32_sat_add(fBottom, dy),
354 };
355 }
356
357 /** Offsets SkIRect by adding dx to fLeft, fRight; and by adding dy to fTop, fBottom.
358
359 If dx is negative, moves SkIRect returned to the left.
360 If dx is positive, moves SkIRect returned to the right.
361 If dy is negative, moves SkIRect returned upward.
362 If dy is positive, moves SkIRect returned downward.
363
364 @param dx offset added to fLeft and fRight
365 @param dy offset added to fTop and fBottom
366 */
367 void offset(int32_t dx, int32_t dy) {
368 fLeft = Sk32_sat_add(fLeft, dx);
369 fTop = Sk32_sat_add(fTop, dy);
370 fRight = Sk32_sat_add(fRight, dx);
371 fBottom = Sk32_sat_add(fBottom, dy);
372 }
373
374 /** Offsets SkIRect by adding delta.fX to fLeft, fRight; and by adding delta.fY to
375 fTop, fBottom.
376
377 If delta.fX is negative, moves SkIRect returned to the left.
378 If delta.fX is positive, moves SkIRect returned to the right.
379 If delta.fY is negative, moves SkIRect returned upward.
380 If delta.fY is positive, moves SkIRect returned downward.
381
382 @param delta offset added to SkIRect
383 */
384 void offset(const SkIPoint& delta) {
385 this->offset(delta.fX, delta.fY);
386 }
387
388 /** Offsets SkIRect so that fLeft equals newX, and fTop equals newY. width and height
389 are unchanged.
390
391 @param newX stored in fLeft, preserving width()
392 @param newY stored in fTop, preserving height()
393 */
394 void offsetTo(int32_t newX, int32_t newY) {
395 fRight = Sk64_pin_to_s32((int64_t)fRight + newX - fLeft);
396 fBottom = Sk64_pin_to_s32((int64_t)fBottom + newY - fTop);
397 fLeft = newX;
398 fTop = newY;
399 }
400
401 /** Insets SkIRect by (dx,dy).
402
403 If dx is positive, makes SkIRect narrower.
404 If dx is negative, makes SkIRect wider.
405 If dy is positive, makes SkIRect shorter.
406 If dy is negative, makes SkIRect taller.
407
408 @param dx offset added to fLeft and subtracted from fRight
409 @param dy offset added to fTop and subtracted from fBottom
410 */
411 void inset(int32_t dx, int32_t dy) {
412 fLeft = Sk32_sat_add(fLeft, dx);
413 fTop = Sk32_sat_add(fTop, dy);
414 fRight = Sk32_sat_sub(fRight, dx);
415 fBottom = Sk32_sat_sub(fBottom, dy);
416 }
417
418 /** Outsets SkIRect by (dx, dy).
419
420 If dx is positive, makes SkIRect wider.
421 If dx is negative, makes SkIRect narrower.
422 If dy is positive, makes SkIRect taller.
423 If dy is negative, makes SkIRect shorter.
424
425 @param dx subtracted to fLeft and added from fRight
426 @param dy subtracted to fTop and added from fBottom
427 */
428 void outset(int32_t dx, int32_t dy) { this->inset(-dx, -dy); }
429
430 /** Adjusts SkIRect by adding dL to fLeft, dT to fTop, dR to fRight, and dB to fBottom.
431
432 If dL is positive, narrows SkIRect on the left. If negative, widens it on the left.
433 If dT is positive, shrinks SkIRect on the top. If negative, lengthens it on the top.
434 If dR is positive, narrows SkIRect on the right. If negative, widens it on the right.
435 If dB is positive, shrinks SkIRect on the bottom. If negative, lengthens it on the bottom.
436
437 The resulting SkIRect is not checked for validity. Thus, if the resulting SkIRect left is
438 greater than right, the SkIRect will be considered empty. Call sort() after this call
439 if that is not the desired behavior.
440
441 @param dL offset added to fLeft
442 @param dT offset added to fTop
443 @param dR offset added to fRight
444 @param dB offset added to fBottom
445 */
446 void adjust(int32_t dL, int32_t dT, int32_t dR, int32_t dB) {
447 fLeft = Sk32_sat_add(fLeft, dL);
448 fTop = Sk32_sat_add(fTop, dT);
449 fRight = Sk32_sat_add(fRight, dR);
450 fBottom = Sk32_sat_add(fBottom, dB);
451 }
452
453 /** Returns true if: fLeft <= x < fRight && fTop <= y < fBottom.
454 Returns false if SkIRect is empty.
455
456 Considers input to describe constructed SkIRect: (x, y, x + 1, y + 1) and
457 returns true if constructed area is completely enclosed by SkIRect area.
458
459 @param x test SkIPoint x-coordinate
460 @param y test SkIPoint y-coordinate
461 @return true if (x, y) is inside SkIRect
462 */
463 bool contains(int32_t x, int32_t y) const {
464 return x >= fLeft && x < fRight && y >= fTop && y < fBottom;
465 }
466
467 /** Returns true if SkIRect contains r.
468 Returns false if SkIRect is empty or r is empty.
469
470 SkIRect contains r when SkIRect area completely includes r area.
471
472 @param r SkIRect contained
473 @return true if all sides of SkIRect are outside r
474 */
475 bool contains(const SkIRect& r) const {
476 return !r.isEmpty() && !this->isEmpty() && // check for empties
477 fLeft <= r.fLeft && fTop <= r.fTop &&
478 fRight >= r.fRight && fBottom >= r.fBottom;
479 }
480
481 /** Returns true if SkIRect contains r.
482 Returns false if SkIRect is empty or r is empty.
483
484 SkIRect contains r when SkIRect area completely includes r area.
485
486 @param r SkRect contained
487 @return true if all sides of SkIRect are outside r
488 */
489 inline bool contains(const SkRect& r) const;
490
491 /** Returns true if SkIRect contains construction.
492 Asserts if SkIRect is empty or construction is empty, and if SK_DEBUG is defined.
493
494 Return is undefined if SkIRect is empty or construction is empty.
495
496 @param r SkIRect contained
497 @return true if all sides of SkIRect are outside r
498 */
499 bool containsNoEmptyCheck(const SkIRect& r) const {
500 SkASSERT(fLeft < fRight && fTop < fBottom);
501 SkASSERT(r.fLeft < r.fRight && r.fTop < r.fBottom);
502 return fLeft <= r.fLeft && fTop <= r.fTop && fRight >= r.fRight && fBottom >= r.fBottom;
503 }
504
505 /** Returns true if SkIRect intersects r, and sets SkIRect to intersection.
506 Returns false if SkIRect does not intersect r, and leaves SkIRect unchanged.
507
508 Returns false if either r or SkIRect is empty, leaving SkIRect unchanged.
509
510 @param r limit of result
511 @return true if r and SkIRect have area in common
512 */
513 bool intersect(const SkIRect& r) {
514 return this->intersect(*this, r);
515 }
516
517 /** Returns true if a intersects b, and sets SkIRect to intersection.
518 Returns false if a does not intersect b, and leaves SkIRect unchanged.
519
520 Returns false if either a or b is empty, leaving SkIRect unchanged.
521
522 @param a SkIRect to intersect
523 @param b SkIRect to intersect
524 @return true if a and b have area in common
525 */
526 [[nodiscard]] bool intersect(const SkIRect& a, const SkIRect& b);
527
528 /** Returns true if a intersects b.
529 Returns false if either a or b is empty, or do not intersect.
530
531 @param a SkIRect to intersect
532 @param b SkIRect to intersect
533 @return true if a and b have area in common
534 */
535 static bool Intersects(const SkIRect& a, const SkIRect& b) {
536 return SkIRect{}.intersect(a, b);
537 }
538
539 /** Sets SkIRect to the union of itself and r.
540
541 Has no effect if r is empty. Otherwise, if SkIRect is empty, sets SkIRect to r.
542
543 @param r expansion SkIRect
544
545 example: https://fiddle.skia.org/c/@IRect_join_2
546 */
547 void join(const SkIRect& r);
548
549 /** Swaps fLeft and fRight if fLeft is greater than fRight; and swaps
550 fTop and fBottom if fTop is greater than fBottom. Result may be empty,
551 and width() and height() will be zero or positive.
552 */
553 void sort() {
554 using std::swap;
555 if (fLeft > fRight) {
556 swap(fLeft, fRight);
557 }
558 if (fTop > fBottom) {
559 swap(fTop, fBottom);
560 }
561 }
562
563 /** Returns SkIRect with fLeft and fRight swapped if fLeft is greater than fRight; and
564 with fTop and fBottom swapped if fTop is greater than fBottom. Result may be empty;
565 and width() and height() will be zero or positive.
566
567 @return sorted SkIRect
568 */
570 return MakeLTRB(std::min(fLeft, fRight), std::min(fTop, fBottom),
571 std::max(fLeft, fRight), std::max(fTop, fBottom));
572 }
573};
574
575/** \struct SkRect
576 SkRect holds four float coordinates describing the upper and
577 lower bounds of a rectangle. SkRect may be created from outer bounds or
578 from position, width, and height. SkRect describes an area; if its right
579 is less than or equal to its left, or if its bottom is less than or equal to
580 its top, it is considered empty.
581*/
582struct SK_API SkRect {
583 float fLeft = 0; //!< smaller x-axis bounds
584 float fTop = 0; //!< smaller y-axis bounds
585 float fRight = 0; //!< larger x-axis bounds
586 float fBottom = 0; //!< larger y-axis bounds
587
588 /** Returns constructed SkRect set to (0, 0, 0, 0).
589 Many other rectangles are empty; if left is equal to or greater than right,
590 or if top is equal to or greater than bottom. Setting all members to zero
591 is a convenience, but does not designate a special empty rectangle.
592
593 @return bounds (0, 0, 0, 0)
594 */
595 [[nodiscard]] static constexpr SkRect MakeEmpty() {
596 return SkRect{0, 0, 0, 0};
597 }
598
599 /** Returns constructed SkRect set to float values (0, 0, w, h). Does not
600 validate input; w or h may be negative.
601
602 Passing integer values may generate a compiler warning since SkRect cannot
603 represent 32-bit integers exactly. Use SkIRect for an exact integer rectangle.
604
605 @param w float width of constructed SkRect
606 @param h float height of constructed SkRect
607 @return bounds (0, 0, w, h)
608 */
609 [[nodiscard]] static constexpr SkRect MakeWH(float w, float h) {
610 return SkRect{0, 0, w, h};
611 }
612
613 /** Returns constructed SkRect set to integer values (0, 0, w, h). Does not validate
614 input; w or h may be negative.
615
616 Use to avoid a compiler warning that input may lose precision when stored.
617 Use SkIRect for an exact integer rectangle.
618
619 @param w integer width of constructed SkRect
620 @param h integer height of constructed SkRect
621 @return bounds (0, 0, w, h)
622 */
623 [[nodiscard]] static SkRect MakeIWH(int w, int h) {
624 return {0, 0, static_cast<float>(w), static_cast<float>(h)};
625 }
626
627 /** Returns constructed SkRect set to (0, 0, size.width(), size.height()). Does not
628 validate input; size.width() or size.height() may be negative.
629
630 @param size float values for SkRect width and height
631 @return bounds (0, 0, size.width(), size.height())
632 */
633 [[nodiscard]] static constexpr SkRect MakeSize(const SkSize& size) {
634 return SkRect{0, 0, size.fWidth, size.fHeight};
635 }
636
637 /** Returns constructed SkRect set to (l, t, r, b). Does not sort input; SkRect may
638 result in fLeft greater than fRight, or fTop greater than fBottom.
639
640 @param l float stored in fLeft
641 @param t float stored in fTop
642 @param r float stored in fRight
643 @param b float stored in fBottom
644 @return bounds (l, t, r, b)
645 */
646 [[nodiscard]] static constexpr SkRect MakeLTRB(float l, float t, float r, float b) {
647 return SkRect {l, t, r, b};
648 }
649
650 /** Returns constructed SkRect set to (x, y, x + w, y + h).
651 Does not validate input; w or h may be negative.
652
653 @param x stored in fLeft
654 @param y stored in fTop
655 @param w added to x and stored in fRight
656 @param h added to y and stored in fBottom
657 @return bounds at (x, y) with width w and height h
658 */
659 [[nodiscard]] static constexpr SkRect MakeXYWH(float x, float y, float w, float h) {
660 return SkRect {x, y, x + w, y + h};
661 }
662
663 /** Returns constructed SkIRect set to (0, 0, size.width(), size.height()).
664 Does not validate input; size.width() or size.height() may be negative.
665
666 @param size integer values for SkRect width and height
667 @return bounds (0, 0, size.width(), size.height())
668 */
669 static SkRect Make(const SkISize& size) {
670 return MakeIWH(size.width(), size.height());
671 }
672
673 /** Returns constructed SkIRect set to irect, promoting integers to float.
674 Does not validate input; fLeft may be greater than fRight, fTop may be greater
675 than fBottom.
676
677 @param irect integer unsorted bounds
678 @return irect members converted to float
679 */
680 [[nodiscard]] static SkRect Make(const SkIRect& irect) {
681 return {
682 static_cast<float>(irect.fLeft), static_cast<float>(irect.fTop),
683 static_cast<float>(irect.fRight), static_cast<float>(irect.fBottom)
684 };
685 }
686
687 /** Returns true if fLeft is equal to or greater than fRight, or if fTop is equal
688 to or greater than fBottom. Call sort() to reverse rectangles with negative
689 width() or height().
690
691 @return true if width() or height() are zero or negative
692 */
693 bool isEmpty() const {
694 // We write it as the NOT of a non-empty rect, so we will return true if any values
695 // are NaN.
696 return !(fLeft < fRight && fTop < fBottom);
697 }
698
699 /** Returns true if fLeft is equal to or less than fRight, or if fTop is equal
700 to or less than fBottom. Call sort() to reverse rectangles with negative
701 width() or height().
702
703 @return true if width() or height() are zero or positive
704 */
705 bool isSorted() const { return fLeft <= fRight && fTop <= fBottom; }
706
707 /** Returns true if all values in the rectangle are finite.
708
709 @return true if no member is infinite or NaN
710 */
711 bool isFinite() const {
712 return SkIsFinite(fLeft, fTop, fRight, fBottom);
713 }
714
715 /** Returns left edge of SkRect, if sorted. Call isSorted() to see if SkRect is valid.
716 Call sort() to reverse fLeft and fRight if needed.
717
718 @return fLeft
719 */
720 constexpr float x() const { return fLeft; }
721
722 /** Returns top edge of SkRect, if sorted. Call isEmpty() to see if SkRect may be invalid,
723 and sort() to reverse fTop and fBottom if needed.
724
725 @return fTop
726 */
727 constexpr float y() const { return fTop; }
728
729 /** Returns left edge of SkRect, if sorted. Call isSorted() to see if SkRect is valid.
730 Call sort() to reverse fLeft and fRight if needed.
731
732 @return fLeft
733 */
734 constexpr float left() const { return fLeft; }
735
736 /** Returns top edge of SkRect, if sorted. Call isEmpty() to see if SkRect may be invalid,
737 and sort() to reverse fTop and fBottom if needed.
738
739 @return fTop
740 */
741 constexpr float top() const { return fTop; }
742
743 /** Returns right edge of SkRect, if sorted. Call isSorted() to see if SkRect is valid.
744 Call sort() to reverse fLeft and fRight if needed.
745
746 @return fRight
747 */
748 constexpr float right() const { return fRight; }
749
750 /** Returns bottom edge of SkRect, if sorted. Call isEmpty() to see if SkRect may be invalid,
751 and sort() to reverse fTop and fBottom if needed.
752
753 @return fBottom
754 */
755 constexpr float bottom() const { return fBottom; }
756
757 /** Returns span on the x-axis. This does not check if SkRect is sorted, or if
758 result fits in 32-bit float; result may be negative or infinity.
759
760 @return fRight minus fLeft
761 */
762 constexpr float width() const { return fRight - fLeft; }
763
764 /** Returns span on the y-axis. This does not check if SkRect is sorted, or if
765 result fits in 32-bit float; result may be negative or infinity.
766
767 @return fBottom minus fTop
768 */
769 constexpr float height() const { return fBottom - fTop; }
770
771 /** Returns average of left edge and right edge. Result does not change if SkRect
772 is sorted. Result may overflow to infinity if SkRect is far from the origin.
773
774 @return midpoint on x-axis
775 */
776 constexpr float centerX() const {
777 return sk_float_midpoint(fLeft, fRight);
778 }
779
780 /** Returns average of top edge and bottom edge. Result does not change if SkRect
781 is sorted.
782
783 @return midpoint on y-axis
784 */
785 constexpr float centerY() const {
786 return sk_float_midpoint(fTop, fBottom);
787 }
788
789 /** Returns the point this->centerX(), this->centerY().
790 @return rectangle center
791 */
792 constexpr SkPoint center() const { return {this->centerX(), this->centerY()}; }
793
794 /** Returns true if all members in a: fLeft, fTop, fRight, and fBottom; are
795 equal to the corresponding members in b.
796
797 a and b are not equal if either contain NaN. a and b are equal if members
798 contain zeroes with different signs.
799
800 @param a SkRect to compare
801 @param b SkRect to compare
802 @return true if members are equal
803 */
804 friend bool operator==(const SkRect& a, const SkRect& b) {
805 return a.fLeft == b.fLeft &&
806 a.fTop == b.fTop &&
807 a.fRight == b.fRight &&
808 a.fBottom == b.fBottom;
809 }
810
811 /** Returns true if any in a: fLeft, fTop, fRight, and fBottom; does not
812 equal the corresponding members in b.
813
814 a and b are not equal if either contain NaN. a and b are equal if members
815 contain zeroes with different signs.
816
817 @param a SkRect to compare
818 @param b SkRect to compare
819 @return true if members are not equal
820 */
821 friend bool operator!=(const SkRect& a, const SkRect& b) {
822 return !(a == b);
823 }
824
825 /** Returns four points in quad that enclose SkRect ordered as: top-left, top-right,
826 bottom-right, bottom-left.
827
828 TODO: Consider adding parameter to control whether quad is clockwise or counterclockwise.
829
830 @param quad storage for corners of SkRect
831
832 example: https://fiddle.skia.org/c/@Rect_toQuad
833 */
834 void toQuad(SkPoint quad[4]) const;
835
836 /** Sets SkRect to (0, 0, 0, 0).
837
838 Many other rectangles are empty; if left is equal to or greater than right,
839 or if top is equal to or greater than bottom. Setting all members to zero
840 is a convenience, but does not designate a special empty rectangle.
841 */
842 void setEmpty() { *this = MakeEmpty(); }
843
844 /** Sets SkRect to src, promoting src members from integer to float.
845 Very large values in src may lose precision.
846
847 @param src integer SkRect
848 */
849 void set(const SkIRect& src) {
850 fLeft = src.fLeft;
851 fTop = src.fTop;
852 fRight = src.fRight;
853 fBottom = src.fBottom;
854 }
855
856 /** Sets SkRect to (left, top, right, bottom).
857 left and right are not sorted; left is not necessarily less than right.
858 top and bottom are not sorted; top is not necessarily less than bottom.
859
860 @param left stored in fLeft
861 @param top stored in fTop
862 @param right stored in fRight
863 @param bottom stored in fBottom
864 */
865 void setLTRB(float left, float top, float right, float bottom) {
866 fLeft = left;
867 fTop = top;
868 fRight = right;
869 fBottom = bottom;
870 }
871
872 /** Sets to bounds of SkPoint array with count entries. If count is zero or smaller,
873 or if SkPoint array contains an infinity or NaN, sets to (0, 0, 0, 0).
874
875 Result is either empty or sorted: fLeft is less than or equal to fRight, and
876 fTop is less than or equal to fBottom.
877
878 @param pts SkPoint array
879 @param count entries in array
880 */
881 void setBounds(const SkPoint pts[], int count) {
882 (void)this->setBoundsCheck(pts, count);
883 }
884
885 /** Sets to bounds of SkPoint array with count entries. Returns false if count is
886 zero or smaller, or if SkPoint array contains an infinity or NaN; in these cases
887 sets SkRect to (0, 0, 0, 0).
888
889 Result is either empty or sorted: fLeft is less than or equal to fRight, and
890 fTop is less than or equal to fBottom.
891
892 @param pts SkPoint array
893 @param count entries in array
894 @return true if all SkPoint values are finite
895
896 example: https://fiddle.skia.org/c/@Rect_setBoundsCheck
897 */
898 bool setBoundsCheck(const SkPoint pts[], int count);
899
900 /** Sets to bounds of SkPoint pts array with count entries. If any SkPoint in pts
901 contains infinity or NaN, all SkRect dimensions are set to NaN.
902
903 @param pts SkPoint array
904 @param count entries in array
905
906 example: https://fiddle.skia.org/c/@Rect_setBoundsNoCheck
907 */
908 void setBoundsNoCheck(const SkPoint pts[], int count);
909
910 /** Sets bounds to the smallest SkRect enclosing SkPoint p0 and p1. The result is
911 sorted and may be empty. Does not check to see if values are finite.
912
913 @param p0 corner to include
914 @param p1 corner to include
915 */
916 void set(const SkPoint& p0, const SkPoint& p1) {
917 fLeft = std::min(p0.fX, p1.fX);
918 fRight = std::max(p0.fX, p1.fX);
919 fTop = std::min(p0.fY, p1.fY);
920 fBottom = std::max(p0.fY, p1.fY);
921 }
922
923 /** Sets SkRect to (x, y, x + width, y + height).
924 Does not validate input; width or height may be negative.
925
926 @param x stored in fLeft
927 @param y stored in fTop
928 @param width added to x and stored in fRight
929 @param height added to y and stored in fBottom
930 */
931 void setXYWH(float x, float y, float width, float height) {
932 fLeft = x;
933 fTop = y;
934 fRight = x + width;
935 fBottom = y + height;
936 }
937
938 /** Sets SkRect to (0, 0, width, height). Does not validate input;
939 width or height may be negative.
940
941 @param width stored in fRight
942 @param height stored in fBottom
943 */
944 void setWH(float width, float height) {
945 fLeft = 0;
946 fTop = 0;
947 fRight = width;
948 fBottom = height;
949 }
950 void setIWH(int32_t width, int32_t height) {
951 this->setWH(width, height);
952 }
953
954 /** Returns SkRect offset by (dx, dy).
955
956 If dx is negative, SkRect returned is moved to the left.
957 If dx is positive, SkRect returned is moved to the right.
958 If dy is negative, SkRect returned is moved upward.
959 If dy is positive, SkRect returned is moved downward.
960
961 @param dx added to fLeft and fRight
962 @param dy added to fTop and fBottom
963 @return SkRect offset on axes, with original width and height
964 */
965 constexpr SkRect makeOffset(float dx, float dy) const {
966 return MakeLTRB(fLeft + dx, fTop + dy, fRight + dx, fBottom + dy);
967 }
968
969 /** Returns SkRect offset by v.
970
971 @param v added to rect
972 @return SkRect offset on axes, with original width and height
973 */
974 constexpr SkRect makeOffset(SkVector v) const { return this->makeOffset(v.x(), v.y()); }
975
976 /** Returns SkRect, inset by (dx, dy).
977
978 If dx is negative, SkRect returned is wider.
979 If dx is positive, SkRect returned is narrower.
980 If dy is negative, SkRect returned is taller.
981 If dy is positive, SkRect returned is shorter.
982
983 @param dx added to fLeft and subtracted from fRight
984 @param dy added to fTop and subtracted from fBottom
985 @return SkRect inset symmetrically left and right, top and bottom
986 */
987 SkRect makeInset(float dx, float dy) const {
988 return MakeLTRB(fLeft + dx, fTop + dy, fRight - dx, fBottom - dy);
989 }
990
991 /** Returns SkRect, outset by (dx, dy).
992
993 If dx is negative, SkRect returned is narrower.
994 If dx is positive, SkRect returned is wider.
995 If dy is negative, SkRect returned is shorter.
996 If dy is positive, SkRect returned is taller.
997
998 @param dx subtracted to fLeft and added from fRight
999 @param dy subtracted to fTop and added from fBottom
1000 @return SkRect outset symmetrically left and right, top and bottom
1001 */
1002 SkRect makeOutset(float dx, float dy) const {
1003 return MakeLTRB(fLeft - dx, fTop - dy, fRight + dx, fBottom + dy);
1004 }
1005
1006 /** Offsets SkRect by adding dx to fLeft, fRight; and by adding dy to fTop, fBottom.
1007
1008 If dx is negative, moves SkRect to the left.
1009 If dx is positive, moves SkRect to the right.
1010 If dy is negative, moves SkRect upward.
1011 If dy is positive, moves SkRect downward.
1012
1013 @param dx offset added to fLeft and fRight
1014 @param dy offset added to fTop and fBottom
1015 */
1016 void offset(float dx, float dy) {
1017 fLeft += dx;
1018 fTop += dy;
1019 fRight += dx;
1020 fBottom += dy;
1021 }
1022
1023 /** Offsets SkRect by adding delta.fX to fLeft, fRight; and by adding delta.fY to
1024 fTop, fBottom.
1025
1026 If delta.fX is negative, moves SkRect to the left.
1027 If delta.fX is positive, moves SkRect to the right.
1028 If delta.fY is negative, moves SkRect upward.
1029 If delta.fY is positive, moves SkRect downward.
1030
1031 @param delta added to SkRect
1032 */
1033 void offset(const SkPoint& delta) {
1034 this->offset(delta.fX, delta.fY);
1035 }
1036
1037 /** Offsets SkRect so that fLeft equals newX, and fTop equals newY. width and height
1038 are unchanged.
1039
1040 @param newX stored in fLeft, preserving width()
1041 @param newY stored in fTop, preserving height()
1042 */
1043 void offsetTo(float newX, float newY) {
1044 fRight += newX - fLeft;
1045 fBottom += newY - fTop;
1046 fLeft = newX;
1047 fTop = newY;
1048 }
1049
1050 /** Insets SkRect by (dx, dy).
1051
1052 If dx is positive, makes SkRect narrower.
1053 If dx is negative, makes SkRect wider.
1054 If dy is positive, makes SkRect shorter.
1055 If dy is negative, makes SkRect taller.
1056
1057 @param dx added to fLeft and subtracted from fRight
1058 @param dy added to fTop and subtracted from fBottom
1059 */
1060 void inset(float dx, float dy) {
1061 fLeft += dx;
1062 fTop += dy;
1063 fRight -= dx;
1064 fBottom -= dy;
1065 }
1066
1067 /** Outsets SkRect by (dx, dy).
1068
1069 If dx is positive, makes SkRect wider.
1070 If dx is negative, makes SkRect narrower.
1071 If dy is positive, makes SkRect taller.
1072 If dy is negative, makes SkRect shorter.
1073
1074 @param dx subtracted to fLeft and added from fRight
1075 @param dy subtracted to fTop and added from fBottom
1076 */
1077 void outset(float dx, float dy) { this->inset(-dx, -dy); }
1078
1079 /** Returns true if SkRect intersects r, and sets SkRect to intersection.
1080 Returns false if SkRect does not intersect r, and leaves SkRect unchanged.
1081
1082 Returns false if either r or SkRect is empty, leaving SkRect unchanged.
1083
1084 @param r limit of result
1085 @return true if r and SkRect have area in common
1086
1087 example: https://fiddle.skia.org/c/@Rect_intersect
1088 */
1089 bool intersect(const SkRect& r);
1090
1091 /** Returns true if a intersects b, and sets SkRect to intersection.
1092 Returns false if a does not intersect b, and leaves SkRect unchanged.
1093
1094 Returns false if either a or b is empty, leaving SkRect unchanged.
1095
1096 @param a SkRect to intersect
1097 @param b SkRect to intersect
1098 @return true if a and b have area in common
1099 */
1100 [[nodiscard]] bool intersect(const SkRect& a, const SkRect& b);
1101
1102
1103private:
1104 static bool Intersects(float al, float at, float ar, float ab,
1105 float bl, float bt, float br, float bb) {
1106 float L = std::max(al, bl);
1107 float R = std::min(ar, br);
1108 float T = std::max(at, bt);
1109 float B = std::min(ab, bb);
1110 return L < R && T < B;
1111 }
1112
1113public:
1114
1115 /** Returns true if SkRect intersects r.
1116 Returns false if either r or SkRect is empty, or do not intersect.
1117
1118 @param r SkRect to intersect
1119 @return true if r and SkRect have area in common
1120 */
1121 bool intersects(const SkRect& r) const {
1122 return Intersects(fLeft, fTop, fRight, fBottom,
1123 r.fLeft, r.fTop, r.fRight, r.fBottom);
1124 }
1125
1126 /** Returns true if a intersects b.
1127 Returns false if either a or b is empty, or do not intersect.
1128
1129 @param a SkRect to intersect
1130 @param b SkRect to intersect
1131 @return true if a and b have area in common
1132 */
1133 static bool Intersects(const SkRect& a, const SkRect& b) {
1134 return Intersects(a.fLeft, a.fTop, a.fRight, a.fBottom,
1135 b.fLeft, b.fTop, b.fRight, b.fBottom);
1136 }
1137
1138 /** Sets SkRect to the union of itself and r.
1139
1140 Has no effect if r is empty. Otherwise, if SkRect is empty, sets
1141 SkRect to r.
1142
1143 @param r expansion SkRect
1144
1145 example: https://fiddle.skia.org/c/@Rect_join_2
1146 */
1147 void join(const SkRect& r);
1148
1149 /** Sets SkRect to the union of itself and r.
1150
1151 Asserts if r is empty and SK_DEBUG is defined.
1152 If SkRect is empty, sets SkRect to r.
1153
1154 May produce incorrect results if r is empty.
1155
1156 @param r expansion SkRect
1157 */
1158 void joinNonEmptyArg(const SkRect& r) {
1159 SkASSERT(!r.isEmpty());
1160 // if we are empty, just assign
1161 if (fLeft >= fRight || fTop >= fBottom) {
1162 *this = r;
1163 } else {
1164 this->joinPossiblyEmptyRect(r);
1165 }
1166 }
1167
1168 /** Sets SkRect to the union of itself and the construction.
1169
1170 May produce incorrect results if SkRect or r is empty.
1171
1172 @param r expansion SkRect
1173 */
1175 fLeft = std::min(fLeft, r.left());
1176 fTop = std::min(fTop, r.top());
1177 fRight = std::max(fRight, r.right());
1178 fBottom = std::max(fBottom, r.bottom());
1179 }
1180
1181 /** Returns true if: fLeft <= x < fRight && fTop <= y < fBottom.
1182 Returns false if SkRect is empty.
1183
1184 @param x test SkPoint x-coordinate
1185 @param y test SkPoint y-coordinate
1186 @return true if (x, y) is inside SkRect
1187 */
1188 bool contains(float x, float y) const {
1189 return x >= fLeft && x < fRight && y >= fTop && y < fBottom;
1190 }
1191
1192 /** Returns true if SkRect contains r.
1193 Returns false if SkRect is empty or r is empty.
1194
1195 SkRect contains r when SkRect area completely includes r area.
1196
1197 @param r SkRect contained
1198 @return true if all sides of SkRect are outside r
1199 */
1200 bool contains(const SkRect& r) const {
1201 // todo: can we eliminate the this->isEmpty check?
1202 return !r.isEmpty() && !this->isEmpty() &&
1203 fLeft <= r.fLeft && fTop <= r.fTop &&
1204 fRight >= r.fRight && fBottom >= r.fBottom;
1205 }
1206
1207 /** Returns true if SkRect contains r.
1208 Returns false if SkRect is empty or r is empty.
1209
1210 SkRect contains r when SkRect area completely includes r area.
1211
1212 @param r SkIRect contained
1213 @return true if all sides of SkRect are outside r
1214 */
1215 bool contains(const SkIRect& r) const {
1216 // todo: can we eliminate the this->isEmpty check?
1217 return !r.isEmpty() && !this->isEmpty() &&
1218 fLeft <= r.fLeft && fTop <= r.fTop &&
1219 fRight >= r.fRight && fBottom >= r.fBottom;
1220 }
1221
1222 /** Sets SkIRect by adding 0.5 and discarding the fractional portion of SkRect
1223 members, using (sk_float_round2int(fLeft), sk_float_round2int(fTop),
1224 sk_float_round2int(fRight), sk_float_round2int(fBottom)).
1225
1226 @param dst storage for SkIRect
1227 */
1228 void round(SkIRect* dst) const {
1229 SkASSERT(dst);
1230 dst->setLTRB(sk_float_round2int(fLeft), sk_float_round2int(fTop),
1231 sk_float_round2int(fRight), sk_float_round2int(fBottom));
1232 }
1233
1234 /** Sets SkIRect by discarding the fractional portion of fLeft and fTop; and rounding
1235 up fRight and fBottom, using
1236 (sk_float_floor2int(fLeft), sk_float_floor2int(fTop),
1237 sk_float_ceil2int(fRight), sk_float_ceil2int(fBottom)).
1238
1239 @param dst storage for SkIRect
1240 */
1241 void roundOut(SkIRect* dst) const {
1242 SkASSERT(dst);
1243 dst->setLTRB(sk_float_floor2int(fLeft), sk_float_floor2int(fTop),
1244 sk_float_ceil2int(fRight), sk_float_ceil2int(fBottom));
1245 }
1246
1247 /** Sets SkRect by discarding the fractional portion of fLeft and fTop; and rounding
1248 up fRight and fBottom, using
1249 (std::floor(fLeft), std::floor(fTop),
1250 std::ceil(fRight), std::ceil(fBottom)).
1251
1252 @param dst storage for SkRect
1253 */
1254 void roundOut(SkRect* dst) const {
1255 dst->setLTRB(std::floor(fLeft), std::floor(fTop),
1256 std::ceil(fRight), std::ceil(fBottom));
1257 }
1258
1259 /** Sets SkRect by rounding up fLeft and fTop; and discarding the fractional portion
1260 of fRight and fBottom, using
1261 (sk_float_ceil2int(fLeft), sk_float_ceil2int(fTop),
1262 sk_float_floor2int(fRight), sk_float_floor2int(fBottom)).
1263
1264 @param dst storage for SkIRect
1265 */
1266 void roundIn(SkIRect* dst) const {
1267 SkASSERT(dst);
1268 dst->setLTRB(sk_float_ceil2int(fLeft), sk_float_ceil2int(fTop),
1269 sk_float_floor2int(fRight), sk_float_floor2int(fBottom));
1270 }
1271
1272 /** Returns SkIRect by adding 0.5 and discarding the fractional portion of SkRect
1273 members, using (sk_float_round2int(fLeft), sk_float_round2int(fTop),
1274 sk_float_round2int(fRight), sk_float_round2int(fBottom)).
1275
1276 @return rounded SkIRect
1277 */
1278 SkIRect round() const {
1279 SkIRect ir;
1280 this->round(&ir);
1281 return ir;
1282 }
1283
1284 /** Sets SkIRect by discarding the fractional portion of fLeft and fTop; and rounding
1285 up fRight and fBottom, using
1286 (sk_float_floor2int(fLeft), sk_float_floor2int(fTop),
1287 sk_float_ceil2int(fRight), sk_float_ceil2int(fBottom)).
1288
1289 @return rounded SkIRect
1290 */
1292 SkIRect ir;
1293 this->roundOut(&ir);
1294 return ir;
1295 }
1296 /** Sets SkIRect by rounding up fLeft and fTop; and discarding the fractional portion
1297 of fRight and fBottom, using
1298 (sk_float_ceil2int(fLeft), sk_float_ceil2int(fTop),
1299 sk_float_floor2int(fRight), sk_float_floor2int(fBottom)).
1300
1301 @return rounded SkIRect
1302 */
1304 SkIRect ir;
1305 this->roundIn(&ir);
1306 return ir;
1307 }
1308
1309 /** Swaps fLeft and fRight if fLeft is greater than fRight; and swaps
1310 fTop and fBottom if fTop is greater than fBottom. Result may be empty;
1311 and width() and height() will be zero or positive.
1312 */
1313 void sort() {
1314 using std::swap;
1315 if (fLeft > fRight) {
1316 swap(fLeft, fRight);
1317 }
1318
1319 if (fTop > fBottom) {
1320 swap(fTop, fBottom);
1321 }
1322 }
1323
1324 /** Returns SkRect with fLeft and fRight swapped if fLeft is greater than fRight; and
1325 with fTop and fBottom swapped if fTop is greater than fBottom. Result may be empty;
1326 and width() and height() will be zero or positive.
1327
1328 @return sorted SkRect
1329 */
1331 return MakeLTRB(std::min(fLeft, fRight), std::min(fTop, fBottom),
1332 std::max(fLeft, fRight), std::max(fTop, fBottom));
1333 }
1334
1335 /** Returns pointer to first float in SkRect, to treat it as an array with four
1336 entries.
1337
1338 @return pointer to fLeft
1339 */
1340 const float* asScalars() const { return &fLeft; }
1341
1342 /** Writes text representation of SkRect to standard output. Set asHex to true to
1343 generate exact binary representations of floating point numbers.
1344
1345 @param asHex true if SkScalar values are written as hexadecimal
1346
1347 example: https://fiddle.skia.org/c/@Rect_dump
1348 */
1349 void dump(bool asHex) const;
1350
1351 /** Writes text representation of SkRect to standard output. The representation may be
1352 directly compiled as C++ code. Floating point values are written
1353 with limited precision; it may not be possible to reconstruct original SkRect
1354 from output.
1355 */
1356 void dump() const { this->dump(false); }
1357
1358 /** Writes text representation of SkRect to standard output. The representation may be
1359 directly compiled as C++ code. Floating point values are written
1360 in hexadecimal to preserve their exact bit pattern. The output reconstructs the
1361 original SkRect.
1362
1363 Use instead of dump() when submitting
1364 */
1365 void dumpHex() const { this->dump(true); }
1366};
1367
1368inline bool SkIRect::contains(const SkRect& r) const {
1369 return !r.isEmpty() && !this->isEmpty() && // check for empties
1370 fLeft <= r.fLeft && fTop <= r.fTop &&
1371 fRight >= r.fRight && fBottom >= r.fBottom;
1372}
1373
1374#endif
int count
Definition: FontMgrTest.cpp:50
static bool intersect(const SkPoint &p0, const SkPoint &n0, const SkPoint &p1, const SkPoint &n1, SkScalar *t)
static void round(SkPoint *p)
#define SK_API
Definition: SkAPI.h:35
#define SkASSERT(cond)
Definition: SkAssert.h:116
#define sk_float_ceil2int(x)
static bool SkIsFinite(T x, Pack... values)
#define sk_float_round2int(x)
static constexpr float sk_float_midpoint(float a, float b)
#define sk_float_floor2int(x)
static bool left(const SkPoint &p0, const SkPoint &p1)
static bool right(const SkPoint &p0, const SkPoint &p1)
void swap(sk_sp< T > &a, sk_sp< T > &b)
Definition: SkRefCnt.h:341
static constexpr int32_t Sk64_pin_to_s32(int64_t x)
Definition: SkSafe32.h:16
static constexpr int32_t Sk32_sat_sub(int32_t a, int32_t b)
Definition: SkSafe32.h:24
static constexpr int32_t Sk32_sat_add(int32_t a, int32_t b)
Definition: SkSafe32.h:20
static constexpr int32_t Sk32_can_overflow_sub(int32_t a, int32_t b)
Definition: SkSafe32.h:33
static void dump(const float m[20], SkYUVColorSpace cs, bool rgb2yuv)
Definition: SkYUVMath.cpp:629
static bool b
struct MyStruct a[10]
static float max(float r, float g, float b)
Definition: hsl.cpp:49
static float min(float r, float g, float b)
Definition: hsl.cpp:48
#define R(r)
#define B
double y
double x
skia_private::AutoTArray< sk_sp< SkImageFilter > > filters TypedMatrix matrix TypedMatrix matrix SkScalar dx
Definition: SkRecords.h:208
Definition: ab.py:1
it will be possible to load the file into Perfetto s trace viewer disable asset Prevents usage of any non test fonts unless they were explicitly Loaded via prefetched default font Indicates whether the embedding started a prefetch of the default font manager before creating the engine run In non interactive keep the shell running after the Dart script has completed enable serial On low power devices with low core running concurrent GC tasks on threads can cause them to contend with the UI thread which could potentially lead to jank This option turns off all concurrent GC activities domain network JSON encoded network policy per domain This overrides the DisallowInsecureConnections switch Embedder can specify whether to allow or disallow insecure connections at a domain level old gen heap size
Definition: switches.h:259
dst
Definition: cp.py:12
constexpr bool contains(std::string_view str, std::string_view needle)
Definition: SkStringView.h:41
SIN Vec< N, float > floor(const Vec< N, float > &x)
Definition: SkVx.h:703
SIN Vec< N, float > ceil(const Vec< N, float > &x)
Definition: SkVx.h:702
static SkRect inset(const SkRect &r)
SkScalar w
SkScalar h
#define T
Definition: precompiler.cc:65
int32_t height
int32_t width
static SkString join(const CommandLineFlags::StringArray &)
Definition: skpbench.cpp:741
SeparatedVector2 offset
constexpr int32_t y() const
Definition: SkPoint_impl.h:52
int32_t fX
x-axis value
Definition: SkPoint_impl.h:29
constexpr int32_t x() const
Definition: SkPoint_impl.h:46
Definition: SkRect.h:32
constexpr int64_t height64() const
Definition: SkRect.h:188
void sort()
Definition: SkRect.h:553
constexpr int32_t x() const
Definition: SkRect.h:141
friend bool operator!=(const SkIRect &a, const SkIRect &b)
Definition: SkRect.h:231
void adjust(int32_t dL, int32_t dT, int32_t dR, int32_t dB)
Definition: SkRect.h:446
SkIRect makeOutset(int32_t dx, int32_t dy) const
Definition: SkRect.h:350
void inset(int32_t dx, int32_t dy)
Definition: SkRect.h:411
bool isEmpty64() const
Definition: SkRect.h:196
bool contains(const SkIRect &r) const
Definition: SkRect.h:475
constexpr int32_t y() const
Definition: SkRect.h:148
void offset(const SkIPoint &delta)
Definition: SkRect.h:384
bool intersect(const SkIRect &r)
Definition: SkRect.h:513
static bool Intersects(const SkIRect &a, const SkIRect &b)
Definition: SkRect.h:535
int32_t fBottom
larger y-axis bounds
Definition: SkRect.h:36
constexpr int32_t top() const
Definition: SkRect.h:120
static constexpr SkIRect MakeLTRB(int32_t l, int32_t t, int32_t r, int32_t b)
Definition: SkRect.h:91
void offsetTo(int32_t newX, int32_t newY)
Definition: SkRect.h:394
bool containsNoEmptyCheck(const SkIRect &r) const
Definition: SkRect.h:499
constexpr SkISize size() const
Definition: SkRect.h:172
constexpr int32_t bottom() const
Definition: SkRect.h:134
constexpr int32_t height() const
Definition: SkRect.h:165
constexpr int32_t right() const
Definition: SkRect.h:127
int32_t fTop
smaller y-axis bounds
Definition: SkRect.h:34
constexpr SkIRect makeOffset(SkIVector offset) const
Definition: SkRect.h:317
static constexpr SkIRect MakeSize(const SkISize &size)
Definition: SkRect.h:66
static constexpr SkIRect MakeEmpty()
Definition: SkRect.h:45
constexpr int32_t width() const
Definition: SkRect.h:158
friend bool operator==(const SkIRect &a, const SkIRect &b)
Definition: SkRect.h:219
constexpr int64_t width64() const
Definition: SkRect.h:180
void offset(int32_t dx, int32_t dy)
Definition: SkRect.h:367
void setEmpty()
Definition: SkRect.h:242
constexpr SkIRect makeOffset(int32_t dx, int32_t dy) const
Definition: SkRect.h:300
static constexpr SkIRect MakeWH(int32_t w, int32_t h)
Definition: SkRect.h:56
bool isEmpty() const
Definition: SkRect.h:202
void setXYWH(int32_t x, int32_t y, int32_t width, int32_t height)
Definition: SkRect.h:268
constexpr SkIPoint topLeft() const
Definition: SkRect.h:151
void setWH(int32_t width, int32_t height)
Definition: SkRect.h:275
static constexpr SkIRect MakeXYWH(int32_t x, int32_t y, int32_t w, int32_t h)
Definition: SkRect.h:104
SkIRect makeInset(int32_t dx, int32_t dy) const
Definition: SkRect.h:332
int32_t fLeft
smaller x-axis bounds
Definition: SkRect.h:33
SkIRect makeSorted() const
Definition: SkRect.h:569
void outset(int32_t dx, int32_t dy)
Definition: SkRect.h:428
static constexpr SkIRect MakePtSize(SkIPoint pt, SkISize size)
Definition: SkRect.h:78
constexpr int32_t left() const
Definition: SkRect.h:113
void setLTRB(int32_t left, int32_t top, int32_t right, int32_t bottom)
Definition: SkRect.h:253
bool contains(int32_t x, int32_t y) const
Definition: SkRect.h:463
int32_t fRight
larger x-axis bounds
Definition: SkRect.h:35
void setSize(SkISize size)
Definition: SkRect.h:282
Definition: SkSize.h:16
static constexpr SkISize Make(int32_t w, int32_t h)
Definition: SkSize.h:20
float fX
x-axis value
Definition: SkPoint_impl.h:164
float fY
y-axis value
Definition: SkPoint_impl.h:165
constexpr float y() const
Definition: SkPoint_impl.h:187
constexpr float x() const
Definition: SkPoint_impl.h:181
constexpr SkRect makeOffset(SkVector v) const
Definition: SkRect.h:974
SkRect makeSorted() const
Definition: SkRect.h:1330
static SkRect Make(const SkISize &size)
Definition: SkRect.h:669
void offsetTo(float newX, float newY)
Definition: SkRect.h:1043
static constexpr SkRect MakeEmpty()
Definition: SkRect.h:595
static bool Intersects(const SkRect &a, const SkRect &b)
Definition: SkRect.h:1133
SkScalar fBottom
larger y-axis bounds
Definition: extension.cpp:17
bool contains(float x, float y) const
Definition: SkRect.h:1188
void joinNonEmptyArg(const SkRect &r)
Definition: SkRect.h:1158
constexpr float left() const
Definition: SkRect.h:734
void offset(const SkPoint &delta)
Definition: SkRect.h:1033
static SkRect Make(const SkIRect &irect)
Definition: SkRect.h:680
friend bool operator==(const SkRect &a, const SkRect &b)
Definition: SkRect.h:804
void inset(float dx, float dy)
Definition: SkRect.h:1060
void setXYWH(float x, float y, float width, float height)
Definition: SkRect.h:931
constexpr SkRect makeOffset(float dx, float dy) const
Definition: SkRect.h:965
bool isFinite() const
Definition: SkRect.h:711
constexpr float top() const
Definition: SkRect.h:741
void joinPossiblyEmptyRect(const SkRect &r)
Definition: SkRect.h:1174
void roundIn(SkIRect *dst) const
Definition: SkRect.h:1266
SkScalar fLeft
smaller x-axis bounds
Definition: extension.cpp:14
constexpr float x() const
Definition: SkRect.h:720
static SkRect MakeIWH(int w, int h)
Definition: SkRect.h:623
void outset(float dx, float dy)
Definition: SkRect.h:1077
const float * asScalars() const
Definition: SkRect.h:1340
void roundOut(SkRect *dst) const
Definition: SkRect.h:1254
constexpr float y() const
Definition: SkRect.h:727
SkRect makeOutset(float dx, float dy) const
Definition: SkRect.h:1002
void setWH(float width, float height)
Definition: SkRect.h:944
static constexpr SkRect MakeXYWH(float x, float y, float w, float h)
Definition: SkRect.h:659
bool contains(const SkRect &r) const
Definition: SkRect.h:1200
bool intersects(const SkRect &r) const
Definition: SkRect.h:1121
SkRect makeInset(float dx, float dy) const
Definition: SkRect.h:987
void set(const SkPoint &p0, const SkPoint &p1)
Definition: SkRect.h:916
bool contains(const SkIRect &r) const
Definition: SkRect.h:1215
SkScalar fRight
larger x-axis bounds
Definition: extension.cpp:16
SkIRect roundOut() const
Definition: SkRect.h:1291
void roundOut(SkIRect *dst) const
Definition: SkRect.h:1241
constexpr float centerX() const
Definition: SkRect.h:776
void offset(float dx, float dy)
Definition: SkRect.h:1016
static constexpr SkRect MakeSize(const SkSize &size)
Definition: SkRect.h:633
SkIRect roundIn() const
Definition: SkRect.h:1303
void round(SkIRect *dst) const
Definition: SkRect.h:1228
constexpr float height() const
Definition: SkRect.h:769
constexpr float right() const
Definition: SkRect.h:748
SkIRect round() const
Definition: SkRect.h:1278
void setIWH(int32_t width, int32_t height)
Definition: SkRect.h:950
void setLTRB(float left, float top, float right, float bottom)
Definition: SkRect.h:865
void setBounds(const SkPoint pts[], int count)
Definition: SkRect.h:881
constexpr float centerY() const
Definition: SkRect.h:785
constexpr float width() const
Definition: SkRect.h:762
bool isEmpty() const
Definition: SkRect.h:693
void sort()
Definition: SkRect.h:1313
constexpr SkPoint center() const
Definition: SkRect.h:792
void dump() const
Definition: SkRect.h:1356
void dumpHex() const
Definition: SkRect.h:1365
friend bool operator!=(const SkRect &a, const SkRect &b)
Definition: SkRect.h:821
static constexpr SkRect MakeWH(float w, float h)
Definition: SkRect.h:609
static constexpr SkRect MakeLTRB(float l, float t, float r, float b)
Definition: SkRect.h:646
bool isSorted() const
Definition: SkRect.h:705
void set(const SkIRect &src)
Definition: SkRect.h:849
constexpr float bottom() const
Definition: SkRect.h:755
SkScalar fTop
smaller y-axis bounds
Definition: extension.cpp:15
void setEmpty()
Definition: SkRect.h:842
Definition: SkSize.h:52