senorblanco | d6ed19c | 2015-02-26 06:58:17 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2015 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 | |
Chris Dalton | 17dc418 | 2020-03-25 16:18:16 -0600 | [diff] [blame] | 8 | #include "src/gpu/ops/GrTriangulatingPathRenderer.h" |
Brian Salomon | 71fe945 | 2020-03-02 16:59:40 -0500 | [diff] [blame] | 9 | |
| 10 | #include "include/private/SkIDChangeListener.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 11 | #include "src/core/SkGeometry.h" |
Greg Daniel | f91aeb2 | 2019-06-18 09:58:02 -0400 | [diff] [blame] | 12 | #include "src/gpu/GrAuditTrail.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 13 | #include "src/gpu/GrCaps.h" |
| 14 | #include "src/gpu/GrClip.h" |
| 15 | #include "src/gpu/GrDefaultGeoProcFactory.h" |
| 16 | #include "src/gpu/GrDrawOpTest.h" |
Chris Dalton | d081dce | 2020-01-23 12:09:04 -0700 | [diff] [blame] | 17 | #include "src/gpu/GrEagerVertexAllocator.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 18 | #include "src/gpu/GrOpFlushState.h" |
Robert Phillips | 740d34f | 2020-03-11 09:36:13 -0400 | [diff] [blame] | 19 | #include "src/gpu/GrProgramInfo.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 20 | #include "src/gpu/GrResourceCache.h" |
| 21 | #include "src/gpu/GrResourceProvider.h" |
Chris Dalton | eb694b7 | 2020-03-16 09:25:50 -0600 | [diff] [blame] | 22 | #include "src/gpu/GrSimpleMesh.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 23 | #include "src/gpu/GrStyle.h" |
Chris Dalton | 17dc418 | 2020-03-25 16:18:16 -0600 | [diff] [blame] | 24 | #include "src/gpu/GrTriangulator.h" |
Michael Ludwig | 663afe5 | 2019-06-03 16:46:19 -0400 | [diff] [blame] | 25 | #include "src/gpu/geometry/GrPathUtils.h" |
| 26 | #include "src/gpu/geometry/GrShape.h" |
Mike Klein | c0bd9f9 | 2019-04-23 12:05:21 -0500 | [diff] [blame] | 27 | #include "src/gpu/ops/GrMeshDrawOp.h" |
Robert Phillips | 55f681f | 2020-02-28 08:58:15 -0500 | [diff] [blame] | 28 | #include "src/gpu/ops/GrSimpleMeshDrawOpHelperWithStencil.h" |
joshualitt | 7441782 | 2015-08-07 11:42:16 -0700 | [diff] [blame] | 29 | |
Chris Dalton | 17dc418 | 2020-03-25 16:18:16 -0600 | [diff] [blame] | 30 | #include <cstdio> |
Brian Salomon | 71fe945 | 2020-03-02 16:59:40 -0500 | [diff] [blame] | 31 | |
Stephen White | a7701e0 | 2018-01-23 15:35:05 -0500 | [diff] [blame] | 32 | #ifndef GR_AA_TESSELLATOR_MAX_VERB_COUNT |
| 33 | #define GR_AA_TESSELLATOR_MAX_VERB_COUNT 10 |
| 34 | #endif |
| 35 | |
senorblanco | d6ed19c | 2015-02-26 06:58:17 -0800 | [diff] [blame] | 36 | /* |
Chris Dalton | 17dc418 | 2020-03-25 16:18:16 -0600 | [diff] [blame] | 37 | * This path renderer linearizes and decomposes the path into triangles using GrTriangulator, |
| 38 | * uploads the triangles to a vertex buffer, and renders them with a single draw call. It can do |
| 39 | * screenspace antialiasing with a one-pixel coverage ramp. |
senorblanco | d6ed19c | 2015-02-26 06:58:17 -0800 | [diff] [blame] | 40 | */ |
senorblanco | d6ed19c | 2015-02-26 06:58:17 -0800 | [diff] [blame] | 41 | namespace { |
| 42 | |
senorblanco | 84cd621 | 2015-08-04 10:01:58 -0700 | [diff] [blame] | 43 | struct TessInfo { |
| 44 | SkScalar fTolerance; |
senorblanco | 06f989a | 2015-09-02 09:05:17 -0700 | [diff] [blame] | 45 | int fCount; |
senorblanco | 84cd621 | 2015-08-04 10:01:58 -0700 | [diff] [blame] | 46 | }; |
| 47 | |
ethannicholas | e9709e8 | 2016-01-07 13:34:16 -0800 | [diff] [blame] | 48 | // When the SkPathRef genID changes, invalidate a corresponding GrResource described by key. |
Brian Salomon | 99a813c | 2020-03-02 12:50:47 -0500 | [diff] [blame] | 49 | class UniqueKeyInvalidator : public SkIDChangeListener { |
ethannicholas | e9709e8 | 2016-01-07 13:34:16 -0800 | [diff] [blame] | 50 | public: |
Brian Salomon | 99a813c | 2020-03-02 12:50:47 -0500 | [diff] [blame] | 51 | UniqueKeyInvalidator(const GrUniqueKey& key, uint32_t contextUniqueID) |
Brian Salomon | 238069b | 2018-07-11 15:58:57 -0400 | [diff] [blame] | 52 | : fMsg(key, contextUniqueID) {} |
| 53 | |
ethannicholas | e9709e8 | 2016-01-07 13:34:16 -0800 | [diff] [blame] | 54 | private: |
| 55 | GrUniqueKeyInvalidatedMessage fMsg; |
| 56 | |
Brian Salomon | 99a813c | 2020-03-02 12:50:47 -0500 | [diff] [blame] | 57 | void changed() override { SkMessageBus<GrUniqueKeyInvalidatedMessage>::Post(fMsg); } |
ethannicholas | e9709e8 | 2016-01-07 13:34:16 -0800 | [diff] [blame] | 58 | }; |
| 59 | |
Brian Salomon | dbf7072 | 2019-02-07 11:31:24 -0500 | [diff] [blame] | 60 | bool cache_match(GrGpuBuffer* vertexBuffer, SkScalar tol, int* actualCount) { |
senorblanco | 84cd621 | 2015-08-04 10:01:58 -0700 | [diff] [blame] | 61 | if (!vertexBuffer) { |
| 62 | return false; |
| 63 | } |
| 64 | const SkData* data = vertexBuffer->getUniqueKey().getCustomData(); |
| 65 | SkASSERT(data); |
| 66 | const TessInfo* info = static_cast<const TessInfo*>(data->data()); |
| 67 | if (info->fTolerance == 0 || info->fTolerance < 3.0f * tol) { |
senorblanco | 06f989a | 2015-09-02 09:05:17 -0700 | [diff] [blame] | 68 | *actualCount = info->fCount; |
senorblanco | 84cd621 | 2015-08-04 10:01:58 -0700 | [diff] [blame] | 69 | return true; |
| 70 | } |
| 71 | return false; |
| 72 | } |
| 73 | |
Chris Dalton | d081dce | 2020-01-23 12:09:04 -0700 | [diff] [blame] | 74 | class StaticVertexAllocator : public GrEagerVertexAllocator { |
senorblanco | 6599eff | 2016-03-10 08:38:45 -0800 | [diff] [blame] | 75 | public: |
Chris Dalton | d081dce | 2020-01-23 12:09:04 -0700 | [diff] [blame] | 76 | StaticVertexAllocator(GrResourceProvider* resourceProvider, bool canMapVB) |
| 77 | : fResourceProvider(resourceProvider) |
senorblanco | 6599eff | 2016-03-10 08:38:45 -0800 | [diff] [blame] | 78 | , fCanMapVB(canMapVB) |
| 79 | , fVertices(nullptr) { |
| 80 | } |
Chris Dalton | d081dce | 2020-01-23 12:09:04 -0700 | [diff] [blame] | 81 | #ifdef SK_DEBUG |
| 82 | ~StaticVertexAllocator() override { |
| 83 | SkASSERT(!fLockStride); |
| 84 | } |
| 85 | #endif |
| 86 | void* lock(size_t stride, int eagerCount) override { |
| 87 | SkASSERT(!fLockStride); |
| 88 | SkASSERT(stride); |
| 89 | size_t size = eagerCount * stride; |
Brian Salomon | ae64c19 | 2019-02-05 09:41:37 -0500 | [diff] [blame] | 90 | fVertexBuffer = fResourceProvider->createBuffer(size, GrGpuBufferType::kVertex, |
Brian Salomon | dbf7072 | 2019-02-07 11:31:24 -0500 | [diff] [blame] | 91 | kStatic_GrAccessPattern); |
senorblanco | 6599eff | 2016-03-10 08:38:45 -0800 | [diff] [blame] | 92 | if (!fVertexBuffer.get()) { |
| 93 | return nullptr; |
| 94 | } |
| 95 | if (fCanMapVB) { |
senorblanco | f57372d | 2016-08-31 10:36:19 -0700 | [diff] [blame] | 96 | fVertices = fVertexBuffer->map(); |
senorblanco | 6599eff | 2016-03-10 08:38:45 -0800 | [diff] [blame] | 97 | } else { |
Chris Dalton | d081dce | 2020-01-23 12:09:04 -0700 | [diff] [blame] | 98 | fVertices = sk_malloc_throw(eagerCount * stride); |
senorblanco | 6599eff | 2016-03-10 08:38:45 -0800 | [diff] [blame] | 99 | } |
Chris Dalton | d081dce | 2020-01-23 12:09:04 -0700 | [diff] [blame] | 100 | fLockStride = stride; |
senorblanco | 6599eff | 2016-03-10 08:38:45 -0800 | [diff] [blame] | 101 | return fVertices; |
| 102 | } |
| 103 | void unlock(int actualCount) override { |
Chris Dalton | d081dce | 2020-01-23 12:09:04 -0700 | [diff] [blame] | 104 | SkASSERT(fLockStride); |
senorblanco | 6599eff | 2016-03-10 08:38:45 -0800 | [diff] [blame] | 105 | if (fCanMapVB) { |
| 106 | fVertexBuffer->unmap(); |
| 107 | } else { |
Chris Dalton | d081dce | 2020-01-23 12:09:04 -0700 | [diff] [blame] | 108 | fVertexBuffer->updateData(fVertices, actualCount * fLockStride); |
senorblanco | f57372d | 2016-08-31 10:36:19 -0700 | [diff] [blame] | 109 | sk_free(fVertices); |
senorblanco | 6599eff | 2016-03-10 08:38:45 -0800 | [diff] [blame] | 110 | } |
| 111 | fVertices = nullptr; |
Chris Dalton | d081dce | 2020-01-23 12:09:04 -0700 | [diff] [blame] | 112 | fLockStride = 0; |
senorblanco | 6599eff | 2016-03-10 08:38:45 -0800 | [diff] [blame] | 113 | } |
Brian Salomon | dbf7072 | 2019-02-07 11:31:24 -0500 | [diff] [blame] | 114 | sk_sp<GrGpuBuffer> detachVertexBuffer() { return std::move(fVertexBuffer); } |
Brian Salomon | 12d2264 | 2019-01-29 14:38:50 -0500 | [diff] [blame] | 115 | |
senorblanco | 6599eff | 2016-03-10 08:38:45 -0800 | [diff] [blame] | 116 | private: |
Brian Salomon | dbf7072 | 2019-02-07 11:31:24 -0500 | [diff] [blame] | 117 | sk_sp<GrGpuBuffer> fVertexBuffer; |
senorblanco | 6599eff | 2016-03-10 08:38:45 -0800 | [diff] [blame] | 118 | GrResourceProvider* fResourceProvider; |
| 119 | bool fCanMapVB; |
senorblanco | f57372d | 2016-08-31 10:36:19 -0700 | [diff] [blame] | 120 | void* fVertices; |
Chris Dalton | d081dce | 2020-01-23 12:09:04 -0700 | [diff] [blame] | 121 | size_t fLockStride = 0; |
senorblanco | 6599eff | 2016-03-10 08:38:45 -0800 | [diff] [blame] | 122 | }; |
| 123 | |
ethannicholas | e9709e8 | 2016-01-07 13:34:16 -0800 | [diff] [blame] | 124 | } // namespace |
senorblanco | d6ed19c | 2015-02-26 06:58:17 -0800 | [diff] [blame] | 125 | |
Chris Dalton | 17dc418 | 2020-03-25 16:18:16 -0600 | [diff] [blame] | 126 | GrTriangulatingPathRenderer::GrTriangulatingPathRenderer() |
Stephen White | 8a3c059 | 2019-05-29 11:26:16 -0400 | [diff] [blame] | 127 | : fMaxVerbCount(GR_AA_TESSELLATOR_MAX_VERB_COUNT) { |
senorblanco | d6ed19c | 2015-02-26 06:58:17 -0800 | [diff] [blame] | 128 | } |
| 129 | |
Chris Dalton | 5ed4423 | 2017-09-07 13:22:46 -0600 | [diff] [blame] | 130 | GrPathRenderer::CanDrawPath |
Chris Dalton | 17dc418 | 2020-03-25 16:18:16 -0600 | [diff] [blame] | 131 | GrTriangulatingPathRenderer::onCanDrawPath(const CanDrawPathArgs& args) const { |
Chris Dalton | e5ede4b | 2017-09-07 18:33:08 +0000 | [diff] [blame] | 132 | // This path renderer can draw fill styles, and can do screenspace antialiasing via a |
| 133 | // one-pixel coverage ramp. It can do convex and concave paths, but we'll leave the convex |
| 134 | // ones to simpler algorithms. We pass on paths that have styles, though they may come back |
Chris Dalton | 09e5689 | 2019-03-13 00:22:01 -0600 | [diff] [blame] | 135 | // around after applying the styling information to the geometry to create a filled path. |
Chris Dalton | e5ede4b | 2017-09-07 18:33:08 +0000 | [diff] [blame] | 136 | if (!args.fShape->style().isSimpleFill() || args.fShape->knownToBeConvex()) { |
Chris Dalton | 5ed4423 | 2017-09-07 13:22:46 -0600 | [diff] [blame] | 137 | return CanDrawPath::kNo; |
senorblanco | f57372d | 2016-08-31 10:36:19 -0700 | [diff] [blame] | 138 | } |
Chris Dalton | 6ce447a | 2019-06-23 18:07:38 -0600 | [diff] [blame] | 139 | switch (args.fAAType) { |
| 140 | case GrAAType::kNone: |
| 141 | case GrAAType::kMSAA: |
| 142 | // Prefer MSAA, if any antialiasing. In the non-analytic-AA case, We skip paths that |
| 143 | // don't have a key since the real advantage of this path renderer comes from caching |
| 144 | // the tessellated geometry. |
| 145 | if (!args.fShape->hasUnstyledKey()) { |
| 146 | return CanDrawPath::kNo; |
| 147 | } |
| 148 | break; |
| 149 | case GrAAType::kCoverage: |
| 150 | // Use analytic AA if we don't have MSAA. In this case, we do not cache, so we accept |
| 151 | // paths without keys. |
| 152 | SkPath path; |
| 153 | args.fShape->asPath(&path); |
| 154 | if (path.countVerbs() > fMaxVerbCount) { |
| 155 | return CanDrawPath::kNo; |
| 156 | } |
| 157 | break; |
senorblanco | f57372d | 2016-08-31 10:36:19 -0700 | [diff] [blame] | 158 | } |
Chris Dalton | 5ed4423 | 2017-09-07 13:22:46 -0600 | [diff] [blame] | 159 | return CanDrawPath::kYes; |
senorblanco | d6ed19c | 2015-02-26 06:58:17 -0800 | [diff] [blame] | 160 | } |
| 161 | |
Brian Salomon | 9530f7e | 2017-07-11 09:03:10 -0400 | [diff] [blame] | 162 | namespace { |
| 163 | |
Chris Dalton | 17dc418 | 2020-03-25 16:18:16 -0600 | [diff] [blame] | 164 | class TriangulatingPathOp final : public GrMeshDrawOp { |
Brian Salomon | 9530f7e | 2017-07-11 09:03:10 -0400 | [diff] [blame] | 165 | private: |
| 166 | using Helper = GrSimpleMeshDrawOpHelperWithStencil; |
| 167 | |
senorblanco | 9ba3972 | 2015-03-05 07:13:42 -0800 | [diff] [blame] | 168 | public: |
Brian Salomon | 25a8809 | 2016-12-01 09:36:50 -0500 | [diff] [blame] | 169 | DEFINE_OP_CLASS_ID |
senorblanco | 9ba3972 | 2015-03-05 07:13:42 -0800 | [diff] [blame] | 170 | |
Robert Phillips | b97da53 | 2019-02-12 15:24:12 -0500 | [diff] [blame] | 171 | static std::unique_ptr<GrDrawOp> Make(GrRecordingContext* context, |
Robert Phillips | 7c525e6 | 2018-06-12 10:11:12 -0400 | [diff] [blame] | 172 | GrPaint&& paint, |
Brian Salomon | 9530f7e | 2017-07-11 09:03:10 -0400 | [diff] [blame] | 173 | const GrShape& shape, |
| 174 | const SkMatrix& viewMatrix, |
| 175 | SkIRect devClipBounds, |
| 176 | GrAAType aaType, |
| 177 | const GrUserStencilSettings* stencilSettings) { |
Chris Dalton | 17dc418 | 2020-03-25 16:18:16 -0600 | [diff] [blame] | 178 | return Helper::FactoryHelper<TriangulatingPathOp>(context, std::move(paint), shape, |
| 179 | viewMatrix, devClipBounds, aaType, |
| 180 | stencilSettings); |
senorblanco | 9ba3972 | 2015-03-05 07:13:42 -0800 | [diff] [blame] | 181 | } |
| 182 | |
Chris Dalton | 17dc418 | 2020-03-25 16:18:16 -0600 | [diff] [blame] | 183 | const char* name() const override { return "TriangulatingPathOp"; } |
senorblanco | 9ba3972 | 2015-03-05 07:13:42 -0800 | [diff] [blame] | 184 | |
Chris Dalton | 1706cbf | 2019-05-21 19:35:29 -0600 | [diff] [blame] | 185 | void visitProxies(const VisitProxyFunc& func) const override { |
Robert Phillips | 740d34f | 2020-03-11 09:36:13 -0400 | [diff] [blame] | 186 | if (fProgramInfo) { |
Chris Dalton | be45742 | 2020-03-16 18:05:03 -0600 | [diff] [blame] | 187 | fProgramInfo->visitFPProxies(func); |
Robert Phillips | 740d34f | 2020-03-11 09:36:13 -0400 | [diff] [blame] | 188 | } else { |
| 189 | fHelper.visitProxies(func); |
| 190 | } |
Robert Phillips | b493eeb | 2017-09-13 13:10:52 -0400 | [diff] [blame] | 191 | } |
| 192 | |
Brian Osman | 9a390ac | 2018-11-12 09:47:48 -0500 | [diff] [blame] | 193 | #ifdef SK_DEBUG |
Brian Salomon | 7c3e718 | 2016-12-01 09:35:30 -0500 | [diff] [blame] | 194 | SkString dumpInfo() const override { |
| 195 | SkString string; |
Brian Osman | cf86085 | 2018-10-31 14:04:39 -0400 | [diff] [blame] | 196 | string.appendf("Color 0x%08x, aa: %d\n", fColor.toBytes_RGBA(), fAntiAlias); |
Brian Salomon | 9530f7e | 2017-07-11 09:03:10 -0400 | [diff] [blame] | 197 | string += fHelper.dumpInfo(); |
| 198 | string += INHERITED::dumpInfo(); |
Brian Salomon | 7c3e718 | 2016-12-01 09:35:30 -0500 | [diff] [blame] | 199 | return string; |
| 200 | } |
Brian Osman | 9a390ac | 2018-11-12 09:47:48 -0500 | [diff] [blame] | 201 | #endif |
Brian Salomon | 7c3e718 | 2016-12-01 09:35:30 -0500 | [diff] [blame] | 202 | |
Chris Dalton | 17dc418 | 2020-03-25 16:18:16 -0600 | [diff] [blame] | 203 | TriangulatingPathOp(Helper::MakeArgs helperArgs, |
| 204 | const SkPMColor4f& color, |
| 205 | const GrShape& shape, |
| 206 | const SkMatrix& viewMatrix, |
| 207 | const SkIRect& devClipBounds, |
| 208 | GrAAType aaType, |
| 209 | const GrUserStencilSettings* stencilSettings) |
Brian Salomon | 9530f7e | 2017-07-11 09:03:10 -0400 | [diff] [blame] | 210 | : INHERITED(ClassID()) |
| 211 | , fHelper(helperArgs, aaType, stencilSettings) |
| 212 | , fColor(color) |
| 213 | , fShape(shape) |
| 214 | , fViewMatrix(viewMatrix) |
| 215 | , fDevClipBounds(devClipBounds) |
| 216 | , fAntiAlias(GrAAType::kCoverage == aaType) { |
| 217 | SkRect devBounds; |
| 218 | viewMatrix.mapRect(&devBounds, shape.bounds()); |
| 219 | if (shape.inverseFilled()) { |
| 220 | // Because the clip bounds are used to add a contour for inverse fills, they must also |
| 221 | // include the path bounds. |
| 222 | devBounds.join(SkRect::Make(fDevClipBounds)); |
| 223 | } |
Greg Daniel | 5faf474 | 2019-10-01 15:14:44 -0400 | [diff] [blame] | 224 | this->setBounds(devBounds, HasAABloat::kNo, IsHairline::kNo); |
Brian Salomon | 9530f7e | 2017-07-11 09:03:10 -0400 | [diff] [blame] | 225 | } |
| 226 | |
| 227 | FixedFunctionFlags fixedFunctionFlags() const override { return fHelper.fixedFunctionFlags(); } |
| 228 | |
Chris Dalton | 6ce447a | 2019-06-23 18:07:38 -0600 | [diff] [blame] | 229 | GrProcessorSet::Analysis finalize( |
| 230 | const GrCaps& caps, const GrAppliedClip* clip, bool hasMixedSampledCoverage, |
| 231 | GrClampType clampType) override { |
Brian Salomon | 9530f7e | 2017-07-11 09:03:10 -0400 | [diff] [blame] | 232 | GrProcessorAnalysisCoverage coverage = fAntiAlias |
| 233 | ? GrProcessorAnalysisCoverage::kSingleChannel |
| 234 | : GrProcessorAnalysisCoverage::kNone; |
Brian Osman | 8fa7ab4 | 2019-03-18 10:22:42 -0400 | [diff] [blame] | 235 | // This Op uses uniform (not vertex) color, so doesn't need to track wide color. |
| 236 | return fHelper.finalizeProcessors( |
Chris Dalton | 6ce447a | 2019-06-23 18:07:38 -0600 | [diff] [blame] | 237 | caps, clip, hasMixedSampledCoverage, clampType, coverage, &fColor, nullptr); |
Brian Salomon | 9530f7e | 2017-07-11 09:03:10 -0400 | [diff] [blame] | 238 | } |
| 239 | |
Brian Salomon | 92aee3d | 2016-12-21 09:20:25 -0500 | [diff] [blame] | 240 | private: |
senorblanco | f57372d | 2016-08-31 10:36:19 -0700 | [diff] [blame] | 241 | SkPath getPath() const { |
| 242 | SkASSERT(!fShape.style().applies()); |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame] | 243 | SkPath path; |
| 244 | fShape.asPath(&path); |
senorblanco | f57372d | 2016-08-31 10:36:19 -0700 | [diff] [blame] | 245 | return path; |
| 246 | } |
| 247 | |
Robert Phillips | 740d34f | 2020-03-11 09:36:13 -0400 | [diff] [blame] | 248 | void draw(Target* target) { |
senorblanco | f57372d | 2016-08-31 10:36:19 -0700 | [diff] [blame] | 249 | SkASSERT(!fAntiAlias); |
| 250 | GrResourceProvider* rp = target->resourceProvider(); |
| 251 | bool inverseFill = fShape.inverseFilled(); |
senorblanco | 84cd621 | 2015-08-04 10:01:58 -0700 | [diff] [blame] | 252 | // construct a cache key from the path's genID and the view matrix |
| 253 | static const GrUniqueKey::Domain kDomain = GrUniqueKey::GenerateDomain(); |
| 254 | GrUniqueKey key; |
senorblanco | f57372d | 2016-08-31 10:36:19 -0700 | [diff] [blame] | 255 | static constexpr int kClipBoundsCnt = sizeof(fDevClipBounds) / sizeof(uint32_t); |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame] | 256 | int shapeKeyDataCnt = fShape.unstyledKeySize(); |
| 257 | SkASSERT(shapeKeyDataCnt >= 0); |
Derek Sollenberger | cf6da8c | 2018-03-29 13:40:02 -0400 | [diff] [blame] | 258 | GrUniqueKey::Builder builder(&key, kDomain, shapeKeyDataCnt + kClipBoundsCnt, "Path"); |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame] | 259 | fShape.writeUnstyledKey(&builder[0]); |
| 260 | // For inverse fills, the tessellation is dependent on clip bounds. |
| 261 | if (inverseFill) { |
senorblanco | f57372d | 2016-08-31 10:36:19 -0700 | [diff] [blame] | 262 | memcpy(&builder[shapeKeyDataCnt], &fDevClipBounds, sizeof(fDevClipBounds)); |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame] | 263 | } else { |
senorblanco | f57372d | 2016-08-31 10:36:19 -0700 | [diff] [blame] | 264 | memset(&builder[shapeKeyDataCnt], 0, sizeof(fDevClipBounds)); |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame] | 265 | } |
| 266 | builder.finish(); |
Brian Salomon | dbf7072 | 2019-02-07 11:31:24 -0500 | [diff] [blame] | 267 | sk_sp<GrGpuBuffer> cachedVertexBuffer(rp->findByUniqueKey<GrGpuBuffer>(key)); |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame] | 268 | int actualCount; |
senorblanco | f57372d | 2016-08-31 10:36:19 -0700 | [diff] [blame] | 269 | SkScalar tol = GrPathUtils::kDefaultTolerance; |
| 270 | tol = GrPathUtils::scaleToleranceToSrc(tol, fViewMatrix, fShape.bounds()); |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame] | 271 | if (cache_match(cachedVertexBuffer.get(), tol, &actualCount)) { |
Robert Phillips | 740d34f | 2020-03-11 09:36:13 -0400 | [diff] [blame] | 272 | this->createMesh(target, std::move(cachedVertexBuffer), 0, actualCount); |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame] | 273 | return; |
senorblanco | 84cd621 | 2015-08-04 10:01:58 -0700 | [diff] [blame] | 274 | } |
| 275 | |
senorblanco | f57372d | 2016-08-31 10:36:19 -0700 | [diff] [blame] | 276 | SkRect clipBounds = SkRect::Make(fDevClipBounds); |
| 277 | |
| 278 | SkMatrix vmi; |
| 279 | if (!fViewMatrix.invert(&vmi)) { |
| 280 | return; |
| 281 | } |
| 282 | vmi.mapRect(&clipBounds); |
senorblanco | 6599eff | 2016-03-10 08:38:45 -0800 | [diff] [blame] | 283 | bool isLinear; |
| 284 | bool canMapVB = GrCaps::kNone_MapFlags != target->caps().mapBufferFlags(); |
Chris Dalton | d081dce | 2020-01-23 12:09:04 -0700 | [diff] [blame] | 285 | StaticVertexAllocator allocator(rp, canMapVB); |
Chris Dalton | 17dc418 | 2020-03-25 16:18:16 -0600 | [diff] [blame] | 286 | int count = GrTriangulator::PathToTriangles(getPath(), tol, clipBounds, &allocator, |
| 287 | GrTriangulator::Mode::kNormal, &isLinear); |
senorblanco | 6599eff | 2016-03-10 08:38:45 -0800 | [diff] [blame] | 288 | if (count == 0) { |
| 289 | return; |
| 290 | } |
Brian Salomon | dbf7072 | 2019-02-07 11:31:24 -0500 | [diff] [blame] | 291 | sk_sp<GrGpuBuffer> vb = allocator.detachVertexBuffer(); |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame] | 292 | TessInfo info; |
| 293 | info.fTolerance = isLinear ? 0 : tol; |
| 294 | info.fCount = count; |
Brian Salomon | 99a813c | 2020-03-02 12:50:47 -0500 | [diff] [blame] | 295 | fShape.addGenIDChangeListener( |
| 296 | sk_make_sp<UniqueKeyInvalidator>(key, target->contextUniqueID())); |
Brian Salomon | 12d2264 | 2019-01-29 14:38:50 -0500 | [diff] [blame] | 297 | key.setCustomData(SkData::MakeWithCopy(&info, sizeof(info))); |
| 298 | rp->assignUniqueKeyToResource(key, vb.get()); |
| 299 | |
Robert Phillips | 740d34f | 2020-03-11 09:36:13 -0400 | [diff] [blame] | 300 | this->createMesh(target, std::move(vb), 0, count); |
senorblanco | 6599eff | 2016-03-10 08:38:45 -0800 | [diff] [blame] | 301 | } |
| 302 | |
Robert Phillips | 740d34f | 2020-03-11 09:36:13 -0400 | [diff] [blame] | 303 | void drawAA(Target* target) { |
senorblanco | f57372d | 2016-08-31 10:36:19 -0700 | [diff] [blame] | 304 | SkASSERT(fAntiAlias); |
| 305 | SkPath path = getPath(); |
| 306 | if (path.isEmpty()) { |
| 307 | return; |
| 308 | } |
| 309 | SkRect clipBounds = SkRect::Make(fDevClipBounds); |
| 310 | path.transform(fViewMatrix); |
| 311 | SkScalar tol = GrPathUtils::kDefaultTolerance; |
Chris Dalton | d081dce | 2020-01-23 12:09:04 -0700 | [diff] [blame] | 312 | sk_sp<const GrBuffer> vertexBuffer; |
| 313 | int firstVertex; |
senorblanco | f57372d | 2016-08-31 10:36:19 -0700 | [diff] [blame] | 314 | bool isLinear; |
Chris Dalton | d081dce | 2020-01-23 12:09:04 -0700 | [diff] [blame] | 315 | GrEagerDynamicVertexAllocator allocator(target, &vertexBuffer, &firstVertex); |
Chris Dalton | 17dc418 | 2020-03-25 16:18:16 -0600 | [diff] [blame] | 316 | int count = GrTriangulator::PathToTriangles(path, tol, clipBounds, &allocator, |
| 317 | GrTriangulator::Mode::kEdgeAntialias, &isLinear); |
senorblanco | f57372d | 2016-08-31 10:36:19 -0700 | [diff] [blame] | 318 | if (count == 0) { |
| 319 | return; |
| 320 | } |
Robert Phillips | 740d34f | 2020-03-11 09:36:13 -0400 | [diff] [blame] | 321 | this->createMesh(target, std::move(vertexBuffer), firstVertex, count); |
senorblanco | f57372d | 2016-08-31 10:36:19 -0700 | [diff] [blame] | 322 | } |
| 323 | |
Robert Phillips | 2669a7b | 2020-03-12 12:07:19 -0400 | [diff] [blame] | 324 | GrProgramInfo* programInfo() override { return fProgramInfo; } |
| 325 | |
Robert Phillips | 4133dc4 | 2020-03-11 15:55:55 -0400 | [diff] [blame] | 326 | void onCreateProgramInfo(const GrCaps* caps, |
| 327 | SkArenaAlloc* arena, |
Brian Salomon | 8afde5f | 2020-04-01 16:22:00 -0400 | [diff] [blame^] | 328 | const GrSurfaceProxyView* writeView, |
Robert Phillips | 4133dc4 | 2020-03-11 15:55:55 -0400 | [diff] [blame] | 329 | GrAppliedClip&& appliedClip, |
| 330 | const GrXferProcessor::DstProxyView& dstProxyView) override { |
Robert Phillips | 7cd0bfe | 2019-11-20 16:08:10 -0500 | [diff] [blame] | 331 | GrGeometryProcessor* gp; |
joshualitt | df0c557 | 2015-08-03 11:35:28 -0700 | [diff] [blame] | 332 | { |
| 333 | using namespace GrDefaultGeoProcFactory; |
| 334 | |
| 335 | Color color(fColor); |
Brian Salomon | 9530f7e | 2017-07-11 09:03:10 -0400 | [diff] [blame] | 336 | LocalCoords::Type localCoordsType = fHelper.usesLocalCoords() |
Brian Salomon | 8c852be | 2017-01-04 10:44:42 -0500 | [diff] [blame] | 337 | ? LocalCoords::kUsePosition_Type |
| 338 | : LocalCoords::kUnused_Type; |
joshualitt | df0c557 | 2015-08-03 11:35:28 -0700 | [diff] [blame] | 339 | Coverage::Type coverageType; |
senorblanco | f57372d | 2016-08-31 10:36:19 -0700 | [diff] [blame] | 340 | if (fAntiAlias) { |
Brian Osman | 605c6d5 | 2019-03-15 12:10:35 -0400 | [diff] [blame] | 341 | if (fHelper.compatibleWithCoverageAsAlpha()) { |
Brian Osman | 80879d4 | 2019-01-07 16:15:27 -0500 | [diff] [blame] | 342 | coverageType = Coverage::kAttributeTweakAlpha_Type; |
senorblanco | f57372d | 2016-08-31 10:36:19 -0700 | [diff] [blame] | 343 | } else { |
| 344 | coverageType = Coverage::kAttribute_Type; |
| 345 | } |
Brian Salomon | 8c852be | 2017-01-04 10:44:42 -0500 | [diff] [blame] | 346 | } else { |
joshualitt | df0c557 | 2015-08-03 11:35:28 -0700 | [diff] [blame] | 347 | coverageType = Coverage::kSolid_Type; |
joshualitt | df0c557 | 2015-08-03 11:35:28 -0700 | [diff] [blame] | 348 | } |
senorblanco | f57372d | 2016-08-31 10:36:19 -0700 | [diff] [blame] | 349 | if (fAntiAlias) { |
Brian Osman | f0aee74 | 2020-03-12 09:28:44 -0400 | [diff] [blame] | 350 | gp = GrDefaultGeoProcFactory::MakeForDeviceSpace(arena, color, coverageType, |
Brian Salomon | 8c852be | 2017-01-04 10:44:42 -0500 | [diff] [blame] | 351 | localCoordsType, fViewMatrix); |
senorblanco | f57372d | 2016-08-31 10:36:19 -0700 | [diff] [blame] | 352 | } else { |
Brian Osman | f0aee74 | 2020-03-12 09:28:44 -0400 | [diff] [blame] | 353 | gp = GrDefaultGeoProcFactory::Make(arena, color, coverageType, localCoordsType, |
Brian Salomon | 8c852be | 2017-01-04 10:44:42 -0500 | [diff] [blame] | 354 | fViewMatrix); |
senorblanco | f57372d | 2016-08-31 10:36:19 -0700 | [diff] [blame] | 355 | } |
joshualitt | df0c557 | 2015-08-03 11:35:28 -0700 | [diff] [blame] | 356 | } |
Robert Phillips | 7cd0bfe | 2019-11-20 16:08:10 -0500 | [diff] [blame] | 357 | if (!gp) { |
Robert Phillips | 4133dc4 | 2020-03-11 15:55:55 -0400 | [diff] [blame] | 358 | return; |
Stephen White | cc70083 | 2017-02-15 11:45:16 -0500 | [diff] [blame] | 359 | } |
Robert Phillips | 740d34f | 2020-03-11 09:36:13 -0400 | [diff] [blame] | 360 | |
Chris Dalton | dcc8c54 | 2020-01-28 17:55:56 -0700 | [diff] [blame] | 361 | #ifdef SK_DEBUG |
Chris Dalton | 17dc418 | 2020-03-25 16:18:16 -0600 | [diff] [blame] | 362 | auto mode = (fAntiAlias) ? GrTriangulator::Mode::kEdgeAntialias |
| 363 | : GrTriangulator::Mode::kNormal; |
| 364 | SkASSERT(GrTriangulator::GetVertexStride(mode) == gp->vertexStride()); |
Chris Dalton | dcc8c54 | 2020-01-28 17:55:56 -0700 | [diff] [blame] | 365 | #endif |
senorblanco | 84cd621 | 2015-08-04 10:01:58 -0700 | [diff] [blame] | 366 | |
Chris Dalton | 17dc418 | 2020-03-25 16:18:16 -0600 | [diff] [blame] | 367 | GrPrimitiveType primitiveType = TRIANGULATOR_WIREFRAME ? GrPrimitiveType::kLines |
| 368 | : GrPrimitiveType::kTriangles; |
Robert Phillips | e94cdd2 | 2019-11-04 14:15:58 -0500 | [diff] [blame] | 369 | |
Brian Salomon | 8afde5f | 2020-04-01 16:22:00 -0400 | [diff] [blame^] | 370 | fProgramInfo = fHelper.createProgramInfoWithStencil(caps, arena, writeView, |
Robert Phillips | 4133dc4 | 2020-03-11 15:55:55 -0400 | [diff] [blame] | 371 | std::move(appliedClip), dstProxyView, |
| 372 | gp, primitiveType); |
Robert Phillips | 740d34f | 2020-03-11 09:36:13 -0400 | [diff] [blame] | 373 | } |
| 374 | |
Robert Phillips | 740d34f | 2020-03-11 09:36:13 -0400 | [diff] [blame] | 375 | void onPrepareDraws(Target* target) override { |
| 376 | if (fAntiAlias) { |
| 377 | this->drawAA(target); |
| 378 | } else { |
| 379 | this->draw(target); |
| 380 | } |
| 381 | } |
| 382 | |
| 383 | void createMesh(Target* target, sk_sp<const GrBuffer> vb, int firstVertex, int count) { |
| 384 | fMesh = target->allocMesh(); |
Chris Dalton | 37c7bdd | 2020-03-13 09:21:12 -0600 | [diff] [blame] | 385 | fMesh->set(std::move(vb), count, firstVertex); |
Chris Dalton | 07cdcfc9 | 2019-02-26 11:13:22 -0700 | [diff] [blame] | 386 | } |
| 387 | |
| 388 | void onExecute(GrOpFlushState* flushState, const SkRect& chainBounds) override { |
Robert Phillips | 740d34f | 2020-03-11 09:36:13 -0400 | [diff] [blame] | 389 | if (!fProgramInfo) { |
Robert Phillips | 4133dc4 | 2020-03-11 15:55:55 -0400 | [diff] [blame] | 390 | this->createProgramInfo(flushState); |
Robert Phillips | 740d34f | 2020-03-11 09:36:13 -0400 | [diff] [blame] | 391 | } |
Robert Phillips | 3968fcb | 2019-12-05 16:40:31 -0500 | [diff] [blame] | 392 | |
Robert Phillips | 740d34f | 2020-03-11 09:36:13 -0400 | [diff] [blame] | 393 | if (!fProgramInfo || !fMesh) { |
| 394 | return; |
| 395 | } |
| 396 | |
Chris Dalton | 765ed36 | 2020-03-16 17:34:44 -0600 | [diff] [blame] | 397 | flushState->bindPipelineAndScissorClip(*fProgramInfo, chainBounds); |
| 398 | flushState->bindTextures(fProgramInfo->primProc(), nullptr, fProgramInfo->pipeline()); |
| 399 | flushState->drawMesh(*fMesh); |
senorblanco | 9ba3972 | 2015-03-05 07:13:42 -0800 | [diff] [blame] | 400 | } |
| 401 | |
Robert Phillips | 740d34f | 2020-03-11 09:36:13 -0400 | [diff] [blame] | 402 | Helper fHelper; |
| 403 | SkPMColor4f fColor; |
| 404 | GrShape fShape; |
| 405 | SkMatrix fViewMatrix; |
| 406 | SkIRect fDevClipBounds; |
| 407 | bool fAntiAlias; |
| 408 | |
Chris Dalton | eb694b7 | 2020-03-16 09:25:50 -0600 | [diff] [blame] | 409 | GrSimpleMesh* fMesh = nullptr; |
Robert Phillips | 740d34f | 2020-03-11 09:36:13 -0400 | [diff] [blame] | 410 | GrProgramInfo* fProgramInfo = nullptr; |
reed | 1b55a96 | 2015-09-17 20:16:13 -0700 | [diff] [blame] | 411 | |
Brian Salomon | 9530f7e | 2017-07-11 09:03:10 -0400 | [diff] [blame] | 412 | typedef GrMeshDrawOp INHERITED; |
senorblanco | 9ba3972 | 2015-03-05 07:13:42 -0800 | [diff] [blame] | 413 | }; |
| 414 | |
Brian Salomon | 9530f7e | 2017-07-11 09:03:10 -0400 | [diff] [blame] | 415 | } // anonymous namespace |
| 416 | |
Chris Dalton | 17dc418 | 2020-03-25 16:18:16 -0600 | [diff] [blame] | 417 | bool GrTriangulatingPathRenderer::onDrawPath(const DrawPathArgs& args) { |
Brian Osman | 1105224 | 2016-10-27 14:47:55 -0400 | [diff] [blame] | 418 | GR_AUDIT_TRAIL_AUTO_FRAME(args.fRenderTargetContext->auditTrail(), |
Chris Dalton | 17dc418 | 2020-03-25 16:18:16 -0600 | [diff] [blame] | 419 | "GrTriangulatingPathRenderer::onDrawPath"); |
senorblanco | d6ed19c | 2015-02-26 06:58:17 -0800 | [diff] [blame] | 420 | SkIRect clipBoundsI; |
Robert Phillips | 784b7bf | 2016-12-09 13:35:02 -0500 | [diff] [blame] | 421 | args.fClip->getConservativeBounds(args.fRenderTargetContext->width(), |
| 422 | args.fRenderTargetContext->height(), |
robertphillips | 976f5f0 | 2016-06-03 10:59:20 -0700 | [diff] [blame] | 423 | &clipBoundsI); |
Chris Dalton | 17dc418 | 2020-03-25 16:18:16 -0600 | [diff] [blame] | 424 | std::unique_ptr<GrDrawOp> op = TriangulatingPathOp::Make( |
Chris Dalton | 09e5689 | 2019-03-13 00:22:01 -0600 | [diff] [blame] | 425 | args.fContext, std::move(args.fPaint), *args.fShape, *args.fViewMatrix, clipBoundsI, |
Chris Dalton | 6ce447a | 2019-06-23 18:07:38 -0600 | [diff] [blame] | 426 | args.fAAType, args.fUserStencilSettings); |
Brian Salomon | 9530f7e | 2017-07-11 09:03:10 -0400 | [diff] [blame] | 427 | args.fRenderTargetContext->addDrawOp(*args.fClip, std::move(op)); |
senorblanco | d6ed19c | 2015-02-26 06:58:17 -0800 | [diff] [blame] | 428 | return true; |
| 429 | } |
joshualitt | 2fbd406 | 2015-05-07 13:06:41 -0700 | [diff] [blame] | 430 | |
| 431 | /////////////////////////////////////////////////////////////////////////////////////////////////// |
| 432 | |
Hal Canary | 6f6961e | 2017-01-31 13:50:44 -0500 | [diff] [blame] | 433 | #if GR_TEST_UTILS |
joshualitt | 2fbd406 | 2015-05-07 13:06:41 -0700 | [diff] [blame] | 434 | |
Chris Dalton | 17dc418 | 2020-03-25 16:18:16 -0600 | [diff] [blame] | 435 | GR_DRAW_OP_TEST_DEFINE(TriangulatingPathOp) { |
joshualitt | 2fbd406 | 2015-05-07 13:06:41 -0700 | [diff] [blame] | 436 | SkMatrix viewMatrix = GrTest::TestMatrixInvertible(random); |
| 437 | SkPath path = GrTest::TestPath(random); |
bsalomon | d3030ac | 2016-09-01 07:20:29 -0700 | [diff] [blame] | 438 | SkIRect devClipBounds = SkIRect::MakeLTRB( |
senorblanco | f57372d | 2016-08-31 10:36:19 -0700 | [diff] [blame] | 439 | random->nextU(), random->nextU(), random->nextU(), random->nextU()); |
bsalomon | d3030ac | 2016-09-01 07:20:29 -0700 | [diff] [blame] | 440 | devClipBounds.sort(); |
Brian Salomon | 9530f7e | 2017-07-11 09:03:10 -0400 | [diff] [blame] | 441 | static constexpr GrAAType kAATypes[] = {GrAAType::kNone, GrAAType::kMSAA, GrAAType::kCoverage}; |
| 442 | GrAAType aaType; |
| 443 | do { |
| 444 | aaType = kAATypes[random->nextULessThan(SK_ARRAY_COUNT(kAATypes))]; |
Chris Dalton | 6ce447a | 2019-06-23 18:07:38 -0600 | [diff] [blame] | 445 | } while(GrAAType::kMSAA == aaType && numSamples <= 1); |
bsalomon | 6663acf | 2016-05-10 09:14:17 -0700 | [diff] [blame] | 446 | GrStyle style; |
| 447 | do { |
| 448 | GrTest::TestStyle(random, &style); |
senorblanco | f57372d | 2016-08-31 10:36:19 -0700 | [diff] [blame] | 449 | } while (!style.isSimpleFill()); |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame] | 450 | GrShape shape(path, style); |
Chris Dalton | 17dc418 | 2020-03-25 16:18:16 -0600 | [diff] [blame] | 451 | return TriangulatingPathOp::Make(context, std::move(paint), shape, viewMatrix, devClipBounds, |
| 452 | aaType, GrGetRandomStencil(random, context)); |
joshualitt | 2fbd406 | 2015-05-07 13:06:41 -0700 | [diff] [blame] | 453 | } |
| 454 | |
| 455 | #endif |