src/gpu/GrAtlasTextContext.h - Issue 1249663002: rename BitmapTextBlob and move it to its own file

Unified Diff: src/gpu/GrAtlasTextContext.h

Issue 1249663002: rename BitmapTextBlob and move it to its own file (Closed) Base URL: https://skia.googlesource.com/skia.git@master

Patch Set: nit Created 5 years, 5 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

Index: src/gpu/GrAtlasTextContext.h

diff --git a/src/gpu/GrAtlasTextContext.h b/src/gpu/GrAtlasTextContext.h

index 8094046d5c81a5e147f91f6401a30d1ed6fa88b8..9e49bba37ec7551c8de0f9d37a02a6e522532f4c 100644

--- a/src/gpu/GrAtlasTextContext.h

+++ b/src/gpu/GrAtlasTextContext.h

@@ -10,14 +10,9 @@

#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"

@@ -56,217 +51,21 @@ private:

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*);

@@ -276,26 +75,26 @@ private:

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,

@@ -305,17 +104,17 @@ private:

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,

@@ -323,7 +122,7 @@ private:

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,

@@ -336,26 +135,26 @@ private:

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,

« no previous file with comments | « src/gpu/GrAtlasTextBlob.h ('k') | src/gpu/GrAtlasTextContext.cpp » ('j') | no next file with comments »