blob: 8375d1f19aeacc87fb5c9c150fb03c647eb65c79 [file] [log] [blame]
* 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 GrAtlasGlyphCache_DEFINED
#define GrAtlasGlyphCache_DEFINED
#include "GrDrawOpAtlas.h"
#include "GrGlyph.h"
#include "SkArenaAlloc.h"
#include "SkGlyphCache.h"
#include "SkMasks.h"
#include "SkTDynamicHash.h"
class GrGlyphCache;
class GrAtlasManager;
class GrGpu;
* The GrTextStrike 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 GrTextStrike may outlive the generating SkGlyphCache. However, it retains a copy
* of it's SkDescriptor as a key to access (or regenerate) the SkGlyphCache. GrTextStrikes are
* created by and owned by a GrGlyphCache.
class GrTextStrike : public SkNVRefCnt<GrTextStrike> {
GrTextStrike(const SkDescriptor& fontScalerKey);
inline GrGlyph* getGlyph(const SkGlyph& skGlyph, GrGlyph::PackedID packed,
SkGlyphCache* cache) {
GrGlyph* glyph = fCache.find(packed);
if (!glyph) {
glyph = this->generateGlyph(skGlyph, packed, cache);
return glyph;
// 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
inline GrGlyph* getGlyph(GrGlyph::PackedID packed,
GrMaskFormat expectedMaskFormat,
SkGlyphCache* cache) {
GrGlyph* glyph = fCache.find(packed);
if (!glyph) {
// We could return this to the caller, but in practice it adds code complexity for
// potentially little benefit(ie, if the glyph is not in our font cache, then its not
// in the atlas and we're going to be doing a texture upload anyways).
const SkGlyph& skGlyph = GrToSkGlyph(cache, packed);
glyph = this->generateGlyph(skGlyph, packed, cache);
glyph->fMaskFormat = expectedMaskFormat;
return glyph;
// returns true if glyph successfully added to texture atlas, false otherwise. If the glyph's
// mask format has changed, then addGlyphToAtlas will draw a clear box. This will almost never
// happen.
// TODO we can handle some of these cases if we really want to, but the long term solution is to
// get the actual glyph image itself when we get the glyph metrics.
GrDrawOpAtlas::ErrorCode addGlyphToAtlas(GrResourceProvider*, GrDeferredUploadTarget*,
GrGlyphCache*, GrAtlasManager*, GrGlyph*,
SkGlyphCache*, GrMaskFormat expectedMaskFormat,
bool isScaledGlyph);
// testing
int countGlyphs() const { return fCache.count(); }
// remove any references to this plot
void removeID(GrDrawOpAtlas::AtlasID);
// 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 GrTextStrike& strike) {
return *strike.fFontScalerKey.getDesc();
static uint32_t Hash(const SkDescriptor& desc) { return desc.getChecksum(); }
SkTDynamicHash<GrGlyph, GrGlyph::PackedID> fCache;
SkAutoDescriptor fFontScalerKey;
SkArenaAlloc fPool{512};
int fAtlasedGlyphs;
bool fIsAbandoned;
static const SkGlyph& GrToSkGlyph(SkGlyphCache* cache, GrGlyph::PackedID id) {
return cache->getGlyphIDMetrics(GrGlyph::UnpackID(id),
GrGlyph* generateGlyph(const SkGlyph&, GrGlyph::PackedID, SkGlyphCache*);
friend class GrGlyphCache;
* GrGlyphCache manages strikes which are indexed by a SkGlyphCache. These strikes can then be
* used to generate individual Glyph Masks.
class GrGlyphCache {
GrGlyphCache(const GrCaps* caps, size_t maxTextureBytes);
SkScalar getGlyphSizeLimit() const { return fGlyphSizeLimit; }
void setStrikeToPreserve(GrTextStrike* strike) { fPreserveStrike = strike; }
// 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 GrTextStrike::isAbandoned() if there are other
// interactions with the cache since the strike was received.
inline sk_sp<GrTextStrike> getStrike(const SkGlyphCache* cache) {
sk_sp<GrTextStrike> strike = sk_ref_sp(fCache.find(cache->getDescriptor()));
if (!strike) {
strike = this->generateStrike(cache);
return strike;
const SkMasks& getMasks() const { return *f565Masks; }
void freeAll();
static void HandleEviction(GrDrawOpAtlas::AtlasID, void*);
static SkScalar ComputeGlyphSizeLimit(int maxTextureSize, size_t maxTextureBytes);
sk_sp<GrTextStrike> generateStrike(const SkGlyphCache* cache) {
// 'fCache' get the construction ref
sk_sp<GrTextStrike> strike = sk_ref_sp(new GrTextStrike(cache->getDescriptor()));
return strike;
using StrikeHash = SkTDynamicHash<GrTextStrike, SkDescriptor>;
StrikeHash fCache;
GrTextStrike* fPreserveStrike;
SkScalar fGlyphSizeLimit;
std::unique_ptr<const SkMasks> f565Masks;