| /* |
| * 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 GrAtlasTextContext_DEFINED |
| #define GrAtlasTextContext_DEFINED |
| |
| #include "GrTextContext.h" |
| |
| #include "GrBatchAtlas.h" |
| #include "GrBatchFontCache.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" |
| #endif |
| |
| class BitmapTextBatch; |
| class GrPipelineBuilder; |
| class GrTextBlobCache; |
| |
| /* |
| * This class implements GrTextContext using standard bitmap fonts, and can also process textblobs. |
| * TODO replace GrBitmapTextContext |
| */ |
| class GrAtlasTextContext : public GrTextContext { |
| public: |
| static GrAtlasTextContext* Create(GrContext*, SkGpuDevice*, const SkDeviceProperties&, |
| bool enableDistanceFields); |
| |
| private: |
| GrAtlasTextContext(GrContext*, SkGpuDevice*, const SkDeviceProperties&, |
| bool enableDistanceFields); |
| ~GrAtlasTextContext() override {} |
| |
| bool canDraw(const GrRenderTarget*, const GrClip&, const GrPaint&, |
| const SkPaint&, const SkMatrix& viewMatrix) override; |
| |
| void onDrawText(GrRenderTarget*, const GrClip&, const GrPaint&, const SkPaint&, |
| const SkMatrix& viewMatrix, const char text[], size_t byteLength, |
| SkScalar x, SkScalar y, const SkIRect& regionClipBounds) override; |
| void onDrawPosText(GrRenderTarget*, const GrClip&, const GrPaint&, const SkPaint&, |
| const SkMatrix& viewMatrix, |
| const char text[], size_t byteLength, |
| const SkScalar pos[], int scalarsPerPosition, |
| const SkPoint& offset, const SkIRect& regionClipBounds) override; |
| void drawTextBlob(GrRenderTarget*, const GrClip&, const SkPaint&, |
| 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 Run::SubRunInfo PerSubRunInfo; |
| |
| inline bool canDrawAsDistanceFields(const SkPaint&, const SkMatrix& viewMatrix); |
| BitmapTextBlob* 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, |
| GrColor color, GrFontScaler*, const SkIRect& clipRect); |
| bool dfAppendGlyph(BitmapTextBlob*, 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, |
| GrFontScaler* scaler, SkScalar x, SkScalar y); |
| inline void appendGlyphCommon(BitmapTextBlob*, Run*, Run::SubRunInfo*, |
| const SkRect& positions, GrColor color, |
| size_t vertexStride, bool useVertexColor, |
| GrGlyph*); |
| |
| inline void flushRunAsPaths(const SkTextBlob::RunIterator&, const SkPaint&, SkDrawFilter*, |
| const SkMatrix& viewMatrix, const SkIRect& clipBounds, SkScalar x, |
| SkScalar y); |
| inline BitmapTextBatch* createBatch(BitmapTextBlob*, const PerSubRunInfo&, |
| int glyphCount, int run, int subRun, |
| GrColor, SkScalar transX, SkScalar transY, |
| const SkPaint&); |
| inline void flushRun(GrDrawTarget*, GrPipelineBuilder*, BitmapTextBlob*, int run, GrColor, |
| SkScalar transX, SkScalar transY, const SkPaint&); |
| inline void flushBigGlyphs(BitmapTextBlob* cacheBlob, GrRenderTarget* rt, |
| const SkPaint& skPaint, |
| SkScalar transX, SkScalar transY, const SkIRect& clipBounds); |
| |
| // We have to flush SkTextBlobs differently from drawText / drawPosText |
| void flush(GrDrawTarget*, const SkTextBlob*, BitmapTextBlob*, GrRenderTarget*, const SkPaint&, |
| const GrPaint&, SkDrawFilter*, const GrClip&, const SkMatrix& viewMatrix, |
| const SkIRect& clipBounds, SkScalar x, SkScalar y, SkScalar transX, SkScalar transY); |
| void flush(GrDrawTarget*, BitmapTextBlob*, 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, |
| GrRenderTarget*, const GrClip&, |
| const GrPaint&, |
| const SkPaint&, const SkMatrix& viewMatrix, |
| const SkTDArray<char>& fallbackTxt, |
| const SkTDArray<SkScalar>& fallbackPos, |
| int scalarsPerPosition, |
| const SkPoint& offset, |
| const SkIRect& clipRect); |
| |
| void internalDrawBMPText(BitmapTextBlob*, 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&, |
| 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&, |
| GrColor color, const SkMatrix& viewMatrix, |
| const char text[], size_t byteLength, |
| SkScalar x, SkScalar y, const SkIRect& clipRect, |
| SkScalar textRatio, |
| SkTDArray<char>* fallbackTxt, |
| SkTDArray<SkScalar>* fallbackPos, |
| SkPoint* offset, const SkPaint& origPaint); |
| void internalDrawDFPosText(BitmapTextBlob*, 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, |
| SkScalar textRatio, |
| SkTDArray<char>* fallbackTxt, |
| SkTDArray<SkScalar>* fallbackPos); |
| |
| // sets up the descriptor on the blob and returns a detached cache. Client must attach |
| 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 SkMaskFilter::BlurRec&, |
| const SkMatrix& viewMatrix, SkScalar x, SkScalar y); |
| void regenerateTextBlob(BitmapTextBlob* 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, |
| 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&, |
| 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&, |
| const SkPaint&, const SkMatrix& viewMatrix, |
| const char text[], size_t byteLength, |
| const SkScalar pos[], int scalarsPerPosition, |
| const SkPoint& offset, |
| const SkIRect& regionClipBounds); |
| |
| // Distance field text needs this table to compute a value for use in the fragment shader. |
| // Because the GrAtlasTextContext can go out of scope before the final flush, this needs to be |
| // refcnted and malloced |
| struct DistanceAdjustTable : public SkNVRefCnt<DistanceAdjustTable> { |
| DistanceAdjustTable(float gamma) { this->buildDistanceAdjustTable(gamma); } |
| ~DistanceAdjustTable() { SkDELETE_ARRAY(fTable); } |
| |
| void buildDistanceAdjustTable(float gamma); |
| |
| SkScalar& operator[] (int i) { |
| return fTable[i]; |
| } |
| |
| const SkScalar& operator[] (int i) const { |
| return fTable[i]; |
| } |
| |
| SkScalar* fTable; |
| }; |
| |
| GrBatchTextStrike* fCurrStrike; |
| GrTextBlobCache* fCache; |
| bool fEnableDFRendering; |
| SkAutoTUnref<DistanceAdjustTable> fDistanceAdjustTable; |
| |
| friend class GrTextBlobCache; |
| friend class BitmapTextBatch; |
| |
| #ifdef GR_TEST_UTILS |
| BATCH_TEST_FRIEND(TextBlobBatch); |
| #endif |
| |
| typedef GrTextContext INHERITED; |
| }; |
| |
| #endif |
