Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

perf(rendering): reuse last frame's shaped text when its inputs are unchanged

Richie McIlroy164bfefbb24c
diff --git a/crates/rendering/src/layers/text.rs b/crates/rendering/src/layers/text.rs
index 36611496c..9a58556d9 100644
--- a/crates/rendering/src/layers/text.rs
+++ b/crates/rendering/src/layers/text.rs
@@ -2,7 +2,7 @@ use std::ops::Range;
use bytemuck::{Pod, Zeroable};
use cap_project::{TextAlign, TextBackgroundStyle};
-use glyphon::cosmic_text::Align;
+use glyphon::cosmic_text::{Align, AttrsOwned};
use glyphon::{
Attrs, Buffer, Cache, Color, Family, FontSystem, Metrics, Resolution, Shaping, Style,
SwashCache, TextArea, TextAtlas, TextBounds, TextRenderer, Viewport, Weight,
@@ -12,6 +12,16 @@ use wgpu::{Device, Queue, include_wgsl, util::DeviceExt};
use crate::text::{PreparedText, StaggerEdge, stagger_alpha};
+#[derive(PartialEq)]
+struct ShapeKey {
+ content: String,
+ attrs: AttrsOwned,
+ align: Align,
+ metrics: Metrics,
+ wrap_width: u32,
+ colors: Option<Vec<Color>>,
+}
+
pub struct TextLayer {
font_system: FontSystem,
swash_cache: SwashCache,
@@ -19,6 +29,11 @@ pub struct TextLayer {
text_renderer: TextRenderer,
viewport: Viewport,
buffers: Vec<Buffer>,
+ buffer_keys: Vec<ShapeKey>,
+ // Last frame's shaped buffers. Shaping (with font fallback for emoji and
+ // mixed scripts) dominates a text segment's per-frame cost, and inputs
+ // rarely change between frames, so a buffer with the same key is reused.
+ previous_buffers: Vec<(ShapeKey, Buffer)>,
draws: Vec<TextDraw>,
segment_renderers: Vec<TextRenderer>,
background: Option<TextBackgroundResources>,
@@ -371,6 +386,8 @@ impl TextLayer {
text_renderer,
viewport,
buffers: Vec::new(),
+ buffer_keys: Vec::new(),
+ previous_buffers: Vec::new(),
draws: Vec::new(),
segment_renderers: Vec::new(),
background: None,
@@ -407,6 +424,25 @@ impl TextLayer {
wrap_width: f32,
colors: Option<&[Color]>,
) -> usize {
+ let key = ShapeKey {
+ content: content.to_owned(),
+ attrs: AttrsOwned::new(attrs),
+ align,
+ metrics,
+ wrap_width: wrap_width.to_bits(),
+ colors: colors.map(<[Color]>::to_vec),
+ };
+ if let Some(index) = self
+ .previous_buffers
+ .iter()
+ .position(|(previous, _)| *previous == key)
+ {
+ let (key, buffer) = self.previous_buffers.swap_remove(index);
+ self.buffers.push(buffer);
+ self.buffer_keys.push(key);
+ return self.buffers.len() - 1;
+ }
+
let mut buffer = Buffer::new(&mut self.font_system, metrics);
// The box only constrains wrapping; height is unbounded so every
// line is laid out even when the configured box is a little
@@ -436,6 +472,7 @@ impl TextLayer {
}
buffer.shape_until_scroll(&mut self.font_system, false);
self.buffers.push(buffer);
+ self.buffer_keys.push(key);
self.buffers.len() - 1
}
@@ -447,7 +484,10 @@ impl TextLayer {
texts: &[PreparedText],
force_segmented: bool,
) {
- self.buffers.clear();
+ self.previous_buffers = std::mem::take(&mut self.buffer_keys)
+ .into_iter()
+ .zip(self.buffers.drain(..))
+ .collect();
self.draws.clear();
let mut backgrounds: Vec<TextBackgroundUniforms> = Vec::new();
let output_px = [output_size.0.max(1) as f32, output_size.1.max(1) as f32];
@@ -975,6 +1015,45 @@ mod gpu_tests {
pixels[index..index + 4].try_into().unwrap()
}
+ #[test]
+ #[ignore = "requires a working wgpu adapter"]
+ fn reused_shaping_renders_exactly_like_fresh_shaping_and_follows_edits() {
+ let (device, queue) = device().expect("A working wgpu adapter is required for this test");
+ let mut words = text([4.0, 4.0, 60.0, 60.0], [0.0, 0.0, 0.0, 0.0]);
+ words.background_color = None;
+ words.color = [0.1, 0.2, 0.9, 1.0];
+ words.font_size = 14.0;
+ words.content = "Cap \u{1F4A5} \u{05E9}\u{05DC}\u{05D5}\u{05DD} wraps".to_string();
+ let mut gradient = words.clone();
+ gradient.bounds = [4.0, 34.0, 60.0, 60.0];
+ gradient.gradient_color = Some([0.9, 0.1, 0.1, 1.0]);
+ gradient.shadow = 0.5;
+ let fresh = |texts: &[PreparedText]| {
+ let mut layer = TextLayer::new(&device, &queue);
+ layer.prepare(&device, &queue, (OUTPUT, OUTPUT), texts);
+ render_pixels(&device, &queue, &layer)
+ };
+
+ let mut cached = TextLayer::new(&device, &queue);
+ let frame = [words.clone(), gradient.clone()];
+ cached.prepare(&device, &queue, (OUTPUT, OUTPUT), &frame);
+ cached.prepare(&device, &queue, (OUTPUT, OUTPUT), &frame);
+ assert!(
+ cached.previous_buffers.is_empty(),
+ "every buffer was reused"
+ );
+ let reused = render_pixels(&device, &queue, &cached);
+ assert_eq!(reused, fresh(&frame));
+
+ let mut edited = words.clone();
+ edited.content = "Edited".to_string();
+ let frame = [edited, gradient];
+ cached.prepare(&device, &queue, (OUTPUT, OUTPUT), &frame);
+ let after_edit = render_pixels(&device, &queue, &cached);
+ assert_ne!(after_edit, reused);
+ assert_eq!(after_edit, fresh(&frame));
+ }
+
#[test]
#[ignore = "requires a working wgpu adapter"]
fn text_background_timeline_preserves_order_and_shrinks_without_stale_layers() {