| /* | |
| * 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 "GrColor.h" | |
| #include "GrMemoryPool.h" | |
| #include "SkDescriptor.h" | |
| #include "SkMaskFilter.h" | |
| #include "SkOpts.h" | |
| #include "SkPathEffect.h" | |
| #include "SkRasterizer.h" | |
| #include "SkSurfaceProps.h" | |
| #include "SkTInternalLList.h" | |
| class GrBlobRegenHelper; | |
| struct GrDistanceFieldAdjustTable; | |
| class GrMemoryPool; | |
| class SkDrawFilter; | |
| class SkTextBlob; | |
| class SkTextBlobRunIterator; | |
| // With this flag enabled, the GrAtlasTextContext will, as a sanity check, regenerate every blob | |
| // that comes in to verify the integrity of its cache | |
| #define CACHE_SANITY_CHECK 0 | |
| /* | |
| * 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. | |
| * | |
| * *WARNING* If you add new fields to this struct, then you may need to to update AssertEqual | |
| */ | |
| class GrAtlasTextBlob : public SkNVRefCnt<GrAtlasTextBlob> { | |
| public: | |
| SK_DECLARE_INTERNAL_LLIST_INTERFACE(GrAtlasTextBlob); | |
| static GrAtlasTextBlob* Create(GrMemoryPool* pool, int glyphCount, int runCount); | |
| 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; | |
| uint32_t fScalerContextFlags; | |
| bool operator==(const Key& other) const { | |
| return 0 == memcmp(this, &other, sizeof(Key)); | |
| } | |
| }; | |
| void setupKey(const GrAtlasTextBlob::Key& key, | |
| const SkMaskFilter::BlurRec& blurRec, | |
| const SkPaint& paint) { | |
| fKey = key; | |
| if (key.fHasBlur) { | |
| fBlurRec = blurRec; | |
| } | |
| if (key.fStyle != SkPaint::kFill_Style) { | |
| fStrokeInfo.fFrameWidth = paint.getStrokeWidth(); | |
| fStrokeInfo.fMiterLimit = paint.getStrokeMiter(); | |
| fStrokeInfo.fJoin = paint.getStrokeJoin(); | |
| } | |
| } | |
| static const Key& GetKey(const GrAtlasTextBlob& blob) { | |
| return blob.fKey; | |
| } | |
| static uint32_t Hash(const Key& key) { | |
| return SkOpts::hash(&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; } | |
| int runCount() const { return fRunCount; } | |
| void push_back_run(int currRun) { | |
| SkASSERT(currRun < fRunCount); | |
| if (currRun > 0) { | |
| Run::SubRunInfo& newRun = fRuns[currRun].fSubRunInfo.back(); | |
| Run::SubRunInfo& lastRun = fRuns[currRun - 1].fSubRunInfo.back(); | |
| newRun.setAsSuccessor(lastRun); | |
| } | |
| } | |
| // sets the last subrun of runIndex to use distance field text | |
| void setSubRunHasDistanceFields(int runIndex, bool hasLCD) { | |
| Run& run = fRuns[runIndex]; | |
| Run::SubRunInfo& subRun = run.fSubRunInfo.back(); | |
| subRun.setUseLCDText(hasLCD); | |
| subRun.setDrawAsDistanceFields(); | |
| } | |
| void setRunDrawAsPaths(int runIndex) { | |
| fRuns[runIndex].fDrawAsPaths = true; | |
| } | |
| void setMinAndMaxScale(SkScalar scaledMax, SkScalar scaledMin) { | |
| // we init fMaxMinScale and fMinMaxScale in the constructor | |
| fMaxMinScale = SkMaxScalar(scaledMax, fMaxMinScale); | |
| fMinMaxScale = SkMinScalar(scaledMin, fMinMaxScale); | |
| } | |
| // inits the override descriptor on the current run. All following subruns must use this | |
| // descriptor | |
| void initOverride(int runIndex) { | |
| Run& run = fRuns[runIndex]; | |
| // Push back a new subrun to fill and set the override descriptor | |
| run.push_back(); | |
| run.fOverrideDescriptor.reset(new SkAutoDescriptor); | |
| } | |
| SkGlyphCache* setupCache(int runIndex, | |
| const SkSurfaceProps& props, | |
| uint32_t scalerContextFlags, | |
| const SkPaint& skPaint, | |
| const SkMatrix* viewMatrix); | |
| // Appends a glyph to the blob. If the glyph is too large, the glyph will be appended | |
| // as a path. | |
| void appendGlyph(int runIndex, | |
| const SkRect& positions, | |
| GrColor color, | |
| GrBatchTextStrike* strike, | |
| GrGlyph* glyph, | |
| SkGlyphCache*, const SkGlyph& skGlyph, | |
| SkScalar x, SkScalar y, SkScalar scale, bool applyVM); | |
| static size_t GetVertexStride(GrMaskFormat maskFormat) { | |
| switch (maskFormat) { | |
| case kA8_GrMaskFormat: | |
| return kGrayTextVASize; | |
| case kARGB_GrMaskFormat: | |
| return kColorTextVASize; | |
| default: | |
| return kLCDTextVASize; | |
| } | |
| } | |
| bool mustRegenerate(const SkPaint& paint, GrColor color, const SkMaskFilter::BlurRec& blurRec, | |
| const SkMatrix& viewMatrix, SkScalar x, SkScalar y); | |
| // flush a GrAtlasTextBlob associated with a SkTextBlob | |
| void flushCached(GrContext* context, | |
| GrDrawContext* dc, | |
| const SkTextBlob* blob, | |
| const SkSurfaceProps& props, | |
| const GrDistanceFieldAdjustTable* distanceAdjustTable, | |
| const SkPaint& skPaint, | |
| const GrPaint& grPaint, | |
| SkDrawFilter* drawFilter, | |
| const GrClip& clip, | |
| const SkMatrix& viewMatrix, | |
| const SkIRect& clipBounds, | |
| SkScalar x, SkScalar y); | |
| // flush a throwaway GrAtlasTextBlob *not* associated with an SkTextBlob | |
| void flushThrowaway(GrContext* context, | |
| GrDrawContext* dc, | |
| const SkSurfaceProps& props, | |
| const GrDistanceFieldAdjustTable* distanceAdjustTable, | |
| const SkPaint& skPaint, | |
| const GrPaint& grPaint, | |
| const GrClip& clip, | |
| const SkMatrix& viewMatrix, | |
| const SkIRect& clipBounds, | |
| SkScalar x, SkScalar y); | |
| void computeSubRunBounds(SkRect* outBounds, int runIndex, int subRunIndex, | |
| const SkMatrix& viewMatrix, SkScalar x, SkScalar y) { | |
| // We don't yet position distance field text on the cpu, so we have to map the vertex bounds | |
| // into device space. | |
| // We handle vertex bounds differently for distance field text and bitmap text because | |
| // the vertex bounds of bitmap text are in device space. If we are flushing multiple runs | |
| // from one blob then we are going to pay the price here of mapping the rect for each run. | |
| const Run& run = fRuns[runIndex]; | |
| const Run::SubRunInfo& subRun = run.fSubRunInfo[subRunIndex]; | |
| *outBounds = subRun.vertexBounds(); | |
| if (subRun.drawAsDistanceFields()) { | |
| // Distance field text is positioned with the (X,Y) as part of the glyph position, | |
| // and currently the view matrix is applied on the GPU | |
| outBounds->offset(x - fInitialX, y - fInitialY); | |
| viewMatrix.mapRect(outBounds); | |
| } else { | |
| // Bitmap text is fully positioned on the CPU, and offset by an (X,Y) translate in | |
| // device space. | |
| SkMatrix boundsMatrix = fInitialViewMatrixInverse; | |
| boundsMatrix.postTranslate(-fInitialX, -fInitialY); | |
| boundsMatrix.postTranslate(x, y); | |
| boundsMatrix.postConcat(viewMatrix); | |
| boundsMatrix.mapRect(outBounds); | |
| // Due to floating point numerical inaccuracies, we have to round out here | |
| outBounds->roundOut(outBounds); | |
| } | |
| } | |
| // position + local coord | |
| static const size_t kColorTextVASize = sizeof(SkPoint) + sizeof(SkIPoint16); | |
| static const size_t kGrayTextVASize = sizeof(SkPoint) + sizeof(GrColor) + sizeof(SkIPoint16); | |
| static const size_t kLCDTextVASize = kGrayTextVASize; | |
| static const size_t kMaxVASize = kGrayTextVASize; | |
| static const int kVerticesPerGlyph = 4; | |
| static void AssertEqual(const GrAtlasTextBlob&, const GrAtlasTextBlob&); | |
| // The color here is the GrPaint color, and it is used to determine whether we | |
| // have to regenerate LCD text blobs. | |
| // We use this color vs the SkPaint color because it has the colorfilter applied. | |
| void initReusableBlob(GrColor color, const SkMatrix& viewMatrix, SkScalar x, SkScalar y) { | |
| fPaintColor = color; | |
| this->setupViewMatrix(viewMatrix, x, y); | |
| } | |
| void initThrowawayBlob(const SkMatrix& viewMatrix, SkScalar x, SkScalar y) { | |
| this->setupViewMatrix(viewMatrix, x, y); | |
| } | |
| /** | |
| * Consecutive calls to regenInBatch often use the same SkGlyphCache. If the same instance of | |
| * SkAutoGlyphCache is passed to multiple calls of regenInBatch then it can save the cost of | |
| * multiple detach/attach operations of SkGlyphCache. | |
| */ | |
| void regenInBatch(GrDrawBatch::Target* target, GrBatchFontCache* fontCache, | |
| GrBlobRegenHelper *helper, int run, int subRun, SkAutoGlyphCache*, | |
| size_t vertexStride, const SkMatrix& viewMatrix, SkScalar x, SkScalar y, | |
| GrColor color, void** vertices, size_t* byteCount, int* glyphCount); | |
| const Key& key() const { return fKey; } | |
| ~GrAtlasTextBlob() { | |
| for (int i = 0; i < fRunCount; i++) { | |
| fRuns[i].~Run(); | |
| } | |
| } | |
| //////////////////////////////////////////////////////////////////////////////////////////////// | |
| // Internal test methods | |
| GrDrawBatch* test_createBatch(int glyphCount, int run, int subRun, | |
| const SkMatrix& viewMatrix, SkScalar x, SkScalar y, GrColor color, | |
| const SkPaint& skPaint, const SkSurfaceProps& props, | |
| const GrDistanceFieldAdjustTable* distanceAdjustTable, | |
| GrBatchFontCache* cache); | |
| private: | |
| GrAtlasTextBlob() | |
| : fMaxMinScale(-SK_ScalarMax) | |
| , fMinMaxScale(SK_ScalarMax) | |
| , fTextType(0) {} | |
| void appendLargeGlyph(GrGlyph* glyph, SkGlyphCache* cache, const SkGlyph& skGlyph, | |
| SkScalar x, SkScalar y, SkScalar scale, bool applyVM); | |
| inline void flushRun(GrDrawContext* dc, const GrPaint&, const GrClip&, | |
| int run, const SkMatrix& viewMatrix, SkScalar x, SkScalar y, | |
| const SkPaint& skPaint, const SkSurfaceProps& props, | |
| const GrDistanceFieldAdjustTable* distanceAdjustTable, | |
| GrBatchFontCache* cache); | |
| void flushBigGlyphs(GrContext* context, GrDrawContext* dc, | |
| const GrClip& clip, const SkPaint& skPaint, | |
| const SkMatrix& viewMatrix, SkScalar x, SkScalar y, | |
| const SkIRect& clipBounds); | |
| void flushRunAsPaths(GrContext* context, | |
| GrDrawContext* dc, | |
| const SkSurfaceProps& props, | |
| const SkTextBlobRunIterator& it, | |
| const GrClip& clip, const SkPaint& skPaint, | |
| SkDrawFilter* drawFilter, const SkMatrix& viewMatrix, | |
| const SkIRect& clipBounds, SkScalar x, SkScalar y); | |
| // This function will only be called when we are generating a blob from scratch. We record the | |
| // initial view matrix and initial offsets(x,y), because we record vertex bounds relative to | |
| // these numbers. When blobs are reused with new matrices, we need to return to model space so | |
| // we can update the vertex bounds appropriately. | |
| void setupViewMatrix(const SkMatrix& viewMatrix, SkScalar x, SkScalar y) { | |
| fInitialViewMatrix = viewMatrix; | |
| if (!viewMatrix.invert(&fInitialViewMatrixInverse)) { | |
| fInitialViewMatrixInverse = SkMatrix::I(); | |
| SkDebugf("Could not invert viewmatrix\n"); | |
| } | |
| fInitialX = x; | |
| fInitialY = y; | |
| // make sure all initial subruns have the correct VM and X/Y applied | |
| for (int i = 0; i < fRunCount; i++) { | |
| fRuns[i].fSubRunInfo[0].init(fInitialViewMatrix, x, y); | |
| } | |
| } | |
| /* | |
| * 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() | |
| : fInitialized(false) | |
| , fDrawAsPaths(false) { | |
| // 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) | |
| , fColor(GrColor_ILLEGAL) | |
| , fMaskFormat(kA8_GrMaskFormat) | |
| , fDrawAsDistanceFields(false) | |
| , fUseLCDText(false) { | |
| fVertexBounds.setLargestInverted(); | |
| } | |
| SubRunInfo(const SubRunInfo& that) | |
| : fBulkUseToken(that.fBulkUseToken) | |
| , fStrike(SkSafeRef(that.fStrike.get())) | |
| , fCurrentViewMatrix(that.fCurrentViewMatrix) | |
| , fVertexBounds(that.fVertexBounds) | |
| , fAtlasGeneration(that.fAtlasGeneration) | |
| , fVertexStartIndex(that.fVertexStartIndex) | |
| , fVertexEndIndex(that.fVertexEndIndex) | |
| , fGlyphStartIndex(that.fGlyphStartIndex) | |
| , fGlyphEndIndex(that.fGlyphEndIndex) | |
| , fX(that.fX) | |
| , fY(that.fY) | |
| , fColor(that.fColor) | |
| , fMaskFormat(that.fMaskFormat) | |
| , fDrawAsDistanceFields(that.fDrawAsDistanceFields) | |
| , fUseLCDText(that.fUseLCDText) { | |
| } | |
| // TODO when this object is more internal, drop the privacy | |
| void resetBulkUseToken() { fBulkUseToken.reset(); } | |
| GrBatchAtlas::BulkUseTokenUpdater* bulkUseToken() { return &fBulkUseToken; } | |
| void setStrike(GrBatchTextStrike* strike) { fStrike.reset(SkRef(strike)); } | |
| GrBatchTextStrike* strike() const { return fStrike.get(); } | |
| void setAtlasGeneration(uint64_t atlasGeneration) { fAtlasGeneration = atlasGeneration;} | |
| uint64_t atlasGeneration() const { return fAtlasGeneration; } | |
| size_t byteCount() const { return fVertexEndIndex - fVertexStartIndex; } | |
| size_t vertexStartIndex() const { return fVertexStartIndex; } | |
| size_t vertexEndIndex() const { return fVertexEndIndex; } | |
| void appendVertices(size_t vertexStride) { | |
| fVertexEndIndex += vertexStride * kVerticesPerGlyph; | |
| } | |
| uint32_t glyphCount() const { return fGlyphEndIndex - fGlyphStartIndex; } | |
| uint32_t glyphStartIndex() const { return fGlyphStartIndex; } | |
| uint32_t glyphEndIndex() const { return fGlyphEndIndex; } | |
| void glyphAppended() { fGlyphEndIndex++; } | |
| void setColor(GrColor color) { fColor = color; } | |
| GrColor color() const { return fColor; } | |
| void setMaskFormat(GrMaskFormat format) { fMaskFormat = format; } | |
| GrMaskFormat maskFormat() const { return fMaskFormat; } | |
| void setAsSuccessor(const SubRunInfo& prev) { | |
| fGlyphStartIndex = prev.glyphEndIndex(); | |
| fGlyphEndIndex = prev.glyphEndIndex(); | |
| fVertexStartIndex = prev.vertexEndIndex(); | |
| fVertexEndIndex = prev.vertexEndIndex(); | |
| // copy over viewmatrix settings | |
| this->init(prev.fCurrentViewMatrix, prev.fX, prev.fY); | |
| } | |
| const SkRect& vertexBounds() const { return fVertexBounds; } | |
| void joinGlyphBounds(const SkRect& glyphBounds) { | |
| fVertexBounds.joinNonEmptyArg(glyphBounds); | |
| } | |
| void init(const SkMatrix& viewMatrix, SkScalar x, SkScalar y) { | |
| fCurrentViewMatrix = viewMatrix; | |
| fX = x; | |
| fY = y; | |
| } | |
| // This function assumes the translation will be applied before it is called again | |
| void computeTranslation(const SkMatrix& viewMatrix, SkScalar x, SkScalar y, | |
| SkScalar*transX, SkScalar* transY); | |
| // df properties | |
| void setUseLCDText(bool useLCDText) { fUseLCDText = useLCDText; } | |
| bool hasUseLCDText() const { return fUseLCDText; } | |
| void setDrawAsDistanceFields() { fDrawAsDistanceFields = true; } | |
| bool drawAsDistanceFields() const { return fDrawAsDistanceFields; } | |
| private: | |
| GrBatchAtlas::BulkUseTokenUpdater fBulkUseToken; | |
| SkAutoTUnref<GrBatchTextStrike> fStrike; | |
| SkMatrix fCurrentViewMatrix; | |
| SkRect fVertexBounds; | |
| uint64_t fAtlasGeneration; | |
| size_t fVertexStartIndex; | |
| size_t fVertexEndIndex; | |
| uint32_t fGlyphStartIndex; | |
| uint32_t fGlyphEndIndex; | |
| SkScalar fX; | |
| SkScalar fY; | |
| GrColor fColor; | |
| GrMaskFormat fMaskFormat; | |
| bool fDrawAsDistanceFields; // df property | |
| bool fUseLCDText; // df property | |
| }; | |
| SubRunInfo& push_back() { | |
| // Forward glyph / vertex information to seed the new sub run | |
| SubRunInfo& newSubRun = fSubRunInfo.push_back(); | |
| const SubRunInfo& prevSubRun = fSubRunInfo.fromBack(1); | |
| newSubRun.setAsSuccessor(prevSubRun); | |
| return newSubRun; | |
| } | |
| static const int kMinSubRuns = 1; | |
| SkAutoTUnref<SkTypeface> fTypeface; | |
| SkSTArray<kMinSubRuns, SubRunInfo> fSubRunInfo; | |
| SkAutoDescriptor fDescriptor; | |
| // Effects from the paint that are used to build a SkScalerContext. | |
| sk_sp<SkPathEffect> fPathEffect; | |
| sk_sp<SkRasterizer> fRasterizer; | |
| sk_sp<SkMaskFilter> fMaskFilter; | |
| // 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-nullptr, then it | |
| // will be used in place of the run's descriptor to regen texture coords | |
| SkAutoTDelete<SkAutoDescriptor> fOverrideDescriptor; // df properties | |
| bool fInitialized; | |
| 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, | |
| SkAutoGlyphCache*, 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, | |
| const SkMatrix& viewMatrix, SkScalar x, SkScalar y, | |
| GrColor color, | |
| const SkPaint& skPaint, const SkSurfaceProps& props, | |
| const GrDistanceFieldAdjustTable* distanceAdjustTable, | |
| bool useGammaCorrectDistanceTable, | |
| GrBatchFontCache* cache); | |
| struct BigGlyph { | |
| BigGlyph(const SkPath& path, SkScalar vx, SkScalar vy, SkScalar scale, bool applyVM) | |
| : fPath(path) | |
| , fScale(scale) | |
| , fX(vx) | |
| , fY(vy) | |
| , fApplyVM(applyVM) {} | |
| SkPath fPath; | |
| SkScalar fScale; | |
| SkScalar fX; | |
| SkScalar fY; | |
| bool fApplyVM; | |
| }; | |
| 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 fInitialViewMatrix; | |
| SkMatrix fInitialViewMatrixInverse; | |
| size_t fSize; | |
| GrColor fPaintColor; | |
| SkScalar fInitialX; | |
| SkScalar fInitialY; | |
| // 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; | |
| }; | |
| #endif |