/*
|
* Copyright 2018 The Android Open Source Project
|
*
|
* Use of this source code is governed by a BSD-style license that can be
|
* found in the LICENSE file.
|
*/
|
|
#include "SkGlyphRunPainter.h"
|
|
#if SK_SUPPORT_GPU
|
#include "GrCaps.h"
|
#include "GrColorSpaceInfo.h"
|
#include "GrContextPriv.h"
|
#include "GrRecordingContext.h"
|
#include "GrRecordingContextPriv.h"
|
#include "GrRenderTargetContext.h"
|
#include "SkGr.h"
|
#include "text/GrTextBlobCache.h"
|
#include "text/GrTextContext.h"
|
#endif
|
|
#include "SkColorFilter.h"
|
#include "SkDevice.h"
|
#include "SkDistanceFieldGen.h"
|
#include "SkDraw.h"
|
#include "SkFontPriv.h"
|
#include "SkMaskFilter.h"
|
#include "SkPaintPriv.h"
|
#include "SkPathEffect.h"
|
#include "SkRasterClip.h"
|
#include "SkRemoteGlyphCacheImpl.h"
|
#include "SkStrikeInterface.h"
|
#include "SkStrike.h"
|
#include "SkStrikeCache.h"
|
#include "SkTDArray.h"
|
#include "SkTraceEvent.h"
|
|
// -- SkGlyphCacheCommon ---------------------------------------------------------------------------
|
|
SkVector SkStrikeCommon::PixelRounding(bool isSubpixel, SkAxisAlignment axisAlignment) {
|
if (!isSubpixel) {
|
return {SK_ScalarHalf, SK_ScalarHalf};
|
} else {
|
static constexpr SkScalar kSubpixelRounding = SkFixedToScalar(SkGlyph::kSubpixelRound);
|
switch (axisAlignment) {
|
case kX_SkAxisAlignment:
|
return {kSubpixelRounding, SK_ScalarHalf};
|
case kY_SkAxisAlignment:
|
return {SK_ScalarHalf, kSubpixelRounding};
|
case kNone_SkAxisAlignment:
|
return {kSubpixelRounding, kSubpixelRounding};
|
}
|
}
|
|
// Some compilers need this.
|
return {0, 0};
|
}
|
|
SkIPoint SkStrikeCommon::SubpixelLookup(SkAxisAlignment axisAlignment, SkPoint position) {
|
// TODO: SkScalarFraction uses truncf to calculate the fraction. This should be floorf.
|
SkFixed lookupX = SkScalarToFixed(SkScalarFraction(position.x())),
|
lookupY = SkScalarToFixed(SkScalarFraction(position.y()));
|
|
// Snap to a given axis if alignment is requested.
|
if (axisAlignment == kX_SkAxisAlignment) {
|
lookupY = 0;
|
} else if (axisAlignment == kY_SkAxisAlignment) {
|
lookupX = 0;
|
}
|
|
return {lookupX, lookupY};
|
}
|
|
bool SkStrikeCommon::GlyphTooBigForAtlas(const SkGlyph& glyph) {
|
return glyph.fWidth > kSkSideTooBigForAtlas || glyph.fHeight > kSkSideTooBigForAtlas;
|
}
|
|
// -- SkGlyphRunListPainter ------------------------------------------------------------------------
|
SkGlyphRunListPainter::SkGlyphRunListPainter(const SkSurfaceProps& props,
|
SkColorType colorType,
|
SkScalerContextFlags flags,
|
SkStrikeCacheInterface* strikeCache)
|
: fDeviceProps{props}
|
, fBitmapFallbackProps{SkSurfaceProps{props.flags(), kUnknown_SkPixelGeometry}}
|
, fColorType{colorType}, fScalerContextFlags{flags}
|
, fStrikeCache{strikeCache} {}
|
|
// TODO: unify with code in GrTextContext.cpp
|
static SkScalerContextFlags compute_scaler_context_flags(const SkColorSpace* cs) {
|
// If we're doing linear blending, then we can disable the gamma hacks.
|
// Otherwise, leave them on. In either case, we still want the contrast boost:
|
// TODO: Can we be even smarter about mask gamma based on the dest transfer function?
|
if (cs && cs->gammaIsLinear()) {
|
return SkScalerContextFlags::kBoostContrast;
|
} else {
|
return SkScalerContextFlags::kFakeGammaAndBoostContrast;
|
}
|
}
|
|
SkGlyphRunListPainter::SkGlyphRunListPainter(const SkSurfaceProps& props,
|
SkColorType colorType,
|
SkColorSpace* cs,
|
SkStrikeCacheInterface* strikeCache)
|
: SkGlyphRunListPainter(props, colorType, compute_scaler_context_flags(cs), strikeCache) {}
|
|
#if SK_SUPPORT_GPU
|
SkGlyphRunListPainter::SkGlyphRunListPainter(const SkSurfaceProps& props,
|
const GrColorSpaceInfo& csi)
|
: SkGlyphRunListPainter(props,
|
kUnknown_SkColorType,
|
compute_scaler_context_flags(csi.colorSpace()),
|
SkStrikeCache::GlobalStrikeCache()) {}
|
|
SkGlyphRunListPainter::SkGlyphRunListPainter(const GrRenderTargetContext& rtc)
|
: SkGlyphRunListPainter{rtc.surfaceProps(), rtc.colorSpaceInfo()} {}
|
|
#endif
|
|
bool SkGlyphRunListPainter::ShouldDrawAsPath(
|
const SkPaint& paint, const SkFont& font, const SkMatrix& matrix) {
|
// hairline glyphs are fast enough so we don't need to cache them
|
if (SkPaint::kStroke_Style == paint.getStyle() && 0 == paint.getStrokeWidth()) {
|
return true;
|
}
|
|
// we don't cache perspective
|
if (matrix.hasPerspective()) {
|
return true;
|
}
|
|
return SkFontPriv::TooBigToUseCache(matrix, SkFontPriv::MakeTextMatrix(font), 1024);
|
}
|
|
static bool check_glyph_position(SkPoint position) {
|
// Prevent glyphs from being drawn outside of or straddling the edge of device space.
|
// Comparisons written a little weirdly so that NaN coordinates are treated safely.
|
auto gt = [](float a, int b) { return !(a <= (float)b); };
|
auto lt = [](float a, int b) { return !(a >= (float)b); };
|
return !(gt(position.fX, INT_MAX - (INT16_MAX + SkTo<int>(UINT16_MAX))) ||
|
lt(position.fX, INT_MIN - (INT16_MIN + 0 /*UINT16_MIN*/)) ||
|
gt(position.fY, INT_MAX - (INT16_MAX + SkTo<int>(UINT16_MAX))) ||
|
lt(position.fY, INT_MIN - (INT16_MIN + 0 /*UINT16_MIN*/)));
|
}
|
|
static SkMask create_mask(const SkGlyph& glyph, SkPoint position, const void* image) {
|
SkMask mask;
|
int left = SkScalarFloorToInt(position.fX);
|
int top = SkScalarFloorToInt(position.fY);
|
|
left += glyph.fLeft;
|
top += glyph.fTop;
|
|
int right = left + glyph.fWidth;
|
int bottom = top + glyph.fHeight;
|
|
mask.fBounds.set(left, top, right, bottom);
|
SkASSERT(!mask.fBounds.isEmpty());
|
|
mask.fImage = (uint8_t*)image;
|
mask.fRowBytes = glyph.rowBytes();
|
mask.fFormat = static_cast<SkMask::Format>(glyph.fMaskFormat);
|
|
return mask;
|
}
|
|
void SkGlyphRunListPainter::drawForBitmapDevice(
|
const SkGlyphRunList& glyphRunList, const SkMatrix& deviceMatrix,
|
const BitmapDevicePainter* bitmapDevice) {
|
ScopedBuffers _ = this->ensureBuffers(glyphRunList);
|
|
const SkPaint& runPaint = glyphRunList.paint();
|
// The bitmap blitters can only draw lcd text to a N32 bitmap in srcOver. Otherwise,
|
// convert the lcd text into A8 text. The props communicates this to the scaler.
|
auto& props = (kN32_SkColorType == fColorType && runPaint.isSrcOver())
|
? fDeviceProps
|
: fBitmapFallbackProps;
|
|
SkPoint origin = glyphRunList.origin();
|
for (auto& glyphRun : glyphRunList) {
|
const SkFont& runFont = glyphRun.font();
|
auto runSize = glyphRun.runSize();
|
|
if (ShouldDrawAsPath(runPaint, runFont, deviceMatrix)) {
|
SkMatrix::MakeTrans(origin.x(), origin.y()).mapPoints(
|
fPositions, glyphRun.positions().data(), runSize);
|
// setup our std pathPaint, in hopes of getting hits in the cache
|
SkPaint pathPaint(runPaint);
|
SkFont pathFont{runFont};
|
SkScalar textScale = pathFont.setupForAsPaths(&pathPaint);
|
|
auto pathCache = SkStrikeCache::FindOrCreateStrikeExclusive(
|
pathFont, pathPaint, props,
|
fScalerContextFlags, SkMatrix::I());
|
|
SkTDArray<SkPathPos> pathsAndPositions;
|
pathsAndPositions.setReserve(runSize);
|
SkPoint* positionCursor = fPositions;
|
for (auto glyphID : glyphRun.glyphsIDs()) {
|
SkPoint position = *positionCursor++;
|
if (check_glyph_position(position)) {
|
const SkGlyph& glyph = pathCache->getGlyphMetrics(glyphID, {0, 0});
|
if (!glyph.isEmpty()) {
|
const SkPath* path = pathCache->findPath(glyph);
|
if (path != nullptr) {
|
pathsAndPositions.push_back(SkPathPos{path, position});
|
}
|
}
|
}
|
}
|
|
// The paint we draw paths with must have the same anti-aliasing state as the runFont
|
// allowing the paths to have the same edging as the glyph masks.
|
pathPaint = runPaint;
|
pathPaint.setAntiAlias(runFont.hasSomeAntiAliasing());
|
|
bitmapDevice->paintPaths(
|
SkSpan<const SkPathPos>{pathsAndPositions.begin(), pathsAndPositions.size()},
|
textScale, pathPaint);
|
} else {
|
auto cache = SkStrikeCache::FindOrCreateStrikeExclusive(
|
runFont, runPaint, props,
|
fScalerContextFlags, deviceMatrix);
|
|
// Add rounding and origin.
|
SkMatrix matrix = deviceMatrix;
|
matrix.preTranslate(origin.x(), origin.y());
|
SkPoint rounding = cache->rounding();
|
matrix.postTranslate(rounding.x(), rounding.y());
|
matrix.mapPoints(fPositions, glyphRun.positions().data(), runSize);
|
|
SkTDArray<SkMask> masks;
|
masks.setReserve(runSize);
|
const SkPoint* positionCursor = fPositions;
|
for (auto glyphID : glyphRun.glyphsIDs()) {
|
auto position = *positionCursor++;
|
if (check_glyph_position(position)) {
|
const SkGlyph& glyph = cache->getGlyphMetrics(glyphID, position);
|
const void* image;
|
if (!glyph.isEmpty() && (image = cache->findImage(glyph))) {
|
masks.push_back(create_mask(glyph, position, image));
|
}
|
}
|
}
|
bitmapDevice->paintMasks(SkSpan<const SkMask>{masks.begin(), masks.size()}, runPaint);
|
}
|
}
|
}
|
|
// Getting glyphs to the screen in a fallback situation can be complex. Here is the set of
|
// transformations that have to happen. Normally, they would all be accommodated by the font
|
// scaler, but the atlas has an upper limit to the glyphs it can handle. So the GPU is used to
|
// make up the difference from the smaller atlas size to the larger size needed by the final
|
// transform. Here are the transformations that are applied.
|
//
|
// final transform = [view matrix] * [text scale] * [text size]
|
//
|
// There are three cases:
|
// * Go Fast - view matrix is scale and translate, and all the glyphs are small enough
|
// Just scale the positions, and have the glyph cache handle the view matrix transformation.
|
// The text scale is 1.
|
// * It's complicated - view matrix is not scale and translate, and the glyphs are small enough
|
// The glyph cache does not handle the view matrix, but stores the glyphs at the text size
|
// specified by the run paint. The GPU handles the rotation, etc. specified by the view matrix.
|
// The text scale is 1.
|
// * Too big - The glyphs are too big to fit in the atlas
|
// Reduce the text size so the glyphs will fit in the atlas, but don't apply any
|
// transformations from the view matrix. Calculate a text scale based on that reduction. This
|
// scale factor is used to increase the size of the destination rectangles. The destination
|
// rectangles are then scaled, rotated, etc. by the GPU using the view matrix.
|
void SkGlyphRunListPainter::processARGBFallback(SkScalar maxSourceGlyphDimension,
|
const SkPaint& runPaint,
|
const SkFont& runFont,
|
const SkMatrix& viewMatrix,
|
SkGlyphRunPainterInterface* process) {
|
SkASSERT(!fARGBGlyphsIDs.empty());
|
|
SkScalar maxScale = viewMatrix.getMaxScale();
|
|
// This is a linear estimate of the longest dimension among all the glyph widths and heights.
|
SkScalar conservativeMaxGlyphDimension = maxSourceGlyphDimension * maxScale;
|
|
// If the situation that the matrix is simple, and all the glyphs are small enough. Go fast!
|
// N.B. If the matrix has scale, that will be reflected in the strike through the viewMatrix
|
// in the useFastPath case.
|
bool useDeviceCache =
|
viewMatrix.isScaleTranslate()
|
&& conservativeMaxGlyphDimension <= SkStrikeCommon::kSkSideTooBigForAtlas;
|
|
// A scaled and translated transform is the common case, and is handled directly in fallback.
|
// Even if the transform is scale and translate, fallback must be careful to use glyphs that
|
// fit in the atlas. If a glyph will not fit in the atlas, then the general transform case is
|
// used to render the glyphs.
|
if (useDeviceCache) {
|
// Translate the positions to device space.
|
viewMatrix.mapPoints(fARGBPositions.data(), fARGBPositions.size());
|
for (SkPoint& point : fARGBPositions) {
|
point.fX = SkScalarFloorToScalar(point.fX);
|
point.fY = SkScalarFloorToScalar(point.fY);
|
}
|
|
SkAutoDescriptor ad;
|
SkScalerContextEffects effects;
|
SkScalerContext::CreateDescriptorAndEffectsUsingPaint(
|
runFont, runPaint, fDeviceProps, fScalerContextFlags, viewMatrix, &ad, &effects);
|
|
SkScopedStrike strike =
|
fStrikeCache->findOrCreateScopedStrike(
|
*ad.getDesc(), effects, *runFont.getTypefaceOrDefault());
|
|
int drawableGlyphCount = strike->glyphMetrics(fARGBGlyphsIDs.data(),
|
fARGBPositions.data(),
|
fARGBGlyphsIDs.size(),
|
fGlyphPos);
|
|
process->processDeviceFallback(
|
SkSpan<const SkGlyphPos>{fGlyphPos, SkTo<size_t>(drawableGlyphCount)},
|
strike.get());
|
|
} else {
|
// If the matrix is complicated or if scaling is used to fit the glyphs in the cache,
|
// then this case is used.
|
|
// Subtract 2 to account for the bilerp pad around the glyph
|
SkScalar maxAtlasDimension = SkStrikeCommon::kSkSideTooBigForAtlas - 2;
|
|
SkScalar runFontTextSize = runFont.getSize();
|
|
// Scale the text size down so the long side of all the glyphs will fit in the atlas.
|
SkScalar fallbackTextSize = SkScalarFloorToScalar(
|
(maxAtlasDimension / maxSourceGlyphDimension) * runFontTextSize);
|
|
SkFont fallbackFont{runFont};
|
fallbackFont.setSize(fallbackTextSize);
|
|
// The scale factor to go from strike size to the source size for glyphs.
|
SkScalar fallbackTextScale = runFontTextSize / fallbackTextSize;
|
|
SkAutoDescriptor ad;
|
SkScalerContextEffects effects;
|
SkScalerContext::CreateDescriptorAndEffectsUsingPaint(fallbackFont,
|
runPaint,
|
fDeviceProps,
|
fScalerContextFlags,
|
SkMatrix::I(),
|
&ad,
|
&effects);
|
|
SkScopedStrike strike =
|
fStrikeCache->findOrCreateScopedStrike(
|
*ad.getDesc(), effects, *fallbackFont.getTypefaceOrDefault());
|
|
SkPoint* posCursor = fARGBPositions.data();
|
int glyphCount = 0;
|
for (SkGlyphID glyphID : fARGBGlyphsIDs) {
|
SkPoint pos = *posCursor++;
|
const SkGlyph& glyph = strike->getGlyphMetrics(glyphID, {0, 0});
|
fGlyphPos[glyphCount++] = {&glyph, pos};
|
}
|
|
process->processSourceFallback(
|
SkSpan<const SkGlyphPos>{fGlyphPos, SkTo<size_t>(glyphCount)},
|
strike.get(),
|
fallbackTextScale,
|
viewMatrix.hasPerspective());
|
}
|
}
|
|
#if SK_SUPPORT_GPU
|
void SkGlyphRunListPainter::processGlyphRunList(const SkGlyphRunList& glyphRunList,
|
const SkMatrix& viewMatrix,
|
const SkSurfaceProps& props,
|
bool contextSupportsDistanceFieldText,
|
const GrTextContext::Options& options,
|
SkGlyphRunPainterInterface* process) {
|
|
SkPoint origin = glyphRunList.origin();
|
const SkPaint& runPaint = glyphRunList.paint();
|
|
for (const auto& glyphRun : glyphRunList) {
|
const SkFont& runFont = glyphRun.font();
|
|
bool useSDFT = GrTextContext::CanDrawAsDistanceFields(
|
runPaint, runFont, viewMatrix, props, contextSupportsDistanceFieldText, options);
|
if (process) {
|
process->startRun(glyphRun, useSDFT);
|
}
|
|
if (useSDFT) {
|
ScopedBuffers _ = this->ensureBuffers(glyphRun);
|
SkScalar maxFallbackDimension{-SK_ScalarInfinity};
|
|
// Setup distance field runPaint and text ratio
|
SkPaint dfPaint = GrTextContext::InitDistanceFieldPaint(runPaint);
|
SkScalar cacheToSourceScale;
|
SkFont dfFont = GrTextContext::InitDistanceFieldFont(
|
runFont, viewMatrix, options, &cacheToSourceScale);
|
// Fake-gamma and subpixel antialiasing are applied in the shader, so we ignore the
|
// passed-in scaler context flags. (It's only used when we fall-back to bitmap text).
|
SkScalerContextFlags flags = SkScalerContextFlags::kNone;
|
|
SkScalar minScale, maxScale;
|
std::tie(minScale, maxScale) = GrTextContext::InitDistanceFieldMinMaxScale(
|
runFont.getSize(), viewMatrix, options);
|
|
SkAutoDescriptor ad;
|
SkScalerContextEffects effects;
|
SkScalerContext::CreateDescriptorAndEffectsUsingPaint(
|
dfFont, dfPaint, fDeviceProps, flags, SkMatrix::I(), &ad, &effects);
|
SkScopedStrike strike =
|
fStrikeCache->findOrCreateScopedStrike(
|
*ad.getDesc(), effects, *dfFont.getTypefaceOrDefault());
|
|
std::vector<SkGlyphPos> paths;
|
|
int glyphCount = 0;
|
const SkPoint* positionCursor = glyphRun.positions().data();
|
for (auto glyphID : glyphRun.glyphsIDs()) {
|
const SkGlyph& glyph = strike->getGlyphMetrics(glyphID, {0, 0});
|
SkPoint glyphPos = origin + *positionCursor++;
|
if (!glyph.isEmpty()) {
|
if (glyph.fMaskFormat == SkMask::kSDF_Format) {
|
if (!SkStrikeCommon::GlyphTooBigForAtlas(glyph)) {
|
// If the glyph is not empty, then it will have a pointer to SDF data.
|
fGlyphPos[glyphCount++] = {&glyph, glyphPos};
|
} else {
|
if (strike->decideCouldDrawFromPath(glyph)) {
|
paths.push_back({&glyph, glyphPos});
|
}
|
}
|
} else {
|
SkASSERT(glyph.fMaskFormat == SkMask::kARGB32_Format);
|
SkScalar largestDimension = std::max(glyph.fWidth, glyph.fHeight);
|
maxFallbackDimension = std::max(maxFallbackDimension, largestDimension);
|
fARGBGlyphsIDs.push_back(glyphID);
|
fARGBPositions.push_back(glyphPos);
|
}
|
}
|
}
|
|
if (process) {
|
if (glyphCount > 0) {
|
bool hasWCoord = viewMatrix.hasPerspective()
|
|| options.fDistanceFieldVerticesAlwaysHaveW;
|
process->processSourceSDFT(
|
SkSpan<const SkGlyphPos>{fGlyphPos, SkTo<size_t>(glyphCount)},
|
strike.get(),
|
runFont,
|
cacheToSourceScale,
|
minScale,
|
maxScale,
|
hasWCoord);
|
}
|
|
if (!paths.empty()) {
|
process->processSourcePaths(
|
SkSpan<const SkGlyphPos>{paths}, strike.get(), cacheToSourceScale);
|
}
|
|
{
|
// fGlyphPos will be reused here.
|
if (!fARGBGlyphsIDs.empty()) {
|
this->processARGBFallback(maxFallbackDimension * cacheToSourceScale,
|
runPaint, runFont, viewMatrix, process);
|
}
|
}
|
}
|
} else if (SkGlyphRunListPainter::ShouldDrawAsPath(runPaint, runFont, viewMatrix)) {
|
ScopedBuffers _ = this->ensureBuffers(glyphRun);
|
SkScalar maxFallbackDimension{-SK_ScalarInfinity};
|
|
// setup our std runPaint, in hopes of getting hits in the cache
|
SkPaint pathPaint{runPaint};
|
SkFont pathFont{runFont};
|
|
// The factor to get from the size stored in the strike to the size needed for
|
// the source.
|
SkScalar strikeToSourceRatio = pathFont.setupForAsPaths(&pathPaint);
|
|
SkAutoDescriptor ad;
|
SkScalerContextEffects effects;
|
SkScalerContext::CreateDescriptorAndEffectsUsingPaint(pathFont,
|
pathPaint,
|
fDeviceProps,
|
fScalerContextFlags,
|
SkMatrix::I(),
|
&ad,
|
&effects);
|
SkScopedStrike strike =
|
fStrikeCache->findOrCreateScopedStrike(
|
*ad.getDesc(), effects,*pathFont.getTypefaceOrDefault());
|
|
int glyphCount = 0;
|
const SkPoint* positionCursor = glyphRun.positions().data();
|
for (auto glyphID : glyphRun.glyphsIDs()) {
|
SkPoint glyphPos = origin + *positionCursor++;
|
|
// Use outline from {0, 0} because all transforms including subpixel translation
|
// happen during drawing.
|
const SkGlyph& glyph = strike->getGlyphMetrics(glyphID, {0, 0});
|
if (!glyph.isEmpty()) {
|
if (glyph.fMaskFormat != SkMask::kARGB32_Format) {
|
if (strike->decideCouldDrawFromPath(glyph)) {
|
fGlyphPos[glyphCount++] = {&glyph, glyphPos};
|
}
|
} else {
|
SkScalar largestDimension = std::max(glyph.fWidth, glyph.fHeight);
|
maxFallbackDimension = std::max(maxFallbackDimension, largestDimension);
|
fARGBGlyphsIDs.push_back(glyphID);
|
fARGBPositions.push_back(glyphPos);
|
}
|
}
|
}
|
|
if (process) {
|
if (glyphCount > 0) {
|
process->processSourcePaths(
|
SkSpan<const SkGlyphPos>{fGlyphPos, SkTo<size_t>(glyphCount)},
|
strike.get(),
|
strikeToSourceRatio);
|
}
|
|
// fGlyphPos will be reused here.
|
if (!fARGBGlyphsIDs.empty()) {
|
this->processARGBFallback(maxFallbackDimension * strikeToSourceRatio,
|
runPaint, runFont, viewMatrix, process);
|
}
|
}
|
} else {
|
|
SkAutoDescriptor ad;
|
SkScalerContextEffects effects;
|
|
SkScalerContext::CreateDescriptorAndEffectsUsingPaint(
|
runFont, runPaint, fDeviceProps, fScalerContextFlags, viewMatrix, &ad,
|
&effects);
|
|
SkTypeface* typeface = runFont.getTypefaceOrDefault();
|
SkScopedStrike strike =
|
fStrikeCache->findOrCreateScopedStrike(*ad.getDesc(), effects, *typeface);
|
|
ScopedBuffers _ = this->ensureBuffers(glyphRun);
|
SkScalar maxFallbackDimension{-SK_ScalarInfinity};
|
|
SkMatrix mapping = viewMatrix;
|
mapping.preTranslate(origin.x(), origin.y());
|
SkVector rounding = strike->rounding();
|
mapping.postTranslate(rounding.x(), rounding.y());
|
mapping.mapPoints(fPositions, glyphRun.positions().data(), glyphRun.runSize());
|
|
int glyphsWithMaskCount = 0;
|
const SkPoint* positionCursor = glyphRun.positions().data();
|
const SkPoint* devicePositionCursor = fPositions;
|
for (auto glyphID : glyphRun.glyphsIDs()) {
|
SkPoint glyphPos = *positionCursor++;
|
SkPoint deviceGlyphPos = *devicePositionCursor++;
|
if (!SkScalarsAreFinite(deviceGlyphPos.x(), deviceGlyphPos.y())) {
|
continue;
|
}
|
|
const SkGlyph& glyph = strike->getGlyphMetrics(glyphID, deviceGlyphPos);
|
if (glyph.isEmpty()) {
|
continue;
|
}
|
|
if (SkStrikeCommon::GlyphTooBigForAtlas(glyph)) {
|
if (strike->decideCouldDrawFromPath(glyph)) {
|
fPaths.push_back({&glyph, deviceGlyphPos});
|
} else {
|
SkScalar largestDimension = std::max(glyph.fWidth, glyph.fHeight);
|
maxFallbackDimension = std::max(maxFallbackDimension, largestDimension);
|
fARGBGlyphsIDs.push_back(glyph.getGlyphID());
|
fARGBPositions.push_back(origin + glyphPos);
|
}
|
} else {
|
fGlyphPos[glyphsWithMaskCount++] = {&glyph, deviceGlyphPos};
|
}
|
}
|
|
if (process) {
|
if (glyphsWithMaskCount > 0) {
|
process->processDeviceMasks(
|
SkSpan<const SkGlyphPos>{fGlyphPos, SkTo<size_t>(glyphsWithMaskCount)},
|
strike.get());
|
}
|
if (!fPaths.empty()) {
|
process->processDevicePaths(SkSpan<const SkGlyphPos>{fPaths});
|
}
|
|
// fGlyphPos will be reused here.
|
if (!fARGBGlyphsIDs.empty()) {
|
this->processARGBFallback(maxFallbackDimension / viewMatrix.getMaxScale(),
|
runPaint, runFont, viewMatrix, process);
|
}
|
}
|
|
}
|
|
}
|
}
|
#endif // SK_SUPPORT_GPU
|
|
auto SkGlyphRunListPainter::ensureBuffers(const SkGlyphRunList& glyphRunList) -> ScopedBuffers {
|
size_t size = 0;
|
for (const SkGlyphRun& run : glyphRunList) {
|
size = std::max(run.runSize(), size);
|
}
|
return ScopedBuffers(this, size);
|
}
|
|
SkGlyphRunListPainter::ScopedBuffers
|
SkGlyphRunListPainter::ensureBuffers(const SkGlyphRun& glyphRun) {
|
return ScopedBuffers(this, glyphRun.runSize());
|
}
|
|
#if SK_SUPPORT_GPU
|
// -- GrTextContext --------------------------------------------------------------------------------
|
SkPMColor4f generate_filtered_color(const SkPaint& paint, const GrColorSpaceInfo& colorSpaceInfo) {
|
SkColor4f filteredColor = paint.getColor4f();
|
if (auto* xform = colorSpaceInfo.colorSpaceXformFromSRGB()) {
|
filteredColor = xform->apply(filteredColor);
|
}
|
if (paint.getColorFilter() != nullptr) {
|
filteredColor = paint.getColorFilter()->filterColor4f(filteredColor,
|
colorSpaceInfo.colorSpace());
|
}
|
return filteredColor.premul();
|
}
|
|
void GrTextContext::drawGlyphRunList(
|
GrRecordingContext* context, GrTextTarget* target, const GrClip& clip,
|
const SkMatrix& viewMatrix, const SkSurfaceProps& props,
|
const SkGlyphRunList& glyphRunList) {
|
SkPoint origin = glyphRunList.origin();
|
|
// Get the first paint to use as the key paint.
|
const SkPaint& listPaint = glyphRunList.paint();
|
|
SkPMColor4f filteredColor = generate_filtered_color(listPaint, target->colorSpaceInfo());
|
GrColor color = generate_filtered_color(listPaint, target->colorSpaceInfo()).toBytes_RGBA();
|
|
// If we have been abandoned, then don't draw
|
if (context->priv().abandoned()) {
|
return;
|
}
|
|
SkMaskFilterBase::BlurRec blurRec;
|
// It might be worth caching these things, but its not clear at this time
|
// TODO for animated mask filters, this will fill up our cache. We need a safeguard here
|
const SkMaskFilter* mf = listPaint.getMaskFilter();
|
bool canCache = glyphRunList.canCache() && !(listPaint.getPathEffect() ||
|
(mf && !as_MFB(mf)->asABlur(&blurRec)));
|
SkScalerContextFlags scalerContextFlags = ComputeScalerContextFlags(target->colorSpaceInfo());
|
|
auto grStrikeCache = context->priv().getGrStrikeCache();
|
GrTextBlobCache* textBlobCache = context->priv().getTextBlobCache();
|
|
sk_sp<GrTextBlob> cacheBlob;
|
GrTextBlob::Key key;
|
if (canCache) {
|
bool hasLCD = glyphRunList.anyRunsLCD();
|
|
// We canonicalize all non-lcd draws to use kUnknown_SkPixelGeometry
|
SkPixelGeometry pixelGeometry = hasLCD ? props.pixelGeometry() :
|
kUnknown_SkPixelGeometry;
|
|
// TODO we want to figure out a way to be able to use the canonical color on LCD text,
|
// see the note on ComputeCanonicalColor above. We pick a dummy value for LCD text to
|
// ensure we always match the same key
|
GrColor canonicalColor = hasLCD ? SK_ColorTRANSPARENT :
|
ComputeCanonicalColor(listPaint, hasLCD);
|
|
key.fPixelGeometry = pixelGeometry;
|
key.fUniqueID = glyphRunList.uniqueID();
|
key.fStyle = listPaint.getStyle();
|
key.fHasBlur = SkToBool(mf);
|
key.fCanonicalColor = canonicalColor;
|
key.fScalerContextFlags = scalerContextFlags;
|
cacheBlob = textBlobCache->find(key);
|
}
|
|
if (cacheBlob) {
|
if (cacheBlob->mustRegenerate(listPaint, glyphRunList.anyRunsSubpixelPositioned(),
|
blurRec, viewMatrix, origin.x(),origin.y())) {
|
// We have to remake the blob because changes may invalidate our masks.
|
// TODO we could probably get away reuse most of the time if the pointer is unique,
|
// but we'd have to clear the subrun information
|
textBlobCache->remove(cacheBlob.get());
|
cacheBlob = textBlobCache->makeCachedBlob(
|
glyphRunList, key, blurRec, listPaint, color, grStrikeCache);
|
cacheBlob->generateFromGlyphRunList(
|
*context->priv().caps()->shaderCaps(), fOptions,
|
listPaint, scalerContextFlags, viewMatrix, props,
|
glyphRunList, target->glyphPainter());
|
} else {
|
textBlobCache->makeMRU(cacheBlob.get());
|
|
if (CACHE_SANITY_CHECK) {
|
sk_sp<GrTextBlob> sanityBlob(textBlobCache->makeBlob(
|
glyphRunList, color, grStrikeCache));
|
sanityBlob->setupKey(key, blurRec, listPaint);
|
cacheBlob->generateFromGlyphRunList(
|
*context->priv().caps()->shaderCaps(), fOptions,
|
listPaint, scalerContextFlags, viewMatrix, props, glyphRunList,
|
target->glyphPainter());
|
GrTextBlob::AssertEqual(*sanityBlob, *cacheBlob);
|
}
|
}
|
} else {
|
if (canCache) {
|
cacheBlob = textBlobCache->makeCachedBlob(
|
glyphRunList, key, blurRec, listPaint, color, grStrikeCache);
|
} else {
|
cacheBlob = textBlobCache->makeBlob(glyphRunList, color, grStrikeCache);
|
}
|
cacheBlob->generateFromGlyphRunList(
|
*context->priv().caps()->shaderCaps(), fOptions, listPaint,
|
scalerContextFlags, viewMatrix, props, glyphRunList,
|
target->glyphPainter());
|
}
|
|
cacheBlob->flush(target, props, fDistanceAdjustTable.get(), listPaint, filteredColor,
|
clip, viewMatrix, origin.x(), origin.y());
|
}
|
|
void GrTextBlob::SubRun::appendGlyph(GrGlyph* glyph, SkRect dstRect) {
|
|
this->joinGlyphBounds(dstRect);
|
|
GrTextBlob* blob = fRun->fBlob;
|
|
bool hasW = this->hasWCoord();
|
// glyphs drawn in perspective must always have a w coord.
|
SkASSERT(hasW || !blob->fInitialViewMatrix.hasPerspective());
|
auto maskFormat = this->maskFormat();
|
size_t vertexStride = GetVertexStride(maskFormat, hasW);
|
|
intptr_t vertex = reinterpret_cast<intptr_t>(blob->fVertices + fVertexEndIndex);
|
|
// We always write the third position component used by SDFs. If it is unused it gets
|
// overwritten. Similarly, we always write the color and the blob will later overwrite it
|
// with texture coords if it is unused.
|
size_t colorOffset = hasW ? sizeof(SkPoint3) : sizeof(SkPoint);
|
// V0
|
*reinterpret_cast<SkPoint3*>(vertex) = {dstRect.fLeft, dstRect.fTop, 1.f};
|
*reinterpret_cast<GrColor*>(vertex + colorOffset) = fColor;
|
vertex += vertexStride;
|
|
// V1
|
*reinterpret_cast<SkPoint3*>(vertex) = {dstRect.fLeft, dstRect.fBottom, 1.f};
|
*reinterpret_cast<GrColor*>(vertex + colorOffset) = fColor;
|
vertex += vertexStride;
|
|
// V2
|
*reinterpret_cast<SkPoint3*>(vertex) = {dstRect.fRight, dstRect.fTop, 1.f};
|
*reinterpret_cast<GrColor*>(vertex + colorOffset) = fColor;
|
vertex += vertexStride;
|
|
// V3
|
*reinterpret_cast<SkPoint3*>(vertex) = {dstRect.fRight, dstRect.fBottom, 1.f};
|
*reinterpret_cast<GrColor*>(vertex + colorOffset) = fColor;
|
|
fVertexEndIndex += vertexStride * kVerticesPerGlyph;
|
blob->fGlyphs[fGlyphEndIndex++] = glyph;
|
}
|
|
void GrTextBlob::Run::switchSubRunIfNeededAndAppendGlyph(GrGlyph* glyph,
|
const sk_sp<GrTextStrike>& strike,
|
const SkRect& destRect,
|
bool needsTransform) {
|
GrMaskFormat format = glyph->fMaskFormat;
|
|
SubRun* subRun = &fSubRunInfo.back();
|
if (fInitialized && subRun->maskFormat() != format) {
|
subRun = pushBackSubRun(fDescriptor, fColor);
|
subRun->setStrike(strike);
|
} else if (!fInitialized) {
|
subRun->setStrike(strike);
|
}
|
|
fInitialized = true;
|
subRun->setMaskFormat(format);
|
subRun->setNeedsTransform(needsTransform);
|
subRun->appendGlyph(glyph, destRect);
|
}
|
|
void GrTextBlob::Run::appendDeviceSpaceGlyph(const sk_sp<GrTextStrike>& strike,
|
const SkGlyph& skGlyph, SkPoint origin) {
|
if (GrGlyph* glyph = strike->getGlyph(skGlyph)) {
|
|
SkRect glyphRect = glyph->destRect(origin);
|
|
if (!glyphRect.isEmpty()) {
|
this->switchSubRunIfNeededAndAppendGlyph(glyph, strike, glyphRect, false);
|
}
|
}
|
}
|
|
void GrTextBlob::Run::appendSourceSpaceGlyph(const sk_sp<GrTextStrike>& strike,
|
const SkGlyph& skGlyph,
|
SkPoint origin,
|
SkScalar textScale) {
|
if (GrGlyph* glyph = strike->getGlyph(skGlyph)) {
|
|
SkRect glyphRect = glyph->destRect(origin, textScale);
|
|
if (!glyphRect.isEmpty()) {
|
this->switchSubRunIfNeededAndAppendGlyph(glyph, strike, glyphRect, true);
|
}
|
}
|
}
|
|
void GrTextBlob::generateFromGlyphRunList(const GrShaderCaps& shaderCaps,
|
const GrTextContext::Options& options,
|
const SkPaint& paint,
|
SkScalerContextFlags scalerContextFlags,
|
const SkMatrix& viewMatrix,
|
const SkSurfaceProps& props,
|
const SkGlyphRunList& glyphRunList,
|
SkGlyphRunListPainter* glyphPainter) {
|
SkPoint origin = glyphRunList.origin();
|
const SkPaint& runPaint = glyphRunList.paint();
|
this->initReusableBlob(SkPaintPriv::ComputeLuminanceColor(runPaint), viewMatrix,
|
origin.x(), origin.y());
|
|
glyphPainter->processGlyphRunList(glyphRunList,
|
viewMatrix,
|
props,
|
shaderCaps.supportsDistanceFieldText(),
|
options,
|
this);
|
}
|
|
GrTextBlob::Run* GrTextBlob::currentRun() {
|
return &fRuns[fRunCount - 1];
|
}
|
|
void GrTextBlob::startRun(const SkGlyphRun& glyphRun, bool useSDFT) {
|
if (useSDFT) {
|
this->setHasDistanceField();
|
}
|
Run* run = this->pushBackRun();
|
run->setRunFontAntiAlias(glyphRun.font().hasSomeAntiAliasing());
|
}
|
|
void GrTextBlob::processDeviceMasks(SkSpan<const SkGlyphPos> masks,
|
SkStrikeInterface* strike) {
|
Run* run = this->currentRun();
|
this->setHasBitmap();
|
run->setupFont(strike->strikeSpec());
|
sk_sp<GrTextStrike> currStrike = fStrikeCache->getStrike(strike->getDescriptor());
|
for (const auto& mask : masks) {
|
SkPoint pt{SkScalarFloorToScalar(mask.position.fX),
|
SkScalarFloorToScalar(mask.position.fY)};
|
run->appendDeviceSpaceGlyph(currStrike, *mask.glyph, pt);
|
}
|
}
|
|
void GrTextBlob::processSourcePaths(SkSpan<const SkGlyphPos> paths,
|
SkStrikeInterface* strike, SkScalar cacheToSourceScale) {
|
Run* run = this->currentRun();
|
this->setHasBitmap();
|
run->setupFont(strike->strikeSpec());
|
for (const auto& path : paths) {
|
if (const SkPath* glyphPath = path.glyph->path()) {
|
run->appendPathGlyph(*glyphPath, path.position, cacheToSourceScale,
|
false);
|
}
|
}
|
}
|
|
void GrTextBlob::processDevicePaths(SkSpan<const SkGlyphPos> paths) {
|
Run* run = this->currentRun();
|
this->setHasBitmap();
|
for (const auto& path : paths) {
|
SkPoint pt{SkScalarFloorToScalar(path.position.fX),
|
SkScalarFloorToScalar(path.position.fY)};
|
// TODO: path should always be set. Remove when proven.
|
if (const SkPath* glyphPath = path.glyph->path()) {
|
run->appendPathGlyph(*glyphPath, pt, SK_Scalar1, true);
|
}
|
}
|
}
|
|
void GrTextBlob::processSourceSDFT(SkSpan<const SkGlyphPos> masks,
|
SkStrikeInterface* strike,
|
const SkFont& runFont,
|
SkScalar cacheToSourceScale,
|
SkScalar minScale,
|
SkScalar maxScale,
|
bool hasWCoord) {
|
|
Run* run = this->currentRun();
|
run->setSubRunHasDistanceFields(
|
runFont.getEdging() == SkFont::Edging::kSubpixelAntiAlias,
|
runFont.hasSomeAntiAliasing(),
|
hasWCoord);
|
this->setMinAndMaxScale(minScale, maxScale);
|
run->setupFont(strike->strikeSpec());
|
sk_sp<GrTextStrike> currStrike = fStrikeCache->getStrike(strike->getDescriptor());
|
for (const auto& mask : masks) {
|
run->appendSourceSpaceGlyph(
|
currStrike, *mask.glyph, mask.position, cacheToSourceScale);
|
}
|
}
|
|
void GrTextBlob::processSourceFallback(SkSpan<const SkGlyphPos> masks,
|
SkStrikeInterface* strike, SkScalar cacheToSourceScale,
|
bool hasW) {
|
Run* run = this->currentRun();
|
|
auto subRun = run->initARGBFallback();
|
sk_sp<GrTextStrike> grStrike =
|
fStrikeCache->getStrike(strike->getDescriptor());
|
subRun->setStrike(grStrike);
|
subRun->setHasWCoord(hasW);
|
|
this->setHasBitmap();
|
run->setupFont(strike->strikeSpec());
|
for (const auto& mask : masks) {
|
run->appendSourceSpaceGlyph
|
(grStrike, *mask.glyph, mask.position, cacheToSourceScale);
|
}
|
}
|
|
void GrTextBlob::processDeviceFallback(SkSpan<const SkGlyphPos> masks,
|
SkStrikeInterface* strike) {
|
Run* run = this->currentRun();
|
this->setHasBitmap();
|
sk_sp<GrTextStrike> grStrike = fStrikeCache->getStrike(strike->getDescriptor());
|
auto subRun = run->initARGBFallback();
|
run->setupFont(strike->strikeSpec());
|
subRun->setStrike(grStrike);
|
for (const auto& mask : masks) {
|
run->appendDeviceSpaceGlyph(grStrike, *mask.glyph, mask.position);
|
}
|
}
|
|
#if GR_TEST_UTILS
|
|
#include "GrRenderTargetContext.h"
|
#include "GrRecordingContextPriv.h"
|
|
std::unique_ptr<GrDrawOp> GrTextContext::createOp_TestingOnly(GrRecordingContext* context,
|
GrTextContext* textContext,
|
GrRenderTargetContext* rtc,
|
const SkPaint& skPaint,
|
const SkFont& font,
|
const SkMatrix& viewMatrix,
|
const char* text,
|
int x,
|
int y) {
|
auto direct = context->priv().asDirectContext();
|
if (!direct) {
|
return nullptr;
|
}
|
|
auto strikeCache = direct->priv().getGrStrikeCache();
|
|
static SkSurfaceProps surfaceProps(SkSurfaceProps::kLegacyFontHost_InitType);
|
|
size_t textLen = (int)strlen(text);
|
|
SkPMColor4f filteredColor = generate_filtered_color(skPaint, rtc->colorSpaceInfo());
|
GrColor color = filteredColor.toBytes_RGBA();
|
|
auto origin = SkPoint::Make(x, y);
|
SkGlyphRunBuilder builder;
|
builder.drawTextUTF8(skPaint, font, text, textLen, origin);
|
|
auto glyphRunList = builder.useGlyphRunList();
|
sk_sp<GrTextBlob> blob;
|
if (!glyphRunList.empty()) {
|
blob = direct->priv().getTextBlobCache()->makeBlob(glyphRunList, color, strikeCache);
|
// Use the text and textLen below, because we don't want to mess with the paint.
|
SkScalerContextFlags scalerContextFlags =
|
ComputeScalerContextFlags(rtc->colorSpaceInfo());
|
blob->generateFromGlyphRunList(
|
*context->priv().caps()->shaderCaps(), textContext->fOptions,
|
skPaint, scalerContextFlags, viewMatrix, surfaceProps,
|
glyphRunList, rtc->textTarget()->glyphPainter());
|
}
|
|
return blob->test_makeOp(textLen, 0, 0, viewMatrix, x, y, skPaint, filteredColor, surfaceProps,
|
textContext->dfAdjustTable(), rtc->textTarget());
|
}
|
|
#endif // GR_TEST_UTILS
|
#endif // SK_SUPPORT_GPU
|
|
SkGlyphRunListPainter::ScopedBuffers::ScopedBuffers(SkGlyphRunListPainter* painter, int size)
|
: fPainter{painter} {
|
SkASSERT(size >= 0);
|
if (fPainter->fMaxRunSize < size) {
|
fPainter->fMaxRunSize = size;
|
|
fPainter->fPositions.reset(size);
|
fPainter->fGlyphPos.reset(size);
|
}
|
}
|
|
SkGlyphRunListPainter::ScopedBuffers::~ScopedBuffers() {
|
fPainter->fPaths.clear();
|
fPainter->fARGBGlyphsIDs.clear();
|
fPainter->fARGBPositions.clear();
|
|
if (fPainter->fMaxRunSize > 200) {
|
fPainter->fMaxRunSize = 0;
|
fPainter->fPositions.reset();
|
fPainter->fGlyphPos.reset();
|
fPainter->fPaths.shrink_to_fit();
|
fPainter->fARGBGlyphsIDs.shrink_to_fit();
|
fPainter->fARGBPositions.shrink_to_fit();
|
}
|
}
|
