jvanverth | fa38a30 | 2014-10-06 05:59:05 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2014 Google Inc. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license that can be |
| 5 | * found in the LICENSE file. |
| 6 | */ |
| 7 | |
| 8 | #include "GrAADistanceFieldPathRenderer.h" |
| 9 | |
bsalomon | 7539856 | 2015-08-17 12:55:38 -0700 | [diff] [blame] | 10 | #include "GrBatchFlushState.h" |
joshualitt | 21279c7 | 2015-05-11 07:21:37 -0700 | [diff] [blame] | 11 | #include "GrBatchTest.h" |
cdalton | 397536c | 2016-03-25 12:15:03 -0700 | [diff] [blame] | 12 | #include "GrBuffer.h" |
jvanverth | fa38a30 | 2014-10-06 05:59:05 -0700 | [diff] [blame] | 13 | #include "GrContext.h" |
egdaniel | 8dd688b | 2015-01-22 10:16:09 -0800 | [diff] [blame] | 14 | #include "GrPipelineBuilder.h" |
bsalomon | b5238a7 | 2015-05-05 07:49:49 -0700 | [diff] [blame] | 15 | #include "GrResourceProvider.h" |
jvanverth | fa38a30 | 2014-10-06 05:59:05 -0700 | [diff] [blame] | 16 | #include "GrSurfacePriv.h" |
| 17 | #include "GrSWMaskHelper.h" |
| 18 | #include "GrTexturePriv.h" |
bsalomon | 16b9913 | 2015-08-13 14:55:50 -0700 | [diff] [blame] | 19 | #include "batches/GrVertexBatch.h" |
jvanverth | 8ed3b9a | 2015-04-09 08:00:49 -0700 | [diff] [blame] | 20 | #include "effects/GrDistanceFieldGeoProc.h" |
jvanverth | fa38a30 | 2014-10-06 05:59:05 -0700 | [diff] [blame] | 21 | |
| 22 | #include "SkDistanceFieldGen.h" |
| 23 | #include "SkRTConf.h" |
| 24 | |
jvanverth | fb1e2fc | 2015-09-15 13:11:11 -0700 | [diff] [blame] | 25 | #define ATLAS_TEXTURE_WIDTH 2048 |
jvanverth | b61283f | 2014-10-30 05:57:21 -0700 | [diff] [blame] | 26 | #define ATLAS_TEXTURE_HEIGHT 2048 |
jvanverth | fb1e2fc | 2015-09-15 13:11:11 -0700 | [diff] [blame] | 27 | #define PLOT_WIDTH 512 |
reed | e4ef1ca | 2015-02-17 18:38:38 -0800 | [diff] [blame] | 28 | #define PLOT_HEIGHT 256 |
jvanverth | fa38a30 | 2014-10-06 05:59:05 -0700 | [diff] [blame] | 29 | |
| 30 | #define NUM_PLOTS_X (ATLAS_TEXTURE_WIDTH / PLOT_WIDTH) |
| 31 | #define NUM_PLOTS_Y (ATLAS_TEXTURE_HEIGHT / PLOT_HEIGHT) |
| 32 | |
jvanverth | b3eb687 | 2014-10-24 07:12:51 -0700 | [diff] [blame] | 33 | #ifdef DF_PATH_TRACKING |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame^] | 34 | static int g_NumCachedShapes = 0; |
| 35 | static int g_NumFreedShapes = 0; |
jvanverth | b3eb687 | 2014-10-24 07:12:51 -0700 | [diff] [blame] | 36 | #endif |
| 37 | |
jvanverth | b61283f | 2014-10-30 05:57:21 -0700 | [diff] [blame] | 38 | // mip levels |
| 39 | static const int kSmallMIP = 32; |
jvanverth | 512e437 | 2015-11-23 11:50:02 -0800 | [diff] [blame] | 40 | static const int kMediumMIP = 73; |
jvanverth | fb1e2fc | 2015-09-15 13:11:11 -0700 | [diff] [blame] | 41 | static const int kLargeMIP = 162; |
jvanverth | b61283f | 2014-10-30 05:57:21 -0700 | [diff] [blame] | 42 | |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 43 | // Callback to clear out internal path cache when eviction occurs |
| 44 | void GrAADistanceFieldPathRenderer::HandleEviction(GrBatchAtlas::AtlasID id, void* pr) { |
| 45 | GrAADistanceFieldPathRenderer* dfpr = (GrAADistanceFieldPathRenderer*)pr; |
| 46 | // remove any paths that use this plot |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame^] | 47 | ShapeDataList::Iter iter; |
| 48 | iter.init(dfpr->fShapeList, ShapeDataList::Iter::kHead_IterStart); |
| 49 | ShapeData* shapeData; |
| 50 | while ((shapeData = iter.get())) { |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 51 | iter.next(); |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame^] | 52 | if (id == shapeData->fID) { |
| 53 | dfpr->fShapeCache.remove(shapeData->fKey); |
| 54 | dfpr->fShapeList.remove(shapeData); |
| 55 | delete shapeData; |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 56 | #ifdef DF_PATH_TRACKING |
| 57 | ++g_NumFreedPaths; |
| 58 | #endif |
| 59 | } |
| 60 | } |
| 61 | } |
| 62 | |
jvanverth | fa38a30 | 2014-10-06 05:59:05 -0700 | [diff] [blame] | 63 | //////////////////////////////////////////////////////////////////////////////// |
halcanary | 96fcdcc | 2015-08-27 07:41:13 -0700 | [diff] [blame] | 64 | GrAADistanceFieldPathRenderer::GrAADistanceFieldPathRenderer() : fAtlas(nullptr) {} |
jvanverth | 6d22eca | 2014-10-28 11:10:48 -0700 | [diff] [blame] | 65 | |
jvanverth | fa38a30 | 2014-10-06 05:59:05 -0700 | [diff] [blame] | 66 | GrAADistanceFieldPathRenderer::~GrAADistanceFieldPathRenderer() { |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame^] | 67 | ShapeDataList::Iter iter; |
| 68 | iter.init(fShapeList, ShapeDataList::Iter::kHead_IterStart); |
| 69 | ShapeData* shapeData; |
| 70 | while ((shapeData = iter.get())) { |
jvanverth | fa38a30 | 2014-10-06 05:59:05 -0700 | [diff] [blame] | 71 | iter.next(); |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame^] | 72 | delete shapeData; |
jvanverth | fa38a30 | 2014-10-06 05:59:05 -0700 | [diff] [blame] | 73 | } |
halcanary | 385fe4d | 2015-08-26 13:07:48 -0700 | [diff] [blame] | 74 | delete fAtlas; |
jvanverth | b3eb687 | 2014-10-24 07:12:51 -0700 | [diff] [blame] | 75 | |
| 76 | #ifdef DF_PATH_TRACKING |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame^] | 77 | SkDebugf("Cached shapes: %d, freed shapes: %d\n", g_NumCachedShapes, g_NumFreedShapes); |
jvanverth | b3eb687 | 2014-10-24 07:12:51 -0700 | [diff] [blame] | 78 | #endif |
jvanverth | fa38a30 | 2014-10-06 05:59:05 -0700 | [diff] [blame] | 79 | } |
| 80 | |
| 81 | //////////////////////////////////////////////////////////////////////////////// |
bsalomon | 0aff2fa | 2015-07-31 06:48:27 -0700 | [diff] [blame] | 82 | bool GrAADistanceFieldPathRenderer::onCanDrawPath(const CanDrawPathArgs& args) const { |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame^] | 83 | if (!args.fShaderCaps->shaderDerivativeSupport()) { |
| 84 | return false; |
| 85 | } |
| 86 | // If the shape has no key then we won't get any reuse. |
| 87 | if (!args.fShape->hasUnstyledKey()) { |
| 88 | return false; |
| 89 | } |
| 90 | // This only supports filled paths, however, the caller may apply the style to make a filled |
| 91 | // path and try again. |
| 92 | if (!args.fShape->style().isSimpleFill()) { |
| 93 | return false; |
| 94 | } |
| 95 | // This does non-inverse antialiased fills. |
| 96 | if (!args.fAntiAlias) { |
bsalomon | 6663acf | 2016-05-10 09:14:17 -0700 | [diff] [blame] | 97 | return false; |
| 98 | } |
jvanverth | fa38a30 | 2014-10-06 05:59:05 -0700 | [diff] [blame] | 99 | // TODO: Support inverse fill |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame^] | 100 | if (!args.fShape->inverseFilled()) { |
jvanverth | fa38a30 | 2014-10-06 05:59:05 -0700 | [diff] [blame] | 101 | return false; |
| 102 | } |
jvanverth | b61283f | 2014-10-30 05:57:21 -0700 | [diff] [blame] | 103 | // currently don't support perspective |
bsalomon | 0aff2fa | 2015-07-31 06:48:27 -0700 | [diff] [blame] | 104 | if (args.fViewMatrix->hasPerspective()) { |
jvanverth | fa38a30 | 2014-10-06 05:59:05 -0700 | [diff] [blame] | 105 | return false; |
| 106 | } |
halcanary | 9d524f2 | 2016-03-29 09:03:52 -0700 | [diff] [blame] | 107 | |
jvanverth | 512e437 | 2015-11-23 11:50:02 -0800 | [diff] [blame] | 108 | // only support paths with bounds within kMediumMIP by kMediumMIP, |
| 109 | // scaled to have bounds within 2.0f*kLargeMIP by 2.0f*kLargeMIP |
jvanverth | b61283f | 2014-10-30 05:57:21 -0700 | [diff] [blame] | 110 | // the goal is to accelerate rendering of lots of small paths that may be scaling |
bsalomon | 0aff2fa | 2015-07-31 06:48:27 -0700 | [diff] [blame] | 111 | SkScalar maxScale = args.fViewMatrix->getMaxScale(); |
bsalomon | 6663acf | 2016-05-10 09:14:17 -0700 | [diff] [blame] | 112 | SkRect bounds; |
bsalomon | 8acedde | 2016-06-24 10:42:16 -0700 | [diff] [blame] | 113 | args.fShape->styledBounds(&bounds); |
bsalomon | 6663acf | 2016-05-10 09:14:17 -0700 | [diff] [blame] | 114 | SkScalar maxDim = SkMaxScalar(bounds.width(), bounds.height()); |
bsalomon | 6266dca | 2016-03-11 06:22:00 -0800 | [diff] [blame] | 115 | |
jvanverth | 512e437 | 2015-11-23 11:50:02 -0800 | [diff] [blame] | 116 | return maxDim <= kMediumMIP && maxDim * maxScale <= 2.0f*kLargeMIP; |
jvanverth | fa38a30 | 2014-10-06 05:59:05 -0700 | [diff] [blame] | 117 | } |
| 118 | |
jvanverth | fa38a30 | 2014-10-06 05:59:05 -0700 | [diff] [blame] | 119 | //////////////////////////////////////////////////////////////////////////////// |
| 120 | |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 121 | // padding around path bounds to allow for antialiased pixels |
| 122 | static const SkScalar kAntiAliasPad = 1.0f; |
| 123 | |
bsalomon | abd30f5 | 2015-08-13 13:34:48 -0700 | [diff] [blame] | 124 | class AADistanceFieldPathBatch : public GrVertexBatch { |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 125 | public: |
reed | 1b55a96 | 2015-09-17 20:16:13 -0700 | [diff] [blame] | 126 | DEFINE_BATCH_CLASS_ID |
| 127 | |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame^] | 128 | typedef GrAADistanceFieldPathRenderer::ShapeData ShapeData; |
| 129 | typedef SkTDynamicHash<ShapeData, ShapeData::Key> ShapeCache; |
| 130 | typedef GrAADistanceFieldPathRenderer::ShapeDataList ShapeDataList; |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 131 | |
| 132 | struct Geometry { |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame^] | 133 | GrShape fShape; |
joshualitt | 53f26aa | 2015-12-10 07:29:54 -0800 | [diff] [blame] | 134 | GrColor fColor; |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 135 | bool fAntiAlias; |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 136 | }; |
| 137 | |
joshualitt | 53f26aa | 2015-12-10 07:29:54 -0800 | [diff] [blame] | 138 | static GrDrawBatch* Create(const Geometry& geometry, const SkMatrix& viewMatrix, |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame^] | 139 | GrBatchAtlas* atlas, ShapeCache* shapeCache, |
| 140 | ShapeDataList* shapeList, bool gammaCorrect) { |
| 141 | return new AADistanceFieldPathBatch(geometry, viewMatrix, atlas, shapeCache, shapeList, |
brianosman | 0e3c554 | 2016-04-13 13:56:21 -0700 | [diff] [blame] | 142 | gammaCorrect); |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 143 | } |
| 144 | |
mtklein | 36352bf | 2015-03-25 18:17:31 -0700 | [diff] [blame] | 145 | const char* name() const override { return "AADistanceFieldPathBatch"; } |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 146 | |
halcanary | 9d524f2 | 2016-03-29 09:03:52 -0700 | [diff] [blame] | 147 | void computePipelineOptimizations(GrInitInvariantOutput* color, |
ethannicholas | ff21032 | 2015-11-24 12:10:10 -0800 | [diff] [blame] | 148 | GrInitInvariantOutput* coverage, |
| 149 | GrBatchToXPOverrides* overrides) const override { |
joshualitt | 53f26aa | 2015-12-10 07:29:54 -0800 | [diff] [blame] | 150 | color->setKnownFourComponents(fGeoData[0].fColor); |
ethannicholas | ff21032 | 2015-11-24 12:10:10 -0800 | [diff] [blame] | 151 | coverage->setUnknownSingleComponent(); |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 152 | } |
| 153 | |
bsalomon | e46f9fe | 2015-08-18 06:05:14 -0700 | [diff] [blame] | 154 | private: |
ethannicholas | ff21032 | 2015-11-24 12:10:10 -0800 | [diff] [blame] | 155 | void initBatchTracker(const GrXPOverridesForBatch& overrides) override { |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 156 | // Handle any color overrides |
ethannicholas | ff21032 | 2015-11-24 12:10:10 -0800 | [diff] [blame] | 157 | if (!overrides.readsColor()) { |
joshualitt | 53f26aa | 2015-12-10 07:29:54 -0800 | [diff] [blame] | 158 | fGeoData[0].fColor = GrColor_ILLEGAL; |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 159 | } |
joshualitt | 53f26aa | 2015-12-10 07:29:54 -0800 | [diff] [blame] | 160 | overrides.getOverrideColorIfSet(&fGeoData[0].fColor); |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 161 | |
| 162 | // setup batch properties |
ethannicholas | ff21032 | 2015-11-24 12:10:10 -0800 | [diff] [blame] | 163 | fBatch.fColorIgnored = !overrides.readsColor(); |
| 164 | fBatch.fUsesLocalCoords = overrides.readsLocalCoords(); |
| 165 | fBatch.fCoverageIgnored = !overrides.readsCoverage(); |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 166 | } |
| 167 | |
bsalomon | b5238a7 | 2015-05-05 07:49:49 -0700 | [diff] [blame] | 168 | struct FlushInfo { |
bungeman | 06ca8ec | 2016-06-09 08:01:03 -0700 | [diff] [blame] | 169 | SkAutoTUnref<const GrBuffer> fVertexBuffer; |
| 170 | SkAutoTUnref<const GrBuffer> fIndexBuffer; |
| 171 | sk_sp<GrGeometryProcessor> fGeometryProcessor; |
bsalomon | b5238a7 | 2015-05-05 07:49:49 -0700 | [diff] [blame] | 172 | int fVertexOffset; |
| 173 | int fInstancesToFlush; |
| 174 | }; |
| 175 | |
joshualitt | 144c3c8 | 2015-11-30 12:30:13 -0800 | [diff] [blame] | 176 | void onPrepareDraws(Target* target) const override { |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 177 | int instanceCount = fGeoData.count(); |
| 178 | |
| 179 | SkMatrix invert; |
| 180 | if (this->usesLocalCoords() && !this->viewMatrix().invert(&invert)) { |
| 181 | SkDebugf("Could not invert viewmatrix\n"); |
| 182 | return; |
| 183 | } |
| 184 | |
jvanverth | cf371bb | 2016-03-10 11:10:43 -0800 | [diff] [blame] | 185 | const SkMatrix& ctm = this->viewMatrix(); |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 186 | uint32_t flags = 0; |
jvanverth | cf371bb | 2016-03-10 11:10:43 -0800 | [diff] [blame] | 187 | flags |= ctm.isScaleTranslate() ? kScaleOnly_DistanceFieldEffectFlag : 0; |
| 188 | flags |= ctm.isSimilarity() ? kSimilarity_DistanceFieldEffectFlag : 0; |
brianosman | 0e3c554 | 2016-04-13 13:56:21 -0700 | [diff] [blame] | 189 | flags |= fGammaCorrect ? kGammaCorrect_DistanceFieldEffectFlag : 0; |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 190 | |
| 191 | GrTextureParams params(SkShader::kRepeat_TileMode, GrTextureParams::kBilerp_FilterMode); |
| 192 | |
bsalomon | 342bfc2 | 2016-04-01 06:06:20 -0700 | [diff] [blame] | 193 | FlushInfo flushInfo; |
| 194 | |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 195 | // Setup GrGeometryProcessor |
| 196 | GrBatchAtlas* atlas = fAtlas; |
bungeman | 06ca8ec | 2016-06-09 08:01:03 -0700 | [diff] [blame] | 197 | flushInfo.fGeometryProcessor = GrDistanceFieldPathGeoProc::Make(this->color(), |
| 198 | this->viewMatrix(), |
| 199 | atlas->getTexture(), |
| 200 | params, |
| 201 | flags, |
| 202 | this->usesLocalCoords()); |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 203 | |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 204 | // allocate vertices |
bsalomon | 342bfc2 | 2016-04-01 06:06:20 -0700 | [diff] [blame] | 205 | size_t vertexStride = flushInfo.fGeometryProcessor->getVertexStride(); |
joshualitt | 53f26aa | 2015-12-10 07:29:54 -0800 | [diff] [blame] | 206 | SkASSERT(vertexStride == 2 * sizeof(SkPoint) + sizeof(GrColor)); |
bsalomon | b5238a7 | 2015-05-05 07:49:49 -0700 | [diff] [blame] | 207 | |
cdalton | 397536c | 2016-03-25 12:15:03 -0700 | [diff] [blame] | 208 | const GrBuffer* vertexBuffer; |
bsalomon | 7539856 | 2015-08-17 12:55:38 -0700 | [diff] [blame] | 209 | void* vertices = target->makeVertexSpace(vertexStride, |
| 210 | kVerticesPerQuad * instanceCount, |
| 211 | &vertexBuffer, |
| 212 | &flushInfo.fVertexOffset); |
bsalomon | b5238a7 | 2015-05-05 07:49:49 -0700 | [diff] [blame] | 213 | flushInfo.fVertexBuffer.reset(SkRef(vertexBuffer)); |
bsalomon | 7539856 | 2015-08-17 12:55:38 -0700 | [diff] [blame] | 214 | flushInfo.fIndexBuffer.reset(target->resourceProvider()->refQuadIndexBuffer()); |
bsalomon | b5238a7 | 2015-05-05 07:49:49 -0700 | [diff] [blame] | 215 | if (!vertices || !flushInfo.fIndexBuffer) { |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 216 | SkDebugf("Could not allocate vertices\n"); |
| 217 | return; |
| 218 | } |
| 219 | |
bsalomon | b5238a7 | 2015-05-05 07:49:49 -0700 | [diff] [blame] | 220 | flushInfo.fInstancesToFlush = 0; |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 221 | for (int i = 0; i < instanceCount; i++) { |
joshualitt | 144c3c8 | 2015-11-30 12:30:13 -0800 | [diff] [blame] | 222 | const Geometry& args = fGeoData[i]; |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 223 | |
| 224 | // get mip level |
| 225 | SkScalar maxScale = this->viewMatrix().getMaxScale(); |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame^] | 226 | const SkRect& bounds = args.fShape.bounds(); |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 227 | SkScalar maxDim = SkMaxScalar(bounds.width(), bounds.height()); |
| 228 | SkScalar size = maxScale * maxDim; |
| 229 | uint32_t desiredDimension; |
| 230 | if (size <= kSmallMIP) { |
| 231 | desiredDimension = kSmallMIP; |
| 232 | } else if (size <= kMediumMIP) { |
| 233 | desiredDimension = kMediumMIP; |
| 234 | } else { |
| 235 | desiredDimension = kLargeMIP; |
| 236 | } |
| 237 | |
| 238 | // check to see if path is cached |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame^] | 239 | ShapeData::Key key(args.fShape, desiredDimension); |
| 240 | ShapeData* shapeData = fShapeCache->find(key); |
| 241 | if (nullptr == shapeData || !atlas->hasID(shapeData->fID)) { |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 242 | // Remove the stale cache entry |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame^] | 243 | if (shapeData) { |
| 244 | fShapeCache->remove(shapeData->fKey); |
| 245 | fShapeList->remove(shapeData); |
| 246 | delete shapeData; |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 247 | } |
| 248 | SkScalar scale = desiredDimension/maxDim; |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame^] | 249 | shapeData = new ShapeData; |
bsalomon | 7539856 | 2015-08-17 12:55:38 -0700 | [diff] [blame] | 250 | if (!this->addPathToAtlas(target, |
bsalomon | b5238a7 | 2015-05-05 07:49:49 -0700 | [diff] [blame] | 251 | &flushInfo, |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 252 | atlas, |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame^] | 253 | shapeData, |
| 254 | args.fShape, |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 255 | args.fAntiAlias, |
| 256 | desiredDimension, |
| 257 | scale)) { |
| 258 | SkDebugf("Can't rasterize path\n"); |
| 259 | return; |
| 260 | } |
| 261 | } |
| 262 | |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame^] | 263 | atlas->setLastUseToken(shapeData->fID, target->nextDrawToken()); |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 264 | |
| 265 | // Now set vertices |
| 266 | intptr_t offset = reinterpret_cast<intptr_t>(vertices); |
bsalomon | b5238a7 | 2015-05-05 07:49:49 -0700 | [diff] [blame] | 267 | offset += i * kVerticesPerQuad * vertexStride; |
bsalomon | 7539856 | 2015-08-17 12:55:38 -0700 | [diff] [blame] | 268 | this->writePathVertices(target, |
bsalomon | b5238a7 | 2015-05-05 07:49:49 -0700 | [diff] [blame] | 269 | atlas, |
joshualitt | 53f26aa | 2015-12-10 07:29:54 -0800 | [diff] [blame] | 270 | offset, |
| 271 | args.fColor, |
bsalomon | b5238a7 | 2015-05-05 07:49:49 -0700 | [diff] [blame] | 272 | vertexStride, |
| 273 | this->viewMatrix(), |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame^] | 274 | args.fShape, |
| 275 | shapeData); |
bsalomon | b5238a7 | 2015-05-05 07:49:49 -0700 | [diff] [blame] | 276 | flushInfo.fInstancesToFlush++; |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 277 | } |
| 278 | |
bsalomon | 7539856 | 2015-08-17 12:55:38 -0700 | [diff] [blame] | 279 | this->flush(target, &flushInfo); |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 280 | } |
| 281 | |
joshualitt | 53f26aa | 2015-12-10 07:29:54 -0800 | [diff] [blame] | 282 | AADistanceFieldPathBatch(const Geometry& geometry, |
| 283 | const SkMatrix& viewMatrix, |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 284 | GrBatchAtlas* atlas, |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame^] | 285 | ShapeCache* shapeCache, ShapeDataList* shapeList, |
brianosman | 0e3c554 | 2016-04-13 13:56:21 -0700 | [diff] [blame] | 286 | bool gammaCorrect) |
reed | 1b55a96 | 2015-09-17 20:16:13 -0700 | [diff] [blame] | 287 | : INHERITED(ClassID()) { |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame^] | 288 | SkASSERT(geometry.fShape.hasUnstyledKey()); |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 289 | fBatch.fViewMatrix = viewMatrix; |
| 290 | fGeoData.push_back(geometry); |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame^] | 291 | SkASSERT(fGeoData[0].fShape.hasUnstyledKey()); |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 292 | |
| 293 | fAtlas = atlas; |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame^] | 294 | fShapeCache = shapeCache; |
| 295 | fShapeList = shapeList; |
brianosman | 0e3c554 | 2016-04-13 13:56:21 -0700 | [diff] [blame] | 296 | fGammaCorrect = gammaCorrect; |
joshualitt | 99c7c07 | 2015-05-01 13:43:30 -0700 | [diff] [blame] | 297 | |
| 298 | // Compute bounds |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame^] | 299 | fBounds = geometry.fShape.bounds(); |
joshualitt | 99c7c07 | 2015-05-01 13:43:30 -0700 | [diff] [blame] | 300 | viewMatrix.mapRect(&fBounds); |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 301 | } |
| 302 | |
bsalomon | 7539856 | 2015-08-17 12:55:38 -0700 | [diff] [blame] | 303 | bool addPathToAtlas(GrVertexBatch::Target* target, |
bsalomon | b5238a7 | 2015-05-05 07:49:49 -0700 | [diff] [blame] | 304 | FlushInfo* flushInfo, |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 305 | GrBatchAtlas* atlas, |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame^] | 306 | ShapeData* shapeData, |
| 307 | const GrShape& shape, |
jvanverth | 512e437 | 2015-11-23 11:50:02 -0800 | [diff] [blame] | 308 | bool antiAlias, |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 309 | uint32_t dimension, |
joshualitt | 144c3c8 | 2015-11-30 12:30:13 -0800 | [diff] [blame] | 310 | SkScalar scale) const { |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame^] | 311 | const SkRect& bounds = shape.bounds(); |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 312 | |
| 313 | // generate bounding rect for bitmap draw |
| 314 | SkRect scaledBounds = bounds; |
| 315 | // scale to mip level size |
| 316 | scaledBounds.fLeft *= scale; |
| 317 | scaledBounds.fTop *= scale; |
| 318 | scaledBounds.fRight *= scale; |
| 319 | scaledBounds.fBottom *= scale; |
| 320 | // move the origin to an integer boundary (gives better results) |
| 321 | SkScalar dx = SkScalarFraction(scaledBounds.fLeft); |
| 322 | SkScalar dy = SkScalarFraction(scaledBounds.fTop); |
| 323 | scaledBounds.offset(-dx, -dy); |
| 324 | // get integer boundary |
| 325 | SkIRect devPathBounds; |
| 326 | scaledBounds.roundOut(&devPathBounds); |
| 327 | // pad to allow room for antialiasing |
jvanverth | ecbed9d | 2015-12-18 10:07:52 -0800 | [diff] [blame] | 328 | const int intPad = SkScalarCeilToInt(kAntiAliasPad); |
| 329 | // pre-move origin (after outset, will be 0,0) |
| 330 | int width = devPathBounds.width(); |
| 331 | int height = devPathBounds.height(); |
| 332 | devPathBounds.fLeft = intPad; |
| 333 | devPathBounds.fTop = intPad; |
| 334 | devPathBounds.fRight = intPad + width; |
| 335 | devPathBounds.fBottom = intPad + height; |
| 336 | devPathBounds.outset(intPad, intPad); |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 337 | |
| 338 | // draw path to bitmap |
| 339 | SkMatrix drawMatrix; |
| 340 | drawMatrix.setTranslate(-bounds.left(), -bounds.top()); |
| 341 | drawMatrix.postScale(scale, scale); |
| 342 | drawMatrix.postTranslate(kAntiAliasPad, kAntiAliasPad); |
| 343 | |
robertphillips | 2a7cf5f | 2016-03-02 05:36:30 -0800 | [diff] [blame] | 344 | // setup bitmap backing |
jvanverth | 512e437 | 2015-11-23 11:50:02 -0800 | [diff] [blame] | 345 | SkASSERT(devPathBounds.fLeft == 0); |
| 346 | SkASSERT(devPathBounds.fTop == 0); |
robertphillips | 2a7cf5f | 2016-03-02 05:36:30 -0800 | [diff] [blame] | 347 | SkAutoPixmapStorage dst; |
| 348 | if (!dst.tryAlloc(SkImageInfo::MakeA8(devPathBounds.width(), |
| 349 | devPathBounds.height()))) { |
| 350 | return false; |
| 351 | } |
| 352 | sk_bzero(dst.writable_addr(), dst.getSafeSize()); |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 353 | |
robertphillips | 2a7cf5f | 2016-03-02 05:36:30 -0800 | [diff] [blame] | 354 | // rasterize path |
| 355 | SkPaint paint; |
| 356 | paint.setStyle(SkPaint::kFill_Style); |
| 357 | paint.setAntiAlias(antiAlias); |
| 358 | |
| 359 | SkDraw draw; |
| 360 | sk_bzero(&draw, sizeof(draw)); |
| 361 | |
| 362 | SkRasterClip rasterClip; |
| 363 | rasterClip.setRect(devPathBounds); |
| 364 | draw.fRC = &rasterClip; |
robertphillips | 2a7cf5f | 2016-03-02 05:36:30 -0800 | [diff] [blame] | 365 | draw.fMatrix = &drawMatrix; |
| 366 | draw.fDst = dst; |
| 367 | |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame^] | 368 | SkPath path; |
| 369 | shape.asPath(&path); |
robertphillips | 2a7cf5f | 2016-03-02 05:36:30 -0800 | [diff] [blame] | 370 | draw.drawPathCoverage(path, paint); |
| 371 | |
| 372 | // generate signed distance field |
| 373 | devPathBounds.outset(SK_DistanceFieldPad, SK_DistanceFieldPad); |
| 374 | width = devPathBounds.width(); |
| 375 | height = devPathBounds.height(); |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 376 | // TODO We should really generate this directly into the plot somehow |
| 377 | SkAutoSMalloc<1024> dfStorage(width * height * sizeof(unsigned char)); |
| 378 | |
robertphillips | 2a7cf5f | 2016-03-02 05:36:30 -0800 | [diff] [blame] | 379 | // Generate signed distance field |
| 380 | SkGenerateDistanceFieldFromA8Image((unsigned char*)dfStorage.get(), |
| 381 | (const unsigned char*)dst.addr(), |
| 382 | dst.width(), dst.height(), dst.rowBytes()); |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 383 | |
| 384 | // add to atlas |
| 385 | SkIPoint16 atlasLocation; |
| 386 | GrBatchAtlas::AtlasID id; |
bsalomon | 7539856 | 2015-08-17 12:55:38 -0700 | [diff] [blame] | 387 | bool success = atlas->addToAtlas(&id, target, width, height, dfStorage.get(), |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 388 | &atlasLocation); |
| 389 | if (!success) { |
bsalomon | 7539856 | 2015-08-17 12:55:38 -0700 | [diff] [blame] | 390 | this->flush(target, flushInfo); |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 391 | |
bsalomon | 7539856 | 2015-08-17 12:55:38 -0700 | [diff] [blame] | 392 | SkDEBUGCODE(success =) atlas->addToAtlas(&id, target, width, height, |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 393 | dfStorage.get(), &atlasLocation); |
| 394 | SkASSERT(success); |
| 395 | |
| 396 | } |
| 397 | |
| 398 | // add to cache |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame^] | 399 | shapeData->fKey.set(shape, dimension); |
| 400 | shapeData->fScale = scale; |
| 401 | shapeData->fID = id; |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 402 | // change the scaled rect to match the size of the inset distance field |
| 403 | scaledBounds.fRight = scaledBounds.fLeft + |
| 404 | SkIntToScalar(devPathBounds.width() - 2*SK_DistanceFieldInset); |
| 405 | scaledBounds.fBottom = scaledBounds.fTop + |
| 406 | SkIntToScalar(devPathBounds.height() - 2*SK_DistanceFieldInset); |
| 407 | // shift the origin to the correct place relative to the distance field |
| 408 | // need to also restore the fractional translation |
| 409 | scaledBounds.offset(-SkIntToScalar(SK_DistanceFieldInset) - kAntiAliasPad + dx, |
| 410 | -SkIntToScalar(SK_DistanceFieldInset) - kAntiAliasPad + dy); |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame^] | 411 | shapeData->fBounds = scaledBounds; |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 412 | // origin we render from is inset from distance field edge |
| 413 | atlasLocation.fX += SK_DistanceFieldInset; |
| 414 | atlasLocation.fY += SK_DistanceFieldInset; |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame^] | 415 | shapeData->fAtlasLocation = atlasLocation; |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 416 | |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame^] | 417 | fShapeCache->add(shapeData); |
| 418 | fShapeList->addToTail(shapeData); |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 419 | #ifdef DF_PATH_TRACKING |
| 420 | ++g_NumCachedPaths; |
| 421 | #endif |
| 422 | return true; |
| 423 | } |
| 424 | |
bsalomon | 7539856 | 2015-08-17 12:55:38 -0700 | [diff] [blame] | 425 | void writePathVertices(GrDrawBatch::Target* target, |
bsalomon | b5238a7 | 2015-05-05 07:49:49 -0700 | [diff] [blame] | 426 | GrBatchAtlas* atlas, |
joshualitt | 53f26aa | 2015-12-10 07:29:54 -0800 | [diff] [blame] | 427 | intptr_t offset, |
| 428 | GrColor color, |
bsalomon | b5238a7 | 2015-05-05 07:49:49 -0700 | [diff] [blame] | 429 | size_t vertexStride, |
| 430 | const SkMatrix& viewMatrix, |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame^] | 431 | const GrShape& shape, |
| 432 | const ShapeData* shapeData) const { |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 433 | GrTexture* texture = atlas->getTexture(); |
| 434 | |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame^] | 435 | SkScalar dx = shapeData->fBounds.fLeft; |
| 436 | SkScalar dy = shapeData->fBounds.fTop; |
| 437 | SkScalar width = shapeData->fBounds.width(); |
| 438 | SkScalar height = shapeData->fBounds.height(); |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 439 | |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame^] | 440 | SkScalar invScale = 1.0f / shapeData->fScale; |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 441 | dx *= invScale; |
| 442 | dy *= invScale; |
| 443 | width *= invScale; |
| 444 | height *= invScale; |
| 445 | |
joshualitt | 53f26aa | 2015-12-10 07:29:54 -0800 | [diff] [blame] | 446 | SkPoint* positions = reinterpret_cast<SkPoint*>(offset); |
| 447 | |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 448 | // vertex positions |
| 449 | // TODO make the vertex attributes a struct |
| 450 | SkRect r = SkRect::MakeXYWH(dx, dy, width, height); |
| 451 | positions->setRectFan(r.left(), r.top(), r.right(), r.bottom(), vertexStride); |
| 452 | |
joshualitt | 53f26aa | 2015-12-10 07:29:54 -0800 | [diff] [blame] | 453 | // colors |
| 454 | for (int i = 0; i < kVerticesPerQuad; i++) { |
| 455 | GrColor* colorPtr = (GrColor*)(offset + sizeof(SkPoint) + i * vertexStride); |
| 456 | *colorPtr = color; |
| 457 | } |
| 458 | |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame^] | 459 | const SkScalar tx = SkIntToScalar(shapeData->fAtlasLocation.fX); |
| 460 | const SkScalar ty = SkIntToScalar(shapeData->fAtlasLocation.fY); |
benjaminwagner | 01e5838 | 2016-02-22 11:10:33 -0800 | [diff] [blame] | 461 | |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 462 | // vertex texture coords |
joshualitt | 53f26aa | 2015-12-10 07:29:54 -0800 | [diff] [blame] | 463 | SkPoint* textureCoords = (SkPoint*)(offset + sizeof(SkPoint) + sizeof(GrColor)); |
benjaminwagner | 01e5838 | 2016-02-22 11:10:33 -0800 | [diff] [blame] | 464 | textureCoords->setRectFan(tx / texture->width(), |
| 465 | ty / texture->height(), |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame^] | 466 | (tx + shapeData->fBounds.width()) / texture->width(), |
| 467 | (ty + shapeData->fBounds.height()) / texture->height(), |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 468 | vertexStride); |
| 469 | } |
| 470 | |
joshualitt | 144c3c8 | 2015-11-30 12:30:13 -0800 | [diff] [blame] | 471 | void flush(GrVertexBatch::Target* target, FlushInfo* flushInfo) const { |
egdaniel | 0e1853c | 2016-03-17 11:35:45 -0700 | [diff] [blame] | 472 | GrMesh mesh; |
cdalton | 397536c | 2016-03-25 12:15:03 -0700 | [diff] [blame] | 473 | int maxInstancesPerDraw = |
| 474 | static_cast<int>(flushInfo->fIndexBuffer->gpuMemorySize() / sizeof(uint16_t) / 6); |
egdaniel | 0e1853c | 2016-03-17 11:35:45 -0700 | [diff] [blame] | 475 | mesh.initInstanced(kTriangles_GrPrimitiveType, flushInfo->fVertexBuffer, |
bsalomon | b5238a7 | 2015-05-05 07:49:49 -0700 | [diff] [blame] | 476 | flushInfo->fIndexBuffer, flushInfo->fVertexOffset, kVerticesPerQuad, |
bsalomon | e64eb57 | 2015-05-07 11:35:55 -0700 | [diff] [blame] | 477 | kIndicesPerQuad, flushInfo->fInstancesToFlush, maxInstancesPerDraw); |
bungeman | 06ca8ec | 2016-06-09 08:01:03 -0700 | [diff] [blame] | 478 | target->draw(flushInfo->fGeometryProcessor.get(), mesh); |
bsalomon | b5238a7 | 2015-05-05 07:49:49 -0700 | [diff] [blame] | 479 | flushInfo->fVertexOffset += kVerticesPerQuad * flushInfo->fInstancesToFlush; |
| 480 | flushInfo->fInstancesToFlush = 0; |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 481 | } |
| 482 | |
joshualitt | 53f26aa | 2015-12-10 07:29:54 -0800 | [diff] [blame] | 483 | GrColor color() const { return fGeoData[0].fColor; } |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 484 | const SkMatrix& viewMatrix() const { return fBatch.fViewMatrix; } |
| 485 | bool usesLocalCoords() const { return fBatch.fUsesLocalCoords; } |
| 486 | |
bsalomon | cb02b38 | 2015-08-12 11:14:50 -0700 | [diff] [blame] | 487 | bool onCombineIfPossible(GrBatch* t, const GrCaps& caps) override { |
bsalomon | abd30f5 | 2015-08-13 13:34:48 -0700 | [diff] [blame] | 488 | AADistanceFieldPathBatch* that = t->cast<AADistanceFieldPathBatch>(); |
| 489 | if (!GrPipeline::CanCombine(*this->pipeline(), this->bounds(), *that->pipeline(), |
| 490 | that->bounds(), caps)) { |
joshualitt | 8cab9a7 | 2015-07-16 09:13:50 -0700 | [diff] [blame] | 491 | return false; |
| 492 | } |
| 493 | |
joshualitt | 53f26aa | 2015-12-10 07:29:54 -0800 | [diff] [blame] | 494 | // TODO We can position on the cpu |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 495 | if (!this->viewMatrix().cheapEqualTo(that->viewMatrix())) { |
| 496 | return false; |
| 497 | } |
| 498 | |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame^] | 499 | fGeoData.push_back_n(that->fGeoData.count(), that->fGeoData.begin()); |
joshualitt | 99c7c07 | 2015-05-01 13:43:30 -0700 | [diff] [blame] | 500 | this->joinBounds(that->bounds()); |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 501 | return true; |
| 502 | } |
| 503 | |
| 504 | struct BatchTracker { |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 505 | SkMatrix fViewMatrix; |
| 506 | bool fUsesLocalCoords; |
| 507 | bool fColorIgnored; |
| 508 | bool fCoverageIgnored; |
| 509 | }; |
| 510 | |
| 511 | BatchTracker fBatch; |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame^] | 512 | SkSTArray<1, Geometry> fGeoData; |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 513 | GrBatchAtlas* fAtlas; |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame^] | 514 | ShapeCache* fShapeCache; |
| 515 | ShapeDataList* fShapeList; |
brianosman | 0e3c554 | 2016-04-13 13:56:21 -0700 | [diff] [blame] | 516 | bool fGammaCorrect; |
reed | 1b55a96 | 2015-09-17 20:16:13 -0700 | [diff] [blame] | 517 | |
| 518 | typedef GrVertexBatch INHERITED; |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 519 | }; |
| 520 | |
bsalomon | 0aff2fa | 2015-07-31 06:48:27 -0700 | [diff] [blame] | 521 | bool GrAADistanceFieldPathRenderer::onDrawPath(const DrawPathArgs& args) { |
robertphillips | 976f5f0 | 2016-06-03 10:59:20 -0700 | [diff] [blame] | 522 | GR_AUDIT_TRAIL_AUTO_FRAME(args.fDrawContext->auditTrail(), |
joshualitt | de83b41 | 2016-01-14 09:58:36 -0800 | [diff] [blame] | 523 | "GrAADistanceFieldPathRenderer::onDrawPath"); |
csmartdalton | ecbc12b | 2016-06-08 10:08:43 -0700 | [diff] [blame] | 524 | SkASSERT(!args.fDrawContext->isUnifiedMultisampled()); |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame^] | 525 | SkASSERT(args.fShape->style().isSimpleFill()); |
csmartdalton | ecbc12b | 2016-06-08 10:08:43 -0700 | [diff] [blame] | 526 | |
jvanverth | fa38a30 | 2014-10-06 05:59:05 -0700 | [diff] [blame] | 527 | // we've already bailed on inverse filled paths, so this is safe |
bsalomon | 8acedde | 2016-06-24 10:42:16 -0700 | [diff] [blame] | 528 | SkASSERT(!args.fShape->isEmpty()); |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame^] | 529 | SkASSERT(args.fShape->hasUnstyledKey()); |
joshualitt | 5bf99f1 | 2015-03-13 11:47:42 -0700 | [diff] [blame] | 530 | if (!fAtlas) { |
joshualitt | b356cbc | 2015-08-05 06:36:39 -0700 | [diff] [blame] | 531 | fAtlas = args.fResourceProvider->createAtlas(kAlpha_8_GrPixelConfig, |
| 532 | ATLAS_TEXTURE_WIDTH, ATLAS_TEXTURE_HEIGHT, |
| 533 | NUM_PLOTS_X, NUM_PLOTS_Y, |
| 534 | &GrAADistanceFieldPathRenderer::HandleEviction, |
| 535 | (void*)this); |
joshualitt | 21279c7 | 2015-05-11 07:21:37 -0700 | [diff] [blame] | 536 | if (!fAtlas) { |
jvanverth | fa38a30 | 2014-10-06 05:59:05 -0700 | [diff] [blame] | 537 | return false; |
| 538 | } |
| 539 | } |
| 540 | |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame^] | 541 | AADistanceFieldPathBatch::Geometry geometry; |
| 542 | geometry.fShape = *args.fShape; |
bsalomon | 8acedde | 2016-06-24 10:42:16 -0700 | [diff] [blame] | 543 | geometry.fColor = args.fColor; |
| 544 | geometry.fAntiAlias = args.fAntiAlias; |
halcanary | 9d524f2 | 2016-03-29 09:03:52 -0700 | [diff] [blame] | 545 | |
joshualitt | 53f26aa | 2015-12-10 07:29:54 -0800 | [diff] [blame] | 546 | SkAutoTUnref<GrDrawBatch> batch(AADistanceFieldPathBatch::Create(geometry, |
bsalomon | abd30f5 | 2015-08-13 13:34:48 -0700 | [diff] [blame] | 547 | *args.fViewMatrix, fAtlas, |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame^] | 548 | &fShapeCache, &fShapeList, |
brianosman | 0e3c554 | 2016-04-13 13:56:21 -0700 | [diff] [blame] | 549 | args.fGammaCorrect)); |
robertphillips | 976f5f0 | 2016-06-03 10:59:20 -0700 | [diff] [blame] | 550 | |
csmartdalton | ecbc12b | 2016-06-08 10:08:43 -0700 | [diff] [blame] | 551 | GrPipelineBuilder pipelineBuilder(*args.fPaint); |
robertphillips | 976f5f0 | 2016-06-03 10:59:20 -0700 | [diff] [blame] | 552 | pipelineBuilder.setUserStencil(args.fUserStencilSettings); |
| 553 | |
| 554 | args.fDrawContext->drawBatch(pipelineBuilder, *args.fClip, batch); |
joshualitt | 9491f7f | 2015-02-11 11:33:38 -0800 | [diff] [blame] | 555 | |
jvanverth | fa38a30 | 2014-10-06 05:59:05 -0700 | [diff] [blame] | 556 | return true; |
| 557 | } |
| 558 | |
joshualitt | 21279c7 | 2015-05-11 07:21:37 -0700 | [diff] [blame] | 559 | /////////////////////////////////////////////////////////////////////////////////////////////////// |
| 560 | |
| 561 | #ifdef GR_TEST_UTILS |
| 562 | |
| 563 | struct PathTestStruct { |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame^] | 564 | typedef GrAADistanceFieldPathRenderer::ShapeCache ShapeCache; |
| 565 | typedef GrAADistanceFieldPathRenderer::ShapeData ShapeData; |
| 566 | typedef GrAADistanceFieldPathRenderer::ShapeDataList ShapeDataList; |
halcanary | 96fcdcc | 2015-08-27 07:41:13 -0700 | [diff] [blame] | 567 | PathTestStruct() : fContextID(SK_InvalidGenID), fAtlas(nullptr) {} |
joshualitt | 21279c7 | 2015-05-11 07:21:37 -0700 | [diff] [blame] | 568 | ~PathTestStruct() { this->reset(); } |
| 569 | |
| 570 | void reset() { |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame^] | 571 | ShapeDataList::Iter iter; |
| 572 | iter.init(fShapeList, ShapeDataList::Iter::kHead_IterStart); |
| 573 | ShapeData* shapeData; |
| 574 | while ((shapeData = iter.get())) { |
joshualitt | 21279c7 | 2015-05-11 07:21:37 -0700 | [diff] [blame] | 575 | iter.next(); |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame^] | 576 | fShapeList.remove(shapeData); |
| 577 | delete shapeData; |
joshualitt | 21279c7 | 2015-05-11 07:21:37 -0700 | [diff] [blame] | 578 | } |
halcanary | 385fe4d | 2015-08-26 13:07:48 -0700 | [diff] [blame] | 579 | delete fAtlas; |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame^] | 580 | fShapeCache.reset(); |
joshualitt | 21279c7 | 2015-05-11 07:21:37 -0700 | [diff] [blame] | 581 | } |
| 582 | |
| 583 | static void HandleEviction(GrBatchAtlas::AtlasID id, void* pr) { |
| 584 | PathTestStruct* dfpr = (PathTestStruct*)pr; |
| 585 | // remove any paths that use this plot |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame^] | 586 | ShapeDataList::Iter iter; |
| 587 | iter.init(dfpr->fShapeList, ShapeDataList::Iter::kHead_IterStart); |
| 588 | ShapeData* shapeData; |
| 589 | while ((shapeData = iter.get())) { |
joshualitt | 21279c7 | 2015-05-11 07:21:37 -0700 | [diff] [blame] | 590 | iter.next(); |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame^] | 591 | if (id == shapeData->fID) { |
| 592 | dfpr->fShapeCache.remove(shapeData->fKey); |
| 593 | dfpr->fShapeList.remove(shapeData); |
| 594 | delete shapeData; |
joshualitt | 21279c7 | 2015-05-11 07:21:37 -0700 | [diff] [blame] | 595 | } |
| 596 | } |
| 597 | } |
| 598 | |
| 599 | uint32_t fContextID; |
| 600 | GrBatchAtlas* fAtlas; |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame^] | 601 | ShapeCache fShapeCache; |
| 602 | ShapeDataList fShapeList; |
joshualitt | 21279c7 | 2015-05-11 07:21:37 -0700 | [diff] [blame] | 603 | }; |
| 604 | |
bsalomon | abd30f5 | 2015-08-13 13:34:48 -0700 | [diff] [blame] | 605 | DRAW_BATCH_TEST_DEFINE(AADistanceFieldPathBatch) { |
joshualitt | 21279c7 | 2015-05-11 07:21:37 -0700 | [diff] [blame] | 606 | static PathTestStruct gTestStruct; |
| 607 | |
| 608 | if (context->uniqueID() != gTestStruct.fContextID) { |
| 609 | gTestStruct.fContextID = context->uniqueID(); |
| 610 | gTestStruct.reset(); |
joshualitt | b356cbc | 2015-08-05 06:36:39 -0700 | [diff] [blame] | 611 | gTestStruct.fAtlas = |
| 612 | context->resourceProvider()->createAtlas(kAlpha_8_GrPixelConfig, |
| 613 | ATLAS_TEXTURE_WIDTH, ATLAS_TEXTURE_HEIGHT, |
| 614 | NUM_PLOTS_X, NUM_PLOTS_Y, |
| 615 | &PathTestStruct::HandleEviction, |
| 616 | (void*)&gTestStruct); |
joshualitt | 21279c7 | 2015-05-11 07:21:37 -0700 | [diff] [blame] | 617 | } |
| 618 | |
| 619 | SkMatrix viewMatrix = GrTest::TestMatrix(random); |
| 620 | GrColor color = GrRandomColor(random); |
brianosman | 0e3c554 | 2016-04-13 13:56:21 -0700 | [diff] [blame] | 621 | bool gammaCorrect = random->nextBool(); |
joshualitt | 21279c7 | 2015-05-11 07:21:37 -0700 | [diff] [blame] | 622 | |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame^] | 623 | AADistanceFieldPathBatch::Geometry geometry; |
| 624 | // This path renderer only allows fill styles. |
| 625 | GrShape shape(GrTest::TestPath(random), GrStyle::SimpleFill()); |
| 626 | geometry.fShape = shape; |
joshualitt | 53f26aa | 2015-12-10 07:29:54 -0800 | [diff] [blame] | 627 | geometry.fColor = color; |
joshualitt | 21279c7 | 2015-05-11 07:21:37 -0700 | [diff] [blame] | 628 | geometry.fAntiAlias = random->nextBool(); |
| 629 | |
joshualitt | 53f26aa | 2015-12-10 07:29:54 -0800 | [diff] [blame] | 630 | return AADistanceFieldPathBatch::Create(geometry, viewMatrix, |
joshualitt | 21279c7 | 2015-05-11 07:21:37 -0700 | [diff] [blame] | 631 | gTestStruct.fAtlas, |
bsalomon | ee43241 | 2016-06-27 07:18:18 -0700 | [diff] [blame^] | 632 | &gTestStruct.fShapeCache, |
| 633 | &gTestStruct.fShapeList, |
brianosman | 0e3c554 | 2016-04-13 13:56:21 -0700 | [diff] [blame] | 634 | gammaCorrect); |
joshualitt | 21279c7 | 2015-05-11 07:21:37 -0700 | [diff] [blame] | 635 | } |
| 636 | |
| 637 | #endif |