1 /*
2 * Copyright 2017 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 "include/core/SkTypes.h"
9
10 #if SK_SUPPORT_GPU
11
12 #include "include/core/SkCanvas.h"
13 #include "include/core/SkPaint.h"
14 #include "include/core/SkPath.h"
15 #include "include/gpu/GrDirectContext.h"
16 #include "samplecode/Sample.h"
17 #include "src/core/SkRectPriv.h"
18 #include "src/gpu/GrDirectContextPriv.h"
19 #include "src/gpu/GrGpu.h"
20 #include "src/gpu/GrMemoryPool.h"
21 #include "src/gpu/GrOnFlushResourceProvider.h"
22 #include "src/gpu/GrOpFlushState.h"
23 #include "src/gpu/GrRecordingContextPriv.h"
24 #include "src/gpu/GrRenderTargetContext.h"
25 #include "src/gpu/GrRenderTargetContextPriv.h"
26 #include "src/gpu/GrResourceProvider.h"
27 #include "src/gpu/ccpr/GrCCCoverageProcessor.h"
28 #include "src/gpu/ccpr/GrCCFillGeometry.h"
29 #include "src/gpu/ccpr/GrGSCoverageProcessor.h"
30 #include "src/gpu/ccpr/GrVSCoverageProcessor.h"
31 #include "src/gpu/geometry/GrPathUtils.h"
32 #include "src/gpu/glsl/GrGLSLFragmentShaderBuilder.h"
33 #include "src/gpu/ops/GrDrawOp.h"
34
35 #ifdef SK_GL
36 #include "src/gpu/gl/GrGLGpu.h"
37 #endif
38
39 using TriPointInstance = GrCCCoverageProcessor::TriPointInstance;
40 using QuadPointInstance = GrCCCoverageProcessor::QuadPointInstance;
41 using PrimitiveType = GrCCCoverageProcessor::PrimitiveType;
42
43 static constexpr float kDebugBloat = 40;
44
45 /**
46 * This sample visualizes the AA bloat geometry generated by the ccpr geometry shaders. It
47 * increases the AA bloat by 50x and outputs color instead of coverage (coverage=+1 -> green,
48 * coverage=0 -> black, coverage=-1 -> red). Use the keys 1-7 to cycle through the different
49 * geometry processors.
50 */
51 class CCPRGeometryView : public Sample {
onOnceBeforeDraw()52 void onOnceBeforeDraw() override { this->updateGpuData(); }
53 void onDrawContent(SkCanvas*) override;
54
55 Sample::Click* onFindClickHandler(SkScalar x, SkScalar y, skui::ModifierKey) override;
56 bool onClick(Sample::Click*) override;
57 bool onChar(SkUnichar) override;
name()58 SkString name() override { return SkString("CCPRGeometry"); }
59
60 class Click;
61 class DrawCoverageCountOp;
62 class VisualizeCoverageCountFP;
63
updateAndInval()64 void updateAndInval() { this->updateGpuData(); }
65
66 void updateGpuData();
67
68 PrimitiveType fPrimitiveType = PrimitiveType::kCubics;
69
70 SkPoint fPoints[4] = {
71 {100.05f, 100.05f}, {400.75f, 100.05f}, {400.75f, 300.95f}, {100.05f, 300.95f}};
72
73 float fConicWeight = .5;
74 float fStrokeWidth = 40;
75 SkPaint::Join fStrokeJoin = SkPaint::kMiter_Join;
76 SkPaint::Cap fStrokeCap = SkPaint::kButt_Cap;
77 bool fDoStroke = true;
78
79 SkTArray<TriPointInstance> fTriPointInstances;
80 SkTArray<QuadPointInstance> fQuadPointInstances;
81 SkPath fPath;
82 };
83
84 class CCPRGeometryView::DrawCoverageCountOp : public GrDrawOp {
85 DEFINE_OP_CLASS_ID
86
87 public:
DrawCoverageCountOp(CCPRGeometryView * view)88 DrawCoverageCountOp(CCPRGeometryView* view) : INHERITED(ClassID()), fView(view) {
89 this->setBounds(SkRect::MakeIWH(fView->width(), fView->height()), GrOp::HasAABloat::kNo,
90 GrOp::IsHairline::kNo);
91 }
92
name() const93 const char* name() const override {
94 return "[Testing/Sample code] CCPRGeometryView::DrawCoverageCountOp";
95 }
96
97 private:
fixedFunctionFlags() const98 FixedFunctionFlags fixedFunctionFlags() const override { return FixedFunctionFlags::kNone; }
finalize(const GrCaps &,const GrAppliedClip *,bool hasMixedSampledCoverage,GrClampType)99 GrProcessorSet::Analysis finalize(const GrCaps&, const GrAppliedClip*,
100 bool hasMixedSampledCoverage, GrClampType) override {
101 return GrProcessorSet::EmptySetAnalysis();
102 }
onPrePrepare(GrRecordingContext *,const GrSurfaceProxyView * writeView,GrAppliedClip *,const GrXferProcessor::DstProxyView &,GrXferBarrierFlags renderPassXferBarriers)103 void onPrePrepare(GrRecordingContext*,
104 const GrSurfaceProxyView* writeView,
105 GrAppliedClip*,
106 const GrXferProcessor::DstProxyView&,
107 GrXferBarrierFlags renderPassXferBarriers) override {}
onPrepare(GrOpFlushState *)108 void onPrepare(GrOpFlushState*) override {}
109 void onExecute(GrOpFlushState*, const SkRect& chainBounds) override;
110
111 CCPRGeometryView* fView;
112
113 using INHERITED = GrDrawOp;
114 };
115
116 class CCPRGeometryView::VisualizeCoverageCountFP : public GrFragmentProcessor {
117 public:
Make(std::unique_ptr<GrFragmentProcessor> inputFP)118 static std::unique_ptr<GrFragmentProcessor> Make(std::unique_ptr<GrFragmentProcessor> inputFP) {
119 return std::unique_ptr<GrFragmentProcessor>(
120 new VisualizeCoverageCountFP(std::move(inputFP)));
121 }
122
123 private:
name() const124 const char* name() const override {
125 return "VisualizeCoverageCountFP";
126 }
clone() const127 std::unique_ptr<GrFragmentProcessor> clone() const override {
128 return std::unique_ptr<GrFragmentProcessor>(new VisualizeCoverageCountFP(*this));
129 }
VisualizeCoverageCountFP(std::unique_ptr<GrFragmentProcessor> inputFP)130 VisualizeCoverageCountFP(std::unique_ptr<GrFragmentProcessor> inputFP)
131 : GrFragmentProcessor(kTestFP_ClassID, kNone_OptimizationFlags) {
132 this->registerChild(std::move(inputFP));
133 }
VisualizeCoverageCountFP(const VisualizeCoverageCountFP & that)134 VisualizeCoverageCountFP(const VisualizeCoverageCountFP& that)
135 : GrFragmentProcessor(kTestFP_ClassID, kNone_OptimizationFlags) {
136 this->cloneAndRegisterAllChildProcessors(that);
137 }
onGetGLSLProcessorKey(const GrShaderCaps &,GrProcessorKeyBuilder *) const138 void onGetGLSLProcessorKey(const GrShaderCaps&, GrProcessorKeyBuilder*) const override {}
onIsEqual(const GrFragmentProcessor &) const139 bool onIsEqual(const GrFragmentProcessor&) const override { return true; }
140
141 class Impl : public GrGLSLFragmentProcessor {
emitCode(EmitArgs & args)142 void emitCode(EmitArgs& args) override {
143 GrGLSLFPFragmentBuilder* f = args.fFragBuilder;
144 static constexpr int kInputFPIndex = 0;
145 SkString inputColor = this->invokeChild(kInputFPIndex, args);
146 f->codeAppendf("half count = %s.a;", inputColor.c_str());
147 f->codeAppendf("%s = half4(clamp(-count, 0, 1), clamp(+count, 0, 1), 0, abs(count));",
148 args.fOutputColor);
149 }
150 };
151
onCreateGLSLInstance() const152 GrGLSLFragmentProcessor* onCreateGLSLInstance() const override { return new Impl; }
153 };
154
onDrawContent(SkCanvas * canvas)155 void CCPRGeometryView::onDrawContent(SkCanvas* canvas) {
156 canvas->clear(SK_ColorBLACK);
157
158 SkPaint outlinePaint;
159 outlinePaint.setColor(0xff808080);
160 outlinePaint.setStyle(SkPaint::kStroke_Style);
161 if (fDoStroke) {
162 outlinePaint.setStrokeWidth(fStrokeWidth);
163 } else {
164 outlinePaint.setStrokeWidth(0);
165 }
166 outlinePaint.setStrokeJoin(fStrokeJoin);
167 outlinePaint.setStrokeCap(fStrokeCap);
168 outlinePaint.setAntiAlias(true);
169 canvas->drawPath(fPath, outlinePaint);
170
171 #if 0
172 SkPaint gridPaint;
173 gridPaint.setColor(0x10000000);
174 gridPaint.setStyle(SkPaint::kStroke_Style);
175 gridPaint.setStrokeWidth(0);
176 gridPaint.setAntiAlias(true);
177 for (int y = 0; y < this->height(); y += kDebugBloat) {
178 canvas->drawLine(0, y, this->width(), y, gridPaint);
179 }
180 for (int x = 0; x < this->width(); x += kDebugBloat) {
181 canvas->drawLine(x, 0, x, this->height(), outlinePaint);
182 }
183 #endif
184
185 SkString caption;
186 caption.appendf("PrimitiveType_%s",
187 GrCCCoverageProcessor::PrimitiveTypeName(fPrimitiveType));
188 if (PrimitiveType::kCubics == fPrimitiveType) {
189 caption.appendf(" (%s)", SkCubicTypeName(SkClassifyCubic(fPoints)));
190 } else if (PrimitiveType::kConics == fPrimitiveType) {
191 caption.appendf(" (w=%f)", fConicWeight);
192 }
193
194 if (fDoStroke) {
195 caption.appendf(" (stroke_width=%f)", fStrokeWidth);
196 } else if (GrRenderTargetContext* rtc =
197 canvas->internal_private_accessTopLayerRenderTargetContext()) {
198 // Render coverage count.
199 auto ctx = canvas->recordingContext();
200 SkASSERT(ctx);
201
202 int width = this->width();
203 int height = this->height();
204 auto ccbuff = GrRenderTargetContext::Make(
205 ctx, GrColorType::kAlpha_F16, nullptr, SkBackingFit::kApprox, {width, height});
206 SkASSERT(ccbuff);
207 ccbuff->clear(SK_PMColor4fTRANSPARENT);
208 ccbuff->priv().testingOnly_addDrawOp(GrOp::Make<DrawCoverageCountOp>(ctx, this));
209
210 // Visualize coverage count in main canvas.
211 GrPaint paint;
212 paint.setColorFragmentProcessor(VisualizeCoverageCountFP::Make(
213 GrTextureEffect::Make(ccbuff->readSurfaceView(), ccbuff->colorInfo().alphaType())));
214 paint.setPorterDuffXPFactory(SkBlendMode::kSrcOver);
215 rtc->drawRect(nullptr, std::move(paint), GrAA::kNo, SkMatrix::I(),
216 SkRect::MakeIWH(this->width(), this->height()));
217 } else {
218 caption = "Use GPU backend to visualize geometry.";
219 }
220
221 SkPaint pointsPaint;
222 pointsPaint.setColor(SK_ColorBLUE);
223 pointsPaint.setStrokeWidth(8);
224 pointsPaint.setAntiAlias(true);
225
226 if (PrimitiveType::kCubics == fPrimitiveType) {
227 canvas->drawPoints(SkCanvas::kPoints_PointMode, 4, fPoints, pointsPaint);
228 } else {
229 canvas->drawPoints(SkCanvas::kPoints_PointMode, 2, fPoints, pointsPaint);
230 canvas->drawPoints(SkCanvas::kPoints_PointMode, 1, fPoints + 3, pointsPaint);
231 }
232
233 SkFont font(nullptr, 20);
234 SkPaint captionPaint;
235 captionPaint.setColor(SK_ColorWHITE);
236 canvas->drawString(caption, 10, 30, font, captionPaint);
237 }
238
updateGpuData()239 void CCPRGeometryView::updateGpuData() {
240 using Verb = GrCCFillGeometry::Verb;
241 fTriPointInstances.reset();
242 fQuadPointInstances.reset();
243
244 fPath.reset();
245 fPath.moveTo(fPoints[0]);
246
247 if (PrimitiveType::kCubics == fPrimitiveType) {
248 GrCCFillGeometry geometry;
249 geometry.beginContour(fPoints[0]);
250 geometry.cubicTo(fPoints, kDebugBloat / 2, kDebugBloat / 2);
251 geometry.endContour();
252 int ptsIdx = 0;
253 for (Verb verb : geometry.verbs()) {
254 switch (verb) {
255 case Verb::kLineTo:
256 ++ptsIdx;
257 continue;
258 case Verb::kMonotonicQuadraticTo:
259 ptsIdx += 2;
260 continue;
261 case Verb::kMonotonicCubicTo:
262 fQuadPointInstances.push_back().set(&geometry.points()[ptsIdx], 0, 0);
263 ptsIdx += 3;
264 continue;
265 default:
266 continue;
267 }
268 }
269 fPath.cubicTo(fPoints[1], fPoints[2], fPoints[3]);
270 } else if (PrimitiveType::kTriangles != fPrimitiveType) {
271 SkPoint P3[3] = {fPoints[0], fPoints[1], fPoints[3]};
272 GrCCFillGeometry geometry;
273 geometry.beginContour(P3[0]);
274 if (PrimitiveType::kQuadratics == fPrimitiveType) {
275 geometry.quadraticTo(P3);
276 fPath.quadTo(fPoints[1], fPoints[3]);
277 } else {
278 SkASSERT(PrimitiveType::kConics == fPrimitiveType);
279 geometry.conicTo(P3, fConicWeight);
280 fPath.conicTo(fPoints[1], fPoints[3], fConicWeight);
281 }
282 geometry.endContour();
283 int ptsIdx = 0, conicWeightIdx = 0;
284 for (Verb verb : geometry.verbs()) {
285 if (Verb::kBeginContour == verb ||
286 Verb::kEndOpenContour == verb ||
287 Verb::kEndClosedContour == verb) {
288 continue;
289 }
290 if (Verb::kLineTo == verb) {
291 ++ptsIdx;
292 continue;
293 }
294 SkASSERT(Verb::kMonotonicQuadraticTo == verb || Verb::kMonotonicConicTo == verb);
295 if (PrimitiveType::kQuadratics == fPrimitiveType &&
296 Verb::kMonotonicQuadraticTo == verb) {
297 fTriPointInstances.push_back().set(
298 &geometry.points()[ptsIdx], Sk2f(0, 0),
299 TriPointInstance::Ordering::kXYTransposed);
300 } else if (PrimitiveType::kConics == fPrimitiveType &&
301 Verb::kMonotonicConicTo == verb) {
302 fQuadPointInstances.push_back().setW(&geometry.points()[ptsIdx], Sk2f(0, 0),
303 geometry.getConicWeight(conicWeightIdx++));
304 }
305 ptsIdx += 2;
306 }
307 } else {
308 fTriPointInstances.push_back().set(
309 fPoints[0], fPoints[1], fPoints[3], Sk2f(0, 0),
310 TriPointInstance::Ordering::kXYTransposed);
311 fPath.lineTo(fPoints[1]);
312 fPath.lineTo(fPoints[3]);
313 fPath.close();
314 }
315 }
316
onExecute(GrOpFlushState * state,const SkRect & chainBounds)317 void CCPRGeometryView::DrawCoverageCountOp::onExecute(GrOpFlushState* state,
318 const SkRect& chainBounds) {
319 GrResourceProvider* rp = state->resourceProvider();
320 #ifdef SK_GL
321 auto direct = state->gpu()->getContext();
322 GrGLGpu* glGpu = GrBackendApi::kOpenGL == direct->backend()
323 ? static_cast<GrGLGpu*>(state->gpu())
324 : nullptr;
325 if (glGpu) {
326 glGpu->handleDirtyContext();
327 // GR_GL_CALL(glGpu->glInterface(), PolygonMode(GR_GL_FRONT_AND_BACK, GR_GL_LINE));
328 GR_GL_CALL(glGpu->glInterface(), Enable(GR_GL_LINE_SMOOTH));
329 }
330 #endif
331
332 GrPipeline pipeline(GrScissorTest::kDisabled, SkBlendMode::kPlus,
333 state->drawOpArgs().writeSwizzle());
334
335 std::unique_ptr<GrCCCoverageProcessor> proc;
336 if (state->caps().shaderCaps()->geometryShaderSupport()) {
337 proc = std::make_unique<GrGSCoverageProcessor>();
338 } else {
339 proc = std::make_unique<GrVSCoverageProcessor>();
340 }
341 SkDEBUGCODE(proc->enableDebugBloat(kDebugBloat));
342
343 GrOpsRenderPass* renderPass = state->opsRenderPass();
344
345 for (int i = 0; i < proc->numSubpasses(); ++i) {
346 proc->reset(fView->fPrimitiveType, i, rp);
347 proc->bindPipeline(state, pipeline, this->bounds());
348
349 if (PrimitiveType::kCubics == fView->fPrimitiveType ||
350 PrimitiveType::kConics == fView->fPrimitiveType) {
351 sk_sp<GrGpuBuffer> instBuff(rp->createBuffer(
352 fView->fQuadPointInstances.count() * sizeof(QuadPointInstance),
353 GrGpuBufferType::kVertex, kDynamic_GrAccessPattern,
354 fView->fQuadPointInstances.begin()));
355 if (!fView->fQuadPointInstances.empty() && instBuff) {
356 proc->bindBuffers(renderPass, std::move(instBuff));
357 proc->drawInstances(renderPass, fView->fQuadPointInstances.count(), 0);
358 }
359 } else {
360 sk_sp<GrGpuBuffer> instBuff(rp->createBuffer(
361 fView->fTriPointInstances.count() * sizeof(TriPointInstance),
362 GrGpuBufferType::kVertex, kDynamic_GrAccessPattern,
363 fView->fTriPointInstances.begin()));
364 if (!fView->fTriPointInstances.empty() && instBuff) {
365 proc->bindBuffers(renderPass, std::move(instBuff));
366 proc->drawInstances(renderPass, fView->fTriPointInstances.count(), 0);
367 }
368 }
369 }
370
371 #ifdef SK_GL
372 if (glGpu) {
373 direct->resetContext(kMisc_GrGLBackendState);
374 }
375 #endif
376 }
377
378 class CCPRGeometryView::Click : public Sample::Click {
379 public:
Click(int ptIdx)380 Click(int ptIdx) : fPtIdx(ptIdx) {}
381
doClick(SkPoint points[])382 void doClick(SkPoint points[]) {
383 if (fPtIdx >= 0) {
384 points[fPtIdx] += fCurr - fPrev;
385 } else {
386 for (int i = 0; i < 4; ++i) {
387 points[i] += fCurr - fPrev;
388 }
389 }
390 }
391
392 private:
393 int fPtIdx;
394 };
395
onFindClickHandler(SkScalar x,SkScalar y,skui::ModifierKey)396 Sample::Click* CCPRGeometryView::onFindClickHandler(SkScalar x, SkScalar y, skui::ModifierKey) {
397 for (int i = 0; i < 4; ++i) {
398 if (PrimitiveType::kCubics != fPrimitiveType && 2 == i) {
399 continue;
400 }
401 if (fabs(x - fPoints[i].x()) < 20 && fabsf(y - fPoints[i].y()) < 20) {
402 return new Click(i);
403 }
404 }
405 return new Click(-1);
406 }
407
onClick(Sample::Click * click)408 bool CCPRGeometryView::onClick(Sample::Click* click) {
409 Click* myClick = (Click*)click;
410 myClick->doClick(fPoints);
411 this->updateAndInval();
412 return true;
413 }
414
onChar(SkUnichar unichar)415 bool CCPRGeometryView::onChar(SkUnichar unichar) {
416 if (unichar >= '1' && unichar <= '4') {
417 fPrimitiveType = PrimitiveType(unichar - '1');
418 if (fPrimitiveType >= PrimitiveType::kWeightedTriangles) {
419 fPrimitiveType = (PrimitiveType) ((int)fPrimitiveType + 1);
420 }
421 this->updateAndInval();
422 return true;
423 }
424 float* valueToScale = nullptr;
425 if (fDoStroke) {
426 valueToScale = &fStrokeWidth;
427 } else if (PrimitiveType::kConics == fPrimitiveType) {
428 valueToScale = &fConicWeight;
429 }
430 if (valueToScale) {
431 if (unichar == '+') {
432 *valueToScale *= 2;
433 this->updateAndInval();
434 return true;
435 }
436 if (unichar == '+' || unichar == '=') {
437 *valueToScale *= 5/4.f;
438 this->updateAndInval();
439 return true;
440 }
441 if (unichar == '-') {
442 *valueToScale *= 4/5.f;
443 this->updateAndInval();
444 return true;
445 }
446 if (unichar == '_') {
447 *valueToScale *= .5f;
448 this->updateAndInval();
449 return true;
450 }
451 }
452 if (unichar == 'D') {
453 SkDebugf(" SkPoint fPoints[4] = {\n");
454 SkDebugf(" {%ff, %ff},\n", fPoints[0].x(), fPoints[0].y());
455 SkDebugf(" {%ff, %ff},\n", fPoints[1].x(), fPoints[1].y());
456 SkDebugf(" {%ff, %ff},\n", fPoints[2].x(), fPoints[2].y());
457 SkDebugf(" {%ff, %ff}\n", fPoints[3].x(), fPoints[3].y());
458 SkDebugf(" };\n");
459 return true;
460 }
461 if (unichar == 'S') {
462 fDoStroke = !fDoStroke;
463 this->updateAndInval();
464 return true;
465 }
466 if (unichar == 'J') {
467 fStrokeJoin = (SkPaint::Join)((fStrokeJoin + 1) % 3);
468 this->updateAndInval();
469 return true;
470 }
471 if (unichar == 'C') {
472 fStrokeCap = (SkPaint::Cap)((fStrokeCap + 1) % 3);
473 this->updateAndInval();
474 return true;
475 }
476 return false;
477 }
478
479 DEF_SAMPLE(return new CCPRGeometryView;)
480
481 #endif // SK_SUPPORT_GPU
482