1/*
2 * Copyright 2018 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#include "src/gpu/geometry/GrQuad.h"
9
10#include "include/core/SkMatrix.h"
11
12using V4f = skvx::Vec<4, float>;
13
14static bool aa_affects_rect(float ql, float qt, float qr, float qb) {
15 return !SkScalarIsInt(ql) || !SkScalarIsInt(qr) || !SkScalarIsInt(qt) || !SkScalarIsInt(qb);
16}
17
18static void map_rect_translate_scale(const SkRect& rect, const SkMatrix& m,
19 V4f* xs, V4f* ys) {
20 SkMatrix::TypeMask tm = m.getType();
21 SkASSERT(tm <= (SkMatrix::kScale_Mask | SkMatrix::kTranslate_Mask));
22
23 V4f r = V4f::Load(&rect);
24 if (tm > SkMatrix::kIdentity_Mask) {
25 const V4f t{m.getTranslateX(), m.getTranslateY(), m.getTranslateX(), m.getTranslateY()};
26 if (tm <= SkMatrix::kTranslate_Mask) {
27 r += t;
28 } else {
29 const V4f s{m.getScaleX(), m.getScaleY(), m.getScaleX(), m.getScaleY()};
30 r = r * s + t;
31 }
32 }
33 *xs = skvx::shuffle<0, 0, 2, 2>(r);
34 *ys = skvx::shuffle<1, 3, 1, 3>(r);
35}
36
37static void map_quad_general(const V4f& qx, const V4f& qy, const SkMatrix& m,
38 V4f* xs, V4f* ys, V4f* ws) {
39 *xs = m.getScaleX() * qx + (m.getSkewX() * qy + m.getTranslateX());
40 *ys = m.getSkewY() * qx + (m.getScaleY() * qy + m.getTranslateY());
41 if (m.hasPerspective()) {
42 V4f w = m.getPerspX() * qx + (m.getPerspY() * qy + m.get(SkMatrix::kMPersp2));
43 if (ws) {
44 // Output the calculated w coordinates
45 *ws = w;
46 } else {
47 // Apply perspective division immediately
48 V4f iw = 1.f / w;
49 *xs *= iw;
50 *ys *= iw;
51 }
52 } else if (ws) {
53 *ws = 1.f;
54 }
55}
56
57static void map_rect_general(const SkRect& rect, const SkMatrix& matrix,
58 V4f* xs, V4f* ys, V4f* ws) {
59 V4f rx{rect.fLeft, rect.fLeft, rect.fRight, rect.fRight};
60 V4f ry{rect.fTop, rect.fBottom, rect.fTop, rect.fBottom};
61 map_quad_general(rx, ry, matrix, xs, ys, ws);
62}
63
64// Rearranges (top-left, top-right, bottom-right, bottom-left) ordered skQuadPts into xs and ys
65// ordered (top-left, bottom-left, top-right, bottom-right)
66static void rearrange_sk_to_gr_points(const SkPoint skQuadPts[4], V4f* xs, V4f* ys) {
67 *xs = V4f{skQuadPts[0].fX, skQuadPts[3].fX, skQuadPts[1].fX, skQuadPts[2].fX};
68 *ys = V4f{skQuadPts[0].fY, skQuadPts[3].fY, skQuadPts[1].fY, skQuadPts[2].fY};
69}
70
71// If an SkRect is transformed by this matrix, what class of quad is required to represent it.
72static GrQuad::Type quad_type_for_transformed_rect(const SkMatrix& matrix) {
73 if (matrix.rectStaysRect()) {
74 return GrQuad::Type::kAxisAligned;
75 } else if (matrix.preservesRightAngles()) {
76 return GrQuad::Type::kRectilinear;
77 } else if (matrix.hasPerspective()) {
78 return GrQuad::Type::kPerspective;
79 } else {
80 return GrQuad::Type::kGeneral;
81 }
82}
83
84// Perform minimal analysis of 'pts' (which are suitable for MakeFromSkQuad), and determine a
85// quad type that will be as minimally general as possible.
86static GrQuad::Type quad_type_for_points(const SkPoint pts[4], const SkMatrix& matrix) {
87 if (matrix.hasPerspective()) {
88 return GrQuad::Type::kPerspective;
89 }
90 // If 'pts' was formed by SkRect::toQuad() and not transformed further, it is safe to use the
91 // quad type derived from 'matrix'. Otherwise don't waste any more time and assume kStandard
92 // (most general 2D quad).
93 if ((pts[0].fX == pts[3].fX && pts[1].fX == pts[2].fX) &&
94 (pts[0].fY == pts[1].fY && pts[2].fY == pts[3].fY)) {
95 return quad_type_for_transformed_rect(matrix);
96 } else {
97 return GrQuad::Type::kGeneral;
98 }
99}
100
101GrQuad GrQuad::MakeFromRect(const SkRect& rect, const SkMatrix& m) {
102 V4f x, y, w;
103 SkMatrix::TypeMask tm = m.getType();
104 Type type;
105 if (tm <= (SkMatrix::kScale_Mask | SkMatrix::kTranslate_Mask)) {
106 map_rect_translate_scale(rect, m, &x, &y);
107 w = 1.f;
108 type = Type::kAxisAligned;
109 } else {
110 map_rect_general(rect, m, &x, &y, &w);
111 type = quad_type_for_transformed_rect(m);
112 }
113 return GrQuad(x, y, w, type);
114}
115
116GrQuad GrQuad::MakeFromSkQuad(const SkPoint pts[4], const SkMatrix& matrix) {
117 V4f xs, ys;
118 rearrange_sk_to_gr_points(pts, &xs, &ys);
119 Type type = quad_type_for_points(pts, matrix);
120 if (matrix.isIdentity()) {
121 return GrQuad(xs, ys, 1.f, type);
122 } else {
123 V4f mx, my, mw;
124 map_quad_general(xs, ys, matrix, &mx, &my, &mw);
125 return GrQuad(mx, my, mw, type);
126 }
127}
128
129bool GrQuad::aaHasEffectOnRect() const {
130 SkASSERT(this->quadType() == Type::kAxisAligned);
131 // If rect, ws must all be 1s so no need to divide
132 return aa_affects_rect(fX[0], fY[0], fX[3], fY[3]);
133}
134
135bool GrQuad::asRect(SkRect* rect) const {
136 if (this->quadType() != Type::kAxisAligned) {
137 return false;
138 }
139
140 *rect = this->bounds();
141 // v0 at the geometric top-left is unique amongst axis-aligned vertex orders
142 // (90, 180, 270 rotations or axis flips all move v0).
143 return fX[0] == rect->fLeft && fY[0] == rect->fTop;
144}
145