diff options
Diffstat (limited to 'src/gpu/text')
-rw-r--r-- | src/gpu/text/GrAtlasTextBlob.h | 23 | ||||
-rw-r--r-- | src/gpu/text/GrAtlasTextBlob_regenInBatch.cpp | 294 |
2 files changed, 315 insertions, 2 deletions
diff --git a/src/gpu/text/GrAtlasTextBlob.h b/src/gpu/text/GrAtlasTextBlob.h index b4168e921e..63eb56b6f8 100644 --- a/src/gpu/text/GrAtlasTextBlob.h +++ b/src/gpu/text/GrAtlasTextBlob.h @@ -17,6 +17,7 @@ #include "SkSurfaceProps.h" #include "SkTInternalLList.h" +class GrBlobRegenHelper; struct GrDistanceFieldAdjustTable; class GrMemoryPool; class GrTextContext; @@ -108,6 +109,8 @@ public: void setHasDistanceField() { fTextType |= kHasDistanceField_TextType; } void setHasBitmap() { fTextType |= kHasBitmap_TextType; } + int runCount() const { return fRunCount; } + void push_back_run(int currRun) { SkASSERT(currRun < fRunCount); if (currRun > 0) { @@ -255,6 +258,13 @@ public: this->setupViewMatrix(viewMatrix, x, y); } + void regenInBatch(GrDrawBatch::Target* target, GrBatchFontCache* fontCache, + GrBlobRegenHelper *helper, int run, int subRun, SkGlyphCache** cache, + SkTypeface** typeface, GrFontScaler** scaler, + const SkDescriptor** desc, size_t vertexStride, + GrColor color, SkScalar transX, SkScalar transY, + void** vertices, size_t* byteCount, int* glyphCount); + const Key& key() const { return fKey; } ~GrAtlasTextBlob() { @@ -453,6 +463,17 @@ private: bool fDrawAsPaths; }; + template <bool regenPos, bool regenCol, bool regenTexCoords, bool regenGlyphs> + void regenInBatch(GrDrawBatch::Target* target, + GrBatchFontCache* fontCache, + GrBlobRegenHelper* helper, + Run* run, Run::SubRunInfo* info, SkGlyphCache** cache, + SkTypeface** typeface, GrFontScaler** scaler, + const SkDescriptor** desc, + int glyphCount, size_t vertexStride, + GrColor color, SkScalar transX, + SkScalar transY) const; + inline GrDrawBatch* createBatch(const Run::SubRunInfo& info, int glyphCount, int run, int subRun, GrColor color, SkScalar transX, SkScalar transY, @@ -510,8 +531,6 @@ private: SkScalar fMinMaxScale; int fRunCount; uint8_t fTextType; - - friend class GrAtlasTextBatch; // We might be able to get rid of this friending }; #endif diff --git a/src/gpu/text/GrAtlasTextBlob_regenInBatch.cpp b/src/gpu/text/GrAtlasTextBlob_regenInBatch.cpp new file mode 100644 index 0000000000..6443d41ac5 --- /dev/null +++ b/src/gpu/text/GrAtlasTextBlob_regenInBatch.cpp @@ -0,0 +1,294 @@ +/* + * Copyright 2016 Google Inc. + * + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + */ + +#include "GrAtlasTextBlob.h" + +#include "GrBatchFlushState.h" + +#include "SkDistanceFieldGen.h" +#include "SkGlyphCache.h" + +#include "batches/GrAtlasTextBatch.h" + +//////////////////////////////////////////////////////////////////////////////////////////////////// +// A large template to handle regenerating the vertices of a textblob with as few branches as +// possible +template <bool regenPos, bool regenCol, bool regenTexCoords> +inline void regen_vertices(intptr_t vertex, const GrGlyph* glyph, size_t vertexStride, + bool useDistanceFields, SkScalar transX, SkScalar transY, + GrColor color) { + int u0, v0, u1, v1; + if (regenTexCoords) { + SkASSERT(glyph); + int width = glyph->fBounds.width(); + int height = glyph->fBounds.height(); + + if (useDistanceFields) { + u0 = glyph->fAtlasLocation.fX + SK_DistanceFieldInset; + v0 = glyph->fAtlasLocation.fY + SK_DistanceFieldInset; + u1 = u0 + width - 2 * SK_DistanceFieldInset; + v1 = v0 + height - 2 * SK_DistanceFieldInset; + } else { + u0 = glyph->fAtlasLocation.fX; + v0 = glyph->fAtlasLocation.fY; + u1 = u0 + width; + v1 = v0 + height; + } + } + + // This is a bit wonky, but sometimes we have LCD text, in which case we won't have color + // vertices, hence vertexStride - sizeof(SkIPoint16) + intptr_t colorOffset = sizeof(SkPoint); + intptr_t texCoordOffset = vertexStride - sizeof(SkIPoint16); + + // V0 + if (regenPos) { + SkPoint* point = reinterpret_cast<SkPoint*>(vertex); + point->fX += transX; + point->fY += transY; + } + + if (regenCol) { + SkColor* vcolor = reinterpret_cast<SkColor*>(vertex + colorOffset); + *vcolor = color; + } + + if (regenTexCoords) { + SkIPoint16* textureCoords = reinterpret_cast<SkIPoint16*>(vertex + texCoordOffset); + textureCoords->set(u0, v0); + } + vertex += vertexStride; + + // V1 + if (regenPos) { + SkPoint* point = reinterpret_cast<SkPoint*>(vertex); + point->fX += transX; + point->fY += transY; + } + + if (regenCol) { + SkColor* vcolor = reinterpret_cast<SkColor*>(vertex + colorOffset); + *vcolor = color; + } + + if (regenTexCoords) { + SkIPoint16* textureCoords = reinterpret_cast<SkIPoint16*>(vertex + texCoordOffset); + textureCoords->set(u0, v1); + } + vertex += vertexStride; + + // V2 + if (regenPos) { + SkPoint* point = reinterpret_cast<SkPoint*>(vertex); + point->fX += transX; + point->fY += transY; + } + + if (regenCol) { + SkColor* vcolor = reinterpret_cast<SkColor*>(vertex + colorOffset); + *vcolor = color; + } + + if (regenTexCoords) { + SkIPoint16* textureCoords = reinterpret_cast<SkIPoint16*>(vertex + texCoordOffset); + textureCoords->set(u1, v1); + } + vertex += vertexStride; + + // V3 + if (regenPos) { + SkPoint* point = reinterpret_cast<SkPoint*>(vertex); + point->fX += transX; + point->fY += transY; + } + + if (regenCol) { + SkColor* vcolor = reinterpret_cast<SkColor*>(vertex + colorOffset); + *vcolor = color; + } + + if (regenTexCoords) { + SkIPoint16* textureCoords = reinterpret_cast<SkIPoint16*>(vertex + texCoordOffset); + textureCoords->set(u1, v0); + } +} + +template <bool regenPos, bool regenCol, bool regenTexCoords, bool regenGlyphs> +void GrAtlasTextBlob::regenInBatch(GrDrawBatch::Target* target, + GrBatchFontCache* fontCache, + GrBlobRegenHelper *helper, + Run* run, + Run::SubRunInfo* info, SkGlyphCache** cache, + SkTypeface** typeface, GrFontScaler** scaler, + const SkDescriptor** desc, + int glyphCount, size_t vertexStride, + GrColor color, SkScalar transX, + SkScalar transY) const { + static_assert(!regenGlyphs || regenTexCoords, "must regenTexCoords along regenGlyphs"); + GrBatchTextStrike* strike = nullptr; + if (regenTexCoords) { + info->resetBulkUseToken(); + + // We can reuse if we have a valid strike and our descriptors / typeface are the + // same. The override descriptor is only for the non distance field text within + // a run + const SkDescriptor* newDesc = (run->fOverrideDescriptor && !info->drawAsDistanceFields()) ? + run->fOverrideDescriptor->getDesc() : + run->fDescriptor.getDesc(); + if (!*cache || !SkTypeface::Equal(*typeface, run->fTypeface) || + !((*desc)->equals(*newDesc))) { + if (*cache) { + SkGlyphCache::AttachCache(*cache); + } + *desc = newDesc; + *cache = SkGlyphCache::DetachCache(run->fTypeface, *desc); + *scaler = GrTextContext::GetGrFontScaler(*cache); + *typeface = run->fTypeface; + } + + if (regenGlyphs) { + strike = fontCache->getStrike(*scaler); + } else { + strike = info->strike(); + } + } + + bool brokenRun = false; + for (int glyphIdx = 0; glyphIdx < glyphCount; glyphIdx++) { + GrGlyph* glyph = nullptr; + if (regenTexCoords) { + size_t glyphOffset = glyphIdx + info->glyphStartIndex(); + + if (regenGlyphs) { + // Get the id from the old glyph, and use the new strike to lookup + // the glyph. + GrGlyph::PackedID id = fGlyphs[glyphOffset]->fPackedID; + fGlyphs[glyphOffset] = strike->getGlyph(id, info->maskFormat(), *scaler); + SkASSERT(id == fGlyphs[glyphOffset]->fPackedID); + } + glyph = fGlyphs[glyphOffset]; + SkASSERT(glyph && glyph->fMaskFormat == info->maskFormat()); + + if (!fontCache->hasGlyph(glyph) && + !strike->addGlyphToAtlas(target, glyph, *scaler, info->maskFormat())) { + helper->flush(); + brokenRun = glyphIdx > 0; + + SkDEBUGCODE(bool success =) strike->addGlyphToAtlas(target, + glyph, + *scaler, + info->maskFormat()); + SkASSERT(success); + } + fontCache->addGlyphToBulkAndSetUseToken(info->bulkUseToken(), glyph, + target->currentToken()); + } + + intptr_t vertex = reinterpret_cast<intptr_t>(fVertices); + vertex += info->vertexStartIndex(); + vertex += vertexStride * glyphIdx * GrAtlasTextBatch::kVerticesPerGlyph; + regen_vertices<regenPos, regenCol, regenTexCoords>(vertex, glyph, vertexStride, + info->drawAsDistanceFields(), transX, + transY, color); + helper->incGlyphCount(); + } + + // We may have changed the color so update it here + info->setColor(color); + if (regenTexCoords) { + if (regenGlyphs) { + info->setStrike(strike); + } + info->setAtlasGeneration(brokenRun ? GrBatchAtlas::kInvalidAtlasGeneration : + fontCache->atlasGeneration(info->maskFormat())); + } +} + +enum RegenMask { + kNoRegen = 0x0, + kRegenPos = 0x1, + kRegenCol = 0x2, + kRegenTex = 0x4, + kRegenGlyph = 0x8 | kRegenTex, // we have to regenerate the texture coords when we regen glyphs + + // combinations + kRegenPosCol = kRegenPos | kRegenCol, + kRegenPosTex = kRegenPos | kRegenTex, + kRegenPosTexGlyph = kRegenPos | kRegenGlyph, + kRegenPosColTex = kRegenPos | kRegenCol | kRegenTex, + kRegenPosColTexGlyph = kRegenPos | kRegenCol | kRegenGlyph, + kRegenColTex = kRegenCol | kRegenTex, + kRegenColTexGlyph = kRegenCol | kRegenGlyph, +}; + +#define REGEN_ARGS target, fontCache, helper, &run, &info, cache, typeface, scaler, desc, \ + *glyphCount, vertexStride, color, transX, transY + +void GrAtlasTextBlob::regenInBatch(GrDrawBatch::Target* target, + GrBatchFontCache* fontCache, + GrBlobRegenHelper *helper, + int runIndex, int subRunIndex, SkGlyphCache** cache, + SkTypeface** typeface, GrFontScaler** scaler, + const SkDescriptor** desc, size_t vertexStride, + GrColor color, SkScalar transX, + SkScalar transY, + void** vertices, size_t* byteCount, int* glyphCount) { + Run& run = fRuns[runIndex]; + Run::SubRunInfo& info = run.fSubRunInfo[subRunIndex]; + + uint64_t currentAtlasGen = fontCache->atlasGeneration(info.maskFormat()); + + // Because the GrBatchFontCache may evict the strike a blob depends on using for + // generating its texture coords, we have to track whether or not the strike has + // been abandoned. If it hasn't been abandoned, then we can use the GrGlyph*s as is + // otherwise we have to get the new strike, and use that to get the correct glyphs. + // Because we do not have the packed ids, and thus can't look up our glyphs in the + // new strike, we instead keep our ref to the old strike and use the packed ids from + // it. These ids will still be valid as long as we hold the ref. When we are done + // updating our cache of the GrGlyph*s, we drop our ref on the old strike + bool regenerateGlyphs = info.strike()->isAbandoned(); + bool regenerateTextureCoords = info.atlasGeneration() != currentAtlasGen || + regenerateGlyphs; + bool regenerateColors = kARGB_GrMaskFormat != info.maskFormat() && + info.color() != color; + bool regeneratePositions = transX != 0.f || transY != 0.f; + *glyphCount = info.glyphCount(); + + uint32_t regenMaskBits = kNoRegen; + regenMaskBits |= regeneratePositions ? kRegenPos : 0; + regenMaskBits |= regenerateColors ? kRegenCol : 0; + regenMaskBits |= regenerateTextureCoords ? kRegenTex : 0; + regenMaskBits |= regenerateGlyphs ? kRegenGlyph : 0; + RegenMask regenMask = (RegenMask)regenMaskBits; + + switch (regenMask) { + case kRegenPos: this->regenInBatch<true, false, false, false>(REGEN_ARGS); break; + case kRegenCol: this->regenInBatch<false, true, false, false>(REGEN_ARGS); break; + case kRegenTex: this->regenInBatch<false, false, true, false>(REGEN_ARGS); break; + case kRegenGlyph: this->regenInBatch<false, false, true, true>(REGEN_ARGS); break; + + // combinations + case kRegenPosCol: this->regenInBatch<true, true, false, false>(REGEN_ARGS); break; + case kRegenPosTex: this->regenInBatch<true, false, true, false>(REGEN_ARGS); break; + case kRegenPosTexGlyph: this->regenInBatch<true, false, true, true>(REGEN_ARGS); break; + case kRegenPosColTex: this->regenInBatch<true, true, true, false>(REGEN_ARGS); break; + case kRegenPosColTexGlyph: this->regenInBatch<true, true, true, true>(REGEN_ARGS); break; + case kRegenColTex: this->regenInBatch<false, true, true, false>(REGEN_ARGS); break; + case kRegenColTexGlyph: this->regenInBatch<false, true, true, true>(REGEN_ARGS); break; + case kNoRegen: + helper->incGlyphCount(*glyphCount); + + // set use tokens for all of the glyphs in our subrun. This is only valid if we + // have a valid atlas generation + fontCache->setUseTokenBulk(*info.bulkUseToken(), target->currentToken(), + info.maskFormat()); + break; + } + + *byteCount = info.byteCount(); + *vertices = fVertices + info.vertexStartIndex(); +} |