'<(skia_src_path)/gpu/GrAllocator.h',
'<(skia_src_path)/gpu/GrAtlas.cpp',
'<(skia_src_path)/gpu/GrAtlas.h',
+ '<(skia_src_path)/gpu/GrAtlasTextBlob.h',
'<(skia_src_path)/gpu/GrAtlasTextContext.cpp',
'<(skia_src_path)/gpu/GrAtlasTextContext.h',
'<(skia_src_path)/gpu/GrBatch.cpp',
--- /dev/null
+/*
+ * Copyright 2015 Google Inc.
+ *
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef GrAtlasTextBlob_DEFINED
+#define GrAtlasTextBlob_DEFINED
+
+#include "GrBatchAtlas.h"
+#include "GrBatchFontCache.h"
+#include "SkDescriptor.h"
+#include "SkMaskFilter.h"
+#include "GrMemoryPool.h"
+#include "SkTInternalLList.h"
+
+/*
+ * A GrAtlasTextBlob contains a fully processed SkTextBlob, suitable for nearly immediate drawing
+ * on the GPU. These are initially created with valid positions and colors, but invalid
+ * texture coordinates. The GrAtlasTextBlob itself has a few Blob-wide properties, and also
+ * consists of a number of runs. Runs inside a blob are flushed individually so they can be
+ * reordered.
+ *
+ * The only thing(aside from a memcopy) required to flush a GrAtlasTextBlob is to ensure that
+ * the GrAtlas will not evict anything the Blob needs.
+ *
+ * Note: This struct should really be named GrCachedAtasTextBlob, but that is too verbose.
+ */
+struct GrAtlasTextBlob : public SkRefCnt {
+ SK_DECLARE_INTERNAL_LLIST_INTERFACE(GrAtlasTextBlob);
+
+ /*
+ * Each Run inside of the blob can have its texture coordinates regenerated if required.
+ * To determine if regeneration is necessary, fAtlasGeneration is used. If there have been
+ * any evictions inside of the atlas, then we will simply regenerate Runs. We could track
+ * this at a more fine grained level, but its not clear if this is worth it, as evictions
+ * should be fairly rare.
+ *
+ * One additional point, each run can contain glyphs with any of the three mask formats.
+ * We call these SubRuns. Because a subrun must be a contiguous range, we have to create
+ * a new subrun each time the mask format changes in a run. In theory, a run can have as
+ * many SubRuns as it has glyphs, ie if a run alternates between color emoji and A8. In
+ * practice, the vast majority of runs have only a single subrun.
+ *
+ * Finally, for runs where the entire thing is too large for the GrAtlasTextContext to
+ * handle, we have a bit to mark the run as flusahable via rendering as paths. It is worth
+ * pointing. It would be a bit expensive to figure out ahead of time whether or not a run
+ * can flush in this manner, so we always allocate vertices for the run, regardless of
+ * whether or not it is too large. The benefit of this strategy is that we can always reuse
+ * a blob allocation regardless of viewmatrix changes. We could store positions for these
+ * glyphs. However, its not clear if this is a win because we'd still have to either go the
+ * glyph cache to get the path at flush time, or hold onto the path in the cache, which
+ * would greatly increase the memory of these cached items.
+ */
+ struct Run {
+ Run()
+ : fColor(GrColor_ILLEGAL)
+ , fInitialized(false)
+ , fDrawAsPaths(false) {
+ fVertexBounds.setLargestInverted();
+ // To ensure we always have one subrun, we push back a fresh run here
+ fSubRunInfo.push_back();
+ }
+ struct SubRunInfo {
+ SubRunInfo()
+ : fAtlasGeneration(GrBatchAtlas::kInvalidAtlasGeneration)
+ , fVertexStartIndex(0)
+ , fVertexEndIndex(0)
+ , fGlyphStartIndex(0)
+ , fGlyphEndIndex(0)
+ , fDrawAsDistanceFields(false) {}
+ // Distance field text cannot draw coloremoji, and so has to fall back. However,
+ // though the distance field text and the coloremoji may share the same run, they
+ // will have different descriptors. If fOverrideDescriptor is non-NULL, then it
+ // will be used in place of the run's descriptor to regen texture coords
+ // TODO we could have a descriptor cache, it would reduce the size of these blobs
+ // significantly, and then the subrun could just have a refed pointer to the
+ // correct descriptor.
+ GrBatchAtlas::BulkUseTokenUpdater fBulkUseToken;
+ uint64_t fAtlasGeneration;
+ size_t fVertexStartIndex;
+ size_t fVertexEndIndex;
+ uint32_t fGlyphStartIndex;
+ uint32_t fGlyphEndIndex;
+ SkScalar fTextRatio; // df property
+ GrMaskFormat fMaskFormat;
+ bool fDrawAsDistanceFields; // df property
+ bool fUseLCDText; // df property
+ };
+
+ SubRunInfo& push_back() {
+ // Forward glyph / vertex information to seed the new sub run
+ SubRunInfo& prevSubRun = fSubRunInfo.back();
+ SubRunInfo& newSubRun = fSubRunInfo.push_back();
+ newSubRun.fGlyphStartIndex = prevSubRun.fGlyphEndIndex;
+ newSubRun.fGlyphEndIndex = prevSubRun.fGlyphEndIndex;
+
+ newSubRun.fVertexStartIndex = prevSubRun.fVertexEndIndex;
+ newSubRun.fVertexEndIndex = prevSubRun.fVertexEndIndex;
+ return newSubRun;
+ }
+ static const int kMinSubRuns = 1;
+ SkAutoTUnref<GrBatchTextStrike> fStrike;
+ SkAutoTUnref<SkTypeface> fTypeface;
+ SkRect fVertexBounds;
+ SkSTArray<kMinSubRuns, SubRunInfo> fSubRunInfo;
+ SkAutoDescriptor fDescriptor;
+ SkAutoTDelete<SkAutoDescriptor> fOverrideDescriptor; // df properties
+ GrColor fColor;
+ bool fInitialized;
+ bool fDrawAsPaths;
+ };
+
+ struct BigGlyph {
+ BigGlyph(const SkPath& path, SkScalar vx, SkScalar vy)
+ : fPath(path)
+ , fVx(vx)
+ , fVy(vy) {}
+ SkPath fPath;
+ SkScalar fVx;
+ SkScalar fVy;
+ };
+
+ struct Key {
+ Key() {
+ sk_bzero(this, sizeof(Key));
+ }
+ uint32_t fUniqueID;
+ // Color may affect the gamma of the mask we generate, but in a fairly limited way.
+ // Each color is assigned to on of a fixed number of buckets based on its
+ // luminance. For each luminance bucket there is a "canonical color" that
+ // represents the bucket. This functionality is currently only supported for A8
+ SkColor fCanonicalColor;
+ SkPaint::Style fStyle;
+ SkPixelGeometry fPixelGeometry;
+ bool fHasBlur;
+
+ bool operator==(const Key& other) const {
+ return 0 == memcmp(this, &other, sizeof(Key));
+ }
+ };
+
+ struct StrokeInfo {
+ SkScalar fFrameWidth;
+ SkScalar fMiterLimit;
+ SkPaint::Join fJoin;
+ };
+
+ enum TextType {
+ kHasDistanceField_TextType = 0x1,
+ kHasBitmap_TextType = 0x2,
+ };
+
+ // all glyph / vertex offsets are into these pools.
+ unsigned char* fVertices;
+ GrGlyph** fGlyphs;
+ Run* fRuns;
+ GrMemoryPool* fPool;
+ SkMaskFilter::BlurRec fBlurRec;
+ StrokeInfo fStrokeInfo;
+ SkTArray<BigGlyph> fBigGlyphs;
+ Key fKey;
+ SkMatrix fViewMatrix;
+ SkColor fPaintColor;
+ SkScalar fX;
+ SkScalar fY;
+
+ // We can reuse distance field text, but only if the new viewmatrix would not result in
+ // a mip change. Because there can be multiple runs in a blob, we track the overall
+ // maximum minimum scale, and minimum maximum scale, we can support before we need to regen
+ SkScalar fMaxMinScale;
+ SkScalar fMinMaxScale;
+ int fRunCount;
+ uint8_t fTextType;
+
+ GrAtlasTextBlob()
+ : fMaxMinScale(-SK_ScalarMax)
+ , fMinMaxScale(SK_ScalarMax)
+ , fTextType(0) {}
+
+ ~GrAtlasTextBlob() override {
+ for (int i = 0; i < fRunCount; i++) {
+ fRuns[i].~Run();
+ }
+ }
+
+ static const Key& GetKey(const GrAtlasTextBlob& blob) {
+ return blob.fKey;
+ }
+
+ static uint32_t Hash(const Key& key) {
+ return SkChecksum::Murmur3(&key, sizeof(Key));
+ }
+
+ void operator delete(void* p) {
+ GrAtlasTextBlob* blob = reinterpret_cast<GrAtlasTextBlob*>(p);
+ blob->fPool->release(p);
+ }
+ void* operator new(size_t) {
+ SkFAIL("All blobs are created by placement new.");
+ return sk_malloc_throw(0);
+ }
+
+ void* operator new(size_t, void* p) { return p; }
+ void operator delete(void* target, void* placement) {
+ ::operator delete(target, placement);
+ }
+
+ bool hasDistanceField() const { return SkToBool(fTextType & kHasDistanceField_TextType); }
+ bool hasBitmap() const { return SkToBool(fTextType & kHasBitmap_TextType); }
+ void setHasDistanceField() { fTextType |= kHasDistanceField_TextType; }
+ void setHasBitmap() { fTextType |= kHasBitmap_TextType; }
+};
+
+#endif
}
bool GrAtlasTextContext::MustRegenerateBlob(SkScalar* outTransX, SkScalar* outTransY,
- const BitmapTextBlob& blob, const SkPaint& paint,
+ const GrAtlasTextBlob& blob, const SkPaint& paint,
const SkMaskFilter::BlurRec& blurRec,
const SkMatrix& viewMatrix, SkScalar x, SkScalar y) {
// If we have LCD text then our canonical color will be set to transparent, in this case we have
(*outTransX) = x - blob.fX;
(*outTransY) = y - blob.fY;
}
+
// It is possible that a blob has neither distanceField nor bitmaptext. This is in the case
// when all of the runs inside the blob are drawn as paths. In this case, we always regenerate
// the blob anyways at flush time, so no need to regenerate explicitly
-
return false;
}
-inline SkGlyphCache* GrAtlasTextContext::setupCache(BitmapTextBlob::Run* run,
+inline SkGlyphCache* GrAtlasTextContext::setupCache(GrAtlasTextBlob::Run* run,
const SkPaint& skPaint,
const SkMatrix* viewMatrix,
bool noGamma) {
return;
}
- SkAutoTUnref<BitmapTextBlob> cacheBlob;
+ SkAutoTUnref<GrAtlasTextBlob> cacheBlob;
SkMaskFilter::BlurRec blurRec;
- BitmapTextBlob::Key key;
+ GrAtlasTextBlob::Key key;
// 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 = skPaint.getMaskFilter();
return true;
}
-void GrAtlasTextContext::regenerateTextBlob(BitmapTextBlob* cacheBlob,
+void GrAtlasTextContext::regenerateTextBlob(GrAtlasTextBlob* cacheBlob,
const SkPaint& skPaint, GrColor color,
const SkMatrix& viewMatrix,
const SkTextBlob* blob, SkScalar x, SkScalar y,
}
}
-inline void GrAtlasTextContext::initDistanceFieldPaint(BitmapTextBlob* blob,
+inline void GrAtlasTextContext::initDistanceFieldPaint(GrAtlasTextBlob* blob,
SkPaint* skPaint,
SkScalar* textRatio,
const SkMatrix& viewMatrix) {
skPaint->setSubpixelText(true);
}
-inline void GrAtlasTextContext::fallbackDrawPosText(BitmapTextBlob* blob,
+inline void GrAtlasTextContext::fallbackDrawPosText(GrAtlasTextBlob* blob,
int runIndex,
GrRenderTarget* rt, const GrClip& clip,
const GrPaint& paint,
SkGlyphCache::AttachCache(cache);
}
-inline GrAtlasTextContext::BitmapTextBlob*
+inline GrAtlasTextBlob*
GrAtlasTextContext::setupDFBlob(int glyphCount, const SkPaint& origPaint,
const SkMatrix& viewMatrix, SkGlyphCache** cache,
SkPaint* dfPaint, SkScalar* textRatio) {
- BitmapTextBlob* blob = fCache->createBlob(glyphCount, 1, kGrayTextVASize);
+ GrAtlasTextBlob* blob = fCache->createBlob(glyphCount, 1, kGrayTextVASize);
*dfPaint = origPaint;
this->initDistanceFieldPaint(blob, dfPaint, textRatio, viewMatrix);
return blob;
}
-inline GrAtlasTextContext::BitmapTextBlob*
+inline GrAtlasTextBlob*
GrAtlasTextContext::createDrawTextBlob(GrRenderTarget* rt, const GrClip& clip,
const GrPaint& paint, const SkPaint& skPaint,
const SkMatrix& viewMatrix,
SkIRect clipRect;
clip.getConservativeBounds(rt->width(), rt->height(), &clipRect);
- BitmapTextBlob* blob;
+ GrAtlasTextBlob* blob;
if (this->canDrawAsDistanceFields(skPaint, viewMatrix)) {
SkPaint dfPaint;
SkScalar textRatio;
return blob;
}
-inline GrAtlasTextContext::BitmapTextBlob*
+inline GrAtlasTextBlob*
GrAtlasTextContext::createDrawPosTextBlob(GrRenderTarget* rt, const GrClip& clip,
const GrPaint& paint, const SkPaint& skPaint,
const SkMatrix& viewMatrix,
SkIRect clipRect;
clip.getConservativeBounds(rt->width(), rt->height(), &clipRect);
- BitmapTextBlob* blob;
+ GrAtlasTextBlob* blob;
if (this->canDrawAsDistanceFields(skPaint, viewMatrix)) {
SkPaint dfPaint;
SkScalar textRatio;
const SkMatrix& viewMatrix,
const char text[], size_t byteLength,
SkScalar x, SkScalar y, const SkIRect& regionClipBounds) {
- SkAutoTUnref<BitmapTextBlob> blob(
+ SkAutoTUnref<GrAtlasTextBlob> blob(
this->createDrawTextBlob(rt, clip, paint, skPaint, viewMatrix,
text, byteLength, x, y, regionClipBounds));
this->flush(blob, rt, skPaint, paint, clip, regionClipBounds);
const char text[], size_t byteLength,
const SkScalar pos[], int scalarsPerPosition,
const SkPoint& offset, const SkIRect& regionClipBounds) {
- SkAutoTUnref<BitmapTextBlob> blob(
+ SkAutoTUnref<GrAtlasTextBlob> blob(
this->createDrawPosTextBlob(rt, clip, paint, skPaint, viewMatrix,
text, byteLength,
pos, scalarsPerPosition,
this->flush(blob, rt, skPaint, paint, clip, regionClipBounds);
}
-void GrAtlasTextContext::internalDrawBMPText(BitmapTextBlob* blob, int runIndex,
+void GrAtlasTextContext::internalDrawBMPText(GrAtlasTextBlob* blob, int runIndex,
SkGlyphCache* cache, const SkPaint& skPaint,
GrColor color,
const SkMatrix& viewMatrix,
}
}
-void GrAtlasTextContext::internalDrawBMPPosText(BitmapTextBlob* blob, int runIndex,
+void GrAtlasTextContext::internalDrawBMPPosText(GrAtlasTextBlob* blob, int runIndex,
SkGlyphCache* cache, const SkPaint& skPaint,
GrColor color,
const SkMatrix& viewMatrix,
}
-void GrAtlasTextContext::internalDrawDFText(BitmapTextBlob* blob, int runIndex,
+void GrAtlasTextContext::internalDrawDFText(GrAtlasTextBlob* blob, int runIndex,
SkGlyphCache* cache, const SkPaint& skPaint,
GrColor color,
const SkMatrix& viewMatrix,
SkGlyphCache::AttachCache(origPaintCache);
}
-void GrAtlasTextContext::internalDrawDFPosText(BitmapTextBlob* blob, int runIndex,
+void GrAtlasTextContext::internalDrawDFPosText(GrAtlasTextBlob* blob, int runIndex,
SkGlyphCache* cache, const SkPaint& skPaint,
GrColor color,
const SkMatrix& viewMatrix,
}
}
-void GrAtlasTextContext::bmpAppendGlyph(BitmapTextBlob* blob, int runIndex,
+void GrAtlasTextContext::bmpAppendGlyph(GrAtlasTextBlob* blob, int runIndex,
GrGlyph::PackedID packed,
int vx, int vy, GrColor color, GrFontScaler* scaler,
const SkIRect& clipRect) {
glyph);
}
-bool GrAtlasTextContext::dfAppendGlyph(BitmapTextBlob* blob, int runIndex,
+bool GrAtlasTextContext::dfAppendGlyph(GrAtlasTextBlob* blob, int runIndex,
GrGlyph::PackedID packed,
SkScalar sx, SkScalar sy, GrColor color,
GrFontScaler* scaler,
return true;
}
-inline void GrAtlasTextContext::appendGlyphPath(BitmapTextBlob* blob, GrGlyph* glyph,
+inline void GrAtlasTextContext::appendGlyphPath(GrAtlasTextBlob* blob, GrGlyph* glyph,
GrFontScaler* scaler, SkScalar x, SkScalar y) {
if (NULL == glyph->fPath) {
SkPath* path = SkNEW(SkPath);
glyph->fPath = path;
}
SkASSERT(glyph->fPath);
- blob->fBigGlyphs.push_back(BitmapTextBlob::BigGlyph(*glyph->fPath, x, y));
+ blob->fBigGlyphs.push_back(GrAtlasTextBlob::BigGlyph(*glyph->fPath, x, y));
}
-inline void GrAtlasTextContext::appendGlyphCommon(BitmapTextBlob* blob, Run* run,
+inline void GrAtlasTextContext::appendGlyphCommon(GrAtlasTextBlob* blob, Run* run,
Run::SubRunInfo* subRun,
const SkRect& positions, GrColor color,
size_t vertexStride, bool useVertexColor,
class BitmapTextBatch : public GrBatch {
public:
typedef GrAtlasTextContext::DistanceAdjustTable DistanceAdjustTable;
- typedef GrAtlasTextContext::BitmapTextBlob Blob;
+ typedef GrAtlasTextBlob Blob;
typedef Blob::Run Run;
typedef Run::SubRunInfo TextInfo;
struct Geometry {
inline BitmapTextBatch*
-GrAtlasTextContext::createBatch(BitmapTextBlob* cacheBlob, const PerSubRunInfo& info,
+GrAtlasTextContext::createBatch(GrAtlasTextBlob* cacheBlob, const PerSubRunInfo& info,
int glyphCount, int run, int subRun,
GrColor color, SkScalar transX, SkScalar transY,
const SkPaint& skPaint) {
}
inline void GrAtlasTextContext::flushRun(GrPipelineBuilder* pipelineBuilder,
- BitmapTextBlob* cacheBlob, int run, GrColor color,
+ GrAtlasTextBlob* cacheBlob, int run, GrColor color,
SkScalar transX, SkScalar transY,
const SkPaint& skPaint) {
for (int subRun = 0; subRun < cacheBlob->fRuns[run].fSubRunInfo.count(); subRun++) {
}
}
-inline void GrAtlasTextContext::flushBigGlyphs(BitmapTextBlob* cacheBlob, GrRenderTarget* rt,
+inline void GrAtlasTextContext::flushBigGlyphs(GrAtlasTextBlob* cacheBlob, GrRenderTarget* rt,
const GrClip& clip, const SkPaint& skPaint,
SkScalar transX, SkScalar transY,
const SkIRect& clipBounds) {
}
for (int i = 0; i < cacheBlob->fBigGlyphs.count(); i++) {
- BitmapTextBlob::BigGlyph& bigGlyph = cacheBlob->fBigGlyphs[i];
+ GrAtlasTextBlob::BigGlyph& bigGlyph = cacheBlob->fBigGlyphs[i];
bigGlyph.fVx += transX;
bigGlyph.fVy += transY;
SkMatrix translate = cacheBlob->fViewMatrix;
}
void GrAtlasTextContext::flush(const SkTextBlob* blob,
- BitmapTextBlob* cacheBlob,
+ GrAtlasTextBlob* cacheBlob,
GrRenderTarget* rt,
const SkPaint& skPaint,
const GrPaint& grPaint,
this->flushBigGlyphs(cacheBlob, rt, clip, skPaint, transX, transY, clipBounds);
}
-void GrAtlasTextContext::flush(BitmapTextBlob* cacheBlob,
+void GrAtlasTextContext::flush(GrAtlasTextBlob* cacheBlob,
GrRenderTarget* rt,
const SkPaint& skPaint,
const GrPaint& grPaint,
// right now we don't handle textblobs, nor do we handle drawPosText. Since we only
// intend to test the batch with this unit test, that is okay.
- SkAutoTUnref<GrAtlasTextContext::BitmapTextBlob> blob(
+ SkAutoTUnref<GrAtlasTextBlob> blob(
gTextContext->createDrawTextBlob(rt, clip, grPaint, skPaint, viewMatrix, text,
static_cast<size_t>(textLen), 0, 0, noClip));
SkScalar transX = static_cast<SkScalar>(random->nextU());
SkScalar transY = static_cast<SkScalar>(random->nextU());
- const GrAtlasTextContext::BitmapTextBlob::Run::SubRunInfo& info = blob->fRuns[0].fSubRunInfo[0];
+ const GrAtlasTextBlob::Run::SubRunInfo& info = blob->fRuns[0].fSubRunInfo[0];
return gTextContext->createBatch(blob, info, textLen, 0, 0, color, transX, transY, skPaint);
}
#include "GrTextContext.h"
-#include "GrBatchAtlas.h"
-#include "GrBatchFontCache.h"
+#include "GrAtlasTextBlob.h"
#include "GrGeometryProcessor.h"
-#include "SkDescriptor.h"
-#include "GrMemoryPool.h"
-#include "SkMaskFilter.h"
#include "SkTextBlob.h"
-#include "SkTInternalLList.h"
#ifdef GR_TEST_UTILS
#include "GrBatchTest.h"
const SkMatrix& viewMatrix, const SkTextBlob*, SkScalar x, SkScalar y,
SkDrawFilter*, const SkIRect& clipBounds) override;
- /*
- * A BitmapTextBlob contains a fully processed SkTextBlob, suitable for nearly immediate drawing
- * on the GPU. These are initially created with valid positions and colors, but invalid
- * texture coordinates. The BitmapTextBlob itself has a few Blob-wide properties, and also
- * consists of a number of runs. Runs inside a blob are flushed individually so they can be
- * reordered.
- *
- * The only thing(aside from a memcopy) required to flush a BitmapTextBlob is to ensure that
- * the GrAtlas will not evict anything the Blob needs.
- */
- struct BitmapTextBlob : public SkRefCnt {
- SK_DECLARE_INTERNAL_LLIST_INTERFACE(BitmapTextBlob);
-
- /*
- * Each Run inside of the blob can have its texture coordinates regenerated if required.
- * To determine if regeneration is necessary, fAtlasGeneration is used. If there have been
- * any evictions inside of the atlas, then we will simply regenerate Runs. We could track
- * this at a more fine grained level, but its not clear if this is worth it, as evictions
- * should be fairly rare.
- *
- * One additional point, each run can contain glyphs with any of the three mask formats.
- * We call these SubRuns. Because a subrun must be a contiguous range, we have to create
- * a new subrun each time the mask format changes in a run. In theory, a run can have as
- * many SubRuns as it has glyphs, ie if a run alternates between color emoji and A8. In
- * practice, the vast majority of runs have only a single subrun.
- *
- * Finally, for runs where the entire thing is too large for the GrAtlasTextContext to
- * handle, we have a bit to mark the run as flusahable via rendering as paths. It is worth
- * pointing. It would be a bit expensive to figure out ahead of time whether or not a run
- * can flush in this manner, so we always allocate vertices for the run, regardless of
- * whether or not it is too large. The benefit of this strategy is that we can always reuse
- * a blob allocation regardless of viewmatrix changes. We could store positions for these
- * glyphs. However, its not clear if this is a win because we'd still have to either go the
- * glyph cache to get the path at flush time, or hold onto the path in the cache, which
- * would greatly increase the memory of these cached items.
- */
- struct Run {
- Run()
- : fColor(GrColor_ILLEGAL)
- , fInitialized(false)
- , fDrawAsPaths(false) {
- fVertexBounds.setLargestInverted();
- // To ensure we always have one subrun, we push back a fresh run here
- fSubRunInfo.push_back();
- }
- struct SubRunInfo {
- SubRunInfo()
- : fAtlasGeneration(GrBatchAtlas::kInvalidAtlasGeneration)
- , fVertexStartIndex(0)
- , fVertexEndIndex(0)
- , fGlyphStartIndex(0)
- , fGlyphEndIndex(0)
- , fDrawAsDistanceFields(false) {}
- // Distance field text cannot draw coloremoji, and so has to fall back. However,
- // though the distance field text and the coloremoji may share the same run, they
- // will have different descriptors. If fOverrideDescriptor is non-NULL, then it
- // will be used in place of the run's descriptor to regen texture coords
- // TODO we could have a descriptor cache, it would reduce the size of these blobs
- // significantly, and then the subrun could just have a refed pointer to the
- // correct descriptor.
- GrBatchAtlas::BulkUseTokenUpdater fBulkUseToken;
- uint64_t fAtlasGeneration;
- size_t fVertexStartIndex;
- size_t fVertexEndIndex;
- uint32_t fGlyphStartIndex;
- uint32_t fGlyphEndIndex;
- SkScalar fTextRatio; // df property
- GrMaskFormat fMaskFormat;
- bool fDrawAsDistanceFields; // df property
- bool fUseLCDText; // df property
- };
-
- SubRunInfo& push_back() {
- // Forward glyph / vertex information to seed the new sub run
- SubRunInfo& prevSubRun = fSubRunInfo.back();
- SubRunInfo& newSubRun = fSubRunInfo.push_back();
- newSubRun.fGlyphStartIndex = prevSubRun.fGlyphEndIndex;
- newSubRun.fGlyphEndIndex = prevSubRun.fGlyphEndIndex;
-
- newSubRun.fVertexStartIndex = prevSubRun.fVertexEndIndex;
- newSubRun.fVertexEndIndex = prevSubRun.fVertexEndIndex;
- return newSubRun;
- }
- static const int kMinSubRuns = 1;
- SkAutoTUnref<GrBatchTextStrike> fStrike;
- SkAutoTUnref<SkTypeface> fTypeface;
- SkRect fVertexBounds;
- SkSTArray<kMinSubRuns, SubRunInfo> fSubRunInfo;
- SkAutoDescriptor fDescriptor;
- SkAutoTDelete<SkAutoDescriptor> fOverrideDescriptor; // df properties
- GrColor fColor;
- bool fInitialized;
- bool fDrawAsPaths;
- };
-
- struct BigGlyph {
- BigGlyph(const SkPath& path, SkScalar vx, SkScalar vy)
- : fPath(path)
- , fVx(vx)
- , fVy(vy) {}
- SkPath fPath;
- SkScalar fVx;
- SkScalar fVy;
- };
-
- struct Key {
- Key() {
- sk_bzero(this, sizeof(Key));
- }
- uint32_t fUniqueID;
- // Color may affect the gamma of the mask we generate, but in a fairly limited way.
- // Each color is assigned to on of a fixed number of buckets based on its
- // luminance. For each luminance bucket there is a "canonical color" that
- // represents the bucket. This functionality is currently only supported for A8
- SkColor fCanonicalColor;
- SkPaint::Style fStyle;
- SkPixelGeometry fPixelGeometry;
- bool fHasBlur;
-
- bool operator==(const Key& other) const {
- return 0 == memcmp(this, &other, sizeof(Key));
- }
- };
-
- struct StrokeInfo {
- SkScalar fFrameWidth;
- SkScalar fMiterLimit;
- SkPaint::Join fJoin;
- };
-
- enum TextType {
- kHasDistanceField_TextType = 0x1,
- kHasBitmap_TextType = 0x2,
- };
-
- // all glyph / vertex offsets are into these pools.
- unsigned char* fVertices;
- GrGlyph** fGlyphs;
- Run* fRuns;
- GrMemoryPool* fPool;
- SkMaskFilter::BlurRec fBlurRec;
- StrokeInfo fStrokeInfo;
- SkTArray<BigGlyph> fBigGlyphs;
- Key fKey;
- SkMatrix fViewMatrix;
- SkColor fPaintColor;
- SkScalar fX;
- SkScalar fY;
-
- // We can reuse distance field text, but only if the new viewmatrix would not result in
- // a mip change. Because there can be multiple runs in a blob, we track the overall
- // maximum minimum scale, and minimum maximum scale, we can support before we need to regen
- SkScalar fMaxMinScale;
- SkScalar fMinMaxScale;
- int fRunCount;
- uint8_t fTextType;
-
- BitmapTextBlob()
- : fMaxMinScale(-SK_ScalarMax)
- , fMinMaxScale(SK_ScalarMax)
- , fTextType(0) {}
-
- ~BitmapTextBlob() override {
- for (int i = 0; i < fRunCount; i++) {
- fRuns[i].~Run();
- }
- }
-
- static const Key& GetKey(const BitmapTextBlob& blob) {
- return blob.fKey;
- }
-
- static uint32_t Hash(const Key& key) {
- return SkChecksum::Murmur3(&key, sizeof(Key));
- }
-
- void operator delete(void* p) {
- BitmapTextBlob* blob = reinterpret_cast<BitmapTextBlob*>(p);
- blob->fPool->release(p);
- }
- void* operator new(size_t) {
- SkFAIL("All blobs are created by placement new.");
- return sk_malloc_throw(0);
- }
-
- void* operator new(size_t, void* p) { return p; }
- void operator delete(void* target, void* placement) {
- ::operator delete(target, placement);
- }
-
- bool hasDistanceField() const { return SkToBool(fTextType & kHasDistanceField_TextType); }
- bool hasBitmap() const { return SkToBool(fTextType & kHasBitmap_TextType); }
- void setHasDistanceField() { fTextType |= kHasDistanceField_TextType; }
- void setHasBitmap() { fTextType |= kHasBitmap_TextType; }
- };
-
- typedef BitmapTextBlob::Run Run;
+ typedef GrAtlasTextBlob::Run Run;
typedef Run::SubRunInfo PerSubRunInfo;
inline bool canDrawAsDistanceFields(const SkPaint&, const SkMatrix& viewMatrix);
- BitmapTextBlob* setupDFBlob(int glyphCount, const SkPaint& origPaint,
+ GrAtlasTextBlob* setupDFBlob(int glyphCount, const SkPaint& origPaint,
const SkMatrix& viewMatrix, SkGlyphCache** cache,
SkPaint* dfPaint, SkScalar* textRatio);
- void bmpAppendGlyph(BitmapTextBlob*, int runIndex, GrGlyph::PackedID, int left, int top,
+ void bmpAppendGlyph(GrAtlasTextBlob*, int runIndex, GrGlyph::PackedID, int left, int top,
GrColor color, GrFontScaler*, const SkIRect& clipRect);
- bool dfAppendGlyph(BitmapTextBlob*, int runIndex, GrGlyph::PackedID, SkScalar sx, SkScalar sy,
+ bool dfAppendGlyph(GrAtlasTextBlob*, int runIndex, GrGlyph::PackedID, SkScalar sx, SkScalar sy,
GrColor color, GrFontScaler*, const SkIRect& clipRect, SkScalar textRatio,
const SkMatrix& viewMatrix);
- inline void appendGlyphPath(BitmapTextBlob* blob, GrGlyph* glyph,
+ inline void appendGlyphPath(GrAtlasTextBlob* blob, GrGlyph* glyph,
GrFontScaler* scaler, SkScalar x, SkScalar y);
- inline void appendGlyphCommon(BitmapTextBlob*, Run*, Run::SubRunInfo*,
+ inline void appendGlyphCommon(GrAtlasTextBlob*, Run*, Run::SubRunInfo*,
const SkRect& positions, GrColor color,
size_t vertexStride, bool useVertexColor,
GrGlyph*);
const SkPaint&, SkDrawFilter*,
const SkMatrix& viewMatrix, const SkIRect& clipBounds, SkScalar x,
SkScalar y);
- inline BitmapTextBatch* createBatch(BitmapTextBlob*, const PerSubRunInfo&,
+ inline BitmapTextBatch* createBatch(GrAtlasTextBlob*, const PerSubRunInfo&,
int glyphCount, int run, int subRun,
GrColor, SkScalar transX, SkScalar transY,
const SkPaint&);
- inline void flushRun(GrPipelineBuilder*, BitmapTextBlob*, int run, GrColor,
+ inline void flushRun(GrPipelineBuilder*, GrAtlasTextBlob*, int run, GrColor,
SkScalar transX, SkScalar transY, const SkPaint&);
- inline void flushBigGlyphs(BitmapTextBlob* cacheBlob, GrRenderTarget*,
+ inline void flushBigGlyphs(GrAtlasTextBlob* cacheBlob, GrRenderTarget*,
const GrClip& clip, const SkPaint& skPaint,
SkScalar transX, SkScalar transY, const SkIRect& clipBounds);
// We have to flush SkTextBlobs differently from drawText / drawPosText
- void flush(const SkTextBlob*, BitmapTextBlob*, GrRenderTarget*,
+ void flush(const SkTextBlob*, GrAtlasTextBlob*, GrRenderTarget*,
const SkPaint&, const GrPaint&, SkDrawFilter*, const GrClip&,
const SkMatrix& viewMatrix, const SkIRect& clipBounds, SkScalar x, SkScalar y,
SkScalar transX, SkScalar transY);
- void flush(BitmapTextBlob*, GrRenderTarget*, const SkPaint&,
+ void flush(GrAtlasTextBlob*, GrRenderTarget*, const SkPaint&,
const GrPaint&, const GrClip&, const SkIRect& clipBounds);
// A helper for drawing BitmapText in a run of distance fields
- inline void fallbackDrawPosText(BitmapTextBlob*, int runIndex,
+ inline void fallbackDrawPosText(GrAtlasTextBlob*, int runIndex,
GrRenderTarget*, const GrClip&,
const GrPaint&,
const SkPaint&, const SkMatrix& viewMatrix,
const SkPoint& offset,
const SkIRect& clipRect);
- void internalDrawBMPText(BitmapTextBlob*, int runIndex, SkGlyphCache*, const SkPaint&,
+ void internalDrawBMPText(GrAtlasTextBlob*, int runIndex, SkGlyphCache*, const SkPaint&,
GrColor color, const SkMatrix& viewMatrix,
const char text[], size_t byteLength,
SkScalar x, SkScalar y, const SkIRect& clipRect);
- void internalDrawBMPPosText(BitmapTextBlob*, int runIndex, SkGlyphCache*, const SkPaint&,
+ void internalDrawBMPPosText(GrAtlasTextBlob*, int runIndex, SkGlyphCache*, const SkPaint&,
GrColor color, const SkMatrix& viewMatrix,
const char text[], size_t byteLength,
const SkScalar pos[], int scalarsPerPosition,
const SkPoint& offset, const SkIRect& clipRect);
- void internalDrawDFText(BitmapTextBlob*, int runIndex, SkGlyphCache*, const SkPaint&,
+ void internalDrawDFText(GrAtlasTextBlob*, int runIndex, SkGlyphCache*, const SkPaint&,
GrColor color, const SkMatrix& viewMatrix,
const char text[], size_t byteLength,
SkScalar x, SkScalar y, const SkIRect& clipRect,
SkTDArray<char>* fallbackTxt,
SkTDArray<SkScalar>* fallbackPos,
SkPoint* offset, const SkPaint& origPaint);
- void internalDrawDFPosText(BitmapTextBlob*, int runIndex, SkGlyphCache*, const SkPaint&,
+ void internalDrawDFPosText(GrAtlasTextBlob*, int runIndex, SkGlyphCache*, const SkPaint&,
GrColor color, const SkMatrix& viewMatrix,
const char text[], size_t byteLength,
const SkScalar pos[], int scalarsPerPosition,
inline static GrColor ComputeCanonicalColor(const SkPaint&, bool lcd);
inline SkGlyphCache* setupCache(Run*, const SkPaint&, const SkMatrix* viewMatrix, bool noGamma);
static inline bool MustRegenerateBlob(SkScalar* outTransX, SkScalar* outTransY,
- const BitmapTextBlob&, const SkPaint&,
+ const GrAtlasTextBlob&, const SkPaint&,
const SkMaskFilter::BlurRec&,
const SkMatrix& viewMatrix, SkScalar x, SkScalar y);
- void regenerateTextBlob(BitmapTextBlob* bmp, const SkPaint& skPaint, GrColor,
+ void regenerateTextBlob(GrAtlasTextBlob* bmp, const SkPaint& skPaint, GrColor,
const SkMatrix& viewMatrix,
const SkTextBlob* blob, SkScalar x, SkScalar y,
SkDrawFilter* drawFilter, const SkIRect& clipRect, GrRenderTarget*,
const GrClip&, const GrPaint&);
inline static bool HasLCD(const SkTextBlob*);
- inline void initDistanceFieldPaint(BitmapTextBlob*, SkPaint*, SkScalar* textRatio,
+ inline void initDistanceFieldPaint(GrAtlasTextBlob*, SkPaint*, SkScalar* textRatio,
const SkMatrix&);
// Test methods
// TODO this is really ugly. It'd be much nicer if positioning could be moved to batch
- inline BitmapTextBlob* createDrawTextBlob(GrRenderTarget*, const GrClip&, const GrPaint&,
+ inline GrAtlasTextBlob* createDrawTextBlob(GrRenderTarget*, const GrClip&, const GrPaint&,
const SkPaint&, const SkMatrix& viewMatrix,
const char text[], size_t byteLength,
SkScalar x, SkScalar y,
const SkIRect& regionClipBounds);
- inline BitmapTextBlob* createDrawPosTextBlob(GrRenderTarget*, const GrClip&, const GrPaint&,
+ inline GrAtlasTextBlob* createDrawPosTextBlob(GrRenderTarget*, const GrClip&, const GrPaint&,
const SkPaint&, const SkMatrix& viewMatrix,
const char text[], size_t byteLength,
const SkScalar pos[], int scalarsPerPosition,
this->freeAll();
}
-GrAtlasTextContext::BitmapTextBlob* GrTextBlobCache::createBlob(int glyphCount, int runCount,
+GrAtlasTextBlob* GrTextBlobCache::createBlob(int glyphCount, int runCount,
size_t maxVASize) {
- // We allocate size for the BitmapTextBlob itself, plus size for the vertices array,
+ // We allocate size for the GrAtlasTextBlob itself, plus size for the vertices array,
// and size for the glyphIds array.
size_t verticesCount = glyphCount * kVerticesPerGlyph * maxVASize;
- size_t size = sizeof(BitmapTextBlob) +
+ size_t size = sizeof(GrAtlasTextBlob) +
verticesCount +
glyphCount * sizeof(GrGlyph**) +
- sizeof(BitmapTextBlob::Run) * runCount;
+ sizeof(GrAtlasTextBlob::Run) * runCount;
- BitmapTextBlob* cacheBlob = SkNEW_PLACEMENT(fPool.allocate(size), BitmapTextBlob);
+ GrAtlasTextBlob* cacheBlob = SkNEW_PLACEMENT(fPool.allocate(size), GrAtlasTextBlob);
// setup offsets for vertices / glyphs
- cacheBlob->fVertices = sizeof(BitmapTextBlob) + reinterpret_cast<unsigned char*>(cacheBlob);
+ cacheBlob->fVertices = sizeof(GrAtlasTextBlob) + reinterpret_cast<unsigned char*>(cacheBlob);
cacheBlob->fGlyphs = reinterpret_cast<GrGlyph**>(cacheBlob->fVertices + verticesCount);
- cacheBlob->fRuns = reinterpret_cast<BitmapTextBlob::Run*>(cacheBlob->fGlyphs + glyphCount);
+ cacheBlob->fRuns = reinterpret_cast<GrAtlasTextBlob::Run*>(cacheBlob->fGlyphs + glyphCount);
// Initialize runs
for (int i = 0; i < runCount; i++) {
- SkNEW_PLACEMENT(&cacheBlob->fRuns[i], BitmapTextBlob::Run);
+ SkNEW_PLACEMENT(&cacheBlob->fRuns[i], GrAtlasTextBlob::Run);
}
cacheBlob->fRunCount = runCount;
cacheBlob->fPool = &fPool;
}
void GrTextBlobCache::freeAll() {
- SkTDynamicHash<BitmapTextBlob, BitmapTextBlob::Key>::Iter iter(&fCache);
+ SkTDynamicHash<GrAtlasTextBlob, GrAtlasTextBlob::Key>::Iter iter(&fCache);
while (!iter.done()) {
- BitmapTextBlob* blob = &(*iter);
+ GrAtlasTextBlob* blob = &(*iter);
fBlobList.remove(blob);
blob->unref();
++iter;
class GrTextBlobCache {
public:
- typedef GrAtlasTextContext::BitmapTextBlob BitmapTextBlob;
-
/**
* The callback function used by the cache when it is still over budget after a purge. The
* passed in 'data' is the same 'data' handed to setOverbudgetCallback.
~GrTextBlobCache();
// creates an uncached blob
- BitmapTextBlob* createBlob(int glyphCount, int runCount, size_t maxVASize);
- BitmapTextBlob* createBlob(const SkTextBlob* blob, size_t maxVAStride) {
+ GrAtlasTextBlob* createBlob(int glyphCount, int runCount, size_t maxVASize);
+ GrAtlasTextBlob* createBlob(const SkTextBlob* blob, size_t maxVAStride) {
int glyphCount = 0;
int runCount = 0;
BlobGlyphCount(&glyphCount, &runCount, blob);
- BitmapTextBlob* cacheBlob = this->createBlob(glyphCount, runCount, maxVAStride);
+ GrAtlasTextBlob* cacheBlob = this->createBlob(glyphCount, runCount, maxVAStride);
return cacheBlob;
}
- BitmapTextBlob* createCachedBlob(const SkTextBlob* blob,
- const BitmapTextBlob::Key& key,
+ GrAtlasTextBlob* createCachedBlob(const SkTextBlob* blob,
+ const GrAtlasTextBlob::Key& key,
const SkMaskFilter::BlurRec& blurRec,
const SkPaint& paint,
size_t maxVAStride) {
int glyphCount = 0;
int runCount = 0;
BlobGlyphCount(&glyphCount, &runCount, blob);
- BitmapTextBlob* cacheBlob = this->createBlob(glyphCount, runCount, maxVAStride);
+ GrAtlasTextBlob* cacheBlob = this->createBlob(glyphCount, runCount, maxVAStride);
cacheBlob->fKey = key;
if (key.fHasBlur) {
cacheBlob->fBlurRec = blurRec;
return cacheBlob;
}
- BitmapTextBlob* find(const BitmapTextBlob::Key& key) {
+ GrAtlasTextBlob* find(const GrAtlasTextBlob::Key& key) {
return fCache.find(key);
}
- void remove(BitmapTextBlob* blob) {
+ void remove(GrAtlasTextBlob* blob) {
fCache.remove(blob->fKey);
fBlobList.remove(blob);
blob->unref();
}
- void add(BitmapTextBlob* blob) {
+ void add(GrAtlasTextBlob* blob) {
fCache.add(blob);
fBlobList.addToHead(blob);
if (fPool.size() > kBudget) {
BitmapBlobList::Iter iter;
iter.init(fBlobList, BitmapBlobList::Iter::kTail_IterStart);
- BitmapTextBlob* lruBlob = iter.get();
+ GrAtlasTextBlob* lruBlob = iter.get();
SkASSERT(lruBlob);
while (fPool.size() > kBudget && (lruBlob = iter.get()) && lruBlob != blob) {
fCache.remove(lruBlob->fKey);
}
}
- void makeMRU(BitmapTextBlob* blob) {
+ void makeMRU(GrAtlasTextBlob* blob) {
if (fBlobList.head() == blob) {
return;
}
}
}
- typedef SkTInternalLList<BitmapTextBlob> BitmapBlobList;
+ typedef SkTInternalLList<GrAtlasTextBlob> BitmapBlobList;
// Budget was chosen to be ~4 megabytes. The min alloc and pre alloc sizes in the pool are
// based off of the largest cached textblob I have seen in the skps(a couple of kilobytes).
static const int kMinGrowthSize = 1 << 17;
static const int kBudget = 1 << 22;
BitmapBlobList fBlobList;
- SkTDynamicHash<BitmapTextBlob, BitmapTextBlob::Key> fCache;
+ SkTDynamicHash<GrAtlasTextBlob, GrAtlasTextBlob::Key> fCache;
GrMemoryPool fPool;
PFOverBudgetCB fCallback;
void* fData;
projects / platform / upstream / libSkiaSharp.git / commitdiff