commit-bot@chromium.org | 78a1078 | 2013-08-21 19:27:48 +0000 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2013 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 | // This test only works with the GPU backend. |
| 9 | |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 10 | #include "gm/gm.h" |
Ben Wagner | 6a34f3a | 2019-05-01 10:59:30 -0400 | [diff] [blame] | 11 | #include "include/core/SkBlendMode.h" |
| 12 | #include "include/core/SkCanvas.h" |
| 13 | #include "include/core/SkMatrix.h" |
| 14 | #include "include/core/SkPaint.h" |
| 15 | #include "include/core/SkPoint.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 16 | #include "include/core/SkPoint3.h" |
Ben Wagner | 6a34f3a | 2019-05-01 10:59:30 -0400 | [diff] [blame] | 17 | #include "include/core/SkRect.h" |
| 18 | #include "include/core/SkRefCnt.h" |
| 19 | #include "include/core/SkScalar.h" |
| 20 | #include "include/core/SkSize.h" |
| 21 | #include "include/core/SkString.h" |
| 22 | #include "include/core/SkTypes.h" |
Robert Phillips | b7bfbc2 | 2020-07-01 12:55:01 -0400 | [diff] [blame] | 23 | #include "include/gpu/GrRecordingContext.h" |
Ben Wagner | 6a34f3a | 2019-05-01 10:59:30 -0400 | [diff] [blame] | 24 | #include "include/private/GrTypesPriv.h" |
| 25 | #include "include/private/SkColorData.h" |
| 26 | #include "include/utils/SkRandom.h" |
Robert Phillips | 7a0d3c3 | 2021-07-21 15:39:51 -0400 | [diff] [blame^] | 27 | #include "src/core/SkCanvasPriv.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 28 | #include "src/core/SkGeometry.h" |
| 29 | #include "src/core/SkPointPriv.h" |
Ben Wagner | 6a34f3a | 2019-05-01 10:59:30 -0400 | [diff] [blame] | 30 | #include "src/gpu/GrCaps.h" |
Adlai Holler | a069304 | 2020-10-14 11:23:11 -0400 | [diff] [blame] | 31 | #include "src/gpu/GrDirectContextPriv.h" |
Ben Wagner | 6a34f3a | 2019-05-01 10:59:30 -0400 | [diff] [blame] | 32 | #include "src/gpu/GrGeometryProcessor.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 33 | #include "src/gpu/GrMemoryPool.h" |
| 34 | #include "src/gpu/GrOpFlushState.h" |
Robert Phillips | ce97857 | 2020-02-28 11:56:44 -0500 | [diff] [blame] | 35 | #include "src/gpu/GrOpsRenderPass.h" |
Ben Wagner | 6a34f3a | 2019-05-01 10:59:30 -0400 | [diff] [blame] | 36 | #include "src/gpu/GrPaint.h" |
Ben Wagner | 6a34f3a | 2019-05-01 10:59:30 -0400 | [diff] [blame] | 37 | #include "src/gpu/GrProcessorAnalysis.h" |
| 38 | #include "src/gpu/GrProcessorSet.h" |
Robert Phillips | ce97857 | 2020-02-28 11:56:44 -0500 | [diff] [blame] | 39 | #include "src/gpu/GrProgramInfo.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 40 | #include "src/gpu/GrRecordingContextPriv.h" |
Brian Salomon | eebe735 | 2020-12-09 16:37:04 -0500 | [diff] [blame] | 41 | #include "src/gpu/GrSurfaceDrawContext.h" |
Ben Wagner | 6a34f3a | 2019-05-01 10:59:30 -0400 | [diff] [blame] | 42 | #include "src/gpu/GrUserStencilSettings.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 43 | #include "src/gpu/effects/GrBezierEffect.h" |
Ben Wagner | 6a34f3a | 2019-05-01 10:59:30 -0400 | [diff] [blame] | 44 | #include "src/gpu/effects/GrPorterDuffXferProcessor.h" |
Michael Ludwig | 663afe5 | 2019-06-03 16:46:19 -0400 | [diff] [blame] | 45 | #include "src/gpu/geometry/GrPathUtils.h" |
Ben Wagner | 6a34f3a | 2019-05-01 10:59:30 -0400 | [diff] [blame] | 46 | #include "src/gpu/ops/GrDrawOp.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 47 | #include "src/gpu/ops/GrMeshDrawOp.h" |
Ben Wagner | 6a34f3a | 2019-05-01 10:59:30 -0400 | [diff] [blame] | 48 | #include "src/gpu/ops/GrOp.h" |
Robert Phillips | 3968fcb | 2019-12-05 16:40:31 -0500 | [diff] [blame] | 49 | #include "src/gpu/ops/GrSimpleMeshDrawOpHelper.h" |
Ben Wagner | 6a34f3a | 2019-05-01 10:59:30 -0400 | [diff] [blame] | 50 | |
| 51 | #include <memory> |
| 52 | #include <utility> |
| 53 | |
| 54 | class GrAppliedClip; |
commit-bot@chromium.org | 78a1078 | 2013-08-21 19:27:48 +0000 | [diff] [blame] | 55 | |
commit-bot@chromium.org | 78a1078 | 2013-08-21 19:27:48 +0000 | [diff] [blame] | 56 | namespace skiagm { |
joshualitt | 95964c6 | 2015-02-11 13:45:50 -0800 | [diff] [blame] | 57 | |
Brian Salomon | 477d0ef | 2017-07-14 10:12:26 -0400 | [diff] [blame] | 58 | class BezierTestOp : public GrMeshDrawOp { |
| 59 | public: |
| 60 | FixedFunctionFlags fixedFunctionFlags() const override { return FixedFunctionFlags::kNone; } |
| 61 | |
Chris Dalton | 6ce447a | 2019-06-23 18:07:38 -0600 | [diff] [blame] | 62 | GrProcessorSet::Analysis finalize( |
Chris Dalton | 57ab06c | 2021-04-22 12:57:28 -0600 | [diff] [blame] | 63 | const GrCaps& caps, const GrAppliedClip* clip, GrClampType clampType) override { |
Chris Dalton | b8fff0d | 2019-03-05 10:11:58 -0700 | [diff] [blame] | 64 | return fProcessorSet.finalize( |
| 65 | fColor, GrProcessorAnalysisCoverage::kSingleChannel, clip, |
Chris Dalton | 57ab06c | 2021-04-22 12:57:28 -0600 | [diff] [blame] | 66 | &GrUserStencilSettings::kUnused, caps, clampType, &fColor); |
Brian Salomon | 477d0ef | 2017-07-14 10:12:26 -0400 | [diff] [blame] | 67 | } |
| 68 | |
Robert Phillips | 294723d | 2021-06-17 09:23:58 -0400 | [diff] [blame] | 69 | void visitProxies(const GrVisitProxyFunc& func) const override { |
Robert Phillips | 4f93c57 | 2020-03-18 08:13:53 -0400 | [diff] [blame] | 70 | if (fProgramInfo) { |
| 71 | fProgramInfo->visitFPProxies(func); |
| 72 | } else { |
| 73 | fProcessorSet.visitProxies(func); |
| 74 | } |
Robert Phillips | b493eeb | 2017-09-13 13:10:52 -0400 | [diff] [blame] | 75 | } |
| 76 | |
Brian Salomon | 477d0ef | 2017-07-14 10:12:26 -0400 | [diff] [blame] | 77 | protected: |
John Stiles | 3b2c06c | 2020-06-17 12:45:57 -0400 | [diff] [blame] | 78 | BezierTestOp(const SkRect& rect, const SkPMColor4f& color, int32_t classID) |
Brian Salomon | 477d0ef | 2017-07-14 10:12:26 -0400 | [diff] [blame] | 79 | : INHERITED(classID) |
| 80 | , fRect(rect) |
| 81 | , fColor(color) |
Brian Salomon | 477d0ef | 2017-07-14 10:12:26 -0400 | [diff] [blame] | 82 | , fProcessorSet(SkBlendMode::kSrc) { |
Greg Daniel | 5faf474 | 2019-10-01 15:14:44 -0400 | [diff] [blame] | 83 | this->setBounds(rect, HasAABloat::kYes, IsHairline::kNo); |
Brian Salomon | 477d0ef | 2017-07-14 10:12:26 -0400 | [diff] [blame] | 84 | } |
| 85 | |
Robert Phillips | ce97857 | 2020-02-28 11:56:44 -0500 | [diff] [blame] | 86 | virtual GrGeometryProcessor* makeGP(const GrCaps& caps, SkArenaAlloc* arena) = 0; |
Robert Phillips | 3968fcb | 2019-12-05 16:40:31 -0500 | [diff] [blame] | 87 | |
Robert Phillips | 2669a7b | 2020-03-12 12:07:19 -0400 | [diff] [blame] | 88 | GrProgramInfo* programInfo() override { return fProgramInfo; } |
| 89 | |
Robert Phillips | 4133dc4 | 2020-03-11 15:55:55 -0400 | [diff] [blame] | 90 | void onCreateProgramInfo(const GrCaps* caps, |
| 91 | SkArenaAlloc* arena, |
Adlai Holler | e2296f7 | 2020-11-19 13:41:26 -0500 | [diff] [blame] | 92 | const GrSurfaceProxyView& writeView, |
Chris Dalton | 6aaf00f | 2021-07-13 13:26:39 -0600 | [diff] [blame] | 93 | bool usesMSAASurface, |
Robert Phillips | 4133dc4 | 2020-03-11 15:55:55 -0400 | [diff] [blame] | 94 | GrAppliedClip&& appliedClip, |
John Stiles | 52cb1d0 | 2021-06-02 11:58:05 -0400 | [diff] [blame] | 95 | const GrDstProxyView& dstProxyView, |
Greg Daniel | 42dbca5 | 2020-11-20 10:22:43 -0500 | [diff] [blame] | 96 | GrXferBarrierFlags renderPassXferBarriers, |
| 97 | GrLoadOp colorLoadOp) override { |
Robert Phillips | ce97857 | 2020-02-28 11:56:44 -0500 | [diff] [blame] | 98 | auto gp = this->makeGP(*caps, arena); |
| 99 | if (!gp) { |
Robert Phillips | 4133dc4 | 2020-03-11 15:55:55 -0400 | [diff] [blame] | 100 | return; |
Robert Phillips | ce97857 | 2020-02-28 11:56:44 -0500 | [diff] [blame] | 101 | } |
| 102 | |
| 103 | GrPipeline::InputFlags flags = GrPipeline::InputFlags::kNone; |
| 104 | |
Brian Salomon | 8afde5f | 2020-04-01 16:22:00 -0400 | [diff] [blame] | 105 | fProgramInfo = GrSimpleMeshDrawOpHelper::CreateProgramInfo(caps, arena, writeView, |
Robert Phillips | 4133dc4 | 2020-03-11 15:55:55 -0400 | [diff] [blame] | 106 | std::move(appliedClip), |
| 107 | dstProxyView, gp, |
| 108 | std::move(fProcessorSet), |
| 109 | GrPrimitiveType::kTriangles, |
Greg Daniel | d358cbe | 2020-09-11 09:33:54 -0400 | [diff] [blame] | 110 | renderPassXferBarriers, |
Greg Daniel | 42dbca5 | 2020-11-20 10:22:43 -0500 | [diff] [blame] | 111 | colorLoadOp, |
Robert Phillips | 4133dc4 | 2020-03-11 15:55:55 -0400 | [diff] [blame] | 112 | flags); |
Robert Phillips | ce97857 | 2020-02-28 11:56:44 -0500 | [diff] [blame] | 113 | } |
| 114 | |
Robert Phillips | ce97857 | 2020-02-28 11:56:44 -0500 | [diff] [blame] | 115 | void onExecute(GrOpFlushState* flushState, const SkRect& chainBounds) final { |
| 116 | if (!fProgramInfo) { |
Robert Phillips | 4133dc4 | 2020-03-11 15:55:55 -0400 | [diff] [blame] | 117 | this->createProgramInfo(flushState); |
Robert Phillips | ce97857 | 2020-02-28 11:56:44 -0500 | [diff] [blame] | 118 | } |
| 119 | |
| 120 | if (!fProgramInfo) { |
| 121 | return; |
| 122 | } |
| 123 | |
Chris Dalton | 765ed36 | 2020-03-16 17:34:44 -0600 | [diff] [blame] | 124 | flushState->bindPipelineAndScissorClip(*fProgramInfo, chainBounds); |
Robert Phillips | 787fd9d | 2021-03-22 14:48:09 -0400 | [diff] [blame] | 125 | flushState->bindTextures(fProgramInfo->geomProc(), nullptr, fProgramInfo->pipeline()); |
Chris Dalton | 765ed36 | 2020-03-16 17:34:44 -0600 | [diff] [blame] | 126 | flushState->drawMesh(*fMesh); |
Brian Salomon | 477d0ef | 2017-07-14 10:12:26 -0400 | [diff] [blame] | 127 | } |
| 128 | |
Brian Salomon | 477d0ef | 2017-07-14 10:12:26 -0400 | [diff] [blame] | 129 | const SkRect& rect() const { return fRect; } |
Brian Osman | cf86085 | 2018-10-31 14:04:39 -0400 | [diff] [blame] | 130 | const SkPMColor4f& color() const { return fColor; } |
Brian Salomon | 477d0ef | 2017-07-14 10:12:26 -0400 | [diff] [blame] | 131 | |
Robert Phillips | ce97857 | 2020-02-28 11:56:44 -0500 | [diff] [blame] | 132 | protected: |
Chris Dalton | eb694b7 | 2020-03-16 09:25:50 -0600 | [diff] [blame] | 133 | GrSimpleMesh* fMesh = nullptr; // filled in by the derived classes |
Robert Phillips | ce97857 | 2020-02-28 11:56:44 -0500 | [diff] [blame] | 134 | |
Brian Salomon | 477d0ef | 2017-07-14 10:12:26 -0400 | [diff] [blame] | 135 | private: |
Robert Phillips | ce97857 | 2020-02-28 11:56:44 -0500 | [diff] [blame] | 136 | SkRect fRect; |
| 137 | SkPMColor4f fColor; |
Robert Phillips | ce97857 | 2020-02-28 11:56:44 -0500 | [diff] [blame] | 138 | GrProcessorSet fProcessorSet; |
| 139 | GrProgramInfo* fProgramInfo = nullptr; |
Brian Salomon | 477d0ef | 2017-07-14 10:12:26 -0400 | [diff] [blame] | 140 | |
John Stiles | 7571f9e | 2020-09-02 22:42:33 -0400 | [diff] [blame] | 141 | using INHERITED = GrMeshDrawOp; |
Brian Salomon | 477d0ef | 2017-07-14 10:12:26 -0400 | [diff] [blame] | 142 | }; |
| 143 | |
commit-bot@chromium.org | 78a1078 | 2013-08-21 19:27:48 +0000 | [diff] [blame] | 144 | /** |
| 145 | * This GM directly exercises effects that draw Bezier curves in the GPU backend. |
| 146 | */ |
Brian Salomon | 477d0ef | 2017-07-14 10:12:26 -0400 | [diff] [blame] | 147 | class BezierConicTestOp : public BezierTestOp { |
Chris Dalton | febbffa | 2017-06-08 13:12:02 -0600 | [diff] [blame] | 148 | public: |
| 149 | DEFINE_OP_CLASS_ID |
| 150 | |
Robert Phillips | ce97857 | 2020-02-28 11:56:44 -0500 | [diff] [blame] | 151 | const char* name() const final { return "BezierConicTestOp"; } |
Chris Dalton | febbffa | 2017-06-08 13:12:02 -0600 | [diff] [blame] | 152 | |
Herb Derby | c76d409 | 2020-10-07 16:46:15 -0400 | [diff] [blame] | 153 | static GrOp::Owner Make(GrRecordingContext* context, |
| 154 | const SkRect& rect, |
| 155 | const SkPMColor4f& color, |
| 156 | const SkMatrix& klm) { |
| 157 | return GrOp::Make<BezierConicTestOp>(context, rect, color, klm); |
Chris Dalton | febbffa | 2017-06-08 13:12:02 -0600 | [diff] [blame] | 158 | } |
| 159 | |
| 160 | private: |
Herb Derby | c76d409 | 2020-10-07 16:46:15 -0400 | [diff] [blame] | 161 | friend class ::GrOp; // for ctor |
Robert Phillips | 7c525e6 | 2018-06-12 10:11:12 -0400 | [diff] [blame] | 162 | |
John Stiles | 3b2c06c | 2020-06-17 12:45:57 -0400 | [diff] [blame] | 163 | BezierConicTestOp(const SkRect& rect, const SkPMColor4f& color, const SkMatrix& klm) |
| 164 | : INHERITED(rect, color, ClassID()) |
| 165 | , fKLM(klm) {} |
Brian Salomon | 477d0ef | 2017-07-14 10:12:26 -0400 | [diff] [blame] | 166 | |
Chris Dalton | febbffa | 2017-06-08 13:12:02 -0600 | [diff] [blame] | 167 | struct Vertex { |
| 168 | SkPoint fPosition; |
| 169 | float fKLM[4]; // The last value is ignored. The effect expects a vec4f. |
| 170 | }; |
| 171 | |
Robert Phillips | ce97857 | 2020-02-28 11:56:44 -0500 | [diff] [blame] | 172 | GrGeometryProcessor* makeGP(const GrCaps& caps, SkArenaAlloc* arena) final { |
John Stiles | 3b2c06c | 2020-06-17 12:45:57 -0400 | [diff] [blame] | 173 | auto tmp = GrConicEffect::Make(arena, this->color(), SkMatrix::I(), caps, SkMatrix::I(), |
| 174 | false); |
Robert Phillips | ce97857 | 2020-02-28 11:56:44 -0500 | [diff] [blame] | 175 | if (!tmp) { |
| 176 | return nullptr; |
Robert Phillips | 7cd0bfe | 2019-11-20 16:08:10 -0500 | [diff] [blame] | 177 | } |
Robert Phillips | ce97857 | 2020-02-28 11:56:44 -0500 | [diff] [blame] | 178 | SkASSERT(tmp->vertexStride() == sizeof(Vertex)); |
| 179 | return tmp; |
| 180 | } |
Robert Phillips | 7cd0bfe | 2019-11-20 16:08:10 -0500 | [diff] [blame] | 181 | |
Robert Phillips | 7114395 | 2021-06-17 14:55:07 -0400 | [diff] [blame] | 182 | void onPrepareDraws(GrMeshDrawTarget* target) final { |
Brian Salomon | 7eae3e0 | 2018-08-07 14:02:38 +0000 | [diff] [blame] | 183 | QuadHelper helper(target, sizeof(Vertex), 1); |
| 184 | Vertex* verts = reinterpret_cast<Vertex*>(helper.vertices()); |
Chris Dalton | febbffa | 2017-06-08 13:12:02 -0600 | [diff] [blame] | 185 | if (!verts) { |
| 186 | return; |
| 187 | } |
Brian Salomon | 477d0ef | 2017-07-14 10:12:26 -0400 | [diff] [blame] | 188 | SkRect rect = this->rect(); |
Robert Phillips | ce97857 | 2020-02-28 11:56:44 -0500 | [diff] [blame] | 189 | SkPointPriv::SetRectTriStrip(&verts[0].fPosition, rect, sizeof(Vertex)); |
Chris Dalton | febbffa | 2017-06-08 13:12:02 -0600 | [diff] [blame] | 190 | for (int v = 0; v < 4; ++v) { |
Cary Clark | e4442cb | 2017-10-18 11:46:18 -0400 | [diff] [blame] | 191 | SkPoint3 pt3 = {verts[v].fPosition.x(), verts[v].fPosition.y(), 1.f}; |
| 192 | fKLM.mapHomogeneousPoints((SkPoint3* ) verts[v].fKLM, &pt3, 1); |
Chris Dalton | febbffa | 2017-06-08 13:12:02 -0600 | [diff] [blame] | 193 | } |
Chris Dalton | 07cdcfc9 | 2019-02-26 11:13:22 -0700 | [diff] [blame] | 194 | |
Robert Phillips | ce97857 | 2020-02-28 11:56:44 -0500 | [diff] [blame] | 195 | fMesh = helper.mesh(); |
Chris Dalton | febbffa | 2017-06-08 13:12:02 -0600 | [diff] [blame] | 196 | } |
| 197 | |
| 198 | SkMatrix fKLM; |
Chris Dalton | febbffa | 2017-06-08 13:12:02 -0600 | [diff] [blame] | 199 | |
| 200 | static constexpr int kVertsPerCubic = 4; |
| 201 | static constexpr int kIndicesPerCubic = 6; |
| 202 | |
John Stiles | 7571f9e | 2020-09-02 22:42:33 -0400 | [diff] [blame] | 203 | using INHERITED = BezierTestOp; |
Chris Dalton | febbffa | 2017-06-08 13:12:02 -0600 | [diff] [blame] | 204 | }; |
| 205 | |
| 206 | |
commit-bot@chromium.org | 53a0b6c | 2013-08-23 18:05:01 +0000 | [diff] [blame] | 207 | /** |
| 208 | * This GM directly exercises effects that draw Bezier curves in the GPU backend. |
| 209 | */ |
Chris Dalton | 3a77837 | 2019-02-07 15:23:36 -0700 | [diff] [blame] | 210 | class BezierConicEffects : public GpuGM { |
commit-bot@chromium.org | 53a0b6c | 2013-08-23 18:05:01 +0000 | [diff] [blame] | 211 | public: |
| 212 | BezierConicEffects() { |
| 213 | this->setBGColor(0xFFFFFFFF); |
| 214 | } |
| 215 | |
| 216 | protected: |
Robert Phillips | 98f3fd9 | 2019-11-21 13:16:21 -0500 | [diff] [blame] | 217 | static const int kNumConics = 10; |
| 218 | static const int kCellWidth = 128; |
| 219 | static const int kCellHeight = 128; |
| 220 | |
mtklein | 36352bf | 2015-03-25 18:17:31 -0700 | [diff] [blame] | 221 | SkString onShortName() override { |
commit-bot@chromium.org | 53a0b6c | 2013-08-23 18:05:01 +0000 | [diff] [blame] | 222 | return SkString("bezier_conic_effects"); |
| 223 | } |
| 224 | |
mtklein | 36352bf | 2015-03-25 18:17:31 -0700 | [diff] [blame] | 225 | SkISize onISize() override { |
John Stiles | 3b2c06c | 2020-06-17 12:45:57 -0400 | [diff] [blame] | 226 | return SkISize::Make(kCellWidth, kNumConics*kCellHeight); |
commit-bot@chromium.org | 53a0b6c | 2013-08-23 18:05:01 +0000 | [diff] [blame] | 227 | } |
| 228 | |
Robert Phillips | 7a0d3c3 | 2021-07-21 15:39:51 -0400 | [diff] [blame^] | 229 | DrawResult onDraw(GrRecordingContext* rContext, SkCanvas* canvas, SkString* errorMsg) override { |
| 230 | auto sdc = SkCanvasPriv::TopDeviceSurfaceDrawContext(canvas); |
| 231 | if (!sdc) { |
| 232 | *errorMsg = kErrorMsg_DrawSkippedGpuOnly; |
| 233 | return DrawResult::kSkip; |
| 234 | } |
Robert Phillips | 98f3fd9 | 2019-11-21 13:16:21 -0500 | [diff] [blame] | 235 | |
| 236 | const SkScalar w = kCellWidth, h = kCellHeight; |
| 237 | const SkPMColor4f kOpaqueBlack = SkPMColor4f::FromBytes_RGBA(0xff000000); |
| 238 | |
| 239 | const SkPoint baseControlPts[kNumConics][3] = { |
| 240 | { { 0.31f * w, 0.01f * h}, { 0.48f * w, 0.74f * h }, { 0.19f * w, 0.33f * h } }, |
| 241 | { { 0.00f * w, 0.07f * h}, { 0.30f * w, 0.70f * h }, { 0.47f * w, 0.37f * h } }, |
| 242 | { { 0.15f * w, 0.23f * h}, { 0.49f * w, 0.87f * h }, { 0.85f * w, 0.66f * h } }, |
| 243 | { { 0.09f * w, 0.15f * h}, { 0.42f * w, 0.33f * h }, { 0.17f * w, 0.38f * h } }, |
| 244 | { { 0.98f * w, 0.54f * h}, { 0.83f * w, 0.91f * h }, { 0.62f * w, 0.40f * h } }, |
| 245 | { { 0.96f * w, 0.65f * h}, { 0.03f * w, 0.79f * h }, { 0.24f * w, 0.56f * h } }, |
| 246 | { { 0.57f * w, 0.12f * h}, { 0.33f * w, 0.67f * h }, { 0.59f * w, 0.33f * h } }, |
| 247 | { { 0.12f * w, 0.72f * h}, { 0.69f * w, 0.85f * h }, { 0.46f * w, 0.32f * h } }, |
| 248 | { { 0.27f * w, 0.49f * h}, { 0.41f * w, 0.02f * h }, { 0.11f * w, 0.42f * h } }, |
| 249 | { { 0.40f * w, 0.13f * h}, { 0.83f * w, 0.30f * h }, { 0.31f * w, 0.68f * h } }, |
commit-bot@chromium.org | 53a0b6c | 2013-08-23 18:05:01 +0000 | [diff] [blame] | 250 | }; |
Robert Phillips | 98f3fd9 | 2019-11-21 13:16:21 -0500 | [diff] [blame] | 251 | const SkScalar weights[kNumConics] = { 0.62f, 0.01f, 0.95f, 1.48f, 0.37f, |
| 252 | 0.66f, 0.15f, 0.14f, 0.61f, 1.4f }; |
commit-bot@chromium.org | 53a0b6c | 2013-08-23 18:05:01 +0000 | [diff] [blame] | 253 | |
Robert Phillips | 98f3fd9 | 2019-11-21 13:16:21 -0500 | [diff] [blame] | 254 | SkPaint ctrlPtPaint; |
| 255 | ctrlPtPaint.setColor(SK_ColorRED); |
commit-bot@chromium.org | 53a0b6c | 2013-08-23 18:05:01 +0000 | [diff] [blame] | 256 | |
Robert Phillips | 98f3fd9 | 2019-11-21 13:16:21 -0500 | [diff] [blame] | 257 | SkPaint choppedPtPaint; |
| 258 | choppedPtPaint.setColor(~ctrlPtPaint.getColor() | 0xFF000000); |
commit-bot@chromium.org | 53a0b6c | 2013-08-23 18:05:01 +0000 | [diff] [blame] | 259 | |
Robert Phillips | 98f3fd9 | 2019-11-21 13:16:21 -0500 | [diff] [blame] | 260 | SkPaint polyPaint; |
| 261 | polyPaint.setColor(0xffA0A0A0); |
| 262 | polyPaint.setStrokeWidth(0); |
| 263 | polyPaint.setStyle(SkPaint::kStroke_Style); |
| 264 | |
| 265 | SkPaint boundsPaint; |
| 266 | boundsPaint.setColor(0xff808080); |
| 267 | boundsPaint.setStrokeWidth(0); |
| 268 | boundsPaint.setStyle(SkPaint::kStroke_Style); |
| 269 | |
| 270 | |
| 271 | for (int row = 0; row < kNumConics; ++row) { |
John Stiles | 3b2c06c | 2020-06-17 12:45:57 -0400 | [diff] [blame] | 272 | SkScalar x = 0; |
| 273 | SkScalar y = row * h; |
| 274 | SkPoint controlPts[] = { |
| 275 | {x + baseControlPts[row][0].fX, y + baseControlPts[row][0].fY}, |
| 276 | {x + baseControlPts[row][1].fX, y + baseControlPts[row][1].fY}, |
| 277 | {x + baseControlPts[row][2].fX, y + baseControlPts[row][2].fY} |
| 278 | }; |
commit-bot@chromium.org | cabf4b2 | 2014-03-05 18:27:43 +0000 | [diff] [blame] | 279 | |
John Stiles | 3b2c06c | 2020-06-17 12:45:57 -0400 | [diff] [blame] | 280 | for (int i = 0; i < 3; ++i) { |
| 281 | canvas->drawCircle(controlPts[i], 6.f, ctrlPtPaint); |
| 282 | } |
commit-bot@chromium.org | 53a0b6c | 2013-08-23 18:05:01 +0000 | [diff] [blame] | 283 | |
John Stiles | 3b2c06c | 2020-06-17 12:45:57 -0400 | [diff] [blame] | 284 | canvas->drawPoints(SkCanvas::kPolygon_PointMode, 3, controlPts, polyPaint); |
| 285 | |
| 286 | SkConic dst[4]; |
| 287 | SkMatrix klm; |
| 288 | int cnt = ChopConic(controlPts, dst, weights[row]); |
| 289 | GrPathUtils::getConicKLM(controlPts, weights[row], &klm); |
| 290 | |
| 291 | for (int c = 0; c < cnt; ++c) { |
| 292 | SkPoint* pts = dst[c].fPts; |
commit-bot@chromium.org | 53a0b6c | 2013-08-23 18:05:01 +0000 | [diff] [blame] | 293 | for (int i = 0; i < 3; ++i) { |
John Stiles | 3b2c06c | 2020-06-17 12:45:57 -0400 | [diff] [blame] | 294 | canvas->drawCircle(pts[i], 3.f, choppedPtPaint); |
commit-bot@chromium.org | 53a0b6c | 2013-08-23 18:05:01 +0000 | [diff] [blame] | 295 | } |
| 296 | |
John Stiles | 3b2c06c | 2020-06-17 12:45:57 -0400 | [diff] [blame] | 297 | SkRect bounds; |
| 298 | bounds.setBounds(pts, 3); |
commit-bot@chromium.org | 53a0b6c | 2013-08-23 18:05:01 +0000 | [diff] [blame] | 299 | |
John Stiles | 3b2c06c | 2020-06-17 12:45:57 -0400 | [diff] [blame] | 300 | canvas->drawRect(bounds, boundsPaint); |
commit-bot@chromium.org | 53a0b6c | 2013-08-23 18:05:01 +0000 | [diff] [blame] | 301 | |
Robert Phillips | 7a0d3c3 | 2021-07-21 15:39:51 -0400 | [diff] [blame^] | 302 | GrOp::Owner op = BezierConicTestOp::Make(rContext, bounds, |
Herb Derby | c76d409 | 2020-10-07 16:46:15 -0400 | [diff] [blame] | 303 | kOpaqueBlack, klm); |
Robert Phillips | 7a0d3c3 | 2021-07-21 15:39:51 -0400 | [diff] [blame^] | 304 | sdc->addDrawOp(std::move(op)); |
commit-bot@chromium.org | 53a0b6c | 2013-08-23 18:05:01 +0000 | [diff] [blame] | 305 | } |
| 306 | } |
Robert Phillips | 7a0d3c3 | 2021-07-21 15:39:51 -0400 | [diff] [blame^] | 307 | |
| 308 | return DrawResult::kOk; |
commit-bot@chromium.org | 53a0b6c | 2013-08-23 18:05:01 +0000 | [diff] [blame] | 309 | } |
| 310 | |
| 311 | private: |
| 312 | // Uses the max curvature function for quads to estimate |
| 313 | // where to chop the conic. If the max curvature is not |
| 314 | // found along the curve segment it will return 1 and |
| 315 | // dst[0] is the original conic. If it returns 2 the dst[0] |
| 316 | // and dst[1] are the two new conics. |
Robert Phillips | 98f3fd9 | 2019-11-21 13:16:21 -0500 | [diff] [blame] | 317 | static int SplitConic(const SkPoint src[3], SkConic dst[2], const SkScalar weight) { |
commit-bot@chromium.org | 53a0b6c | 2013-08-23 18:05:01 +0000 | [diff] [blame] | 318 | SkScalar t = SkFindQuadMaxCurvature(src); |
Chris Dalton | 1d474dd | 2018-07-24 01:08:31 -0600 | [diff] [blame] | 319 | if (t == 0 || t == 1) { |
commit-bot@chromium.org | 53a0b6c | 2013-08-23 18:05:01 +0000 | [diff] [blame] | 320 | if (dst) { |
| 321 | dst[0].set(src, weight); |
| 322 | } |
| 323 | return 1; |
| 324 | } else { |
| 325 | if (dst) { |
| 326 | SkConic conic; |
| 327 | conic.set(src, weight); |
caryclark | 414c429 | 2016-09-26 11:03:54 -0700 | [diff] [blame] | 328 | if (!conic.chopAt(t, dst)) { |
| 329 | dst[0].set(src, weight); |
| 330 | return 1; |
| 331 | } |
commit-bot@chromium.org | 53a0b6c | 2013-08-23 18:05:01 +0000 | [diff] [blame] | 332 | } |
| 333 | return 2; |
| 334 | } |
| 335 | } |
| 336 | |
Robert Phillips | 98f3fd9 | 2019-11-21 13:16:21 -0500 | [diff] [blame] | 337 | // Calls SplitConic on the entire conic and then once more on each subsection. |
commit-bot@chromium.org | 53a0b6c | 2013-08-23 18:05:01 +0000 | [diff] [blame] | 338 | // Most cases will result in either 1 conic (chop point is not within t range) |
| 339 | // or 3 points (split once and then one subsection is split again). |
Robert Phillips | 98f3fd9 | 2019-11-21 13:16:21 -0500 | [diff] [blame] | 340 | static int ChopConic(const SkPoint src[3], SkConic dst[4], const SkScalar weight) { |
commit-bot@chromium.org | 53a0b6c | 2013-08-23 18:05:01 +0000 | [diff] [blame] | 341 | SkConic dstTemp[2]; |
Robert Phillips | 98f3fd9 | 2019-11-21 13:16:21 -0500 | [diff] [blame] | 342 | int conicCnt = SplitConic(src, dstTemp, weight); |
commit-bot@chromium.org | 53a0b6c | 2013-08-23 18:05:01 +0000 | [diff] [blame] | 343 | if (2 == conicCnt) { |
Robert Phillips | 98f3fd9 | 2019-11-21 13:16:21 -0500 | [diff] [blame] | 344 | int conicCnt2 = SplitConic(dstTemp[0].fPts, dst, dstTemp[0].fW); |
| 345 | conicCnt = conicCnt2 + SplitConic(dstTemp[1].fPts, &dst[conicCnt2], dstTemp[1].fW); |
commit-bot@chromium.org | 53a0b6c | 2013-08-23 18:05:01 +0000 | [diff] [blame] | 346 | } else { |
| 347 | dst[0] = dstTemp[0]; |
| 348 | } |
| 349 | return conicCnt; |
| 350 | } |
| 351 | |
John Stiles | 7571f9e | 2020-09-02 22:42:33 -0400 | [diff] [blame] | 352 | using INHERITED = GM; |
commit-bot@chromium.org | 53a0b6c | 2013-08-23 18:05:01 +0000 | [diff] [blame] | 353 | }; |
| 354 | |
| 355 | ////////////////////////////////////////////////////////////////////////////// |
joshualitt | 95964c6 | 2015-02-11 13:45:50 -0800 | [diff] [blame] | 356 | |
Brian Salomon | 477d0ef | 2017-07-14 10:12:26 -0400 | [diff] [blame] | 357 | class BezierQuadTestOp : public BezierTestOp { |
joshualitt | 95964c6 | 2015-02-11 13:45:50 -0800 | [diff] [blame] | 358 | public: |
Brian Salomon | 25a8809 | 2016-12-01 09:36:50 -0500 | [diff] [blame] | 359 | DEFINE_OP_CLASS_ID |
Brian Salomon | 6b316e9 | 2016-12-16 09:35:49 -0500 | [diff] [blame] | 360 | const char* name() const override { return "BezierQuadTestOp"; } |
joshualitt | 95964c6 | 2015-02-11 13:45:50 -0800 | [diff] [blame] | 361 | |
Herb Derby | c76d409 | 2020-10-07 16:46:15 -0400 | [diff] [blame] | 362 | static GrOp::Owner Make(GrRecordingContext* context, |
| 363 | const SkRect& rect, |
| 364 | const SkPMColor4f& color, |
| 365 | const GrPathUtils::QuadUVMatrix& devToUV) { |
| 366 | return GrOp::Make<BezierQuadTestOp>(context, rect, color, devToUV); |
joshualitt | 95964c6 | 2015-02-11 13:45:50 -0800 | [diff] [blame] | 367 | } |
| 368 | |
| 369 | private: |
Herb Derby | c76d409 | 2020-10-07 16:46:15 -0400 | [diff] [blame] | 370 | friend class ::GrOp; // for ctor |
Robert Phillips | 7c525e6 | 2018-06-12 10:11:12 -0400 | [diff] [blame] | 371 | |
John Stiles | 3b2c06c | 2020-06-17 12:45:57 -0400 | [diff] [blame] | 372 | BezierQuadTestOp(const SkRect& rect, const SkPMColor4f& color, |
| 373 | const GrPathUtils::QuadUVMatrix& devToUV) |
| 374 | : INHERITED(rect, color, ClassID()) |
| 375 | , fDevToUV(devToUV) {} |
joshualitt | 95964c6 | 2015-02-11 13:45:50 -0800 | [diff] [blame] | 376 | |
| 377 | struct Vertex { |
| 378 | SkPoint fPosition; |
| 379 | float fKLM[4]; // The last value is ignored. The effect expects a vec4f. |
| 380 | }; |
| 381 | |
Robert Phillips | ce97857 | 2020-02-28 11:56:44 -0500 | [diff] [blame] | 382 | GrGeometryProcessor* makeGP(const GrCaps& caps, SkArenaAlloc* arena) final { |
John Stiles | 3b2c06c | 2020-06-17 12:45:57 -0400 | [diff] [blame] | 383 | auto tmp = GrQuadEffect::Make(arena, this->color(), SkMatrix::I(), caps, SkMatrix::I(), |
| 384 | false); |
Robert Phillips | ce97857 | 2020-02-28 11:56:44 -0500 | [diff] [blame] | 385 | if (!tmp) { |
| 386 | return nullptr; |
Robert Phillips | 7cd0bfe | 2019-11-20 16:08:10 -0500 | [diff] [blame] | 387 | } |
Robert Phillips | ce97857 | 2020-02-28 11:56:44 -0500 | [diff] [blame] | 388 | SkASSERT(tmp->vertexStride() == sizeof(Vertex)); |
| 389 | return tmp; |
| 390 | } |
Robert Phillips | 7cd0bfe | 2019-11-20 16:08:10 -0500 | [diff] [blame] | 391 | |
Robert Phillips | 7114395 | 2021-06-17 14:55:07 -0400 | [diff] [blame] | 392 | void onPrepareDraws(GrMeshDrawTarget* target) final { |
Brian Salomon | 7eae3e0 | 2018-08-07 14:02:38 +0000 | [diff] [blame] | 393 | QuadHelper helper(target, sizeof(Vertex), 1); |
| 394 | Vertex* verts = reinterpret_cast<Vertex*>(helper.vertices()); |
bsalomon | b5238a7 | 2015-05-05 07:49:49 -0700 | [diff] [blame] | 395 | if (!verts) { |
joshualitt | 4b31de8 | 2015-03-05 14:33:41 -0800 | [diff] [blame] | 396 | return; |
| 397 | } |
Brian Salomon | 477d0ef | 2017-07-14 10:12:26 -0400 | [diff] [blame] | 398 | SkRect rect = this->rect(); |
Brian Salomon | ec42e15 | 2018-05-18 12:52:22 -0400 | [diff] [blame] | 399 | SkPointPriv::SetRectTriStrip(&verts[0].fPosition, rect, sizeof(Vertex)); |
Brian Osman | 568bec7 | 2018-12-26 16:48:25 -0500 | [diff] [blame] | 400 | fDevToUV.apply(verts, 4, sizeof(Vertex), sizeof(SkPoint)); |
Robert Phillips | ce97857 | 2020-02-28 11:56:44 -0500 | [diff] [blame] | 401 | |
| 402 | fMesh = helper.mesh(); |
joshualitt | 95964c6 | 2015-02-11 13:45:50 -0800 | [diff] [blame] | 403 | } |
| 404 | |
Brian Salomon | 9e50f7b | 2017-03-06 12:02:34 -0500 | [diff] [blame] | 405 | GrPathUtils::QuadUVMatrix fDevToUV; |
joshualitt | 95964c6 | 2015-02-11 13:45:50 -0800 | [diff] [blame] | 406 | |
mtklein | dbfd7ab | 2016-09-01 11:24:54 -0700 | [diff] [blame] | 407 | static constexpr int kVertsPerCubic = 4; |
| 408 | static constexpr int kIndicesPerCubic = 6; |
joshualitt | 95964c6 | 2015-02-11 13:45:50 -0800 | [diff] [blame] | 409 | |
John Stiles | 7571f9e | 2020-09-02 22:42:33 -0400 | [diff] [blame] | 410 | using INHERITED = BezierTestOp; |
joshualitt | 95964c6 | 2015-02-11 13:45:50 -0800 | [diff] [blame] | 411 | }; |
| 412 | |
commit-bot@chromium.org | 53a0b6c | 2013-08-23 18:05:01 +0000 | [diff] [blame] | 413 | /** |
| 414 | * This GM directly exercises effects that draw Bezier quad curves in the GPU backend. |
| 415 | */ |
Chris Dalton | 3a77837 | 2019-02-07 15:23:36 -0700 | [diff] [blame] | 416 | class BezierQuadEffects : public GpuGM { |
commit-bot@chromium.org | 53a0b6c | 2013-08-23 18:05:01 +0000 | [diff] [blame] | 417 | public: |
| 418 | BezierQuadEffects() { |
| 419 | this->setBGColor(0xFFFFFFFF); |
| 420 | } |
| 421 | |
| 422 | protected: |
Robert Phillips | 98f3fd9 | 2019-11-21 13:16:21 -0500 | [diff] [blame] | 423 | static const int kNumQuads = 5; |
| 424 | static const int kCellWidth = 128; |
| 425 | static const int kCellHeight = 128; |
| 426 | |
mtklein | 36352bf | 2015-03-25 18:17:31 -0700 | [diff] [blame] | 427 | SkString onShortName() override { |
commit-bot@chromium.org | 53a0b6c | 2013-08-23 18:05:01 +0000 | [diff] [blame] | 428 | return SkString("bezier_quad_effects"); |
| 429 | } |
| 430 | |
mtklein | 36352bf | 2015-03-25 18:17:31 -0700 | [diff] [blame] | 431 | SkISize onISize() override { |
John Stiles | 3b2c06c | 2020-06-17 12:45:57 -0400 | [diff] [blame] | 432 | return SkISize::Make(kCellWidth, kNumQuads*kCellHeight); |
commit-bot@chromium.org | 53a0b6c | 2013-08-23 18:05:01 +0000 | [diff] [blame] | 433 | } |
| 434 | |
Robert Phillips | 7a0d3c3 | 2021-07-21 15:39:51 -0400 | [diff] [blame^] | 435 | DrawResult onDraw(GrRecordingContext* rContext, SkCanvas* canvas, SkString* errorMsg) override { |
| 436 | auto sdc = SkCanvasPriv::TopDeviceSurfaceDrawContext(canvas); |
| 437 | if (!sdc) { |
| 438 | *errorMsg = kErrorMsg_DrawSkippedGpuOnly; |
| 439 | return DrawResult::kSkip; |
| 440 | } |
Robert Phillips | 98f3fd9 | 2019-11-21 13:16:21 -0500 | [diff] [blame] | 441 | |
| 442 | const SkScalar w = kCellWidth, h = kCellHeight; |
| 443 | const SkPMColor4f kOpaqueBlack = SkPMColor4f::FromBytes_RGBA(0xff000000); |
| 444 | |
| 445 | const SkPoint baseControlPts[kNumQuads][3] = { |
| 446 | { { 0.31f * w, 0.01f * h}, { 0.48f * w, 0.74f * h }, { 0.19f * w, 0.33f * h } }, |
| 447 | { { 0.00f * w, 0.07f * h}, { 0.30f * w, 0.70f * h }, { 0.47f * w, 0.37f * h } }, |
| 448 | { { 0.15f * w, 0.23f * h}, { 0.49f * w, 0.87f * h }, { 0.85f * w, 0.66f * h } }, |
| 449 | { { 0.09f * w, 0.15f * h}, { 0.42f * w, 0.33f * h }, { 0.17f * w, 0.38f * h } }, |
| 450 | { { 0.98f * w, 0.54f * h}, { 0.83f * w, 0.91f * h }, { 0.62f * w, 0.40f * h } }, |
commit-bot@chromium.org | 53a0b6c | 2013-08-23 18:05:01 +0000 | [diff] [blame] | 451 | }; |
| 452 | |
Robert Phillips | 98f3fd9 | 2019-11-21 13:16:21 -0500 | [diff] [blame] | 453 | SkPaint ctrlPtPaint; |
| 454 | ctrlPtPaint.setColor(SK_ColorRED); |
commit-bot@chromium.org | 53a0b6c | 2013-08-23 18:05:01 +0000 | [diff] [blame] | 455 | |
Robert Phillips | 98f3fd9 | 2019-11-21 13:16:21 -0500 | [diff] [blame] | 456 | SkPaint choppedPtPaint; |
| 457 | choppedPtPaint.setColor(~ctrlPtPaint.getColor() | 0xFF000000); |
commit-bot@chromium.org | 53a0b6c | 2013-08-23 18:05:01 +0000 | [diff] [blame] | 458 | |
Robert Phillips | 98f3fd9 | 2019-11-21 13:16:21 -0500 | [diff] [blame] | 459 | SkPaint polyPaint; |
| 460 | polyPaint.setColor(0xffA0A0A0); |
| 461 | polyPaint.setStrokeWidth(0); |
| 462 | polyPaint.setStyle(SkPaint::kStroke_Style); |
| 463 | |
| 464 | SkPaint boundsPaint; |
| 465 | boundsPaint.setColor(0xff808080); |
| 466 | boundsPaint.setStrokeWidth(0); |
| 467 | boundsPaint.setStyle(SkPaint::kStroke_Style); |
| 468 | |
| 469 | for (int row = 0; row < kNumQuads; ++row) { |
John Stiles | 3b2c06c | 2020-06-17 12:45:57 -0400 | [diff] [blame] | 470 | SkScalar x = 0; |
| 471 | SkScalar y = row * h; |
| 472 | SkPoint controlPts[] = { |
| 473 | {x + baseControlPts[row][0].fX, y + baseControlPts[row][0].fY}, |
| 474 | {x + baseControlPts[row][1].fX, y + baseControlPts[row][1].fY}, |
| 475 | {x + baseControlPts[row][2].fX, y + baseControlPts[row][2].fY} |
| 476 | }; |
commit-bot@chromium.org | cabf4b2 | 2014-03-05 18:27:43 +0000 | [diff] [blame] | 477 | |
John Stiles | 3b2c06c | 2020-06-17 12:45:57 -0400 | [diff] [blame] | 478 | for (int i = 0; i < 3; ++i) { |
| 479 | canvas->drawCircle(controlPts[i], 6.f, ctrlPtPaint); |
| 480 | } |
| 481 | |
| 482 | canvas->drawPoints(SkCanvas::kPolygon_PointMode, 3, controlPts, polyPaint); |
| 483 | |
| 484 | SkPoint chopped[5]; |
| 485 | int cnt = SkChopQuadAtMaxCurvature(controlPts, chopped); |
| 486 | |
| 487 | for (int c = 0; c < cnt; ++c) { |
| 488 | SkPoint* pts = chopped + 2 * c; |
commit-bot@chromium.org | 53a0b6c | 2013-08-23 18:05:01 +0000 | [diff] [blame] | 489 | |
commit-bot@chromium.org | 53a0b6c | 2013-08-23 18:05:01 +0000 | [diff] [blame] | 490 | for (int i = 0; i < 3; ++i) { |
John Stiles | 3b2c06c | 2020-06-17 12:45:57 -0400 | [diff] [blame] | 491 | canvas->drawCircle(pts[i], 3.f, choppedPtPaint); |
commit-bot@chromium.org | 53a0b6c | 2013-08-23 18:05:01 +0000 | [diff] [blame] | 492 | } |
| 493 | |
John Stiles | 3b2c06c | 2020-06-17 12:45:57 -0400 | [diff] [blame] | 494 | SkRect bounds; |
| 495 | bounds.setBounds(pts, 3); |
commit-bot@chromium.org | 53a0b6c | 2013-08-23 18:05:01 +0000 | [diff] [blame] | 496 | |
John Stiles | 3b2c06c | 2020-06-17 12:45:57 -0400 | [diff] [blame] | 497 | canvas->drawRect(bounds, boundsPaint); |
commit-bot@chromium.org | 53a0b6c | 2013-08-23 18:05:01 +0000 | [diff] [blame] | 498 | |
John Stiles | 3b2c06c | 2020-06-17 12:45:57 -0400 | [diff] [blame] | 499 | GrPathUtils::QuadUVMatrix DevToUV(pts); |
commit-bot@chromium.org | 53a0b6c | 2013-08-23 18:05:01 +0000 | [diff] [blame] | 500 | |
Robert Phillips | 7a0d3c3 | 2021-07-21 15:39:51 -0400 | [diff] [blame^] | 501 | GrOp::Owner op = BezierQuadTestOp::Make(rContext, bounds, |
Herb Derby | c76d409 | 2020-10-07 16:46:15 -0400 | [diff] [blame] | 502 | kOpaqueBlack, DevToUV); |
Robert Phillips | 7a0d3c3 | 2021-07-21 15:39:51 -0400 | [diff] [blame^] | 503 | sdc->addDrawOp(std::move(op)); |
commit-bot@chromium.org | 53a0b6c | 2013-08-23 18:05:01 +0000 | [diff] [blame] | 504 | } |
| 505 | } |
Robert Phillips | 7a0d3c3 | 2021-07-21 15:39:51 -0400 | [diff] [blame^] | 506 | |
| 507 | return DrawResult::kOk; |
commit-bot@chromium.org | 53a0b6c | 2013-08-23 18:05:01 +0000 | [diff] [blame] | 508 | } |
| 509 | |
| 510 | private: |
John Stiles | 7571f9e | 2020-09-02 22:42:33 -0400 | [diff] [blame] | 511 | using INHERITED = GM; |
commit-bot@chromium.org | 53a0b6c | 2013-08-23 18:05:01 +0000 | [diff] [blame] | 512 | }; |
| 513 | |
halcanary | 385fe4d | 2015-08-26 13:07:48 -0700 | [diff] [blame] | 514 | DEF_GM(return new BezierConicEffects;) |
| 515 | DEF_GM(return new BezierQuadEffects;) |
John Stiles | a6841be | 2020-08-06 14:11:56 -0400 | [diff] [blame] | 516 | } // namespace skiagm |