joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright 2015 Google Inc. |
| 3 | * |
| 4 | * Use of this source code is governed by a BSD-style license that can be |
| 5 | * found in the LICENSE file. |
| 6 | */ |
| 7 | |
Brian Salomon | 09e019e | 2016-12-15 10:20:35 -0500 | [diff] [blame] | 8 | #include "GrAtlasTextOp.h" |
Robert Phillips | e4fda6c | 2018-02-21 12:10:41 -0500 | [diff] [blame] | 9 | |
Robert Phillips | 296b1cc | 2017-03-15 10:42:12 -0400 | [diff] [blame] | 10 | #include "GrContext.h" |
Robert Phillips | c994a93 | 2018-06-19 13:09:54 -0400 | [diff] [blame^] | 11 | #include "GrContextPriv.h" |
Robert Phillips | 7c525e6 | 2018-06-12 10:11:12 -0400 | [diff] [blame] | 12 | #include "GrMemoryPool.h" |
Brian Salomon | 742e31d | 2016-12-07 17:06:19 -0500 | [diff] [blame] | 13 | #include "GrOpFlushState.h" |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 14 | #include "GrResourceProvider.h" |
halcanary | 4dbbd04 | 2016-06-07 17:21:10 -0700 | [diff] [blame] | 15 | #include "SkMathPriv.h" |
Brian Salomon | 5c6ac64 | 2017-12-19 11:09:32 -0500 | [diff] [blame] | 16 | #include "SkMatrixPriv.h" |
| 17 | #include "SkPoint3.h" |
Herb Derby | dce19a7 | 2018-04-18 16:02:17 -0400 | [diff] [blame] | 18 | #include "SkStrikeCache.h" |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 19 | #include "effects/GrBitmapTextGeoProc.h" |
| 20 | #include "effects/GrDistanceFieldGeoProc.h" |
Robert Phillips | c4039ea | 2018-03-01 11:36:45 -0500 | [diff] [blame] | 21 | #include "text/GrAtlasManager.h" |
| 22 | #include "text/GrGlyphCache.h" |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 23 | |
joshualitt | 60ce86d | 2015-11-23 13:08:22 -0800 | [diff] [blame] | 24 | /////////////////////////////////////////////////////////////////////////////////////////////////// |
| 25 | |
Robert Phillips | 7c525e6 | 2018-06-12 10:11:12 -0400 | [diff] [blame] | 26 | std::unique_ptr<GrAtlasTextOp> GrAtlasTextOp::MakeBitmap(GrContext* context, |
| 27 | GrPaint&& paint, |
| 28 | GrMaskFormat maskFormat, |
| 29 | int glyphCount, |
| 30 | bool needsTransform) { |
Robert Phillips | c994a93 | 2018-06-19 13:09:54 -0400 | [diff] [blame^] | 31 | GrOpMemoryPool* pool = context->contextPriv().opMemoryPool(); |
| 32 | |
| 33 | std::unique_ptr<GrAtlasTextOp> op = pool->allocate<GrAtlasTextOp>(std::move(paint)); |
Robert Phillips | 7c525e6 | 2018-06-12 10:11:12 -0400 | [diff] [blame] | 34 | |
| 35 | switch (maskFormat) { |
| 36 | case kA8_GrMaskFormat: |
| 37 | op->fMaskType = kGrayscaleCoverageMask_MaskType; |
| 38 | break; |
| 39 | case kA565_GrMaskFormat: |
| 40 | op->fMaskType = kLCDCoverageMask_MaskType; |
| 41 | break; |
| 42 | case kARGB_GrMaskFormat: |
| 43 | op->fMaskType = kColorBitmapMask_MaskType; |
| 44 | break; |
| 45 | } |
| 46 | op->fNumGlyphs = glyphCount; |
| 47 | op->fGeoCount = 1; |
| 48 | op->fLuminanceColor = 0; |
| 49 | op->fNeedsGlyphTransform = needsTransform; |
| 50 | return op; |
| 51 | } |
| 52 | |
| 53 | std::unique_ptr<GrAtlasTextOp> GrAtlasTextOp::MakeDistanceField( |
| 54 | GrContext* context, |
| 55 | GrPaint&& paint, |
| 56 | int glyphCount, |
| 57 | const GrDistanceFieldAdjustTable* distanceAdjustTable, |
| 58 | bool useGammaCorrectDistanceTable, |
| 59 | SkColor luminanceColor, |
| 60 | const SkSurfaceProps& props, |
| 61 | bool isAntiAliased, |
| 62 | bool useLCD) { |
Robert Phillips | c994a93 | 2018-06-19 13:09:54 -0400 | [diff] [blame^] | 63 | GrOpMemoryPool* pool = context->contextPriv().opMemoryPool(); |
| 64 | |
| 65 | std::unique_ptr<GrAtlasTextOp> op = pool->allocate<GrAtlasTextOp>(std::move(paint)); |
Robert Phillips | 7c525e6 | 2018-06-12 10:11:12 -0400 | [diff] [blame] | 66 | |
| 67 | bool isBGR = SkPixelGeometryIsBGR(props.pixelGeometry()); |
| 68 | bool isLCD = useLCD && SkPixelGeometryIsH(props.pixelGeometry()); |
| 69 | op->fMaskType = !isAntiAliased ? kAliasedDistanceField_MaskType |
| 70 | : isLCD ? (isBGR ? kLCDBGRDistanceField_MaskType |
| 71 | : kLCDDistanceField_MaskType) |
| 72 | : kGrayscaleDistanceField_MaskType; |
| 73 | op->fDistanceAdjustTable.reset(SkRef(distanceAdjustTable)); |
| 74 | op->fUseGammaCorrectDistanceTable = useGammaCorrectDistanceTable; |
| 75 | op->fLuminanceColor = luminanceColor; |
| 76 | op->fNumGlyphs = glyphCount; |
| 77 | op->fGeoCount = 1; |
| 78 | return op; |
| 79 | } |
| 80 | |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 81 | static const int kDistanceAdjustLumShift = 5; |
| 82 | |
Brian Salomon | 5c6ac64 | 2017-12-19 11:09:32 -0500 | [diff] [blame] | 83 | void GrAtlasTextOp::init() { |
| 84 | const Geometry& geo = fGeoData[0]; |
Brian Salomon | 5c6ac64 | 2017-12-19 11:09:32 -0500 | [diff] [blame] | 85 | if (this->usesDistanceFields()) { |
| 86 | bool isLCD = this->isLCD(); |
| 87 | |
| 88 | const SkMatrix& viewMatrix = geo.fViewMatrix; |
| 89 | |
| 90 | fDFGPFlags = viewMatrix.isSimilarity() ? kSimilarity_DistanceFieldEffectFlag : 0; |
| 91 | fDFGPFlags |= viewMatrix.isScaleTranslate() ? kScaleOnly_DistanceFieldEffectFlag : 0; |
| 92 | fDFGPFlags |= viewMatrix.hasPerspective() ? kPerspective_DistanceFieldEffectFlag : 0; |
| 93 | fDFGPFlags |= fUseGammaCorrectDistanceTable ? kGammaCorrect_DistanceFieldEffectFlag : 0; |
| 94 | fDFGPFlags |= (kAliasedDistanceField_MaskType == fMaskType) |
| 95 | ? kAliased_DistanceFieldEffectFlag |
| 96 | : 0; |
| 97 | |
| 98 | if (isLCD) { |
| 99 | fDFGPFlags |= kUseLCD_DistanceFieldEffectFlag; |
| 100 | fDFGPFlags |= |
| 101 | (kLCDBGRDistanceField_MaskType == fMaskType) ? kBGR_DistanceFieldEffectFlag : 0; |
| 102 | } |
Jim Van Verth | b515ae7 | 2018-05-23 16:44:55 -0400 | [diff] [blame] | 103 | |
| 104 | fNeedsGlyphTransform = true; |
Brian Salomon | 5c6ac64 | 2017-12-19 11:09:32 -0500 | [diff] [blame] | 105 | } |
Jim Van Verth | 7027691 | 2018-06-01 13:46:46 -0400 | [diff] [blame] | 106 | |
| 107 | SkRect bounds; |
| 108 | geo.fBlob->computeSubRunBounds(&bounds, geo.fRun, geo.fSubRun, geo.fViewMatrix, geo.fX, geo.fY, |
| 109 | fNeedsGlyphTransform); |
| 110 | // We don't have tight bounds on the glyph paths in device space. For the purposes of bounds |
| 111 | // we treat this as a set of non-AA rects rendered with a texture. |
| 112 | this->setBounds(bounds, HasAABloat::kNo, IsZeroArea::kNo); |
Brian Salomon | 5c6ac64 | 2017-12-19 11:09:32 -0500 | [diff] [blame] | 113 | } |
| 114 | |
Robert Phillips | e4fda6c | 2018-02-21 12:10:41 -0500 | [diff] [blame] | 115 | void GrAtlasTextOp::visitProxies(const VisitProxyFunc& func) const { |
| 116 | fProcessors.visitProxies(func); |
Robert Phillips | e4fda6c | 2018-02-21 12:10:41 -0500 | [diff] [blame] | 117 | } |
| 118 | |
Brian Salomon | 344ec42 | 2016-12-15 10:58:41 -0500 | [diff] [blame] | 119 | SkString GrAtlasTextOp::dumpInfo() const { |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 120 | SkString str; |
| 121 | |
| 122 | for (int i = 0; i < fGeoCount; ++i) { |
| 123 | str.appendf("%d: Color: 0x%08x Trans: %.2f,%.2f Runs: %d\n", |
| 124 | i, |
| 125 | fGeoData[i].fColor, |
joshualitt | 8e0ef29 | 2016-02-19 14:13:03 -0800 | [diff] [blame] | 126 | fGeoData[i].fX, |
| 127 | fGeoData[i].fY, |
joshualitt | ddd22d8 | 2016-02-16 06:47:52 -0800 | [diff] [blame] | 128 | fGeoData[i].fBlob->runCount()); |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 129 | } |
| 130 | |
Brian Salomon | 44acb5b | 2017-07-18 19:59:24 -0400 | [diff] [blame] | 131 | str += fProcessors.dumpProcessors(); |
| 132 | str += INHERITED::dumpInfo(); |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 133 | return str; |
| 134 | } |
| 135 | |
Brian Salomon | 44acb5b | 2017-07-18 19:59:24 -0400 | [diff] [blame] | 136 | GrDrawOp::FixedFunctionFlags GrAtlasTextOp::fixedFunctionFlags() const { |
| 137 | return FixedFunctionFlags::kNone; |
| 138 | } |
| 139 | |
| 140 | GrDrawOp::RequiresDstTexture GrAtlasTextOp::finalize(const GrCaps& caps, |
Brian Osman | 9a725dd | 2017-09-20 09:53:22 -0400 | [diff] [blame] | 141 | const GrAppliedClip* clip, |
| 142 | GrPixelConfigIsClamped dstIsClamped) { |
Brian Salomon | 44acb5b | 2017-07-18 19:59:24 -0400 | [diff] [blame] | 143 | GrProcessorAnalysisCoverage coverage; |
| 144 | GrProcessorAnalysisColor color; |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 145 | if (kColorBitmapMask_MaskType == fMaskType) { |
Brian Salomon | 44acb5b | 2017-07-18 19:59:24 -0400 | [diff] [blame] | 146 | color.setToUnknown(); |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 147 | } else { |
Brian Osman | 0906825 | 2018-01-03 09:57:29 -0500 | [diff] [blame] | 148 | color.setToConstant(this->color()); |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 149 | } |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 150 | switch (fMaskType) { |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 151 | case kGrayscaleCoverageMask_MaskType: |
Jim Van Verth | 90e89b3 | 2017-07-06 16:36:55 -0400 | [diff] [blame] | 152 | case kAliasedDistanceField_MaskType: |
| 153 | case kGrayscaleDistanceField_MaskType: |
Brian Salomon | 44acb5b | 2017-07-18 19:59:24 -0400 | [diff] [blame] | 154 | coverage = GrProcessorAnalysisCoverage::kSingleChannel; |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 155 | break; |
| 156 | case kLCDCoverageMask_MaskType: |
| 157 | case kLCDDistanceField_MaskType: |
Jim Van Verth | 90e89b3 | 2017-07-06 16:36:55 -0400 | [diff] [blame] | 158 | case kLCDBGRDistanceField_MaskType: |
Brian Salomon | 44acb5b | 2017-07-18 19:59:24 -0400 | [diff] [blame] | 159 | coverage = GrProcessorAnalysisCoverage::kLCD; |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 160 | break; |
| 161 | case kColorBitmapMask_MaskType: |
Brian Salomon | 44acb5b | 2017-07-18 19:59:24 -0400 | [diff] [blame] | 162 | coverage = GrProcessorAnalysisCoverage::kNone; |
Brian Salomon | c0b642c | 2017-03-27 13:09:36 -0400 | [diff] [blame] | 163 | break; |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 164 | } |
Brian Osman | 0906825 | 2018-01-03 09:57:29 -0500 | [diff] [blame] | 165 | auto analysis = fProcessors.finalize(color, coverage, clip, false, caps, dstIsClamped, |
| 166 | &fGeoData[0].fColor); |
Brian Salomon | 44acb5b | 2017-07-18 19:59:24 -0400 | [diff] [blame] | 167 | fUsesLocalCoords = analysis.usesLocalCoords(); |
| 168 | fCanCombineOnTouchOrOverlap = |
| 169 | !analysis.requiresDstTexture() && |
| 170 | !(fProcessors.xferProcessor() && fProcessors.xferProcessor()->xferBarrierType(caps)); |
| 171 | return analysis.requiresDstTexture() ? RequiresDstTexture::kYes : RequiresDstTexture::kNo; |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 172 | } |
| 173 | |
Brian Salomon | 18923f9 | 2017-11-06 16:26:02 -0500 | [diff] [blame] | 174 | static void clip_quads(const SkIRect& clipRect, char* currVertex, const char* blobVertices, |
Jim Van Verth | 58c3cce | 2017-10-19 15:50:24 -0400 | [diff] [blame] | 175 | size_t vertexStride, int glyphCount) { |
| 176 | for (int i = 0; i < glyphCount; ++i) { |
Brian Salomon | 18923f9 | 2017-11-06 16:26:02 -0500 | [diff] [blame] | 177 | const SkPoint* blobPositionLT = reinterpret_cast<const SkPoint*>(blobVertices); |
| 178 | const SkPoint* blobPositionRB = |
| 179 | reinterpret_cast<const SkPoint*>(blobVertices + 3 * vertexStride); |
Jim Van Verth | 58c3cce | 2017-10-19 15:50:24 -0400 | [diff] [blame] | 180 | |
Jim Van Verth | 328a33f | 2017-10-20 12:14:22 -0400 | [diff] [blame] | 181 | // positions for bitmap glyphs are pixel boundary aligned |
Brian Osman | 7ca90d2 | 2017-11-10 15:31:27 -0500 | [diff] [blame] | 182 | SkIRect positionRect = SkIRect::MakeLTRB(SkScalarRoundToInt(blobPositionLT->fX), |
| 183 | SkScalarRoundToInt(blobPositionLT->fY), |
| 184 | SkScalarRoundToInt(blobPositionRB->fX), |
| 185 | SkScalarRoundToInt(blobPositionRB->fY)); |
Jim Van Verth | 58c3cce | 2017-10-19 15:50:24 -0400 | [diff] [blame] | 186 | if (clipRect.contains(positionRect)) { |
| 187 | memcpy(currVertex, blobVertices, 4 * vertexStride); |
| 188 | currVertex += 4 * vertexStride; |
| 189 | } else { |
| 190 | // Pull out some more data that we'll need. |
| 191 | // In the LCD case the color will be garbage, but we'll overwrite it with the texcoords |
| 192 | // and it avoids a lot of conditionals. |
Brian Salomon | 18923f9 | 2017-11-06 16:26:02 -0500 | [diff] [blame] | 193 | auto color = *reinterpret_cast<const SkColor*>(blobVertices + sizeof(SkPoint)); |
Jim Van Verth | 328a33f | 2017-10-20 12:14:22 -0400 | [diff] [blame] | 194 | size_t coordOffset = vertexStride - 2*sizeof(uint16_t); |
Brian Salomon | 18923f9 | 2017-11-06 16:26:02 -0500 | [diff] [blame] | 195 | auto* blobCoordsLT = reinterpret_cast<const uint16_t*>(blobVertices + coordOffset); |
| 196 | auto* blobCoordsRB = reinterpret_cast<const uint16_t*>(blobVertices + 3 * vertexStride + |
| 197 | coordOffset); |
Jim Van Verth | 328a33f | 2017-10-20 12:14:22 -0400 | [diff] [blame] | 198 | // Pull out the texel coordinates and texture index bits |
| 199 | uint16_t coordsRectL = blobCoordsLT[0] >> 1; |
| 200 | uint16_t coordsRectT = blobCoordsLT[1] >> 1; |
| 201 | uint16_t coordsRectR = blobCoordsRB[0] >> 1; |
| 202 | uint16_t coordsRectB = blobCoordsRB[1] >> 1; |
| 203 | uint16_t pageIndexX = blobCoordsLT[0] & 0x1; |
| 204 | uint16_t pageIndexY = blobCoordsLT[1] & 0x1; |
Jim Van Verth | 58c3cce | 2017-10-19 15:50:24 -0400 | [diff] [blame] | 205 | |
Jim Van Verth | 328a33f | 2017-10-20 12:14:22 -0400 | [diff] [blame] | 206 | int positionRectWidth = positionRect.width(); |
| 207 | int positionRectHeight = positionRect.height(); |
| 208 | SkASSERT(positionRectWidth == (coordsRectR - coordsRectL)); |
| 209 | SkASSERT(positionRectHeight == (coordsRectB - coordsRectT)); |
Jim Van Verth | 58c3cce | 2017-10-19 15:50:24 -0400 | [diff] [blame] | 210 | |
| 211 | // Clip position and texCoords to the clipRect |
Jim Van Verth | 328a33f | 2017-10-20 12:14:22 -0400 | [diff] [blame] | 212 | unsigned int delta; |
| 213 | delta = SkTMin(SkTMax(clipRect.fLeft - positionRect.fLeft, 0), positionRectWidth); |
| 214 | coordsRectL += delta; |
| 215 | positionRect.fLeft += delta; |
Jim Van Verth | 58c3cce | 2017-10-19 15:50:24 -0400 | [diff] [blame] | 216 | |
Jim Van Verth | 328a33f | 2017-10-20 12:14:22 -0400 | [diff] [blame] | 217 | delta = SkTMin(SkTMax(clipRect.fTop - positionRect.fTop, 0), positionRectHeight); |
| 218 | coordsRectT += delta; |
| 219 | positionRect.fTop += delta; |
| 220 | |
| 221 | delta = SkTMin(SkTMax(positionRect.fRight - clipRect.fRight, 0), positionRectWidth); |
| 222 | coordsRectR -= delta; |
| 223 | positionRect.fRight -= delta; |
| 224 | |
| 225 | delta = SkTMin(SkTMax(positionRect.fBottom - clipRect.fBottom, 0), positionRectHeight); |
| 226 | coordsRectB -= delta; |
| 227 | positionRect.fBottom -= delta; |
| 228 | |
| 229 | // Repack texel coordinates and index |
| 230 | coordsRectL = coordsRectL << 1 | pageIndexX; |
| 231 | coordsRectT = coordsRectT << 1 | pageIndexY; |
| 232 | coordsRectR = coordsRectR << 1 | pageIndexX; |
| 233 | coordsRectB = coordsRectB << 1 | pageIndexY; |
| 234 | |
| 235 | // Set new positions and coords |
Jim Van Verth | 58c3cce | 2017-10-19 15:50:24 -0400 | [diff] [blame] | 236 | SkPoint* currPosition = reinterpret_cast<SkPoint*>(currVertex); |
| 237 | currPosition->fX = positionRect.fLeft; |
| 238 | currPosition->fY = positionRect.fTop; |
| 239 | *(reinterpret_cast<SkColor*>(currVertex + sizeof(SkPoint))) = color; |
Jim Van Verth | 328a33f | 2017-10-20 12:14:22 -0400 | [diff] [blame] | 240 | uint16_t* currCoords = reinterpret_cast<uint16_t*>(currVertex + coordOffset); |
| 241 | currCoords[0] = coordsRectL; |
| 242 | currCoords[1] = coordsRectT; |
Jim Van Verth | 58c3cce | 2017-10-19 15:50:24 -0400 | [diff] [blame] | 243 | currVertex += vertexStride; |
| 244 | |
| 245 | currPosition = reinterpret_cast<SkPoint*>(currVertex); |
| 246 | currPosition->fX = positionRect.fLeft; |
| 247 | currPosition->fY = positionRect.fBottom; |
| 248 | *(reinterpret_cast<SkColor*>(currVertex + sizeof(SkPoint))) = color; |
Jim Van Verth | 328a33f | 2017-10-20 12:14:22 -0400 | [diff] [blame] | 249 | currCoords = reinterpret_cast<uint16_t*>(currVertex + coordOffset); |
| 250 | currCoords[0] = coordsRectL; |
| 251 | currCoords[1] = coordsRectB; |
Jim Van Verth | 58c3cce | 2017-10-19 15:50:24 -0400 | [diff] [blame] | 252 | currVertex += vertexStride; |
| 253 | |
| 254 | currPosition = reinterpret_cast<SkPoint*>(currVertex); |
| 255 | currPosition->fX = positionRect.fRight; |
| 256 | currPosition->fY = positionRect.fTop; |
| 257 | *(reinterpret_cast<SkColor*>(currVertex + sizeof(SkPoint))) = color; |
Jim Van Verth | 328a33f | 2017-10-20 12:14:22 -0400 | [diff] [blame] | 258 | currCoords = reinterpret_cast<uint16_t*>(currVertex + coordOffset); |
| 259 | currCoords[0] = coordsRectR; |
| 260 | currCoords[1] = coordsRectT; |
Jim Van Verth | 58c3cce | 2017-10-19 15:50:24 -0400 | [diff] [blame] | 261 | currVertex += vertexStride; |
| 262 | |
| 263 | currPosition = reinterpret_cast<SkPoint*>(currVertex); |
| 264 | currPosition->fX = positionRect.fRight; |
| 265 | currPosition->fY = positionRect.fBottom; |
| 266 | *(reinterpret_cast<SkColor*>(currVertex + sizeof(SkPoint))) = color; |
Jim Van Verth | 328a33f | 2017-10-20 12:14:22 -0400 | [diff] [blame] | 267 | currCoords = reinterpret_cast<uint16_t*>(currVertex + coordOffset); |
| 268 | currCoords[0] = coordsRectR; |
| 269 | currCoords[1] = coordsRectB; |
Jim Van Verth | 58c3cce | 2017-10-19 15:50:24 -0400 | [diff] [blame] | 270 | currVertex += vertexStride; |
| 271 | } |
| 272 | |
| 273 | blobVertices += 4 * vertexStride; |
| 274 | } |
| 275 | } |
| 276 | |
Brian Salomon | 91326c3 | 2017-08-09 16:02:19 -0400 | [diff] [blame] | 277 | void GrAtlasTextOp::onPrepareDraws(Target* target) { |
Robert Phillips | 4bc7011 | 2018-03-01 10:24:02 -0500 | [diff] [blame] | 278 | auto resourceProvider = target->resourceProvider(); |
| 279 | |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 280 | // if we have RGB, then we won't have any SkShaders so no need to use a localmatrix. |
| 281 | // TODO actually only invert if we don't have RGBA |
| 282 | SkMatrix localMatrix; |
Brian Salomon | 5c6ac64 | 2017-12-19 11:09:32 -0500 | [diff] [blame] | 283 | if (this->usesLocalCoords() && !fGeoData[0].fViewMatrix.invert(&localMatrix)) { |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 284 | return; |
| 285 | } |
| 286 | |
Robert Phillips | 5a66efb | 2018-03-07 15:13:18 -0500 | [diff] [blame] | 287 | GrAtlasManager* atlasManager = target->atlasManager(); |
Robert Phillips | c4039ea | 2018-03-01 11:36:45 -0500 | [diff] [blame] | 288 | GrGlyphCache* glyphCache = target->glyphCache(); |
| 289 | |
Jim Van Verth | eafa64b | 2017-09-18 10:05:00 -0400 | [diff] [blame] | 290 | GrMaskFormat maskFormat = this->maskFormat(); |
| 291 | |
Jim Van Verth | cbeae03 | 2018-05-16 14:54:41 -0400 | [diff] [blame] | 292 | unsigned int numActiveProxies; |
| 293 | const sk_sp<GrTextureProxy>* proxies = atlasManager->getProxies(maskFormat, &numActiveProxies); |
| 294 | if (!proxies) { |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 295 | SkDebugf("Could not allocate backing texture for atlas\n"); |
| 296 | return; |
| 297 | } |
Jim Van Verth | cbeae03 | 2018-05-16 14:54:41 -0400 | [diff] [blame] | 298 | SkASSERT(proxies[0]); |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 299 | |
bsalomon | 342bfc2 | 2016-04-01 06:06:20 -0700 | [diff] [blame] | 300 | FlushInfo flushInfo; |
Brian Salomon | bfd18cd | 2017-08-09 16:27:09 -0400 | [diff] [blame] | 301 | flushInfo.fPipeline = |
| 302 | target->makePipeline(fSRGBFlags, std::move(fProcessors), target->detachAppliedClip()); |
Jim Van Verth | b515ae7 | 2018-05-23 16:44:55 -0400 | [diff] [blame] | 303 | bool vmPerspective = fGeoData[0].fViewMatrix.hasPerspective(); |
joshualitt | d9d30f7 | 2015-12-08 10:47:55 -0800 | [diff] [blame] | 304 | if (this->usesDistanceFields()) { |
Jim Van Verth | cbeae03 | 2018-05-16 14:54:41 -0400 | [diff] [blame] | 305 | flushInfo.fGeometryProcessor = this->setupDfProcessor(proxies, numActiveProxies); |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 306 | } else { |
Jim Van Verth | b515ae7 | 2018-05-23 16:44:55 -0400 | [diff] [blame] | 307 | GrSamplerState samplerState = fNeedsGlyphTransform ? GrSamplerState::ClampBilerp() |
| 308 | : GrSamplerState::ClampNearest(); |
Brian Salomon | 2bbdcc4 | 2017-09-07 12:36:34 -0400 | [diff] [blame] | 309 | flushInfo.fGeometryProcessor = GrBitmapTextGeoProc::Make( |
Jim Van Verth | cbeae03 | 2018-05-16 14:54:41 -0400 | [diff] [blame] | 310 | this->color(), proxies, numActiveProxies, samplerState, maskFormat, |
Jim Van Verth | b515ae7 | 2018-05-23 16:44:55 -0400 | [diff] [blame] | 311 | localMatrix, vmPerspective); |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 312 | } |
| 313 | |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 314 | flushInfo.fGlyphsToFlush = 0; |
Mike Klein | 5045e50 | 2018-06-19 01:40:57 +0000 | [diff] [blame] | 315 | size_t vertexStride = flushInfo.fGeometryProcessor->getVertexStride(); |
| 316 | SkASSERT(vertexStride == GrTextBlob::GetVertexStride(maskFormat, vmPerspective)); |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 317 | |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 318 | int glyphCount = this->numGlyphs(); |
cdalton | 397536c | 2016-03-25 12:15:03 -0700 | [diff] [blame] | 319 | const GrBuffer* vertexBuffer; |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 320 | |
Brian Salomon | 344ec42 | 2016-12-15 10:58:41 -0500 | [diff] [blame] | 321 | void* vertices = target->makeVertexSpace( |
| 322 | vertexStride, glyphCount * kVerticesPerGlyph, &vertexBuffer, &flushInfo.fVertexOffset); |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 323 | flushInfo.fVertexBuffer.reset(SkRef(vertexBuffer)); |
Brian Salomon | d28a79d | 2017-10-16 13:01:07 -0400 | [diff] [blame] | 324 | flushInfo.fIndexBuffer = target->resourceProvider()->refQuadIndexBuffer(); |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 325 | if (!vertices || !flushInfo.fVertexBuffer) { |
| 326 | SkDebugf("Could not allocate vertices\n"); |
| 327 | return; |
| 328 | } |
| 329 | |
Brian Salomon | 18923f9 | 2017-11-06 16:26:02 -0500 | [diff] [blame] | 330 | char* currVertex = reinterpret_cast<char*>(vertices); |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 331 | |
Herb Derby | 7956b59 | 2018-03-22 16:10:30 -0400 | [diff] [blame] | 332 | SkExclusiveStrikePtr autoGlyphCache; |
Jim Van Verth | 58c3cce | 2017-10-19 15:50:24 -0400 | [diff] [blame] | 333 | // each of these is a SubRun |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 334 | for (int i = 0; i < fGeoCount; i++) { |
joshualitt | 144c3c8 | 2015-11-30 12:30:13 -0800 | [diff] [blame] | 335 | const Geometry& args = fGeoData[i]; |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 336 | Blob* blob = args.fBlob; |
Herb Derby | 8624059 | 2018-05-24 16:12:31 -0400 | [diff] [blame] | 337 | GrTextBlob::VertexRegenerator regenerator( |
Robert Phillips | 4bc7011 | 2018-03-01 10:24:02 -0500 | [diff] [blame] | 338 | resourceProvider, blob, args.fRun, args.fSubRun, args.fViewMatrix, args.fX, args.fY, |
Robert Phillips | 5a66efb | 2018-03-07 15:13:18 -0500 | [diff] [blame] | 339 | args.fColor, target->deferredUploadTarget(), glyphCache, atlasManager, |
Robert Phillips | c4039ea | 2018-03-01 11:36:45 -0500 | [diff] [blame] | 340 | &autoGlyphCache); |
Robert Phillips | d2e9f76 | 2018-03-07 11:54:37 -0500 | [diff] [blame] | 341 | bool done = false; |
| 342 | while (!done) { |
Herb Derby | 8624059 | 2018-05-24 16:12:31 -0400 | [diff] [blame] | 343 | GrTextBlob::VertexRegenerator::Result result; |
Robert Phillips | d2e9f76 | 2018-03-07 11:54:37 -0500 | [diff] [blame] | 344 | if (!regenerator.regenerate(&result)) { |
| 345 | break; |
| 346 | } |
| 347 | done = result.fFinished; |
| 348 | |
Brian Salomon | 18923f9 | 2017-11-06 16:26:02 -0500 | [diff] [blame] | 349 | // Copy regenerated vertices from the blob to our vertex buffer. |
| 350 | size_t vertexBytes = result.fGlyphsRegenerated * kVerticesPerGlyph * vertexStride; |
| 351 | if (args.fClipRect.isEmpty()) { |
| 352 | memcpy(currVertex, result.fFirstVertex, vertexBytes); |
| 353 | } else { |
Jim Van Verth | b515ae7 | 2018-05-23 16:44:55 -0400 | [diff] [blame] | 354 | SkASSERT(!vmPerspective); |
Brian Salomon | 18923f9 | 2017-11-06 16:26:02 -0500 | [diff] [blame] | 355 | clip_quads(args.fClipRect, currVertex, result.fFirstVertex, vertexStride, |
| 356 | result.fGlyphsRegenerated); |
| 357 | } |
Jim Van Verth | b515ae7 | 2018-05-23 16:44:55 -0400 | [diff] [blame] | 358 | if (fNeedsGlyphTransform && !args.fViewMatrix.isIdentity()) { |
Brian Salomon | 5c6ac64 | 2017-12-19 11:09:32 -0500 | [diff] [blame] | 359 | // We always do the distance field view matrix transformation after copying rather |
| 360 | // than during blob vertex generation time in the blob as handling successive |
| 361 | // arbitrary transformations would be complicated and accumulate error. |
| 362 | if (args.fViewMatrix.hasPerspective()) { |
| 363 | auto* pos = reinterpret_cast<SkPoint3*>(currVertex); |
Brian Salomon | 7c2192b | 2018-01-08 09:47:57 -0500 | [diff] [blame] | 364 | SkMatrixPriv::MapHomogeneousPointsWithStride( |
| 365 | args.fViewMatrix, pos, vertexStride, pos, vertexStride, |
| 366 | result.fGlyphsRegenerated * kVerticesPerGlyph); |
Brian Salomon | 5c6ac64 | 2017-12-19 11:09:32 -0500 | [diff] [blame] | 367 | } else { |
| 368 | auto* pos = reinterpret_cast<SkPoint*>(currVertex); |
Brian Salomon | fa3783f | 2018-01-05 13:49:07 -0500 | [diff] [blame] | 369 | SkMatrixPriv::MapPointsWithStride( |
| 370 | args.fViewMatrix, pos, vertexStride, |
| 371 | result.fGlyphsRegenerated * kVerticesPerGlyph); |
Brian Salomon | 5c6ac64 | 2017-12-19 11:09:32 -0500 | [diff] [blame] | 372 | } |
| 373 | } |
Brian Salomon | 18923f9 | 2017-11-06 16:26:02 -0500 | [diff] [blame] | 374 | flushInfo.fGlyphsToFlush += result.fGlyphsRegenerated; |
| 375 | if (!result.fFinished) { |
| 376 | this->flush(target, &flushInfo); |
| 377 | } |
| 378 | currVertex += vertexBytes; |
Robert Phillips | d2e9f76 | 2018-03-07 11:54:37 -0500 | [diff] [blame] | 379 | } |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 380 | } |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 381 | this->flush(target, &flushInfo); |
| 382 | } |
| 383 | |
Brian Salomon | e5b399e | 2017-07-19 13:50:54 -0400 | [diff] [blame] | 384 | void GrAtlasTextOp::flush(GrMeshDrawOp::Target* target, FlushInfo* flushInfo) const { |
Robert Phillips | d2e9f76 | 2018-03-07 11:54:37 -0500 | [diff] [blame] | 385 | if (!flushInfo->fGlyphsToFlush) { |
| 386 | return; |
| 387 | } |
| 388 | |
Robert Phillips | 5a66efb | 2018-03-07 15:13:18 -0500 | [diff] [blame] | 389 | auto atlasManager = target->atlasManager(); |
Robert Phillips | c4039ea | 2018-03-01 11:36:45 -0500 | [diff] [blame] | 390 | |
Jim Van Verth | eafa64b | 2017-09-18 10:05:00 -0400 | [diff] [blame] | 391 | GrGeometryProcessor* gp = flushInfo->fGeometryProcessor.get(); |
| 392 | GrMaskFormat maskFormat = this->maskFormat(); |
Robert Phillips | f3690dd | 2018-02-20 15:18:59 -0500 | [diff] [blame] | 393 | |
Jim Van Verth | cbeae03 | 2018-05-16 14:54:41 -0400 | [diff] [blame] | 394 | unsigned int numActiveProxies; |
| 395 | const sk_sp<GrTextureProxy>* proxies = atlasManager->getProxies(maskFormat, &numActiveProxies); |
| 396 | SkASSERT(proxies); |
| 397 | if (gp->numTextureSamplers() != (int) numActiveProxies) { |
Jim Van Verth | eafa64b | 2017-09-18 10:05:00 -0400 | [diff] [blame] | 398 | // During preparation the number of atlas pages has increased. |
| 399 | // Update the proxies used in the GP to match. |
| 400 | if (this->usesDistanceFields()) { |
| 401 | if (this->isLCD()) { |
| 402 | reinterpret_cast<GrDistanceFieldLCDTextGeoProc*>(gp)->addNewProxies( |
Jim Van Verth | cbeae03 | 2018-05-16 14:54:41 -0400 | [diff] [blame] | 403 | proxies, numActiveProxies, GrSamplerState::ClampBilerp()); |
Jim Van Verth | eafa64b | 2017-09-18 10:05:00 -0400 | [diff] [blame] | 404 | } else { |
| 405 | reinterpret_cast<GrDistanceFieldA8TextGeoProc*>(gp)->addNewProxies( |
Jim Van Verth | cbeae03 | 2018-05-16 14:54:41 -0400 | [diff] [blame] | 406 | proxies, numActiveProxies, GrSamplerState::ClampBilerp()); |
Jim Van Verth | eafa64b | 2017-09-18 10:05:00 -0400 | [diff] [blame] | 407 | } |
| 408 | } else { |
Jim Van Verth | b515ae7 | 2018-05-23 16:44:55 -0400 | [diff] [blame] | 409 | GrSamplerState samplerState = fNeedsGlyphTransform ? GrSamplerState::ClampBilerp() |
| 410 | : GrSamplerState::ClampNearest(); |
Jim Van Verth | cbeae03 | 2018-05-16 14:54:41 -0400 | [diff] [blame] | 411 | reinterpret_cast<GrBitmapTextGeoProc*>(gp)->addNewProxies(proxies, numActiveProxies, |
Jim Van Verth | cf838c7 | 2018-03-05 14:40:36 -0500 | [diff] [blame] | 412 | samplerState); |
Jim Van Verth | eafa64b | 2017-09-18 10:05:00 -0400 | [diff] [blame] | 413 | } |
| 414 | } |
| 415 | |
Chris Dalton | 3809bab | 2017-06-13 10:55:06 -0600 | [diff] [blame] | 416 | GrMesh mesh(GrPrimitiveType::kTriangles); |
cdalton | 397536c | 2016-03-25 12:15:03 -0700 | [diff] [blame] | 417 | int maxGlyphsPerDraw = |
Brian Salomon | 344ec42 | 2016-12-15 10:58:41 -0500 | [diff] [blame] | 418 | static_cast<int>(flushInfo->fIndexBuffer->gpuMemorySize() / sizeof(uint16_t) / 6); |
Chris Dalton | 114a3c0 | 2017-05-26 15:17:19 -0600 | [diff] [blame] | 419 | mesh.setIndexedPatterned(flushInfo->fIndexBuffer.get(), kIndicesPerGlyph, kVerticesPerGlyph, |
Chris Dalton | bca46e2 | 2017-05-15 11:03:26 -0600 | [diff] [blame] | 420 | flushInfo->fGlyphsToFlush, maxGlyphsPerDraw); |
Chris Dalton | 114a3c0 | 2017-05-26 15:17:19 -0600 | [diff] [blame] | 421 | mesh.setVertexData(flushInfo->fVertexBuffer.get(), flushInfo->fVertexOffset); |
Brian Salomon | 44acb5b | 2017-07-18 19:59:24 -0400 | [diff] [blame] | 422 | target->draw(flushInfo->fGeometryProcessor.get(), flushInfo->fPipeline, mesh); |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 423 | flushInfo->fVertexOffset += kVerticesPerGlyph * flushInfo->fGlyphsToFlush; |
| 424 | flushInfo->fGlyphsToFlush = 0; |
| 425 | } |
| 426 | |
Brian Salomon | 344ec42 | 2016-12-15 10:58:41 -0500 | [diff] [blame] | 427 | bool GrAtlasTextOp::onCombineIfPossible(GrOp* t, const GrCaps& caps) { |
| 428 | GrAtlasTextOp* that = t->cast<GrAtlasTextOp>(); |
Brian Salomon | 44acb5b | 2017-07-18 19:59:24 -0400 | [diff] [blame] | 429 | if (fProcessors != that->fProcessors) { |
| 430 | return false; |
| 431 | } |
| 432 | |
| 433 | if (!fCanCombineOnTouchOrOverlap && GrRectsTouchOrOverlap(this->bounds(), that->bounds())) { |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 434 | return false; |
| 435 | } |
| 436 | |
| 437 | if (fMaskType != that->fMaskType) { |
| 438 | return false; |
| 439 | } |
| 440 | |
Brian Salomon | 5c6ac64 | 2017-12-19 11:09:32 -0500 | [diff] [blame] | 441 | const SkMatrix& thisFirstMatrix = fGeoData[0].fViewMatrix; |
| 442 | const SkMatrix& thatFirstMatrix = that->fGeoData[0].fViewMatrix; |
| 443 | |
| 444 | if (this->usesLocalCoords() && !thisFirstMatrix.cheapEqualTo(thatFirstMatrix)) { |
| 445 | return false; |
| 446 | } |
| 447 | |
Jim Van Verth | b515ae7 | 2018-05-23 16:44:55 -0400 | [diff] [blame] | 448 | if (fNeedsGlyphTransform != that->fNeedsGlyphTransform) { |
| 449 | return false; |
| 450 | } |
| 451 | |
| 452 | if (fNeedsGlyphTransform && |
| 453 | (thisFirstMatrix.hasPerspective() != thatFirstMatrix.hasPerspective())) { |
| 454 | return false; |
| 455 | } |
| 456 | |
Brian Salomon | 5c6ac64 | 2017-12-19 11:09:32 -0500 | [diff] [blame] | 457 | if (this->usesDistanceFields()) { |
| 458 | if (fDFGPFlags != that->fDFGPFlags) { |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 459 | return false; |
| 460 | } |
| 461 | |
Jim Van Verth | bc2cdd1 | 2017-06-08 11:14:35 -0400 | [diff] [blame] | 462 | if (fLuminanceColor != that->fLuminanceColor) { |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 463 | return false; |
| 464 | } |
Brian Salomon | 5c6ac64 | 2017-12-19 11:09:32 -0500 | [diff] [blame] | 465 | } else { |
| 466 | if (kColorBitmapMask_MaskType == fMaskType && this->color() != that->color()) { |
| 467 | return false; |
| 468 | } |
Jim Van Verth | cf838c7 | 2018-03-05 14:40:36 -0500 | [diff] [blame] | 469 | |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 470 | } |
| 471 | |
Jim Van Verth | c8a65e3 | 2017-10-25 14:25:27 -0400 | [diff] [blame] | 472 | // Keep the batch vertex buffer size below 32K so we don't have to create a special one |
| 473 | // We use the largest possible vertex size for this |
| 474 | static const int kVertexSize = sizeof(SkPoint) + sizeof(SkColor) + 2 * sizeof(uint16_t); |
Jim Van Verth | 56c3714 | 2017-10-31 14:44:25 -0400 | [diff] [blame] | 475 | static const int kMaxGlyphs = 32768 / (kVerticesPerGlyph * kVertexSize); |
Jim Van Verth | c8a65e3 | 2017-10-25 14:25:27 -0400 | [diff] [blame] | 476 | if (this->fNumGlyphs + that->fNumGlyphs > kMaxGlyphs) { |
| 477 | return false; |
| 478 | } |
| 479 | |
Brian Salomon | 344ec42 | 2016-12-15 10:58:41 -0500 | [diff] [blame] | 480 | fNumGlyphs += that->numGlyphs(); |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 481 | |
Jim Van Verth | 56c3714 | 2017-10-31 14:44:25 -0400 | [diff] [blame] | 482 | // Reallocate space for geo data if necessary and then import that geo's data. |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 483 | int newGeoCount = that->fGeoCount + fGeoCount; |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 484 | |
Jim Van Verth | c8a65e3 | 2017-10-25 14:25:27 -0400 | [diff] [blame] | 485 | // We reallocate at a rate of 1.5x to try to get better total memory usage |
| 486 | if (newGeoCount > fGeoDataAllocSize) { |
Jim Van Verth | 56c3714 | 2017-10-31 14:44:25 -0400 | [diff] [blame] | 487 | int newAllocSize = fGeoDataAllocSize + fGeoDataAllocSize / 2; |
Jim Van Verth | c8a65e3 | 2017-10-25 14:25:27 -0400 | [diff] [blame] | 488 | while (newAllocSize < newGeoCount) { |
| 489 | newAllocSize += newAllocSize / 2; |
| 490 | } |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 491 | fGeoData.realloc(newAllocSize); |
Jim Van Verth | c8a65e3 | 2017-10-25 14:25:27 -0400 | [diff] [blame] | 492 | fGeoDataAllocSize = newAllocSize; |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 493 | } |
| 494 | |
Brian Salomon | 344ec42 | 2016-12-15 10:58:41 -0500 | [diff] [blame] | 495 | // We steal the ref on the blobs from the other AtlasTextOp and set its count to 0 so that |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 496 | // it doesn't try to unref them. |
Brian Salomon | 344ec42 | 2016-12-15 10:58:41 -0500 | [diff] [blame] | 497 | memcpy(&fGeoData[fGeoCount], that->fGeoData.get(), that->fGeoCount * sizeof(Geometry)); |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 498 | #ifdef SK_DEBUG |
| 499 | for (int i = 0; i < that->fGeoCount; ++i) { |
| 500 | that->fGeoData.get()[i].fBlob = (Blob*)0x1; |
| 501 | } |
| 502 | #endif |
| 503 | that->fGeoCount = 0; |
| 504 | fGeoCount = newGeoCount; |
| 505 | |
bsalomon | 88cf17d | 2016-07-08 06:40:56 -0700 | [diff] [blame] | 506 | this->joinBounds(*that); |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 507 | return true; |
| 508 | } |
| 509 | |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 510 | // TODO trying to figure out why lcd is so whack |
Herb Derby | 26cbe51 | 2018-05-24 14:39:01 -0400 | [diff] [blame] | 511 | // (see comments in GrTextContext::ComputeCanonicalColor) |
Jim Van Verth | cbeae03 | 2018-05-16 14:54:41 -0400 | [diff] [blame] | 512 | sk_sp<GrGeometryProcessor> GrAtlasTextOp::setupDfProcessor(const sk_sp<GrTextureProxy>* proxies, |
| 513 | unsigned int numActiveProxies) const { |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 514 | bool isLCD = this->isLCD(); |
Brian Salomon | 5c6ac64 | 2017-12-19 11:09:32 -0500 | [diff] [blame] | 515 | |
| 516 | SkMatrix localMatrix = SkMatrix::I(); |
| 517 | if (this->usesLocalCoords()) { |
| 518 | // If this fails we'll just use I(). |
| 519 | bool result = fGeoData[0].fViewMatrix.invert(&localMatrix); |
| 520 | (void)result; |
| 521 | } |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 522 | |
| 523 | // see if we need to create a new effect |
| 524 | if (isLCD) { |
brianosman | 0586f5c | 2016-04-12 12:48:21 -0700 | [diff] [blame] | 525 | float redCorrection = fDistanceAdjustTable->getAdjustment( |
Jim Van Verth | 58c3cce | 2017-10-19 15:50:24 -0400 | [diff] [blame] | 526 | SkColorGetR(fLuminanceColor) >> kDistanceAdjustLumShift, |
Brian Salomon | 344ec42 | 2016-12-15 10:58:41 -0500 | [diff] [blame] | 527 | fUseGammaCorrectDistanceTable); |
brianosman | 0586f5c | 2016-04-12 12:48:21 -0700 | [diff] [blame] | 528 | float greenCorrection = fDistanceAdjustTable->getAdjustment( |
Jim Van Verth | 58c3cce | 2017-10-19 15:50:24 -0400 | [diff] [blame] | 529 | SkColorGetG(fLuminanceColor) >> kDistanceAdjustLumShift, |
Brian Salomon | 344ec42 | 2016-12-15 10:58:41 -0500 | [diff] [blame] | 530 | fUseGammaCorrectDistanceTable); |
brianosman | 0586f5c | 2016-04-12 12:48:21 -0700 | [diff] [blame] | 531 | float blueCorrection = fDistanceAdjustTable->getAdjustment( |
Jim Van Verth | 58c3cce | 2017-10-19 15:50:24 -0400 | [diff] [blame] | 532 | SkColorGetB(fLuminanceColor) >> kDistanceAdjustLumShift, |
Brian Salomon | 344ec42 | 2016-12-15 10:58:41 -0500 | [diff] [blame] | 533 | fUseGammaCorrectDistanceTable); |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 534 | GrDistanceFieldLCDTextGeoProc::DistanceAdjust widthAdjust = |
Brian Salomon | 344ec42 | 2016-12-15 10:58:41 -0500 | [diff] [blame] | 535 | GrDistanceFieldLCDTextGeoProc::DistanceAdjust::Make( |
| 536 | redCorrection, greenCorrection, blueCorrection); |
Jim Van Verth | cbeae03 | 2018-05-16 14:54:41 -0400 | [diff] [blame] | 537 | return GrDistanceFieldLCDTextGeoProc::Make(proxies, numActiveProxies, |
Robert Phillips | 4bc7011 | 2018-03-01 10:24:02 -0500 | [diff] [blame] | 538 | GrSamplerState::ClampBilerp(), widthAdjust, |
Brian Osman | 0906825 | 2018-01-03 09:57:29 -0500 | [diff] [blame] | 539 | fDFGPFlags, localMatrix); |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 540 | } else { |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 541 | #ifdef SK_GAMMA_APPLY_TO_A8 |
Jim Van Verth | 90e89b3 | 2017-07-06 16:36:55 -0400 | [diff] [blame] | 542 | float correction = 0; |
| 543 | if (kAliasedDistanceField_MaskType != fMaskType) { |
Jim Van Verth | 58c3cce | 2017-10-19 15:50:24 -0400 | [diff] [blame] | 544 | U8CPU lum = SkColorSpaceLuminance::computeLuminance(SK_GAMMA_EXPONENT, |
| 545 | fLuminanceColor); |
Jim Van Verth | 90e89b3 | 2017-07-06 16:36:55 -0400 | [diff] [blame] | 546 | correction = fDistanceAdjustTable->getAdjustment(lum >> kDistanceAdjustLumShift, |
| 547 | fUseGammaCorrectDistanceTable); |
| 548 | } |
Jim Van Verth | cbeae03 | 2018-05-16 14:54:41 -0400 | [diff] [blame] | 549 | return GrDistanceFieldA8TextGeoProc::Make(proxies, numActiveProxies, |
Robert Phillips | 4bc7011 | 2018-03-01 10:24:02 -0500 | [diff] [blame] | 550 | GrSamplerState::ClampBilerp(), |
Brian Salomon | 5c6ac64 | 2017-12-19 11:09:32 -0500 | [diff] [blame] | 551 | correction, fDFGPFlags, localMatrix); |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 552 | #else |
Jim Van Verth | cbeae03 | 2018-05-16 14:54:41 -0400 | [diff] [blame] | 553 | return GrDistanceFieldA8TextGeoProc::Make(proxies, numActiveProxies, |
Robert Phillips | 4bc7011 | 2018-03-01 10:24:02 -0500 | [diff] [blame] | 554 | GrSamplerState::ClampBilerp(), |
Brian Salomon | 5c6ac64 | 2017-12-19 11:09:32 -0500 | [diff] [blame] | 555 | fDFGPFlags, localMatrix); |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 556 | #endif |
| 557 | } |
joshualitt | a751c97 | 2015-11-20 13:37:32 -0800 | [diff] [blame] | 558 | } |
joshualitt | ddd22d8 | 2016-02-16 06:47:52 -0800 | [diff] [blame] | 559 | |