samplecode/SampleCCPRGeometry.cpp - platform/external/skia - Gitiles

 /*
  * Copyright 2017 Google Inc.
  *
  * Use of this source code is governed by a BSD-style license that can be
  * found in the LICENSE file.
  */

 #include "SkTypes.h"

 #if SK_SUPPORT_GPU

 #include "GrContextPriv.h"
 #include "GrPathUtils.h"
 #include "GrRenderTargetContext.h"
 #include "GrRenderTargetContextPriv.h"
 #include "GrResourceProvider.h"
 #include "SampleCode.h"
 #include "SkCanvas.h"
 #include "SkMakeUnique.h"
 #include "SkPaint.h"
 #include "SkPath.h"
 #include "SkView.h"
 #include "ccpr/GrCCPRCoverageProcessor.h"
 #include "ccpr/GrCCPRGeometry.h"
 #include "gl/GrGLGpu.cpp"
 #include "ops/GrDrawOp.h"

 using TriangleInstance = GrCCPRCoverageProcessor::TriangleInstance;
 using CubicInstance = GrCCPRCoverageProcessor::CubicInstance;
 using RenderPass = GrCCPRCoverageProcessor::RenderPass;

 static constexpr float kDebugBloat = 40;

 static int is_quadratic(RenderPass renderPass)  {
     return renderPass >= RenderPass::kQuadraticHulls && renderPass < RenderPass::kSerpentineHulls;
 }

 /**
  * This sample visualizes the AA bloat geometry generated by the ccpr geometry shaders. It
  * increases the AA bloat by 50x and outputs color instead of coverage (coverage=+1 -> green,
  * coverage=0 -> black, coverage=-1 -> red). Use the keys 1-7 to cycle through the different
  * geometry processors.
  */
 class CCPRGeometryView : public SampleView {
 public:
     CCPRGeometryView() { this->updateGpuData(); }
     void onDrawContent(SkCanvas*) override;

     SkView::Click* onFindClickHandler(SkScalar x, SkScalar y, unsigned) override;
     bool onClick(SampleView::Click*) override;
     bool onQuery(SkEvent* evt) override;

 private:
     class Click;
     class Op;

     void updateAndInval() {
         this->updateGpuData();
     }

     void updateGpuData();

     RenderPass fRenderPass = RenderPass::kTriangleHulls;
     SkMatrix fCubicKLM;

     SkPoint fPoints[4] = {
         {100.05f, 100.05f},
         {400.75f, 100.05f},
         {400.75f, 300.95f},
         {100.05f, 300.95f}
     };

     SkTArray<TriangleInstance> fTriangleInstances;
     SkTArray<CubicInstance> fCubicInstances;

     typedef SampleView INHERITED;
 };

 class CCPRGeometryView::Op : public GrDrawOp {
     DEFINE_OP_CLASS_ID

 public:
     Op(CCPRGeometryView* view)
             : INHERITED(ClassID())
             , fView(view) {
         this->setBounds(SkRect::MakeLargest(), GrOp::HasAABloat::kNo, GrOp::IsZeroArea::kNo);
     }

     const char* name() const override { return "[Testing/Sample code] CCPRGeometryView::Op"; }

 private:
     FixedFunctionFlags fixedFunctionFlags() const override { return FixedFunctionFlags::kNone; }
     RequiresDstTexture finalize(const GrCaps&, const GrAppliedClip*,
                                 GrPixelConfigIsClamped) override {
         return RequiresDstTexture::kNo;
     }
     bool onCombineIfPossible(GrOp* other, const GrCaps& caps) override { return false; }
     void onPrepare(GrOpFlushState*) override {}
     void onExecute(GrOpFlushState*) override;

     CCPRGeometryView* fView;

     typedef GrDrawOp INHERITED;
 };

 static void draw_klm_line(int w, int h, SkCanvas* canvas, const SkScalar line[3], SkColor color) {
     SkPoint p1, p2;
     if (SkScalarAbs(line[1]) > SkScalarAbs(line[0])) {
         // Draw from vertical edge to vertical edge.
         p1 = {0, -line[2] / line[1]};
         p2 = {(SkScalar) w, (-line[2] - w * line[0]) / line[1]};
     } else {
         // Draw from horizontal edge to horizontal edge.
         p1 = {-line[2] / line[0], 0};
         p2 = {(-line[2] - h * line[1]) / line[0], (SkScalar) h};
     }

     SkPaint linePaint;
     linePaint.setColor(color);
     linePaint.setAlpha(128);
     linePaint.setStyle(SkPaint::kStroke_Style);
     linePaint.setStrokeWidth(0);
     linePaint.setAntiAlias(true);
     canvas->drawLine(p1, p2, linePaint);
 }

 void CCPRGeometryView::onDrawContent(SkCanvas* canvas) {
     SkAutoCanvasRestore acr(canvas, true);
     canvas->setMatrix(SkMatrix::I());

     SkPath outline;
     outline.moveTo(fPoints[0]);
     if (GrCCPRCoverageProcessor::RenderPassIsCubic(fRenderPass)) {
         outline.cubicTo(fPoints[1], fPoints[2], fPoints[3]);
     } else if (is_quadratic(fRenderPass)) {
         outline.quadTo(fPoints[1], fPoints[3]);
     } else {
         outline.lineTo(fPoints[1]);
         outline.lineTo(fPoints[3]);
         outline.close();
     }

     SkPaint outlinePaint;
     outlinePaint.setColor(0x30000000);
     outlinePaint.setStyle(SkPaint::kStroke_Style);
     outlinePaint.setStrokeWidth(0);
     outlinePaint.setAntiAlias(true);
     canvas->drawPath(outline, outlinePaint);

 #if 0
     SkPaint gridPaint;
     gridPaint.setColor(0x10000000);
     gridPaint.setStyle(SkPaint::kStroke_Style);
     gridPaint.setStrokeWidth(0);
     gridPaint.setAntiAlias(true);
     for (int y = 0; y < this->height(); y += kDebugBloat) {
         canvas->drawLine(0, y, this->width(), y, gridPaint);
     }
     for (int x = 0; x < this->width(); x += kDebugBloat) {
         canvas->drawLine(x, 0, x, this->height(), outlinePaint);
     }
 #endif

     const char* caption = "Use GPU backend to visualize geometry.";

     if (GrRenderTargetContext* rtc =
         canvas->internal_private_accessTopLayerRenderTargetContext()) {
         rtc->priv().testingOnly_addDrawOp(skstd::make_unique<Op>(this));
         caption = GrCCPRCoverageProcessor::GetRenderPassName(fRenderPass);
     }

     SkPaint pointsPaint;
     pointsPaint.setColor(SK_ColorBLUE);
     pointsPaint.setStrokeWidth(8);
     pointsPaint.setAntiAlias(true);

     if (GrCCPRCoverageProcessor::RenderPassIsCubic(fRenderPass)) {
         int w = this->width(), h = this->height();
         canvas->drawPoints(SkCanvas::kPoints_PointMode, 4, fPoints, pointsPaint);
         draw_klm_line(w, h, canvas, &fCubicKLM[0], SK_ColorYELLOW);
         draw_klm_line(w, h, canvas, &fCubicKLM[3], SK_ColorBLUE);
         draw_klm_line(w, h, canvas, &fCubicKLM[6], SK_ColorRED);
     } else {
         canvas->drawPoints(SkCanvas::kPoints_PointMode, 2, fPoints, pointsPaint);
         canvas->drawPoints(SkCanvas::kPoints_PointMode, 1, fPoints + 3, pointsPaint);
     }

     SkPaint captionPaint;
     captionPaint.setTextSize(20);
     captionPaint.setColor(SK_ColorBLACK);
     captionPaint.setAntiAlias(true);
     canvas->drawText(caption, strlen(caption), 10, 30, captionPaint);
 }

 void CCPRGeometryView::updateGpuData() {
     fTriangleInstances.reset();
     fCubicInstances.reset();

     if (GrCCPRCoverageProcessor::RenderPassIsCubic(fRenderPass)) {
         double t[2], s[2];
         SkCubicType type = GrPathUtils::getCubicKLM(fPoints, &fCubicKLM, t, s);
         if (RenderPass::kSerpentineHulls == fRenderPass && SkCubicType::kLoop == type) {
             fRenderPass = RenderPass::kLoopHulls;
         }
         if (RenderPass::kSerpentineCorners == fRenderPass && SkCubicType::kLoop == type) {
             fRenderPass = RenderPass::kLoopCorners;
         }
         if (RenderPass::kLoopHulls == fRenderPass && SkCubicType::kLoop != type) {
             fRenderPass = RenderPass::kSerpentineHulls;
         }
         if (RenderPass::kLoopCorners == fRenderPass && SkCubicType::kLoop != type) {
             fRenderPass = RenderPass::kSerpentineCorners;
         }

         GrCCPRGeometry geometry;
         geometry.beginContour(fPoints[0]);
         geometry.cubicTo(fPoints[1], fPoints[2], fPoints[3], kDebugBloat/2, kDebugBloat/2);
         geometry.endContour();
         int ptsIdx = 0;
         for (GrCCPRGeometry::Verb verb : geometry.verbs()) {
             switch (verb) {
                 case GrCCPRGeometry::Verb::kLineTo:
                     ++ptsIdx;
                     continue;
                 case GrCCPRGeometry::Verb::kMonotonicQuadraticTo:
                     ptsIdx += 2;
                     continue;
                 case GrCCPRGeometry::Verb::kMonotonicSerpentineTo:
                 case GrCCPRGeometry::Verb::kMonotonicLoopTo:
                     fCubicInstances.push_back().set(&geometry.points()[ptsIdx], 0, 0);
                     ptsIdx += 3;
                     continue;
                 default: continue;
             }
         }
     } else if (is_quadratic(fRenderPass)) {
         GrCCPRGeometry geometry;
         geometry.beginContour(fPoints[0]);
         geometry.quadraticTo(fPoints[1], fPoints[3]);
         geometry.endContour();
         int ptsIdx = 0;
         for (GrCCPRGeometry::Verb verb : geometry.verbs()) {
             if (GrCCPRGeometry::Verb::kBeginContour == verb ||
                 GrCCPRGeometry::Verb::kEndOpenContour == verb ||
                 GrCCPRGeometry::Verb::kEndClosedContour == verb) {
                 continue;
             }
             SkASSERT(GrCCPRGeometry::Verb::kMonotonicQuadraticTo == verb);
             fTriangleInstances.push_back().set(&geometry.points()[ptsIdx], Sk2f(0, 0));
             ptsIdx += 2;
         }
     } else {
         fTriangleInstances.push_back().set(fPoints[0], fPoints[1], fPoints[3], Sk2f(0, 0));
     }
 }

 void CCPRGeometryView::Op::onExecute(GrOpFlushState* state) {
     GrResourceProvider* rp = state->resourceProvider();
     GrContext* context = state->gpu()->getContext();
     GrGLGpu* glGpu = kOpenGL_GrBackend == context->contextPriv().getBackend() ?
                      static_cast<GrGLGpu*>(state->gpu()) : nullptr;

     bool isCubic = GrCCPRCoverageProcessor::RenderPassIsCubic(fView->fRenderPass);
     GrMesh mesh(isCubic ?  GrPrimitiveType::kLinesAdjacency : GrPrimitiveType::kTriangles);
     if (isCubic) {
         if (fView->fCubicInstances.empty()) {
             return;
         }
         sk_sp<GrBuffer> instBuff(rp->createBuffer(fView->fCubicInstances.count() *
                                                   sizeof(CubicInstance), kVertex_GrBufferType,
                                                   kDynamic_GrAccessPattern,
                                                   GrResourceProvider::kNoPendingIO_Flag |
                                                   GrResourceProvider::kRequireGpuMemory_Flag,
                                                   fView->fCubicInstances.begin()));
         if (!instBuff) {
             return;
         }
         mesh.setInstanced(instBuff.get(), fView->fCubicInstances.count(), 0, 4);
     } else {
         if (fView->fTriangleInstances.empty()) {
             return;
         }
         sk_sp<GrBuffer> instBuff(rp->createBuffer(fView->fTriangleInstances.count() *
                                                   sizeof(TriangleInstance), kVertex_GrBufferType,
                                                   kDynamic_GrAccessPattern,
                                                   GrResourceProvider::kNoPendingIO_Flag |
                                                   GrResourceProvider::kRequireGpuMemory_Flag,
                                                   fView->fTriangleInstances.begin()));
         if (!instBuff) {
             return;
         }
         mesh.setInstanced(instBuff.get(), fView->fTriangleInstances.count(), 0, 3);
     }

     GrPipeline pipeline(state->drawOpArgs().fProxy, GrPipeline::ScissorState::kDisabled,
                         SkBlendMode::kSrcOver);

     GrCCPRCoverageProcessor ccprProc(fView->fRenderPass);
     SkDEBUGCODE(ccprProc.enableDebugVisualizations(kDebugBloat);)

     if (glGpu) {
         glGpu->handleDirtyContext();
         GR_GL_CALL(glGpu->glInterface(), PolygonMode(GR_GL_FRONT_AND_BACK, GR_GL_LINE));
         GR_GL_CALL(glGpu->glInterface(), Enable(GR_GL_LINE_SMOOTH));
     }

     state->rtCommandBuffer()->draw(pipeline, ccprProc, &mesh, nullptr, 1, this->bounds());

     if (glGpu) {
         context->resetContext(kMisc_GrGLBackendState);
     }
 }

 class CCPRGeometryView::Click : public SampleView::Click {
 public:
     Click(SkView* target, int ptIdx) : SampleView::Click(target), fPtIdx(ptIdx) {}

     void doClick(SkPoint points[]) {
         if (fPtIdx >= 0) {
             this->dragPoint(points, fPtIdx);
         } else {
             for (int i = 0; i < 4; ++i) {
                 this->dragPoint(points, i);
             }
         }
     }

 private:
     void dragPoint(SkPoint points[], int idx)  {
         SkIPoint delta = fICurr - fIPrev;
         points[idx] += SkPoint::Make(delta.x(), delta.y());
     }

     int fPtIdx;
 };

 SkView::Click* CCPRGeometryView::onFindClickHandler(SkScalar x, SkScalar y, unsigned) {
     for (int i = 0; i < 4; ++i) {
         if (!GrCCPRCoverageProcessor::RenderPassIsCubic(fRenderPass) && 2 == i) {
             continue;
         }
         if (fabs(x - fPoints[i].x()) < 20 && fabsf(y - fPoints[i].y()) < 20) {
             return new Click(this, i);
         }
     }
     return new Click(this, -1);
 }

 bool CCPRGeometryView::onClick(SampleView::Click* click) {
     Click* myClick = (Click*) click;
     myClick->doClick(fPoints);
     this->updateAndInval();
     return true;
 }

 bool CCPRGeometryView::onQuery(SkEvent* evt) {
     if (SampleCode::TitleQ(*evt)) {
         SampleCode::TitleR(evt, "CCPRGeometry");
         return true;
     }
     SkUnichar unichar;
     if (SampleCode::CharQ(*evt, &unichar)) {
         if (unichar >= '1' && unichar <= '7') {
             fRenderPass = RenderPass(unichar - '1');
             if (fRenderPass >= RenderPass::kLoopHulls) {
                 // '6' -> kSerpentineHulls, '7' -> kSerpentineCorners. updateGpuData converts to
                 // kLoop* if needed.
                 fRenderPass = RenderPass(int(fRenderPass) + 1);
             }
             this->updateAndInval();
             return true;
         }
         if (unichar == 'D') {
             SkDebugf("    SkPoint fPoints[4] = {\n");
             SkDebugf("        {%ff, %ff},\n", fPoints[0].x(), fPoints[0].y());
             SkDebugf("        {%ff, %ff},\n", fPoints[1].x(), fPoints[1].y());
             SkDebugf("        {%ff, %ff},\n", fPoints[2].x(), fPoints[2].y());
             SkDebugf("        {%ff, %ff}\n", fPoints[3].x(), fPoints[3].y());
             SkDebugf("    };\n");
             return true;
         }
     }
     return this->INHERITED::onQuery(evt);
 }

 DEF_SAMPLE( return new CCPRGeometryView; )

 #endif // SK_SUPPORT_GPU
	/*
	* Copyright 2017 Google Inc.
	*
	* Use of this source code is governed by a BSD-style license that can be
	* found in the LICENSE file.
	*/

	#include "SkTypes.h"

	#if SK_SUPPORT_GPU

	#include "GrContextPriv.h"
	#include "GrPathUtils.h"
	#include "GrRenderTargetContext.h"
	#include "GrRenderTargetContextPriv.h"
	#include "GrResourceProvider.h"
	#include "SampleCode.h"
	#include "SkCanvas.h"
	#include "SkMakeUnique.h"
	#include "SkPaint.h"
	#include "SkPath.h"
	#include "SkView.h"
	#include "ccpr/GrCCPRCoverageProcessor.h"
	#include "ccpr/GrCCPRGeometry.h"
	#include "gl/GrGLGpu.cpp"
	#include "ops/GrDrawOp.h"

	using TriangleInstance = GrCCPRCoverageProcessor::TriangleInstance;
	using CubicInstance = GrCCPRCoverageProcessor::CubicInstance;
	using RenderPass = GrCCPRCoverageProcessor::RenderPass;

	static constexpr float kDebugBloat = 40;

	static int is_quadratic(RenderPass renderPass) {
	return renderPass >= RenderPass::kQuadraticHulls && renderPass < RenderPass::kSerpentineHulls;
	}

	/**
	* This sample visualizes the AA bloat geometry generated by the ccpr geometry shaders. It
	* increases the AA bloat by 50x and outputs color instead of coverage (coverage=+1 -> green,
	* coverage=0 -> black, coverage=-1 -> red). Use the keys 1-7 to cycle through the different
	* geometry processors.
	*/
	class CCPRGeometryView : public SampleView {
	public:
	CCPRGeometryView() { this->updateGpuData(); }
	void onDrawContent(SkCanvas*) override;

	SkView::Click* onFindClickHandler(SkScalar x, SkScalar y, unsigned) override;
	bool onClick(SampleView::Click*) override;
	bool onQuery(SkEvent* evt) override;

	private:
	class Click;
	class Op;

	void updateAndInval() {
	this->updateGpuData();
	}

	void updateGpuData();

	RenderPass fRenderPass = RenderPass::kTriangleHulls;
	SkMatrix fCubicKLM;

	SkPoint fPoints[4] = {
	{100.05f, 100.05f},
	{400.75f, 100.05f},
	{400.75f, 300.95f},
	{100.05f, 300.95f}
	};

	SkTArray<TriangleInstance> fTriangleInstances;
	SkTArray<CubicInstance> fCubicInstances;

	typedef SampleView INHERITED;
	};

	class CCPRGeometryView::Op : public GrDrawOp {
	DEFINE_OP_CLASS_ID

	public:
	Op(CCPRGeometryView* view)
	: INHERITED(ClassID())
	, fView(view) {
	this->setBounds(SkRect::MakeLargest(), GrOp::HasAABloat::kNo, GrOp::IsZeroArea::kNo);
	}

	const char* name() const override { return "[Testing/Sample code] CCPRGeometryView::Op"; }

	private:
	FixedFunctionFlags fixedFunctionFlags() const override { return FixedFunctionFlags::kNone; }
	RequiresDstTexture finalize(const GrCaps&, const GrAppliedClip*,
	GrPixelConfigIsClamped) override {
	return RequiresDstTexture::kNo;
	}
	bool onCombineIfPossible(GrOp* other, const GrCaps& caps) override { return false; }
	void onPrepare(GrOpFlushState*) override {}
	void onExecute(GrOpFlushState*) override;

	CCPRGeometryView* fView;

	typedef GrDrawOp INHERITED;
	};

	static void draw_klm_line(int w, int h, SkCanvas* canvas, const SkScalar line[3], SkColor color) {
	SkPoint p1, p2;
	if (SkScalarAbs(line[1]) > SkScalarAbs(line[0])) {
	// Draw from vertical edge to vertical edge.
	p1 = {0, -line[2] / line[1]};
	p2 = {(SkScalar) w, (-line[2] - w * line[0]) / line[1]};
	} else {
	// Draw from horizontal edge to horizontal edge.
	p1 = {-line[2] / line[0], 0};
	p2 = {(-line[2] - h * line[1]) / line[0], (SkScalar) h};
	}

	SkPaint linePaint;
	linePaint.setColor(color);
	linePaint.setAlpha(128);
	linePaint.setStyle(SkPaint::kStroke_Style);
	linePaint.setStrokeWidth(0);
	linePaint.setAntiAlias(true);
	canvas->drawLine(p1, p2, linePaint);
	}

	void CCPRGeometryView::onDrawContent(SkCanvas* canvas) {
	SkAutoCanvasRestore acr(canvas, true);
	canvas->setMatrix(SkMatrix::I());

	SkPath outline;
	outline.moveTo(fPoints[0]);
	if (GrCCPRCoverageProcessor::RenderPassIsCubic(fRenderPass)) {
	outline.cubicTo(fPoints[1], fPoints[2], fPoints[3]);
	} else if (is_quadratic(fRenderPass)) {
	outline.quadTo(fPoints[1], fPoints[3]);
	} else {
	outline.lineTo(fPoints[1]);
	outline.lineTo(fPoints[3]);
	outline.close();
	}

	SkPaint outlinePaint;
	outlinePaint.setColor(0x30000000);
	outlinePaint.setStyle(SkPaint::kStroke_Style);
	outlinePaint.setStrokeWidth(0);
	outlinePaint.setAntiAlias(true);
	canvas->drawPath(outline, outlinePaint);

	#if 0
	SkPaint gridPaint;
	gridPaint.setColor(0x10000000);
	gridPaint.setStyle(SkPaint::kStroke_Style);
	gridPaint.setStrokeWidth(0);
	gridPaint.setAntiAlias(true);
	for (int y = 0; y < this->height(); y += kDebugBloat) {
	canvas->drawLine(0, y, this->width(), y, gridPaint);
	}
	for (int x = 0; x < this->width(); x += kDebugBloat) {
	canvas->drawLine(x, 0, x, this->height(), outlinePaint);
	}
	#endif

	const char* caption = "Use GPU backend to visualize geometry.";

	if (GrRenderTargetContext* rtc =
	canvas->internal_private_accessTopLayerRenderTargetContext()) {
	rtc->priv().testingOnly_addDrawOp(skstd::make_unique<Op>(this));
	caption = GrCCPRCoverageProcessor::GetRenderPassName(fRenderPass);
	}

	SkPaint pointsPaint;
	pointsPaint.setColor(SK_ColorBLUE);
	pointsPaint.setStrokeWidth(8);
	pointsPaint.setAntiAlias(true);

	if (GrCCPRCoverageProcessor::RenderPassIsCubic(fRenderPass)) {
	int w = this->width(), h = this->height();
	canvas->drawPoints(SkCanvas::kPoints_PointMode, 4, fPoints, pointsPaint);
	draw_klm_line(w, h, canvas, &fCubicKLM[0], SK_ColorYELLOW);
	draw_klm_line(w, h, canvas, &fCubicKLM[3], SK_ColorBLUE);
	draw_klm_line(w, h, canvas, &fCubicKLM[6], SK_ColorRED);
	} else {
	canvas->drawPoints(SkCanvas::kPoints_PointMode, 2, fPoints, pointsPaint);
	canvas->drawPoints(SkCanvas::kPoints_PointMode, 1, fPoints + 3, pointsPaint);
	}

	SkPaint captionPaint;
	captionPaint.setTextSize(20);
	captionPaint.setColor(SK_ColorBLACK);
	captionPaint.setAntiAlias(true);
	canvas->drawText(caption, strlen(caption), 10, 30, captionPaint);
	}

	void CCPRGeometryView::updateGpuData() {
	fTriangleInstances.reset();
	fCubicInstances.reset();

	if (GrCCPRCoverageProcessor::RenderPassIsCubic(fRenderPass)) {
	double t[2], s[2];
	SkCubicType type = GrPathUtils::getCubicKLM(fPoints, &fCubicKLM, t, s);
	if (RenderPass::kSerpentineHulls == fRenderPass && SkCubicType::kLoop == type) {
	fRenderPass = RenderPass::kLoopHulls;
	}
	if (RenderPass::kSerpentineCorners == fRenderPass && SkCubicType::kLoop == type) {
	fRenderPass = RenderPass::kLoopCorners;
	}
	if (RenderPass::kLoopHulls == fRenderPass && SkCubicType::kLoop != type) {
	fRenderPass = RenderPass::kSerpentineHulls;
	}
	if (RenderPass::kLoopCorners == fRenderPass && SkCubicType::kLoop != type) {
	fRenderPass = RenderPass::kSerpentineCorners;
	}

	GrCCPRGeometry geometry;
	geometry.beginContour(fPoints[0]);
	geometry.cubicTo(fPoints[1], fPoints[2], fPoints[3], kDebugBloat/2, kDebugBloat/2);
	geometry.endContour();
	int ptsIdx = 0;
	for (GrCCPRGeometry::Verb verb : geometry.verbs()) {
	switch (verb) {
	case GrCCPRGeometry::Verb::kLineTo:
	++ptsIdx;
	continue;
	case GrCCPRGeometry::Verb::kMonotonicQuadraticTo:
	ptsIdx += 2;
	continue;
	case GrCCPRGeometry::Verb::kMonotonicSerpentineTo:
	case GrCCPRGeometry::Verb::kMonotonicLoopTo:
	fCubicInstances.push_back().set(&geometry.points()[ptsIdx], 0, 0);
	ptsIdx += 3;
	continue;
	default: continue;
	}
	}
	} else if (is_quadratic(fRenderPass)) {
	GrCCPRGeometry geometry;
	geometry.beginContour(fPoints[0]);
	geometry.quadraticTo(fPoints[1], fPoints[3]);
	geometry.endContour();
	int ptsIdx = 0;
	for (GrCCPRGeometry::Verb verb : geometry.verbs()) {
	if (GrCCPRGeometry::Verb::kBeginContour == verb \|\|
	GrCCPRGeometry::Verb::kEndOpenContour == verb \|\|
	GrCCPRGeometry::Verb::kEndClosedContour == verb) {
	continue;
	}
	SkASSERT(GrCCPRGeometry::Verb::kMonotonicQuadraticTo == verb);
	fTriangleInstances.push_back().set(&geometry.points()[ptsIdx], Sk2f(0, 0));
	ptsIdx += 2;
	}
	} else {
	fTriangleInstances.push_back().set(fPoints[0], fPoints[1], fPoints[3], Sk2f(0, 0));
	}
	}

	void CCPRGeometryView::Op::onExecute(GrOpFlushState* state) {
	GrResourceProvider* rp = state->resourceProvider();
	GrContext* context = state->gpu()->getContext();
	GrGLGpu* glGpu = kOpenGL_GrBackend == context->contextPriv().getBackend() ?
	static_cast<GrGLGpu*>(state->gpu()) : nullptr;

	bool isCubic = GrCCPRCoverageProcessor::RenderPassIsCubic(fView->fRenderPass);
	GrMesh mesh(isCubic ? GrPrimitiveType::kLinesAdjacency : GrPrimitiveType::kTriangles);
	if (isCubic) {
	if (fView->fCubicInstances.empty()) {
	return;
	}
	sk_sp<GrBuffer> instBuff(rp->createBuffer(fView->fCubicInstances.count() *
	sizeof(CubicInstance), kVertex_GrBufferType,
	kDynamic_GrAccessPattern,
	GrResourceProvider::kNoPendingIO_Flag \|
	GrResourceProvider::kRequireGpuMemory_Flag,
	fView->fCubicInstances.begin()));
	if (!instBuff) {
	return;
	}
	mesh.setInstanced(instBuff.get(), fView->fCubicInstances.count(), 0, 4);
	} else {
	if (fView->fTriangleInstances.empty()) {
	return;
	}
	sk_sp<GrBuffer> instBuff(rp->createBuffer(fView->fTriangleInstances.count() *
	sizeof(TriangleInstance), kVertex_GrBufferType,
	kDynamic_GrAccessPattern,
	GrResourceProvider::kNoPendingIO_Flag \|
	GrResourceProvider::kRequireGpuMemory_Flag,
	fView->fTriangleInstances.begin()));
	if (!instBuff) {
	return;
	}
	mesh.setInstanced(instBuff.get(), fView->fTriangleInstances.count(), 0, 3);
	}

	GrPipeline pipeline(state->drawOpArgs().fProxy, GrPipeline::ScissorState::kDisabled,
	SkBlendMode::kSrcOver);

	GrCCPRCoverageProcessor ccprProc(fView->fRenderPass);
	SkDEBUGCODE(ccprProc.enableDebugVisualizations(kDebugBloat);)

	if (glGpu) {
	glGpu->handleDirtyContext();
	GR_GL_CALL(glGpu->glInterface(), PolygonMode(GR_GL_FRONT_AND_BACK, GR_GL_LINE));
	GR_GL_CALL(glGpu->glInterface(), Enable(GR_GL_LINE_SMOOTH));
	}

	state->rtCommandBuffer()->draw(pipeline, ccprProc, &mesh, nullptr, 1, this->bounds());

	if (glGpu) {
	context->resetContext(kMisc_GrGLBackendState);
	}
	}

	class CCPRGeometryView::Click : public SampleView::Click {
	public:
	Click(SkView* target, int ptIdx) : SampleView::Click(target), fPtIdx(ptIdx) {}

	void doClick(SkPoint points[]) {
	if (fPtIdx >= 0) {
	this->dragPoint(points, fPtIdx);
	} else {
	for (int i = 0; i < 4; ++i) {
	this->dragPoint(points, i);
	}
	}
	}

	private:
	void dragPoint(SkPoint points[], int idx) {
	SkIPoint delta = fICurr - fIPrev;
	points[idx] += SkPoint::Make(delta.x(), delta.y());
	}

	int fPtIdx;
	};

	SkView::Click* CCPRGeometryView::onFindClickHandler(SkScalar x, SkScalar y, unsigned) {
	for (int i = 0; i < 4; ++i) {
	if (!GrCCPRCoverageProcessor::RenderPassIsCubic(fRenderPass) && 2 == i) {
	continue;
	}
	if (fabs(x - fPoints[i].x()) < 20 && fabsf(y - fPoints[i].y()) < 20) {
	return new Click(this, i);
	}
	}
	return new Click(this, -1);
	}

	bool CCPRGeometryView::onClick(SampleView::Click* click) {
	Click* myClick = (Click*) click;
	myClick->doClick(fPoints);
	this->updateAndInval();
	return true;
	}

	bool CCPRGeometryView::onQuery(SkEvent* evt) {
	if (SampleCode::TitleQ(*evt)) {
	SampleCode::TitleR(evt, "CCPRGeometry");
	return true;
	}
	SkUnichar unichar;
	if (SampleCode::CharQ(*evt, &unichar)) {
	if (unichar >= '1' && unichar <= '7') {
	fRenderPass = RenderPass(unichar - '1');
	if (fRenderPass >= RenderPass::kLoopHulls) {
	// '6' -> kSerpentineHulls, '7' -> kSerpentineCorners. updateGpuData converts to
	// kLoop* if needed.
	fRenderPass = RenderPass(int(fRenderPass) + 1);
	}
	this->updateAndInval();
	return true;
	}
	if (unichar == 'D') {
	SkDebugf(" SkPoint fPoints[4] = {\n");
	SkDebugf(" {%ff, %ff},\n", fPoints[0].x(), fPoints[0].y());
	SkDebugf(" {%ff, %ff},\n", fPoints[1].x(), fPoints[1].y());
	SkDebugf(" {%ff, %ff},\n", fPoints[2].x(), fPoints[2].y());
	SkDebugf(" {%ff, %ff}\n", fPoints[3].x(), fPoints[3].y());
	SkDebugf(" };\n");
	return true;
	}
	}
	return this->INHERITED::onQuery(evt);
	}

	DEF_SAMPLE( return new CCPRGeometryView; )

	#endif // SK_SUPPORT_GPU