blob: 1761acc82727c6f72fedeca9e7bf5db9594bc194 [file] [log] [blame]
joshualitta751c972015-11-20 13:37:32 -08001/*
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
Mike Kleinc0bd9f92019-04-23 12:05:21 -05008#include "src/gpu/ops/GrAtlasTextOp.h"
Robert Phillipse4fda6c2018-02-21 12:10:41 -05009
Mike Kleinc0bd9f92019-04-23 12:05:21 -050010#include "include/core/SkPoint3.h"
11#include "include/private/GrRecordingContext.h"
12#include "src/core/SkMathPriv.h"
13#include "src/core/SkMatrixPriv.h"
14#include "src/core/SkStrikeCache.h"
15#include "src/gpu/GrCaps.h"
16#include "src/gpu/GrMemoryPool.h"
17#include "src/gpu/GrOpFlushState.h"
18#include "src/gpu/GrRecordingContextPriv.h"
19#include "src/gpu/GrResourceProvider.h"
20#include "src/gpu/effects/GrBitmapTextGeoProc.h"
21#include "src/gpu/effects/GrDistanceFieldGeoProc.h"
22#include "src/gpu/text/GrAtlasManager.h"
23#include "src/gpu/text/GrStrikeCache.h"
joshualitta751c972015-11-20 13:37:32 -080024
joshualitt60ce86d2015-11-23 13:08:22 -080025///////////////////////////////////////////////////////////////////////////////////////////////////
26
Robert Phillipsb97da532019-02-12 15:24:12 -050027std::unique_ptr<GrAtlasTextOp> GrAtlasTextOp::MakeBitmap(GrRecordingContext* context,
Robert Phillips7c525e62018-06-12 10:11:12 -040028 GrPaint&& paint,
29 GrMaskFormat maskFormat,
30 int glyphCount,
31 bool needsTransform) {
Robert Phillips9da87e02019-02-04 13:26:26 -050032 GrOpMemoryPool* pool = context->priv().opMemoryPool();
Robert Phillipsc994a932018-06-19 13:09:54 -040033
34 std::unique_ptr<GrAtlasTextOp> op = pool->allocate<GrAtlasTextOp>(std::move(paint));
Robert Phillips7c525e62018-06-12 10:11:12 -040035
36 switch (maskFormat) {
37 case kA8_GrMaskFormat:
38 op->fMaskType = kGrayscaleCoverageMask_MaskType;
39 break;
40 case kA565_GrMaskFormat:
41 op->fMaskType = kLCDCoverageMask_MaskType;
42 break;
43 case kARGB_GrMaskFormat:
44 op->fMaskType = kColorBitmapMask_MaskType;
45 break;
46 }
47 op->fNumGlyphs = glyphCount;
48 op->fGeoCount = 1;
49 op->fLuminanceColor = 0;
50 op->fNeedsGlyphTransform = needsTransform;
51 return op;
52 }
53
54std::unique_ptr<GrAtlasTextOp> GrAtlasTextOp::MakeDistanceField(
Robert Phillipsb97da532019-02-12 15:24:12 -050055 GrRecordingContext* context,
Robert Phillips7c525e62018-06-12 10:11:12 -040056 GrPaint&& paint,
57 int glyphCount,
58 const GrDistanceFieldAdjustTable* distanceAdjustTable,
59 bool useGammaCorrectDistanceTable,
60 SkColor luminanceColor,
61 const SkSurfaceProps& props,
62 bool isAntiAliased,
63 bool useLCD) {
Robert Phillips9da87e02019-02-04 13:26:26 -050064 GrOpMemoryPool* pool = context->priv().opMemoryPool();
Robert Phillipsc994a932018-06-19 13:09:54 -040065
66 std::unique_ptr<GrAtlasTextOp> op = pool->allocate<GrAtlasTextOp>(std::move(paint));
Robert Phillips7c525e62018-06-12 10:11:12 -040067
68 bool isBGR = SkPixelGeometryIsBGR(props.pixelGeometry());
69 bool isLCD = useLCD && SkPixelGeometryIsH(props.pixelGeometry());
70 op->fMaskType = !isAntiAliased ? kAliasedDistanceField_MaskType
71 : isLCD ? (isBGR ? kLCDBGRDistanceField_MaskType
72 : kLCDDistanceField_MaskType)
73 : kGrayscaleDistanceField_MaskType;
74 op->fDistanceAdjustTable.reset(SkRef(distanceAdjustTable));
75 op->fUseGammaCorrectDistanceTable = useGammaCorrectDistanceTable;
76 op->fLuminanceColor = luminanceColor;
77 op->fNumGlyphs = glyphCount;
78 op->fGeoCount = 1;
79 return op;
80 }
81
joshualitta751c972015-11-20 13:37:32 -080082static const int kDistanceAdjustLumShift = 5;
83
Brian Salomon5c6ac642017-12-19 11:09:32 -050084void GrAtlasTextOp::init() {
85 const Geometry& geo = fGeoData[0];
Brian Salomon5c6ac642017-12-19 11:09:32 -050086 if (this->usesDistanceFields()) {
87 bool isLCD = this->isLCD();
88
89 const SkMatrix& viewMatrix = geo.fViewMatrix;
90
91 fDFGPFlags = viewMatrix.isSimilarity() ? kSimilarity_DistanceFieldEffectFlag : 0;
92 fDFGPFlags |= viewMatrix.isScaleTranslate() ? kScaleOnly_DistanceFieldEffectFlag : 0;
93 fDFGPFlags |= viewMatrix.hasPerspective() ? kPerspective_DistanceFieldEffectFlag : 0;
94 fDFGPFlags |= fUseGammaCorrectDistanceTable ? kGammaCorrect_DistanceFieldEffectFlag : 0;
95 fDFGPFlags |= (kAliasedDistanceField_MaskType == fMaskType)
96 ? kAliased_DistanceFieldEffectFlag
97 : 0;
98
99 if (isLCD) {
100 fDFGPFlags |= kUseLCD_DistanceFieldEffectFlag;
101 fDFGPFlags |=
102 (kLCDBGRDistanceField_MaskType == fMaskType) ? kBGR_DistanceFieldEffectFlag : 0;
103 }
Jim Van Verthb515ae72018-05-23 16:44:55 -0400104
105 fNeedsGlyphTransform = true;
Brian Salomon5c6ac642017-12-19 11:09:32 -0500106 }
Jim Van Verth70276912018-06-01 13:46:46 -0400107
108 SkRect bounds;
109 geo.fBlob->computeSubRunBounds(&bounds, geo.fRun, geo.fSubRun, geo.fViewMatrix, geo.fX, geo.fY,
110 fNeedsGlyphTransform);
111 // We don't have tight bounds on the glyph paths in device space. For the purposes of bounds
112 // we treat this as a set of non-AA rects rendered with a texture.
113 this->setBounds(bounds, HasAABloat::kNo, IsZeroArea::kNo);
Brian Salomon5c6ac642017-12-19 11:09:32 -0500114}
115
Chris Dalton1706cbf2019-05-21 19:35:29 -0600116void GrAtlasTextOp::visitProxies(const VisitProxyFunc& func) const {
Robert Phillipse4fda6c2018-02-21 12:10:41 -0500117 fProcessors.visitProxies(func);
Robert Phillipse4fda6c2018-02-21 12:10:41 -0500118}
119
Brian Osman9a390ac2018-11-12 09:47:48 -0500120#ifdef SK_DEBUG
Brian Salomon344ec422016-12-15 10:58:41 -0500121SkString GrAtlasTextOp::dumpInfo() const {
joshualitta751c972015-11-20 13:37:32 -0800122 SkString str;
123
124 for (int i = 0; i < fGeoCount; ++i) {
125 str.appendf("%d: Color: 0x%08x Trans: %.2f,%.2f Runs: %d\n",
126 i,
Brian Osmancf860852018-10-31 14:04:39 -0400127 fGeoData[i].fColor.toBytes_RGBA(),
joshualitt8e0ef292016-02-19 14:13:03 -0800128 fGeoData[i].fX,
129 fGeoData[i].fY,
Herb Derby2bb343c2018-11-08 15:03:48 -0500130 fGeoData[i].fBlob->runCountLimit());
joshualitta751c972015-11-20 13:37:32 -0800131 }
132
Brian Salomon44acb5b2017-07-18 19:59:24 -0400133 str += fProcessors.dumpProcessors();
134 str += INHERITED::dumpInfo();
joshualitta751c972015-11-20 13:37:32 -0800135 return str;
136}
Brian Osman9a390ac2018-11-12 09:47:48 -0500137#endif
joshualitta751c972015-11-20 13:37:32 -0800138
Brian Salomon44acb5b2017-07-18 19:59:24 -0400139GrDrawOp::FixedFunctionFlags GrAtlasTextOp::fixedFunctionFlags() const {
140 return FixedFunctionFlags::kNone;
141}
142
Chris Dalton6ce447a2019-06-23 18:07:38 -0600143GrProcessorSet::Analysis GrAtlasTextOp::finalize(
144 const GrCaps& caps, const GrAppliedClip* clip, bool hasMixedSampledCoverage,
145 GrClampType clampType) {
Brian Salomon44acb5b2017-07-18 19:59:24 -0400146 GrProcessorAnalysisCoverage coverage;
147 GrProcessorAnalysisColor color;
joshualitta751c972015-11-20 13:37:32 -0800148 if (kColorBitmapMask_MaskType == fMaskType) {
Brian Salomon44acb5b2017-07-18 19:59:24 -0400149 color.setToUnknown();
joshualitta751c972015-11-20 13:37:32 -0800150 } else {
Brian Osman09068252018-01-03 09:57:29 -0500151 color.setToConstant(this->color());
joshualitta751c972015-11-20 13:37:32 -0800152 }
joshualitta751c972015-11-20 13:37:32 -0800153 switch (fMaskType) {
joshualitta751c972015-11-20 13:37:32 -0800154 case kGrayscaleCoverageMask_MaskType:
Jim Van Verth90e89b32017-07-06 16:36:55 -0400155 case kAliasedDistanceField_MaskType:
156 case kGrayscaleDistanceField_MaskType:
Brian Salomon44acb5b2017-07-18 19:59:24 -0400157 coverage = GrProcessorAnalysisCoverage::kSingleChannel;
joshualitta751c972015-11-20 13:37:32 -0800158 break;
159 case kLCDCoverageMask_MaskType:
160 case kLCDDistanceField_MaskType:
Jim Van Verth90e89b32017-07-06 16:36:55 -0400161 case kLCDBGRDistanceField_MaskType:
Brian Salomon44acb5b2017-07-18 19:59:24 -0400162 coverage = GrProcessorAnalysisCoverage::kLCD;
joshualitta751c972015-11-20 13:37:32 -0800163 break;
164 case kColorBitmapMask_MaskType:
Brian Salomon44acb5b2017-07-18 19:59:24 -0400165 coverage = GrProcessorAnalysisCoverage::kNone;
Brian Salomonc0b642c2017-03-27 13:09:36 -0400166 break;
joshualitta751c972015-11-20 13:37:32 -0800167 }
Chris Daltonb8fff0d2019-03-05 10:11:58 -0700168 auto analysis = fProcessors.finalize(
Chris Dalton6ce447a2019-06-23 18:07:38 -0600169 color, coverage, clip, &GrUserStencilSettings::kUnused, hasMixedSampledCoverage, caps,
170 clampType, &fGeoData[0].fColor);
Brian Salomon44acb5b2017-07-18 19:59:24 -0400171 fUsesLocalCoords = analysis.usesLocalCoords();
Chris Dalton4b62aed2019-01-15 11:53:00 -0700172 return analysis;
joshualitta751c972015-11-20 13:37:32 -0800173}
174
Brian Salomon18923f92017-11-06 16:26:02 -0500175static void clip_quads(const SkIRect& clipRect, char* currVertex, const char* blobVertices,
Jim Van Verth58c3cce2017-10-19 15:50:24 -0400176 size_t vertexStride, int glyphCount) {
177 for (int i = 0; i < glyphCount; ++i) {
Brian Salomon18923f92017-11-06 16:26:02 -0500178 const SkPoint* blobPositionLT = reinterpret_cast<const SkPoint*>(blobVertices);
179 const SkPoint* blobPositionRB =
180 reinterpret_cast<const SkPoint*>(blobVertices + 3 * vertexStride);
Jim Van Verth58c3cce2017-10-19 15:50:24 -0400181
Jim Van Verth328a33f2017-10-20 12:14:22 -0400182 // positions for bitmap glyphs are pixel boundary aligned
Brian Osman7ca90d22017-11-10 15:31:27 -0500183 SkIRect positionRect = SkIRect::MakeLTRB(SkScalarRoundToInt(blobPositionLT->fX),
184 SkScalarRoundToInt(blobPositionLT->fY),
185 SkScalarRoundToInt(blobPositionRB->fX),
186 SkScalarRoundToInt(blobPositionRB->fY));
Jim Van Verth58c3cce2017-10-19 15:50:24 -0400187 if (clipRect.contains(positionRect)) {
188 memcpy(currVertex, blobVertices, 4 * vertexStride);
189 currVertex += 4 * vertexStride;
190 } else {
191 // Pull out some more data that we'll need.
192 // In the LCD case the color will be garbage, but we'll overwrite it with the texcoords
193 // and it avoids a lot of conditionals.
Brian Salomon18923f92017-11-06 16:26:02 -0500194 auto color = *reinterpret_cast<const SkColor*>(blobVertices + sizeof(SkPoint));
Jim Van Verth328a33f2017-10-20 12:14:22 -0400195 size_t coordOffset = vertexStride - 2*sizeof(uint16_t);
Brian Salomon18923f92017-11-06 16:26:02 -0500196 auto* blobCoordsLT = reinterpret_cast<const uint16_t*>(blobVertices + coordOffset);
197 auto* blobCoordsRB = reinterpret_cast<const uint16_t*>(blobVertices + 3 * vertexStride +
198 coordOffset);
Jim Van Verth328a33f2017-10-20 12:14:22 -0400199 // Pull out the texel coordinates and texture index bits
200 uint16_t coordsRectL = blobCoordsLT[0] >> 1;
201 uint16_t coordsRectT = blobCoordsLT[1] >> 1;
202 uint16_t coordsRectR = blobCoordsRB[0] >> 1;
203 uint16_t coordsRectB = blobCoordsRB[1] >> 1;
204 uint16_t pageIndexX = blobCoordsLT[0] & 0x1;
205 uint16_t pageIndexY = blobCoordsLT[1] & 0x1;
Jim Van Verth58c3cce2017-10-19 15:50:24 -0400206
Jim Van Verth328a33f2017-10-20 12:14:22 -0400207 int positionRectWidth = positionRect.width();
208 int positionRectHeight = positionRect.height();
209 SkASSERT(positionRectWidth == (coordsRectR - coordsRectL));
210 SkASSERT(positionRectHeight == (coordsRectB - coordsRectT));
Jim Van Verth58c3cce2017-10-19 15:50:24 -0400211
212 // Clip position and texCoords to the clipRect
Jim Van Verth328a33f2017-10-20 12:14:22 -0400213 unsigned int delta;
214 delta = SkTMin(SkTMax(clipRect.fLeft - positionRect.fLeft, 0), positionRectWidth);
215 coordsRectL += delta;
216 positionRect.fLeft += delta;
Jim Van Verth58c3cce2017-10-19 15:50:24 -0400217
Jim Van Verth328a33f2017-10-20 12:14:22 -0400218 delta = SkTMin(SkTMax(clipRect.fTop - positionRect.fTop, 0), positionRectHeight);
219 coordsRectT += delta;
220 positionRect.fTop += delta;
221
222 delta = SkTMin(SkTMax(positionRect.fRight - clipRect.fRight, 0), positionRectWidth);
223 coordsRectR -= delta;
224 positionRect.fRight -= delta;
225
226 delta = SkTMin(SkTMax(positionRect.fBottom - clipRect.fBottom, 0), positionRectHeight);
227 coordsRectB -= delta;
228 positionRect.fBottom -= delta;
229
230 // Repack texel coordinates and index
231 coordsRectL = coordsRectL << 1 | pageIndexX;
232 coordsRectT = coordsRectT << 1 | pageIndexY;
233 coordsRectR = coordsRectR << 1 | pageIndexX;
234 coordsRectB = coordsRectB << 1 | pageIndexY;
235
236 // Set new positions and coords
Jim Van Verth58c3cce2017-10-19 15:50:24 -0400237 SkPoint* currPosition = reinterpret_cast<SkPoint*>(currVertex);
238 currPosition->fX = positionRect.fLeft;
239 currPosition->fY = positionRect.fTop;
240 *(reinterpret_cast<SkColor*>(currVertex + sizeof(SkPoint))) = color;
Jim Van Verth328a33f2017-10-20 12:14:22 -0400241 uint16_t* currCoords = reinterpret_cast<uint16_t*>(currVertex + coordOffset);
242 currCoords[0] = coordsRectL;
243 currCoords[1] = coordsRectT;
Jim Van Verth58c3cce2017-10-19 15:50:24 -0400244 currVertex += vertexStride;
245
246 currPosition = reinterpret_cast<SkPoint*>(currVertex);
247 currPosition->fX = positionRect.fLeft;
248 currPosition->fY = positionRect.fBottom;
249 *(reinterpret_cast<SkColor*>(currVertex + sizeof(SkPoint))) = color;
Jim Van Verth328a33f2017-10-20 12:14:22 -0400250 currCoords = reinterpret_cast<uint16_t*>(currVertex + coordOffset);
251 currCoords[0] = coordsRectL;
252 currCoords[1] = coordsRectB;
Jim Van Verth58c3cce2017-10-19 15:50:24 -0400253 currVertex += vertexStride;
254
255 currPosition = reinterpret_cast<SkPoint*>(currVertex);
256 currPosition->fX = positionRect.fRight;
257 currPosition->fY = positionRect.fTop;
258 *(reinterpret_cast<SkColor*>(currVertex + sizeof(SkPoint))) = color;
Jim Van Verth328a33f2017-10-20 12:14:22 -0400259 currCoords = reinterpret_cast<uint16_t*>(currVertex + coordOffset);
260 currCoords[0] = coordsRectR;
261 currCoords[1] = coordsRectT;
Jim Van Verth58c3cce2017-10-19 15:50:24 -0400262 currVertex += vertexStride;
263
264 currPosition = reinterpret_cast<SkPoint*>(currVertex);
265 currPosition->fX = positionRect.fRight;
266 currPosition->fY = positionRect.fBottom;
267 *(reinterpret_cast<SkColor*>(currVertex + sizeof(SkPoint))) = color;
Jim Van Verth328a33f2017-10-20 12:14:22 -0400268 currCoords = reinterpret_cast<uint16_t*>(currVertex + coordOffset);
269 currCoords[0] = coordsRectR;
270 currCoords[1] = coordsRectB;
Jim Van Verth58c3cce2017-10-19 15:50:24 -0400271 currVertex += vertexStride;
272 }
273
274 blobVertices += 4 * vertexStride;
275 }
276}
277
Brian Salomon91326c32017-08-09 16:02:19 -0400278void GrAtlasTextOp::onPrepareDraws(Target* target) {
Robert Phillips4bc70112018-03-01 10:24:02 -0500279 auto resourceProvider = target->resourceProvider();
280
joshualitta751c972015-11-20 13:37:32 -0800281 // if we have RGB, then we won't have any SkShaders so no need to use a localmatrix.
282 // TODO actually only invert if we don't have RGBA
283 SkMatrix localMatrix;
Brian Salomon5c6ac642017-12-19 11:09:32 -0500284 if (this->usesLocalCoords() && !fGeoData[0].fViewMatrix.invert(&localMatrix)) {
joshualitta751c972015-11-20 13:37:32 -0800285 return;
286 }
287
Robert Phillips5a66efb2018-03-07 15:13:18 -0500288 GrAtlasManager* atlasManager = target->atlasManager();
Herb Derby081e6f32019-01-16 13:46:02 -0500289 GrStrikeCache* glyphCache = target->glyphCache();
Robert Phillipsc4039ea2018-03-01 11:36:45 -0500290
Jim Van Vertheafa64b2017-09-18 10:05:00 -0400291 GrMaskFormat maskFormat = this->maskFormat();
292
Jim Van Verthcbeae032018-05-16 14:54:41 -0400293 unsigned int numActiveProxies;
294 const sk_sp<GrTextureProxy>* proxies = atlasManager->getProxies(maskFormat, &numActiveProxies);
295 if (!proxies) {
joshualitta751c972015-11-20 13:37:32 -0800296 SkDebugf("Could not allocate backing texture for atlas\n");
297 return;
298 }
Jim Van Verthcbeae032018-05-16 14:54:41 -0400299 SkASSERT(proxies[0]);
joshualitta751c972015-11-20 13:37:32 -0800300
Brian Salomon7eae3e02018-08-07 14:02:38 +0000301 static constexpr int kMaxTextures = GrBitmapTextGeoProc::kMaxTextures;
302 GR_STATIC_ASSERT(GrDistanceFieldA8TextGeoProc::kMaxTextures == kMaxTextures);
303 GR_STATIC_ASSERT(GrDistanceFieldLCDTextGeoProc::kMaxTextures == kMaxTextures);
304
Chris Dalton07cdcfc92019-02-26 11:13:22 -0700305 auto fixedDynamicState = target->makeFixedDynamicState(kMaxTextures);
Brian Salomon7eae3e02018-08-07 14:02:38 +0000306 for (unsigned i = 0; i < numActiveProxies; ++i) {
Chris Dalton07cdcfc92019-02-26 11:13:22 -0700307 fixedDynamicState->fPrimitiveProcessorTextures[i] = proxies[i].get();
Brian Salomon7eae3e02018-08-07 14:02:38 +0000308 }
Brian Salomon49348902018-06-26 09:12:38 -0400309
310 FlushInfo flushInfo;
Chris Dalton07cdcfc92019-02-26 11:13:22 -0700311 flushInfo.fFixedDynamicState = fixedDynamicState;
Brian Salomon49348902018-06-26 09:12:38 -0400312
Jim Van Verthb515ae72018-05-23 16:44:55 -0400313 bool vmPerspective = fGeoData[0].fViewMatrix.hasPerspective();
joshualittd9d30f72015-12-08 10:47:55 -0800314 if (this->usesDistanceFields()) {
Brian Osman4a3f5c82018-09-18 16:16:38 -0400315 flushInfo.fGeometryProcessor = this->setupDfProcessor(*target->caps().shaderCaps(),
316 proxies, numActiveProxies);
joshualitta751c972015-11-20 13:37:32 -0800317 } else {
Jim Van Verthb515ae72018-05-23 16:44:55 -0400318 GrSamplerState samplerState = fNeedsGlyphTransform ? GrSamplerState::ClampBilerp()
319 : GrSamplerState::ClampNearest();
Brian Salomon2bbdcc42017-09-07 12:36:34 -0400320 flushInfo.fGeometryProcessor = GrBitmapTextGeoProc::Make(
Brian Osmanc906d252018-12-04 11:17:46 -0500321 *target->caps().shaderCaps(), this->color(), false, proxies, numActiveProxies,
322 samplerState, maskFormat, localMatrix, vmPerspective);
joshualitta751c972015-11-20 13:37:32 -0800323 }
324
joshualitta751c972015-11-20 13:37:32 -0800325 flushInfo.fGlyphsToFlush = 0;
Brian Osmanf04fb3c2018-11-12 15:34:00 -0500326 size_t vertexStride = flushInfo.fGeometryProcessor->vertexStride();
joshualitta751c972015-11-20 13:37:32 -0800327
joshualitta751c972015-11-20 13:37:32 -0800328 int glyphCount = this->numGlyphs();
joshualitta751c972015-11-20 13:37:32 -0800329
Brian Salomon12d22642019-01-29 14:38:50 -0500330 void* vertices = target->makeVertexSpace(vertexStride, glyphCount * kVerticesPerGlyph,
331 &flushInfo.fVertexBuffer, &flushInfo.fVertexOffset);
Robert Phillips82774f82019-06-20 14:38:27 -0400332 flushInfo.fIndexBuffer = resourceProvider->refQuadIndexBuffer();
joshualitta751c972015-11-20 13:37:32 -0800333 if (!vertices || !flushInfo.fVertexBuffer) {
334 SkDebugf("Could not allocate vertices\n");
335 return;
336 }
337
Brian Salomon18923f92017-11-06 16:26:02 -0500338 char* currVertex = reinterpret_cast<char*>(vertices);
joshualitta751c972015-11-20 13:37:32 -0800339
Herb Derby7956b592018-03-22 16:10:30 -0400340 SkExclusiveStrikePtr autoGlyphCache;
Jim Van Verth58c3cce2017-10-19 15:50:24 -0400341 // each of these is a SubRun
joshualitta751c972015-11-20 13:37:32 -0800342 for (int i = 0; i < fGeoCount; i++) {
joshualitt144c3c82015-11-30 12:30:13 -0800343 const Geometry& args = fGeoData[i];
joshualitta751c972015-11-20 13:37:32 -0800344 Blob* blob = args.fBlob;
Brian Osman1be2b7c2018-10-29 16:07:15 -0400345 // TODO4F: Preserve float colors
Herb Derby86240592018-05-24 16:12:31 -0400346 GrTextBlob::VertexRegenerator regenerator(
Robert Phillips4bc70112018-03-01 10:24:02 -0500347 resourceProvider, blob, args.fRun, args.fSubRun, args.fViewMatrix, args.fX, args.fY,
Brian Osmancf860852018-10-31 14:04:39 -0400348 args.fColor.toBytes_RGBA(), target->deferredUploadTarget(), glyphCache,
349 atlasManager, &autoGlyphCache);
Robert Phillipsd2e9f762018-03-07 11:54:37 -0500350 bool done = false;
351 while (!done) {
Herb Derby86240592018-05-24 16:12:31 -0400352 GrTextBlob::VertexRegenerator::Result result;
Robert Phillipsd2e9f762018-03-07 11:54:37 -0500353 if (!regenerator.regenerate(&result)) {
354 break;
355 }
356 done = result.fFinished;
357
Brian Salomon18923f92017-11-06 16:26:02 -0500358 // Copy regenerated vertices from the blob to our vertex buffer.
359 size_t vertexBytes = result.fGlyphsRegenerated * kVerticesPerGlyph * vertexStride;
360 if (args.fClipRect.isEmpty()) {
361 memcpy(currVertex, result.fFirstVertex, vertexBytes);
362 } else {
Jim Van Verthb515ae72018-05-23 16:44:55 -0400363 SkASSERT(!vmPerspective);
Brian Salomon18923f92017-11-06 16:26:02 -0500364 clip_quads(args.fClipRect, currVertex, result.fFirstVertex, vertexStride,
365 result.fGlyphsRegenerated);
366 }
Jim Van Verthb515ae72018-05-23 16:44:55 -0400367 if (fNeedsGlyphTransform && !args.fViewMatrix.isIdentity()) {
Brian Salomon5c6ac642017-12-19 11:09:32 -0500368 // We always do the distance field view matrix transformation after copying rather
369 // than during blob vertex generation time in the blob as handling successive
370 // arbitrary transformations would be complicated and accumulate error.
371 if (args.fViewMatrix.hasPerspective()) {
372 auto* pos = reinterpret_cast<SkPoint3*>(currVertex);
Brian Salomon7c2192b2018-01-08 09:47:57 -0500373 SkMatrixPriv::MapHomogeneousPointsWithStride(
374 args.fViewMatrix, pos, vertexStride, pos, vertexStride,
375 result.fGlyphsRegenerated * kVerticesPerGlyph);
Brian Salomon5c6ac642017-12-19 11:09:32 -0500376 } else {
377 auto* pos = reinterpret_cast<SkPoint*>(currVertex);
Brian Salomonfa3783f2018-01-05 13:49:07 -0500378 SkMatrixPriv::MapPointsWithStride(
379 args.fViewMatrix, pos, vertexStride,
380 result.fGlyphsRegenerated * kVerticesPerGlyph);
Brian Salomon5c6ac642017-12-19 11:09:32 -0500381 }
382 }
Brian Salomon18923f92017-11-06 16:26:02 -0500383 flushInfo.fGlyphsToFlush += result.fGlyphsRegenerated;
384 if (!result.fFinished) {
385 this->flush(target, &flushInfo);
386 }
387 currVertex += vertexBytes;
Robert Phillipsd2e9f762018-03-07 11:54:37 -0500388 }
joshualitta751c972015-11-20 13:37:32 -0800389 }
joshualitta751c972015-11-20 13:37:32 -0800390 this->flush(target, &flushInfo);
391}
392
Chris Dalton07cdcfc92019-02-26 11:13:22 -0700393void GrAtlasTextOp::onExecute(GrOpFlushState* flushState, const SkRect& chainBounds) {
Chris Dalton07cdcfc92019-02-26 11:13:22 -0700394 flushState->executeDrawsAndUploadsForMeshDrawOp(
Chris Daltonbaa1b352019-04-03 12:03:00 -0600395 this, chainBounds, std::move(fProcessors), GrPipeline::InputFlags::kNone);
Chris Dalton07cdcfc92019-02-26 11:13:22 -0700396}
397
Brian Salomone5b399e2017-07-19 13:50:54 -0400398void GrAtlasTextOp::flush(GrMeshDrawOp::Target* target, FlushInfo* flushInfo) const {
Robert Phillipsd2e9f762018-03-07 11:54:37 -0500399 if (!flushInfo->fGlyphsToFlush) {
400 return;
401 }
402
Robert Phillips5a66efb2018-03-07 15:13:18 -0500403 auto atlasManager = target->atlasManager();
Robert Phillipsc4039ea2018-03-01 11:36:45 -0500404
Jim Van Vertheafa64b2017-09-18 10:05:00 -0400405 GrGeometryProcessor* gp = flushInfo->fGeometryProcessor.get();
406 GrMaskFormat maskFormat = this->maskFormat();
Robert Phillipsf3690dd2018-02-20 15:18:59 -0500407
Jim Van Verthcbeae032018-05-16 14:54:41 -0400408 unsigned int numActiveProxies;
409 const sk_sp<GrTextureProxy>* proxies = atlasManager->getProxies(maskFormat, &numActiveProxies);
410 SkASSERT(proxies);
411 if (gp->numTextureSamplers() != (int) numActiveProxies) {
Jim Van Vertheafa64b2017-09-18 10:05:00 -0400412 // During preparation the number of atlas pages has increased.
413 // Update the proxies used in the GP to match.
Brian Salomon7eae3e02018-08-07 14:02:38 +0000414 for (unsigned i = gp->numTextureSamplers(); i < numActiveProxies; ++i) {
415 flushInfo->fFixedDynamicState->fPrimitiveProcessorTextures[i] = proxies[i].get();
416 }
Jim Van Vertheafa64b2017-09-18 10:05:00 -0400417 if (this->usesDistanceFields()) {
418 if (this->isLCD()) {
419 reinterpret_cast<GrDistanceFieldLCDTextGeoProc*>(gp)->addNewProxies(
Jim Van Verthcbeae032018-05-16 14:54:41 -0400420 proxies, numActiveProxies, GrSamplerState::ClampBilerp());
Jim Van Vertheafa64b2017-09-18 10:05:00 -0400421 } else {
422 reinterpret_cast<GrDistanceFieldA8TextGeoProc*>(gp)->addNewProxies(
Jim Van Verthcbeae032018-05-16 14:54:41 -0400423 proxies, numActiveProxies, GrSamplerState::ClampBilerp());
Jim Van Vertheafa64b2017-09-18 10:05:00 -0400424 }
425 } else {
Jim Van Verthb515ae72018-05-23 16:44:55 -0400426 GrSamplerState samplerState = fNeedsGlyphTransform ? GrSamplerState::ClampBilerp()
427 : GrSamplerState::ClampNearest();
Jim Van Verthcbeae032018-05-16 14:54:41 -0400428 reinterpret_cast<GrBitmapTextGeoProc*>(gp)->addNewProxies(proxies, numActiveProxies,
Jim Van Verthcf838c72018-03-05 14:40:36 -0500429 samplerState);
Jim Van Vertheafa64b2017-09-18 10:05:00 -0400430 }
431 }
Brian Salomondbf70722019-02-07 11:31:24 -0500432 int maxGlyphsPerDraw = static_cast<int>(flushInfo->fIndexBuffer->size() / sizeof(uint16_t) / 6);
Brian Salomon7eae3e02018-08-07 14:02:38 +0000433 GrMesh* mesh = target->allocMesh(GrPrimitiveType::kTriangles);
Brian Salomon12d22642019-01-29 14:38:50 -0500434 mesh->setIndexedPatterned(flushInfo->fIndexBuffer, kIndicesPerGlyph, kVerticesPerGlyph,
Brian Salomon7eae3e02018-08-07 14:02:38 +0000435 flushInfo->fGlyphsToFlush, maxGlyphsPerDraw);
Brian Salomon12d22642019-01-29 14:38:50 -0500436 mesh->setVertexData(flushInfo->fVertexBuffer, flushInfo->fVertexOffset);
Chris Dalton07cdcfc92019-02-26 11:13:22 -0700437 target->recordDraw(
438 flushInfo->fGeometryProcessor, mesh, 1, flushInfo->fFixedDynamicState, nullptr);
joshualitta751c972015-11-20 13:37:32 -0800439 flushInfo->fVertexOffset += kVerticesPerGlyph * flushInfo->fGlyphsToFlush;
440 flushInfo->fGlyphsToFlush = 0;
441}
442
Brian Salomon7eae3e02018-08-07 14:02:38 +0000443GrOp::CombineResult GrAtlasTextOp::onCombineIfPossible(GrOp* t, const GrCaps& caps) {
Brian Salomon344ec422016-12-15 10:58:41 -0500444 GrAtlasTextOp* that = t->cast<GrAtlasTextOp>();
Brian Salomon44acb5b2017-07-18 19:59:24 -0400445 if (fProcessors != that->fProcessors) {
Brian Salomon7eae3e02018-08-07 14:02:38 +0000446 return CombineResult::kCannotCombine;
Brian Salomon44acb5b2017-07-18 19:59:24 -0400447 }
448
joshualitta751c972015-11-20 13:37:32 -0800449 if (fMaskType != that->fMaskType) {
Brian Salomon7eae3e02018-08-07 14:02:38 +0000450 return CombineResult::kCannotCombine;
joshualitta751c972015-11-20 13:37:32 -0800451 }
452
Brian Salomon5c6ac642017-12-19 11:09:32 -0500453 const SkMatrix& thisFirstMatrix = fGeoData[0].fViewMatrix;
454 const SkMatrix& thatFirstMatrix = that->fGeoData[0].fViewMatrix;
455
456 if (this->usesLocalCoords() && !thisFirstMatrix.cheapEqualTo(thatFirstMatrix)) {
Brian Salomon7eae3e02018-08-07 14:02:38 +0000457 return CombineResult::kCannotCombine;
Brian Salomon5c6ac642017-12-19 11:09:32 -0500458 }
459
Jim Van Verthb515ae72018-05-23 16:44:55 -0400460 if (fNeedsGlyphTransform != that->fNeedsGlyphTransform) {
Brian Salomon7eae3e02018-08-07 14:02:38 +0000461 return CombineResult::kCannotCombine;
Jim Van Verthb515ae72018-05-23 16:44:55 -0400462 }
463
464 if (fNeedsGlyphTransform &&
465 (thisFirstMatrix.hasPerspective() != thatFirstMatrix.hasPerspective())) {
Brian Salomon7eae3e02018-08-07 14:02:38 +0000466 return CombineResult::kCannotCombine;
Jim Van Verthb515ae72018-05-23 16:44:55 -0400467 }
468
Brian Salomon5c6ac642017-12-19 11:09:32 -0500469 if (this->usesDistanceFields()) {
470 if (fDFGPFlags != that->fDFGPFlags) {
Brian Salomon7eae3e02018-08-07 14:02:38 +0000471 return CombineResult::kCannotCombine;
joshualitta751c972015-11-20 13:37:32 -0800472 }
473
Jim Van Verthbc2cdd12017-06-08 11:14:35 -0400474 if (fLuminanceColor != that->fLuminanceColor) {
Brian Salomon7eae3e02018-08-07 14:02:38 +0000475 return CombineResult::kCannotCombine;
joshualitta751c972015-11-20 13:37:32 -0800476 }
Brian Salomon5c6ac642017-12-19 11:09:32 -0500477 } else {
478 if (kColorBitmapMask_MaskType == fMaskType && this->color() != that->color()) {
Brian Salomon7eae3e02018-08-07 14:02:38 +0000479 return CombineResult::kCannotCombine;
Brian Salomon5c6ac642017-12-19 11:09:32 -0500480 }
joshualitta751c972015-11-20 13:37:32 -0800481 }
482
Jim Van Verthc8a65e32017-10-25 14:25:27 -0400483 // Keep the batch vertex buffer size below 32K so we don't have to create a special one
484 // We use the largest possible vertex size for this
485 static const int kVertexSize = sizeof(SkPoint) + sizeof(SkColor) + 2 * sizeof(uint16_t);
Jim Van Verth56c37142017-10-31 14:44:25 -0400486 static const int kMaxGlyphs = 32768 / (kVerticesPerGlyph * kVertexSize);
Jim Van Verthc8a65e32017-10-25 14:25:27 -0400487 if (this->fNumGlyphs + that->fNumGlyphs > kMaxGlyphs) {
Brian Salomon7eae3e02018-08-07 14:02:38 +0000488 return CombineResult::kCannotCombine;
Jim Van Verthc8a65e32017-10-25 14:25:27 -0400489 }
490
Brian Salomon344ec422016-12-15 10:58:41 -0500491 fNumGlyphs += that->numGlyphs();
joshualitta751c972015-11-20 13:37:32 -0800492
Jim Van Verth56c37142017-10-31 14:44:25 -0400493 // Reallocate space for geo data if necessary and then import that geo's data.
joshualitta751c972015-11-20 13:37:32 -0800494 int newGeoCount = that->fGeoCount + fGeoCount;
joshualitta751c972015-11-20 13:37:32 -0800495
Jim Van Verthc8a65e32017-10-25 14:25:27 -0400496 // We reallocate at a rate of 1.5x to try to get better total memory usage
497 if (newGeoCount > fGeoDataAllocSize) {
Jim Van Verth56c37142017-10-31 14:44:25 -0400498 int newAllocSize = fGeoDataAllocSize + fGeoDataAllocSize / 2;
Jim Van Verthc8a65e32017-10-25 14:25:27 -0400499 while (newAllocSize < newGeoCount) {
500 newAllocSize += newAllocSize / 2;
501 }
joshualitta751c972015-11-20 13:37:32 -0800502 fGeoData.realloc(newAllocSize);
Jim Van Verthc8a65e32017-10-25 14:25:27 -0400503 fGeoDataAllocSize = newAllocSize;
joshualitta751c972015-11-20 13:37:32 -0800504 }
505
Brian Salomon344ec422016-12-15 10:58:41 -0500506 // We steal the ref on the blobs from the other AtlasTextOp and set its count to 0 so that
joshualitta751c972015-11-20 13:37:32 -0800507 // it doesn't try to unref them.
Brian Salomon344ec422016-12-15 10:58:41 -0500508 memcpy(&fGeoData[fGeoCount], that->fGeoData.get(), that->fGeoCount * sizeof(Geometry));
joshualitta751c972015-11-20 13:37:32 -0800509#ifdef SK_DEBUG
510 for (int i = 0; i < that->fGeoCount; ++i) {
511 that->fGeoData.get()[i].fBlob = (Blob*)0x1;
512 }
513#endif
514 that->fGeoCount = 0;
515 fGeoCount = newGeoCount;
516
Brian Salomon7eae3e02018-08-07 14:02:38 +0000517 return CombineResult::kMerged;
joshualitta751c972015-11-20 13:37:32 -0800518}
519
joshualitta751c972015-11-20 13:37:32 -0800520// TODO trying to figure out why lcd is so whack
Herb Derby26cbe512018-05-24 14:39:01 -0400521// (see comments in GrTextContext::ComputeCanonicalColor)
Brian Osman4a3f5c82018-09-18 16:16:38 -0400522sk_sp<GrGeometryProcessor> GrAtlasTextOp::setupDfProcessor(const GrShaderCaps& caps,
523 const sk_sp<GrTextureProxy>* proxies,
Jim Van Verthcbeae032018-05-16 14:54:41 -0400524 unsigned int numActiveProxies) const {
joshualitta751c972015-11-20 13:37:32 -0800525 bool isLCD = this->isLCD();
Brian Salomon5c6ac642017-12-19 11:09:32 -0500526
527 SkMatrix localMatrix = SkMatrix::I();
528 if (this->usesLocalCoords()) {
529 // If this fails we'll just use I().
530 bool result = fGeoData[0].fViewMatrix.invert(&localMatrix);
531 (void)result;
532 }
joshualitta751c972015-11-20 13:37:32 -0800533
534 // see if we need to create a new effect
535 if (isLCD) {
brianosman0586f5c2016-04-12 12:48:21 -0700536 float redCorrection = fDistanceAdjustTable->getAdjustment(
Jim Van Verth58c3cce2017-10-19 15:50:24 -0400537 SkColorGetR(fLuminanceColor) >> kDistanceAdjustLumShift,
Brian Salomon344ec422016-12-15 10:58:41 -0500538 fUseGammaCorrectDistanceTable);
brianosman0586f5c2016-04-12 12:48:21 -0700539 float greenCorrection = fDistanceAdjustTable->getAdjustment(
Jim Van Verth58c3cce2017-10-19 15:50:24 -0400540 SkColorGetG(fLuminanceColor) >> kDistanceAdjustLumShift,
Brian Salomon344ec422016-12-15 10:58:41 -0500541 fUseGammaCorrectDistanceTable);
brianosman0586f5c2016-04-12 12:48:21 -0700542 float blueCorrection = fDistanceAdjustTable->getAdjustment(
Jim Van Verth58c3cce2017-10-19 15:50:24 -0400543 SkColorGetB(fLuminanceColor) >> kDistanceAdjustLumShift,
Brian Salomon344ec422016-12-15 10:58:41 -0500544 fUseGammaCorrectDistanceTable);
joshualitta751c972015-11-20 13:37:32 -0800545 GrDistanceFieldLCDTextGeoProc::DistanceAdjust widthAdjust =
Brian Salomon344ec422016-12-15 10:58:41 -0500546 GrDistanceFieldLCDTextGeoProc::DistanceAdjust::Make(
547 redCorrection, greenCorrection, blueCorrection);
Brian Osman4a3f5c82018-09-18 16:16:38 -0400548 return GrDistanceFieldLCDTextGeoProc::Make(caps, proxies, numActiveProxies,
Robert Phillips4bc70112018-03-01 10:24:02 -0500549 GrSamplerState::ClampBilerp(), widthAdjust,
Brian Osman09068252018-01-03 09:57:29 -0500550 fDFGPFlags, localMatrix);
joshualitta751c972015-11-20 13:37:32 -0800551 } else {
joshualitta751c972015-11-20 13:37:32 -0800552#ifdef SK_GAMMA_APPLY_TO_A8
Jim Van Verth90e89b32017-07-06 16:36:55 -0400553 float correction = 0;
554 if (kAliasedDistanceField_MaskType != fMaskType) {
Jim Van Verth58c3cce2017-10-19 15:50:24 -0400555 U8CPU lum = SkColorSpaceLuminance::computeLuminance(SK_GAMMA_EXPONENT,
556 fLuminanceColor);
Jim Van Verth90e89b32017-07-06 16:36:55 -0400557 correction = fDistanceAdjustTable->getAdjustment(lum >> kDistanceAdjustLumShift,
558 fUseGammaCorrectDistanceTable);
559 }
Brian Osman4a3f5c82018-09-18 16:16:38 -0400560 return GrDistanceFieldA8TextGeoProc::Make(caps, proxies, numActiveProxies,
Robert Phillips4bc70112018-03-01 10:24:02 -0500561 GrSamplerState::ClampBilerp(),
Brian Salomon5c6ac642017-12-19 11:09:32 -0500562 correction, fDFGPFlags, localMatrix);
joshualitta751c972015-11-20 13:37:32 -0800563#else
Brian Osman4a3f5c82018-09-18 16:16:38 -0400564 return GrDistanceFieldA8TextGeoProc::Make(caps, proxies, numActiveProxies,
Robert Phillips4bc70112018-03-01 10:24:02 -0500565 GrSamplerState::ClampBilerp(),
Brian Salomon5c6ac642017-12-19 11:09:32 -0500566 fDFGPFlags, localMatrix);
joshualitta751c972015-11-20 13:37:32 -0800567#endif
568 }
joshualitta751c972015-11-20 13:37:32 -0800569}
joshualittddd22d82016-02-16 06:47:52 -0800570