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 
11 #include "include/core/SkMatrix.h"
12 #include "include/core/SkPoint.h"
13 #include "include/core/SkPoint3.h"
14 #include "include/private/SkVx.h"
15 
16 enum class GrQuadAAFlags;
17 
18 /**
19  * GrQuad is a collection of 4 points which can be used to represent an arbitrary quadrilateral. The
20  * points make a triangle strip with CCW triangles (top-left, bottom-left, top-right, bottom-right).
21  */
22 class GrQuad {
23 public:
24     // Quadrilaterals can be classified in several useful ways that assist AA tessellation and other
25     // analysis when drawing, in particular, knowing if it was originally a rectangle transformed by
26     // certain types of matrices:
27     enum class Type {
28         // The 4 points remain an axis-aligned rectangle; their logical indices may not respect
29         // TL, BL, TR, BR ordering if the transform was a 90 degree rotation or mirror.
30         kAxisAligned,
31         // The 4 points represent a rectangle subjected to a rotation, its corners are right angles.
32         kRectilinear,
33         // Arbitrary 2D quadrilateral; may have been a rectangle transformed with skew or some
34         // clipped polygon. Its w coordinates will all be 1.
35         kGeneral,
36         // Even more general-purpose than kGeneral, this allows the w coordinates to be non-unity.
37         kPerspective,
38         kLast = kPerspective
39     };
40     static const int kTypeCount = static_cast<int>(Type::kLast) + 1;
41 
42     // This enforces W == 1 for non-perspective quads, but does not initialize X or Y.
43     GrQuad() = default;
44 
GrQuad(const SkRect & rect)45     explicit GrQuad(const SkRect& rect)
46             : fX{rect.fLeft, rect.fLeft, rect.fRight, rect.fRight}
47             , fY{rect.fTop, rect.fBottom, rect.fTop, rect.fBottom} {}
48 
49     static GrQuad MakeFromRect(const SkRect&, const SkMatrix&);
50 
51     // Creates a GrQuad from the quadrilateral 'pts', transformed by the matrix. The input
52     // points array is arranged as per SkRect::toQuad (top-left, top-right, bottom-right,
53     // bottom-left). The returned instance's point order will still be CCW tri-strip order.
54     static GrQuad MakeFromSkQuad(const SkPoint pts[4], const SkMatrix&);
55 
56     GrQuad& operator=(const GrQuad&) = default;
57 
point3(int i)58     SkPoint3 point3(int i) const { return {fX[i], fY[i], fW[i]}; }
59 
point(int i)60     SkPoint point(int i) const {
61         if (fType == Type::kPerspective) {
62             return {fX[i] / fW[i], fY[i] / fW[i]};
63         } else {
64             return {fX[i], fY[i]};
65         }
66     }
67 
bounds()68     SkRect bounds() const {
69         if (fType == GrQuad::Type::kPerspective) {
70             return this->projectedBounds();
71         }
72         // Calculate min/max directly on the 4 floats, instead of loading/unloading into SIMD. Since
73         // there's no horizontal min/max, it's not worth it. Defining non-perspective case in header
74         // also leads to substantial performance boost due to inlining.
75         auto min = [](const float c[4]) { return std::min(std::min(c[0], c[1]),
76                                                           std::min(c[2], c[3]));};
77         auto max = [](const float c[4]) { return std::max(std::max(c[0], c[1]),
78                                                           std::max(c[2], c[3]));};
79         return { min(fX), min(fY), max(fX), max(fY) };
80     }
81 
isFinite()82     bool isFinite() const {
83         // If any coordinate is infinity or NaN, then multiplying it with 0 will make accum NaN
84         float accum = 0;
85         for (int i = 0; i < 4; ++i) {
86             accum *= fX[i];
87             accum *= fY[i];
88             accum *= fW[i];
89         }
90         SkASSERT(0 == accum || SkScalarIsNaN(accum));
91         return !SkScalarIsNaN(accum);
92     }
93 
x(int i)94     float x(int i) const { return fX[i]; }
y(int i)95     float y(int i) const { return fY[i]; }
w(int i)96     float w(int i) const { return fW[i]; }
iw(int i)97     float iw(int i) const { return sk_ieee_float_divide(1.f, fW[i]); }
98 
x4f()99     skvx::Vec<4, float> x4f() const { return skvx::Vec<4, float>::Load(fX); }
y4f()100     skvx::Vec<4, float> y4f() const { return skvx::Vec<4, float>::Load(fY); }
w4f()101     skvx::Vec<4, float> w4f() const { return skvx::Vec<4, float>::Load(fW); }
iw4f()102     skvx::Vec<4, float> iw4f() const { return 1.f / this->w4f(); }
103 
quadType()104     Type quadType() const { return fType; }
105 
hasPerspective()106     bool hasPerspective() const { return fType == Type::kPerspective; }
107 
108     // True if anti-aliasing affects this quad. Only valid when quadType == kAxisAligned
109     bool aaHasEffectOnRect() const;
110 
111     // True if this quad is axis-aligned and still has its top-left corner at v0. Equivalently,
112     // quad == GrQuad(quad->bounds()). Axis-aligned quads with flips and rotations may exactly
113     // fill their bounds, but their vertex order will not match TL BL TR BR anymore.
114     bool asRect(SkRect* rect) const;
115 
116     // The non-const pointers are provided to support modifying a GrQuad in-place, but care must be
117     // taken to keep its quad type aligned with the geometric nature of the new coordinates.
xs()118     const float* xs() const { return fX; }
xs()119     float* xs() { return fX; }
ys()120     const float* ys() const { return fY; }
ys()121     float* ys() { return fY; }
ws()122     const float* ws() const { return fW; }
ws()123     float* ws() { return fW; }
124 
125     // Automatically ensures ws are 1 if new type is not perspective.
setQuadType(Type newType)126     void setQuadType(Type newType) {
127         if (newType != Type::kPerspective && fType == Type::kPerspective) {
128             fW[0] = fW[1] = fW[2] = fW[3] = 1.f;
129         }
130         SkASSERT(newType == Type::kPerspective ||
131                  (SkScalarNearlyEqual(fW[0], 1.f) && SkScalarNearlyEqual(fW[1], 1.f) &&
132                   SkScalarNearlyEqual(fW[2], 1.f) && SkScalarNearlyEqual(fW[3], 1.f)));
133 
134         fType = newType;
135     }
136 private:
137     template<typename T>
138     friend class GrQuadListBase; // for access to fX, fY, fW
139 
GrQuad(const skvx::Vec<4,float> & xs,const skvx::Vec<4,float> & ys,Type type)140     GrQuad(const skvx::Vec<4, float>& xs, const skvx::Vec<4, float>& ys, Type type)
141             : fType(type) {
142         SkASSERT(type != Type::kPerspective);
143         xs.store(fX);
144         ys.store(fY);
145     }
146 
GrQuad(const skvx::Vec<4,float> & xs,const skvx::Vec<4,float> & ys,const skvx::Vec<4,float> & ws,Type type)147     GrQuad(const skvx::Vec<4, float>& xs, const skvx::Vec<4, float>& ys,
148            const skvx::Vec<4, float>& ws, Type type)
149             : fW{} // Include fW in member initializer to avoid redundant default initializer
150             , fType(type) {
151         xs.store(fX);
152         ys.store(fY);
153         ws.store(fW);
154     }
155 
156     // Defined in GrQuadUtils.cpp to share the coord clipping code
157     SkRect projectedBounds() const;
158 
159     float fX[4];
160     float fY[4];
161     float fW[4] = {1.f, 1.f, 1.f, 1.f};
162 
163     Type fType = Type::kAxisAligned;
164 };
165 
166 // A simple struct representing the common work unit of a pair of device and local coordinates, as
167 // well as the edge flags controlling anti-aliasing for the quadrilateral when drawn.
168 struct DrawQuad {
169     GrQuad        fDevice;
170     GrQuad        fLocal;
171     GrQuadAAFlags fEdgeFlags;
172 };
173 
174 #endif
175