Render: sampleImage and text fonts note the files they read

EvalCtx carries the render's read log. A sampleImage render records its footage
reads, keeps them with its per-thread cached buffer and notes them in the
evaluating render's log on every use. Text notes the font files it is drawn with,
with the identity their bytes were read with; a family that isn't installed, a
fallback or missing glyph, or a font from memory leaves the list incomplete.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
vangel76andClaude Opus 5.5 committed 2026-11-07 01:58:15 +01:00
1 parent 8d948c231c
commit d04ccd5234
38 files changed
+298 -24

No files matched your search

+4 -1
View File
@@ -44,11 +44,14 @@ pub struct EvalCtx<'a> {
/// Media Replacement values overridden by the Essential Properties of a collapsed precomp
/// instance.
pub media_overrides: &'a [crate::MediaOverride],
/// Where the source files of what expressions render (`sampleImage`) are noted: the
/// renderer's [`Renderer::reads`](crate::Renderer::reads) while rendering.
pub reads: Option<&'a crate::reads::ReadLog>,
}
impl<'a> EvalCtx<'a> {
pub fn new(project: &'a Project, comp_id: ItemId, comp: &'a Comp, time: Tick) -> EvalCtx<'a> {
EvalCtx { project, comp_id, comp, time, expr: None, footage: None, property_overrides: &[], media_overrides: &[] }
EvalCtx { project, comp_id, comp, time, expr: None, footage: None, property_overrides: &[], media_overrides: &[], reads: None }
}
pub fn at(&self, time: Tick) -> EvalCtx<'a> {
EvalCtx { time, ..*self }
+21 -2
View File
@@ -140,6 +140,13 @@ impl<'a> Renderer<'a> {
out
}
/// `ctx` noting what it reads (fonts, `sampleImage`) in this render's [`Renderer::reads`]:
/// a context made by an outer render carries that render's log, not the one of the buffer
/// [`Renderer::recorded`] makes.
pub(crate) fn with_reads<'c>(&'c self, ctx: &EvalCtx<'c>) -> EvalCtx<'c> {
EvalCtx { reads: self.reads, ..*ctx }
}
/// The buffer the layer cache keeps under `key`, with the files it was made of noted in
/// [`Renderer::reads`].
pub(crate) fn cached(&self, key: Option<u64>) -> Option<(Arc<Buf>, Arc<ReadFiles>)> {
@@ -422,7 +429,17 @@ impl<'a> Renderer<'a> {
}
pub(crate) fn ctx(&self, comp_id: ItemId, comp: &'a Comp, t: Tick) -> EvalCtx<'a> {
EvalCtx { project: self.project, comp_id, comp, time: t, expr: self.expr, footage: Some(self.footage), property_overrides: &[], media_overrides: &[] }
EvalCtx {
project: self.project,
comp_id,
comp,
time: t,
expr: self.expr,
footage: Some(self.footage),
property_overrides: &[],
media_overrides: &[],
reads: self.reads,
}
}
/// This renderer with another accelerator (or none): the passes of
@@ -831,7 +848,9 @@ impl<'a> Renderer<'a> {
let img = self.footage_frame(ctx, layer, item, pf, lt, size)?;
Some(self.footage_buf(&img, pf, f.width, f.height))
}
LayerSource::Text => Some(self.authored(text::render(ctx, layer, self.raster_scale(ctx, layer)))),
// (the font files go to this render's log, which `ctx` may not carry: see
// [`Renderer::with_reads`])
LayerSource::Text => Some(self.authored(text::render(&self.with_reads(ctx), layer, self.raster_scale(ctx, layer)))),
LayerSource::Shape => layer.props.sub("contents").map(|c| self.authored(shapes::render(ctx, layer, c, self.raster_scale(ctx, layer)))),
_ => None,
}
+11 -2
View File
@@ -161,8 +161,17 @@ fn referenced_layer_overrides_change_the_owner_cache_key() {
let opacity = comp.layer(aid).unwrap().props.prop("transform/opacity").unwrap().uid;
let key = |value: f64| {
let overrides = [crate::PropertyOverride { layer: aid, prop: opacity, value: Value::Scalar(value), font: false }];
let ctx =
EvalCtx { project: &p, comp_id: cid, comp, time: Tick::ZERO, expr: None, footage: None, property_overrides: &overrides, media_overrides: &[] };
let ctx = EvalCtx {
project: &p,
comp_id: cid,
comp,
time: Tick::ZERO,
expr: None,
footage: None,
property_overrides: &overrides,
media_overrides: &[],
reads: None,
};
crate::cache::layer_key(&ctx, b, 1.0, false, false)
};
let (opaque, half) = (key(100.0), key(50.0));
+1
View File
@@ -143,6 +143,7 @@ fn input_keys_ignore_later_effects() {
footage: None,
property_overrides: &[],
media_overrides: &[],
reads: None,
};
let l = &comp.layers[0];
(crate::cache::input_key(&ctx, l, 1.0, false, false, 1), crate::cache::input_key(&ctx, l, 1.0, false, false, 2))
+39
View File
@@ -638,11 +638,49 @@ fn align_index(j: Justify) -> u8 {
}
}
/// Note the font files `lay` is drawn with in [`EvalCtx::reads`] (#3184), each with its identity
/// as its bytes were read, so a cache entry of the text is checked against them. What the
/// files can't vouch for makes the list incomplete: a family that is not installed (installing
/// it changes the text), a character drawn with a fallback face or with none (another installed
/// font could take it), a font from memory.
fn note_fonts(ctx: &EvalCtx, lay: &TextLayout) {
use crate::reads::{FileStamp, ReadFile};
use effectcraft_text::fonts;
let Some(log) = ctx.reads else { return };
let resolved: Vec<fonts::Resolved> = lay.styles.iter().map(|s| fonts::resolve(&s.font, &s.style)).collect();
if resolved.iter().any(|r| r.missing) {
log.mark_incomplete();
}
let mut faces: Vec<fonts::FaceId> = Vec::new();
for g in &lay.layout.glyphs {
if g.id == 0 || resolved.get(g.run).is_none_or(|r| r.face != g.face) {
log.mark_incomplete();
}
if !faces.contains(&g.face) {
faces.push(g.face);
}
}
for id in faces {
let face = fonts::face(id);
match &face.info.data {
fonts::FaceData::Static(_) => {}
fonts::FaceData::Shared(_) => log.mark_incomplete(),
fonts::FaceData::File(_) => {
if let Some((path, meta)) = face.file_read() {
let stamp = meta.map_or(FileStamp::Missing, FileStamp::of_metadata);
log.note(ReadFile::new(path.to_string_lossy().as_ref(), stamp));
}
}
}
}
}
/// Lay out and animate a text layer.
pub fn text_geom(ctx: &EvalCtx, layer: &Layer) -> Option<TextGeom> {
let doc = source_text(ctx, layer)?;
let text = layer.props.sub("text")?;
let lay = layout_doc(&doc);
note_fonts(ctx, &lay);
let xfs = char_transforms(ctx, layer, text, &lay);
let three = per_char_3d(ctx, layer);
let more = text.sub("moreOptions");
@@ -665,6 +703,7 @@ pub fn text_geom(ctx: &EvalCtx, layer: &Layer) -> Option<TextGeom> {
// Same character count: the style runs still line up.
let d2 = TextDoc { text: chars.into_iter().collect(), ..doc.clone() };
let l2 = layout_doc(&d2);
note_fonts(ctx, &l2);
let by_char: std::collections::HashMap<usize, CharXf> = lay.glyphs.iter().zip(&xfs).map(|(g, x)| (g.char_index, *x)).collect();
let x2: Vec<CharXf> = l2.glyphs.iter().map(|g| by_char.get(&g.char_index).copied().unwrap_or_default()).collect();
subs = vec![None; l2.glyphs.len()];
+55
View File
@@ -715,3 +715,58 @@ fn range_bar_drag_values() {
assert_eq!(range_value_of(3.6 / 7.0, 0.0, true, 7), 4.0);
assert_eq!(range_value_of(3.6 / 7.0, 2.0 / 7.0, true, 7), 2.0, "less a 2-character Offset");
}
/// Text names the font files it is drawn with (#3184), with their identity as they were read, so
/// a cache entry of it is checked against them; what the files can't vouch for (a family that
/// isn't installed) leaves the list incomplete.
#[test]
fn text_notes_the_font_files_it_draws_with() {
use crate::reads::{FileStamp, ReadLog};
use effectcraft_text::fonts::{self, FaceData, FaceInfo, FontSource};
struct OneFile(std::path::PathBuf);
impl FontSource for OneFile {
fn faces(&self) -> Vec<FaceInfo> {
vec![FaceInfo {
family: "Reads Test Sans".into(),
style: "Regular".into(),
weight: 400,
italic: false,
index: 0,
data: FaceData::File(self.0.clone()),
origin: "system",
native_family: None,
full_name: "Reads Test Sans Regular".into(),
postscript: None,
variable: false,
instances: vec![],
}]
}
}
let dir = std::env::temp_dir().join(format!("effectcraft-font-reads-{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
let font = dir.join("reads-test-sans.ttf");
std::fs::write(&font, fonts::INTER_REGULAR).unwrap();
fonts::add_source(&OneFile(font.clone()));
let stamp = FileStamp::native(&font.to_string_lossy()).unwrap();
let files_of = |family: &str| {
let (mut p, cid, comp) = setup(200, 80);
let l =
text_layer(&mut p, &comp, TextDoc { text: "Hi there\rtwo".into(), font: family.into(), style: "Regular".into(), size: 30.0, ..Default::default() });
p.comp_mut(cid).unwrap().layers.push(l);
let log = ReadLog::new();
let c = EvalCtx { reads: Some(&log), ..ctx(&p, cid, 0.0) };
assert!(text_geom(&c, &p.comp(cid).unwrap().layers[0]).is_some());
log.into_files()
};
let files = files_of("Reads Test Sans");
assert!(files.is_complete(), "{files:?}");
assert_eq!(files.files().len(), 1, "{files:?}");
assert_eq!(files.get(&font.to_string_lossy()), Some(stamp));
// The bundled family reads no file.
let files = files_of(effectcraft_text::fonts::DEFAULT_FAMILY);
assert!(files.is_complete() && files.is_empty(), "{files:?}");
// A family that isn't installed falls back: installing it would change the text.
assert!(!files_of("No Such Family 3184").is_complete());
let _ = std::fs::remove_dir_all(&dir);
}
+2 -2
View File
@@ -656,7 +656,7 @@ fn extruded_layer(r: &Renderer, ctx: &EvalCtx, layer: &Layer, p: &model::extrude
let opacity = (ctx.opacity(layer) as f32 * r.opacity_mul()).clamp(0.0, 1.0);
let world = b.outer * ctx.world_matrix(layer);
let lin = b.s.linear_io;
for (mesh, c, local) in extruded_meshes(ctx, layer, p) {
for (mesh, c, local) in extruded_meshes(&r.with_reads(ctx), layer, p) {
let l = |v: f32| if lin { v } else { srgb_to_linear(v) };
let m = b.material(Material {
base: [l(c[0]), l(c[1]), l(c[2]), c[3]],
@@ -699,7 +699,7 @@ fn card_layer(r: &Renderer, ctx: &EvalCtx, layer: &Layer, b: &mut Builder) {
mat.opacity = (ctx.opacity(layer) as f32 * r.opacity_mul()).clamp(0.0, 1.0);
let world = b.outer * ctx.world_matrix(layer);
if crate::text::per_char_3d(ctx, layer) {
for (buf, m) in crate::text::per_char_planes(ctx, layer, r.opts.scale) {
for (buf, m) in crate::text::per_char_planes(&r.with_reads(ctx), layer, r.opts.scale) {
let buf = r.to_blend(Arc::new(buf), None, &Arc::default());
card(b, &buf, world * m, mat);
}
+4
View File
@@ -822,6 +822,7 @@ fn extruded_text_renders_as_a_mesh() {
footage: None,
property_overrides: &[],
media_overrides: &[],
reads: None,
};
let l = &ctx.comp.layers[0];
let params = scene::extrusion_params(&ctx, l).unwrap();
@@ -870,6 +871,7 @@ fn shape_surface_items_colour_the_extruded_surfaces() {
footage: None,
property_overrides: &[],
media_overrides: &[],
reads: None,
};
let l = &ctx.comp.layers[0];
let params = scene::extrusion_params(&ctx, l).unwrap();
@@ -915,6 +917,7 @@ fn text_animators_colour_the_extruded_surfaces() {
footage: None,
property_overrides: &[],
media_overrides: &[],
reads: None,
};
let l = &ctx.comp.layers[0];
let params = scene::extrusion_params(&ctx, l).unwrap();
@@ -1122,6 +1125,7 @@ fn extruded_strokes_render_as_bevelled_meshes() {
footage: None,
property_overrides: &[],
media_overrides: &[],
reads: None,
};
let l = &ctx.comp.layers[0];
let params = scene::extrusion_params(&ctx, l).unwrap();
+1 -1
View File
@@ -203,7 +203,7 @@ pub(crate) fn prepare<'a>(r: &Renderer, ctx: &EvalCtx<'_>, layer: &'a Layer, ord
/// Prepare a layer as planes: one per character for per-character 3D text, else one.
pub(crate) fn prepare_all<'a>(r: &Renderer, ctx: &EvalCtx<'_>, layer: &'a Layer, order: usize, out: (u32, u32), in_run: bool) -> Vec<Item<'a>> {
if crate::text::per_char_3d(ctx, layer) {
return crate::text::per_char_planes(ctx, layer, r.opts.scale)
return crate::text::per_char_planes(&r.with_reads(ctx), layer, r.opts.scale)
.into_iter()
.filter_map(|(buf, m)| {
prepare_with(r, ctx, layer, order, out, in_run, PlaneInput { buf: r.to_blend(Arc::new(buf), None, &Arc::default()), local: m })