blob: d1fbbc4e7b67bae41753bd81f9a8bcc1fb6e2b9a [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"
Greg Danield5b45932018-06-07 13:15:10 -040025#include "SkTypes.h"
egdaniel7ea439b2015-12-03 09:20:44 -080026#include "glsl/GrGLSLFragmentShaderBuilder.h"
egdaniele659a582015-11-13 09:55:43 -080027#include "glsl/GrGLSLGeometryProcessor.h"
egdaniel018fb622015-10-28 07:26:40 -070028#include "glsl/GrGLSLProgramDataManager.h"
egdaniel7ea439b2015-12-03 09:20:44 -080029#include "glsl/GrGLSLUniformHandler.h"
egdaniel0eafe792015-11-20 14:01:22 -080030#include "glsl/GrGLSLVarying.h"
Chris Daltonc17bf322017-10-24 10:59:03 -060031#include "glsl/GrGLSLVertexGeoBuilder.h"
Brian Salomon89527432016-12-16 09:52:16 -050032#include "ops/GrMeshDrawOp.h"
commit-bot@chromium.org234d4fb2013-09-30 19:55:49 +000033
bsalomon@google.com69cc6ad2012-01-17 14:25:10 +000034GrAAConvexPathRenderer::GrAAConvexPathRenderer() {
35}
36
bsalomon@google.com69cc6ad2012-01-17 14:25:10 +000037struct Segment {
38 enum {
bsalomon@google.com9b1517e2012-03-05 17:58:34 +000039 // These enum values are assumed in member functions below.
40 kLine = 0,
41 kQuad = 1,
bsalomon@google.com69cc6ad2012-01-17 14:25:10 +000042 } fType;
bsalomon@google.com9b1517e2012-03-05 17:58:34 +000043
bsalomon@google.com9aed1142012-01-30 14:28:39 +000044 // line uses one pt, quad uses 2 pts
commit-bot@chromium.org972f9cd2014-03-28 17:58:28 +000045 SkPoint fPts[2];
bsalomon@google.com9aed1142012-01-30 14:28:39 +000046 // normal to edge ending at each pt
commit-bot@chromium.org972f9cd2014-03-28 17:58:28 +000047 SkVector fNorms[2];
bsalomon@google.com9aed1142012-01-30 14:28:39 +000048 // is the corner where the previous segment meets this segment
49 // sharp. If so, fMid is a normalized bisector facing outward.
commit-bot@chromium.org972f9cd2014-03-28 17:58:28 +000050 SkVector fMid;
bsalomon@google.com9aed1142012-01-30 14:28:39 +000051
52 int countPoints() {
bsalomon@google.com9b1517e2012-03-05 17:58:34 +000053 GR_STATIC_ASSERT(0 == kLine && 1 == kQuad);
54 return fType + 1;
bsalomon@google.com9aed1142012-01-30 14:28:39 +000055 }
56 const SkPoint& endPt() const {
bsalomon@google.com9b1517e2012-03-05 17:58:34 +000057 GR_STATIC_ASSERT(0 == kLine && 1 == kQuad);
58 return fPts[fType];
Mike Kleinfc6c37b2016-09-27 09:34:10 -040059 }
bsalomon@google.com9aed1142012-01-30 14:28:39 +000060 const SkPoint& endNorm() const {
bsalomon@google.com9b1517e2012-03-05 17:58:34 +000061 GR_STATIC_ASSERT(0 == kLine && 1 == kQuad);
62 return fNorms[fType];
Mike Kleinfc6c37b2016-09-27 09:34:10 -040063 }
bsalomon@google.com69cc6ad2012-01-17 14:25:10 +000064};
65
66typedef SkTArray<Segment, true> SegmentArray;
67
Greg Daniel8b09b962018-04-03 14:53:45 -040068static bool center_of_mass(const SegmentArray& segments, SkPoint* c) {
bsalomon@google.com81712882012-11-01 17:12:34 +000069 SkScalar area = 0;
vandebo@chromium.org6390c722012-03-28 21:03:22 +000070 SkPoint center = {0, 0};
bsalomon@google.com9aed1142012-01-30 14:28:39 +000071 int count = segments.count();
vandebo@chromium.org6390c722012-03-28 21:03:22 +000072 SkPoint p0 = {0, 0};
bsalomon@google.com5b56d9e2012-02-23 19:18:37 +000073 if (count > 2) {
74 // We translate the polygon so that the first point is at the origin.
75 // This avoids some precision issues with small area polygons far away
76 // from the origin.
77 p0 = segments[0].endPt();
78 SkPoint pi;
79 SkPoint pj;
bsalomon@google.coma51ab842012-07-10 19:53:34 +000080 // the first and last iteration of the below loop would compute
bsalomon@google.com5b56d9e2012-02-23 19:18:37 +000081 // zeros since the starting / ending point is (0,0). So instead we start
82 // at i=1 and make the last iteration i=count-2.
83 pj = segments[1].endPt() - p0;
84 for (int i = 1; i < count - 1; ++i) {
85 pi = pj;
robertphillips44c31282015-09-03 12:58:48 -070086 pj = segments[i + 1].endPt() - p0;
bsalomon@google.com5b56d9e2012-02-23 19:18:37 +000087
robertphillips44c31282015-09-03 12:58:48 -070088 SkScalar t = SkPoint::CrossProduct(pi, pj);
bsalomon@google.com5b56d9e2012-02-23 19:18:37 +000089 area += t;
90 center.fX += (pi.fX + pj.fX) * t;
91 center.fY += (pi.fY + pj.fY) * t;
bsalomon@google.com5b56d9e2012-02-23 19:18:37 +000092 }
bsalomon@google.com9aed1142012-01-30 14:28:39 +000093 }
robertphillips44c31282015-09-03 12:58:48 -070094
bsalomon@google.com278dc692012-02-15 16:52:51 +000095 // If the poly has no area then we instead return the average of
96 // its points.
bsalomon@google.com5b56d9e2012-02-23 19:18:37 +000097 if (SkScalarNearlyZero(area)) {
bsalomon@google.com278dc692012-02-15 16:52:51 +000098 SkPoint avg;
99 avg.set(0, 0);
100 for (int i = 0; i < count; ++i) {
101 const SkPoint& pt = segments[i].endPt();
102 avg.fX += pt.fX;
103 avg.fY += pt.fY;
104 }
105 SkScalar denom = SK_Scalar1 / count;
106 avg.scale(denom);
107 *c = avg;
108 } else {
109 area *= 3;
reed80ea19c2015-05-12 10:37:34 -0700110 area = SkScalarInvert(area);
robertphillips44c31282015-09-03 12:58:48 -0700111 center.scale(area);
bsalomon@google.com5b56d9e2012-02-23 19:18:37 +0000112 // undo the translate of p0 to the origin.
113 *c = center + p0;
bsalomon@google.com278dc692012-02-15 16:52:51 +0000114 }
Greg Daniel62473ad2018-04-03 15:44:18 -0400115 return !SkScalarIsNaN(c->fX) && !SkScalarIsNaN(c->fY) && c->isFinite();
bsalomon@google.com9aed1142012-01-30 14:28:39 +0000116}
117
Greg Daniel8b09b962018-04-03 14:53:45 -0400118static bool compute_vectors(SegmentArray* segments,
commit-bot@chromium.orgfdfbb9d2013-08-15 18:16:27 +0000119 SkPoint* fanPt,
reed026beb52015-06-10 14:23:15 -0700120 SkPathPriv::FirstDirection dir,
commit-bot@chromium.orgfdfbb9d2013-08-15 18:16:27 +0000121 int* vCount,
122 int* iCount) {
Greg Daniel8b09b962018-04-03 14:53:45 -0400123 if (!center_of_mass(*segments, fanPt)) {
124 return false;
125 }
bsalomon@google.com9aed1142012-01-30 14:28:39 +0000126 int count = segments->count();
127
bsalomon@google.com278dc692012-02-15 16:52:51 +0000128 // Make the normals point towards the outside
Cary Clarkdf429f32017-11-08 11:44:31 -0500129 SkPointPriv::Side normSide;
reed026beb52015-06-10 14:23:15 -0700130 if (dir == SkPathPriv::kCCW_FirstDirection) {
Cary Clarkdf429f32017-11-08 11:44:31 -0500131 normSide = SkPointPriv::kRight_Side;
bsalomon@google.com278dc692012-02-15 16:52:51 +0000132 } else {
Cary Clarkdf429f32017-11-08 11:44:31 -0500133 normSide = SkPointPriv::kLeft_Side;
bsalomon@google.com278dc692012-02-15 16:52:51 +0000134 }
bsalomon@google.com9aed1142012-01-30 14:28:39 +0000135
Greg Danield5b45932018-06-07 13:15:10 -0400136 int64_t vCount64 = 0;
137 int64_t iCount64 = 0;
bsalomon@google.com9aed1142012-01-30 14:28:39 +0000138 // compute normals at all points
139 for (int a = 0; a < count; ++a) {
bsalomon@google.com7d9ffc82013-05-14 14:20:28 +0000140 Segment& sega = (*segments)[a];
bsalomon@google.com9aed1142012-01-30 14:28:39 +0000141 int b = (a + 1) % count;
142 Segment& segb = (*segments)[b];
143
commit-bot@chromium.org972f9cd2014-03-28 17:58:28 +0000144 const SkPoint* prevPt = &sega.endPt();
bsalomon@google.com9aed1142012-01-30 14:28:39 +0000145 int n = segb.countPoints();
146 for (int p = 0; p < n; ++p) {
147 segb.fNorms[p] = segb.fPts[p] - *prevPt;
148 segb.fNorms[p].normalize();
Cary Clarkdf429f32017-11-08 11:44:31 -0500149 SkPointPriv::SetOrthog(&segb.fNorms[p], segb.fNorms[p], normSide);
bsalomon@google.com9aed1142012-01-30 14:28:39 +0000150 prevPt = &segb.fPts[p];
151 }
152 if (Segment::kLine == segb.fType) {
Greg Danield5b45932018-06-07 13:15:10 -0400153 vCount64 += 5;
154 iCount64 += 9;
bsalomon@google.com9aed1142012-01-30 14:28:39 +0000155 } else {
Greg Danield5b45932018-06-07 13:15:10 -0400156 vCount64 += 6;
157 iCount64 += 12;
bsalomon@google.com9aed1142012-01-30 14:28:39 +0000158 }
159 }
160
161 // compute mid-vectors where segments meet. TODO: Detect shallow corners
162 // and leave out the wedges and close gaps by stitching segments together.
163 for (int a = 0; a < count; ++a) {
164 const Segment& sega = (*segments)[a];
165 int b = (a + 1) % count;
166 Segment& segb = (*segments)[b];
167 segb.fMid = segb.fNorms[0] + sega.endNorm();
168 segb.fMid.normalize();
169 // corner wedges
Greg Danield5b45932018-06-07 13:15:10 -0400170 vCount64 += 4;
171 iCount64 += 6;
bsalomon@google.com9aed1142012-01-30 14:28:39 +0000172 }
Greg Danield5b45932018-06-07 13:15:10 -0400173 if (vCount64 > SK_MaxS32 || iCount64 > SK_MaxS32) {
174 return false;
175 }
176 *vCount = vCount64;
177 *iCount = iCount64;
Greg Daniel8b09b962018-04-03 14:53:45 -0400178 return true;
bsalomon@google.com9aed1142012-01-30 14:28:39 +0000179}
180
bsalomon@google.com9732f622012-01-31 15:19:21 +0000181struct DegenerateTestData {
182 DegenerateTestData() { fStage = kInitial; }
183 bool isDegenerate() const { return kNonDegenerate != fStage; }
184 enum {
185 kInitial,
186 kPoint,
187 kLine,
188 kNonDegenerate
189 } fStage;
commit-bot@chromium.org972f9cd2014-03-28 17:58:28 +0000190 SkPoint fFirstPoint;
191 SkVector fLineNormal;
bsalomon@google.com81712882012-11-01 17:12:34 +0000192 SkScalar fLineC;
bsalomon@google.com9732f622012-01-31 15:19:21 +0000193};
194
commit-bot@chromium.orgfdfbb9d2013-08-15 18:16:27 +0000195static const SkScalar kClose = (SK_Scalar1 / 16);
Mike Reed8be952a2017-02-13 20:44:33 -0500196static const SkScalar kCloseSqd = kClose * kClose;
bsalomon@google.com9732f622012-01-31 15:19:21 +0000197
commit-bot@chromium.org972f9cd2014-03-28 17:58:28 +0000198static void update_degenerate_test(DegenerateTestData* data, const SkPoint& pt) {
bsalomon@google.com9732f622012-01-31 15:19:21 +0000199 switch (data->fStage) {
200 case DegenerateTestData::kInitial:
201 data->fFirstPoint = pt;
202 data->fStage = DegenerateTestData::kPoint;
203 break;
204 case DegenerateTestData::kPoint:
Cary Clarkdf429f32017-11-08 11:44:31 -0500205 if (SkPointPriv::DistanceToSqd(pt, data->fFirstPoint) > kCloseSqd) {
bsalomon@google.com9732f622012-01-31 15:19:21 +0000206 data->fLineNormal = pt - data->fFirstPoint;
207 data->fLineNormal.normalize();
Cary Clarkdf429f32017-11-08 11:44:31 -0500208 SkPointPriv::SetOrthog(&data->fLineNormal, data->fLineNormal);
bsalomon@google.com9732f622012-01-31 15:19:21 +0000209 data->fLineC = -data->fLineNormal.dot(data->fFirstPoint);
210 data->fStage = DegenerateTestData::kLine;
211 }
212 break;
213 case DegenerateTestData::kLine:
commit-bot@chromium.orgfdfbb9d2013-08-15 18:16:27 +0000214 if (SkScalarAbs(data->fLineNormal.dot(pt) + data->fLineC) > kClose) {
bsalomon@google.com9732f622012-01-31 15:19:21 +0000215 data->fStage = DegenerateTestData::kNonDegenerate;
216 }
217 case DegenerateTestData::kNonDegenerate:
218 break;
219 default:
Ben Wagnerb4aab9a2017-08-16 10:53:04 -0400220 SK_ABORT("Unexpected degenerate test stage.");
bsalomon@google.com9732f622012-01-31 15:19:21 +0000221 }
222}
223
reed026beb52015-06-10 14:23:15 -0700224static inline bool get_direction(const SkPath& path, const SkMatrix& m,
225 SkPathPriv::FirstDirection* dir) {
226 if (!SkPathPriv::CheapComputeFirstDirection(path, dir)) {
bsalomon@google.coma51ab842012-07-10 19:53:34 +0000227 return false;
228 }
bsalomon@google.comaf90f7f2012-03-05 20:50:10 +0000229 // check whether m reverses the orientation
tfarina@chromium.orgf6de4752013-08-17 00:02:59 +0000230 SkASSERT(!m.hasPerspective());
Mike Reed8be952a2017-02-13 20:44:33 -0500231 SkScalar det2x2 = m.get(SkMatrix::kMScaleX) * m.get(SkMatrix::kMScaleY) -
232 m.get(SkMatrix::kMSkewX) * m.get(SkMatrix::kMSkewY);
bsalomon@google.comaf90f7f2012-03-05 20:50:10 +0000233 if (det2x2 < 0) {
reed026beb52015-06-10 14:23:15 -0700234 *dir = SkPathPriv::OppositeFirstDirection(*dir);
bsalomon@google.comaf90f7f2012-03-05 20:50:10 +0000235 }
bsalomon@google.coma51ab842012-07-10 19:53:34 +0000236 return true;
bsalomon@google.comaf90f7f2012-03-05 20:50:10 +0000237}
238
commit-bot@chromium.org106655e2013-09-03 21:28:55 +0000239static inline void add_line_to_segment(const SkPoint& pt,
joshualitt27f398f2015-02-05 14:39:01 -0800240 SegmentArray* segments) {
commit-bot@chromium.orgfdfbb9d2013-08-15 18:16:27 +0000241 segments->push_back();
242 segments->back().fType = Segment::kLine;
243 segments->back().fPts[0] = pt;
244}
245
commit-bot@chromium.org106655e2013-09-03 21:28:55 +0000246static inline void add_quad_segment(const SkPoint pts[3],
joshualitt27f398f2015-02-05 14:39:01 -0800247 SegmentArray* segments) {
Cary Clarkdf429f32017-11-08 11:44:31 -0500248 if (SkPointPriv::DistanceToSqd(pts[0], pts[1]) < kCloseSqd ||
249 SkPointPriv::DistanceToSqd(pts[1], pts[2]) < kCloseSqd) {
commit-bot@chromium.orgfdfbb9d2013-08-15 18:16:27 +0000250 if (pts[0] != pts[2]) {
joshualitt27f398f2015-02-05 14:39:01 -0800251 add_line_to_segment(pts[2], segments);
commit-bot@chromium.orgfdfbb9d2013-08-15 18:16:27 +0000252 }
253 } else {
254 segments->push_back();
255 segments->back().fType = Segment::kQuad;
256 segments->back().fPts[0] = pts[1];
257 segments->back().fPts[1] = pts[2];
258 }
259}
260
261static inline void add_cubic_segments(const SkPoint pts[4],
reed026beb52015-06-10 14:23:15 -0700262 SkPathPriv::FirstDirection dir,
joshualitt27f398f2015-02-05 14:39:01 -0800263 SegmentArray* segments) {
commit-bot@chromium.orgfdfbb9d2013-08-15 18:16:27 +0000264 SkSTArray<15, SkPoint, true> quads;
bsalomon18fab302016-02-16 08:00:05 -0800265 GrPathUtils::convertCubicToQuadsConstrainToTangents(pts, SK_Scalar1, dir, &quads);
commit-bot@chromium.orgfdfbb9d2013-08-15 18:16:27 +0000266 int count = quads.count();
267 for (int q = 0; q < count; q += 3) {
joshualitt27f398f2015-02-05 14:39:01 -0800268 add_quad_segment(&quads[q], segments);
commit-bot@chromium.orgfdfbb9d2013-08-15 18:16:27 +0000269 }
270}
271
272static bool get_segments(const SkPath& path,
273 const SkMatrix& m,
274 SegmentArray* segments,
275 SkPoint* fanPt,
276 int* vCount,
joshualitt27f398f2015-02-05 14:39:01 -0800277 int* iCount) {
bsalomon@google.com69cc6ad2012-01-17 14:25:10 +0000278 SkPath::Iter iter(path, true);
bsalomon@google.com30c174b2012-11-13 14:36:42 +0000279 // This renderer over-emphasizes very thin path regions. We use the distance
bsalomon@google.com5cc90d12012-01-17 16:28:34 +0000280 // to the path from the sample to compute coverage. Every pixel intersected
281 // 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 +0000282 // notice that the sample may be close to a very thin area of the path and
bsalomon@google.com5cc90d12012-01-17 16:28:34 +0000283 // thus should be very light. This is particularly egregious for degenerate
284 // line paths. We detect paths that are very close to a line (zero area) and
285 // draw nothing.
bsalomon@google.com9732f622012-01-31 15:19:21 +0000286 DegenerateTestData degenerateData;
reed026beb52015-06-10 14:23:15 -0700287 SkPathPriv::FirstDirection dir;
bsalomon@google.coma51ab842012-07-10 19:53:34 +0000288 // get_direction can fail for some degenerate paths.
289 if (!get_direction(path, m, &dir)) {
290 return false;
291 }
bsalomon@google.com9732f622012-01-31 15:19:21 +0000292
bsalomon@google.com69cc6ad2012-01-17 14:25:10 +0000293 for (;;) {
commit-bot@chromium.org972f9cd2014-03-28 17:58:28 +0000294 SkPoint pts[4];
Brian Salomon97042bf2017-02-28 11:21:28 -0500295 SkPath::Verb verb = iter.next(pts, true, true);
bsalomon@google.com94b284d2013-05-10 17:14:06 +0000296 switch (verb) {
297 case SkPath::kMove_Verb:
bsalomon@google.com1a38d552012-03-15 14:40:46 +0000298 m.mapPoints(pts, 1);
bsalomon@google.com9732f622012-01-31 15:19:21 +0000299 update_degenerate_test(&degenerateData, pts[0]);
300 break;
bsalomon@google.com94b284d2013-05-10 17:14:06 +0000301 case SkPath::kLine_Verb: {
commit-bot@chromium.orgfdfbb9d2013-08-15 18:16:27 +0000302 m.mapPoints(&pts[1], 1);
bsalomon@google.com1a38d552012-03-15 14:40:46 +0000303 update_degenerate_test(&degenerateData, pts[1]);
joshualitt27f398f2015-02-05 14:39:01 -0800304 add_line_to_segment(pts[1], segments);
bsalomon@google.com69cc6ad2012-01-17 14:25:10 +0000305 break;
306 }
bsalomon@google.com94b284d2013-05-10 17:14:06 +0000307 case SkPath::kQuad_Verb:
commit-bot@chromium.orgfdfbb9d2013-08-15 18:16:27 +0000308 m.mapPoints(pts, 3);
bsalomon@google.com9732f622012-01-31 15:19:21 +0000309 update_degenerate_test(&degenerateData, pts[1]);
310 update_degenerate_test(&degenerateData, pts[2]);
joshualitt27f398f2015-02-05 14:39:01 -0800311 add_quad_segment(pts, segments);
bsalomon@google.com69cc6ad2012-01-17 14:25:10 +0000312 break;
egdanielaf18a092015-01-05 10:22:28 -0800313 case SkPath::kConic_Verb: {
314 m.mapPoints(pts, 3);
315 SkScalar weight = iter.conicWeight();
316 SkAutoConicToQuads converter;
317 const SkPoint* quadPts = converter.computeQuads(pts, weight, 0.5f);
318 for (int i = 0; i < converter.countQuads(); ++i) {
319 update_degenerate_test(&degenerateData, quadPts[2*i + 1]);
320 update_degenerate_test(&degenerateData, quadPts[2*i + 2]);
joshualitt27f398f2015-02-05 14:39:01 -0800321 add_quad_segment(quadPts + 2*i, segments);
egdanielaf18a092015-01-05 10:22:28 -0800322 }
323 break;
324 }
bsalomon@google.com94b284d2013-05-10 17:14:06 +0000325 case SkPath::kCubic_Verb: {
bsalomon@google.com1a38d552012-03-15 14:40:46 +0000326 m.mapPoints(pts, 4);
bsalomon@google.com9732f622012-01-31 15:19:21 +0000327 update_degenerate_test(&degenerateData, pts[1]);
328 update_degenerate_test(&degenerateData, pts[2]);
329 update_degenerate_test(&degenerateData, pts[3]);
joshualitt27f398f2015-02-05 14:39:01 -0800330 add_cubic_segments(pts, dir, segments);
bsalomon@google.com69cc6ad2012-01-17 14:25:10 +0000331 break;
332 };
bsalomon@google.com94b284d2013-05-10 17:14:06 +0000333 case SkPath::kDone_Verb:
bsalomon@google.com9732f622012-01-31 15:19:21 +0000334 if (degenerateData.isDegenerate()) {
335 return false;
336 } else {
Greg Daniel8b09b962018-04-03 14:53:45 -0400337 return compute_vectors(segments, fanPt, dir, vCount, iCount);
bsalomon@google.com9732f622012-01-31 15:19:21 +0000338 }
bsalomon@google.com69cc6ad2012-01-17 14:25:10 +0000339 default:
340 break;
341 }
342 }
343}
344
345struct QuadVertex {
commit-bot@chromium.org972f9cd2014-03-28 17:58:28 +0000346 SkPoint fPos;
Brian Salomon60fb0b22017-06-15 17:09:36 -0400347 GrColor fColor;
commit-bot@chromium.org972f9cd2014-03-28 17:58:28 +0000348 SkPoint fUV;
bsalomon@google.com81712882012-11-01 17:12:34 +0000349 SkScalar fD0;
350 SkScalar fD1;
bsalomon@google.com69cc6ad2012-01-17 14:25:10 +0000351};
rmistry@google.comfbfcd562012-08-23 18:09:54 +0000352
bsalomon@google.com7d9ffc82013-05-14 14:20:28 +0000353struct Draw {
354 Draw() : fVertexCnt(0), fIndexCnt(0) {}
355 int fVertexCnt;
356 int fIndexCnt;
357};
358
359typedef SkTArray<Draw, true> DrawArray;
360
Brian Salomon60fb0b22017-06-15 17:09:36 -0400361static void create_vertices(const SegmentArray& segments,
commit-bot@chromium.orgfdfbb9d2013-08-15 18:16:27 +0000362 const SkPoint& fanPt,
Brian Salomon60fb0b22017-06-15 17:09:36 -0400363 GrColor color,
364 DrawArray* draws,
365 QuadVertex* verts,
366 uint16_t* idxs) {
bsalomon@google.com7d9ffc82013-05-14 14:20:28 +0000367 Draw* draw = &draws->push_back();
368 // alias just to make vert/index assignments easier to read.
369 int* v = &draw->fVertexCnt;
370 int* i = &draw->fIndexCnt;
bsalomon@google.com69cc6ad2012-01-17 14:25:10 +0000371
bsalomon@google.com9aed1142012-01-30 14:28:39 +0000372 int count = segments.count();
373 for (int a = 0; a < count; ++a) {
374 const Segment& sega = segments[a];
375 int b = (a + 1) % count;
376 const Segment& segb = segments[b];
rmistry@google.comfbfcd562012-08-23 18:09:54 +0000377
bsalomon@google.com7d9ffc82013-05-14 14:20:28 +0000378 // Check whether adding the verts for this segment to the current draw would cause index
379 // values to overflow.
380 int vCount = 4;
381 if (Segment::kLine == segb.fType) {
382 vCount += 5;
383 } else {
384 vCount += 6;
385 }
386 if (draw->fVertexCnt + vCount > (1 << 16)) {
387 verts += *v;
388 idxs += *i;
389 draw = &draws->push_back();
390 v = &draw->fVertexCnt;
391 i = &draw->fIndexCnt;
392 }
393
bsalomon@google.com9aed1142012-01-30 14:28:39 +0000394 // FIXME: These tris are inset in the 1 unit arc around the corner
bsalomon@google.com7d9ffc82013-05-14 14:20:28 +0000395 verts[*v + 0].fPos = sega.endPt();
396 verts[*v + 1].fPos = verts[*v + 0].fPos + sega.endNorm();
397 verts[*v + 2].fPos = verts[*v + 0].fPos + segb.fMid;
398 verts[*v + 3].fPos = verts[*v + 0].fPos + segb.fNorms[0];
Brian Salomon60fb0b22017-06-15 17:09:36 -0400399 verts[*v + 0].fColor = color;
400 verts[*v + 1].fColor = color;
401 verts[*v + 2].fColor = color;
402 verts[*v + 3].fColor = color;
bsalomon@google.com7d9ffc82013-05-14 14:20:28 +0000403 verts[*v + 0].fUV.set(0,0);
404 verts[*v + 1].fUV.set(0,-SK_Scalar1);
405 verts[*v + 2].fUV.set(0,-SK_Scalar1);
406 verts[*v + 3].fUV.set(0,-SK_Scalar1);
407 verts[*v + 0].fD0 = verts[*v + 0].fD1 = -SK_Scalar1;
408 verts[*v + 1].fD0 = verts[*v + 1].fD1 = -SK_Scalar1;
409 verts[*v + 2].fD0 = verts[*v + 2].fD1 = -SK_Scalar1;
410 verts[*v + 3].fD0 = verts[*v + 3].fD1 = -SK_Scalar1;
rmistry@google.comfbfcd562012-08-23 18:09:54 +0000411
bsalomon@google.com7d9ffc82013-05-14 14:20:28 +0000412 idxs[*i + 0] = *v + 0;
413 idxs[*i + 1] = *v + 2;
414 idxs[*i + 2] = *v + 1;
415 idxs[*i + 3] = *v + 0;
416 idxs[*i + 4] = *v + 3;
417 idxs[*i + 5] = *v + 2;
rmistry@google.comfbfcd562012-08-23 18:09:54 +0000418
bsalomon@google.com7d9ffc82013-05-14 14:20:28 +0000419 *v += 4;
420 *i += 6;
bsalomon@google.com69cc6ad2012-01-17 14:25:10 +0000421
bsalomon@google.com9aed1142012-01-30 14:28:39 +0000422 if (Segment::kLine == segb.fType) {
bsalomon@google.com7d9ffc82013-05-14 14:20:28 +0000423 verts[*v + 0].fPos = fanPt;
424 verts[*v + 1].fPos = sega.endPt();
425 verts[*v + 2].fPos = segb.fPts[0];
bsalomon@google.com9aed1142012-01-30 14:28:39 +0000426
bsalomon@google.com7d9ffc82013-05-14 14:20:28 +0000427 verts[*v + 3].fPos = verts[*v + 1].fPos + segb.fNorms[0];
428 verts[*v + 4].fPos = verts[*v + 2].fPos + segb.fNorms[0];
bsalomon@google.com9aed1142012-01-30 14:28:39 +0000429
Brian Salomon60fb0b22017-06-15 17:09:36 -0400430 verts[*v + 0].fColor = color;
431 verts[*v + 1].fColor = color;
432 verts[*v + 2].fColor = color;
433 verts[*v + 3].fColor = color;
434 verts[*v + 4].fColor = color;
435
bsalomon@google.com9aed1142012-01-30 14:28:39 +0000436 // we draw the line edge as a degenerate quad (u is 0, v is the
437 // signed distance to the edge)
Cary Clarkdf429f32017-11-08 11:44:31 -0500438 SkScalar dist = SkPointPriv::DistanceToLineBetween(fanPt, verts[*v + 1].fPos,
439 verts[*v + 2].fPos);
bsalomon@google.com7d9ffc82013-05-14 14:20:28 +0000440 verts[*v + 0].fUV.set(0, dist);
441 verts[*v + 1].fUV.set(0, 0);
442 verts[*v + 2].fUV.set(0, 0);
443 verts[*v + 3].fUV.set(0, -SK_Scalar1);
444 verts[*v + 4].fUV.set(0, -SK_Scalar1);
bsalomon@google.com9aed1142012-01-30 14:28:39 +0000445
bsalomon@google.com7d9ffc82013-05-14 14:20:28 +0000446 verts[*v + 0].fD0 = verts[*v + 0].fD1 = -SK_Scalar1;
447 verts[*v + 1].fD0 = verts[*v + 1].fD1 = -SK_Scalar1;
448 verts[*v + 2].fD0 = verts[*v + 2].fD1 = -SK_Scalar1;
449 verts[*v + 3].fD0 = verts[*v + 3].fD1 = -SK_Scalar1;
450 verts[*v + 4].fD0 = verts[*v + 4].fD1 = -SK_Scalar1;
bsalomon@google.com69cc6ad2012-01-17 14:25:10 +0000451
cdalton35964822015-04-29 10:14:03 -0700452 idxs[*i + 0] = *v + 3;
453 idxs[*i + 1] = *v + 1;
454 idxs[*i + 2] = *v + 2;
bsalomon@google.com9aed1142012-01-30 14:28:39 +0000455
cdalton35964822015-04-29 10:14:03 -0700456 idxs[*i + 3] = *v + 4;
457 idxs[*i + 4] = *v + 3;
bsalomon@google.com7d9ffc82013-05-14 14:20:28 +0000458 idxs[*i + 5] = *v + 2;
bsalomon@google.com9aed1142012-01-30 14:28:39 +0000459
cdalton35964822015-04-29 10:14:03 -0700460 *i += 6;
461
462 // Draw the interior fan if it exists.
463 // TODO: Detect and combine colinear segments. This will ensure we catch every case
464 // with no interior, and that the resulting shared edge uses the same endpoints.
465 if (count >= 3) {
466 idxs[*i + 0] = *v + 0;
467 idxs[*i + 1] = *v + 2;
468 idxs[*i + 2] = *v + 1;
469
470 *i += 3;
471 }
bsalomon@google.com69cc6ad2012-01-17 14:25:10 +0000472
bsalomon@google.com7d9ffc82013-05-14 14:20:28 +0000473 *v += 5;
bsalomon@google.com06809612012-01-21 15:03:39 +0000474 } else {
commit-bot@chromium.org972f9cd2014-03-28 17:58:28 +0000475 SkPoint qpts[] = {sega.endPt(), segb.fPts[0], segb.fPts[1]};
bsalomon@google.com495e2102012-01-21 14:48:36 +0000476
commit-bot@chromium.org972f9cd2014-03-28 17:58:28 +0000477 SkVector midVec = segb.fNorms[0] + segb.fNorms[1];
bsalomon@google.com9aed1142012-01-30 14:28:39 +0000478 midVec.normalize();
bsalomon@google.com06809612012-01-21 15:03:39 +0000479
bsalomon@google.com7d9ffc82013-05-14 14:20:28 +0000480 verts[*v + 0].fPos = fanPt;
481 verts[*v + 1].fPos = qpts[0];
482 verts[*v + 2].fPos = qpts[2];
483 verts[*v + 3].fPos = qpts[0] + segb.fNorms[0];
484 verts[*v + 4].fPos = qpts[2] + segb.fNorms[1];
485 verts[*v + 5].fPos = qpts[1] + midVec;
bsalomon@google.com9aed1142012-01-30 14:28:39 +0000486
Brian Salomon60fb0b22017-06-15 17:09:36 -0400487 verts[*v + 0].fColor = color;
488 verts[*v + 1].fColor = color;
489 verts[*v + 2].fColor = color;
490 verts[*v + 3].fColor = color;
491 verts[*v + 4].fColor = color;
492 verts[*v + 5].fColor = color;
493
bsalomon@google.com81712882012-11-01 17:12:34 +0000494 SkScalar c = segb.fNorms[0].dot(qpts[0]);
bsalomon@google.com7d9ffc82013-05-14 14:20:28 +0000495 verts[*v + 0].fD0 = -segb.fNorms[0].dot(fanPt) + c;
496 verts[*v + 1].fD0 = 0.f;
497 verts[*v + 2].fD0 = -segb.fNorms[0].dot(qpts[2]) + c;
498 verts[*v + 3].fD0 = -SK_ScalarMax/100;
499 verts[*v + 4].fD0 = -SK_ScalarMax/100;
500 verts[*v + 5].fD0 = -SK_ScalarMax/100;
bsalomon@google.com9aed1142012-01-30 14:28:39 +0000501
502 c = segb.fNorms[1].dot(qpts[2]);
bsalomon@google.com7d9ffc82013-05-14 14:20:28 +0000503 verts[*v + 0].fD1 = -segb.fNorms[1].dot(fanPt) + c;
504 verts[*v + 1].fD1 = -segb.fNorms[1].dot(qpts[0]) + c;
505 verts[*v + 2].fD1 = 0.f;
506 verts[*v + 3].fD1 = -SK_ScalarMax/100;
507 verts[*v + 4].fD1 = -SK_ScalarMax/100;
508 verts[*v + 5].fD1 = -SK_ScalarMax/100;
bsalomon@google.com9aed1142012-01-30 14:28:39 +0000509
bsalomon@google.com19713172012-03-15 13:51:08 +0000510 GrPathUtils::QuadUVMatrix toUV(qpts);
Brian Salomon60fb0b22017-06-15 17:09:36 -0400511 toUV.apply<6, sizeof(QuadVertex), offsetof(QuadVertex, fUV)>(verts + *v);
bsalomon@google.com06809612012-01-21 15:03:39 +0000512
bsalomon@google.com7d9ffc82013-05-14 14:20:28 +0000513 idxs[*i + 0] = *v + 3;
514 idxs[*i + 1] = *v + 1;
515 idxs[*i + 2] = *v + 2;
516 idxs[*i + 3] = *v + 4;
517 idxs[*i + 4] = *v + 3;
518 idxs[*i + 5] = *v + 2;
bsalomon@google.com06809612012-01-21 15:03:39 +0000519
bsalomon@google.com7d9ffc82013-05-14 14:20:28 +0000520 idxs[*i + 6] = *v + 5;
521 idxs[*i + 7] = *v + 3;
522 idxs[*i + 8] = *v + 4;
bsalomon@google.com9aed1142012-01-30 14:28:39 +0000523
cdalton35964822015-04-29 10:14:03 -0700524 *i += 9;
525
526 // Draw the interior fan if it exists.
527 // TODO: Detect and combine colinear segments. This will ensure we catch every case
528 // with no interior, and that the resulting shared edge uses the same endpoints.
529 if (count >= 3) {
530 idxs[*i + 0] = *v + 0;
531 idxs[*i + 1] = *v + 2;
532 idxs[*i + 2] = *v + 1;
533
534 *i += 3;
535 }
bsalomon@google.com9aed1142012-01-30 14:28:39 +0000536
bsalomon@google.com7d9ffc82013-05-14 14:20:28 +0000537 *v += 6;
bsalomon@google.com69cc6ad2012-01-17 14:25:10 +0000538 }
539 }
540}
541
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000542///////////////////////////////////////////////////////////////////////////////
543
544/*
545 * Quadratic specified by 0=u^2-v canonical coords. u and v are the first
546 * two components of the vertex attribute. Coverage is based on signed
547 * distance with negative being inside, positive outside. The edge is specified in
548 * window space (y-down). If either the third or fourth component of the interpolated
549 * 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 +0000550 * attempt to trim to a portion of the infinite quad.
551 * Requires shader derivative instruction support.
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000552 */
553
joshualitt249af152014-09-15 11:41:13 -0700554class QuadEdgeEffect : public GrGeometryProcessor {
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000555public:
Brian Salomon60fb0b22017-06-15 17:09:36 -0400556 static sk_sp<GrGeometryProcessor> Make(const SkMatrix& localMatrix, bool usesLocalCoords) {
557 return sk_sp<GrGeometryProcessor>(new QuadEdgeEffect(localMatrix, usesLocalCoords));
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000558 }
559
Brian Salomond3b65972017-03-22 12:05:03 -0400560 ~QuadEdgeEffect() override {}
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000561
mtklein36352bf2015-03-25 18:17:31 -0700562 const char* name() const override { return "QuadEdge"; }
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000563
egdaniel57d3b032015-11-13 11:57:27 -0800564 class GLSLProcessor : public GrGLSLGeometryProcessor {
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000565 public:
Brian Salomon60fb0b22017-06-15 17:09:36 -0400566 GLSLProcessor() {}
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000567
mtklein36352bf2015-03-25 18:17:31 -0700568 void onEmitCode(EmitArgs& args, GrGPArgs* gpArgs) override {
joshualitt2dd1ae02014-12-03 06:24:10 -0800569 const QuadEdgeEffect& qe = args.fGP.cast<QuadEdgeEffect>();
egdaniel4ca2e602015-11-18 08:01:26 -0800570 GrGLSLVertexBuilder* vertBuilder = args.fVertBuilder;
egdaniel0eafe792015-11-20 14:01:22 -0800571 GrGLSLVaryingHandler* varyingHandler = args.fVaryingHandler;
egdaniel7ea439b2015-12-03 09:20:44 -0800572 GrGLSLUniformHandler* uniformHandler = args.fUniformHandler;
joshualitt2dd1ae02014-12-03 06:24:10 -0800573
joshualittabb52a12015-01-13 15:02:10 -0800574 // emit attributes
egdaniel0eafe792015-11-20 14:01:22 -0800575 varyingHandler->emitAttributes(qe);
joshualittabb52a12015-01-13 15:02:10 -0800576
Chris Dalton27372882017-12-08 13:34:21 -0700577 GrGLSLVarying v(kHalf4_GrSLType);
egdaniel0eafe792015-11-20 14:01:22 -0800578 varyingHandler->addVarying("QuadEdge", &v);
Brian Salomon70132d02018-05-29 15:33:06 -0400579 vertBuilder->codeAppendf("%s = %s;", v.vsOut(), qe.fInQuadEdge->name());
Brian Salomon60fb0b22017-06-15 17:09:36 -0400580
581 // Setup pass through color
582 varyingHandler->addPassThroughAttribute(qe.fInColor, args.fOutputColor);
joshualitt2dd1ae02014-12-03 06:24:10 -0800583
Chris Dalton60283612018-02-14 13:38:14 -0700584 GrGLSLFPFragmentBuilder* fragBuilder = args.fFragBuilder;
joshualitt9b989322014-12-15 14:16:27 -0800585
joshualittabb52a12015-01-13 15:02:10 -0800586 // Setup position
Brian Salomon70132d02018-05-29 15:33:06 -0400587 this->writeOutputPosition(vertBuilder, gpArgs, qe.fInPosition->name());
joshualittabb52a12015-01-13 15:02:10 -0800588
589 // emit transforms
egdaniel7ea439b2015-12-03 09:20:44 -0800590 this->emitTransforms(vertBuilder,
egdaniel0eafe792015-11-20 14:01:22 -0800591 varyingHandler,
egdaniel7ea439b2015-12-03 09:20:44 -0800592 uniformHandler,
Brian Salomon04460cc2017-12-06 14:47:42 -0500593 qe.fInPosition->asShaderVar(),
Brian Salomon60fb0b22017-06-15 17:09:36 -0400594 qe.fLocalMatrix,
bsalomona624bf32016-09-20 09:12:47 -0700595 args.fFPCoordTransformHandler);
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000596
Ethan Nicholasf7b88202017-09-18 14:10:39 -0400597 fragBuilder->codeAppendf("half edgeAlpha;");
joshualitt30ba4362014-08-21 20:18:45 -0700598
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000599 // keep the derivative instructions outside the conditional
Ethan Nicholasf7b88202017-09-18 14:10:39 -0400600 fragBuilder->codeAppendf("half2 duvdx = dFdx(%s.xy);", v.fsIn());
601 fragBuilder->codeAppendf("half2 duvdy = dFdy(%s.xy);", v.fsIn());
egdaniel4ca2e602015-11-18 08:01:26 -0800602 fragBuilder->codeAppendf("if (%s.z > 0.0 && %s.w > 0.0) {", v.fsIn(), v.fsIn());
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000603 // today we know z and w are in device space. We could use derivatives
egdaniel4ca2e602015-11-18 08:01:26 -0800604 fragBuilder->codeAppendf("edgeAlpha = min(min(%s.z, %s.w) + 0.5, 1.0);", v.fsIn(),
605 v.fsIn());
606 fragBuilder->codeAppendf ("} else {");
Ethan Nicholasf7b88202017-09-18 14:10:39 -0400607 fragBuilder->codeAppendf("half2 gF = half2(2.0*%s.x*duvdx.x - duvdx.y,"
egdaniel4ca2e602015-11-18 08:01:26 -0800608 " 2.0*%s.x*duvdy.x - duvdy.y);",
609 v.fsIn(), v.fsIn());
610 fragBuilder->codeAppendf("edgeAlpha = (%s.x*%s.x - %s.y);", v.fsIn(), v.fsIn(),
611 v.fsIn());
612 fragBuilder->codeAppendf("edgeAlpha = "
613 "clamp(0.5 - edgeAlpha / length(gF), 0.0, 1.0);}");
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000614
Ethan Nicholasf7b88202017-09-18 14:10:39 -0400615 fragBuilder->codeAppendf("%s = half4(edgeAlpha);", args.fOutputCoverage);
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000616 }
617
joshualitt9b989322014-12-15 14:16:27 -0800618 static inline void GenKey(const GrGeometryProcessor& gp,
Brian Salomon94efbf52016-11-29 13:43:05 -0500619 const GrShaderCaps&,
joshualitt9b989322014-12-15 14:16:27 -0800620 GrProcessorKeyBuilder* b) {
joshualitte3ababe2015-05-15 07:56:07 -0700621 const QuadEdgeEffect& qee = gp.cast<QuadEdgeEffect>();
Brian Salomon60fb0b22017-06-15 17:09:36 -0400622 b->add32(SkToBool(qee.fUsesLocalCoords && qee.fLocalMatrix.hasPerspective()));
joshualitt9b989322014-12-15 14:16:27 -0800623 }
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000624
egdaniel018fb622015-10-28 07:26:40 -0700625 void setData(const GrGLSLProgramDataManager& pdman,
bsalomona624bf32016-09-20 09:12:47 -0700626 const GrPrimitiveProcessor& gp,
627 FPCoordTransformIter&& transformIter) override {
joshualittb8c241a2015-05-19 08:23:30 -0700628 const QuadEdgeEffect& qe = gp.cast<QuadEdgeEffect>();
bsalomona624bf32016-09-20 09:12:47 -0700629 this->setTransformDataHelper(qe.fLocalMatrix, pdman, &transformIter);
joshualitte3ababe2015-05-15 07:56:07 -0700630 }
631
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000632 private:
egdaniele659a582015-11-13 09:55:43 -0800633 typedef GrGLSLGeometryProcessor INHERITED;
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000634 };
skia.committer@gmail.com041e2db2013-04-03 07:01:14 +0000635
Brian Salomon94efbf52016-11-29 13:43:05 -0500636 void getGLSLProcessorKey(const GrShaderCaps& caps, GrProcessorKeyBuilder* b) const override {
egdaniel57d3b032015-11-13 11:57:27 -0800637 GLSLProcessor::GenKey(*this, caps, b);
joshualitteb2a6762014-12-04 11:35:33 -0800638 }
639
Brian Salomon94efbf52016-11-29 13:43:05 -0500640 GrGLSLPrimitiveProcessor* createGLSLInstance(const GrShaderCaps&) const override {
egdaniel57d3b032015-11-13 11:57:27 -0800641 return new GLSLProcessor();
joshualitteb2a6762014-12-04 11:35:33 -0800642 }
643
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000644private:
Brian Salomon60fb0b22017-06-15 17:09:36 -0400645 QuadEdgeEffect(const SkMatrix& localMatrix, bool usesLocalCoords)
Ethan Nicholasabff9562017-10-09 10:54:08 -0400646 : INHERITED(kQuadEdgeEffect_ClassID)
647 , fLocalMatrix(localMatrix)
648 , fUsesLocalCoords(usesLocalCoords) {
Ethan Nicholasfa7ee242017-09-25 09:52:04 -0400649 fInPosition = &this->addVertexAttrib("inPosition", kFloat2_GrVertexAttribType);
650 fInColor = &this->addVertexAttrib("inColor", kUByte4_norm_GrVertexAttribType);
651 fInQuadEdge = &this->addVertexAttrib("inQuadEdge", kHalf4_GrVertexAttribType);
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000652 }
653
joshualitt71c92602015-01-14 08:12:47 -0800654 const Attribute* fInPosition;
655 const Attribute* fInQuadEdge;
Brian Salomon60fb0b22017-06-15 17:09:36 -0400656 const Attribute* fInColor;
joshualitte3ababe2015-05-15 07:56:07 -0700657 SkMatrix fLocalMatrix;
joshualittb8c241a2015-05-19 08:23:30 -0700658 bool fUsesLocalCoords;
joshualitt249af152014-09-15 11:41:13 -0700659
Brian Salomon0c26a9d2017-07-06 10:09:38 -0400660 GR_DECLARE_GEOMETRY_PROCESSOR_TEST
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000661
joshualitt2e3b3e32014-12-09 13:31:14 -0800662 typedef GrGeometryProcessor INHERITED;
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000663};
664
joshualittb0a8a372014-09-23 09:50:21 -0700665GR_DEFINE_GEOMETRY_PROCESSOR_TEST(QuadEdgeEffect);
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000666
Hal Canary6f6961e2017-01-31 13:50:44 -0500667#if GR_TEST_UTILS
bungeman06ca8ec2016-06-09 08:01:03 -0700668sk_sp<GrGeometryProcessor> QuadEdgeEffect::TestCreate(GrProcessorTestData* d) {
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000669 // Doesn't work without derivative instructions.
Robert Phillips296b1cc2017-03-15 10:42:12 -0400670 return d->caps()->shaderCaps()->shaderDerivativeSupport()
Brian Salomon60fb0b22017-06-15 17:09:36 -0400671 ? QuadEdgeEffect::Make(GrTest::TestMatrix(d->fRandom), d->fRandom->nextBool())
Brian Salomon9ae32a22017-01-25 14:58:24 -0500672 : nullptr;
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000673}
Hal Canary6f6961e2017-01-31 13:50:44 -0500674#endif
commit-bot@chromium.org90c240a2013-04-02 17:57:21 +0000675
676///////////////////////////////////////////////////////////////////////////////
677
Chris Dalton5ed44232017-09-07 13:22:46 -0600678GrPathRenderer::CanDrawPath
679GrAAConvexPathRenderer::onCanDrawPath(const CanDrawPathArgs& args) const {
680 if (args.fCaps->shaderCaps()->shaderDerivativeSupport() &&
681 (GrAAType::kCoverage == args.fAAType) && args.fShape->style().isSimpleFill() &&
682 !args.fShape->inverseFilled() && args.fShape->knownToBeConvex()) {
683 return CanDrawPath::kYes;
684 }
685 return CanDrawPath::kNo;
robertphillips@google.comfa662942012-05-17 12:20:22 +0000686}
687
robertphillipse16dfdb2015-05-08 04:46:51 -0700688// extract the result vertices and indices from the GrAAConvexTessellator
Brian Salomon60fb0b22017-06-15 17:09:36 -0400689static void extract_lines_only_verts(const GrAAConvexTessellator& tess,
690 void* vertices,
691 size_t vertexStride,
692 GrColor color,
693 uint16_t* idxs,
694 bool tweakAlphaForCoverage) {
robertphillipse16dfdb2015-05-08 04:46:51 -0700695 intptr_t verts = reinterpret_cast<intptr_t>(vertices);
696
697 for (int i = 0; i < tess.numPts(); ++i) {
698 *((SkPoint*)((intptr_t)verts + i * vertexStride)) = tess.point(i);
699 }
700
701 // Make 'verts' point to the colors
702 verts += sizeof(SkPoint);
703 for (int i = 0; i < tess.numPts(); ++i) {
robertphillipse16dfdb2015-05-08 04:46:51 -0700704 if (tweakAlphaForCoverage) {
fmalitabd5d7e72015-06-26 07:18:24 -0700705 SkASSERT(SkScalarRoundToInt(255.0f * tess.coverage(i)) <= 255);
706 unsigned scale = SkScalarRoundToInt(255.0f * tess.coverage(i));
robertphillipse16dfdb2015-05-08 04:46:51 -0700707 GrColor scaledColor = (0xff == scale) ? color : SkAlphaMulQ(color, scale);
708 *reinterpret_cast<GrColor*>(verts + i * vertexStride) = scaledColor;
709 } else {
710 *reinterpret_cast<GrColor*>(verts + i * vertexStride) = color;
halcanary9d524f22016-03-29 09:03:52 -0700711 *reinterpret_cast<float*>(verts + i * vertexStride + sizeof(GrColor)) =
fmalitabd5d7e72015-06-26 07:18:24 -0700712 tess.coverage(i);
robertphillipse16dfdb2015-05-08 04:46:51 -0700713 }
714 }
715
716 for (int i = 0; i < tess.numIndices(); ++i) {
717 idxs[i] = tess.index(i);
718 }
719}
720
Brian Salomon60fb0b22017-06-15 17:09:36 -0400721static sk_sp<GrGeometryProcessor> make_lines_only_gp(bool tweakAlphaForCoverage,
722 const SkMatrix& viewMatrix,
723 bool usesLocalCoords) {
joshualittdf0c5572015-08-03 11:35:28 -0700724 using namespace GrDefaultGeoProcFactory;
joshualitte494a582015-08-03 09:32:36 -0700725
joshualittdf0c5572015-08-03 11:35:28 -0700726 Coverage::Type coverageType;
Brian Salomon8c852be2017-01-04 10:44:42 -0500727 if (tweakAlphaForCoverage) {
joshualittdf0c5572015-08-03 11:35:28 -0700728 coverageType = Coverage::kSolid_Type;
729 } else {
730 coverageType = Coverage::kAttribute_Type;
731 }
Brian Salomon8c852be2017-01-04 10:44:42 -0500732 LocalCoords::Type localCoordsType =
733 usesLocalCoords ? LocalCoords::kUsePosition_Type : LocalCoords::kUnused_Type;
Brian Salomon3de0aee2017-01-29 09:34:17 -0500734 return MakeForDeviceSpace(Color::kPremulGrColorAttribute_Type, coverageType, localCoordsType,
735 viewMatrix);
robertphillipse16dfdb2015-05-08 04:46:51 -0700736}
737
Brian Salomon10978a62017-06-15 16:21:49 -0400738namespace {
739
740class AAConvexPathOp final : public GrMeshDrawOp {
741private:
742 using Helper = GrSimpleMeshDrawOpHelperWithStencil;
743
joshualitt27f398f2015-02-05 14:39:01 -0800744public:
Brian Salomon25a88092016-12-01 09:36:50 -0500745 DEFINE_OP_CLASS_ID
Robert Phillipsb493eeb2017-09-13 13:10:52 -0400746
Brian Salomon10978a62017-06-15 16:21:49 -0400747 static std::unique_ptr<GrDrawOp> Make(GrPaint&& paint, const SkMatrix& viewMatrix,
748 const SkPath& path,
749 const GrUserStencilSettings* stencilSettings) {
750 return Helper::FactoryHelper<AAConvexPathOp>(std::move(paint), viewMatrix, path,
751 stencilSettings);
752 }
753
754 AAConvexPathOp(const Helper::MakeArgs& helperArgs, GrColor color, const SkMatrix& viewMatrix,
755 const SkPath& path, const GrUserStencilSettings* stencilSettings)
Brian Salomon60fb0b22017-06-15 17:09:36 -0400756 : INHERITED(ClassID()), fHelper(helperArgs, GrAAType::kCoverage, stencilSettings) {
757 fPaths.emplace_back(PathData{viewMatrix, path, color});
Brian Salomon10978a62017-06-15 16:21:49 -0400758 this->setTransformedBounds(path.getBounds(), viewMatrix, HasAABloat::kYes, IsZeroArea::kNo);
759 fLinesOnly = SkPath::kLine_SegmentMask == path.getSegmentMasks();
bsalomonf1703092016-06-29 18:41:53 -0700760 }
joshualitt27f398f2015-02-05 14:39:01 -0800761
Brian Salomond0a0a652016-12-15 15:25:22 -0500762 const char* name() const override { return "AAConvexPathOp"; }
joshualitt27f398f2015-02-05 14:39:01 -0800763
Robert Phillipsf1748f52017-09-14 14:11:24 -0400764 void visitProxies(const VisitProxyFunc& func) const override {
Robert Phillipsb493eeb2017-09-13 13:10:52 -0400765 fHelper.visitProxies(func);
766 }
767
Brian Salomon7c3e7182016-12-01 09:35:30 -0500768 SkString dumpInfo() const override {
769 SkString string;
Brian Salomon60fb0b22017-06-15 17:09:36 -0400770 string.appendf("Count: %d\n", fPaths.count());
Brian Salomon10978a62017-06-15 16:21:49 -0400771 string += fHelper.dumpInfo();
772 string += INHERITED::dumpInfo();
Brian Salomon7c3e7182016-12-01 09:35:30 -0500773 return string;
774 }
775
Brian Salomon10978a62017-06-15 16:21:49 -0400776 FixedFunctionFlags fixedFunctionFlags() const override { return fHelper.fixedFunctionFlags(); }
777
Brian Osman9a725dd2017-09-20 09:53:22 -0400778 RequiresDstTexture finalize(const GrCaps& caps, const GrAppliedClip* clip,
779 GrPixelConfigIsClamped dstIsClamped) override {
780 return fHelper.xpRequiresDstTexture(caps, clip, dstIsClamped,
781 GrProcessorAnalysisCoverage::kSingleChannel,
Brian Salomon60fb0b22017-06-15 17:09:36 -0400782 &fPaths.back().fColor);
Brian Salomon10978a62017-06-15 16:21:49 -0400783 }
784
bsalomone46f9fe2015-08-18 06:05:14 -0700785private:
Brian Salomon91326c32017-08-09 16:02:19 -0400786 void prepareLinesOnlyDraws(Target* target) {
Brian Salomon60fb0b22017-06-15 17:09:36 -0400787 // Setup GrGeometryProcessor
788 sk_sp<GrGeometryProcessor> gp(make_lines_only_gp(fHelper.compatibleWithAlphaAsCoverage(),
789 fPaths.back().fViewMatrix,
790 fHelper.usesLocalCoords()));
joshualittdf0c5572015-08-03 11:35:28 -0700791 if (!gp) {
792 SkDebugf("Could not create GrGeometryProcessor\n");
robertphillipse16dfdb2015-05-08 04:46:51 -0700793 return;
794 }
795
robertphillipse16dfdb2015-05-08 04:46:51 -0700796 size_t vertexStride = gp->getVertexStride();
797
Brian Salomon60fb0b22017-06-15 17:09:36 -0400798 SkASSERT(fHelper.compatibleWithAlphaAsCoverage()
799 ? vertexStride == sizeof(GrDefaultGeoProcFactory::PositionColorAttr)
800 : vertexStride ==
801 sizeof(GrDefaultGeoProcFactory::PositionColorCoverageAttr));
robertphillipse16dfdb2015-05-08 04:46:51 -0700802
803 GrAAConvexTessellator tess;
804
Brian Salomond0a0a652016-12-15 15:25:22 -0500805 int instanceCount = fPaths.count();
Brian Salomon10978a62017-06-15 16:21:49 -0400806 const GrPipeline* pipeline = fHelper.makePipeline(target);
robertphillipse16dfdb2015-05-08 04:46:51 -0700807 for (int i = 0; i < instanceCount; i++) {
808 tess.rewind();
809
Brian Salomond0a0a652016-12-15 15:25:22 -0500810 const PathData& args = fPaths[i];
robertphillipse16dfdb2015-05-08 04:46:51 -0700811
812 if (!tess.tessellate(args.fViewMatrix, args.fPath)) {
813 continue;
814 }
815
cdalton397536c2016-03-25 12:15:03 -0700816 const GrBuffer* vertexBuffer;
robertphillipse16dfdb2015-05-08 04:46:51 -0700817 int firstVertex;
818
bsalomon75398562015-08-17 12:55:38 -0700819 void* verts = target->makeVertexSpace(vertexStride, tess.numPts(), &vertexBuffer,
820 &firstVertex);
robertphillipse16dfdb2015-05-08 04:46:51 -0700821 if (!verts) {
822 SkDebugf("Could not allocate vertices\n");
823 return;
824 }
825
cdalton397536c2016-03-25 12:15:03 -0700826 const GrBuffer* indexBuffer;
robertphillipse16dfdb2015-05-08 04:46:51 -0700827 int firstIndex;
828
bsalomon75398562015-08-17 12:55:38 -0700829 uint16_t* idxs = target->makeIndexSpace(tess.numIndices(), &indexBuffer, &firstIndex);
robertphillipse16dfdb2015-05-08 04:46:51 -0700830 if (!idxs) {
831 SkDebugf("Could not allocate indices\n");
832 return;
833 }
834
Brian Salomon60fb0b22017-06-15 17:09:36 -0400835 extract_lines_only_verts(tess, verts, vertexStride, args.fColor, idxs,
836 fHelper.compatibleWithAlphaAsCoverage());
robertphillipse16dfdb2015-05-08 04:46:51 -0700837
Chris Dalton3809bab2017-06-13 10:55:06 -0600838 GrMesh mesh(GrPrimitiveType::kTriangles);
Chris Dalton114a3c02017-05-26 15:17:19 -0600839 mesh.setIndexed(indexBuffer, tess.numIndices(), firstIndex, 0, tess.numPts() - 1);
840 mesh.setVertexData(vertexBuffer, firstVertex);
Brian Salomon10978a62017-06-15 16:21:49 -0400841 target->draw(gp.get(), pipeline, mesh);
robertphillipse16dfdb2015-05-08 04:46:51 -0700842 }
joshualitt27f398f2015-02-05 14:39:01 -0800843 }
844
Brian Salomon91326c32017-08-09 16:02:19 -0400845 void onPrepareDraws(Target* target) override {
robertphillipse16dfdb2015-05-08 04:46:51 -0700846#ifndef SK_IGNORE_LINEONLY_AA_CONVEX_PATH_OPTS
Brian Salomon10978a62017-06-15 16:21:49 -0400847 if (fLinesOnly) {
bsalomon75398562015-08-17 12:55:38 -0700848 this->prepareLinesOnlyDraws(target);
robertphillipse16dfdb2015-05-08 04:46:51 -0700849 return;
850 }
851#endif
Brian Salomon10978a62017-06-15 16:21:49 -0400852 const GrPipeline* pipeline = fHelper.makePipeline(target);
Brian Salomond0a0a652016-12-15 15:25:22 -0500853 int instanceCount = fPaths.count();
joshualitt27f398f2015-02-05 14:39:01 -0800854
855 SkMatrix invert;
Brian Salomon10978a62017-06-15 16:21:49 -0400856 if (fHelper.usesLocalCoords() && !fPaths.back().fViewMatrix.invert(&invert)) {
joshualitt27f398f2015-02-05 14:39:01 -0800857 return;
858 }
859
860 // Setup GrGeometryProcessor
bungeman06ca8ec2016-06-09 08:01:03 -0700861 sk_sp<GrGeometryProcessor> quadProcessor(
Brian Salomon60fb0b22017-06-15 17:09:36 -0400862 QuadEdgeEffect::Make(invert, fHelper.usesLocalCoords()));
joshualitt27f398f2015-02-05 14:39:01 -0800863
joshualitt27f398f2015-02-05 14:39:01 -0800864 // TODO generate all segments for all paths and use one vertex buffer
865 for (int i = 0; i < instanceCount; i++) {
Brian Salomond0a0a652016-12-15 15:25:22 -0500866 const PathData& args = fPaths[i];
joshualitt27f398f2015-02-05 14:39:01 -0800867
868 // We use the fact that SkPath::transform path does subdivision based on
869 // perspective. Otherwise, we apply the view matrix when copying to the
870 // segment representation.
871 const SkMatrix* viewMatrix = &args.fViewMatrix;
joshualitt144c3c82015-11-30 12:30:13 -0800872
873 // We avoid initializing the path unless we have to
874 const SkPath* pathPtr = &args.fPath;
875 SkTLazy<SkPath> tmpPath;
joshualitt27f398f2015-02-05 14:39:01 -0800876 if (viewMatrix->hasPerspective()) {
joshualitt144c3c82015-11-30 12:30:13 -0800877 SkPath* tmpPathPtr = tmpPath.init(*pathPtr);
878 tmpPathPtr->setIsVolatile(true);
879 tmpPathPtr->transform(*viewMatrix);
joshualitt27f398f2015-02-05 14:39:01 -0800880 viewMatrix = &SkMatrix::I();
joshualitt144c3c82015-11-30 12:30:13 -0800881 pathPtr = tmpPathPtr;
joshualitt27f398f2015-02-05 14:39:01 -0800882 }
883
884 int vertexCount;
885 int indexCount;
886 enum {
887 kPreallocSegmentCnt = 512 / sizeof(Segment),
888 kPreallocDrawCnt = 4,
889 };
890 SkSTArray<kPreallocSegmentCnt, Segment, true> segments;
891 SkPoint fanPt;
892
joshualitt144c3c82015-11-30 12:30:13 -0800893 if (!get_segments(*pathPtr, *viewMatrix, &segments, &fanPt, &vertexCount,
joshualitt27f398f2015-02-05 14:39:01 -0800894 &indexCount)) {
895 continue;
896 }
897
Chris Daltonff926502017-05-03 14:36:54 -0400898 const GrBuffer* vertexBuffer;
Chris Daltonbca46e22017-05-15 11:03:26 -0600899 int firstVertex;
900
joshualitt27f398f2015-02-05 14:39:01 -0800901 size_t vertexStride = quadProcessor->getVertexStride();
bsalomon75398562015-08-17 12:55:38 -0700902 QuadVertex* verts = reinterpret_cast<QuadVertex*>(target->makeVertexSpace(
Chris Daltonbca46e22017-05-15 11:03:26 -0600903 vertexStride, vertexCount, &vertexBuffer, &firstVertex));
bsalomone64eb572015-05-07 11:35:55 -0700904
905 if (!verts) {
joshualitt4b31de82015-03-05 14:33:41 -0800906 SkDebugf("Could not allocate vertices\n");
907 return;
908 }
909
cdalton397536c2016-03-25 12:15:03 -0700910 const GrBuffer* indexBuffer;
Chris Daltonbca46e22017-05-15 11:03:26 -0600911 int firstIndex;
912
913 uint16_t *idxs = target->makeIndexSpace(indexCount, &indexBuffer, &firstIndex);
robertphillipse40d3972015-05-07 09:51:43 -0700914 if (!idxs) {
joshualitt4b31de82015-03-05 14:33:41 -0800915 SkDebugf("Could not allocate indices\n");
916 return;
917 }
918
joshualitt27f398f2015-02-05 14:39:01 -0800919 SkSTArray<kPreallocDrawCnt, Draw, true> draws;
Brian Salomon60fb0b22017-06-15 17:09:36 -0400920 create_vertices(segments, fanPt, args.fColor, &draws, verts, idxs);
joshualitt27f398f2015-02-05 14:39:01 -0800921
Chris Dalton3809bab2017-06-13 10:55:06 -0600922 GrMesh mesh(GrPrimitiveType::kTriangles);
Chris Daltonbca46e22017-05-15 11:03:26 -0600923
robertphillips44c31282015-09-03 12:58:48 -0700924 for (int j = 0; j < draws.count(); ++j) {
925 const Draw& draw = draws[j];
Chris Dalton114a3c02017-05-26 15:17:19 -0600926 mesh.setIndexed(indexBuffer, draw.fIndexCnt, firstIndex, 0, draw.fVertexCnt - 1);
927 mesh.setVertexData(vertexBuffer, firstVertex);
Brian Salomon10978a62017-06-15 16:21:49 -0400928 target->draw(quadProcessor.get(), pipeline, mesh);
Chris Daltonbca46e22017-05-15 11:03:26 -0600929 firstIndex += draw.fIndexCnt;
930 firstVertex += draw.fVertexCnt;
joshualitt27f398f2015-02-05 14:39:01 -0800931 }
932 }
933 }
934
Brian Salomon25a88092016-12-01 09:36:50 -0500935 bool onCombineIfPossible(GrOp* t, const GrCaps& caps) override {
Brian Salomond0a0a652016-12-15 15:25:22 -0500936 AAConvexPathOp* that = t->cast<AAConvexPathOp>();
Brian Salomon10978a62017-06-15 16:21:49 -0400937 if (!fHelper.isCompatible(that->fHelper, caps, this->bounds(), that->bounds())) {
joshualitt8cab9a72015-07-16 09:13:50 -0700938 return false;
939 }
Brian Salomon10978a62017-06-15 16:21:49 -0400940 if (fHelper.usesLocalCoords() &&
941 !fPaths[0].fViewMatrix.cheapEqualTo(that->fPaths[0].fViewMatrix)) {
joshualitt27f398f2015-02-05 14:39:01 -0800942 return false;
943 }
944
Brian Salomon10978a62017-06-15 16:21:49 -0400945 if (fLinesOnly != that->fLinesOnly) {
robertphillipse16dfdb2015-05-08 04:46:51 -0700946 return false;
947 }
948
Brian Salomond0a0a652016-12-15 15:25:22 -0500949 fPaths.push_back_n(that->fPaths.count(), that->fPaths.begin());
bsalomon88cf17d2016-07-08 06:40:56 -0700950 this->joinBounds(*that);
joshualitt27f398f2015-02-05 14:39:01 -0800951 return true;
952 }
953
Brian Salomond0a0a652016-12-15 15:25:22 -0500954 struct PathData {
bsalomonf1703092016-06-29 18:41:53 -0700955 SkMatrix fViewMatrix;
956 SkPath fPath;
Brian Salomon60fb0b22017-06-15 17:09:36 -0400957 GrColor fColor;
bsalomonf1703092016-06-29 18:41:53 -0700958 };
959
Brian Salomon10978a62017-06-15 16:21:49 -0400960 Helper fHelper;
Brian Salomond0a0a652016-12-15 15:25:22 -0500961 SkSTArray<1, PathData, true> fPaths;
Brian Salomon10978a62017-06-15 16:21:49 -0400962 bool fLinesOnly;
reed1b55a962015-09-17 20:16:13 -0700963
Brian Salomon10978a62017-06-15 16:21:49 -0400964 typedef GrMeshDrawOp INHERITED;
joshualitt27f398f2015-02-05 14:39:01 -0800965};
966
Brian Salomon10978a62017-06-15 16:21:49 -0400967} // anonymous namespace
968
bsalomon0aff2fa2015-07-31 06:48:27 -0700969bool GrAAConvexPathRenderer::onDrawPath(const DrawPathArgs& args) {
Brian Osman11052242016-10-27 14:47:55 -0400970 GR_AUDIT_TRAIL_AUTO_FRAME(args.fRenderTargetContext->auditTrail(),
robertphillips976f5f02016-06-03 10:59:20 -0700971 "GrAAConvexPathRenderer::onDrawPath");
Brian Salomon7c8460e2017-05-12 11:36:10 -0400972 SkASSERT(GrFSAAType::kUnifiedMSAA != args.fRenderTargetContext->fsaaType());
bsalomon8acedde2016-06-24 10:42:16 -0700973 SkASSERT(!args.fShape->isEmpty());
bsalomon@google.com4647f902013-03-26 14:45:27 +0000974
bsalomonf1703092016-06-29 18:41:53 -0700975 SkPath path;
976 args.fShape->asPath(&path);
bsalomon@google.comaf90f7f2012-03-05 20:50:10 +0000977
Brian Salomon10978a62017-06-15 16:21:49 -0400978 std::unique_ptr<GrDrawOp> op = AAConvexPathOp::Make(std::move(args.fPaint), *args.fViewMatrix,
979 path, args.fUserStencilSettings);
980 args.fRenderTargetContext->addDrawOp(*args.fClip, std::move(op));
bsalomon@google.comc2099d22012-03-02 21:26:50 +0000981 return true;
bsalomon@google.com69cc6ad2012-01-17 14:25:10 +0000982}
joshualitt8e5c1772015-05-11 08:58:52 -0700983
984///////////////////////////////////////////////////////////////////////////////////////////////////
985
Hal Canary6f6961e2017-01-31 13:50:44 -0500986#if GR_TEST_UTILS
joshualitt8e5c1772015-05-11 08:58:52 -0700987
Brian Salomon10978a62017-06-15 16:21:49 -0400988GR_DRAW_OP_TEST_DEFINE(AAConvexPathOp) {
bsalomonf1703092016-06-29 18:41:53 -0700989 SkMatrix viewMatrix = GrTest::TestMatrixInvertible(random);
990 SkPath path = GrTest::TestPathConvex(random);
Brian Salomon10978a62017-06-15 16:21:49 -0400991 const GrUserStencilSettings* stencilSettings = GrGetRandomStencil(random, context);
992 return AAConvexPathOp::Make(std::move(paint), viewMatrix, path, stencilSettings);
joshualitt8e5c1772015-05-11 08:58:52 -0700993}
994
995#endif