blob: 3c84b32df752975a3dd014137a6da18922abd864 [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
Ethan Nicholasf7b88202017-09-18 14:10:39 -0400569 GrGLSLVertToFrag 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
cdalton85285412016-02-18 12:37:07 -0800576 GrGLSLPPFragmentBuilder* 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,
egdaniel4ca2e602015-11-18 08:01:26 -0800585 gpArgs->fPositionVar,
Brian Salomon60fb0b22017-06-15 17:09:36 -0400586 qe.fInPosition->fName,
587 qe.fLocalMatrix,
bsalomona624bf32016-09-20 09:12:47 -0700588 args.fFPCoordTransformHandler);
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000589
Ethan Nicholasf7b88202017-09-18 14:10:39 -0400590 fragBuilder->codeAppendf("half edgeAlpha;");
joshualitt30ba4362014-08-21 20:18:45 -0700591
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000592 // keep the derivative instructions outside the conditional
Ethan Nicholasf7b88202017-09-18 14:10:39 -0400593 fragBuilder->codeAppendf("half2 duvdx = dFdx(%s.xy);", v.fsIn());
594 fragBuilder->codeAppendf("half2 duvdy = dFdy(%s.xy);", v.fsIn());
egdaniel4ca2e602015-11-18 08:01:26 -0800595 fragBuilder->codeAppendf("if (%s.z > 0.0 && %s.w > 0.0) {", v.fsIn(), v.fsIn());
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000596 // today we know z and w are in device space. We could use derivatives
egdaniel4ca2e602015-11-18 08:01:26 -0800597 fragBuilder->codeAppendf("edgeAlpha = min(min(%s.z, %s.w) + 0.5, 1.0);", v.fsIn(),
598 v.fsIn());
599 fragBuilder->codeAppendf ("} else {");
Ethan Nicholasf7b88202017-09-18 14:10:39 -0400600 fragBuilder->codeAppendf("half2 gF = half2(2.0*%s.x*duvdx.x - duvdx.y,"
egdaniel4ca2e602015-11-18 08:01:26 -0800601 " 2.0*%s.x*duvdy.x - duvdy.y);",
602 v.fsIn(), v.fsIn());
603 fragBuilder->codeAppendf("edgeAlpha = (%s.x*%s.x - %s.y);", v.fsIn(), v.fsIn(),
604 v.fsIn());
605 fragBuilder->codeAppendf("edgeAlpha = "
606 "clamp(0.5 - edgeAlpha / length(gF), 0.0, 1.0);}");
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000607
Ethan Nicholasf7b88202017-09-18 14:10:39 -0400608 fragBuilder->codeAppendf("%s = half4(edgeAlpha);", args.fOutputCoverage);
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000609 }
610
joshualitt9b989322014-12-15 14:16:27 -0800611 static inline void GenKey(const GrGeometryProcessor& gp,
Brian Salomon94efbf52016-11-29 13:43:05 -0500612 const GrShaderCaps&,
joshualitt9b989322014-12-15 14:16:27 -0800613 GrProcessorKeyBuilder* b) {
joshualitte3ababe2015-05-15 07:56:07 -0700614 const QuadEdgeEffect& qee = gp.cast<QuadEdgeEffect>();
Brian Salomon60fb0b22017-06-15 17:09:36 -0400615 b->add32(SkToBool(qee.fUsesLocalCoords && qee.fLocalMatrix.hasPerspective()));
joshualitt9b989322014-12-15 14:16:27 -0800616 }
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000617
egdaniel018fb622015-10-28 07:26:40 -0700618 void setData(const GrGLSLProgramDataManager& pdman,
bsalomona624bf32016-09-20 09:12:47 -0700619 const GrPrimitiveProcessor& gp,
620 FPCoordTransformIter&& transformIter) override {
joshualittb8c241a2015-05-19 08:23:30 -0700621 const QuadEdgeEffect& qe = gp.cast<QuadEdgeEffect>();
bsalomona624bf32016-09-20 09:12:47 -0700622 this->setTransformDataHelper(qe.fLocalMatrix, pdman, &transformIter);
joshualitte3ababe2015-05-15 07:56:07 -0700623 }
624
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000625 private:
egdaniele659a582015-11-13 09:55:43 -0800626 typedef GrGLSLGeometryProcessor INHERITED;
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000627 };
skia.committer@gmail.com041e2db2013-04-03 07:01:14 +0000628
Brian Salomon94efbf52016-11-29 13:43:05 -0500629 void getGLSLProcessorKey(const GrShaderCaps& caps, GrProcessorKeyBuilder* b) const override {
egdaniel57d3b032015-11-13 11:57:27 -0800630 GLSLProcessor::GenKey(*this, caps, b);
joshualitteb2a6762014-12-04 11:35:33 -0800631 }
632
Brian Salomon94efbf52016-11-29 13:43:05 -0500633 GrGLSLPrimitiveProcessor* createGLSLInstance(const GrShaderCaps&) const override {
egdaniel57d3b032015-11-13 11:57:27 -0800634 return new GLSLProcessor();
joshualitteb2a6762014-12-04 11:35:33 -0800635 }
636
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000637private:
Brian Salomon60fb0b22017-06-15 17:09:36 -0400638 QuadEdgeEffect(const SkMatrix& localMatrix, bool usesLocalCoords)
Ethan Nicholasabff9562017-10-09 10:54:08 -0400639 : INHERITED(kQuadEdgeEffect_ClassID)
640 , fLocalMatrix(localMatrix)
641 , fUsesLocalCoords(usesLocalCoords) {
Ethan Nicholasfa7ee242017-09-25 09:52:04 -0400642 fInPosition = &this->addVertexAttrib("inPosition", kFloat2_GrVertexAttribType);
643 fInColor = &this->addVertexAttrib("inColor", kUByte4_norm_GrVertexAttribType);
644 fInQuadEdge = &this->addVertexAttrib("inQuadEdge", kHalf4_GrVertexAttribType);
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000645 }
646
joshualitt71c92602015-01-14 08:12:47 -0800647 const Attribute* fInPosition;
648 const Attribute* fInQuadEdge;
Brian Salomon60fb0b22017-06-15 17:09:36 -0400649 const Attribute* fInColor;
joshualitte3ababe2015-05-15 07:56:07 -0700650 SkMatrix fLocalMatrix;
joshualittb8c241a2015-05-19 08:23:30 -0700651 bool fUsesLocalCoords;
joshualitt249af152014-09-15 11:41:13 -0700652
Brian Salomon0c26a9d2017-07-06 10:09:38 -0400653 GR_DECLARE_GEOMETRY_PROCESSOR_TEST
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000654
joshualitt2e3b3e32014-12-09 13:31:14 -0800655 typedef GrGeometryProcessor INHERITED;
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000656};
657
joshualittb0a8a372014-09-23 09:50:21 -0700658GR_DEFINE_GEOMETRY_PROCESSOR_TEST(QuadEdgeEffect);
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000659
Hal Canary6f6961e2017-01-31 13:50:44 -0500660#if GR_TEST_UTILS
bungeman06ca8ec2016-06-09 08:01:03 -0700661sk_sp<GrGeometryProcessor> QuadEdgeEffect::TestCreate(GrProcessorTestData* d) {
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000662 // Doesn't work without derivative instructions.
Robert Phillips296b1cc2017-03-15 10:42:12 -0400663 return d->caps()->shaderCaps()->shaderDerivativeSupport()
Brian Salomon60fb0b22017-06-15 17:09:36 -0400664 ? QuadEdgeEffect::Make(GrTest::TestMatrix(d->fRandom), d->fRandom->nextBool())
Brian Salomon9ae32a22017-01-25 14:58:24 -0500665 : nullptr;
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000666}
Hal Canary6f6961e2017-01-31 13:50:44 -0500667#endif
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000668
669///////////////////////////////////////////////////////////////////////////////
670
Chris Dalton5ed44232017-09-07 13:22:46 -0600671GrPathRenderer::CanDrawPath
672GrAAConvexPathRenderer::onCanDrawPath(const CanDrawPathArgs& args) const {
673 if (args.fCaps->shaderCaps()->shaderDerivativeSupport() &&
674 (GrAAType::kCoverage == args.fAAType) && args.fShape->style().isSimpleFill() &&
675 !args.fShape->inverseFilled() && args.fShape->knownToBeConvex()) {
676 return CanDrawPath::kYes;
677 }
678 return CanDrawPath::kNo;
robertphillips@google.comfa662942012-05-17 12:20:22 +0000679}
680
robertphillipse16dfdb2015-05-08 04:46:51 -0700681// extract the result vertices and indices from the GrAAConvexTessellator
Brian Salomon60fb0b22017-06-15 17:09:36 -0400682static void extract_lines_only_verts(const GrAAConvexTessellator& tess,
683 void* vertices,
684 size_t vertexStride,
685 GrColor color,
686 uint16_t* idxs,
687 bool tweakAlphaForCoverage) {
robertphillipse16dfdb2015-05-08 04:46:51 -0700688 intptr_t verts = reinterpret_cast<intptr_t>(vertices);
689
690 for (int i = 0; i < tess.numPts(); ++i) {
691 *((SkPoint*)((intptr_t)verts + i * vertexStride)) = tess.point(i);
692 }
693
694 // Make 'verts' point to the colors
695 verts += sizeof(SkPoint);
696 for (int i = 0; i < tess.numPts(); ++i) {
robertphillipse16dfdb2015-05-08 04:46:51 -0700697 if (tweakAlphaForCoverage) {
fmalitabd5d7e72015-06-26 07:18:24 -0700698 SkASSERT(SkScalarRoundToInt(255.0f * tess.coverage(i)) <= 255);
699 unsigned scale = SkScalarRoundToInt(255.0f * tess.coverage(i));
robertphillipse16dfdb2015-05-08 04:46:51 -0700700 GrColor scaledColor = (0xff == scale) ? color : SkAlphaMulQ(color, scale);
701 *reinterpret_cast<GrColor*>(verts + i * vertexStride) = scaledColor;
702 } else {
703 *reinterpret_cast<GrColor*>(verts + i * vertexStride) = color;
halcanary9d524f22016-03-29 09:03:52 -0700704 *reinterpret_cast<float*>(verts + i * vertexStride + sizeof(GrColor)) =
fmalitabd5d7e72015-06-26 07:18:24 -0700705 tess.coverage(i);
robertphillipse16dfdb2015-05-08 04:46:51 -0700706 }
707 }
708
709 for (int i = 0; i < tess.numIndices(); ++i) {
710 idxs[i] = tess.index(i);
711 }
712}
713
Brian Salomon60fb0b22017-06-15 17:09:36 -0400714static sk_sp<GrGeometryProcessor> make_lines_only_gp(bool tweakAlphaForCoverage,
715 const SkMatrix& viewMatrix,
716 bool usesLocalCoords) {
joshualittdf0c5572015-08-03 11:35:28 -0700717 using namespace GrDefaultGeoProcFactory;
joshualitte494a582015-08-03 09:32:36 -0700718
joshualittdf0c5572015-08-03 11:35:28 -0700719 Coverage::Type coverageType;
Brian Salomon8c852be2017-01-04 10:44:42 -0500720 if (tweakAlphaForCoverage) {
joshualittdf0c5572015-08-03 11:35:28 -0700721 coverageType = Coverage::kSolid_Type;
722 } else {
723 coverageType = Coverage::kAttribute_Type;
724 }
Brian Salomon8c852be2017-01-04 10:44:42 -0500725 LocalCoords::Type localCoordsType =
726 usesLocalCoords ? LocalCoords::kUsePosition_Type : LocalCoords::kUnused_Type;
Brian Salomon3de0aee2017-01-29 09:34:17 -0500727 return MakeForDeviceSpace(Color::kPremulGrColorAttribute_Type, coverageType, localCoordsType,
728 viewMatrix);
robertphillipse16dfdb2015-05-08 04:46:51 -0700729}
730
Brian Salomon10978a62017-06-15 16:21:49 -0400731namespace {
732
733class AAConvexPathOp final : public GrMeshDrawOp {
734private:
735 using Helper = GrSimpleMeshDrawOpHelperWithStencil;
736
joshualitt27f398f2015-02-05 14:39:01 -0800737public:
Brian Salomon25a88092016-12-01 09:36:50 -0500738 DEFINE_OP_CLASS_ID
Robert Phillipsb493eeb2017-09-13 13:10:52 -0400739
Brian Salomon10978a62017-06-15 16:21:49 -0400740 static std::unique_ptr<GrDrawOp> Make(GrPaint&& paint, const SkMatrix& viewMatrix,
741 const SkPath& path,
742 const GrUserStencilSettings* stencilSettings) {
743 return Helper::FactoryHelper<AAConvexPathOp>(std::move(paint), viewMatrix, path,
744 stencilSettings);
745 }
746
747 AAConvexPathOp(const Helper::MakeArgs& helperArgs, GrColor color, const SkMatrix& viewMatrix,
748 const SkPath& path, const GrUserStencilSettings* stencilSettings)
Brian Salomon60fb0b22017-06-15 17:09:36 -0400749 : INHERITED(ClassID()), fHelper(helperArgs, GrAAType::kCoverage, stencilSettings) {
750 fPaths.emplace_back(PathData{viewMatrix, path, color});
Brian Salomon10978a62017-06-15 16:21:49 -0400751 this->setTransformedBounds(path.getBounds(), viewMatrix, HasAABloat::kYes, IsZeroArea::kNo);
752 fLinesOnly = SkPath::kLine_SegmentMask == path.getSegmentMasks();
bsalomonf1703092016-06-29 18:41:53 -0700753 }
joshualitt27f398f2015-02-05 14:39:01 -0800754
Brian Salomond0a0a652016-12-15 15:25:22 -0500755 const char* name() const override { return "AAConvexPathOp"; }
joshualitt27f398f2015-02-05 14:39:01 -0800756
Robert Phillipsf1748f52017-09-14 14:11:24 -0400757 void visitProxies(const VisitProxyFunc& func) const override {
Robert Phillipsb493eeb2017-09-13 13:10:52 -0400758 fHelper.visitProxies(func);
759 }
760
Brian Salomon7c3e7182016-12-01 09:35:30 -0500761 SkString dumpInfo() const override {
762 SkString string;
Brian Salomon60fb0b22017-06-15 17:09:36 -0400763 string.appendf("Count: %d\n", fPaths.count());
Brian Salomon10978a62017-06-15 16:21:49 -0400764 string += fHelper.dumpInfo();
765 string += INHERITED::dumpInfo();
Brian Salomon7c3e7182016-12-01 09:35:30 -0500766 return string;
767 }
768
Brian Salomon10978a62017-06-15 16:21:49 -0400769 FixedFunctionFlags fixedFunctionFlags() const override { return fHelper.fixedFunctionFlags(); }
770
Brian Osman9a725dd2017-09-20 09:53:22 -0400771 RequiresDstTexture finalize(const GrCaps& caps, const GrAppliedClip* clip,
772 GrPixelConfigIsClamped dstIsClamped) override {
773 return fHelper.xpRequiresDstTexture(caps, clip, dstIsClamped,
774 GrProcessorAnalysisCoverage::kSingleChannel,
Brian Salomon60fb0b22017-06-15 17:09:36 -0400775 &fPaths.back().fColor);
Brian Salomon10978a62017-06-15 16:21:49 -0400776 }
777
bsalomone46f9fe2015-08-18 06:05:14 -0700778private:
Brian Salomon91326c32017-08-09 16:02:19 -0400779 void prepareLinesOnlyDraws(Target* target) {
Brian Salomon60fb0b22017-06-15 17:09:36 -0400780 // Setup GrGeometryProcessor
781 sk_sp<GrGeometryProcessor> gp(make_lines_only_gp(fHelper.compatibleWithAlphaAsCoverage(),
782 fPaths.back().fViewMatrix,
783 fHelper.usesLocalCoords()));
joshualittdf0c5572015-08-03 11:35:28 -0700784 if (!gp) {
785 SkDebugf("Could not create GrGeometryProcessor\n");
robertphillipse16dfdb2015-05-08 04:46:51 -0700786 return;
787 }
788
robertphillipse16dfdb2015-05-08 04:46:51 -0700789 size_t vertexStride = gp->getVertexStride();
790
Brian Salomon60fb0b22017-06-15 17:09:36 -0400791 SkASSERT(fHelper.compatibleWithAlphaAsCoverage()
792 ? vertexStride == sizeof(GrDefaultGeoProcFactory::PositionColorAttr)
793 : vertexStride ==
794 sizeof(GrDefaultGeoProcFactory::PositionColorCoverageAttr));
robertphillipse16dfdb2015-05-08 04:46:51 -0700795
796 GrAAConvexTessellator tess;
797
Brian Salomond0a0a652016-12-15 15:25:22 -0500798 int instanceCount = fPaths.count();
Brian Salomon10978a62017-06-15 16:21:49 -0400799 const GrPipeline* pipeline = fHelper.makePipeline(target);
robertphillipse16dfdb2015-05-08 04:46:51 -0700800 for (int i = 0; i < instanceCount; i++) {
801 tess.rewind();
802
Brian Salomond0a0a652016-12-15 15:25:22 -0500803 const PathData& args = fPaths[i];
robertphillipse16dfdb2015-05-08 04:46:51 -0700804
805 if (!tess.tessellate(args.fViewMatrix, args.fPath)) {
806 continue;
807 }
808
cdalton397536c2016-03-25 12:15:03 -0700809 const GrBuffer* vertexBuffer;
robertphillipse16dfdb2015-05-08 04:46:51 -0700810 int firstVertex;
811
bsalomon75398562015-08-17 12:55:38 -0700812 void* verts = target->makeVertexSpace(vertexStride, tess.numPts(), &vertexBuffer,
813 &firstVertex);
robertphillipse16dfdb2015-05-08 04:46:51 -0700814 if (!verts) {
815 SkDebugf("Could not allocate vertices\n");
816 return;
817 }
818
cdalton397536c2016-03-25 12:15:03 -0700819 const GrBuffer* indexBuffer;
robertphillipse16dfdb2015-05-08 04:46:51 -0700820 int firstIndex;
821
bsalomon75398562015-08-17 12:55:38 -0700822 uint16_t* idxs = target->makeIndexSpace(tess.numIndices(), &indexBuffer, &firstIndex);
robertphillipse16dfdb2015-05-08 04:46:51 -0700823 if (!idxs) {
824 SkDebugf("Could not allocate indices\n");
825 return;
826 }
827
Brian Salomon60fb0b22017-06-15 17:09:36 -0400828 extract_lines_only_verts(tess, verts, vertexStride, args.fColor, idxs,
829 fHelper.compatibleWithAlphaAsCoverage());
robertphillipse16dfdb2015-05-08 04:46:51 -0700830
Chris Dalton3809bab2017-06-13 10:55:06 -0600831 GrMesh mesh(GrPrimitiveType::kTriangles);
Chris Dalton114a3c02017-05-26 15:17:19 -0600832 mesh.setIndexed(indexBuffer, tess.numIndices(), firstIndex, 0, tess.numPts() - 1);
833 mesh.setVertexData(vertexBuffer, firstVertex);
Brian Salomon10978a62017-06-15 16:21:49 -0400834 target->draw(gp.get(), pipeline, mesh);
robertphillipse16dfdb2015-05-08 04:46:51 -0700835 }
joshualitt27f398f2015-02-05 14:39:01 -0800836 }
837
Brian Salomon91326c32017-08-09 16:02:19 -0400838 void onPrepareDraws(Target* target) override {
robertphillipse16dfdb2015-05-08 04:46:51 -0700839#ifndef SK_IGNORE_LINEONLY_AA_CONVEX_PATH_OPTS
Brian Salomon10978a62017-06-15 16:21:49 -0400840 if (fLinesOnly) {
bsalomon75398562015-08-17 12:55:38 -0700841 this->prepareLinesOnlyDraws(target);
robertphillipse16dfdb2015-05-08 04:46:51 -0700842 return;
843 }
844#endif
Brian Salomon10978a62017-06-15 16:21:49 -0400845 const GrPipeline* pipeline = fHelper.makePipeline(target);
Brian Salomond0a0a652016-12-15 15:25:22 -0500846 int instanceCount = fPaths.count();
joshualitt27f398f2015-02-05 14:39:01 -0800847
848 SkMatrix invert;
Brian Salomon10978a62017-06-15 16:21:49 -0400849 if (fHelper.usesLocalCoords() && !fPaths.back().fViewMatrix.invert(&invert)) {
joshualitt27f398f2015-02-05 14:39:01 -0800850 SkDebugf("Could not invert viewmatrix\n");
851 return;
852 }
853
854 // Setup GrGeometryProcessor
bungeman06ca8ec2016-06-09 08:01:03 -0700855 sk_sp<GrGeometryProcessor> quadProcessor(
Brian Salomon60fb0b22017-06-15 17:09:36 -0400856 QuadEdgeEffect::Make(invert, fHelper.usesLocalCoords()));
joshualitt27f398f2015-02-05 14:39:01 -0800857
joshualitt27f398f2015-02-05 14:39:01 -0800858 // TODO generate all segments for all paths and use one vertex buffer
859 for (int i = 0; i < instanceCount; i++) {
Brian Salomond0a0a652016-12-15 15:25:22 -0500860 const PathData& args = fPaths[i];
joshualitt27f398f2015-02-05 14:39:01 -0800861
862 // We use the fact that SkPath::transform path does subdivision based on
863 // perspective. Otherwise, we apply the view matrix when copying to the
864 // segment representation.
865 const SkMatrix* viewMatrix = &args.fViewMatrix;
joshualitt144c3c82015-11-30 12:30:13 -0800866
867 // We avoid initializing the path unless we have to
868 const SkPath* pathPtr = &args.fPath;
869 SkTLazy<SkPath> tmpPath;
joshualitt27f398f2015-02-05 14:39:01 -0800870 if (viewMatrix->hasPerspective()) {
joshualitt144c3c82015-11-30 12:30:13 -0800871 SkPath* tmpPathPtr = tmpPath.init(*pathPtr);
872 tmpPathPtr->setIsVolatile(true);
873 tmpPathPtr->transform(*viewMatrix);
joshualitt27f398f2015-02-05 14:39:01 -0800874 viewMatrix = &SkMatrix::I();
joshualitt144c3c82015-11-30 12:30:13 -0800875 pathPtr = tmpPathPtr;
joshualitt27f398f2015-02-05 14:39:01 -0800876 }
877
878 int vertexCount;
879 int indexCount;
880 enum {
881 kPreallocSegmentCnt = 512 / sizeof(Segment),
882 kPreallocDrawCnt = 4,
883 };
884 SkSTArray<kPreallocSegmentCnt, Segment, true> segments;
885 SkPoint fanPt;
886
joshualitt144c3c82015-11-30 12:30:13 -0800887 if (!get_segments(*pathPtr, *viewMatrix, &segments, &fanPt, &vertexCount,
joshualitt27f398f2015-02-05 14:39:01 -0800888 &indexCount)) {
889 continue;
890 }
891
Chris Daltonff926502017-05-03 14:36:54 -0400892 const GrBuffer* vertexBuffer;
Chris Daltonbca46e22017-05-15 11:03:26 -0600893 int firstVertex;
894
joshualitt27f398f2015-02-05 14:39:01 -0800895 size_t vertexStride = quadProcessor->getVertexStride();
bsalomon75398562015-08-17 12:55:38 -0700896 QuadVertex* verts = reinterpret_cast<QuadVertex*>(target->makeVertexSpace(
Chris Daltonbca46e22017-05-15 11:03:26 -0600897 vertexStride, vertexCount, &vertexBuffer, &firstVertex));
bsalomone64eb572015-05-07 11:35:55 -0700898
899 if (!verts) {
joshualitt4b31de82015-03-05 14:33:41 -0800900 SkDebugf("Could not allocate vertices\n");
901 return;
902 }
903
cdalton397536c2016-03-25 12:15:03 -0700904 const GrBuffer* indexBuffer;
Chris Daltonbca46e22017-05-15 11:03:26 -0600905 int firstIndex;
906
907 uint16_t *idxs = target->makeIndexSpace(indexCount, &indexBuffer, &firstIndex);
robertphillipse40d3972015-05-07 09:51:43 -0700908 if (!idxs) {
joshualitt4b31de82015-03-05 14:33:41 -0800909 SkDebugf("Could not allocate indices\n");
910 return;
911 }
912
joshualitt27f398f2015-02-05 14:39:01 -0800913 SkSTArray<kPreallocDrawCnt, Draw, true> draws;
Brian Salomon60fb0b22017-06-15 17:09:36 -0400914 create_vertices(segments, fanPt, args.fColor, &draws, verts, idxs);
joshualitt27f398f2015-02-05 14:39:01 -0800915
Chris Dalton3809bab2017-06-13 10:55:06 -0600916 GrMesh mesh(GrPrimitiveType::kTriangles);
Chris Daltonbca46e22017-05-15 11:03:26 -0600917
robertphillips44c31282015-09-03 12:58:48 -0700918 for (int j = 0; j < draws.count(); ++j) {
919 const Draw& draw = draws[j];
Chris Dalton114a3c02017-05-26 15:17:19 -0600920 mesh.setIndexed(indexBuffer, draw.fIndexCnt, firstIndex, 0, draw.fVertexCnt - 1);
921 mesh.setVertexData(vertexBuffer, firstVertex);
Brian Salomon10978a62017-06-15 16:21:49 -0400922 target->draw(quadProcessor.get(), pipeline, mesh);
Chris Daltonbca46e22017-05-15 11:03:26 -0600923 firstIndex += draw.fIndexCnt;
924 firstVertex += draw.fVertexCnt;
joshualitt27f398f2015-02-05 14:39:01 -0800925 }
926 }
927 }
928
Brian Salomon25a88092016-12-01 09:36:50 -0500929 bool onCombineIfPossible(GrOp* t, const GrCaps& caps) override {
Brian Salomond0a0a652016-12-15 15:25:22 -0500930 AAConvexPathOp* that = t->cast<AAConvexPathOp>();
Brian Salomon10978a62017-06-15 16:21:49 -0400931 if (!fHelper.isCompatible(that->fHelper, caps, this->bounds(), that->bounds())) {
joshualitt8cab9a72015-07-16 09:13:50 -0700932 return false;
933 }
Brian Salomon10978a62017-06-15 16:21:49 -0400934 if (fHelper.usesLocalCoords() &&
935 !fPaths[0].fViewMatrix.cheapEqualTo(that->fPaths[0].fViewMatrix)) {
joshualitt27f398f2015-02-05 14:39:01 -0800936 return false;
937 }
938
Brian Salomon10978a62017-06-15 16:21:49 -0400939 if (fLinesOnly != that->fLinesOnly) {
robertphillipse16dfdb2015-05-08 04:46:51 -0700940 return false;
941 }
942
Brian Salomond0a0a652016-12-15 15:25:22 -0500943 fPaths.push_back_n(that->fPaths.count(), that->fPaths.begin());
bsalomon88cf17d2016-07-08 06:40:56 -0700944 this->joinBounds(*that);
joshualitt27f398f2015-02-05 14:39:01 -0800945 return true;
946 }
947
Brian Salomond0a0a652016-12-15 15:25:22 -0500948 struct PathData {
bsalomonf1703092016-06-29 18:41:53 -0700949 SkMatrix fViewMatrix;
950 SkPath fPath;
Brian Salomon60fb0b22017-06-15 17:09:36 -0400951 GrColor fColor;
bsalomonf1703092016-06-29 18:41:53 -0700952 };
953
Brian Salomon10978a62017-06-15 16:21:49 -0400954 Helper fHelper;
Brian Salomond0a0a652016-12-15 15:25:22 -0500955 SkSTArray<1, PathData, true> fPaths;
Brian Salomon10978a62017-06-15 16:21:49 -0400956 bool fLinesOnly;
reed1b55a962015-09-17 20:16:13 -0700957
Brian Salomon10978a62017-06-15 16:21:49 -0400958 typedef GrMeshDrawOp INHERITED;
joshualitt27f398f2015-02-05 14:39:01 -0800959};
960
Brian Salomon10978a62017-06-15 16:21:49 -0400961} // anonymous namespace
962
bsalomon0aff2fa2015-07-31 06:48:27 -0700963bool GrAAConvexPathRenderer::onDrawPath(const DrawPathArgs& args) {
Brian Osman11052242016-10-27 14:47:55 -0400964 GR_AUDIT_TRAIL_AUTO_FRAME(args.fRenderTargetContext->auditTrail(),
robertphillips976f5f02016-06-03 10:59:20 -0700965 "GrAAConvexPathRenderer::onDrawPath");
Brian Salomon7c8460e2017-05-12 11:36:10 -0400966 SkASSERT(GrFSAAType::kUnifiedMSAA != args.fRenderTargetContext->fsaaType());
bsalomon8acedde2016-06-24 10:42:16 -0700967 SkASSERT(!args.fShape->isEmpty());
bsalomon@google.com4647f902013-03-26 14:45:27 +0000968
bsalomonf1703092016-06-29 18:41:53 -0700969 SkPath path;
970 args.fShape->asPath(&path);
bsalomon@google.comaf90f7f2012-03-05 20:50:10 +0000971
Brian Salomon10978a62017-06-15 16:21:49 -0400972 std::unique_ptr<GrDrawOp> op = AAConvexPathOp::Make(std::move(args.fPaint), *args.fViewMatrix,
973 path, args.fUserStencilSettings);
974 args.fRenderTargetContext->addDrawOp(*args.fClip, std::move(op));
bsalomon@google.comc2099d22012-03-02 21:26:50 +0000975 return true;
bsalomon@google.com69cc6ad2012-01-17 14:25:10 +0000976}
joshualitt8e5c1772015-05-11 08:58:52 -0700977
978///////////////////////////////////////////////////////////////////////////////////////////////////
979
Hal Canary6f6961e2017-01-31 13:50:44 -0500980#if GR_TEST_UTILS
joshualitt8e5c1772015-05-11 08:58:52 -0700981
Brian Salomon10978a62017-06-15 16:21:49 -0400982GR_DRAW_OP_TEST_DEFINE(AAConvexPathOp) {
bsalomonf1703092016-06-29 18:41:53 -0700983 SkMatrix viewMatrix = GrTest::TestMatrixInvertible(random);
984 SkPath path = GrTest::TestPathConvex(random);
Brian Salomon10978a62017-06-15 16:21:49 -0400985 const GrUserStencilSettings* stencilSettings = GrGetRandomStencil(random, context);
986 return AAConvexPathOp::Make(std::move(paint), viewMatrix, path, stencilSettings);
joshualitt8e5c1772015-05-11 08:58:52 -0700987}
988
989#endif