src/third_party/skia/src/gpu/GrStencilAndCoverTextContext.cpp

   1 /*
   2  * Copyright 2014 Google Inc.
   3  *
   4  * Use of this source code is governed by a BSD-style license that can be
   5  * found in the LICENSE file.
   6  */
   7
   8 #include "GrStencilAndCoverTextContext.h"
   9 #include "GrDrawTarget.h"
  10 #include "GrGpu.h"
  11 #include "GrPath.h"
  12 #include "GrPathRange.h"
  13 #include "SkAutoKern.h"
  14 #include "SkDraw.h"
  15 #include "SkDrawProcs.h"
  16 #include "SkGlyphCache.h"
  17 #include "SkGpuDevice.h"
  18 #include "SkPath.h"
  19 #include "SkTextMapStateProc.h"
  20 #include "SkTextFormatParams.h"
  21
  22 GrStencilAndCoverTextContext::GrStencilAndCoverTextContext(
  23     GrContext* context, const SkDeviceProperties& properties)
  24     : GrTextContext(context, properties)
  25     , fPendingGlyphCount(0) {
  26 }
  27
  28 GrStencilAndCoverTextContext::~GrStencilAndCoverTextContext() {
  29 }
  30
  31 void GrStencilAndCoverTextContext::drawText(const GrPaint& paint,
  32                                             const SkPaint& skPaint,
  33                                             const char text[],
  34                                             size_t byteLength,
  35                                             SkScalar x, SkScalar y) {
  36     SkASSERT(byteLength == 0 || text != NULL);
  37
  38     if (text == NULL || byteLength == 0 /*|| fRC->isEmpty()*/) {
  39         return;
  40     }
  41
  42     // This is the slow path, mainly used by Skia unit tests.  The other
  43     // backends (8888, gpu, ...) use device-space dependent glyph caches. In
  44     // order to match the glyph positions that the other code paths produce, we
  45     // must also use device-space dependent glyph cache. This has the
  46     // side-effect that the glyph shape outline will be in device-space,
  47     // too. This in turn has the side-effect that NVPR can not stroke the paths,
  48     // as the stroke in NVPR is defined in object-space.
  49     // NOTE: here we have following coincidence that works at the moment:
  50     // - When using the device-space glyphs, the transforms we pass to NVPR
  51     // instanced drawing are the global transforms, and the view transform is
  52     // identity. NVPR can not use non-affine transforms in the instanced
  53     // drawing. This is taken care of by SkDraw::ShouldDrawTextAsPaths since it
  54     // will turn off the use of device-space glyphs when perspective transforms
  55     // are in use.
  56
  57     this->init(paint, skPaint, byteLength, kMaxAccuracy_RenderMode);
  58
  59     // Transform our starting point.
  60     if (fNeedsDeviceSpaceGlyphs) {
  61         SkPoint loc;
  62         fContextInitialMatrix.mapXY(x, y, &loc);
  63         x = loc.fX;
  64         y = loc.fY;
  65     }
  66
  67     SkDrawCacheProc glyphCacheProc = fSkPaint.getDrawCacheProc();
  68
  69     fTransformType = GrPathRendering::kTranslate_PathTransformType;
  70
  71     const char* stop = text + byteLength;
  72
  73     // Measure first if needed.
  74     if (fSkPaint.getTextAlign() != SkPaint::kLeft_Align) {
  75         SkFixed    stopX = 0;
  76         SkFixed    stopY = 0;
  77
  78         const char* textPtr = text;
  79         while (textPtr < stop) {
  80             // We don't need x, y here, since all subpixel variants will have the
  81             // same advance.
  82             const SkGlyph& glyph = glyphCacheProc(fGlyphCache, &textPtr, 0, 0);
  83
  84             stopX += glyph.fAdvanceX;
  85             stopY += glyph.fAdvanceY;
  86         }
  87         SkASSERT(textPtr == stop);
  88
  89         SkScalar alignX = SkFixedToScalar(stopX) * fTextRatio;
  90         SkScalar alignY = SkFixedToScalar(stopY) * fTextRatio;
  91
  92         if (fSkPaint.getTextAlign() == SkPaint::kCenter_Align) {
  93             alignX = SkScalarHalf(alignX);
  94             alignY = SkScalarHalf(alignY);
  95         }
  96
  97         x -= alignX;
  98         y -= alignY;
  99     }
 100
 101     SkAutoKern autokern;
 102
 103     SkFixed fixedSizeRatio = SkScalarToFixed(fTextRatio);
 104
 105     SkFixed fx = SkScalarToFixed(x);
 106     SkFixed fy = SkScalarToFixed(y);
 107     while (text < stop) {
 108         const SkGlyph& glyph = glyphCacheProc(fGlyphCache, &text, 0, 0);
 109         fx += SkFixedMul_portable(autokern.adjust(glyph), fixedSizeRatio);
 110         if (glyph.fWidth) {
 111             this->appendGlyph(glyph.getGlyphID(), SkFixedToScalar(fx), SkFixedToScalar(fy));
 112         }
 113
 114         fx += SkFixedMul_portable(glyph.fAdvanceX, fixedSizeRatio);
 115         fy += SkFixedMul_portable(glyph.fAdvanceY, fixedSizeRatio);
 116     }
 117
 118     this->finish();
 119 }
 120
 121 void GrStencilAndCoverTextContext::drawPosText(const GrPaint& paint,
 122                                                const SkPaint& skPaint,
 123                                                const char text[],
 124                                                size_t byteLength,
 125                                                const SkScalar pos[],
 126                                                SkScalar constY,
 127                                                int scalarsPerPosition) {
 128     SkASSERT(byteLength == 0 || text != NULL);
 129     SkASSERT(1 == scalarsPerPosition || 2 == scalarsPerPosition);
 130
 131     // nothing to draw
 132     if (text == NULL || byteLength == 0/* || fRC->isEmpty()*/) {
 133         return;
 134     }
 135
 136     // This is the fast path.  Here we do not bake in the device-transform to
 137     // the glyph outline or the advances. This is because we do not need to
 138     // position the glyphs at all, since the caller has done the positioning.
 139     // The positioning is based on SkPaint::measureText of individual
 140     // glyphs. That already uses glyph cache without device transforms. Device
 141     // transform is not part of SkPaint::measureText API, and thus we use the
 142     // same glyphs as what were measured.
 143
 144     const float textTranslateY = (1 == scalarsPerPosition ? constY : 0);
 145     this->init(paint, skPaint, byteLength, kMaxPerformance_RenderMode, textTranslateY);
 146
 147     SkDrawCacheProc glyphCacheProc = fSkPaint.getDrawCacheProc();
 148
 149     const char* stop = text + byteLength;
 150
 151     if (SkPaint::kLeft_Align == fSkPaint.getTextAlign()) {
 152         if (1 == scalarsPerPosition) {
 153             fTransformType = GrPathRendering::kTranslateX_PathTransformType;
 154             while (text < stop) {
 155                 const SkGlyph& glyph = glyphCacheProc(fGlyphCache, &text, 0, 0);
 156                 if (glyph.fWidth) {
 157                     this->appendGlyph(glyph.getGlyphID(), *pos);
 158                 }
 159                 pos++;
 160             }
 161         } else {
 162             SkASSERT(2 == scalarsPerPosition);
 163             fTransformType = GrPathRendering::kTranslate_PathTransformType;
 164             while (text < stop) {
 165                 const SkGlyph& glyph = glyphCacheProc(fGlyphCache, &text, 0, 0);
 166                 if (glyph.fWidth) {
 167                     this->appendGlyph(glyph.getGlyphID(), pos[0], pos[1]);
 168                 }
 169                 pos += 2;
 170             }
 171         }
 172     } else {
 173         fTransformType = GrPathRendering::kTranslate_PathTransformType;
 174         SkTextMapStateProc tmsProc(SkMatrix::I(), 0, scalarsPerPosition);
 175         SkTextAlignProcScalar alignProc(fSkPaint.getTextAlign());
 176         while (text < stop) {
 177             const SkGlyph& glyph = glyphCacheProc(fGlyphCache, &text, 0, 0);
 178             if (glyph.fWidth) {
 179                 SkPoint tmsLoc;
 180                 tmsProc(pos, &tmsLoc);
 181                 SkPoint loc;
 182                 alignProc(tmsLoc, glyph, &loc);
 183
 184                 this->appendGlyph(glyph.getGlyphID(), loc.x(), loc.y());
 185             }
 186             pos += scalarsPerPosition;
 187         }
 188     }
 189
 190     this->finish();
 191 }
 192
 193 bool GrStencilAndCoverTextContext::canDraw(const SkPaint& paint) {
 194     if (paint.getRasterizer()) {
 195         return false;
 196     }
 197     if (paint.getMaskFilter()) {
 198         return false;
 199     }
 200     if (paint.getPathEffect()) {
 201         return false;
 202     }
 203
 204     // No hairlines unless we can map the 1 px width to the object space.
 205     if (paint.getStyle() == SkPaint::kStroke_Style
 206         && paint.getStrokeWidth() == 0
 207         && fContext->getMatrix().hasPerspective()) {
 208         return false;
 209     }
 210
 211     // No color bitmap fonts.
 212     SkScalerContext::Rec    rec;
 213     SkScalerContext::MakeRec(paint, &fDeviceProperties, NULL, &rec);
 214     return rec.getFormat() != SkMask::kARGB32_Format;
 215 }
 216
 217 static GrPathRange* get_gr_glyphs(GrContext* ctx,
 218                                   const SkTypeface* typeface,
 219                                   const SkDescriptor* desc,
 220                                   const SkStrokeRec& stroke) {
 221     static const GrCacheID::Domain gGlyphsDomain = GrCacheID::GenerateDomain();
 222
 223     GrCacheID::Key key;
 224     uint64_t* keyData = key.fData64;
 225     keyData[0] = desc ? desc->getChecksum() : 0;
 226     keyData[0] = (keyData[0] << 32) | (typeface ? typeface->uniqueID() : 0);
 227     keyData[1] = GrPath::ComputeStrokeKey(stroke);
 228     GrResourceKey resourceKey = GrResourceKey(GrCacheID(gGlyphsDomain, key),
 229                                               GrPathRange::resourceType(), 0);
 230
 231     SkAutoTUnref<GrPathRange> glyphs(
 232         static_cast<GrPathRange*>(ctx->findAndRefCachedResource(resourceKey)));
 233     if (NULL == glyphs || (NULL != desc && !glyphs->isEqualTo(*desc))) {
 234         glyphs.reset(ctx->getGpu()->pathRendering()->createGlyphs(typeface, desc, stroke));
 235         ctx->addResourceToCache(resourceKey, glyphs);
 236     }
 237
 238     return glyphs.detach();
 239 }
 240
 241 void GrStencilAndCoverTextContext::init(const GrPaint& paint,
 242                                         const SkPaint& skPaint,
 243                                         size_t textByteLength,
 244                                         RenderMode renderMode,
 245                                         SkScalar textTranslateY) {
 246     GrTextContext::init(paint, skPaint);
 247
 248     fContextInitialMatrix = fContext->getMatrix();
 249
 250     const bool otherBackendsWillDrawAsPaths =
 251         SkDraw::ShouldDrawTextAsPaths(skPaint, fContextInitialMatrix);
 252
 253     fNeedsDeviceSpaceGlyphs = !otherBackendsWillDrawAsPaths &&
 254                               kMaxAccuracy_RenderMode == renderMode &&
 255                               SkToBool(fContextInitialMatrix.getType() &
 256                                        (SkMatrix::kScale_Mask | SkMatrix::kAffine_Mask));
 257
 258     if (fNeedsDeviceSpaceGlyphs) {
 259         // SkDraw::ShouldDrawTextAsPaths takes care of perspective transforms.
 260         SkASSERT(!fContextInitialMatrix.hasPerspective());
 261         SkASSERT(0 == textTranslateY); // TODO: Handle textTranslateY in device-space usecase.
 262
 263         fTextRatio = fTextInverseRatio = 1.0f;
 264
 265         // Glyphs loaded by GPU path rendering have an inverted y-direction.
 266         SkMatrix m;
 267         m.setScale(1, -1);
 268         fContext->setMatrix(m);
 269
 270         // Post-flip the initial matrix so we're left with just the flip after
 271         // the paint preConcats the inverse.
 272         m = fContextInitialMatrix;
 273         m.postScale(1, -1);
 274         fPaint.localCoordChangeInverse(m);
 275
 276         // The whole shape (including stroke) will be baked into the glyph outlines. Make
 277         // NVPR just fill the baked shapes.
 278         fGlyphCache = fSkPaint.detachCache(&fDeviceProperties, &fContextInitialMatrix, false);
 279         fGlyphs = get_gr_glyphs(fContext, fGlyphCache->getScalerContext()->getTypeface(),
 280                                 &fGlyphCache->getDescriptor(),
 281                                 SkStrokeRec(SkStrokeRec::kFill_InitStyle));
 282     } else {
 283         // Don't bake strokes into the glyph outlines. We will stroke the glyphs
 284         // using the GPU instead. This is the fast path.
 285         SkStrokeRec gpuStroke = SkStrokeRec(fSkPaint);
 286         fSkPaint.setStyle(SkPaint::kFill_Style);
 287
 288         if (gpuStroke.isHairlineStyle()) {
 289             // Approximate hairline stroke.
 290             SkScalar strokeWidth = SK_Scalar1 /
 291                 (SkVector::Make(fContextInitialMatrix.getScaleX(),
 292                                 fContextInitialMatrix.getSkewY()).length());
 293             gpuStroke.setStrokeStyle(strokeWidth, false /*strokeAndFill*/);
 294
 295         } else if (fSkPaint.isFakeBoldText() &&
 296 #ifdef SK_USE_FREETYPE_EMBOLDEN
 297                    kMaxPerformance_RenderMode == renderMode &&
 298 #endif
 299                    SkStrokeRec::kStroke_Style != gpuStroke.getStyle()) {
 300
 301             // Instead of baking fake bold into the glyph outlines, do it with the GPU stroke.
 302             SkScalar fakeBoldScale = SkScalarInterpFunc(fSkPaint.getTextSize(),
 303                                                         kStdFakeBoldInterpKeys,
 304                                                         kStdFakeBoldInterpValues,
 305                                                         kStdFakeBoldInterpLength);
 306             SkScalar extra = SkScalarMul(fSkPaint.getTextSize(), fakeBoldScale);
 307             gpuStroke.setStrokeStyle(gpuStroke.needToApply() ? gpuStroke.getWidth() + extra : extra,
 308                                      true /*strokeAndFill*/);
 309
 310             fSkPaint.setFakeBoldText(false);
 311         }
 312
 313         bool canUseRawPaths;
 314
 315         if (otherBackendsWillDrawAsPaths || kMaxPerformance_RenderMode == renderMode) {
 316             // We can draw the glyphs from canonically sized paths.
 317             fTextRatio = fSkPaint.getTextSize() / SkPaint::kCanonicalTextSizeForPaths;
 318             fTextInverseRatio = SkPaint::kCanonicalTextSizeForPaths / fSkPaint.getTextSize();
 319
 320             // Compensate for the glyphs being scaled by fTextRatio.
 321             if (!gpuStroke.isFillStyle()) {
 322                 gpuStroke.setStrokeStyle(gpuStroke.getWidth() / fTextRatio,
 323                                          SkStrokeRec::kStrokeAndFill_Style == gpuStroke.getStyle());
 324             }
 325
 326             fSkPaint.setLinearText(true);
 327             fSkPaint.setLCDRenderText(false);
 328             fSkPaint.setAutohinted(false);
 329             fSkPaint.setHinting(SkPaint::kNo_Hinting);
 330             fSkPaint.setSubpixelText(true);
 331             fSkPaint.setTextSize(SkIntToScalar(SkPaint::kCanonicalTextSizeForPaths));
 332
 333             canUseRawPaths = SK_Scalar1 == fSkPaint.getTextScaleX() &&
 334                              0 == fSkPaint.getTextSkewX() &&
 335                              !fSkPaint.isFakeBoldText() &&
 336                              !fSkPaint.isVerticalText();
 337         } else {
 338             fTextRatio = fTextInverseRatio = 1.0f;
 339             canUseRawPaths = false;
 340         }
 341
 342         SkMatrix textMatrix;
 343         textMatrix.setTranslate(0, textTranslateY);
 344         // Glyphs loaded by GPU path rendering have an inverted y-direction.
 345         textMatrix.preScale(fTextRatio, -fTextRatio);
 346         fPaint.localCoordChange(textMatrix);
 347         fContext->concatMatrix(textMatrix);
 348
 349         fGlyphCache = fSkPaint.detachCache(&fDeviceProperties, NULL, false);
 350         fGlyphs = canUseRawPaths ?
 351                       get_gr_glyphs(fContext, fSkPaint.getTypeface(), NULL, gpuStroke) :
 352                       get_gr_glyphs(fContext, fGlyphCache->getScalerContext()->getTypeface(),
 353                                     &fGlyphCache->getDescriptor(), gpuStroke);
 354     }
 355
 356     fStateRestore.set(fDrawTarget->drawState());
 357
 358     fDrawTarget->drawState()->setFromPaint(fPaint, fContext->getMatrix(),
 359                                            fContext->getRenderTarget());
 360
 361     GR_STATIC_CONST_SAME_STENCIL(kStencilPass,
 362                                  kZero_StencilOp,
 363                                  kZero_StencilOp,
 364                                  kNotEqual_StencilFunc,
 365                                  0xffff,
 366                                  0x0000,
 367                                  0xffff);
 368
 369     *fDrawTarget->drawState()->stencil() = kStencilPass;
 370
 371     SkASSERT(0 == fPendingGlyphCount);
 372 }
 373
 374 inline void GrStencilAndCoverTextContext::appendGlyph(uint16_t glyphID, float x) {
 375     SkASSERT(GrPathRendering::kTranslateX_PathTransformType == fTransformType);
 376
 377     if (fPendingGlyphCount >= kGlyphBufferSize) {
 378         this->flush();
 379     }
 380
 381     fIndexBuffer[fPendingGlyphCount] = glyphID;
 382     fTransformBuffer[fPendingGlyphCount] = fTextInverseRatio * x;
 383
 384     ++fPendingGlyphCount;
 385 }
 386
 387 inline void GrStencilAndCoverTextContext::appendGlyph(uint16_t glyphID, float x, float y) {
 388     SkASSERT(GrPathRendering::kTranslate_PathTransformType == fTransformType);
 389
 390     if (fPendingGlyphCount >= kGlyphBufferSize) {
 391         this->flush();
 392     }
 393
 394     fIndexBuffer[fPendingGlyphCount] = glyphID;
 395     fTransformBuffer[2 * fPendingGlyphCount] = fTextInverseRatio * x;
 396     fTransformBuffer[2 * fPendingGlyphCount + 1] = -fTextInverseRatio * y;
 397
 398     ++fPendingGlyphCount;
 399 }
 400
 401 void GrStencilAndCoverTextContext::flush() {
 402     if (0 == fPendingGlyphCount) {
 403         return;
 404     }
 405
 406     fDrawTarget->drawPaths(fGlyphs, fIndexBuffer, fPendingGlyphCount,
 407                            fTransformBuffer, fTransformType, SkPath::kWinding_FillType);
 408
 409     fPendingGlyphCount = 0;
 410 }
 411
 412 void GrStencilAndCoverTextContext::finish() {
 413     this->flush();
 414
 415     fGlyphs->unref();
 416     fGlyphs = NULL;
 417
 418     SkGlyphCache::AttachCache(fGlyphCache);
 419     fGlyphCache = NULL;
 420
 421     fDrawTarget->drawState()->stencil()->setDisabled();
 422     fStateRestore.set(NULL);
 423     fContext->setMatrix(fContextInitialMatrix);
 424     GrTextContext::finish();
 425 }
 426