joshualitt | ae5b2c6 | 2015-08-19 08:48:41 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2015 Google Inc. |
| 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 GrQuad_DEFINED |
| 9 | #define GrQuad_DEFINED |
| 10 | |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 11 | #include "include/core/SkMatrix.h" |
| 12 | #include "include/core/SkPoint.h" |
| 13 | #include "include/core/SkPoint3.h" |
Michael Ludwig | b3461fa | 2019-04-30 11:50:55 -0400 | [diff] [blame] | 14 | #include "include/private/SkVx.h" |
joshualitt | ae5b2c6 | 2015-08-19 08:48:41 -0700 | [diff] [blame] | 15 | |
| 16 | /** |
Brian Salomon | 57caa66 | 2017-10-18 12:21:05 +0000 | [diff] [blame] | 17 | * GrQuad is a collection of 4 points which can be used to represent an arbitrary quadrilateral. The |
| 18 | * points make a triangle strip with CCW triangles (top-left, bottom-left, top-right, bottom-right). |
joshualitt | ae5b2c6 | 2015-08-19 08:48:41 -0700 | [diff] [blame] | 19 | */ |
| 20 | class GrQuad { |
| 21 | public: |
Michael Ludwig | de4c58c | 2019-06-04 09:12:59 -0400 | [diff] [blame] | 22 | // Quadrilaterals can be classified in several useful ways that assist AA tessellation and other |
| 23 | // analysis when drawing, in particular, knowing if it was originally a rectangle transformed by |
| 24 | // certain types of matrices: |
| 25 | enum class Type { |
| 26 | // The 4 points remain an axis-aligned rectangle; their logical indices may not respect |
| 27 | // TL, BL, TR, BR ordering if the transform was a 90 degre rotation or mirror. |
| 28 | kAxisAligned, |
| 29 | // The 4 points represent a rectangle subjected to a rotation, its corners are right angles. |
| 30 | kRectilinear, |
| 31 | // Arbitrary 2D quadrilateral; may have been a rectangle transformed with skew or some |
| 32 | // clipped polygon. Its w coordinates will all be 1. |
| 33 | kGeneral, |
| 34 | // Even more general-purpose than kGeneral, this allows the w coordinates to be non-unity. |
| 35 | kPerspective, |
| 36 | kLast = kPerspective |
| 37 | }; |
| 38 | static const int kTypeCount = static_cast<int>(Type::kLast) + 1; |
joshualitt | 8cce8f1 | 2015-08-26 06:23:39 -0700 | [diff] [blame] | 39 | |
Michael Ludwig | de4c58c | 2019-06-04 09:12:59 -0400 | [diff] [blame] | 40 | GrQuad() = default; |
Brian Salomon | a33b67c | 2018-05-17 10:42:14 -0400 | [diff] [blame] | 41 | |
| 42 | explicit GrQuad(const SkRect& rect) |
| 43 | : fX{rect.fLeft, rect.fLeft, rect.fRight, rect.fRight} |
Michael Ludwig | 41f395d | 2019-05-23 13:59:45 -0400 | [diff] [blame] | 44 | , fY{rect.fTop, rect.fBottom, rect.fTop, rect.fBottom} |
Michael Ludwig | 41f395d | 2019-05-23 13:59:45 -0400 | [diff] [blame] | 45 | , fW{1.f, 1.f, 1.f, 1.f} |
Michael Ludwig | de4c58c | 2019-06-04 09:12:59 -0400 | [diff] [blame] | 46 | , fType(Type::kAxisAligned) {} |
Michael Ludwig | e9c57d3 | 2019-02-13 13:39:39 -0500 | [diff] [blame] | 47 | |
Michael Ludwig | de4c58c | 2019-06-04 09:12:59 -0400 | [diff] [blame] | 48 | GrQuad(const skvx::Vec<4, float>& xs, const skvx::Vec<4, float>& ys, Type type) |
Michael Ludwig | 41f395d | 2019-05-23 13:59:45 -0400 | [diff] [blame] | 49 | : fType(type) { |
Michael Ludwig | de4c58c | 2019-06-04 09:12:59 -0400 | [diff] [blame] | 50 | SkASSERT(type != Type::kPerspective); |
Michael Ludwig | e9c57d3 | 2019-02-13 13:39:39 -0500 | [diff] [blame] | 51 | xs.store(fX); |
| 52 | ys.store(fY); |
| 53 | fW[0] = fW[1] = fW[2] = fW[3] = 1.f; |
| 54 | } |
Michael Ludwig | 009b92e | 2019-02-15 16:03:53 -0500 | [diff] [blame] | 55 | |
Michael Ludwig | de4c58c | 2019-06-04 09:12:59 -0400 | [diff] [blame] | 56 | GrQuad(const skvx::Vec<4, float>& xs, const skvx::Vec<4, float>& ys, |
| 57 | const skvx::Vec<4, float>& ws, Type type) |
Michael Ludwig | 41f395d | 2019-05-23 13:59:45 -0400 | [diff] [blame] | 58 | : fType(type) { |
Michael Ludwig | e9c57d3 | 2019-02-13 13:39:39 -0500 | [diff] [blame] | 59 | xs.store(fX); |
| 60 | ys.store(fY); |
| 61 | ws.store(fW); |
| 62 | } |
| 63 | |
Michael Ludwig | de4c58c | 2019-06-04 09:12:59 -0400 | [diff] [blame] | 64 | // Copy 4 values from each of the arrays into the quad's components |
| 65 | GrQuad(const float xs[4], const float ys[4], const float ws[4], Type type) |
| 66 | : fType(type) { |
| 67 | memcpy(fX, xs, 4 * sizeof(float)); |
| 68 | memcpy(fY, ys, 4 * sizeof(float)); |
| 69 | memcpy(fW, ws, 4 * sizeof(float)); |
| 70 | } |
Brian Salomon | be3c1d2 | 2018-05-21 12:54:39 -0400 | [diff] [blame] | 71 | |
Michael Ludwig | de4c58c | 2019-06-04 09:12:59 -0400 | [diff] [blame] | 72 | static GrQuad MakeFromRect(const SkRect&, const SkMatrix&); |
| 73 | |
| 74 | // Creates a GrQuad from the quadrilateral 'pts', transformed by the matrix. The input |
Michael Ludwig | 009b92e | 2019-02-15 16:03:53 -0500 | [diff] [blame] | 75 | // points array is arranged as per SkRect::toQuad (top-left, top-right, bottom-right, |
| 76 | // bottom-left). The returned instance's point order will still be CCW tri-strip order. |
Michael Ludwig | de4c58c | 2019-06-04 09:12:59 -0400 | [diff] [blame] | 77 | static GrQuad MakeFromSkQuad(const SkPoint pts[4], const SkMatrix&); |
Michael Ludwig | 009b92e | 2019-02-15 16:03:53 -0500 | [diff] [blame] | 78 | |
Michael Ludwig | de4c58c | 2019-06-04 09:12:59 -0400 | [diff] [blame] | 79 | GrQuad& operator=(const GrQuad&) = default; |
Brian Salomon | be3c1d2 | 2018-05-21 12:54:39 -0400 | [diff] [blame] | 80 | |
Michael Ludwig | de4c58c | 2019-06-04 09:12:59 -0400 | [diff] [blame] | 81 | SkPoint3 point3(int i) const { return {fX[i], fY[i], fW[i]}; } |
| 82 | |
| 83 | SkPoint point(int i) const { |
| 84 | if (fType == Type::kPerspective) { |
| 85 | return {fX[i] / fW[i], fY[i] / fW[i]}; |
| 86 | } else { |
| 87 | return {fX[i], fY[i]}; |
| 88 | } |
| 89 | } |
Brian Salomon | be3c1d2 | 2018-05-21 12:54:39 -0400 | [diff] [blame] | 90 | |
Michael Ludwig | 41f395d | 2019-05-23 13:59:45 -0400 | [diff] [blame] | 91 | SkRect bounds() const { |
Michael Ludwig | b3461fa | 2019-04-30 11:50:55 -0400 | [diff] [blame] | 92 | auto x = this->x4f(); |
| 93 | auto y = this->y4f(); |
Michael Ludwig | de4c58c | 2019-06-04 09:12:59 -0400 | [diff] [blame] | 94 | if (fType == Type::kPerspective) { |
Michael Ludwig | b3461fa | 2019-04-30 11:50:55 -0400 | [diff] [blame] | 95 | auto iw = this->iw4f(); |
Michael Ludwig | c96fc37 | 2019-01-08 15:46:15 -0500 | [diff] [blame] | 96 | x *= iw; |
| 97 | y *= iw; |
| 98 | } |
| 99 | |
Michael Ludwig | b3461fa | 2019-04-30 11:50:55 -0400 | [diff] [blame] | 100 | return {min(x), min(y), max(x), max(y)}; |
Brian Salomon | be3c1d2 | 2018-05-21 12:54:39 -0400 | [diff] [blame] | 101 | } |
| 102 | |
Michael Ludwig | ed71b7e | 2019-06-21 13:47:02 -0400 | [diff] [blame] | 103 | bool isFinite() const { |
| 104 | // If any coordinate is infinity or NaN, then multiplying it with 0 will make accum NaN |
| 105 | float accum = 0; |
| 106 | for (int i = 0; i < 4; ++i) { |
| 107 | accum *= fX[i]; |
| 108 | accum *= fY[i]; |
| 109 | accum *= fW[i]; |
| 110 | } |
| 111 | SkASSERT(0 == accum || SkScalarIsNaN(accum)); |
| 112 | return !SkScalarIsNaN(accum); |
| 113 | } |
| 114 | |
Brian Salomon | be3c1d2 | 2018-05-21 12:54:39 -0400 | [diff] [blame] | 115 | float x(int i) const { return fX[i]; } |
| 116 | float y(int i) const { return fY[i]; } |
| 117 | float w(int i) const { return fW[i]; } |
Michael Ludwig | c96fc37 | 2019-01-08 15:46:15 -0500 | [diff] [blame] | 118 | float iw(int i) const { return sk_ieee_float_divide(1.f, fW[i]); } |
Brian Salomon | be3c1d2 | 2018-05-21 12:54:39 -0400 | [diff] [blame] | 119 | |
Michael Ludwig | b3461fa | 2019-04-30 11:50:55 -0400 | [diff] [blame] | 120 | skvx::Vec<4, float> x4f() const { return skvx::Vec<4, float>::Load(fX); } |
| 121 | skvx::Vec<4, float> y4f() const { return skvx::Vec<4, float>::Load(fY); } |
| 122 | skvx::Vec<4, float> w4f() const { return skvx::Vec<4, float>::Load(fW); } |
| 123 | skvx::Vec<4, float> iw4f() const { return 1.f / this->w4f(); } |
Brian Salomon | be3c1d2 | 2018-05-21 12:54:39 -0400 | [diff] [blame] | 124 | |
Michael Ludwig | de4c58c | 2019-06-04 09:12:59 -0400 | [diff] [blame] | 125 | Type quadType() const { return fType; } |
Michael Ludwig | 41f395d | 2019-05-23 13:59:45 -0400 | [diff] [blame] | 126 | |
Michael Ludwig | de4c58c | 2019-06-04 09:12:59 -0400 | [diff] [blame] | 127 | bool hasPerspective() const { return fType == Type::kPerspective; } |
Michael Ludwig | 1f7e438 | 2018-10-19 09:36:57 -0400 | [diff] [blame] | 128 | |
Michael Ludwig | de4c58c | 2019-06-04 09:12:59 -0400 | [diff] [blame] | 129 | // True if anti-aliasing affects this quad. Only valid when quadType == kAxisAligned |
Michael Ludwig | 1f7e438 | 2018-10-19 09:36:57 -0400 | [diff] [blame] | 130 | bool aaHasEffectOnRect() const; |
| 131 | |
Michael Ludwig | 22429f9 | 2019-06-27 10:44:48 -0400 | [diff] [blame] | 132 | // True if this quad is axis-aligned and still has its top-left corner at v0. Equivalently, |
| 133 | // quad == GrQuad(quad->bounds()). Axis-aligned quads with flips and rotations may exactly |
| 134 | // fill their bounds, but their vertex order will not match TL BL TR BR anymore. |
| 135 | bool asRect(SkRect* rect) const; |
| 136 | |
Michael Ludwig | 6132820 | 2019-06-19 14:48:58 +0000 | [diff] [blame] | 137 | // The non-const pointers are provided to support modifying a GrQuad in-place, but care must be |
| 138 | // taken to keep its quad type aligned with the geometric nature of the new coordinates. This is |
| 139 | // no different than using the constructors that accept a quad type. |
Michael Ludwig | 425eb45 | 2019-06-27 10:13:27 -0400 | [diff] [blame] | 140 | const float* xs() const { return fX; } |
Michael Ludwig | 6132820 | 2019-06-19 14:48:58 +0000 | [diff] [blame] | 141 | float* xs() { return fX; } |
Michael Ludwig | 425eb45 | 2019-06-27 10:13:27 -0400 | [diff] [blame] | 142 | const float* ys() const { return fY; } |
Michael Ludwig | 6132820 | 2019-06-19 14:48:58 +0000 | [diff] [blame] | 143 | float* ys() { return fY; } |
Michael Ludwig | 425eb45 | 2019-06-27 10:13:27 -0400 | [diff] [blame] | 144 | const float* ws() const { return fW; } |
Michael Ludwig | 6132820 | 2019-06-19 14:48:58 +0000 | [diff] [blame] | 145 | float* ws() { return fW; } |
| 146 | |
| 147 | void setQuadType(Type newType) { fType = newType; } |
Brian Salomon | be3c1d2 | 2018-05-21 12:54:39 -0400 | [diff] [blame] | 148 | private: |
Michael Ludwig | c96fc37 | 2019-01-08 15:46:15 -0500 | [diff] [blame] | 149 | template<typename T> |
Michael Ludwig | de4c58c | 2019-06-04 09:12:59 -0400 | [diff] [blame] | 150 | friend class GrQuadListBase; // for access to fX, fY, fW |
Michael Ludwig | c96fc37 | 2019-01-08 15:46:15 -0500 | [diff] [blame] | 151 | |
Brian Salomon | be3c1d2 | 2018-05-21 12:54:39 -0400 | [diff] [blame] | 152 | float fX[4]; |
| 153 | float fY[4]; |
| 154 | float fW[4]; |
Michael Ludwig | 41f395d | 2019-05-23 13:59:45 -0400 | [diff] [blame] | 155 | |
Michael Ludwig | de4c58c | 2019-06-04 09:12:59 -0400 | [diff] [blame] | 156 | Type fType; |
Michael Ludwig | c96fc37 | 2019-01-08 15:46:15 -0500 | [diff] [blame] | 157 | }; |
| 158 | |
joshualitt | ae5b2c6 | 2015-08-19 08:48:41 -0700 | [diff] [blame] | 159 | #endif |