blob: 07e114196bcbf5953d55829327ea8da9fe5e5f23 [file] [log] [blame]
/*
* Copyright 2015 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#include "GrAtlasTextOp.h"
#include "GrContext.h"
#include "GrOpFlushState.h"
#include "GrResourceProvider.h"
#include "SkGlyphCache.h"
#include "SkMathPriv.h"
#include "SkMatrixPriv.h"
#include "SkPoint3.h"
#include "effects/GrBitmapTextGeoProc.h"
#include "effects/GrDistanceFieldGeoProc.h"
#include "text/GrAtlasManager.h"
#include "text/GrGlyphCache.h"
///////////////////////////////////////////////////////////////////////////////////////////////////
static const int kDistanceAdjustLumShift = 5;
void GrAtlasTextOp::init() {
const Geometry& geo = fGeoData[0];
SkRect bounds;
geo.fBlob->computeSubRunBounds(&bounds, geo.fRun, geo.fSubRun, geo.fViewMatrix, geo.fX, geo.fY);
// We don't have tight bounds on the glyph paths in device space. For the purposes of bounds
// we treat this as a set of non-AA rects rendered with a texture.
this->setBounds(bounds, HasAABloat::kNo, IsZeroArea::kNo);
if (this->usesDistanceFields()) {
bool isLCD = this->isLCD();
const SkMatrix& viewMatrix = geo.fViewMatrix;
fDFGPFlags = viewMatrix.isSimilarity() ? kSimilarity_DistanceFieldEffectFlag : 0;
fDFGPFlags |= viewMatrix.isScaleTranslate() ? kScaleOnly_DistanceFieldEffectFlag : 0;
fDFGPFlags |= viewMatrix.hasPerspective() ? kPerspective_DistanceFieldEffectFlag : 0;
fDFGPFlags |= fUseGammaCorrectDistanceTable ? kGammaCorrect_DistanceFieldEffectFlag : 0;
fDFGPFlags |= (kAliasedDistanceField_MaskType == fMaskType)
? kAliased_DistanceFieldEffectFlag
: 0;
if (isLCD) {
fDFGPFlags |= kUseLCD_DistanceFieldEffectFlag;
fDFGPFlags |=
(kLCDBGRDistanceField_MaskType == fMaskType) ? kBGR_DistanceFieldEffectFlag : 0;
}
}
}
void GrAtlasTextOp::visitProxies(const VisitProxyFunc& func) const {
fProcessors.visitProxies(func);
// We need to visit the atlasManager's proxies because, although the atlasManager explicitly
// manages their lifetimes, if they fail to allocate the draws that reference them need to
// be dropped.
unsigned int numProxies;
const sk_sp<GrTextureProxy>* proxies = fRestrictedAtlasManager->getProxies(
this->maskFormat(), &numProxies);
for (unsigned int i = 0; i < numProxies; ++i) {
if (proxies[i]) {
func(proxies[i].get());
}
}
}
SkString GrAtlasTextOp::dumpInfo() const {
SkString str;
for (int i = 0; i < fGeoCount; ++i) {
str.appendf("%d: Color: 0x%08x Trans: %.2f,%.2f Runs: %d\n",
i,
fGeoData[i].fColor,
fGeoData[i].fX,
fGeoData[i].fY,
fGeoData[i].fBlob->runCount());
}
str += fProcessors.dumpProcessors();
str += INHERITED::dumpInfo();
return str;
}
GrDrawOp::FixedFunctionFlags GrAtlasTextOp::fixedFunctionFlags() const {
return FixedFunctionFlags::kNone;
}
GrDrawOp::RequiresDstTexture GrAtlasTextOp::finalize(const GrCaps& caps,
const GrAppliedClip* clip,
GrPixelConfigIsClamped dstIsClamped) {
GrProcessorAnalysisCoverage coverage;
GrProcessorAnalysisColor color;
if (kColorBitmapMask_MaskType == fMaskType) {
color.setToUnknown();
} else {
color.setToConstant(this->color());
}
switch (fMaskType) {
case kGrayscaleCoverageMask_MaskType:
case kAliasedDistanceField_MaskType:
case kGrayscaleDistanceField_MaskType:
coverage = GrProcessorAnalysisCoverage::kSingleChannel;
break;
case kLCDCoverageMask_MaskType:
case kLCDDistanceField_MaskType:
case kLCDBGRDistanceField_MaskType:
coverage = GrProcessorAnalysisCoverage::kLCD;
break;
case kColorBitmapMask_MaskType:
coverage = GrProcessorAnalysisCoverage::kNone;
break;
}
auto analysis = fProcessors.finalize(color, coverage, clip, false, caps, dstIsClamped,
&fGeoData[0].fColor);
fUsesLocalCoords = analysis.usesLocalCoords();
fCanCombineOnTouchOrOverlap =
!analysis.requiresDstTexture() &&
!(fProcessors.xferProcessor() && fProcessors.xferProcessor()->xferBarrierType(caps));
return analysis.requiresDstTexture() ? RequiresDstTexture::kYes : RequiresDstTexture::kNo;
}
static void clip_quads(const SkIRect& clipRect, char* currVertex, const char* blobVertices,
size_t vertexStride, int glyphCount) {
for (int i = 0; i < glyphCount; ++i) {
const SkPoint* blobPositionLT = reinterpret_cast<const SkPoint*>(blobVertices);
const SkPoint* blobPositionRB =
reinterpret_cast<const SkPoint*>(blobVertices + 3 * vertexStride);
// positions for bitmap glyphs are pixel boundary aligned
SkIRect positionRect = SkIRect::MakeLTRB(SkScalarRoundToInt(blobPositionLT->fX),
SkScalarRoundToInt(blobPositionLT->fY),
SkScalarRoundToInt(blobPositionRB->fX),
SkScalarRoundToInt(blobPositionRB->fY));
if (clipRect.contains(positionRect)) {
memcpy(currVertex, blobVertices, 4 * vertexStride);
currVertex += 4 * vertexStride;
} else {
// Pull out some more data that we'll need.
// In the LCD case the color will be garbage, but we'll overwrite it with the texcoords
// and it avoids a lot of conditionals.
auto color = *reinterpret_cast<const SkColor*>(blobVertices + sizeof(SkPoint));
size_t coordOffset = vertexStride - 2*sizeof(uint16_t);
auto* blobCoordsLT = reinterpret_cast<const uint16_t*>(blobVertices + coordOffset);
auto* blobCoordsRB = reinterpret_cast<const uint16_t*>(blobVertices + 3 * vertexStride +
coordOffset);
// Pull out the texel coordinates and texture index bits
uint16_t coordsRectL = blobCoordsLT[0] >> 1;
uint16_t coordsRectT = blobCoordsLT[1] >> 1;
uint16_t coordsRectR = blobCoordsRB[0] >> 1;
uint16_t coordsRectB = blobCoordsRB[1] >> 1;
uint16_t pageIndexX = blobCoordsLT[0] & 0x1;
uint16_t pageIndexY = blobCoordsLT[1] & 0x1;
int positionRectWidth = positionRect.width();
int positionRectHeight = positionRect.height();
SkASSERT(positionRectWidth == (coordsRectR - coordsRectL));
SkASSERT(positionRectHeight == (coordsRectB - coordsRectT));
// Clip position and texCoords to the clipRect
unsigned int delta;
delta = SkTMin(SkTMax(clipRect.fLeft - positionRect.fLeft, 0), positionRectWidth);
coordsRectL += delta;
positionRect.fLeft += delta;
delta = SkTMin(SkTMax(clipRect.fTop - positionRect.fTop, 0), positionRectHeight);
coordsRectT += delta;
positionRect.fTop += delta;
delta = SkTMin(SkTMax(positionRect.fRight - clipRect.fRight, 0), positionRectWidth);
coordsRectR -= delta;
positionRect.fRight -= delta;
delta = SkTMin(SkTMax(positionRect.fBottom - clipRect.fBottom, 0), positionRectHeight);
coordsRectB -= delta;
positionRect.fBottom -= delta;
// Repack texel coordinates and index
coordsRectL = coordsRectL << 1 | pageIndexX;
coordsRectT = coordsRectT << 1 | pageIndexY;
coordsRectR = coordsRectR << 1 | pageIndexX;
coordsRectB = coordsRectB << 1 | pageIndexY;
// Set new positions and coords
SkPoint* currPosition = reinterpret_cast<SkPoint*>(currVertex);
currPosition->fX = positionRect.fLeft;
currPosition->fY = positionRect.fTop;
*(reinterpret_cast<SkColor*>(currVertex + sizeof(SkPoint))) = color;
uint16_t* currCoords = reinterpret_cast<uint16_t*>(currVertex + coordOffset);
currCoords[0] = coordsRectL;
currCoords[1] = coordsRectT;
currVertex += vertexStride;
currPosition = reinterpret_cast<SkPoint*>(currVertex);
currPosition->fX = positionRect.fLeft;
currPosition->fY = positionRect.fBottom;
*(reinterpret_cast<SkColor*>(currVertex + sizeof(SkPoint))) = color;
currCoords = reinterpret_cast<uint16_t*>(currVertex + coordOffset);
currCoords[0] = coordsRectL;
currCoords[1] = coordsRectB;
currVertex += vertexStride;
currPosition = reinterpret_cast<SkPoint*>(currVertex);
currPosition->fX = positionRect.fRight;
currPosition->fY = positionRect.fTop;
*(reinterpret_cast<SkColor*>(currVertex + sizeof(SkPoint))) = color;
currCoords = reinterpret_cast<uint16_t*>(currVertex + coordOffset);
currCoords[0] = coordsRectR;
currCoords[1] = coordsRectT;
currVertex += vertexStride;
currPosition = reinterpret_cast<SkPoint*>(currVertex);
currPosition->fX = positionRect.fRight;
currPosition->fY = positionRect.fBottom;
*(reinterpret_cast<SkColor*>(currVertex + sizeof(SkPoint))) = color;
currCoords = reinterpret_cast<uint16_t*>(currVertex + coordOffset);
currCoords[0] = coordsRectR;
currCoords[1] = coordsRectB;
currVertex += vertexStride;
}
blobVertices += 4 * vertexStride;
}
}
void GrAtlasTextOp::onPrepareDraws(Target* target) {
auto resourceProvider = target->resourceProvider();
// if we have RGB, then we won't have any SkShaders so no need to use a localmatrix.
// TODO actually only invert if we don't have RGBA
SkMatrix localMatrix;
if (this->usesLocalCoords() && !fGeoData[0].fViewMatrix.invert(&localMatrix)) {
SkDebugf("Cannot invert viewmatrix\n");
return;
}
GrAtlasManager* fullAtlasManager = target->fullAtlasManager();
SkASSERT(fRestrictedAtlasManager == fullAtlasManager);
GrGlyphCache* glyphCache = target->glyphCache();
GrMaskFormat maskFormat = this->maskFormat();
unsigned int atlasPageCount;
const sk_sp<GrTextureProxy>* proxies = fullAtlasManager->getProxies(maskFormat,
&atlasPageCount);
if (!proxies[0]) {
SkDebugf("Could not allocate backing texture for atlas\n");
return;
}
FlushInfo flushInfo;
flushInfo.fPipeline =
target->makePipeline(fSRGBFlags, std::move(fProcessors), target->detachAppliedClip());
SkDEBUGCODE(bool dfPerspective = false);
if (this->usesDistanceFields()) {
flushInfo.fGeometryProcessor = this->setupDfProcessor(fullAtlasManager);
SkDEBUGCODE(dfPerspective = fGeoData[0].fViewMatrix.hasPerspective());
} else {
GrSamplerState samplerState = fHasScaledGlyphs ? GrSamplerState::ClampBilerp()
: GrSamplerState::ClampNearest();
flushInfo.fGeometryProcessor = GrBitmapTextGeoProc::Make(
this->color(), proxies, atlasPageCount, samplerState, maskFormat,
localMatrix, this->usesLocalCoords());
}
flushInfo.fGlyphsToFlush = 0;
size_t vertexStride = flushInfo.fGeometryProcessor->getVertexStride();
SkASSERT(vertexStride == GrAtlasTextBlob::GetVertexStride(maskFormat, dfPerspective));
int glyphCount = this->numGlyphs();
const GrBuffer* vertexBuffer;
void* vertices = target->makeVertexSpace(
vertexStride, glyphCount * kVerticesPerGlyph, &vertexBuffer, &flushInfo.fVertexOffset);
flushInfo.fVertexBuffer.reset(SkRef(vertexBuffer));
flushInfo.fIndexBuffer = target->resourceProvider()->refQuadIndexBuffer();
if (!vertices || !flushInfo.fVertexBuffer) {
SkDebugf("Could not allocate vertices\n");
return;
}
char* currVertex = reinterpret_cast<char*>(vertices);
SkAutoGlyphCache autoGlyphCache;
// each of these is a SubRun
for (int i = 0; i < fGeoCount; i++) {
const Geometry& args = fGeoData[i];
Blob* blob = args.fBlob;
GrAtlasTextBlob::VertexRegenerator regenerator(
resourceProvider, blob, args.fRun, args.fSubRun, args.fViewMatrix, args.fX, args.fY,
args.fColor, target->deferredUploadTarget(), glyphCache, fullAtlasManager,
&autoGlyphCache);
bool done = false;
while (!done) {
GrAtlasTextBlob::VertexRegenerator::Result result;
if (!regenerator.regenerate(&result)) {
break;
}
done = result.fFinished;
// Copy regenerated vertices from the blob to our vertex buffer.
size_t vertexBytes = result.fGlyphsRegenerated * kVerticesPerGlyph * vertexStride;
if (args.fClipRect.isEmpty()) {
memcpy(currVertex, result.fFirstVertex, vertexBytes);
} else {
SkASSERT(!dfPerspective);
clip_quads(args.fClipRect, currVertex, result.fFirstVertex, vertexStride,
result.fGlyphsRegenerated);
}
if (this->usesDistanceFields() && !args.fViewMatrix.isIdentity()) {
// We always do the distance field view matrix transformation after copying rather
// than during blob vertex generation time in the blob as handling successive
// arbitrary transformations would be complicated and accumulate error.
if (args.fViewMatrix.hasPerspective()) {
auto* pos = reinterpret_cast<SkPoint3*>(currVertex);
SkMatrixPriv::MapHomogeneousPointsWithStride(
args.fViewMatrix, pos, vertexStride, pos, vertexStride,
result.fGlyphsRegenerated * kVerticesPerGlyph);
} else {
auto* pos = reinterpret_cast<SkPoint*>(currVertex);
SkMatrixPriv::MapPointsWithStride(
args.fViewMatrix, pos, vertexStride,
result.fGlyphsRegenerated * kVerticesPerGlyph);
}
}
flushInfo.fGlyphsToFlush += result.fGlyphsRegenerated;
if (!result.fFinished) {
this->flush(target, &flushInfo);
}
currVertex += vertexBytes;
}
}
this->flush(target, &flushInfo);
}
void GrAtlasTextOp::flush(GrMeshDrawOp::Target* target, FlushInfo* flushInfo) const {
if (!flushInfo->fGlyphsToFlush) {
return;
}
auto fullAtlasManager = target->fullAtlasManager();
SkASSERT(fRestrictedAtlasManager == fullAtlasManager);
GrGeometryProcessor* gp = flushInfo->fGeometryProcessor.get();
GrMaskFormat maskFormat = this->maskFormat();
unsigned int numProxies;
const sk_sp<GrTextureProxy>* proxies = fullAtlasManager->getProxies(maskFormat, &numProxies);
if (gp->numTextureSamplers() != (int) numProxies) {
// During preparation the number of atlas pages has increased.
// Update the proxies used in the GP to match.
if (this->usesDistanceFields()) {
if (this->isLCD()) {
reinterpret_cast<GrDistanceFieldLCDTextGeoProc*>(gp)->addNewProxies(
proxies, numProxies, GrSamplerState::ClampBilerp());
} else {
reinterpret_cast<GrDistanceFieldA8TextGeoProc*>(gp)->addNewProxies(
proxies, numProxies, GrSamplerState::ClampBilerp());
}
} else {
GrSamplerState samplerState = fHasScaledGlyphs ? GrSamplerState::ClampBilerp()
: GrSamplerState::ClampNearest();
reinterpret_cast<GrBitmapTextGeoProc*>(gp)->addNewProxies(proxies, numProxies,
samplerState);
}
}
GrMesh mesh(GrPrimitiveType::kTriangles);
int maxGlyphsPerDraw =
static_cast<int>(flushInfo->fIndexBuffer->gpuMemorySize() / sizeof(uint16_t) / 6);
mesh.setIndexedPatterned(flushInfo->fIndexBuffer.get(), kIndicesPerGlyph, kVerticesPerGlyph,
flushInfo->fGlyphsToFlush, maxGlyphsPerDraw);
mesh.setVertexData(flushInfo->fVertexBuffer.get(), flushInfo->fVertexOffset);
target->draw(flushInfo->fGeometryProcessor.get(), flushInfo->fPipeline, mesh);
flushInfo->fVertexOffset += kVerticesPerGlyph * flushInfo->fGlyphsToFlush;
flushInfo->fGlyphsToFlush = 0;
}
bool GrAtlasTextOp::onCombineIfPossible(GrOp* t, const GrCaps& caps) {
GrAtlasTextOp* that = t->cast<GrAtlasTextOp>();
if (fProcessors != that->fProcessors) {
return false;
}
if (!fCanCombineOnTouchOrOverlap && GrRectsTouchOrOverlap(this->bounds(), that->bounds())) {
return false;
}
if (fMaskType != that->fMaskType) {
return false;
}
const SkMatrix& thisFirstMatrix = fGeoData[0].fViewMatrix;
const SkMatrix& thatFirstMatrix = that->fGeoData[0].fViewMatrix;
if (this->usesLocalCoords() && !thisFirstMatrix.cheapEqualTo(thatFirstMatrix)) {
return false;
}
if (this->usesDistanceFields()) {
if (fDFGPFlags != that->fDFGPFlags) {
return false;
}
if (fLuminanceColor != that->fLuminanceColor) {
return false;
}
} else {
if (kColorBitmapMask_MaskType == fMaskType && this->color() != that->color()) {
return false;
}
if (fHasScaledGlyphs != that->fHasScaledGlyphs) {
return false;
}
}
// Keep the batch vertex buffer size below 32K so we don't have to create a special one
// We use the largest possible vertex size for this
static const int kVertexSize = sizeof(SkPoint) + sizeof(SkColor) + 2 * sizeof(uint16_t);
static const int kMaxGlyphs = 32768 / (kVerticesPerGlyph * kVertexSize);
if (this->fNumGlyphs + that->fNumGlyphs > kMaxGlyphs) {
return false;
}
fNumGlyphs += that->numGlyphs();
// Reallocate space for geo data if necessary and then import that geo's data.
int newGeoCount = that->fGeoCount + fGeoCount;
// We reallocate at a rate of 1.5x to try to get better total memory usage
if (newGeoCount > fGeoDataAllocSize) {
int newAllocSize = fGeoDataAllocSize + fGeoDataAllocSize / 2;
while (newAllocSize < newGeoCount) {
newAllocSize += newAllocSize / 2;
}
fGeoData.realloc(newAllocSize);
fGeoDataAllocSize = newAllocSize;
}
// We steal the ref on the blobs from the other AtlasTextOp and set its count to 0 so that
// it doesn't try to unref them.
memcpy(&fGeoData[fGeoCount], that->fGeoData.get(), that->fGeoCount * sizeof(Geometry));
#ifdef SK_DEBUG
for (int i = 0; i < that->fGeoCount; ++i) {
that->fGeoData.get()[i].fBlob = (Blob*)0x1;
}
#endif
that->fGeoCount = 0;
fGeoCount = newGeoCount;
this->joinBounds(*that);
return true;
}
// TODO trying to figure out why lcd is so whack
// (see comments in GrAtlasTextContext::ComputeCanonicalColor)
sk_sp<GrGeometryProcessor> GrAtlasTextOp::setupDfProcessor(
GrRestrictedAtlasManager* restrictedAtlasManager) const {
unsigned int numProxies;
const sk_sp<GrTextureProxy>* proxies = restrictedAtlasManager->getProxies(this->maskFormat(),
&numProxies);
bool isLCD = this->isLCD();
SkMatrix localMatrix = SkMatrix::I();
if (this->usesLocalCoords()) {
// If this fails we'll just use I().
bool result = fGeoData[0].fViewMatrix.invert(&localMatrix);
(void)result;
}
// see if we need to create a new effect
if (isLCD) {
float redCorrection = fDistanceAdjustTable->getAdjustment(
SkColorGetR(fLuminanceColor) >> kDistanceAdjustLumShift,
fUseGammaCorrectDistanceTable);
float greenCorrection = fDistanceAdjustTable->getAdjustment(
SkColorGetG(fLuminanceColor) >> kDistanceAdjustLumShift,
fUseGammaCorrectDistanceTable);
float blueCorrection = fDistanceAdjustTable->getAdjustment(
SkColorGetB(fLuminanceColor) >> kDistanceAdjustLumShift,
fUseGammaCorrectDistanceTable);
GrDistanceFieldLCDTextGeoProc::DistanceAdjust widthAdjust =
GrDistanceFieldLCDTextGeoProc::DistanceAdjust::Make(
redCorrection, greenCorrection, blueCorrection);
return GrDistanceFieldLCDTextGeoProc::Make(proxies, numProxies,
GrSamplerState::ClampBilerp(), widthAdjust,
fDFGPFlags, localMatrix);
} else {
#ifdef SK_GAMMA_APPLY_TO_A8
float correction = 0;
if (kAliasedDistanceField_MaskType != fMaskType) {
U8CPU lum = SkColorSpaceLuminance::computeLuminance(SK_GAMMA_EXPONENT,
fLuminanceColor);
correction = fDistanceAdjustTable->getAdjustment(lum >> kDistanceAdjustLumShift,
fUseGammaCorrectDistanceTable);
}
return GrDistanceFieldA8TextGeoProc::Make(proxies, numProxies,
GrSamplerState::ClampBilerp(),
correction, fDFGPFlags, localMatrix);
#else
return GrDistanceFieldA8TextGeoProc::Make(proxies, numProxies,
GrSamplerState::ClampBilerp(),
fDFGPFlags, localMatrix);
#endif
}
}