impeller::TextShadowCache Class Reference

A cache for blurred text that re-uses these across frames. More...

#include <text_shadow_cache.h>

Classes
struct	TextShadowCacheKey
	A key to look up cached glyph textures. More...

Public Member Functions
	TextShadowCache ()=default
	~TextShadowCache ()=default
void	MarkFrameStart ()
	Mark all glyph textures as unused this frame. More...
void	MarkFrameEnd ()
	Remove all glyph textures that were not referenced at least once. More...
std::optional< Entity >	Lookup (const ContentContext &renderer, const Entity &entity, const std::shared_ptr< FilterContents > &contents, const TextShadowCacheKey &)
	Lookup the entity in the cache with the given filter/text contents, returning the new entity to render. More...
size_t	GetCacheSizeForTesting () const

Detailed Description

A cache for blurred text that re-uses these across frames.

Text shadows are generally stable, but expensive to compute as we use a full gaussian blur. This class caches these shadows by text blob identifier and holds them for at least one frame.

Additionally, there is an optimization for a single glyph (generally an Icon) that uses the content itself as a key.

If there was a cheaper method of text frame identity, or a per-glyph caching system this could be more efficient. As it exists, this mostly ameliorate severe performance degradation for glyph shadows but does not provide substantially better performance than Skia.

Definition at line 31 of file text_shadow_cache.h.

Constructor & Destructor Documentation

TextShadowCache()

impeller::TextShadowCache::TextShadowCache ( )

default

~TextShadowCache()

impeller::TextShadowCache::~TextShadowCache ( )

default

Member Function Documentation

GetCacheSizeForTesting()

size_t impeller::TextShadowCache::GetCacheSizeForTesting ( ) const

inline

Definition at line 87 of file text_shadow_cache.h.

{ return entries_.size(); }

Referenced by impeller::testing::TEST_P().

Lookup()

std::optional< Entity > impeller::TextShadowCache::Lookup	(	const ContentContext &	renderer,
		const Entity &	entity,
		const std::shared_ptr< FilterContents > &	contents,
		const TextShadowCacheKey &	text_key
	)

Lookup the entity in the cache with the given filter/text contents, returning the new entity to render.

If the entity is not present, render and place in the cache.

Definition at line 41 of file text_shadow_cache.cc.

                                        {
  auto it = entries_.find(text_key);
 
  if (it != entries_.end()) {
    it->second.used_this_frame = true;
    Entity cache_entity = it->second.entity.Clone();
    cache_entity.SetClipDepth(entity.GetClipDepth());
    cache_entity.SetTransform(entity.GetTransform() * it->second.key_matrix);
    return cache_entity;
  }
 
  std::optional<Rect> filter_coverage = contents->GetCoverage(entity);
  if (!filter_coverage.has_value()) {
    return std::nullopt;
  }
 
  // Execute the filter to produce a snapshot that can be resued on subsequent
  // frames. To prevent this texture from being re-used by the render target
  // cache, we temporarily disable any RT caching.
  renderer.GetRenderTargetCache()->DisableCache();
  fml::ScopedCleanupClosure closure(
      [&] { renderer.GetRenderTargetCache()->EnableCache(); });
  std::optional<Entity> maybe_entity =
      contents->GetEntity(renderer, entity, contents->GetCoverageHint());
  if (!maybe_entity.has_value()) {
    return std::nullopt;
  }
 
  // The original entity has a transform matrix A. The snapshot entity has a
  // transform matrix B. We need a function that converts A to B, so that if we
  // render an entity with a slightly different transform matrix A', it appears
  // in the correct position.
  //   A * K = B
  //   A-1 * A * K = A-1 * B
  //   K = A-1 * B
  //
  // The transform matrix K can be computed by inverse A times B. Multiplying
  // any subsequent entity transforms by this matrix will correctly position
  // them.
  Matrix key_matrix =
      entity.GetTransform().Invert() * maybe_entity->GetTransform();
  entries_[text_key] =
      TextShadowCacheData{.entity = maybe_entity.value().Clone(),
                          .used_this_frame = true,
                          .key_matrix = key_matrix};
 
  maybe_entity->SetClipDepth(entity.GetClipDepth());
  return maybe_entity;
}

References impeller::Entity::Clone(), impeller::Entity::GetClipDepth(), impeller::Entity::GetCoverage(), impeller::ContentContext::GetRenderTargetCache(), impeller::Entity::GetTransform(), impeller::Matrix::Invert(), impeller::Entity::SetClipDepth(), and impeller::Entity::SetTransform().

MarkFrameEnd()

void impeller::TextShadowCache::MarkFrameEnd

(

)

Remove all glyph textures that were not referenced at least once.

Definition at line 36 of file text_shadow_cache.cc.

                                   {
  absl::erase_if(entries_,
                 [](const auto& pair) { return !pair.second.used_this_frame; });
}

MarkFrameStart()

void impeller::TextShadowCache::MarkFrameStart

(

)

Mark all glyph textures as unused this frame.

Definition at line 30 of file text_shadow_cache.cc.

                                     {
  for (auto& entry : entries_) {
    entry.second.used_this_frame = false;
  }
}

Referenced by impeller::DisplayListToTexture(), and impeller::RenderToTarget().

---

The documentation for this class was generated from the following files:

• impeller/entity/contents/text_shadow_cache.h
• impeller/entity/contents/text_shadow_cache.cc