blob: e8eeb0c78a67ca9e0729d5a541284c1b3953133e [file] [log] [blame]
joshualitt259fbf12015-07-21 11:39:34 -07001/*
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
8#include "GrAtlasTextBlob.h"
joshualitt2e2202e2015-12-10 11:22:08 -08009#include "GrBlurUtils.h"
10#include "GrContext.h"
bsalomonbb243832016-07-22 07:10:19 -070011#include "GrPipelineBuilder.h"
Brian Salomon344ec422016-12-15 10:58:41 -050012#include "GrRenderTargetContext.h"
joshualitt0a42e682015-12-10 13:20:58 -080013#include "GrTextUtils.h"
joshualitt2e2202e2015-12-10 11:22:08 -080014#include "SkColorFilter.h"
15#include "SkDrawFilter.h"
joshualitte76b4bb2015-12-28 07:23:58 -080016#include "SkGlyphCache.h"
joshualitt2e2202e2015-12-10 11:22:08 -080017#include "SkTextBlobRunIterator.h"
Brian Salomon89527432016-12-16 09:52:16 -050018#include "ops/GrAtlasTextOp.h"
joshualitt2e2202e2015-12-10 11:22:08 -080019
Florin Malitac337c9e2017-03-10 18:02:29 +000020sk_sp<GrAtlasTextBlob> GrAtlasTextBlob::Make(GrMemoryPool* pool, int glyphCount, int runCount) {
joshualitt92303772016-02-10 11:55:52 -080021 // We allocate size for the GrAtlasTextBlob itself, plus size for the vertices array,
22 // and size for the glyphIds array.
23 size_t verticesCount = glyphCount * kVerticesPerGlyph * kMaxVASize;
24 size_t size = sizeof(GrAtlasTextBlob) +
25 verticesCount +
26 glyphCount * sizeof(GrGlyph**) +
27 sizeof(GrAtlasTextBlob::Run) * runCount;
28
29 void* allocation = pool->allocate(size);
30 if (CACHE_SANITY_CHECK) {
31 sk_bzero(allocation, size);
32 }
33
Florin Malitac337c9e2017-03-10 18:02:29 +000034 sk_sp<GrAtlasTextBlob> cacheBlob(new (allocation) GrAtlasTextBlob);
joshualitt92303772016-02-10 11:55:52 -080035 cacheBlob->fSize = size;
36
37 // setup offsets for vertices / glyphs
Florin Malitac337c9e2017-03-10 18:02:29 +000038 cacheBlob->fVertices = sizeof(GrAtlasTextBlob) +
39 reinterpret_cast<unsigned char*>(cacheBlob.get());
joshualitt92303772016-02-10 11:55:52 -080040 cacheBlob->fGlyphs = reinterpret_cast<GrGlyph**>(cacheBlob->fVertices + verticesCount);
41 cacheBlob->fRuns = reinterpret_cast<GrAtlasTextBlob::Run*>(cacheBlob->fGlyphs + glyphCount);
42
43 // Initialize runs
44 for (int i = 0; i < runCount; i++) {
45 new (&cacheBlob->fRuns[i]) GrAtlasTextBlob::Run;
46 }
47 cacheBlob->fRunCount = runCount;
48 cacheBlob->fPool = pool;
49 return cacheBlob;
50}
51
joshualitte76b4bb2015-12-28 07:23:58 -080052SkGlyphCache* GrAtlasTextBlob::setupCache(int runIndex,
53 const SkSurfaceProps& props,
brianosmana1e8f8d2016-04-08 06:47:54 -070054 uint32_t scalerContextFlags,
joshualitte76b4bb2015-12-28 07:23:58 -080055 const SkPaint& skPaint,
bungemanf6d1e602016-02-22 13:20:28 -080056 const SkMatrix* viewMatrix) {
joshualitte76b4bb2015-12-28 07:23:58 -080057 GrAtlasTextBlob::Run* run = &fRuns[runIndex];
58
59 // if we have an override descriptor for the run, then we should use that
60 SkAutoDescriptor* desc = run->fOverrideDescriptor.get() ? run->fOverrideDescriptor.get() :
61 &run->fDescriptor;
bsalomon8b6fa5e2016-05-19 16:23:47 -070062 SkScalerContextEffects effects;
63 skPaint.getScalerContextDescriptor(&effects, desc, props, scalerContextFlags, viewMatrix);
joshualitte76b4bb2015-12-28 07:23:58 -080064 run->fTypeface.reset(SkSafeRef(skPaint.getTypeface()));
bsalomon8b6fa5e2016-05-19 16:23:47 -070065 run->fPathEffect = sk_ref_sp(effects.fPathEffect);
66 run->fRasterizer = sk_ref_sp(effects.fRasterizer);
67 run->fMaskFilter = sk_ref_sp(effects.fMaskFilter);
Hal Canary144caf52016-11-07 17:57:18 -050068 return SkGlyphCache::DetachCache(run->fTypeface.get(), effects, desc->getDesc());
joshualitte76b4bb2015-12-28 07:23:58 -080069}
70
joshualittf528e0d2015-12-09 06:42:52 -080071void GrAtlasTextBlob::appendGlyph(int runIndex,
72 const SkRect& positions,
73 GrColor color,
Brian Salomonf856fd12016-12-16 14:24:34 -050074 GrAtlasTextStrike* strike,
joshualitta06e6ab2015-12-10 08:54:41 -080075 GrGlyph* glyph,
bsalomonc2878e22016-05-17 13:18:03 -070076 SkGlyphCache* cache, const SkGlyph& skGlyph,
Jim Van Verth08576e62016-11-16 10:15:23 -050077 SkScalar x, SkScalar y, SkScalar scale, bool treatAsBMP) {
Lee Salzman26d3f212017-01-27 14:31:10 -050078 if (positions.isEmpty()) {
79 return;
80 }
joshualitta06e6ab2015-12-10 08:54:41 -080081
82 // If the glyph is too large we fall back to paths
83 if (glyph->fTooLargeForAtlas) {
Jim Van Verth08576e62016-11-16 10:15:23 -050084 this->appendLargeGlyph(glyph, cache, skGlyph, x, y, scale, treatAsBMP);
joshualitta06e6ab2015-12-10 08:54:41 -080085 return;
86 }
87
joshualittf528e0d2015-12-09 06:42:52 -080088 Run& run = fRuns[runIndex];
89 GrMaskFormat format = glyph->fMaskFormat;
90
91 Run::SubRunInfo* subRun = &run.fSubRunInfo.back();
92 if (run.fInitialized && subRun->maskFormat() != format) {
93 subRun = &run.push_back();
94 subRun->setStrike(strike);
95 } else if (!run.fInitialized) {
96 subRun->setStrike(strike);
97 }
98
99 run.fInitialized = true;
100
101 size_t vertexStride = GetVertexStride(format);
102
103 subRun->setMaskFormat(format);
104
joshualitt7481e752016-01-22 06:08:48 -0800105 subRun->joinGlyphBounds(positions);
joshualittf9e658b2015-12-09 09:26:44 -0800106 subRun->setColor(color);
joshualitt18b072d2015-12-07 12:26:12 -0800107
108 intptr_t vertex = reinterpret_cast<intptr_t>(this->fVertices + subRun->vertexEndIndex());
109
joshualittf528e0d2015-12-09 06:42:52 -0800110 if (kARGB_GrMaskFormat != glyph->fMaskFormat) {
joshualitt18b072d2015-12-07 12:26:12 -0800111 // V0
112 SkPoint* position = reinterpret_cast<SkPoint*>(vertex);
113 position->set(positions.fLeft, positions.fTop);
114 SkColor* colorPtr = reinterpret_cast<SkColor*>(vertex + sizeof(SkPoint));
115 *colorPtr = color;
116 vertex += vertexStride;
117
118 // V1
119 position = reinterpret_cast<SkPoint*>(vertex);
120 position->set(positions.fLeft, positions.fBottom);
121 colorPtr = reinterpret_cast<SkColor*>(vertex + sizeof(SkPoint));
122 *colorPtr = color;
123 vertex += vertexStride;
124
125 // V2
126 position = reinterpret_cast<SkPoint*>(vertex);
127 position->set(positions.fRight, positions.fBottom);
128 colorPtr = reinterpret_cast<SkColor*>(vertex + sizeof(SkPoint));
129 *colorPtr = color;
130 vertex += vertexStride;
131
132 // V3
133 position = reinterpret_cast<SkPoint*>(vertex);
134 position->set(positions.fRight, positions.fTop);
135 colorPtr = reinterpret_cast<SkColor*>(vertex + sizeof(SkPoint));
136 *colorPtr = color;
137 } else {
138 // V0
139 SkPoint* position = reinterpret_cast<SkPoint*>(vertex);
140 position->set(positions.fLeft, positions.fTop);
141 vertex += vertexStride;
142
143 // V1
144 position = reinterpret_cast<SkPoint*>(vertex);
145 position->set(positions.fLeft, positions.fBottom);
146 vertex += vertexStride;
147
148 // V2
149 position = reinterpret_cast<SkPoint*>(vertex);
150 position->set(positions.fRight, positions.fBottom);
151 vertex += vertexStride;
152
153 // V3
154 position = reinterpret_cast<SkPoint*>(vertex);
155 position->set(positions.fRight, positions.fTop);
156 }
157 subRun->appendVertices(vertexStride);
158 fGlyphs[subRun->glyphEndIndex()] = glyph;
159 subRun->glyphAppended();
160}
161
bsalomonc2878e22016-05-17 13:18:03 -0700162void GrAtlasTextBlob::appendLargeGlyph(GrGlyph* glyph, SkGlyphCache* cache, const SkGlyph& skGlyph,
Jim Van Verth08576e62016-11-16 10:15:23 -0500163 SkScalar x, SkScalar y, SkScalar scale, bool treatAsBMP) {
joshualitta06e6ab2015-12-10 08:54:41 -0800164 if (nullptr == glyph->fPath) {
bsalomonc2878e22016-05-17 13:18:03 -0700165 const SkPath* glyphPath = cache->findPath(skGlyph);
joshualitta06e6ab2015-12-10 08:54:41 -0800166 if (!glyphPath) {
167 return;
168 }
169
170 glyph->fPath = new SkPath(*glyphPath);
171 }
Jim Van Verth08576e62016-11-16 10:15:23 -0500172 fBigGlyphs.push_back(GrAtlasTextBlob::BigGlyph(*glyph->fPath, x, y, scale, treatAsBMP));
joshualitta06e6ab2015-12-10 08:54:41 -0800173}
174
Brian Salomon6f1d36c2017-01-13 12:02:17 -0500175bool GrAtlasTextBlob::mustRegenerate(const GrTextUtils::Paint& paint,
176 const SkMaskFilter::BlurRec& blurRec,
joshualittfd5f6c12015-12-10 07:44:50 -0800177 const SkMatrix& viewMatrix, SkScalar x, SkScalar y) {
178 // If we have LCD text then our canonical color will be set to transparent, in this case we have
179 // to regenerate the blob on any color change
180 // We use the grPaint to get any color filter effects
181 if (fKey.fCanonicalColor == SK_ColorTRANSPARENT &&
Brian Salomon6f1d36c2017-01-13 12:02:17 -0500182 fFilteredPaintColor != paint.filteredSkColor()) {
joshualittfd5f6c12015-12-10 07:44:50 -0800183 return true;
184 }
185
joshualitt8e0ef292016-02-19 14:13:03 -0800186 if (fInitialViewMatrix.hasPerspective() != viewMatrix.hasPerspective()) {
joshualittfd5f6c12015-12-10 07:44:50 -0800187 return true;
188 }
189
joshualitt8e0ef292016-02-19 14:13:03 -0800190 if (fInitialViewMatrix.hasPerspective() && !fInitialViewMatrix.cheapEqualTo(viewMatrix)) {
joshualittfd5f6c12015-12-10 07:44:50 -0800191 return true;
192 }
193
194 // We only cache one masked version
195 if (fKey.fHasBlur &&
196 (fBlurRec.fSigma != blurRec.fSigma ||
197 fBlurRec.fStyle != blurRec.fStyle ||
198 fBlurRec.fQuality != blurRec.fQuality)) {
199 return true;
200 }
201
202 // Similarly, we only cache one version for each style
203 if (fKey.fStyle != SkPaint::kFill_Style &&
Brian Salomon6f1d36c2017-01-13 12:02:17 -0500204 (fStrokeInfo.fFrameWidth != paint.skPaint().getStrokeWidth() ||
205 fStrokeInfo.fMiterLimit != paint.skPaint().getStrokeMiter() ||
206 fStrokeInfo.fJoin != paint.skPaint().getStrokeJoin())) {
joshualittfd5f6c12015-12-10 07:44:50 -0800207 return true;
208 }
209
210 // Mixed blobs must be regenerated. We could probably figure out a way to do integer scrolls
211 // for mixed blobs if this becomes an issue.
212 if (this->hasBitmap() && this->hasDistanceField()) {
213 // Identical viewmatrices and we can reuse in all cases
joshualitt8e0ef292016-02-19 14:13:03 -0800214 if (fInitialViewMatrix.cheapEqualTo(viewMatrix) && x == fInitialX && y == fInitialY) {
joshualittfd5f6c12015-12-10 07:44:50 -0800215 return false;
216 }
217 return true;
218 }
219
220 if (this->hasBitmap()) {
joshualitt8e0ef292016-02-19 14:13:03 -0800221 if (fInitialViewMatrix.getScaleX() != viewMatrix.getScaleX() ||
222 fInitialViewMatrix.getScaleY() != viewMatrix.getScaleY() ||
223 fInitialViewMatrix.getSkewX() != viewMatrix.getSkewX() ||
224 fInitialViewMatrix.getSkewY() != viewMatrix.getSkewY()) {
joshualittfd5f6c12015-12-10 07:44:50 -0800225 return true;
226 }
227
228 // We can update the positions in the cachedtextblobs without regenerating the whole blob,
229 // but only for integer translations.
230 // This cool bit of math will determine the necessary translation to apply to the already
231 // generated vertex coordinates to move them to the correct position
232 SkScalar transX = viewMatrix.getTranslateX() +
joshualitt8e0ef292016-02-19 14:13:03 -0800233 viewMatrix.getScaleX() * (x - fInitialX) +
234 viewMatrix.getSkewX() * (y - fInitialY) -
235 fInitialViewMatrix.getTranslateX();
joshualittfd5f6c12015-12-10 07:44:50 -0800236 SkScalar transY = viewMatrix.getTranslateY() +
joshualitt8e0ef292016-02-19 14:13:03 -0800237 viewMatrix.getSkewY() * (x - fInitialX) +
238 viewMatrix.getScaleY() * (y - fInitialY) -
239 fInitialViewMatrix.getTranslateY();
240 if (!SkScalarIsInt(transX) || !SkScalarIsInt(transY)) {
joshualittfd5f6c12015-12-10 07:44:50 -0800241 return true;
242 }
joshualittfd5f6c12015-12-10 07:44:50 -0800243 } else if (this->hasDistanceField()) {
244 // A scale outside of [blob.fMaxMinScale, blob.fMinMaxScale] would result in a different
245 // distance field being generated, so we have to regenerate in those cases
246 SkScalar newMaxScale = viewMatrix.getMaxScale();
joshualitt8e0ef292016-02-19 14:13:03 -0800247 SkScalar oldMaxScale = fInitialViewMatrix.getMaxScale();
joshualittfd5f6c12015-12-10 07:44:50 -0800248 SkScalar scaleAdjust = newMaxScale / oldMaxScale;
249 if (scaleAdjust < fMaxMinScale || scaleAdjust > fMinMaxScale) {
250 return true;
251 }
joshualittfd5f6c12015-12-10 07:44:50 -0800252 }
253
joshualittfd5f6c12015-12-10 07:44:50 -0800254 // It is possible that a blob has neither distanceField nor bitmaptext. This is in the case
255 // when all of the runs inside the blob are drawn as paths. In this case, we always regenerate
256 // the blob anyways at flush time, so no need to regenerate explicitly
257 return false;
258}
259
Brian Salomond3ccb0a2017-04-03 10:38:00 -0400260inline std::unique_ptr<GrLegacyMeshDrawOp> GrAtlasTextBlob::makeOp(
Brian Salomon344ec422016-12-15 10:58:41 -0500261 const Run::SubRunInfo& info, int glyphCount, int run, int subRun,
Brian Salomon6f1d36c2017-01-13 12:02:17 -0500262 const SkMatrix& viewMatrix, SkScalar x, SkScalar y, const GrTextUtils::Paint& paint,
Brian Salomon344ec422016-12-15 10:58:41 -0500263 const SkSurfaceProps& props, const GrDistanceFieldAdjustTable* distanceAdjustTable,
Brian Salomonf856fd12016-12-16 14:24:34 -0500264 bool useGammaCorrectDistanceTable, GrAtlasGlyphCache* cache) {
joshualitt2e2202e2015-12-10 11:22:08 -0800265 GrMaskFormat format = info.maskFormat();
joshualitt2e2202e2015-12-10 11:22:08 -0800266
Brian Salomonf8334782017-01-03 09:42:58 -0500267 std::unique_ptr<GrAtlasTextOp> op;
joshualitt2e2202e2015-12-10 11:22:08 -0800268 if (info.drawAsDistanceFields()) {
Brian Salomon6f1d36c2017-01-13 12:02:17 -0500269 SkColor filteredColor = paint.filteredSkColor();
joshualitt2e2202e2015-12-10 11:22:08 -0800270 bool useBGR = SkPixelGeometryIsBGR(props.pixelGeometry());
Brian Salomon09d994e2016-12-21 11:14:46 -0500271 op = GrAtlasTextOp::MakeDistanceField(glyphCount, cache, distanceAdjustTable,
272 useGammaCorrectDistanceTable, filteredColor,
273 info.hasUseLCDText(), useBGR);
joshualitt2e2202e2015-12-10 11:22:08 -0800274 } else {
Brian Salomon09d994e2016-12-21 11:14:46 -0500275 op = GrAtlasTextOp::MakeBitmap(format, glyphCount, cache);
joshualitt2e2202e2015-12-10 11:22:08 -0800276 }
Brian Salomon09d994e2016-12-21 11:14:46 -0500277 GrAtlasTextOp::Geometry& geometry = op->geometry();
joshualitt8e0ef292016-02-19 14:13:03 -0800278 geometry.fViewMatrix = viewMatrix;
joshualitt2e2202e2015-12-10 11:22:08 -0800279 geometry.fBlob = SkRef(this);
280 geometry.fRun = run;
281 geometry.fSubRun = subRun;
Brian Salomon6f1d36c2017-01-13 12:02:17 -0500282 geometry.fColor =
283 info.maskFormat() == kARGB_GrMaskFormat ? GrColor_WHITE : paint.filteredPremulGrColor();
joshualitt8e0ef292016-02-19 14:13:03 -0800284 geometry.fX = x;
285 geometry.fY = y;
Brian Salomon09d994e2016-12-21 11:14:46 -0500286 op->init();
joshualitt2e2202e2015-12-10 11:22:08 -0800287
Brian Salomon09d994e2016-12-21 11:14:46 -0500288 return std::move(op);
joshualitt2e2202e2015-12-10 11:22:08 -0800289}
290
Brian Salomon6f1d36c2017-01-13 12:02:17 -0500291inline void GrAtlasTextBlob::flushRun(GrRenderTargetContext* rtc, const GrClip& clip, int run,
292 const SkMatrix& viewMatrix, SkScalar x, SkScalar y,
293 const GrTextUtils::Paint& paint, const SkSurfaceProps& props,
Brian Salomon82f44312017-01-11 13:42:54 -0500294 const GrDistanceFieldAdjustTable* distanceAdjustTable,
295 GrAtlasGlyphCache* cache) {
296 int lastRun = fRuns[run].fSubRunInfo.count() - 1;
297 for (int subRun = 0; subRun <= lastRun; subRun++) {
joshualitt2e2202e2015-12-10 11:22:08 -0800298 const Run::SubRunInfo& info = fRuns[run].fSubRunInfo[subRun];
Brian Salomon6f1d36c2017-01-13 12:02:17 -0500299 GrPaint grPaint;
300 if (!paint.toGrPaint(info.maskFormat(), rtc, viewMatrix, &grPaint)) {
301 continue;
302 }
joshualitt2e2202e2015-12-10 11:22:08 -0800303 int glyphCount = info.glyphCount();
304 if (0 == glyphCount) {
305 continue;
306 }
307
Brian Salomond3ccb0a2017-04-03 10:38:00 -0400308 std::unique_ptr<GrLegacyMeshDrawOp> op(
309 this->makeOp(info, glyphCount, run, subRun, viewMatrix, x, y, paint, props,
310 distanceAdjustTable, rtc->isGammaCorrect(), cache));
Brian Salomon6f1d36c2017-01-13 12:02:17 -0500311 GrPipelineBuilder pipelineBuilder(std::move(grPaint), GrAAType::kNone);
bsalomonbb243832016-07-22 07:10:19 -0700312
Brian Salomond3ccb0a2017-04-03 10:38:00 -0400313 rtc->addLegacyMeshDrawOp(pipelineBuilder, clip, std::move(op));
joshualitt2e2202e2015-12-10 11:22:08 -0800314 }
315}
316
joshualitt8e0ef292016-02-19 14:13:03 -0800317static void calculate_translation(bool applyVM,
318 const SkMatrix& newViewMatrix, SkScalar newX, SkScalar newY,
319 const SkMatrix& currentViewMatrix, SkScalar currentX,
320 SkScalar currentY, SkScalar* transX, SkScalar* transY) {
321 if (applyVM) {
322 *transX = newViewMatrix.getTranslateX() +
323 newViewMatrix.getScaleX() * (newX - currentX) +
324 newViewMatrix.getSkewX() * (newY - currentY) -
325 currentViewMatrix.getTranslateX();
326
327 *transY = newViewMatrix.getTranslateY() +
328 newViewMatrix.getSkewY() * (newX - currentX) +
329 newViewMatrix.getScaleY() * (newY - currentY) -
330 currentViewMatrix.getTranslateY();
331 } else {
332 *transX = newX - currentX;
333 *transY = newY - currentY;
334 }
335}
336
Brian Osman11052242016-10-27 14:47:55 -0400337void GrAtlasTextBlob::flushBigGlyphs(GrContext* context, GrRenderTargetContext* rtc,
Brian Salomon6f1d36c2017-01-13 12:02:17 -0500338 const GrClip& clip, const SkPaint& paint,
joshualitt8e0ef292016-02-19 14:13:03 -0800339 const SkMatrix& viewMatrix, SkScalar x, SkScalar y,
joshualitt2e2202e2015-12-10 11:22:08 -0800340 const SkIRect& clipBounds) {
joshualitt8e0ef292016-02-19 14:13:03 -0800341 SkScalar transX, transY;
joshualitt2e2202e2015-12-10 11:22:08 -0800342 for (int i = 0; i < fBigGlyphs.count(); i++) {
343 GrAtlasTextBlob::BigGlyph& bigGlyph = fBigGlyphs[i];
Jim Van Verth08576e62016-11-16 10:15:23 -0500344 calculate_translation(bigGlyph.fTreatAsBMP, viewMatrix, x, y,
joshualitt8e0ef292016-02-19 14:13:03 -0800345 fInitialViewMatrix, fInitialX, fInitialY, &transX, &transY);
joshualitt2e2202e2015-12-10 11:22:08 -0800346 SkMatrix ctm;
347 ctm.setScale(bigGlyph.fScale, bigGlyph.fScale);
joshualitt8e0ef292016-02-19 14:13:03 -0800348 ctm.postTranslate(bigGlyph.fX + transX, bigGlyph.fY + transY);
Jim Van Verth08576e62016-11-16 10:15:23 -0500349 if (!bigGlyph.fTreatAsBMP) {
joshualitt8e0ef292016-02-19 14:13:03 -0800350 ctm.postConcat(viewMatrix);
joshualitt2e2202e2015-12-10 11:22:08 -0800351 }
352
Brian Salomon6f1d36c2017-01-13 12:02:17 -0500353 GrBlurUtils::drawPathWithMaskFilter(context, rtc, clip, bigGlyph.fPath, paint, ctm, nullptr,
354 clipBounds, false);
joshualitt2e2202e2015-12-10 11:22:08 -0800355 }
356}
357
Brian Osman11052242016-10-27 14:47:55 -0400358void GrAtlasTextBlob::flushRunAsPaths(GrContext* context, GrRenderTargetContext* rtc,
Brian Salomon6f1d36c2017-01-13 12:02:17 -0500359 const SkSurfaceProps& props, const SkTextBlobRunIterator& it,
360 const GrClip& clip, const GrTextUtils::Paint& paint,
joshualitt2e2202e2015-12-10 11:22:08 -0800361 SkDrawFilter* drawFilter, const SkMatrix& viewMatrix,
362 const SkIRect& clipBounds, SkScalar x, SkScalar y) {
joshualitt2e2202e2015-12-10 11:22:08 -0800363 size_t textLen = it.glyphCount() * sizeof(uint16_t);
364 const SkPoint& offset = it.offset();
365
Brian Salomon6f1d36c2017-01-13 12:02:17 -0500366 GrTextUtils::RunPaint runPaint(&paint, drawFilter, props);
367 if (!runPaint.modifyForRun(it)) {
joshualitt2e2202e2015-12-10 11:22:08 -0800368 return;
369 }
370
joshualitt2e2202e2015-12-10 11:22:08 -0800371 switch (it.positioning()) {
372 case SkTextBlob::kDefault_Positioning:
Brian Osman11052242016-10-27 14:47:55 -0400373 GrTextUtils::DrawTextAsPath(context, rtc, clip, runPaint, viewMatrix,
Brian Salomon6f1d36c2017-01-13 12:02:17 -0500374 (const char*)it.glyphs(), textLen, x + offset.x(),
375 y + offset.y(), clipBounds);
joshualitt2e2202e2015-12-10 11:22:08 -0800376 break;
377 case SkTextBlob::kHorizontal_Positioning:
Brian Osman11052242016-10-27 14:47:55 -0400378 GrTextUtils::DrawPosTextAsPath(context, rtc, props, clip, runPaint, viewMatrix,
Brian Salomon6f1d36c2017-01-13 12:02:17 -0500379 (const char*)it.glyphs(), textLen, it.pos(), 1,
380 SkPoint::Make(x, y + offset.y()), clipBounds);
joshualitt2e2202e2015-12-10 11:22:08 -0800381 break;
382 case SkTextBlob::kFull_Positioning:
Brian Osman11052242016-10-27 14:47:55 -0400383 GrTextUtils::DrawPosTextAsPath(context, rtc, props, clip, runPaint, viewMatrix,
Brian Salomon6f1d36c2017-01-13 12:02:17 -0500384 (const char*)it.glyphs(), textLen, it.pos(), 2,
385 SkPoint::Make(x, y), clipBounds);
joshualitt2e2202e2015-12-10 11:22:08 -0800386 break;
387 }
388}
389
Brian Salomon82f44312017-01-11 13:42:54 -0500390void GrAtlasTextBlob::flushCached(GrContext* context, GrRenderTargetContext* rtc,
391 const SkTextBlob* blob, const SkSurfaceProps& props,
joshualitt2e2202e2015-12-10 11:22:08 -0800392 const GrDistanceFieldAdjustTable* distanceAdjustTable,
Brian Salomon6f1d36c2017-01-13 12:02:17 -0500393 const GrTextUtils::Paint& paint, SkDrawFilter* drawFilter,
394 const GrClip& clip, const SkMatrix& viewMatrix,
395 const SkIRect& clipBounds, SkScalar x, SkScalar y) {
joshualitt2e2202e2015-12-10 11:22:08 -0800396 // We loop through the runs of the blob, flushing each. If any run is too large, then we flush
397 // it as paths
joshualitt2e2202e2015-12-10 11:22:08 -0800398 SkTextBlobRunIterator it(blob);
399 for (int run = 0; !it.done(); it.next(), run++) {
400 if (fRuns[run].fDrawAsPaths) {
Brian Salomon6f1d36c2017-01-13 12:02:17 -0500401 this->flushRunAsPaths(context, rtc, props, it, clip, paint, drawFilter, viewMatrix,
402 clipBounds, x, y);
joshualitt2e2202e2015-12-10 11:22:08 -0800403 continue;
404 }
Brian Salomon6f1d36c2017-01-13 12:02:17 -0500405 this->flushRun(rtc, clip, run, viewMatrix, x, y, paint, props, distanceAdjustTable,
406 context->getAtlasGlyphCache());
joshualitt2e2202e2015-12-10 11:22:08 -0800407 }
408
409 // Now flush big glyphs
Brian Salomon6f1d36c2017-01-13 12:02:17 -0500410 this->flushBigGlyphs(context, rtc, clip, paint, viewMatrix, x, y, clipBounds);
joshualitt2e2202e2015-12-10 11:22:08 -0800411}
412
Brian Salomon82f44312017-01-11 13:42:54 -0500413void GrAtlasTextBlob::flushThrowaway(GrContext* context, GrRenderTargetContext* rtc,
joshualitt2e2202e2015-12-10 11:22:08 -0800414 const SkSurfaceProps& props,
415 const GrDistanceFieldAdjustTable* distanceAdjustTable,
Brian Salomon6f1d36c2017-01-13 12:02:17 -0500416 const GrTextUtils::Paint& paint, const GrClip& clip,
Brian Salomon82f44312017-01-11 13:42:54 -0500417 const SkMatrix& viewMatrix, const SkIRect& clipBounds,
joshualitt8e0ef292016-02-19 14:13:03 -0800418 SkScalar x, SkScalar y) {
joshualitt2e2202e2015-12-10 11:22:08 -0800419 for (int run = 0; run < fRunCount; run++) {
Brian Salomon6f1d36c2017-01-13 12:02:17 -0500420 this->flushRun(rtc, clip, run, viewMatrix, x, y, paint, props, distanceAdjustTable,
Brian Salomon82f44312017-01-11 13:42:54 -0500421 context->getAtlasGlyphCache());
joshualitt2e2202e2015-12-10 11:22:08 -0800422 }
423
424 // Now flush big glyphs
Brian Salomon6f1d36c2017-01-13 12:02:17 -0500425 this->flushBigGlyphs(context, rtc, clip, paint, viewMatrix, x, y, clipBounds);
joshualitt2e2202e2015-12-10 11:22:08 -0800426}
427
Brian Salomond3ccb0a2017-04-03 10:38:00 -0400428std::unique_ptr<GrLegacyMeshDrawOp> GrAtlasTextBlob::test_makeOp(
Brian Salomonf8334782017-01-03 09:42:58 -0500429 int glyphCount, int run, int subRun, const SkMatrix& viewMatrix, SkScalar x, SkScalar y,
Brian Salomon6f1d36c2017-01-13 12:02:17 -0500430 const GrTextUtils::Paint& paint, const SkSurfaceProps& props,
Brian Salomonf8334782017-01-03 09:42:58 -0500431 const GrDistanceFieldAdjustTable* distanceAdjustTable, GrAtlasGlyphCache* cache) {
joshualitt7481e752016-01-22 06:08:48 -0800432 const GrAtlasTextBlob::Run::SubRunInfo& info = fRuns[run].fSubRunInfo[subRun];
Brian Salomon6f1d36c2017-01-13 12:02:17 -0500433 return this->makeOp(info, glyphCount, run, subRun, viewMatrix, x, y, paint, props,
Brian Salomon344ec422016-12-15 10:58:41 -0500434 distanceAdjustTable, false, cache);
joshualitt323c2eb2016-01-20 06:48:47 -0800435}
joshualitt2e2202e2015-12-10 11:22:08 -0800436
joshualitt259fbf12015-07-21 11:39:34 -0700437void GrAtlasTextBlob::AssertEqual(const GrAtlasTextBlob& l, const GrAtlasTextBlob& r) {
joshualitt2f2ee832016-02-10 08:52:24 -0800438 SkASSERT_RELEASE(l.fSize == r.fSize);
439 SkASSERT_RELEASE(l.fPool == r.fPool);
joshualitt259fbf12015-07-21 11:39:34 -0700440
joshualitt2f2ee832016-02-10 08:52:24 -0800441 SkASSERT_RELEASE(l.fBlurRec.fSigma == r.fBlurRec.fSigma);
442 SkASSERT_RELEASE(l.fBlurRec.fStyle == r.fBlurRec.fStyle);
443 SkASSERT_RELEASE(l.fBlurRec.fQuality == r.fBlurRec.fQuality);
joshualitt259fbf12015-07-21 11:39:34 -0700444
joshualitt2f2ee832016-02-10 08:52:24 -0800445 SkASSERT_RELEASE(l.fStrokeInfo.fFrameWidth == r.fStrokeInfo.fFrameWidth);
446 SkASSERT_RELEASE(l.fStrokeInfo.fMiterLimit == r.fStrokeInfo.fMiterLimit);
447 SkASSERT_RELEASE(l.fStrokeInfo.fJoin == r.fStrokeInfo.fJoin);
joshualitt259fbf12015-07-21 11:39:34 -0700448
joshualitt2f2ee832016-02-10 08:52:24 -0800449 SkASSERT_RELEASE(l.fBigGlyphs.count() == r.fBigGlyphs.count());
joshualitt259fbf12015-07-21 11:39:34 -0700450 for (int i = 0; i < l.fBigGlyphs.count(); i++) {
451 const BigGlyph& lBigGlyph = l.fBigGlyphs[i];
452 const BigGlyph& rBigGlyph = r.fBigGlyphs[i];
453
joshualitt2f2ee832016-02-10 08:52:24 -0800454 SkASSERT_RELEASE(lBigGlyph.fPath == rBigGlyph.fPath);
joshualitt259fbf12015-07-21 11:39:34 -0700455 // We can't assert that these have the same translations
456 }
457
joshualitt2f2ee832016-02-10 08:52:24 -0800458 SkASSERT_RELEASE(l.fKey == r.fKey);
joshualitt2f2ee832016-02-10 08:52:24 -0800459 //SkASSERT_RELEASE(l.fPaintColor == r.fPaintColor); // Colors might not actually be identical
460 SkASSERT_RELEASE(l.fMaxMinScale == r.fMaxMinScale);
461 SkASSERT_RELEASE(l.fMinMaxScale == r.fMinMaxScale);
462 SkASSERT_RELEASE(l.fTextType == r.fTextType);
joshualitt259fbf12015-07-21 11:39:34 -0700463
joshualitt2f2ee832016-02-10 08:52:24 -0800464 SkASSERT_RELEASE(l.fRunCount == r.fRunCount);
joshualitt259fbf12015-07-21 11:39:34 -0700465 for (int i = 0; i < l.fRunCount; i++) {
466 const Run& lRun = l.fRuns[i];
467 const Run& rRun = r.fRuns[i];
468
joshualitt259fbf12015-07-21 11:39:34 -0700469 if (lRun.fTypeface.get()) {
joshualitt2f2ee832016-02-10 08:52:24 -0800470 SkASSERT_RELEASE(rRun.fTypeface.get());
Hal Canary144caf52016-11-07 17:57:18 -0500471 SkASSERT_RELEASE(SkTypeface::Equal(lRun.fTypeface.get(), rRun.fTypeface.get()));
joshualitt259fbf12015-07-21 11:39:34 -0700472 } else {
joshualitt2f2ee832016-02-10 08:52:24 -0800473 SkASSERT_RELEASE(!rRun.fTypeface.get());
joshualitt259fbf12015-07-21 11:39:34 -0700474 }
475
joshualitt259fbf12015-07-21 11:39:34 -0700476
joshualitt2f2ee832016-02-10 08:52:24 -0800477 SkASSERT_RELEASE(lRun.fDescriptor.getDesc());
478 SkASSERT_RELEASE(rRun.fDescriptor.getDesc());
bsalomonc5d07fa2016-05-17 10:17:45 -0700479 SkASSERT_RELEASE(*lRun.fDescriptor.getDesc() == *rRun.fDescriptor.getDesc());
joshualitt259fbf12015-07-21 11:39:34 -0700480
481 if (lRun.fOverrideDescriptor.get()) {
joshualitt2f2ee832016-02-10 08:52:24 -0800482 SkASSERT_RELEASE(lRun.fOverrideDescriptor->getDesc());
483 SkASSERT_RELEASE(rRun.fOverrideDescriptor.get() && rRun.fOverrideDescriptor->getDesc());
bsalomonc5d07fa2016-05-17 10:17:45 -0700484 SkASSERT_RELEASE(*lRun.fOverrideDescriptor->getDesc() ==
485 *rRun.fOverrideDescriptor->getDesc());
joshualitt259fbf12015-07-21 11:39:34 -0700486 } else {
joshualitt2f2ee832016-02-10 08:52:24 -0800487 SkASSERT_RELEASE(!rRun.fOverrideDescriptor.get());
joshualitt259fbf12015-07-21 11:39:34 -0700488 }
489
490 // color can be changed
491 //SkASSERT(lRun.fColor == rRun.fColor);
joshualitt2f2ee832016-02-10 08:52:24 -0800492 SkASSERT_RELEASE(lRun.fInitialized == rRun.fInitialized);
493 SkASSERT_RELEASE(lRun.fDrawAsPaths == rRun.fDrawAsPaths);
joshualitt259fbf12015-07-21 11:39:34 -0700494
joshualitt2f2ee832016-02-10 08:52:24 -0800495 SkASSERT_RELEASE(lRun.fSubRunInfo.count() == rRun.fSubRunInfo.count());
joshualitt259fbf12015-07-21 11:39:34 -0700496 for(int j = 0; j < lRun.fSubRunInfo.count(); j++) {
497 const Run::SubRunInfo& lSubRun = lRun.fSubRunInfo[j];
498 const Run::SubRunInfo& rSubRun = rRun.fSubRunInfo[j];
499
joshualitt2f2ee832016-02-10 08:52:24 -0800500 // TODO we can do this check, but we have to apply the VM to the old vertex bounds
501 //SkASSERT_RELEASE(lSubRun.vertexBounds() == rSubRun.vertexBounds());
joshualitt259fbf12015-07-21 11:39:34 -0700502
joshualitt2f2ee832016-02-10 08:52:24 -0800503 if (lSubRun.strike()) {
504 SkASSERT_RELEASE(rSubRun.strike());
Brian Salomonf856fd12016-12-16 14:24:34 -0500505 SkASSERT_RELEASE(GrAtlasTextStrike::GetKey(*lSubRun.strike()) ==
506 GrAtlasTextStrike::GetKey(*rSubRun.strike()));
joshualitt2f2ee832016-02-10 08:52:24 -0800507
508 } else {
509 SkASSERT_RELEASE(!rSubRun.strike());
510 }
511
512 SkASSERT_RELEASE(lSubRun.vertexStartIndex() == rSubRun.vertexStartIndex());
513 SkASSERT_RELEASE(lSubRun.vertexEndIndex() == rSubRun.vertexEndIndex());
514 SkASSERT_RELEASE(lSubRun.glyphStartIndex() == rSubRun.glyphStartIndex());
515 SkASSERT_RELEASE(lSubRun.glyphEndIndex() == rSubRun.glyphEndIndex());
516 SkASSERT_RELEASE(lSubRun.maskFormat() == rSubRun.maskFormat());
517 SkASSERT_RELEASE(lSubRun.drawAsDistanceFields() == rSubRun.drawAsDistanceFields());
518 SkASSERT_RELEASE(lSubRun.hasUseLCDText() == rSubRun.hasUseLCDText());
joshualitt259fbf12015-07-21 11:39:34 -0700519 }
520 }
521}
joshualitt8e0ef292016-02-19 14:13:03 -0800522
523void GrAtlasTextBlob::Run::SubRunInfo::computeTranslation(const SkMatrix& viewMatrix,
524 SkScalar x, SkScalar y, SkScalar* transX,
525 SkScalar* transY) {
526 calculate_translation(!this->drawAsDistanceFields(), viewMatrix, x, y,
527 fCurrentViewMatrix, fX, fY, transX, transY);
528 fCurrentViewMatrix = viewMatrix;
529 fX = x;
530 fY = y;
531}