"$_src/gpu/instanced/GLInstancedRendering.h",
# text
+ "$_src/gpu/text/GrAtlasGlyphCache.cpp",
+ "$_src/gpu/text/GrAtlasGlyphCache.h",
"$_src/gpu/text/GrAtlasTextBlob.cpp",
"$_src/gpu/text/GrAtlasTextBlob_regenInBatch.cpp",
"$_src/gpu/text/GrAtlasTextBlob.h",
"$_src/gpu/text/GrAtlasTextContext.cpp",
"$_src/gpu/text/GrAtlasTextContext.h",
- "$_src/gpu/text/GrBatchFontCache.cpp",
- "$_src/gpu/text/GrBatchFontCache.h",
"$_src/gpu/text/GrDistanceFieldAdjustTable.cpp",
"$_src/gpu/text/GrDistanceFieldAdjustTable.h",
"$_src/gpu/text/GrStencilAndCoverTextContext.cpp",
#include "../private/GrAuditTrail.h"
#include "../private/GrSingleOwner.h"
+class GrAtlasGlyphCache;
struct GrBatchAtlasConfig;
-class GrBatchFontCache;
struct GrContextOptions;
class GrContextPriv;
class GrContextThreadSafeProxy;
// Functions intended for internal use only.
GrGpu* getGpu() { return fGpu; }
const GrGpu* getGpu() const { return fGpu; }
- GrBatchFontCache* getBatchFontCache() { return fBatchFontCache; }
+ GrAtlasGlyphCache* getAtlasGlyphCache() { return fAtlasGlyphCache; }
GrTextBlobCache* getTextBlobCache() { return fTextBlobCache.get(); }
bool abandoned() const;
GrResourceProvider* resourceProvider() { return fResourceProvider; }
sk_sp<GrContextThreadSafeProxy> fThreadSafeProxy;
- GrBatchFontCache* fBatchFontCache;
+ GrAtlasGlyphCache* fAtlasGlyphCache;
std::unique_ptr<GrTextBlobCache> fTextBlobCache;
bool fDidTestPMConversions;
fCaps = nullptr;
fResourceCache = nullptr;
fResourceProvider = nullptr;
- fBatchFontCache = nullptr;
+ fAtlasGlyphCache = nullptr;
}
bool GrContext::init(GrBackend backend, GrBackendContext backendContext,
fDrawingManager.reset(new GrDrawingManager(this, rtOpListOptions, prcOptions,
options.fImmediateMode, &fSingleOwner));
- // GrBatchFontCache will eventually replace GrFontCache
- fBatchFontCache = new GrBatchFontCache(this);
+ fAtlasGlyphCache = new GrAtlasGlyphCache(this);
fTextBlobCache.reset(new GrTextBlobCache(TextBlobCacheOverBudgetCB, this));
}
delete fResourceProvider;
delete fResourceCache;
- delete fBatchFontCache;
+ delete fAtlasGlyphCache;
fGpu->unref();
fCaps->unref();
fGpu->disconnect(GrGpu::DisconnectType::kAbandon);
- fBatchFontCache->freeAll();
+ fAtlasGlyphCache->freeAll();
fTextBlobCache->freeAll();
}
fGpu->disconnect(GrGpu::DisconnectType::kCleanup);
- fBatchFontCache->freeAll();
+ fAtlasGlyphCache->freeAll();
fTextBlobCache->freeAll();
}
this->flush();
- fBatchFontCache->freeAll();
+ fAtlasGlyphCache->freeAll();
fDrawingManager->freeGpuResources();
#include "effects/GrBitmapTextGeoProc.h"
#include "effects/GrDistanceFieldGeoProc.h"
-#include "text/GrBatchFontCache.h"
+#include "text/GrAtlasGlyphCache.h"
///////////////////////////////////////////////////////////////////////////////////////////////////
};
static sk_sp<GrAtlasTextOp> MakeBitmap(GrMaskFormat maskFormat, int glyphCount,
- GrBatchFontCache* fontCache) {
+ GrAtlasGlyphCache* fontCache) {
sk_sp<GrAtlasTextOp> op(new GrAtlasTextOp);
op->fFontCache = fontCache;
}
static sk_sp<GrAtlasTextOp> MakeDistanceField(
- int glyphCount, GrBatchFontCache* fontCache,
+ int glyphCount, GrAtlasGlyphCache* fontCache,
const GrDistanceFieldAdjustTable* distanceAdjustTable,
bool useGammaCorrectDistanceTable, SkColor filteredColor, bool isLCD, bool useBGR) {
sk_sp<GrAtlasTextOp> op(new GrAtlasTextOp);
} fMaskType;
bool fUseBGR; // fold this into the enum?
- GrBatchFontCache* fFontCache;
+ GrAtlasGlyphCache* fFontCache;
// Distance field properties
sk_sp<const GrDistanceFieldAdjustTable> fDistanceAdjustTable;
* found in the LICENSE file.
*/
-#include "GrBatchFontCache.h"
+#include "GrAtlasGlyphCache.h"
#include "GrContext.h"
#include "GrGpu.h"
#include "GrRectanizer.h"
#include "SkDistanceFieldGen.h"
-bool GrBatchFontCache::initAtlas(GrMaskFormat format) {
+bool GrAtlasGlyphCache::initAtlas(GrMaskFormat format) {
int index = MaskFormatToAtlasIndex(format);
if (!fAtlases[index]) {
GrPixelConfig config = MaskFormatToPixelConfig(format, *fContext->caps());
int numPlotsX = fAtlasConfigs[index].numPlotsX();
int numPlotsY = fAtlasConfigs[index].numPlotsY();
- fAtlases[index] = fContext->resourceProvider()->makeAtlas(config, width, height,
- numPlotsX, numPlotsY,
- &GrBatchFontCache::HandleEviction,
- (void*)this);
+ fAtlases[index] = fContext->resourceProvider()->makeAtlas(
+ config, width, height, numPlotsX, numPlotsY, &GrAtlasGlyphCache::HandleEviction,
+ (void*)this);
if (!fAtlases[index]) {
return false;
}
return true;
}
-GrBatchFontCache::GrBatchFontCache(GrContext* context)
+GrAtlasGlyphCache::GrAtlasGlyphCache(GrContext* context)
: fContext(context)
, fPreserveStrike(nullptr) {
fAtlasConfigs[kARGB_GrMaskFormat].fPlotHeight = 256;
}
-GrBatchFontCache::~GrBatchFontCache() {
+GrAtlasGlyphCache::~GrAtlasGlyphCache() {
StrikeHash::Iter iter(&fCache);
while (!iter.done()) {
(*iter).fIsAbandoned = true;
}
}
-void GrBatchFontCache::freeAll() {
+void GrAtlasGlyphCache::freeAll() {
StrikeHash::Iter iter(&fCache);
while (!iter.done()) {
(*iter).fIsAbandoned = true;
}
}
-void GrBatchFontCache::HandleEviction(GrBatchAtlas::AtlasID id, void* ptr) {
- GrBatchFontCache* fontCache = reinterpret_cast<GrBatchFontCache*>(ptr);
+void GrAtlasGlyphCache::HandleEviction(GrBatchAtlas::AtlasID id, void* ptr) {
+ GrAtlasGlyphCache* fontCache = reinterpret_cast<GrAtlasGlyphCache*>(ptr);
StrikeHash::Iter iter(&fontCache->fCache);
for (; !iter.done(); ++iter) {
- GrBatchTextStrike* strike = &*iter;
+ GrAtlasTextStrike* strike = &*iter;
strike->removeID(id);
// clear out any empty strikes. We will preserve the strike whose call to addToAtlas
// triggered the eviction
if (strike != fontCache->fPreserveStrike && 0 == strike->fAtlasedGlyphs) {
- fontCache->fCache.remove(GrBatchTextStrike::GetKey(*strike));
+ fontCache->fCache.remove(GrAtlasTextStrike::GetKey(*strike));
strike->fIsAbandoned = true;
strike->unref();
}
return true;
}
-void GrBatchFontCache::dump() const {
+void GrAtlasGlyphCache::dump() const {
static int gDumpCount = 0;
for (int i = 0; i < kMaskFormatCount; ++i) {
if (fAtlases[i]) {
}
#endif
-void GrBatchFontCache::setAtlasSizes_ForTesting(const GrBatchAtlasConfig configs[3]) {
+void GrAtlasGlyphCache::setAtlasSizes_ForTesting(const GrBatchAtlasConfig configs[3]) {
// Delete any old atlases.
// This should be safe to do as long as we are not in the middle of a flush.
for (int i = 0; i < kMaskFormatCount; i++) {
atlas and a position within that texture.
*/
-GrBatchTextStrike::GrBatchTextStrike(GrBatchFontCache* owner, const SkDescriptor& key)
+GrAtlasTextStrike::GrAtlasTextStrike(GrAtlasGlyphCache* owner, const SkDescriptor& key)
: fFontScalerKey(key)
, fPool(9/*start allocations at 512 bytes*/)
- , fBatchFontCache(owner) // no need to ref, it won't go away before we do
+ , fAtlasGlyphCache(owner) // no need to ref, it won't go away before we do
, fAtlasedGlyphs(0)
, fIsAbandoned(false) {}
-GrBatchTextStrike::~GrBatchTextStrike() {
+GrAtlasTextStrike::~GrAtlasTextStrike() {
SkTDynamicHash<GrGlyph, GrGlyph::PackedID>::Iter iter(&fCache);
while (!iter.done()) {
(*iter).reset();
}
}
-GrGlyph* GrBatchTextStrike::generateGlyph(const SkGlyph& skGlyph, GrGlyph::PackedID packed,
+GrGlyph* GrAtlasTextStrike::generateGlyph(const SkGlyph& skGlyph, GrGlyph::PackedID packed,
SkGlyphCache* cache) {
SkIRect bounds;
if (GrGlyph::kDistance_MaskStyle == GrGlyph::UnpackMaskStyle(packed)) {
return glyph;
}
-void GrBatchTextStrike::removeID(GrBatchAtlas::AtlasID id) {
+void GrAtlasTextStrike::removeID(GrBatchAtlas::AtlasID id) {
SkTDynamicHash<GrGlyph, GrGlyph::PackedID>::Iter iter(&fCache);
while (!iter.done()) {
if (id == (*iter).fID) {
}
}
-bool GrBatchTextStrike::addGlyphToAtlas(GrDrawOp::Target* target,
+bool GrAtlasTextStrike::addGlyphToAtlas(GrDrawOp::Target* target,
GrGlyph* glyph,
SkGlyphCache* cache,
GrMaskFormat expectedMaskFormat) {
}
}
- bool success = fBatchFontCache->addToAtlas(this, &glyph->fID, target, expectedMaskFormat,
+ bool success = fAtlasGlyphCache->addToAtlas(this, &glyph->fID, target, expectedMaskFormat,
glyph->width(), glyph->height(),
storage.get(), &glyph->fAtlasLocation);
if (success) {
* found in the LICENSE file.
*/
-#ifndef GrBatchFontCache_DEFINED
-#define GrBatchFontCache_DEFINED
+#ifndef GrAtlasGlyphCache_DEFINED
+#define GrAtlasGlyphCache_DEFINED
#include "GrBatchAtlas.h"
#include "GrCaps.h"
#include "SkTDynamicHash.h"
#include "SkVarAlloc.h"
-class GrBatchFontCache;
+class GrAtlasGlyphCache;
class GrGpu;
/**
- * The GrBatchTextStrike manages a pool of CPU backing memory for GrGlyphs. This backing memory
+ * The GrAtlasTextStrike manages a pool of CPU backing memory for GrGlyphs. This backing memory
* is indexed by a PackedID and SkGlyphCache. The SkGlyphCache is what actually creates the mask.
- * The GrBatchTextStrike may outlive the generating SkGlyphCache. However, it retains a copy
- * of it's SkDescriptor as a key to access (or regenerate) the SkGlyphCache. GrBatchTextStrikes are
- * created by and owned by a GrBatchFontCache.
+ * The GrAtlasTextStrike may outlive the generating SkGlyphCache. However, it retains a copy
+ * of it's SkDescriptor as a key to access (or regenerate) the SkGlyphCache. GrAtlasTextStrike are
+ * created by and owned by a GrAtlasGlyphCache.
*/
-class GrBatchTextStrike : public SkNVRefCnt<GrBatchTextStrike> {
+class GrAtlasTextStrike : public SkNVRefCnt<GrAtlasTextStrike> {
public:
/** Owner is the cache that owns this strike. */
- GrBatchTextStrike(GrBatchFontCache* owner, const SkDescriptor& fontScalerKey);
- ~GrBatchTextStrike();
+ GrAtlasTextStrike(GrAtlasGlyphCache* owner, const SkDescriptor& fontScalerKey);
+ ~GrAtlasTextStrike();
inline GrGlyph* getGlyph(const SkGlyph& skGlyph, GrGlyph::PackedID packed,
SkGlyphCache* cache) {
return glyph;
}
- // This variant of the above function is called by TextBatch. At this point, it is possible
+ // This variant of the above function is called by GrAtlasTextOp. At this point, it is possible
// that the maskformat of the glyph differs from what we expect. In these cases we will just
// draw a clear square.
// skbug:4143 crbug:510931
// If a TextStrike is abandoned by the cache, then the caller must get a new strike
bool isAbandoned() const { return fIsAbandoned; }
- static const SkDescriptor& GetKey(const GrBatchTextStrike& ts) {
+ static const SkDescriptor& GetKey(const GrAtlasTextStrike& ts) {
return *ts.fFontScalerKey.getDesc();
}
SkAutoDescriptor fFontScalerKey;
SkVarAlloc fPool;
- GrBatchFontCache* fBatchFontCache;
+ GrAtlasGlyphCache* fAtlasGlyphCache;
int fAtlasedGlyphs;
bool fIsAbandoned;
GrGlyph* generateGlyph(const SkGlyph&, GrGlyph::PackedID, SkGlyphCache*);
- friend class GrBatchFontCache;
+ friend class GrAtlasGlyphCache;
};
/*
- * GrBatchFontCache manages strikes which are indexed by a SkGlyphCache. These strikes can then be
- * used to individual Glyph Masks. The GrBatchFontCache also manages GrBatchAtlases, though this is
- * more or less transparent to the client(aside from atlasGeneration, described below).
- * Note - we used to initialize the backing atlas for the GrBatchFontCache at initialization time.
- * However, this caused a regression, even when the GrBatchFontCache was unused. We now initialize
- * the backing atlases lazily. Its not immediately clear why this improves the situation.
+ * GrAtlasGlyphCache manages strikes which are indexed by a SkGlyphCache. These strikes can then be
+ * used to generate individual Glyph Masks. The GrAtlasGlyphCache also manages GrBatchAtlases,
+ * though this is more or less transparent to the client(aside from atlasGeneration, described
+ * below).
*/
-class GrBatchFontCache {
+class GrAtlasGlyphCache {
public:
- GrBatchFontCache(GrContext*);
- ~GrBatchFontCache();
+ GrAtlasGlyphCache(GrContext*);
+ ~GrAtlasGlyphCache();
// The user of the cache may hold a long-lived ref to the returned strike. However, actions by
// another client of the cache may cause the strike to be purged while it is still reffed.
- // Therefore, the caller must check GrBatchTextStrike::isAbandoned() if there are other
+ // Therefore, the caller must check GrAtlasTextStrike::isAbandoned() if there are other
// interactions with the cache since the strike was received.
- inline GrBatchTextStrike* getStrike(const SkGlyphCache* cache) {
- GrBatchTextStrike* strike = fCache.find(cache->getDescriptor());
+ inline GrAtlasTextStrike* getStrike(const SkGlyphCache* cache) {
+ GrAtlasTextStrike* strike = fCache.find(cache->getDescriptor());
if (nullptr == strike) {
strike = this->generateStrike(cache);
}
void freeAll();
// if texture returns nullptr, the client must not try to use other functions on the
- // GrBatchFontCache which use the atlas. This function *must* be called first, before other
+ // GrAtlasGlyphCache which use the atlas. This function *must* be called first, before other
// functions which use the atlas.
GrTexture* getTexture(GrMaskFormat format) {
if (this->initAtlas(format)) {
}
// To ensure the GrBatchAtlas does not evict the Glyph Mask from its texture backing store,
- // the client must pass in the current batch token along with the GrGlyph.
+ // the client must pass in the current op token along with the GrGlyph.
// A BulkUseTokenUpdater is used to manage bulk last use token updating in the Atlas.
// For convenience, this function will also set the use token for the current glyph if required
// NOTE: the bulk uploader is only valid if the subrun has a valid atlasGeneration
}
// add to texture atlas that matches this format
- bool addToAtlas(GrBatchTextStrike* strike, GrBatchAtlas::AtlasID* id,
+ bool addToAtlas(GrAtlasTextStrike* strike, GrBatchAtlas::AtlasID* id,
GrDrawOp::Target* target,
GrMaskFormat format, int width, int height, const void* image,
SkIPoint16* loc) {
}
// Some clients may wish to verify the integrity of the texture backing store of the
- // GrBatchAtlas. The atlasGeneration returned below is a monitonically increasing number which
- // changes everytime something is removed from the texture backing store.
+ // GrBatchAtlas. The atlasGeneration returned below is a monotonically increasing number which
+ // changes every time something is removed from the texture backing store.
uint64_t atlasGeneration(GrMaskFormat format) const {
return this->getAtlas(format)->atlasGeneration();
}
bool initAtlas(GrMaskFormat);
- GrBatchTextStrike* generateStrike(const SkGlyphCache* cache) {
- GrBatchTextStrike* strike = new GrBatchTextStrike(this, cache->getDescriptor());
+ GrAtlasTextStrike* generateStrike(const SkGlyphCache* cache) {
+ GrAtlasTextStrike* strike = new GrAtlasTextStrike(this, cache->getDescriptor());
fCache.add(strike);
return strike;
}
static void HandleEviction(GrBatchAtlas::AtlasID, void*);
- using StrikeHash = SkTDynamicHash<GrBatchTextStrike, SkDescriptor>;
+ using StrikeHash = SkTDynamicHash<GrAtlasTextStrike, SkDescriptor>;
GrContext* fContext;
StrikeHash fCache;
std::unique_ptr<GrBatchAtlas> fAtlases[kMaskFormatCount];
- GrBatchTextStrike* fPreserveStrike;
+ GrAtlasTextStrike* fPreserveStrike;
GrBatchAtlasConfig fAtlasConfigs[kMaskFormatCount];
};
void GrAtlasTextBlob::appendGlyph(int runIndex,
const SkRect& positions,
GrColor color,
- GrBatchTextStrike* strike,
+ GrAtlasTextStrike* strike,
GrGlyph* glyph,
SkGlyphCache* cache, const SkGlyph& skGlyph,
SkScalar x, SkScalar y, SkScalar scale, bool treatAsBMP) {
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) {
+ bool useGammaCorrectDistanceTable, GrAtlasGlyphCache* cache) {
GrMaskFormat format = info.maskFormat();
GrColor subRunColor;
if (kARGB_GrMaskFormat == format) {
SkScalar y,
const SkPaint& skPaint, const SkSurfaceProps& props,
const GrDistanceFieldAdjustTable* distanceAdjustTable,
- GrBatchFontCache* cache) {
+ GrAtlasGlyphCache* cache) {
for (int subRun = 0; subRun < fRuns[run].fSubRunInfo.count(); subRun++) {
const Run::SubRunInfo& info = fRuns[run].fSubRunInfo[subRun];
int glyphCount = info.glyphCount();
continue;
}
this->flushRun(rtc, grPaint, clip, run, viewMatrix, x, y, skPaint, props,
- distanceAdjustTable, context->getBatchFontCache());
+ distanceAdjustTable, context->getAtlasGlyphCache());
}
// Now flush big glyphs
SkScalar x, SkScalar y) {
for (int run = 0; run < fRunCount; run++) {
this->flushRun(rtc, grPaint, clip, run, viewMatrix, x, y, skPaint, props,
- distanceAdjustTable, context->getBatchFontCache());
+ distanceAdjustTable, context->getAtlasGlyphCache());
}
// Now flush big glyphs
GrColor color, const SkPaint& skPaint,
const SkSurfaceProps& props,
const GrDistanceFieldAdjustTable* distanceAdjustTable,
- GrBatchFontCache* cache) {
+ GrAtlasGlyphCache* cache) {
const GrAtlasTextBlob::Run::SubRunInfo& info = fRuns[run].fSubRunInfo[subRun];
return this->makeOp(info, glyphCount, run, subRun, viewMatrix, x, y, color, skPaint, props,
distanceAdjustTable, false, cache);
if (lSubRun.strike()) {
SkASSERT_RELEASE(rSubRun.strike());
- SkASSERT_RELEASE(GrBatchTextStrike::GetKey(*lSubRun.strike()) ==
- GrBatchTextStrike::GetKey(*rSubRun.strike()));
+ SkASSERT_RELEASE(GrAtlasTextStrike::GetKey(*lSubRun.strike()) ==
+ GrAtlasTextStrike::GetKey(*rSubRun.strike()));
} else {
SkASSERT_RELEASE(!rSubRun.strike());
#ifndef GrAtlasTextBlob_DEFINED
#define GrAtlasTextBlob_DEFINED
+#include "GrAtlasGlyphCache.h"
#include "GrBatchAtlas.h"
-#include "GrBatchFontCache.h"
#include "GrColor.h"
#include "GrMemoryPool.h"
#include "SkDescriptor.h"
void appendGlyph(int runIndex,
const SkRect& positions,
GrColor color,
- GrBatchTextStrike* strike,
+ GrAtlasTextStrike* strike,
GrGlyph* glyph,
SkGlyphCache*, const SkGlyph& skGlyph,
SkScalar x, SkScalar y, SkScalar scale, bool treatAsBMP);
* SkAutoGlyphCache is passed to multiple calls of regenInBatch then it can save the cost of
* multiple detach/attach operations of SkGlyphCache.
*/
- void regenInBatch(GrDrawOp::Target* target, GrBatchFontCache* fontCache,
+ void regenInBatch(GrDrawOp::Target* target, GrAtlasGlyphCache* 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);
SkScalar x, SkScalar y, GrColor color, const SkPaint& skPaint,
const SkSurfaceProps& props,
const GrDistanceFieldAdjustTable* distanceAdjustTable,
- GrBatchFontCache* cache);
+ GrAtlasGlyphCache* cache);
private:
GrAtlasTextBlob()
int run, const SkMatrix& viewMatrix, SkScalar x, SkScalar y,
const SkPaint& skPaint, const SkSurfaceProps& props,
const GrDistanceFieldAdjustTable* distanceAdjustTable,
- GrBatchFontCache* cache);
+ GrAtlasGlyphCache* cache);
void flushBigGlyphs(GrContext* context, GrRenderTargetContext* rtc,
const GrClip& clip, const SkPaint& skPaint,
// 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 setStrike(GrAtlasTextStrike* strike) { fStrike.reset(SkRef(strike)); }
+ GrAtlasTextStrike* strike() const { return fStrike.get(); }
void setAtlasGeneration(uint64_t atlasGeneration) { fAtlasGeneration = atlasGeneration;}
uint64_t atlasGeneration() const { return fAtlasGeneration; }
private:
GrBatchAtlas::BulkUseTokenUpdater fBulkUseToken;
- sk_sp<GrBatchTextStrike> fStrike;
+ sk_sp<GrAtlasTextStrike> fStrike;
SkMatrix fCurrentViewMatrix;
SkRect fVertexBounds;
uint64_t fAtlasGeneration;
};
template <bool regenPos, bool regenCol, bool regenTexCoords, bool regenGlyphs>
- void regenInOp(GrDrawOp::Target* target, GrBatchFontCache* fontCache, GrBlobRegenHelper* helper,
+ void regenInOp(GrDrawOp::Target* target, GrAtlasGlyphCache* fontCache, GrBlobRegenHelper* helper,
Run* run, Run::SubRunInfo* info, SkAutoGlyphCache*, int glyphCount,
size_t vertexStride, GrColor color, SkScalar transX, SkScalar transY) const;
const SkMatrix& viewMatrix, SkScalar x, SkScalar y, GrColor color,
const SkPaint& skPaint, const SkSurfaceProps& props,
const GrDistanceFieldAdjustTable* distanceAdjustTable,
- bool useGammaCorrectDistanceTable, GrBatchFontCache* cache);
+ bool useGammaCorrectDistanceTable, GrAtlasGlyphCache* cache);
struct BigGlyph {
BigGlyph(const SkPath& path, SkScalar vx, SkScalar vy, SkScalar scale, bool treatAsBMP)
}
template <bool regenPos, bool regenCol, bool regenTexCoords, bool regenGlyphs>
-void GrAtlasTextBlob::regenInOp(GrDrawOp::Target* target, GrBatchFontCache* fontCache,
+void GrAtlasTextBlob::regenInOp(GrDrawOp::Target* target, GrAtlasGlyphCache* fontCache,
GrBlobRegenHelper* helper, Run* run, Run::SubRunInfo* info,
SkAutoGlyphCache* lazyCache, int glyphCount, size_t vertexStride,
GrColor color, SkScalar transX, SkScalar transY) const {
SkASSERT(lazyCache);
static_assert(!regenGlyphs || regenTexCoords, "must regenTexCoords along regenGlyphs");
- GrBatchTextStrike* strike = nullptr;
+ GrAtlasTextStrike* strike = nullptr;
if (regenTexCoords) {
info->resetBulkUseToken();
*glyphCount, vertexStride, color, transX, transY
void GrAtlasTextBlob::regenInBatch(GrDrawOp::Target* target,
- GrBatchFontCache* fontCache,
+ GrAtlasGlyphCache* fontCache,
GrBlobRegenHelper *helper,
int runIndex, int subRunIndex, SkAutoGlyphCache* lazyCache,
size_t vertexStride, const SkMatrix& viewMatrix,
SkScalar transX, transY;
info.computeTranslation(viewMatrix, x, y, &transX, &transY);
- // Because the GrBatchFontCache may evict the strike a blob depends on using for
+ // Because the GrAtlasGlyphCache 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.
// but we'd have to clear the subrun information
cache->remove(cacheBlob.get());
cacheBlob.reset(SkRef(cache->createCachedBlob(blob, key, blurRec, skPaint)));
- RegenerateTextBlob(cacheBlob.get(), context->getBatchFontCache(),
+ RegenerateTextBlob(cacheBlob.get(), context->getAtlasGlyphCache(),
*context->caps()->shaderCaps(), skPaint, grPaint.getColor(),
scalerContextFlags, viewMatrix, props,
blob, x, y, drawFilter);
GrTextBlobCache::BlobGlyphCount(&glyphCount, &runCount, blob);
sk_sp<GrAtlasTextBlob> sanityBlob(cache->createBlob(glyphCount, runCount));
sanityBlob->setupKey(key, blurRec, skPaint);
- RegenerateTextBlob(sanityBlob.get(), context->getBatchFontCache(),
+ RegenerateTextBlob(sanityBlob.get(), context->getAtlasGlyphCache(),
*context->caps()->shaderCaps(), skPaint,
grPaint.getColor(), scalerContextFlags, viewMatrix, props,
blob, x, y, drawFilter);
} else {
cacheBlob.reset(cache->createBlob(blob));
}
- RegenerateTextBlob(cacheBlob.get(), context->getBatchFontCache(),
+ RegenerateTextBlob(cacheBlob.get(), context->getAtlasGlyphCache(),
*context->caps()->shaderCaps(), skPaint, grPaint.getColor(),
scalerContextFlags, viewMatrix, props,
blob, x, y, drawFilter);
}
void GrAtlasTextContext::RegenerateTextBlob(GrAtlasTextBlob* cacheBlob,
- GrBatchFontCache* fontCache,
+ GrAtlasGlyphCache* fontCache,
const GrShaderCaps& shaderCaps,
const SkPaint& skPaint, GrColor color,
uint32_t scalerContextFlags,
inline GrAtlasTextBlob*
GrAtlasTextContext::CreateDrawTextBlob(GrTextBlobCache* blobCache,
- GrBatchFontCache* fontCache,
+ GrAtlasGlyphCache* fontCache,
const GrShaderCaps& shaderCaps,
const GrPaint& paint,
const SkPaint& skPaint,
}
inline GrAtlasTextBlob*
-GrAtlasTextContext::CreateDrawPosTextBlob(GrTextBlobCache* blobCache, GrBatchFontCache* fontCache,
+GrAtlasTextContext::CreateDrawPosTextBlob(GrTextBlobCache* blobCache, GrAtlasGlyphCache* fontCache,
const GrShaderCaps& shaderCaps, const GrPaint& paint,
const SkPaint& skPaint, uint32_t scalerContextFlags,
const SkMatrix& viewMatrix, const SkSurfaceProps& props,
return;
} else if (this->canDraw(skPaint, viewMatrix, props, *context->caps()->shaderCaps())) {
sk_sp<GrAtlasTextBlob> blob(
- CreateDrawTextBlob(context->getTextBlobCache(), context->getBatchFontCache(),
+ CreateDrawTextBlob(context->getTextBlobCache(), context->getAtlasGlyphCache(),
*context->caps()->shaderCaps(),
paint, skPaint,
ComputeScalerContextFlags(rtc),
} else if (this->canDraw(skPaint, viewMatrix, props, *context->caps()->shaderCaps())) {
sk_sp<GrAtlasTextBlob> blob(
CreateDrawPosTextBlob(context->getTextBlobCache(),
- context->getBatchFontCache(),
+ context->getAtlasGlyphCache(),
*context->caps()->shaderCaps(),
paint, skPaint,
ComputeScalerContextFlags(rtc),
// intend to test the batch with this unit test, that is okay.
sk_sp<GrAtlasTextBlob> blob(
GrAtlasTextContext::CreateDrawTextBlob(context->getTextBlobCache(),
- context->getBatchFontCache(),
+ context->getAtlasGlyphCache(),
*context->caps()->shaderCaps(), grPaint, skPaint,
GrAtlasTextContext::kTextBlobBatchScalerContextFlags,
viewMatrix,
return blob
->test_makeOp(textLen, 0, 0, viewMatrix, x, y, color, skPaint, gSurfaceProps,
- gTextContext->dfAdjustTable(), context->getBatchFontCache())
+ gTextContext->dfAdjustTable(), context->getAtlasGlyphCache())
.release();
}
// Determines if we need to use fake gamma (and contrast boost):
inline static uint32_t ComputeScalerContextFlags(GrRenderTargetContext*);
static void RegenerateTextBlob(GrAtlasTextBlob* bmp,
- GrBatchFontCache*,
+ GrAtlasGlyphCache*,
const GrShaderCaps&,
const SkPaint& skPaint, GrColor,
uint32_t scalerContextFlags,
inline static bool HasLCD(const SkTextBlob*);
static inline GrAtlasTextBlob* CreateDrawTextBlob(GrTextBlobCache*,
- GrBatchFontCache*, const GrShaderCaps&,
+ GrAtlasGlyphCache*, const GrShaderCaps&,
const GrPaint&,
const SkPaint&,
uint32_t scalerContextFlags,
const SkSurfaceProps&,
const char text[], size_t byteLength,
SkScalar x, SkScalar y);
- static inline GrAtlasTextBlob* CreateDrawPosTextBlob(GrTextBlobCache*, GrBatchFontCache*,
+ static inline GrAtlasTextBlob* CreateDrawPosTextBlob(GrTextBlobCache*, GrAtlasGlyphCache*,
const GrShaderCaps&,
const GrPaint&,
const SkPaint&,
#include "GrTextUtils.h"
+#include "GrAtlasGlyphCache.h"
#include "GrAtlasTextBlob.h"
-#include "GrBatchFontCache.h"
#include "GrBlurUtils.h"
#include "GrCaps.h"
#include "GrContext.h"
};
void GrTextUtils::DrawBmpText(GrAtlasTextBlob* blob, int runIndex,
- GrBatchFontCache* fontCache,
+ GrAtlasGlyphCache* fontCache,
const SkSurfaceProps& props, const SkPaint& skPaint,
GrColor color, uint32_t scalerContextFlags,
const SkMatrix& viewMatrix,
// Ensure the blob is set for bitmaptext
blob->setHasBitmap();
- GrBatchTextStrike* currStrike = nullptr;
+ GrAtlasTextStrike* currStrike = nullptr;
SkGlyphCache* cache = blob->setupCache(runIndex, props, scalerContextFlags, skPaint,
&viewMatrix);
}
void GrTextUtils::DrawBmpPosText(GrAtlasTextBlob* blob, int runIndex,
- GrBatchFontCache* fontCache,
+ GrAtlasGlyphCache* fontCache,
const SkSurfaceProps& props, const SkPaint& skPaint,
GrColor color, uint32_t scalerContextFlags,
const SkMatrix& viewMatrix,
// Ensure the blob is set for bitmaptext
blob->setHasBitmap();
- GrBatchTextStrike* currStrike = nullptr;
+ GrAtlasTextStrike* currStrike = nullptr;
SkGlyphCache* cache = blob->setupCache(runIndex, props, scalerContextFlags, skPaint,
&viewMatrix);
}
void GrTextUtils::BmpAppendGlyph(GrAtlasTextBlob* blob, int runIndex,
- GrBatchFontCache* fontCache,
- GrBatchTextStrike** strike, const SkGlyph& skGlyph,
+ GrAtlasGlyphCache* fontCache,
+ GrAtlasTextStrike** strike, const SkGlyph& skGlyph,
int vx, int vy, GrColor color, SkGlyphCache* cache) {
if (!*strike) {
*strike = fontCache->getStrike(cache);
}
void GrTextUtils::DrawDFText(GrAtlasTextBlob* blob, int runIndex,
- GrBatchFontCache* fontCache, const SkSurfaceProps& props,
+ GrAtlasGlyphCache* fontCache, const SkSurfaceProps& props,
const SkPaint& skPaint, GrColor color, uint32_t scalerContextFlags,
const SkMatrix& viewMatrix,
const char text[], size_t byteLength,
}
void GrTextUtils::DrawDFPosText(GrAtlasTextBlob* blob, int runIndex,
- GrBatchFontCache* fontCache, const SkSurfaceProps& props,
+ GrAtlasGlyphCache* fontCache, const SkSurfaceProps& props,
const SkPaint& origPaint,
GrColor color, uint32_t scalerContextFlags,
const SkMatrix& viewMatrix,
blob->setHasDistanceField();
blob->setSubRunHasDistanceFields(runIndex, origPaint.isLCDRenderText());
- GrBatchTextStrike* currStrike = nullptr;
+ GrAtlasTextStrike* currStrike = nullptr;
// We apply the fake-gamma by altering the distance in the shader, so we ignore the
// passed-in scaler context flags. (It's only used when we fall-back to bitmap text).
}
}
-bool GrTextUtils::DfAppendGlyph(GrAtlasTextBlob* blob, int runIndex, GrBatchFontCache* cache,
- GrBatchTextStrike** strike, const SkGlyph& skGlyph,
+bool GrTextUtils::DfAppendGlyph(GrAtlasTextBlob* blob, int runIndex, GrAtlasGlyphCache* cache,
+ GrAtlasTextStrike** strike, const SkGlyph& skGlyph,
SkScalar sx, SkScalar sy, GrColor color,
SkGlyphCache* glyphCache,
SkScalar textRatio, const SkMatrix& viewMatrix) {
#include "SkPaint.h"
#include "SkScalar.h"
+class GrAtlasGlyphCache;
class GrAtlasTextBlob;
-class GrBatchFontCache;
-class GrBatchTextStrike;
+class GrAtlasTextStrike;
class GrClip;
class GrContext;
class GrRenderTargetContext;
public:
// Functions for appending BMP text to GrAtlasTextBlob
static void DrawBmpText(GrAtlasTextBlob*, int runIndex,
- GrBatchFontCache*, const SkSurfaceProps&,
+ GrAtlasGlyphCache*, const SkSurfaceProps&,
const SkPaint&,
GrColor, uint32_t scalerContextFlags, const SkMatrix& viewMatrix,
const char text[], size_t byteLength,
SkScalar x, SkScalar y);
static void DrawBmpPosText(GrAtlasTextBlob*, int runIndex,
- GrBatchFontCache*, const SkSurfaceProps&, const SkPaint&,
+ GrAtlasGlyphCache*, const SkSurfaceProps&, const SkPaint&,
GrColor, uint32_t scalerContextFlags, const SkMatrix& viewMatrix,
const char text[], size_t byteLength,
const SkScalar pos[], int scalarsPerPosition,
const SkSurfaceProps& props, const GrShaderCaps& caps);
static void DrawDFText(GrAtlasTextBlob* blob, int runIndex,
- GrBatchFontCache*, const SkSurfaceProps&,
+ GrAtlasGlyphCache*, const SkSurfaceProps&,
const SkPaint& skPaint, GrColor color, uint32_t scalerContextFlags,
const SkMatrix& viewMatrix,
const char text[], size_t byteLength,
SkScalar x, SkScalar y);
static void DrawDFPosText(GrAtlasTextBlob* blob, int runIndex,
- GrBatchFontCache*, const SkSurfaceProps&, const SkPaint&,
+ GrAtlasGlyphCache*, const SkSurfaceProps&, const SkPaint&,
GrColor color, uint32_t scalerContextFlags,
const SkMatrix& viewMatrix,
const char text[], size_t byteLength,
SkScalar* textRatio,
const SkMatrix& viewMatrix);
- static void BmpAppendGlyph(GrAtlasTextBlob*, int runIndex, GrBatchFontCache*,
- GrBatchTextStrike**, const SkGlyph&, int left, int top,
+ static void BmpAppendGlyph(GrAtlasTextBlob*, int runIndex, GrAtlasGlyphCache*,
+ GrAtlasTextStrike**, const SkGlyph&, int left, int top,
GrColor color, SkGlyphCache*);
- static bool DfAppendGlyph(GrAtlasTextBlob*, int runIndex, GrBatchFontCache*,
- GrBatchTextStrike**, const SkGlyph&,
+ static bool DfAppendGlyph(GrAtlasTextBlob*, int runIndex, GrAtlasGlyphCache*,
+ GrAtlasTextStrike**, const SkGlyph&,
SkScalar sx, SkScalar sy, GrColor color,
SkGlyphCache* cache,
SkScalar textRatio, const SkMatrix& viewMatrix);
#include "SkMathPriv.h"
#include "SkString.h"
-#include "text/GrBatchFontCache.h"
+#include "text/GrAtlasGlyphCache.h"
#include "text/GrTextBlobCache.h"
namespace GrTest {
}
void GrContext::setTextContextAtlasSizes_ForTesting(const GrBatchAtlasConfig* configs) {
- fBatchFontCache->setAtlasSizes_ForTesting(configs);
+ fAtlasGlyphCache->setAtlasSizes_ForTesting(configs);
}
///////////////////////////////////////////////////////////////////////////////
}
GrTexture* GrContext::getFontAtlasTexture(GrMaskFormat format) {
- GrBatchFontCache* cache = this->getBatchFontCache();
+ GrAtlasGlyphCache* cache = this->getAtlasGlyphCache();
return cache->getTexture(format);
}
projects / platform / upstream / libSkiaSharp.git / commitdiff