Struct SharedText 

pub struct SharedText(/* private fields */);

The device-scoped half of text rendering, shareable across Runners (issue #94): the font system + shaping cache, the CPU-side glyph and MSDF atlases, and their GPU page textures with bind groups. Everything here is independent of the swapchain format and MSAA sample count, so one SharedText per wgpu::Device can back every window — a multi-window host that passes the same handle to each Runner (Runner::with_shared_text) pays glyph rasterization, shaping, warm-up, and atlas VRAM once per device instead of once per window.

Cloning is cheap (an Arc); the inner state is mutex-guarded and locked per record/flush call, so windows can be prepared from one thread in any order. Each attached Runner widens the atlases’ LRU protection window (see MsdfAtlas::set_lru_protection_window) so a page referenced by one window’s in-flight frame can’t be recycled by another’s prepare.

The default Runner constructors create a private SharedText per runner — single-window behavior is unchanged.

Implementations

impl SharedText

pub fn new(device: &Device) -> Self

A fresh shared text pool for device. Pass the same handle to every Runner created on that device. Do not share one SharedText across devices — the page textures belong to the device that created them.

pub fn warm_default_glyphs(&self)

Pre-rasterize printable ASCII for the bundled default faces — see [TextPaint::warm_default_glyphs] for cost and rationale. On a shared pool this runs once per device: warm the pool before (or after) attaching runners, and every attached runner is warm. Runners attached to an already-warm pool skip the cost in their own warm_default_glyphs automatically (rasterized glyphs are cache hits).

pub fn warm_glyphs(&self, families: &[FontFamily], chars: &[char])

Pre-rasterize a chosen set of (family, char) glyphs — the app-selectable counterpart to Self::warm_default_glyphs. Use it to warm fonts you registered yourself, or a glyph set beyond printable ASCII (e.g. the Latin-1 supplement, or the symbols your UI actually shows). MSDF keys are size/weight-independent, so each glyph is rasterized once and reused at every size.

pub fn export_msdf_snapshot(&self) -> Vec<u8>

Serialize the resident outline-glyph atlas into a portable snapshot blob. Glyphs are keyed by a content hash of each font’s bytes, so the blob reloads across runs (and processes) regardless of font-registration order. Persist it however suits the app — embed via include_bytes!, or cache to disk — and reload with Self::import_msdf_snapshot to skip regenerating those glyphs.

This is the app-driven equivalent of the built-in prebaked-default-fonts bake, for fonts damascene can’t bake at its own build time (anything you register_font).

pub fn import_msdf_snapshot(&self, bytes: &[u8]) -> Result<usize, SnapshotError>

Load a snapshot produced by Self::export_msdf_snapshot, resolving each font by content hash against the fonts currently loaded; sections whose font isn’t present are skipped, and already-resident glyphs are left untouched. Returns the number of glyphs loaded, or SnapshotError if the blob is unreadable or its bake parameters don’t match this renderer (in which case nothing is loaded and you should warm live instead).

Trait Implementations

impl Clone for SharedText

fn clone(&self) -> SharedText

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.