blob: c238d102e4b3072fd0ed755e2a775a8661171847 [file] [log] [blame]
bsalomon@google.com69cc6ad2012-01-17 14:25:10 +00001/*
2 * Copyright 2012 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 "GrAAConvexPathRenderer.h"
9
robertphillipse16dfdb2015-05-08 04:46:51 -070010#include "GrAAConvexTessellator.h"
bsalomoneb1cb5c2015-05-22 08:01:09 -070011#include "GrCaps.h"
bsalomon@google.com69cc6ad2012-01-17 14:25:10 +000012#include "GrContext.h"
robertphillipse16dfdb2015-05-08 04:46:51 -070013#include "GrDefaultGeoProcFactory.h"
Brian Salomon5ec9def2016-12-20 15:34:05 -050014#include "GrDrawOpTest.h"
joshualitteb2a6762014-12-04 11:35:33 -080015#include "GrGeometryProcessor.h"
Brian Salomon742e31d2016-12-07 17:06:19 -050016#include "GrOpFlushState.h"
bsalomon@google.com69cc6ad2012-01-17 14:25:10 +000017#include "GrPathUtils.h"
Brian Salomondad29232016-12-01 16:40:24 -050018#include "GrProcessor.h"
Brian Salomon10978a62017-06-15 16:21:49 -040019#include "GrSimpleMeshDrawOpHelper.h"
egdanielaf18a092015-01-05 10:22:28 -080020#include "SkGeometry.h"
reed026beb52015-06-10 14:23:15 -070021#include "SkPathPriv.h"
Cary Clarkdf429f32017-11-08 11:44:31 -050022#include "SkPointPriv.h"
bsalomon@google.com69cc6ad2012-01-17 14:25:10 +000023#include "SkString.h"
commit-bot@chromium.org933e65d2014-03-20 20:00:24 +000024#include "SkTraceEvent.h"
egdaniel7ea439b2015-12-03 09:20:44 -080025#include "glsl/GrGLSLFragmentShaderBuilder.h"
egdaniele659a582015-11-13 09:55:43 -080026#include "glsl/GrGLSLGeometryProcessor.h"
egdaniel018fb622015-10-28 07:26:40 -070027#include "glsl/GrGLSLProgramDataManager.h"
egdaniel7ea439b2015-12-03 09:20:44 -080028#include "glsl/GrGLSLUniformHandler.h"
egdaniel0eafe792015-11-20 14:01:22 -080029#include "glsl/GrGLSLVarying.h"
Chris Daltonc17bf322017-10-24 10:59:03 -060030#include "glsl/GrGLSLVertexGeoBuilder.h"
Brian Salomon89527432016-12-16 09:52:16 -050031#include "ops/GrMeshDrawOp.h"
commit-bot@chromium.org234d4fb2013-09-30 19:55:49 +000032
bsalomon@google.com69cc6ad2012-01-17 14:25:10 +000033GrAAConvexPathRenderer::GrAAConvexPathRenderer() {
34}
35
bsalomon@google.com69cc6ad2012-01-17 14:25:10 +000036struct Segment {
37 enum {
bsalomon@google.com9b1517e2012-03-05 17:58:34 +000038 // These enum values are assumed in member functions below.
39 kLine = 0,
40 kQuad = 1,
bsalomon@google.com69cc6ad2012-01-17 14:25:10 +000041 } fType;
bsalomon@google.com9b1517e2012-03-05 17:58:34 +000042
bsalomon@google.com9aed1142012-01-30 14:28:39 +000043 // line uses one pt, quad uses 2 pts
commit-bot@chromium.org972f9cd2014-03-28 17:58:28 +000044 SkPoint fPts[2];
bsalomon@google.com9aed1142012-01-30 14:28:39 +000045 // normal to edge ending at each pt
commit-bot@chromium.org972f9cd2014-03-28 17:58:28 +000046 SkVector fNorms[2];
bsalomon@google.com9aed1142012-01-30 14:28:39 +000047 // is the corner where the previous segment meets this segment
48 // sharp. If so, fMid is a normalized bisector facing outward.
commit-bot@chromium.org972f9cd2014-03-28 17:58:28 +000049 SkVector fMid;
bsalomon@google.com9aed1142012-01-30 14:28:39 +000050
51 int countPoints() {
bsalomon@google.com9b1517e2012-03-05 17:58:34 +000052 GR_STATIC_ASSERT(0 == kLine && 1 == kQuad);
53 return fType + 1;
bsalomon@google.com9aed1142012-01-30 14:28:39 +000054 }
55 const SkPoint& endPt() const {
bsalomon@google.com9b1517e2012-03-05 17:58:34 +000056 GR_STATIC_ASSERT(0 == kLine && 1 == kQuad);
57 return fPts[fType];
Mike Kleinfc6c37b2016-09-27 09:34:10 -040058 }
bsalomon@google.com9aed1142012-01-30 14:28:39 +000059 const SkPoint& endNorm() const {
bsalomon@google.com9b1517e2012-03-05 17:58:34 +000060 GR_STATIC_ASSERT(0 == kLine && 1 == kQuad);
61 return fNorms[fType];
Mike Kleinfc6c37b2016-09-27 09:34:10 -040062 }
bsalomon@google.com69cc6ad2012-01-17 14:25:10 +000063};
64
65typedef SkTArray<Segment, true> SegmentArray;
66
commit-bot@chromium.orgfdfbb9d2013-08-15 18:16:27 +000067static void center_of_mass(const SegmentArray& segments, SkPoint* c) {
bsalomon@google.com81712882012-11-01 17:12:34 +000068 SkScalar area = 0;
vandebo@chromium.org6390c722012-03-28 21:03:22 +000069 SkPoint center = {0, 0};
bsalomon@google.com9aed1142012-01-30 14:28:39 +000070 int count = segments.count();
vandebo@chromium.org6390c722012-03-28 21:03:22 +000071 SkPoint p0 = {0, 0};
bsalomon@google.com5b56d9e2012-02-23 19:18:37 +000072 if (count > 2) {
73 // We translate the polygon so that the first point is at the origin.
74 // This avoids some precision issues with small area polygons far away
75 // from the origin.
76 p0 = segments[0].endPt();
77 SkPoint pi;
78 SkPoint pj;
bsalomon@google.coma51ab842012-07-10 19:53:34 +000079 // the first and last iteration of the below loop would compute
bsalomon@google.com5b56d9e2012-02-23 19:18:37 +000080 // zeros since the starting / ending point is (0,0). So instead we start
81 // at i=1 and make the last iteration i=count-2.
82 pj = segments[1].endPt() - p0;
83 for (int i = 1; i < count - 1; ++i) {
84 pi = pj;
robertphillips44c31282015-09-03 12:58:48 -070085 pj = segments[i + 1].endPt() - p0;
bsalomon@google.com5b56d9e2012-02-23 19:18:37 +000086
robertphillips44c31282015-09-03 12:58:48 -070087 SkScalar t = SkPoint::CrossProduct(pi, pj);
bsalomon@google.com5b56d9e2012-02-23 19:18:37 +000088 area += t;
89 center.fX += (pi.fX + pj.fX) * t;
90 center.fY += (pi.fY + pj.fY) * t;
bsalomon@google.com5b56d9e2012-02-23 19:18:37 +000091 }
bsalomon@google.com9aed1142012-01-30 14:28:39 +000092 }
robertphillips44c31282015-09-03 12:58:48 -070093
bsalomon@google.com278dc692012-02-15 16:52:51 +000094 // If the poly has no area then we instead return the average of
95 // its points.
bsalomon@google.com5b56d9e2012-02-23 19:18:37 +000096 if (SkScalarNearlyZero(area)) {
bsalomon@google.com278dc692012-02-15 16:52:51 +000097 SkPoint avg;
98 avg.set(0, 0);
99 for (int i = 0; i < count; ++i) {
100 const SkPoint& pt = segments[i].endPt();
101 avg.fX += pt.fX;
102 avg.fY += pt.fY;
103 }
104 SkScalar denom = SK_Scalar1 / count;
105 avg.scale(denom);
106 *c = avg;
107 } else {
108 area *= 3;
reed80ea19c2015-05-12 10:37:34 -0700109 area = SkScalarInvert(area);
robertphillips44c31282015-09-03 12:58:48 -0700110 center.scale(area);
bsalomon@google.com5b56d9e2012-02-23 19:18:37 +0000111 // undo the translate of p0 to the origin.
112 *c = center + p0;
bsalomon@google.com278dc692012-02-15 16:52:51 +0000113 }
tfarina@chromium.orgf6de4752013-08-17 00:02:59 +0000114 SkASSERT(!SkScalarIsNaN(c->fX) && !SkScalarIsNaN(c->fY));
bsalomon@google.com9aed1142012-01-30 14:28:39 +0000115}
116
commit-bot@chromium.orgfdfbb9d2013-08-15 18:16:27 +0000117static void compute_vectors(SegmentArray* segments,
118 SkPoint* fanPt,
reed026beb52015-06-10 14:23:15 -0700119 SkPathPriv::FirstDirection dir,
commit-bot@chromium.orgfdfbb9d2013-08-15 18:16:27 +0000120 int* vCount,
121 int* iCount) {
bsalomon@google.com9aed1142012-01-30 14:28:39 +0000122 center_of_mass(*segments, fanPt);
123 int count = segments->count();
124
bsalomon@google.com278dc692012-02-15 16:52:51 +0000125 // Make the normals point towards the outside
Cary Clarkdf429f32017-11-08 11:44:31 -0500126 SkPointPriv::Side normSide;
reed026beb52015-06-10 14:23:15 -0700127 if (dir == SkPathPriv::kCCW_FirstDirection) {
Cary Clarkdf429f32017-11-08 11:44:31 -0500128 normSide = SkPointPriv::kRight_Side;
bsalomon@google.com278dc692012-02-15 16:52:51 +0000129 } else {
Cary Clarkdf429f32017-11-08 11:44:31 -0500130 normSide = SkPointPriv::kLeft_Side;
bsalomon@google.com278dc692012-02-15 16:52:51 +0000131 }
bsalomon@google.com9aed1142012-01-30 14:28:39 +0000132
133 *vCount = 0;
134 *iCount = 0;
135 // compute normals at all points
136 for (int a = 0; a < count; ++a) {
bsalomon@google.com7d9ffc82013-05-14 14:20:28 +0000137 Segment& sega = (*segments)[a];
bsalomon@google.com9aed1142012-01-30 14:28:39 +0000138 int b = (a + 1) % count;
139 Segment& segb = (*segments)[b];
140
commit-bot@chromium.org972f9cd2014-03-28 17:58:28 +0000141 const SkPoint* prevPt = &sega.endPt();
bsalomon@google.com9aed1142012-01-30 14:28:39 +0000142 int n = segb.countPoints();
143 for (int p = 0; p < n; ++p) {
144 segb.fNorms[p] = segb.fPts[p] - *prevPt;
145 segb.fNorms[p].normalize();
Cary Clarkdf429f32017-11-08 11:44:31 -0500146 SkPointPriv::SetOrthog(&segb.fNorms[p], segb.fNorms[p], normSide);
bsalomon@google.com9aed1142012-01-30 14:28:39 +0000147 prevPt = &segb.fPts[p];
148 }
149 if (Segment::kLine == segb.fType) {
150 *vCount += 5;
151 *iCount += 9;
152 } else {
153 *vCount += 6;
154 *iCount += 12;
155 }
156 }
157
158 // compute mid-vectors where segments meet. TODO: Detect shallow corners
159 // and leave out the wedges and close gaps by stitching segments together.
160 for (int a = 0; a < count; ++a) {
161 const Segment& sega = (*segments)[a];
162 int b = (a + 1) % count;
163 Segment& segb = (*segments)[b];
164 segb.fMid = segb.fNorms[0] + sega.endNorm();
165 segb.fMid.normalize();
166 // corner wedges
167 *vCount += 4;
168 *iCount += 6;
169 }
170}
171
bsalomon@google.com9732f622012-01-31 15:19:21 +0000172struct DegenerateTestData {
173 DegenerateTestData() { fStage = kInitial; }
174 bool isDegenerate() const { return kNonDegenerate != fStage; }
175 enum {
176 kInitial,
177 kPoint,
178 kLine,
179 kNonDegenerate
180 } fStage;
commit-bot@chromium.org972f9cd2014-03-28 17:58:28 +0000181 SkPoint fFirstPoint;
182 SkVector fLineNormal;
bsalomon@google.com81712882012-11-01 17:12:34 +0000183 SkScalar fLineC;
bsalomon@google.com9732f622012-01-31 15:19:21 +0000184};
185
commit-bot@chromium.orgfdfbb9d2013-08-15 18:16:27 +0000186static const SkScalar kClose = (SK_Scalar1 / 16);
Mike Reed8be952a2017-02-13 20:44:33 -0500187static const SkScalar kCloseSqd = kClose * kClose;
bsalomon@google.com9732f622012-01-31 15:19:21 +0000188
commit-bot@chromium.org972f9cd2014-03-28 17:58:28 +0000189static void update_degenerate_test(DegenerateTestData* data, const SkPoint& pt) {
bsalomon@google.com9732f622012-01-31 15:19:21 +0000190 switch (data->fStage) {
191 case DegenerateTestData::kInitial:
192 data->fFirstPoint = pt;
193 data->fStage = DegenerateTestData::kPoint;
194 break;
195 case DegenerateTestData::kPoint:
Cary Clarkdf429f32017-11-08 11:44:31 -0500196 if (SkPointPriv::DistanceToSqd(pt, data->fFirstPoint) > kCloseSqd) {
bsalomon@google.com9732f622012-01-31 15:19:21 +0000197 data->fLineNormal = pt - data->fFirstPoint;
198 data->fLineNormal.normalize();
Cary Clarkdf429f32017-11-08 11:44:31 -0500199 SkPointPriv::SetOrthog(&data->fLineNormal, data->fLineNormal);
bsalomon@google.com9732f622012-01-31 15:19:21 +0000200 data->fLineC = -data->fLineNormal.dot(data->fFirstPoint);
201 data->fStage = DegenerateTestData::kLine;
202 }
203 break;
204 case DegenerateTestData::kLine:
commit-bot@chromium.orgfdfbb9d2013-08-15 18:16:27 +0000205 if (SkScalarAbs(data->fLineNormal.dot(pt) + data->fLineC) > kClose) {
bsalomon@google.com9732f622012-01-31 15:19:21 +0000206 data->fStage = DegenerateTestData::kNonDegenerate;
207 }
208 case DegenerateTestData::kNonDegenerate:
209 break;
210 default:
Ben Wagnerb4aab9a2017-08-16 10:53:04 -0400211 SK_ABORT("Unexpected degenerate test stage.");
bsalomon@google.com9732f622012-01-31 15:19:21 +0000212 }
213}
214
reed026beb52015-06-10 14:23:15 -0700215static inline bool get_direction(const SkPath& path, const SkMatrix& m,
216 SkPathPriv::FirstDirection* dir) {
217 if (!SkPathPriv::CheapComputeFirstDirection(path, dir)) {
bsalomon@google.coma51ab842012-07-10 19:53:34 +0000218 return false;
219 }
bsalomon@google.comaf90f7f2012-03-05 20:50:10 +0000220 // check whether m reverses the orientation
tfarina@chromium.orgf6de4752013-08-17 00:02:59 +0000221 SkASSERT(!m.hasPerspective());
Mike Reed8be952a2017-02-13 20:44:33 -0500222 SkScalar det2x2 = m.get(SkMatrix::kMScaleX) * m.get(SkMatrix::kMScaleY) -
223 m.get(SkMatrix::kMSkewX) * m.get(SkMatrix::kMSkewY);
bsalomon@google.comaf90f7f2012-03-05 20:50:10 +0000224 if (det2x2 < 0) {
reed026beb52015-06-10 14:23:15 -0700225 *dir = SkPathPriv::OppositeFirstDirection(*dir);
bsalomon@google.comaf90f7f2012-03-05 20:50:10 +0000226 }
bsalomon@google.coma51ab842012-07-10 19:53:34 +0000227 return true;
bsalomon@google.comaf90f7f2012-03-05 20:50:10 +0000228}
229
commit-bot@chromium.org106655e2013-09-03 21:28:55 +0000230static inline void add_line_to_segment(const SkPoint& pt,
joshualitt27f398f2015-02-05 14:39:01 -0800231 SegmentArray* segments) {
commit-bot@chromium.orgfdfbb9d2013-08-15 18:16:27 +0000232 segments->push_back();
233 segments->back().fType = Segment::kLine;
234 segments->back().fPts[0] = pt;
235}
236
commit-bot@chromium.org106655e2013-09-03 21:28:55 +0000237static inline void add_quad_segment(const SkPoint pts[3],
joshualitt27f398f2015-02-05 14:39:01 -0800238 SegmentArray* segments) {
Cary Clarkdf429f32017-11-08 11:44:31 -0500239 if (SkPointPriv::DistanceToSqd(pts[0], pts[1]) < kCloseSqd ||
240 SkPointPriv::DistanceToSqd(pts[1], pts[2]) < kCloseSqd) {
commit-bot@chromium.orgfdfbb9d2013-08-15 18:16:27 +0000241 if (pts[0] != pts[2]) {
joshualitt27f398f2015-02-05 14:39:01 -0800242 add_line_to_segment(pts[2], segments);
commit-bot@chromium.orgfdfbb9d2013-08-15 18:16:27 +0000243 }
244 } else {
245 segments->push_back();
246 segments->back().fType = Segment::kQuad;
247 segments->back().fPts[0] = pts[1];
248 segments->back().fPts[1] = pts[2];
249 }
250}
251
252static inline void add_cubic_segments(const SkPoint pts[4],
reed026beb52015-06-10 14:23:15 -0700253 SkPathPriv::FirstDirection dir,
joshualitt27f398f2015-02-05 14:39:01 -0800254 SegmentArray* segments) {
commit-bot@chromium.orgfdfbb9d2013-08-15 18:16:27 +0000255 SkSTArray<15, SkPoint, true> quads;
bsalomon18fab302016-02-16 08:00:05 -0800256 GrPathUtils::convertCubicToQuadsConstrainToTangents(pts, SK_Scalar1, dir, &quads);
commit-bot@chromium.orgfdfbb9d2013-08-15 18:16:27 +0000257 int count = quads.count();
258 for (int q = 0; q < count; q += 3) {
joshualitt27f398f2015-02-05 14:39:01 -0800259 add_quad_segment(&quads[q], segments);
commit-bot@chromium.orgfdfbb9d2013-08-15 18:16:27 +0000260 }
261}
262
263static bool get_segments(const SkPath& path,
264 const SkMatrix& m,
265 SegmentArray* segments,
266 SkPoint* fanPt,
267 int* vCount,
joshualitt27f398f2015-02-05 14:39:01 -0800268 int* iCount) {
bsalomon@google.com69cc6ad2012-01-17 14:25:10 +0000269 SkPath::Iter iter(path, true);
bsalomon@google.com30c174b2012-11-13 14:36:42 +0000270 // This renderer over-emphasizes very thin path regions. We use the distance
bsalomon@google.com5cc90d12012-01-17 16:28:34 +0000271 // to the path from the sample to compute coverage. Every pixel intersected
272 // by the path will be hit and the maximum distance is sqrt(2)/2. We don't
rmistry@google.comfbfcd562012-08-23 18:09:54 +0000273 // notice that the sample may be close to a very thin area of the path and
bsalomon@google.com5cc90d12012-01-17 16:28:34 +0000274 // thus should be very light. This is particularly egregious for degenerate
275 // line paths. We detect paths that are very close to a line (zero area) and
276 // draw nothing.
bsalomon@google.com9732f622012-01-31 15:19:21 +0000277 DegenerateTestData degenerateData;
reed026beb52015-06-10 14:23:15 -0700278 SkPathPriv::FirstDirection dir;
bsalomon@google.coma51ab842012-07-10 19:53:34 +0000279 // get_direction can fail for some degenerate paths.
280 if (!get_direction(path, m, &dir)) {
281 return false;
282 }
bsalomon@google.com9732f622012-01-31 15:19:21 +0000283
bsalomon@google.com69cc6ad2012-01-17 14:25:10 +0000284 for (;;) {
commit-bot@chromium.org972f9cd2014-03-28 17:58:28 +0000285 SkPoint pts[4];
Brian Salomon97042bf2017-02-28 11:21:28 -0500286 SkPath::Verb verb = iter.next(pts, true, true);
bsalomon@google.com94b284d2013-05-10 17:14:06 +0000287 switch (verb) {
288 case SkPath::kMove_Verb:
bsalomon@google.com1a38d552012-03-15 14:40:46 +0000289 m.mapPoints(pts, 1);
bsalomon@google.com9732f622012-01-31 15:19:21 +0000290 update_degenerate_test(&degenerateData, pts[0]);
291 break;
bsalomon@google.com94b284d2013-05-10 17:14:06 +0000292 case SkPath::kLine_Verb: {
commit-bot@chromium.orgfdfbb9d2013-08-15 18:16:27 +0000293 m.mapPoints(&pts[1], 1);
bsalomon@google.com1a38d552012-03-15 14:40:46 +0000294 update_degenerate_test(&degenerateData, pts[1]);
joshualitt27f398f2015-02-05 14:39:01 -0800295 add_line_to_segment(pts[1], segments);
bsalomon@google.com69cc6ad2012-01-17 14:25:10 +0000296 break;
297 }
bsalomon@google.com94b284d2013-05-10 17:14:06 +0000298 case SkPath::kQuad_Verb:
commit-bot@chromium.orgfdfbb9d2013-08-15 18:16:27 +0000299 m.mapPoints(pts, 3);
bsalomon@google.com9732f622012-01-31 15:19:21 +0000300 update_degenerate_test(&degenerateData, pts[1]);
301 update_degenerate_test(&degenerateData, pts[2]);
joshualitt27f398f2015-02-05 14:39:01 -0800302 add_quad_segment(pts, segments);
bsalomon@google.com69cc6ad2012-01-17 14:25:10 +0000303 break;
egdanielaf18a092015-01-05 10:22:28 -0800304 case SkPath::kConic_Verb: {
305 m.mapPoints(pts, 3);
306 SkScalar weight = iter.conicWeight();
307 SkAutoConicToQuads converter;
308 const SkPoint* quadPts = converter.computeQuads(pts, weight, 0.5f);
309 for (int i = 0; i < converter.countQuads(); ++i) {
310 update_degenerate_test(&degenerateData, quadPts[2*i + 1]);
311 update_degenerate_test(&degenerateData, quadPts[2*i + 2]);
joshualitt27f398f2015-02-05 14:39:01 -0800312 add_quad_segment(quadPts + 2*i, segments);
egdanielaf18a092015-01-05 10:22:28 -0800313 }
314 break;
315 }
bsalomon@google.com94b284d2013-05-10 17:14:06 +0000316 case SkPath::kCubic_Verb: {
bsalomon@google.com1a38d552012-03-15 14:40:46 +0000317 m.mapPoints(pts, 4);
bsalomon@google.com9732f622012-01-31 15:19:21 +0000318 update_degenerate_test(&degenerateData, pts[1]);
319 update_degenerate_test(&degenerateData, pts[2]);
320 update_degenerate_test(&degenerateData, pts[3]);
joshualitt27f398f2015-02-05 14:39:01 -0800321 add_cubic_segments(pts, dir, segments);
bsalomon@google.com69cc6ad2012-01-17 14:25:10 +0000322 break;
323 };
bsalomon@google.com94b284d2013-05-10 17:14:06 +0000324 case SkPath::kDone_Verb:
bsalomon@google.com9732f622012-01-31 15:19:21 +0000325 if (degenerateData.isDegenerate()) {
326 return false;
327 } else {
bsalomon@google.com278dc692012-02-15 16:52:51 +0000328 compute_vectors(segments, fanPt, dir, vCount, iCount);
bsalomon@google.com9732f622012-01-31 15:19:21 +0000329 return true;
330 }
bsalomon@google.com69cc6ad2012-01-17 14:25:10 +0000331 default:
332 break;
333 }
334 }
335}
336
337struct QuadVertex {
commit-bot@chromium.org972f9cd2014-03-28 17:58:28 +0000338 SkPoint fPos;
Brian Salomon60fb0b22017-06-15 17:09:36 -0400339 GrColor fColor;
commit-bot@chromium.org972f9cd2014-03-28 17:58:28 +0000340 SkPoint fUV;
bsalomon@google.com81712882012-11-01 17:12:34 +0000341 SkScalar fD0;
342 SkScalar fD1;
bsalomon@google.com69cc6ad2012-01-17 14:25:10 +0000343};
rmistry@google.comfbfcd562012-08-23 18:09:54 +0000344
bsalomon@google.com7d9ffc82013-05-14 14:20:28 +0000345struct Draw {
346 Draw() : fVertexCnt(0), fIndexCnt(0) {}
347 int fVertexCnt;
348 int fIndexCnt;
349};
350
351typedef SkTArray<Draw, true> DrawArray;
352
Brian Salomon60fb0b22017-06-15 17:09:36 -0400353static void create_vertices(const SegmentArray& segments,
commit-bot@chromium.orgfdfbb9d2013-08-15 18:16:27 +0000354 const SkPoint& fanPt,
Brian Salomon60fb0b22017-06-15 17:09:36 -0400355 GrColor color,
356 DrawArray* draws,
357 QuadVertex* verts,
358 uint16_t* idxs) {
bsalomon@google.com7d9ffc82013-05-14 14:20:28 +0000359 Draw* draw = &draws->push_back();
360 // alias just to make vert/index assignments easier to read.
361 int* v = &draw->fVertexCnt;
362 int* i = &draw->fIndexCnt;
bsalomon@google.com69cc6ad2012-01-17 14:25:10 +0000363
bsalomon@google.com9aed1142012-01-30 14:28:39 +0000364 int count = segments.count();
365 for (int a = 0; a < count; ++a) {
366 const Segment& sega = segments[a];
367 int b = (a + 1) % count;
368 const Segment& segb = segments[b];
rmistry@google.comfbfcd562012-08-23 18:09:54 +0000369
bsalomon@google.com7d9ffc82013-05-14 14:20:28 +0000370 // Check whether adding the verts for this segment to the current draw would cause index
371 // values to overflow.
372 int vCount = 4;
373 if (Segment::kLine == segb.fType) {
374 vCount += 5;
375 } else {
376 vCount += 6;
377 }
378 if (draw->fVertexCnt + vCount > (1 << 16)) {
379 verts += *v;
380 idxs += *i;
381 draw = &draws->push_back();
382 v = &draw->fVertexCnt;
383 i = &draw->fIndexCnt;
384 }
385
bsalomon@google.com9aed1142012-01-30 14:28:39 +0000386 // FIXME: These tris are inset in the 1 unit arc around the corner
bsalomon@google.com7d9ffc82013-05-14 14:20:28 +0000387 verts[*v + 0].fPos = sega.endPt();
388 verts[*v + 1].fPos = verts[*v + 0].fPos + sega.endNorm();
389 verts[*v + 2].fPos = verts[*v + 0].fPos + segb.fMid;
390 verts[*v + 3].fPos = verts[*v + 0].fPos + segb.fNorms[0];
Brian Salomon60fb0b22017-06-15 17:09:36 -0400391 verts[*v + 0].fColor = color;
392 verts[*v + 1].fColor = color;
393 verts[*v + 2].fColor = color;
394 verts[*v + 3].fColor = color;
bsalomon@google.com7d9ffc82013-05-14 14:20:28 +0000395 verts[*v + 0].fUV.set(0,0);
396 verts[*v + 1].fUV.set(0,-SK_Scalar1);
397 verts[*v + 2].fUV.set(0,-SK_Scalar1);
398 verts[*v + 3].fUV.set(0,-SK_Scalar1);
399 verts[*v + 0].fD0 = verts[*v + 0].fD1 = -SK_Scalar1;
400 verts[*v + 1].fD0 = verts[*v + 1].fD1 = -SK_Scalar1;
401 verts[*v + 2].fD0 = verts[*v + 2].fD1 = -SK_Scalar1;
402 verts[*v + 3].fD0 = verts[*v + 3].fD1 = -SK_Scalar1;
rmistry@google.comfbfcd562012-08-23 18:09:54 +0000403
bsalomon@google.com7d9ffc82013-05-14 14:20:28 +0000404 idxs[*i + 0] = *v + 0;
405 idxs[*i + 1] = *v + 2;
406 idxs[*i + 2] = *v + 1;
407 idxs[*i + 3] = *v + 0;
408 idxs[*i + 4] = *v + 3;
409 idxs[*i + 5] = *v + 2;
rmistry@google.comfbfcd562012-08-23 18:09:54 +0000410
bsalomon@google.com7d9ffc82013-05-14 14:20:28 +0000411 *v += 4;
412 *i += 6;
bsalomon@google.com69cc6ad2012-01-17 14:25:10 +0000413
bsalomon@google.com9aed1142012-01-30 14:28:39 +0000414 if (Segment::kLine == segb.fType) {
bsalomon@google.com7d9ffc82013-05-14 14:20:28 +0000415 verts[*v + 0].fPos = fanPt;
416 verts[*v + 1].fPos = sega.endPt();
417 verts[*v + 2].fPos = segb.fPts[0];
bsalomon@google.com9aed1142012-01-30 14:28:39 +0000418
bsalomon@google.com7d9ffc82013-05-14 14:20:28 +0000419 verts[*v + 3].fPos = verts[*v + 1].fPos + segb.fNorms[0];
420 verts[*v + 4].fPos = verts[*v + 2].fPos + segb.fNorms[0];
bsalomon@google.com9aed1142012-01-30 14:28:39 +0000421
Brian Salomon60fb0b22017-06-15 17:09:36 -0400422 verts[*v + 0].fColor = color;
423 verts[*v + 1].fColor = color;
424 verts[*v + 2].fColor = color;
425 verts[*v + 3].fColor = color;
426 verts[*v + 4].fColor = color;
427
bsalomon@google.com9aed1142012-01-30 14:28:39 +0000428 // we draw the line edge as a degenerate quad (u is 0, v is the
429 // signed distance to the edge)
Cary Clarkdf429f32017-11-08 11:44:31 -0500430 SkScalar dist = SkPointPriv::DistanceToLineBetween(fanPt, verts[*v + 1].fPos,
431 verts[*v + 2].fPos);
bsalomon@google.com7d9ffc82013-05-14 14:20:28 +0000432 verts[*v + 0].fUV.set(0, dist);
433 verts[*v + 1].fUV.set(0, 0);
434 verts[*v + 2].fUV.set(0, 0);
435 verts[*v + 3].fUV.set(0, -SK_Scalar1);
436 verts[*v + 4].fUV.set(0, -SK_Scalar1);
bsalomon@google.com9aed1142012-01-30 14:28:39 +0000437
bsalomon@google.com7d9ffc82013-05-14 14:20:28 +0000438 verts[*v + 0].fD0 = verts[*v + 0].fD1 = -SK_Scalar1;
439 verts[*v + 1].fD0 = verts[*v + 1].fD1 = -SK_Scalar1;
440 verts[*v + 2].fD0 = verts[*v + 2].fD1 = -SK_Scalar1;
441 verts[*v + 3].fD0 = verts[*v + 3].fD1 = -SK_Scalar1;
442 verts[*v + 4].fD0 = verts[*v + 4].fD1 = -SK_Scalar1;
bsalomon@google.com69cc6ad2012-01-17 14:25:10 +0000443
cdalton35964822015-04-29 10:14:03 -0700444 idxs[*i + 0] = *v + 3;
445 idxs[*i + 1] = *v + 1;
446 idxs[*i + 2] = *v + 2;
bsalomon@google.com9aed1142012-01-30 14:28:39 +0000447
cdalton35964822015-04-29 10:14:03 -0700448 idxs[*i + 3] = *v + 4;
449 idxs[*i + 4] = *v + 3;
bsalomon@google.com7d9ffc82013-05-14 14:20:28 +0000450 idxs[*i + 5] = *v + 2;
bsalomon@google.com9aed1142012-01-30 14:28:39 +0000451
cdalton35964822015-04-29 10:14:03 -0700452 *i += 6;
453
454 // Draw the interior fan if it exists.
455 // TODO: Detect and combine colinear segments. This will ensure we catch every case
456 // with no interior, and that the resulting shared edge uses the same endpoints.
457 if (count >= 3) {
458 idxs[*i + 0] = *v + 0;
459 idxs[*i + 1] = *v + 2;
460 idxs[*i + 2] = *v + 1;
461
462 *i += 3;
463 }
bsalomon@google.com69cc6ad2012-01-17 14:25:10 +0000464
bsalomon@google.com7d9ffc82013-05-14 14:20:28 +0000465 *v += 5;
bsalomon@google.com06809612012-01-21 15:03:39 +0000466 } else {
commit-bot@chromium.org972f9cd2014-03-28 17:58:28 +0000467 SkPoint qpts[] = {sega.endPt(), segb.fPts[0], segb.fPts[1]};
bsalomon@google.com495e2102012-01-21 14:48:36 +0000468
commit-bot@chromium.org972f9cd2014-03-28 17:58:28 +0000469 SkVector midVec = segb.fNorms[0] + segb.fNorms[1];
bsalomon@google.com9aed1142012-01-30 14:28:39 +0000470 midVec.normalize();
bsalomon@google.com06809612012-01-21 15:03:39 +0000471
bsalomon@google.com7d9ffc82013-05-14 14:20:28 +0000472 verts[*v + 0].fPos = fanPt;
473 verts[*v + 1].fPos = qpts[0];
474 verts[*v + 2].fPos = qpts[2];
475 verts[*v + 3].fPos = qpts[0] + segb.fNorms[0];
476 verts[*v + 4].fPos = qpts[2] + segb.fNorms[1];
477 verts[*v + 5].fPos = qpts[1] + midVec;
bsalomon@google.com9aed1142012-01-30 14:28:39 +0000478
Brian Salomon60fb0b22017-06-15 17:09:36 -0400479 verts[*v + 0].fColor = color;
480 verts[*v + 1].fColor = color;
481 verts[*v + 2].fColor = color;
482 verts[*v + 3].fColor = color;
483 verts[*v + 4].fColor = color;
484 verts[*v + 5].fColor = color;
485
bsalomon@google.com81712882012-11-01 17:12:34 +0000486 SkScalar c = segb.fNorms[0].dot(qpts[0]);
bsalomon@google.com7d9ffc82013-05-14 14:20:28 +0000487 verts[*v + 0].fD0 = -segb.fNorms[0].dot(fanPt) + c;
488 verts[*v + 1].fD0 = 0.f;
489 verts[*v + 2].fD0 = -segb.fNorms[0].dot(qpts[2]) + c;
490 verts[*v + 3].fD0 = -SK_ScalarMax/100;
491 verts[*v + 4].fD0 = -SK_ScalarMax/100;
492 verts[*v + 5].fD0 = -SK_ScalarMax/100;
bsalomon@google.com9aed1142012-01-30 14:28:39 +0000493
494 c = segb.fNorms[1].dot(qpts[2]);
bsalomon@google.com7d9ffc82013-05-14 14:20:28 +0000495 verts[*v + 0].fD1 = -segb.fNorms[1].dot(fanPt) + c;
496 verts[*v + 1].fD1 = -segb.fNorms[1].dot(qpts[0]) + c;
497 verts[*v + 2].fD1 = 0.f;
498 verts[*v + 3].fD1 = -SK_ScalarMax/100;
499 verts[*v + 4].fD1 = -SK_ScalarMax/100;
500 verts[*v + 5].fD1 = -SK_ScalarMax/100;
bsalomon@google.com9aed1142012-01-30 14:28:39 +0000501
bsalomon@google.com19713172012-03-15 13:51:08 +0000502 GrPathUtils::QuadUVMatrix toUV(qpts);
Brian Salomon60fb0b22017-06-15 17:09:36 -0400503 toUV.apply<6, sizeof(QuadVertex), offsetof(QuadVertex, fUV)>(verts + *v);
bsalomon@google.com06809612012-01-21 15:03:39 +0000504
bsalomon@google.com7d9ffc82013-05-14 14:20:28 +0000505 idxs[*i + 0] = *v + 3;
506 idxs[*i + 1] = *v + 1;
507 idxs[*i + 2] = *v + 2;
508 idxs[*i + 3] = *v + 4;
509 idxs[*i + 4] = *v + 3;
510 idxs[*i + 5] = *v + 2;
bsalomon@google.com06809612012-01-21 15:03:39 +0000511
bsalomon@google.com7d9ffc82013-05-14 14:20:28 +0000512 idxs[*i + 6] = *v + 5;
513 idxs[*i + 7] = *v + 3;
514 idxs[*i + 8] = *v + 4;
bsalomon@google.com9aed1142012-01-30 14:28:39 +0000515
cdalton35964822015-04-29 10:14:03 -0700516 *i += 9;
517
518 // Draw the interior fan if it exists.
519 // TODO: Detect and combine colinear segments. This will ensure we catch every case
520 // with no interior, and that the resulting shared edge uses the same endpoints.
521 if (count >= 3) {
522 idxs[*i + 0] = *v + 0;
523 idxs[*i + 1] = *v + 2;
524 idxs[*i + 2] = *v + 1;
525
526 *i += 3;
527 }
bsalomon@google.com9aed1142012-01-30 14:28:39 +0000528
bsalomon@google.com7d9ffc82013-05-14 14:20:28 +0000529 *v += 6;
bsalomon@google.com69cc6ad2012-01-17 14:25:10 +0000530 }
531 }
532}
533
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000534///////////////////////////////////////////////////////////////////////////////
535
536/*
537 * Quadratic specified by 0=u^2-v canonical coords. u and v are the first
538 * two components of the vertex attribute. Coverage is based on signed
539 * distance with negative being inside, positive outside. The edge is specified in
540 * window space (y-down). If either the third or fourth component of the interpolated
541 * vertex coord is > 0 then the pixel is considered outside the edge. This is used to
skia.committer@gmail.com041e2db2013-04-03 07:01:14 +0000542 * attempt to trim to a portion of the infinite quad.
543 * Requires shader derivative instruction support.
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000544 */
545
joshualitt249af152014-09-15 11:41:13 -0700546class QuadEdgeEffect : public GrGeometryProcessor {
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000547public:
Brian Salomon60fb0b22017-06-15 17:09:36 -0400548 static sk_sp<GrGeometryProcessor> Make(const SkMatrix& localMatrix, bool usesLocalCoords) {
549 return sk_sp<GrGeometryProcessor>(new QuadEdgeEffect(localMatrix, usesLocalCoords));
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000550 }
551
Brian Salomond3b65972017-03-22 12:05:03 -0400552 ~QuadEdgeEffect() override {}
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000553
mtklein36352bf2015-03-25 18:17:31 -0700554 const char* name() const override { return "QuadEdge"; }
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000555
egdaniel57d3b032015-11-13 11:57:27 -0800556 class GLSLProcessor : public GrGLSLGeometryProcessor {
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000557 public:
Brian Salomon60fb0b22017-06-15 17:09:36 -0400558 GLSLProcessor() {}
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000559
mtklein36352bf2015-03-25 18:17:31 -0700560 void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override {
joshualitt2dd1ae02014-12-03 06:24:10 -0800561 const QuadEdgeEffect& qe = args.fGP.cast<QuadEdgeEffect>();
egdaniel4ca2e602015-11-18 08:01:26 -0800562 GrGLSLVertexBuilder* vertBuilder = args.fVertBuilder;
egdaniel0eafe792015-11-20 14:01:22 -0800563 GrGLSLVaryingHandler* varyingHandler = args.fVaryingHandler;
egdaniel7ea439b2015-12-03 09:20:44 -0800564 GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
joshualitt2dd1ae02014-12-03 06:24:10 -0800565
joshualittabb52a12015-01-13 15:02:10 -0800566 // emit attributes
egdaniel0eafe792015-11-20 14:01:22 -0800567 varyingHandler->emitAttributes(qe);
joshualittabb52a12015-01-13 15:02:10 -0800568
Chris Dalton27372882017-12-08 13:34:21 -0700569 GrGLSLVarying v(kHalf4_GrSLType);
egdaniel0eafe792015-11-20 14:01:22 -0800570 varyingHandler->addVarying("QuadEdge", &v);
Brian Salomon60fb0b22017-06-15 17:09:36 -0400571 vertBuilder->codeAppendf("%s = %s;", v.vsOut(), qe.fInQuadEdge->fName);
572
573 // Setup pass through color
574 varyingHandler->addPassThroughAttribute(qe.fInColor, args.fOutputColor);
joshualitt2dd1ae02014-12-03 06:24:10 -0800575
Chris Dalton60283612018-02-14 13:38:14 -0700576 GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
joshualitt9b989322014-12-15 14:16:27 -0800577
joshualittabb52a12015-01-13 15:02:10 -0800578 // Setup position
Brian Salomon7f235432017-08-16 09:41:48 -0400579 this->writeOutputPosition(vertBuilder, gpArgs, qe.fInPosition->fName);
joshualittabb52a12015-01-13 15:02:10 -0800580
581 // emit transforms
egdaniel7ea439b2015-12-03 09:20:44 -0800582 this->emitTransforms(vertBuilder,
egdaniel0eafe792015-11-20 14:01:22 -0800583 varyingHandler,
egdaniel7ea439b2015-12-03 09:20:44 -0800584 uniformHandler,
Brian Salomon04460cc2017-12-06 14:47:42 -0500585 qe.fInPosition->asShaderVar(),
Brian Salomon60fb0b22017-06-15 17:09:36 -0400586 qe.fLocalMatrix,
bsalomona624bf32016-09-20 09:12:47 -0700587 args.fFPCoordTransformHandler);
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000588
Ethan Nicholasf7b88202017-09-18 14:10:39 -0400589 fragBuilder->codeAppendf("half edgeAlpha;");
joshualitt30ba4362014-08-21 20:18:45 -0700590
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000591 // keep the derivative instructions outside the conditional
Ethan Nicholasf7b88202017-09-18 14:10:39 -0400592 fragBuilder->codeAppendf("half2 duvdx = dFdx(%s.xy);", v.fsIn());
593 fragBuilder->codeAppendf("half2 duvdy = dFdy(%s.xy);", v.fsIn());
egdaniel4ca2e602015-11-18 08:01:26 -0800594 fragBuilder->codeAppendf("if (%s.z > 0.0 && %s.w > 0.0) {", v.fsIn(), v.fsIn());
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000595 // today we know z and w are in device space. We could use derivatives
egdaniel4ca2e602015-11-18 08:01:26 -0800596 fragBuilder->codeAppendf("edgeAlpha = min(min(%s.z, %s.w) + 0.5, 1.0);", v.fsIn(),
597 v.fsIn());
598 fragBuilder->codeAppendf ("} else {");
Ethan Nicholasf7b88202017-09-18 14:10:39 -0400599 fragBuilder->codeAppendf("half2 gF = half2(2.0*%s.x*duvdx.x - duvdx.y,"
egdaniel4ca2e602015-11-18 08:01:26 -0800600 " 2.0*%s.x*duvdy.x - duvdy.y);",
601 v.fsIn(), v.fsIn());
602 fragBuilder->codeAppendf("edgeAlpha = (%s.x*%s.x - %s.y);", v.fsIn(), v.fsIn(),
603 v.fsIn());
604 fragBuilder->codeAppendf("edgeAlpha = "
605 "clamp(0.5 - edgeAlpha / length(gF), 0.0, 1.0);}");
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000606
Ethan Nicholasf7b88202017-09-18 14:10:39 -0400607 fragBuilder->codeAppendf("%s = half4(edgeAlpha);", args.fOutputCoverage);
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000608 }
609
joshualitt9b989322014-12-15 14:16:27 -0800610 static inline void GenKey(const GrGeometryProcessor& gp,
Brian Salomon94efbf52016-11-29 13:43:05 -0500611 const GrShaderCaps&,
joshualitt9b989322014-12-15 14:16:27 -0800612 GrProcessorKeyBuilder* b) {
joshualitte3ababe2015-05-15 07:56:07 -0700613 const QuadEdgeEffect& qee = gp.cast<QuadEdgeEffect>();
Brian Salomon60fb0b22017-06-15 17:09:36 -0400614 b->add32(SkToBool(qee.fUsesLocalCoords && qee.fLocalMatrix.hasPerspective()));
joshualitt9b989322014-12-15 14:16:27 -0800615 }
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000616
egdaniel018fb622015-10-28 07:26:40 -0700617 void setData(const GrGLSLProgramDataManager& pdman,
bsalomona624bf32016-09-20 09:12:47 -0700618 const GrPrimitiveProcessor& gp,
619 FPCoordTransformIter&& transformIter) override {
joshualittb8c241a2015-05-19 08:23:30 -0700620 const QuadEdgeEffect& qe = gp.cast<QuadEdgeEffect>();
bsalomona624bf32016-09-20 09:12:47 -0700621 this->setTransformDataHelper(qe.fLocalMatrix, pdman, &transformIter);
joshualitte3ababe2015-05-15 07:56:07 -0700622 }
623
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000624 private:
egdaniele659a582015-11-13 09:55:43 -0800625 typedef GrGLSLGeometryProcessor INHERITED;
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000626 };
skia.committer@gmail.com041e2db2013-04-03 07:01:14 +0000627
Brian Salomon94efbf52016-11-29 13:43:05 -0500628 void getGLSLProcessorKey(const GrShaderCaps& caps, GrProcessorKeyBuilder* b) const override {
egdaniel57d3b032015-11-13 11:57:27 -0800629 GLSLProcessor::GenKey(*this, caps, b);
joshualitteb2a6762014-12-04 11:35:33 -0800630 }
631
Brian Salomon94efbf52016-11-29 13:43:05 -0500632 GrGLSLPrimitiveProcessor* createGLSLInstance(const GrShaderCaps&) const override {
egdaniel57d3b032015-11-13 11:57:27 -0800633 return new GLSLProcessor();
joshualitteb2a6762014-12-04 11:35:33 -0800634 }
635
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000636private:
Brian Salomon60fb0b22017-06-15 17:09:36 -0400637 QuadEdgeEffect(const SkMatrix& localMatrix, bool usesLocalCoords)
Ethan Nicholasabff9562017-10-09 10:54:08 -0400638 : INHERITED(kQuadEdgeEffect_ClassID)
639 , fLocalMatrix(localMatrix)
640 , fUsesLocalCoords(usesLocalCoords) {
Ethan Nicholasfa7ee242017-09-25 09:52:04 -0400641 fInPosition = &this->addVertexAttrib("inPosition", kFloat2_GrVertexAttribType);
642 fInColor = &this->addVertexAttrib("inColor", kUByte4_norm_GrVertexAttribType);
643 fInQuadEdge = &this->addVertexAttrib("inQuadEdge", kHalf4_GrVertexAttribType);
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000644 }
645
joshualitt71c92602015-01-14 08:12:47 -0800646 const Attribute* fInPosition;
647 const Attribute* fInQuadEdge;
Brian Salomon60fb0b22017-06-15 17:09:36 -0400648 const Attribute* fInColor;
joshualitte3ababe2015-05-15 07:56:07 -0700649 SkMatrix fLocalMatrix;
joshualittb8c241a2015-05-19 08:23:30 -0700650 bool fUsesLocalCoords;
joshualitt249af152014-09-15 11:41:13 -0700651
Brian Salomon0c26a9d2017-07-06 10:09:38 -0400652 GR_DECLARE_GEOMETRY_PROCESSOR_TEST
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000653
joshualitt2e3b3e32014-12-09 13:31:14 -0800654 typedef GrGeometryProcessor INHERITED;
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000655};
656
joshualittb0a8a372014-09-23 09:50:21 -0700657GR_DEFINE_GEOMETRY_PROCESSOR_TEST(QuadEdgeEffect);
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000658
Hal Canary6f6961e2017-01-31 13:50:44 -0500659#if GR_TEST_UTILS
bungeman06ca8ec2016-06-09 08:01:03 -0700660sk_sp<GrGeometryProcessor> QuadEdgeEffect::TestCreate(GrProcessorTestData* d) {
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000661 // Doesn't work without derivative instructions.
Robert Phillips296b1cc2017-03-15 10:42:12 -0400662 return d->caps()->shaderCaps()->shaderDerivativeSupport()
Brian Salomon60fb0b22017-06-15 17:09:36 -0400663 ? QuadEdgeEffect::Make(GrTest::TestMatrix(d->fRandom), d->fRandom->nextBool())
Brian Salomon9ae32a22017-01-25 14:58:24 -0500664 : nullptr;
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000665}
Hal Canary6f6961e2017-01-31 13:50:44 -0500666#endif
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000667
668///////////////////////////////////////////////////////////////////////////////
669
Chris Dalton5ed44232017-09-07 13:22:46 -0600670GrPathRenderer::CanDrawPath
671GrAAConvexPathRenderer::onCanDrawPath(const CanDrawPathArgs& args) const {
672 if (args.fCaps->shaderCaps()->shaderDerivativeSupport() &&
673 (GrAAType::kCoverage == args.fAAType) && args.fShape->style().isSimpleFill() &&
674 !args.fShape->inverseFilled() && args.fShape->knownToBeConvex()) {
675 return CanDrawPath::kYes;
676 }
677 return CanDrawPath::kNo;
robertphillips@google.comfa662942012-05-17 12:20:22 +0000678}
679
robertphillipse16dfdb2015-05-08 04:46:51 -0700680// extract the result vertices and indices from the GrAAConvexTessellator
Brian Salomon60fb0b22017-06-15 17:09:36 -0400681static void extract_lines_only_verts(const GrAAConvexTessellator& tess,
682 void* vertices,
683 size_t vertexStride,
684 GrColor color,
685 uint16_t* idxs,
686 bool tweakAlphaForCoverage) {
robertphillipse16dfdb2015-05-08 04:46:51 -0700687 intptr_t verts = reinterpret_cast<intptr_t>(vertices);
688
689 for (int i = 0; i < tess.numPts(); ++i) {
690 *((SkPoint*)((intptr_t)verts + i * vertexStride)) = tess.point(i);
691 }
692
693 // Make 'verts' point to the colors
694 verts += sizeof(SkPoint);
695 for (int i = 0; i < tess.numPts(); ++i) {
robertphillipse16dfdb2015-05-08 04:46:51 -0700696 if (tweakAlphaForCoverage) {
fmalitabd5d7e72015-06-26 07:18:24 -0700697 SkASSERT(SkScalarRoundToInt(255.0f * tess.coverage(i)) <= 255);
698 unsigned scale = SkScalarRoundToInt(255.0f * tess.coverage(i));
robertphillipse16dfdb2015-05-08 04:46:51 -0700699 GrColor scaledColor = (0xff == scale) ? color : SkAlphaMulQ(color, scale);
700 *reinterpret_cast<GrColor*>(verts + i * vertexStride) = scaledColor;
701 } else {
702 *reinterpret_cast<GrColor*>(verts + i * vertexStride) = color;
halcanary9d524f22016-03-29 09:03:52 -0700703 *reinterpret_cast<float*>(verts + i * vertexStride + sizeof(GrColor)) =
fmalitabd5d7e72015-06-26 07:18:24 -0700704 tess.coverage(i);
robertphillipse16dfdb2015-05-08 04:46:51 -0700705 }
706 }
707
708 for (int i = 0; i < tess.numIndices(); ++i) {
709 idxs[i] = tess.index(i);
710 }
711}
712
Brian Salomon60fb0b22017-06-15 17:09:36 -0400713static sk_sp<GrGeometryProcessor> make_lines_only_gp(bool tweakAlphaForCoverage,
714 const SkMatrix& viewMatrix,
715 bool usesLocalCoords) {
joshualittdf0c5572015-08-03 11:35:28 -0700716 using namespace GrDefaultGeoProcFactory;
joshualitte494a582015-08-03 09:32:36 -0700717
joshualittdf0c5572015-08-03 11:35:28 -0700718 Coverage::Type coverageType;
Brian Salomon8c852be2017-01-04 10:44:42 -0500719 if (tweakAlphaForCoverage) {
joshualittdf0c5572015-08-03 11:35:28 -0700720 coverageType = Coverage::kSolid_Type;
721 } else {
722 coverageType = Coverage::kAttribute_Type;
723 }
Brian Salomon8c852be2017-01-04 10:44:42 -0500724 LocalCoords::Type localCoordsType =
725 usesLocalCoords ? LocalCoords::kUsePosition_Type : LocalCoords::kUnused_Type;
Brian Salomon3de0aee2017-01-29 09:34:17 -0500726 return MakeForDeviceSpace(Color::kPremulGrColorAttribute_Type, coverageType, localCoordsType,
727 viewMatrix);
robertphillipse16dfdb2015-05-08 04:46:51 -0700728}
729
Brian Salomon10978a62017-06-15 16:21:49 -0400730namespace {
731
732class AAConvexPathOp final : public GrMeshDrawOp {
733private:
734 using Helper = GrSimpleMeshDrawOpHelperWithStencil;
735
joshualitt27f398f2015-02-05 14:39:01 -0800736public:
Brian Salomon25a88092016-12-01 09:36:50 -0500737 DEFINE_OP_CLASS_ID
Robert Phillipsb493eeb2017-09-13 13:10:52 -0400738
Brian Salomon10978a62017-06-15 16:21:49 -0400739 static std::unique_ptr<GrDrawOp> Make(GrPaint&& paint, const SkMatrix& viewMatrix,
740 const SkPath& path,
741 const GrUserStencilSettings* stencilSettings) {
742 return Helper::FactoryHelper<AAConvexPathOp>(std::move(paint), viewMatrix, path,
743 stencilSettings);
744 }
745
746 AAConvexPathOp(const Helper::MakeArgs& helperArgs, GrColor color, const SkMatrix& viewMatrix,
747 const SkPath& path, const GrUserStencilSettings* stencilSettings)
Brian Salomon60fb0b22017-06-15 17:09:36 -0400748 : INHERITED(ClassID()), fHelper(helperArgs, GrAAType::kCoverage, stencilSettings) {
749 fPaths.emplace_back(PathData{viewMatrix, path, color});
Brian Salomon10978a62017-06-15 16:21:49 -0400750 this->setTransformedBounds(path.getBounds(), viewMatrix, HasAABloat::kYes, IsZeroArea::kNo);
751 fLinesOnly = SkPath::kLine_SegmentMask == path.getSegmentMasks();
bsalomonf1703092016-06-29 18:41:53 -0700752 }
joshualitt27f398f2015-02-05 14:39:01 -0800753
Brian Salomond0a0a652016-12-15 15:25:22 -0500754 const char* name() const override { return "AAConvexPathOp"; }
joshualitt27f398f2015-02-05 14:39:01 -0800755
Robert Phillipsf1748f52017-09-14 14:11:24 -0400756 void visitProxies(const VisitProxyFunc& func) const override {
Robert Phillipsb493eeb2017-09-13 13:10:52 -0400757 fHelper.visitProxies(func);
758 }
759
Brian Salomon7c3e7182016-12-01 09:35:30 -0500760 SkString dumpInfo() const override {
761 SkString string;
Brian Salomon60fb0b22017-06-15 17:09:36 -0400762 string.appendf("Count: %d\n", fPaths.count());
Brian Salomon10978a62017-06-15 16:21:49 -0400763 string += fHelper.dumpInfo();
764 string += INHERITED::dumpInfo();
Brian Salomon7c3e7182016-12-01 09:35:30 -0500765 return string;
766 }
767
Brian Salomon10978a62017-06-15 16:21:49 -0400768 FixedFunctionFlags fixedFunctionFlags() const override { return fHelper.fixedFunctionFlags(); }
769
Brian Osman9a725dd2017-09-20 09:53:22 -0400770 RequiresDstTexture finalize(const GrCaps& caps, const GrAppliedClip* clip,
771 GrPixelConfigIsClamped dstIsClamped) override {
772 return fHelper.xpRequiresDstTexture(caps, clip, dstIsClamped,
773 GrProcessorAnalysisCoverage::kSingleChannel,
Brian Salomon60fb0b22017-06-15 17:09:36 -0400774 &fPaths.back().fColor);
Brian Salomon10978a62017-06-15 16:21:49 -0400775 }
776
bsalomone46f9fe2015-08-18 06:05:14 -0700777private:
Brian Salomon91326c32017-08-09 16:02:19 -0400778 void prepareLinesOnlyDraws(Target* target) {
Brian Salomon60fb0b22017-06-15 17:09:36 -0400779 // Setup GrGeometryProcessor
780 sk_sp<GrGeometryProcessor> gp(make_lines_only_gp(fHelper.compatibleWithAlphaAsCoverage(),
781 fPaths.back().fViewMatrix,
782 fHelper.usesLocalCoords()));
joshualittdf0c5572015-08-03 11:35:28 -0700783 if (!gp) {
784 SkDebugf("Could not create GrGeometryProcessor\n");
robertphillipse16dfdb2015-05-08 04:46:51 -0700785 return;
786 }
787
robertphillipse16dfdb2015-05-08 04:46:51 -0700788 size_t vertexStride = gp->getVertexStride();
789
Brian Salomon60fb0b22017-06-15 17:09:36 -0400790 SkASSERT(fHelper.compatibleWithAlphaAsCoverage()
791 ? vertexStride == sizeof(GrDefaultGeoProcFactory::PositionColorAttr)
792 : vertexStride ==
793 sizeof(GrDefaultGeoProcFactory::PositionColorCoverageAttr));
robertphillipse16dfdb2015-05-08 04:46:51 -0700794
795 GrAAConvexTessellator tess;
796
Brian Salomond0a0a652016-12-15 15:25:22 -0500797 int instanceCount = fPaths.count();
Brian Salomon10978a62017-06-15 16:21:49 -0400798 const GrPipeline* pipeline = fHelper.makePipeline(target);
robertphillipse16dfdb2015-05-08 04:46:51 -0700799 for (int i = 0; i < instanceCount; i++) {
800 tess.rewind();
801
Brian Salomond0a0a652016-12-15 15:25:22 -0500802 const PathData& args = fPaths[i];
robertphillipse16dfdb2015-05-08 04:46:51 -0700803
804 if (!tess.tessellate(args.fViewMatrix, args.fPath)) {
805 continue;
806 }
807
cdalton397536c2016-03-25 12:15:03 -0700808 const GrBuffer* vertexBuffer;
robertphillipse16dfdb2015-05-08 04:46:51 -0700809 int firstVertex;
810
bsalomon75398562015-08-17 12:55:38 -0700811 void* verts = target->makeVertexSpace(vertexStride, tess.numPts(), &vertexBuffer,
812 &firstVertex);
robertphillipse16dfdb2015-05-08 04:46:51 -0700813 if (!verts) {
814 SkDebugf("Could not allocate vertices\n");
815 return;
816 }
817
cdalton397536c2016-03-25 12:15:03 -0700818 const GrBuffer* indexBuffer;
robertphillipse16dfdb2015-05-08 04:46:51 -0700819 int firstIndex;
820
bsalomon75398562015-08-17 12:55:38 -0700821 uint16_t* idxs = target->makeIndexSpace(tess.numIndices(), &indexBuffer, &firstIndex);
robertphillipse16dfdb2015-05-08 04:46:51 -0700822 if (!idxs) {
823 SkDebugf("Could not allocate indices\n");
824 return;
825 }
826
Brian Salomon60fb0b22017-06-15 17:09:36 -0400827 extract_lines_only_verts(tess, verts, vertexStride, args.fColor, idxs,
828 fHelper.compatibleWithAlphaAsCoverage());
robertphillipse16dfdb2015-05-08 04:46:51 -0700829
Chris Dalton3809bab2017-06-13 10:55:06 -0600830 GrMesh mesh(GrPrimitiveType::kTriangles);
Chris Dalton114a3c02017-05-26 15:17:19 -0600831 mesh.setIndexed(indexBuffer, tess.numIndices(), firstIndex, 0, tess.numPts() - 1);
832 mesh.setVertexData(vertexBuffer, firstVertex);
Brian Salomon10978a62017-06-15 16:21:49 -0400833 target->draw(gp.get(), pipeline, mesh);
robertphillipse16dfdb2015-05-08 04:46:51 -0700834 }
joshualitt27f398f2015-02-05 14:39:01 -0800835 }
836
Brian Salomon91326c32017-08-09 16:02:19 -0400837 void onPrepareDraws(Target* target) override {
robertphillipse16dfdb2015-05-08 04:46:51 -0700838#ifndef SK_IGNORE_LINEONLY_AA_CONVEX_PATH_OPTS
Brian Salomon10978a62017-06-15 16:21:49 -0400839 if (fLinesOnly) {
bsalomon75398562015-08-17 12:55:38 -0700840 this->prepareLinesOnlyDraws(target);
robertphillipse16dfdb2015-05-08 04:46:51 -0700841 return;
842 }
843#endif
Brian Salomon10978a62017-06-15 16:21:49 -0400844 const GrPipeline* pipeline = fHelper.makePipeline(target);
Brian Salomond0a0a652016-12-15 15:25:22 -0500845 int instanceCount = fPaths.count();
joshualitt27f398f2015-02-05 14:39:01 -0800846
847 SkMatrix invert;
Brian Salomon10978a62017-06-15 16:21:49 -0400848 if (fHelper.usesLocalCoords() && !fPaths.back().fViewMatrix.invert(&invert)) {
joshualitt27f398f2015-02-05 14:39:01 -0800849 SkDebugf("Could not invert viewmatrix\n");
850 return;
851 }
852
853 // Setup GrGeometryProcessor
bungeman06ca8ec2016-06-09 08:01:03 -0700854 sk_sp<GrGeometryProcessor> quadProcessor(
Brian Salomon60fb0b22017-06-15 17:09:36 -0400855 QuadEdgeEffect::Make(invert, fHelper.usesLocalCoords()));
joshualitt27f398f2015-02-05 14:39:01 -0800856
joshualitt27f398f2015-02-05 14:39:01 -0800857 // TODO generate all segments for all paths and use one vertex buffer
858 for (int i = 0; i < instanceCount; i++) {
Brian Salomond0a0a652016-12-15 15:25:22 -0500859 const PathData& args = fPaths[i];
joshualitt27f398f2015-02-05 14:39:01 -0800860
861 // We use the fact that SkPath::transform path does subdivision based on
862 // perspective. Otherwise, we apply the view matrix when copying to the
863 // segment representation.
864 const SkMatrix* viewMatrix = &args.fViewMatrix;
joshualitt144c3c82015-11-30 12:30:13 -0800865
866 // We avoid initializing the path unless we have to
867 const SkPath* pathPtr = &args.fPath;
868 SkTLazy<SkPath> tmpPath;
joshualitt27f398f2015-02-05 14:39:01 -0800869 if (viewMatrix->hasPerspective()) {
joshualitt144c3c82015-11-30 12:30:13 -0800870 SkPath* tmpPathPtr = tmpPath.init(*pathPtr);
871 tmpPathPtr->setIsVolatile(true);
872 tmpPathPtr->transform(*viewMatrix);
joshualitt27f398f2015-02-05 14:39:01 -0800873 viewMatrix = &SkMatrix::I();
joshualitt144c3c82015-11-30 12:30:13 -0800874 pathPtr = tmpPathPtr;
joshualitt27f398f2015-02-05 14:39:01 -0800875 }
876
877 int vertexCount;
878 int indexCount;
879 enum {
880 kPreallocSegmentCnt = 512 / sizeof(Segment),
881 kPreallocDrawCnt = 4,
882 };
883 SkSTArray<kPreallocSegmentCnt, Segment, true> segments;
884 SkPoint fanPt;
885
joshualitt144c3c82015-11-30 12:30:13 -0800886 if (!get_segments(*pathPtr, *viewMatrix, &segments, &fanPt, &vertexCount,
joshualitt27f398f2015-02-05 14:39:01 -0800887 &indexCount)) {
888 continue;
889 }
890
Chris Daltonff926502017-05-03 14:36:54 -0400891 const GrBuffer* vertexBuffer;
Chris Daltonbca46e22017-05-15 11:03:26 -0600892 int firstVertex;
893
joshualitt27f398f2015-02-05 14:39:01 -0800894 size_t vertexStride = quadProcessor->getVertexStride();
bsalomon75398562015-08-17 12:55:38 -0700895 QuadVertex* verts = reinterpret_cast<QuadVertex*>(target->makeVertexSpace(
Chris Daltonbca46e22017-05-15 11:03:26 -0600896 vertexStride, vertexCount, &vertexBuffer, &firstVertex));
bsalomone64eb572015-05-07 11:35:55 -0700897
898 if (!verts) {
joshualitt4b31de82015-03-05 14:33:41 -0800899 SkDebugf("Could not allocate vertices\n");
900 return;
901 }
902
cdalton397536c2016-03-25 12:15:03 -0700903 const GrBuffer* indexBuffer;
Chris Daltonbca46e22017-05-15 11:03:26 -0600904 int firstIndex;
905
906 uint16_t *idxs = target->makeIndexSpace(indexCount, &indexBuffer, &firstIndex);
robertphillipse40d3972015-05-07 09:51:43 -0700907 if (!idxs) {
joshualitt4b31de82015-03-05 14:33:41 -0800908 SkDebugf("Could not allocate indices\n");
909 return;
910 }
911
joshualitt27f398f2015-02-05 14:39:01 -0800912 SkSTArray<kPreallocDrawCnt, Draw, true> draws;
Brian Salomon60fb0b22017-06-15 17:09:36 -0400913 create_vertices(segments, fanPt, args.fColor, &draws, verts, idxs);
joshualitt27f398f2015-02-05 14:39:01 -0800914
Chris Dalton3809bab2017-06-13 10:55:06 -0600915 GrMesh mesh(GrPrimitiveType::kTriangles);
Chris Daltonbca46e22017-05-15 11:03:26 -0600916
robertphillips44c31282015-09-03 12:58:48 -0700917 for (int j = 0; j < draws.count(); ++j) {
918 const Draw& draw = draws[j];
Chris Dalton114a3c02017-05-26 15:17:19 -0600919 mesh.setIndexed(indexBuffer, draw.fIndexCnt, firstIndex, 0, draw.fVertexCnt - 1);
920 mesh.setVertexData(vertexBuffer, firstVertex);
Brian Salomon10978a62017-06-15 16:21:49 -0400921 target->draw(quadProcessor.get(), pipeline, mesh);
Chris Daltonbca46e22017-05-15 11:03:26 -0600922 firstIndex += draw.fIndexCnt;
923 firstVertex += draw.fVertexCnt;
joshualitt27f398f2015-02-05 14:39:01 -0800924 }
925 }
926 }
927
Brian Salomon25a88092016-12-01 09:36:50 -0500928 bool onCombineIfPossible(GrOp* t, const GrCaps& caps) override {
Brian Salomond0a0a652016-12-15 15:25:22 -0500929 AAConvexPathOp* that = t->cast<AAConvexPathOp>();
Brian Salomon10978a62017-06-15 16:21:49 -0400930 if (!fHelper.isCompatible(that->fHelper, caps, this->bounds(), that->bounds())) {
joshualitt8cab9a72015-07-16 09:13:50 -0700931 return false;
932 }
Brian Salomon10978a62017-06-15 16:21:49 -0400933 if (fHelper.usesLocalCoords() &&
934 !fPaths[0].fViewMatrix.cheapEqualTo(that->fPaths[0].fViewMatrix)) {
joshualitt27f398f2015-02-05 14:39:01 -0800935 return false;
936 }
937
Brian Salomon10978a62017-06-15 16:21:49 -0400938 if (fLinesOnly != that->fLinesOnly) {
robertphillipse16dfdb2015-05-08 04:46:51 -0700939 return false;
940 }
941
Brian Salomond0a0a652016-12-15 15:25:22 -0500942 fPaths.push_back_n(that->fPaths.count(), that->fPaths.begin());
bsalomon88cf17d2016-07-08 06:40:56 -0700943 this->joinBounds(*that);
joshualitt27f398f2015-02-05 14:39:01 -0800944 return true;
945 }
946
Brian Salomond0a0a652016-12-15 15:25:22 -0500947 struct PathData {
bsalomonf1703092016-06-29 18:41:53 -0700948 SkMatrix fViewMatrix;
949 SkPath fPath;
Brian Salomon60fb0b22017-06-15 17:09:36 -0400950 GrColor fColor;
bsalomonf1703092016-06-29 18:41:53 -0700951 };
952
Brian Salomon10978a62017-06-15 16:21:49 -0400953 Helper fHelper;
Brian Salomond0a0a652016-12-15 15:25:22 -0500954 SkSTArray<1, PathData, true> fPaths;
Brian Salomon10978a62017-06-15 16:21:49 -0400955 bool fLinesOnly;
reed1b55a962015-09-17 20:16:13 -0700956
Brian Salomon10978a62017-06-15 16:21:49 -0400957 typedef GrMeshDrawOp INHERITED;
joshualitt27f398f2015-02-05 14:39:01 -0800958};
959
Brian Salomon10978a62017-06-15 16:21:49 -0400960} // anonymous namespace
961
bsalomon0aff2fa2015-07-31 06:48:27 -0700962bool GrAAConvexPathRenderer::onDrawPath(const DrawPathArgs& args) {
Brian Osman11052242016-10-27 14:47:55 -0400963 GR_AUDIT_TRAIL_AUTO_FRAME(args.fRenderTargetContext->auditTrail(),
robertphillips976f5f02016-06-03 10:59:20 -0700964 "GrAAConvexPathRenderer::onDrawPath");
Brian Salomon7c8460e2017-05-12 11:36:10 -0400965 SkASSERT(GrFSAAType::kUnifiedMSAA != args.fRenderTargetContext->fsaaType());
bsalomon8acedde2016-06-24 10:42:16 -0700966 SkASSERT(!args.fShape->isEmpty());
bsalomon@google.com4647f902013-03-26 14:45:27 +0000967
bsalomonf1703092016-06-29 18:41:53 -0700968 SkPath path;
969 args.fShape->asPath(&path);
bsalomon@google.comaf90f7f2012-03-05 20:50:10 +0000970
Brian Salomon10978a62017-06-15 16:21:49 -0400971 std::unique_ptr<GrDrawOp> op = AAConvexPathOp::Make(std::move(args.fPaint), *args.fViewMatrix,
972 path, args.fUserStencilSettings);
973 args.fRenderTargetContext->addDrawOp(*args.fClip, std::move(op));
bsalomon@google.comc2099d22012-03-02 21:26:50 +0000974 return true;
bsalomon@google.com69cc6ad2012-01-17 14:25:10 +0000975}
joshualitt8e5c1772015-05-11 08:58:52 -0700976
977///////////////////////////////////////////////////////////////////////////////////////////////////
978
Hal Canary6f6961e2017-01-31 13:50:44 -0500979#if GR_TEST_UTILS
joshualitt8e5c1772015-05-11 08:58:52 -0700980
Brian Salomon10978a62017-06-15 16:21:49 -0400981GR_DRAW_OP_TEST_DEFINE(AAConvexPathOp) {
bsalomonf1703092016-06-29 18:41:53 -0700982 SkMatrix viewMatrix = GrTest::TestMatrixInvertible(random);
983 SkPath path = GrTest::TestPathConvex(random);
Brian Salomon10978a62017-06-15 16:21:49 -0400984 const GrUserStencilSettings* stencilSettings = GrGetRandomStencil(random, context);
985 return AAConvexPathOp::Make(std::move(paint), viewMatrix, path, stencilSettings);
joshualitt8e5c1772015-05-11 08:58:52 -0700986}
987
988#endif