mirror of
https://github.com/storytold/effectcraft.git
synced 2026-11-19 16:45:28 +00:00
Disk cache: the comp key covers what its expressions can read
With an expression anywhere in the project, every comp's disk key hashed
every item of the project, so any edit (another comp, an unused footage
item) threw away every comp's frames on disk. The key now covers what the
comp can draw plus what the expressions among it can reach
(Project::pixel_reach):
- without expressions: the items the comp draws, without silent layers,
plus the footage its precomp layers swap in (Media Replacement);
- with expressions: every layer of the comps they reach, their markers,
the comps and footage they name with string literals (comp("Name"),
footage("Name")) together with which items have those names now, and
the footage named like a reached source (its data is read by name);
- the whole project when an expression computes a name, uses the object
model's constructors or internals, dynamic code, computed keys or
writes, or text the scanner can't read for sure (regex literals,
template strings, escapes): expression_reach errs towards reaching more.
Markers count only where an expression can read them (#1083). Memory
only, no file is looked at.
Tests: scanner and reach unit tests in the project crate; engine tests
for the key (own-comp expressions keep the key through edits elsewhere,
comp("Other") follows Other and not a third comp, a second comp taking
the name counts, a computed name counts every item, markers read from
another comp); a ui-egui test that the disk frames outside an expression
layer are carried when the comp it names changes.
Part of #3184. Part of #1492.
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
2efa859aa9
commit
642fcb7bcb
6 files changed
+774
-29
No files matched your search
@@ -242,3 +242,100 @@ fn protected_markers_with_a_duration_change_the_content_key() {
|
||||
s.execute("markers.set", json!({"comp": inner.0, "index": index, "duration": 2.0})).unwrap();
|
||||
assert_ne!(key(&s), k1, "its duration");
|
||||
}
|
||||
|
||||
/// With expressions the comp key covers what they can read, not the whole project (#3184,
|
||||
/// #1492): an expression reading only its own comp keeps the key through edits of another comp
|
||||
/// and of unused footage; `comp("Other")` makes "Other" count (and which comps have that name),
|
||||
/// not a third comp; a computed name counts every item.
|
||||
#[test]
|
||||
fn expressions_reach_only_what_they_name() {
|
||||
let mut s = Session::default();
|
||||
let comp = |s: &mut Session, name: &str| {
|
||||
let c = s.execute("comp.new", json!({"name": name, "width": 8, "height": 8, "frameRate": 30, "duration": 1})).unwrap()["comp"].as_u64().unwrap();
|
||||
let l = s.execute("layer.newSolid", json!({"comp": c, "color": "#ff0000"})).unwrap()["layer"].as_u64().unwrap();
|
||||
(effectcraft_project::ItemId(c), (c, l))
|
||||
};
|
||||
let (main, ml) = comp(&mut s, "Main");
|
||||
let (_, ol) = comp(&mut s, "Other");
|
||||
let (third, tl) = comp(&mut s, "Third");
|
||||
let unused = s.edit("add", None, |p, _| {
|
||||
let f = effectcraft_project::Footage { path: "/nowhere/a.png".into(), has_video: true, ..Default::default() };
|
||||
Ok(p.add_item("a.png", effectcraft_color::Label::None, None, effectcraft_project::ItemKind::Footage(f)))
|
||||
});
|
||||
let unused = unused.unwrap();
|
||||
let key = |s: &Session| effectcraft_render::disk_cache::comp_content_key(&s.project, main);
|
||||
let expr = |s: &mut Session, (comp, layer): (u64, u64), text: &str| {
|
||||
s.execute("prop.setExpression", json!({"comp": comp, "layer": layer, "path": "transform/opacity", "expression": text})).unwrap();
|
||||
};
|
||||
let opacity = |s: &mut Session, (comp, layer): (u64, u64), v: f64| {
|
||||
s.execute("prop.set", json!({"comp": comp, "layer": layer, "path": "transform/opacity", "value": v})).unwrap();
|
||||
};
|
||||
let repath = |s: &mut Session, path: &str| {
|
||||
let path = path.to_string();
|
||||
s.edit("repath", None, move |p, _| {
|
||||
if let Some(effectcraft_project::ItemKind::Footage(f)) = p.item_mut(unused).map(|i| &mut i.kind) {
|
||||
f.path = path;
|
||||
}
|
||||
Ok(())
|
||||
})
|
||||
.unwrap();
|
||||
};
|
||||
// Its own comp only.
|
||||
expr(&mut s, ml, "thisComp.layer(1).transform.rotation + wiggle(1, 1)[0]");
|
||||
expr(&mut s, ol, "wiggle(2, 10)");
|
||||
let k0 = key(&s);
|
||||
opacity(&mut s, ol, 40.0);
|
||||
expr(&mut s, tl, "time * 10");
|
||||
repath(&mut s, "/nowhere/b.png");
|
||||
s.execute("comp.addMarker", json!({"comp": third.0, "time": 0.5})).unwrap();
|
||||
assert_eq!(key(&s), k0, "edits elsewhere keep the key");
|
||||
// An edit in the comp itself changes it.
|
||||
opacity(&mut s, ml, 30.0);
|
||||
assert_ne!(key(&s), k0);
|
||||
// `comp("Other")`: Other counts, Third doesn't.
|
||||
expr(&mut s, ml, "comp(\"Other\").layer(1).transform.opacity");
|
||||
let k1 = key(&s);
|
||||
expr(&mut s, ol, "wiggle(3, 10)");
|
||||
let k2 = key(&s);
|
||||
assert_ne!(k2, k1, "the comp it names");
|
||||
opacity(&mut s, tl, 20.0);
|
||||
repath(&mut s, "/nowhere/c.png");
|
||||
assert_eq!(key(&s), k2, "a comp it doesn't name");
|
||||
// Another comp taking the name changes what it may read.
|
||||
s.edit("rename", None, |p, _| {
|
||||
p.item_mut(third).unwrap().name = "Other".into();
|
||||
Ok(())
|
||||
})
|
||||
.unwrap();
|
||||
let k3 = key(&s);
|
||||
assert_ne!(k3, k2, "a second comp named Other");
|
||||
// A computed name reaches every item.
|
||||
expr(&mut s, ml, "comp(\"Oth\" + \"er\").layer(1).transform.opacity");
|
||||
let k4 = key(&s);
|
||||
repath(&mut s, "/nowhere/d.png");
|
||||
assert_ne!(key(&s), k4, "unused footage counts with a computed name");
|
||||
}
|
||||
|
||||
/// Markers count only for the comps whose expressions can read them (#1083): an expression in
|
||||
/// another comp that reads markers leaves this comp's markers out of its key.
|
||||
#[test]
|
||||
fn markers_count_only_where_an_expression_can_read_them() {
|
||||
let mut s = Session::default();
|
||||
s.execute("comp.new", json!({"name": "M", "width": 8, "height": 8, "frameRate": 30, "duration": 2})).unwrap();
|
||||
let cid = s.active_comp_id().unwrap();
|
||||
s.execute("layer.newSolid", json!({"color": "#ff0000"})).unwrap();
|
||||
let other = s.execute("comp.new", json!({"name": "N", "width": 8, "height": 8, "frameRate": 30, "duration": 2})).unwrap()["comp"].as_u64().unwrap();
|
||||
let ol = s.execute("layer.newSolid", json!({"comp": other, "color": "#ff0000"})).unwrap()["layer"].as_u64().unwrap();
|
||||
s.execute("prop.setExpression", json!({"comp": other, "layer": ol, "path": "transform/opacity", "expression": "thisComp.marker.numKeys"})).unwrap();
|
||||
let key = |s: &Session| effectcraft_render::disk_cache::comp_content_key(&s.project, cid);
|
||||
let k0 = key(&s);
|
||||
s.execute("comp.addMarker", json!({"comp": cid.0, "time": 0.5, "comment": "beat"})).unwrap();
|
||||
assert_eq!(key(&s), k0, "no expression of M reads its markers");
|
||||
s.execute("prop.setExpression", json!({"comp": other, "layer": ol, "path": "transform/opacity", "expression": "comp(\"M\").marker.numKeys"})).unwrap();
|
||||
let other_key = |s: &Session| effectcraft_render::disk_cache::comp_content_key(&s.project, effectcraft_project::ItemId(other));
|
||||
let n0 = other_key(&s);
|
||||
s.execute("comp.addMarker", json!({"comp": cid.0, "time": 1.0})).unwrap();
|
||||
assert_ne!(other_key(&s), n0, "N reads M's markers");
|
||||
assert_eq!(key(&s), k0, "M itself still doesn't");
|
||||
}
|
||||
|
||||
@@ -35,6 +35,7 @@ mod footage;
|
||||
mod item;
|
||||
mod layer;
|
||||
mod layers;
|
||||
mod reach;
|
||||
mod settings;
|
||||
|
||||
pub use comp::{Comp, Guide, Renderer, Resolution};
|
||||
@@ -46,6 +47,7 @@ pub use layer::{
|
||||
reads_other_frames,
|
||||
};
|
||||
pub use layers::Layers;
|
||||
pub use reach::{ExprReach, PixelReach, expression_reach};
|
||||
pub use settings::{
|
||||
APP_VERSION, BitDepth, ColorEngine, CuePoint, HdrMode, Marker, ProjectError, ProjectSettings, SCHEMA_EFFECT_SPACE, SCHEMA_VERSION, SavedView,
|
||||
TimeDisplayStyle, is_newer_version, saved_by, saved_view,
|
||||
|
||||
@@ -0,0 +1,401 @@
|
||||
//! What a composition's pixels can depend on, from the project in memory: the items it draws
|
||||
//! and, when expressions are among them, what those expressions can read (#3184). The disk
|
||||
//! cache keys a comp's frames by exactly these items, so an edit elsewhere in the project keeps
|
||||
//! them.
|
||||
//!
|
||||
//! An expression reaches its own comp's layers (`thisComp`, `thisLayer`), the sources of the
|
||||
//! layers it can read (`layer.source`, a precomp's layers through it), and other items by name:
|
||||
//! `comp("Name")` and `footage("Name")`. A name given as a plain string literal is followed; a
|
||||
//! computed name (`comp("Shot " + index)`), the object model's constructors and internals
|
||||
//! (`new Comp(7)`, `__h`), dynamic code (`eval`, `Function`) and anything the scanner can't read
|
||||
//! for sure (a regular expression literal, a template string, an escape in a name) count as
|
||||
//! reaching every item of the project. The scan errs on the side of reaching more: an item
|
||||
//! wrongly left out would serve a stale frame, one wrongly let in only renders again.
|
||||
//!
|
||||
//! Known limit (`ponytail`): an expression that builds the names of the object model's private
|
||||
//! fields at run time into a variable and writes them with a computed key it reads from that
|
||||
//! variable could forge another comp's id. That is deliberate tampering with the internals, not
|
||||
//! an expression one writes; the scan refuses every direct form of it (`__` names, the
|
||||
//! constructors, `Object`, `JSON`, `call`/`apply`/`bind`, computed writes and computed keys).
|
||||
//! Upgrade: have the expression host record which items an evaluation reached.
|
||||
|
||||
use std::collections::{BTreeMap, BTreeSet};
|
||||
|
||||
use crate::{Comp, ItemId, ItemKind, LayerId, LayerSource, Node, Project, PropGroup, Value};
|
||||
|
||||
/// What an expression's text can reach outside its own comp and the layers it can read.
|
||||
#[derive(Clone, Debug, PartialEq, Eq)]
|
||||
pub enum ExprReach {
|
||||
/// Only items named by string literals: comps by `comp("…")`, footage by `footage("…")`.
|
||||
Names { comps: Vec<String>, footage: Vec<String> },
|
||||
/// Any item of the project.
|
||||
Anything,
|
||||
}
|
||||
|
||||
/// Names that hand an expression another item by id, run code built at run time, or give it the
|
||||
/// tools to forge the object model's private fields.
|
||||
const REACHES_ANYTHING: &[&str] = &[
|
||||
"Comp",
|
||||
"Footage",
|
||||
"Layer",
|
||||
"Prop",
|
||||
"Markers",
|
||||
"eval",
|
||||
"Function",
|
||||
"globalThis",
|
||||
"this",
|
||||
"self",
|
||||
"window",
|
||||
"arguments",
|
||||
"constructor",
|
||||
"prototype",
|
||||
"Object",
|
||||
"Reflect",
|
||||
"Proxy",
|
||||
"JSON",
|
||||
"call",
|
||||
"apply",
|
||||
"bind",
|
||||
"class",
|
||||
"with",
|
||||
"import",
|
||||
"require",
|
||||
"fromCharCode",
|
||||
"fromCodePoint",
|
||||
"getOwnPropertyDescriptor",
|
||||
"getOwnPropertyDescriptors",
|
||||
"getPrototypeOf",
|
||||
"setPrototypeOf",
|
||||
"defineProperty",
|
||||
];
|
||||
|
||||
/// Keywords after which a `/` starts a regular expression.
|
||||
const BEFORE_REGEX: &[&str] = &["return", "typeof", "instanceof", "in", "of", "new", "delete", "void", "throw", "case", "do", "else", "yield", "await"];
|
||||
|
||||
/// Keywords whose `( … )` a regular expression may follow (`if (a) /x/.test(s)`).
|
||||
const CONTROL: &[&str] = &["if", "while", "for", "with"];
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
enum Tok<'a> {
|
||||
Ident(&'a str),
|
||||
/// A string literal's text between its quotes; `plain` when it has no escape.
|
||||
Str {
|
||||
text: &'a str,
|
||||
plain: bool,
|
||||
},
|
||||
Num,
|
||||
Punct(u8),
|
||||
}
|
||||
|
||||
/// The tokens of `text`, or `None` when it can't be read for sure.
|
||||
fn tokens(text: &str) -> Option<Vec<Tok<'_>>> {
|
||||
let b = text.as_bytes();
|
||||
let mut out: Vec<Tok<'_>> = Vec::new();
|
||||
// Per open `(`: whether a control keyword is before it; whether the last `)` closed one
|
||||
// (only looked at right after a `)`).
|
||||
let mut parens: Vec<bool> = Vec::new();
|
||||
let mut control_close = false;
|
||||
let mut i = 0;
|
||||
while let Some(&c) = b.get(i) {
|
||||
match c {
|
||||
b' ' | b'\t' | b'\n' | b'\r' | 0x0b | 0x0c => i += 1,
|
||||
b'/' if b.get(i + 1) == Some(&b'/') => {
|
||||
while b.get(i).is_some_and(|c| *c != b'\n') {
|
||||
i += 1;
|
||||
}
|
||||
}
|
||||
b'/' if b.get(i + 1) == Some(&b'*') => {
|
||||
let end = text.get(i + 2..)?.find("*/")?;
|
||||
i += 2 + end + 2;
|
||||
}
|
||||
b'/' => {
|
||||
if regex_may_start(out.last(), control_close) {
|
||||
return None;
|
||||
}
|
||||
out.push(Tok::Punct(c));
|
||||
i += 1;
|
||||
}
|
||||
b'"' | b'\'' => {
|
||||
let start = i + 1;
|
||||
let mut j = start;
|
||||
let mut plain = true;
|
||||
loop {
|
||||
match *b.get(j)? {
|
||||
q if q == c => break,
|
||||
b'\n' | b'\r' => return None,
|
||||
b'\\' => {
|
||||
// Only escapes that can't spell a name: `\n`, `\t`, a quote...
|
||||
if !matches!(b.get(j + 1)?, b'n' | b'r' | b't' | b'b' | b'f' | b'v' | b'\'' | b'"' | b'\\') {
|
||||
return None;
|
||||
}
|
||||
plain = false;
|
||||
j += 2;
|
||||
}
|
||||
_ => j += 1,
|
||||
}
|
||||
}
|
||||
let s = text.get(start..j)?;
|
||||
if s.contains("__") {
|
||||
return None;
|
||||
}
|
||||
out.push(Tok::Str { text: s, plain });
|
||||
i = j + 1;
|
||||
}
|
||||
b'0'..=b'9' => {
|
||||
while b.get(i).is_some_and(|c| c.is_ascii_alphanumeric() || *c == b'_' || *c == b'.') {
|
||||
i += 1;
|
||||
}
|
||||
out.push(Tok::Num);
|
||||
}
|
||||
b'.' if b.get(i + 1).is_some_and(u8::is_ascii_digit) => {
|
||||
i += 1;
|
||||
while b.get(i).is_some_and(|c| c.is_ascii_alphanumeric() || *c == b'_' || *c == b'.') {
|
||||
i += 1;
|
||||
}
|
||||
out.push(Tok::Num);
|
||||
}
|
||||
c if c.is_ascii_alphabetic() || c == b'_' || c == b'$' => {
|
||||
let start = i;
|
||||
while b.get(i).is_some_and(|c| c.is_ascii_alphanumeric() || *c == b'_' || *c == b'$') {
|
||||
i += 1;
|
||||
}
|
||||
out.push(Tok::Ident(text.get(start..i)?));
|
||||
}
|
||||
// A template string (code inside `${}`), an escaped identifier, a name in another
|
||||
// alphabet: not followed.
|
||||
b'`' | b'\\' => return None,
|
||||
c if !c.is_ascii() => return None,
|
||||
c => {
|
||||
match c {
|
||||
b'(' => parens.push(matches!(out.last(), Some(Tok::Ident(k)) if CONTROL.contains(k))),
|
||||
b')' => control_close = parens.pop().unwrap_or(false),
|
||||
_ => {}
|
||||
}
|
||||
out.push(Tok::Punct(c));
|
||||
i += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
Some(out)
|
||||
}
|
||||
|
||||
/// Whether a `/` after `prev` may start a regular expression literal (which the scanner doesn't
|
||||
/// read: its text could hide a quote).
|
||||
fn regex_may_start(prev: Option<&Tok<'_>>, control_close: bool) -> bool {
|
||||
match prev {
|
||||
None => true,
|
||||
Some(Tok::Ident(k)) => BEFORE_REGEX.contains(k),
|
||||
Some(Tok::Num | Tok::Str { .. }) => false,
|
||||
Some(Tok::Punct(b')')) => control_close,
|
||||
Some(Tok::Punct(b']')) => false,
|
||||
Some(Tok::Punct(_)) => true,
|
||||
}
|
||||
}
|
||||
|
||||
/// What the expression `text` can reach by name, or [`ExprReach::Anything`].
|
||||
pub fn expression_reach(text: &str) -> ExprReach {
|
||||
expression_names(text).map_or(ExprReach::Anything, |(comps, footage)| ExprReach::Names { comps, footage })
|
||||
}
|
||||
|
||||
fn expression_names(text: &str) -> Option<(Vec<String>, Vec<String>)> {
|
||||
let toks = tokens(text)?;
|
||||
let (mut comps, mut footage) = (Vec::new(), Vec::new());
|
||||
// Per open `[`: a computed key (`{[k]: v}`), a computed member (`o[k]`).
|
||||
let mut brackets: Vec<(bool, bool)> = Vec::new();
|
||||
for (i, t) in toks.iter().enumerate() {
|
||||
let prev = i.checked_sub(1).and_then(|p| toks.get(p));
|
||||
let next = |n: usize| toks.get(i + n);
|
||||
match *t {
|
||||
Tok::Ident(name) if name.starts_with("__") || REACHES_ANYTHING.contains(&name) => return None,
|
||||
Tok::Ident(name @ ("comp" | "footage")) => {
|
||||
// Only a call with a plain literal, not a property of something else.
|
||||
let (Some(Tok::Punct(b'(')), Some(Tok::Str { text, plain: true }), Some(Tok::Punct(b')'))) = (next(1), next(2), next(3)) else { return None };
|
||||
if matches!(prev, Some(Tok::Punct(b'.'))) {
|
||||
return None;
|
||||
}
|
||||
if name == "comp" { comps.push((*text).to_string()) } else { footage.push((*text).to_string()) }
|
||||
}
|
||||
Tok::Punct(b'[') => {
|
||||
let key = matches!(prev, Some(Tok::Punct(b'{' | b',')) | Some(Tok::Ident("get" | "set" | "static" | "async")) | Some(Tok::Punct(b'*')));
|
||||
let member = matches!(prev, Some(Tok::Ident(_) | Tok::Str { .. } | Tok::Num | Tok::Punct(b')' | b']' | b'.')));
|
||||
brackets.push((key, member));
|
||||
}
|
||||
Tok::Str { .. } if brackets.last().is_some_and(|(_, member)| *member) => return None,
|
||||
Tok::Punct(b']') => {
|
||||
let (key, _) = brackets.pop().unwrap_or((true, true));
|
||||
// A computed key (`{[k]: v}`, `{[k]() {}}`) or a write through brackets (`o[k] = v`,
|
||||
// `o[k] ||= v`, `for (o[k] in …)`, `[o[k]] = v`) could name a private field.
|
||||
if key && matches!(next(1), Some(Tok::Punct(b':' | b'('))) {
|
||||
return None;
|
||||
}
|
||||
if assigns(&toks, i + 1) || matches!(next(1), Some(Tok::Ident("in" | "of"))) {
|
||||
return None;
|
||||
}
|
||||
}
|
||||
// A destructuring write (`({a: o[k]} = v)`).
|
||||
Tok::Punct(b'}') if assigns(&toks, i + 1) => return None,
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
Some((comps, footage))
|
||||
}
|
||||
|
||||
/// Whether the tokens from `at` are an assignment operator (`=`, `+=`, `>>>=`, `??=`...), not a
|
||||
/// comparison (`==`, `<=`) or an arrow (`=>`).
|
||||
fn assigns(toks: &[Tok<'_>], at: usize) -> bool {
|
||||
let mut op = Vec::new();
|
||||
for t in toks.iter().skip(at).take(5) {
|
||||
match t {
|
||||
Tok::Punct(c) if b"+-*/%&|^<>?=".contains(c) => op.push(*c),
|
||||
_ => break,
|
||||
}
|
||||
}
|
||||
let Some(eq) = op.iter().position(|c| *c == b'=') else { return false };
|
||||
let (before, after) = op.split_at(eq);
|
||||
if after.get(1).is_some_and(|c| *c == b'=' || *c == b'>') {
|
||||
return false;
|
||||
}
|
||||
matches!(before, b"" | b"+" | b"-" | b"*" | b"/" | b"%" | b"&" | b"|" | b"^" | b"**" | b"<<" | b">>" | b">>>" | b"&&" | b"||" | b"??")
|
||||
}
|
||||
|
||||
/// The items a comp's pixels can depend on ([`Project::pixel_reach`]).
|
||||
#[derive(Clone, Debug, Default, PartialEq, Eq)]
|
||||
pub struct PixelReach {
|
||||
/// The items whose state counts; `None`: every item of the project.
|
||||
pub items: Option<BTreeSet<ItemId>>,
|
||||
/// Expressions are among them: they can read every layer of the comps they reach (hidden
|
||||
/// and silent ones too) and the markers, which therefore count as well (#1083).
|
||||
pub expressions: bool,
|
||||
/// The names expressions look items up by (`true`: a comp's, `false`: footage's), each with
|
||||
/// the ids of the items of that kind that have it now, in id order (the first one is what
|
||||
/// the lookup finds; another item taking or giving up the name changes it).
|
||||
pub names: Vec<(bool, String, Vec<ItemId>)>,
|
||||
}
|
||||
|
||||
/// Each property of a group and its subgroups (iterative: no depth limit to hit).
|
||||
fn each_prop<'a>(g: &'a PropGroup, f: &mut dyn FnMut(&'a crate::Property) -> Option<()>) -> Option<()> {
|
||||
let mut stack = vec![g];
|
||||
while let Some(g) = stack.pop() {
|
||||
for n in &g.children {
|
||||
match n {
|
||||
Node::Prop(p) => f(p)?,
|
||||
Node::Group(sub) => stack.push(sub),
|
||||
}
|
||||
}
|
||||
}
|
||||
Some(())
|
||||
}
|
||||
|
||||
impl Project {
|
||||
/// The items comp `comp` draws ([`Self::silent_layers`] aside, with `heard`) and the
|
||||
/// footage its precomp layers swap in (Essential Graphics Media Replacement); with an
|
||||
/// expression in any of its comps, everything those expressions can reach
|
||||
/// ([`expression_reach`]). Memory only: no file is looked at.
|
||||
pub fn pixel_reach(&self, comp: ItemId, heard: &crate::Heard) -> PixelReach {
|
||||
let Some(drawn) = self.reach_walk(comp, &|id, c| self.silent_layers(id, c, heard), &mut |_| Some(vec![])) else { return PixelReach::every() };
|
||||
let has_expression = |g: &PropGroup| each_prop(g, &mut |p| p.expr.is_none().then_some(())).is_none();
|
||||
if !drawn.iter().filter_map(|id| self.comp(*id)).any(|c| c.layers.iter().any(|l| has_expression(&l.props))) {
|
||||
return PixelReach { items: Some(drawn), expressions: false, names: vec![] };
|
||||
}
|
||||
// Expressions: every layer of a comp they reach counts, and what they name.
|
||||
let mut names: BTreeMap<(bool, String), Vec<ItemId>> = BTreeMap::new();
|
||||
let mut scan = |p: &crate::Property| match p.expr.as_ref().map(|e| expression_reach(&e.text)) {
|
||||
None => Some(vec![]),
|
||||
Some(ExprReach::Anything) => None,
|
||||
Some(ExprReach::Names { comps, footage }) => {
|
||||
let mut found = vec![];
|
||||
for (is_comp, name) in comps.into_iter().map(|n| (true, n)).chain(footage.into_iter().map(|n| (false, n))) {
|
||||
let ids = self.named(is_comp, &name);
|
||||
found.extend(ids.iter().copied());
|
||||
names.insert((is_comp, name), ids);
|
||||
}
|
||||
Some(found)
|
||||
}
|
||||
};
|
||||
let Some(mut items) = self.reach_walk(comp, &|_, _| BTreeSet::new(), &mut scan) else { return PixelReach::every() };
|
||||
// A source's data is read by its name (`layer.source.sourceData`).
|
||||
let footage_names: BTreeSet<&str> =
|
||||
items.iter().filter_map(|id| self.item(*id)).filter(|i| matches!(i.kind, ItemKind::Footage(_))).map(|i| i.name.as_str()).collect();
|
||||
let same_name: Vec<ItemId> =
|
||||
self.items.values().filter(|i| matches!(i.kind, ItemKind::Footage(_)) && footage_names.contains(i.name.as_str())).map(|i| i.id).collect();
|
||||
items.extend(same_name);
|
||||
PixelReach { items: Some(items), expressions: true, names: names.into_iter().map(|((c, n), ids)| (c, n, ids)).collect() }
|
||||
}
|
||||
|
||||
/// The items of one kind (`is_comp`: comps, else footage) named `name`, in id order.
|
||||
fn named(&self, is_comp: bool, name: &str) -> Vec<ItemId> {
|
||||
self.items
|
||||
.values()
|
||||
.filter(|i| i.name == name && if is_comp { matches!(i.kind, ItemKind::Comp(_)) } else { matches!(i.kind, ItemKind::Footage(_)) })
|
||||
.map(|i| i.id)
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// The items reached from `comp` through its layers (but those `quiet` names) and the items
|
||||
/// `scan` returns for each of their properties; `None` when something reaches every item.
|
||||
/// (A stack and a visited set: each item is visited once, cycles included.)
|
||||
fn reach_walk(
|
||||
&self,
|
||||
comp: ItemId,
|
||||
quiet: &dyn Fn(ItemId, &Comp) -> BTreeSet<LayerId>,
|
||||
scan: &mut dyn FnMut(&crate::Property) -> Option<Vec<ItemId>>,
|
||||
) -> Option<BTreeSet<ItemId>> {
|
||||
let mut seen = BTreeSet::new();
|
||||
let mut stack = vec![comp];
|
||||
while let Some(id) = stack.pop() {
|
||||
if !seen.insert(id) {
|
||||
continue;
|
||||
}
|
||||
let Some(c) = self.comp(id) else { continue };
|
||||
let quiet = quiet(id, c);
|
||||
for l in c.layers.iter().filter(|l| !quiet.contains(&l.id)) {
|
||||
if let LayerSource::Comp { item } | LayerSource::Footage { item } | LayerSource::Solid { item } = l.source {
|
||||
stack.push(item);
|
||||
}
|
||||
stack.extend(self.media_replacements(l)?);
|
||||
let mut reached = vec![];
|
||||
each_prop(&l.props, &mut |p| {
|
||||
reached.extend(scan(p)?);
|
||||
Some(())
|
||||
})?;
|
||||
stack.extend(reached);
|
||||
}
|
||||
}
|
||||
Some(seen)
|
||||
}
|
||||
|
||||
/// The footage a precomp layer swaps in through its Essential Properties (Media Replacement):
|
||||
/// the items its overridden properties name. `None` when they can't be listed (an
|
||||
/// expression or keyframes choose the item over time).
|
||||
fn media_replacements(&self, layer: &crate::Layer) -> Option<Vec<ItemId>> {
|
||||
let over = crate::essential::overridden(layer);
|
||||
let Some(g) = crate::essential::group(layer).filter(|_| !over.is_empty()) else { return Some(vec![]) };
|
||||
let mut out = vec![];
|
||||
each_prop(g, &mut |p| {
|
||||
if !over.contains(&p.uid) {
|
||||
return Some(());
|
||||
}
|
||||
if p.expr.is_some() || !p.keys.is_empty() {
|
||||
return None;
|
||||
}
|
||||
if let Value::Scalar(id) = p.value {
|
||||
let item = ItemId(id.max(0.0) as u64);
|
||||
if matches!(self.item(item).map(|i| &i.kind), Some(ItemKind::Footage(_))) {
|
||||
out.push(item);
|
||||
}
|
||||
}
|
||||
Some(())
|
||||
})?;
|
||||
Some(out)
|
||||
}
|
||||
}
|
||||
|
||||
impl PixelReach {
|
||||
/// Every item of the project, with expressions.
|
||||
fn every() -> PixelReach {
|
||||
PixelReach { items: None, expressions: true, names: vec![] }
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests;
|
||||
@@ -0,0 +1,177 @@
|
||||
use super::*;
|
||||
use crate::{Expression, Solid, build};
|
||||
use effectcraft_time::{FrameRate, Tick};
|
||||
|
||||
fn names(comps: &[&str], footage: &[&str]) -> ExprReach {
|
||||
ExprReach::Names { comps: comps.iter().map(|s| s.to_string()).collect(), footage: footage.iter().map(|s| s.to_string()).collect() }
|
||||
}
|
||||
|
||||
/// Expressions that read their own comp, or other items by literal names, are followed; every
|
||||
/// way to reach items by a computed name or an id, or text the scanner can't read for sure,
|
||||
/// reaches everything.
|
||||
#[test]
|
||||
fn expression_reach_follows_literal_names_and_refuses_the_rest() {
|
||||
let follows = [
|
||||
("wiggle(2, 20)", names(&[], &[])),
|
||||
("thisComp.layer(\"Comp 1 Layer\").transform.opacity * 2 / 3", names(&[], &[])),
|
||||
("value + [10, 0]; value[0] / 2", names(&[], &[])),
|
||||
("// comp(name) in a comment\n/* footage(x) */ value", names(&[], &[])),
|
||||
("\"a string that says comp(x) and Layer\"", names(&[], &[])),
|
||||
("comp(\"Other\").layer(1).transform.position", names(&["Other"], &[])),
|
||||
("comp( 'A' ).width + comp(\"B\").height", names(&["A", "B"], &[])),
|
||||
("footage(\"data.json\").sourceData.x", names(&[], &["data.json"])),
|
||||
("x = a[0] <= b ? a[1] : 0; y = a[0] == 1", names(&[], &[])),
|
||||
("thisLayer.source.layer(1).name", names(&[], &[])),
|
||||
("if (a) x = 1; else x = 2; (a + b) / 2", names(&[], &[])),
|
||||
("\"Ünïcödé name\"", names(&[], &[])),
|
||||
("const f = (v) => v * 2; f(1)", names(&[], &[])),
|
||||
];
|
||||
for (text, want) in follows {
|
||||
assert_eq!(expression_reach(text), want, "{text}");
|
||||
}
|
||||
let anything = [
|
||||
"comp(\"Shot \" + index).layer(1)",
|
||||
"comp(name)",
|
||||
"var n = \"Other\"; comp(n)",
|
||||
"comp(\"O\\\"ther\")",
|
||||
"x.comp(\"Other\")",
|
||||
"var comp = 1",
|
||||
"footage(thisComp.name)",
|
||||
"new Comp(7).layer(1)",
|
||||
"Layer(7, 3).name",
|
||||
"__h(__COMP, 7)",
|
||||
"o.__c = 7",
|
||||
"eval('1')",
|
||||
"Function('return 1')()",
|
||||
"this.x",
|
||||
"({}).constructor",
|
||||
"Object.getPrototypeOf(thisComp)",
|
||||
"JSON.parse(s)",
|
||||
"thisComp.layer.call(o, 1)",
|
||||
"o['_' + '_c']",
|
||||
"o[k] = 7",
|
||||
"o[k] ||= 7",
|
||||
"o[k] += 7",
|
||||
"[o[k]] = [7]",
|
||||
"({a: o[k]} = {a: 7})",
|
||||
"for (o[k] in x) {}",
|
||||
"({[k]: 7})",
|
||||
"({a: 1, [k]: 7})",
|
||||
"o = {'__c': 7}",
|
||||
"'\\x5f\\x5fc'",
|
||||
"'\\_\\_c'",
|
||||
"`${x}`",
|
||||
"c\\u006fmp('A')",
|
||||
"comp\u{0430}('A')",
|
||||
"/\"/.test(s); comp(n); \"",
|
||||
"return /x/",
|
||||
"if (a) /\"/.test(s)",
|
||||
"x = '",
|
||||
"/* comp(n)",
|
||||
"class X {}",
|
||||
"String.fromCharCode(95)",
|
||||
];
|
||||
for text in anything {
|
||||
assert_eq!(expression_reach(text), ExprReach::Anything, "{text}");
|
||||
}
|
||||
}
|
||||
|
||||
/// `a / b` divides after a name, a number, a string and a closing bracket or parenthesis.
|
||||
#[test]
|
||||
fn division_is_not_a_regular_expression() {
|
||||
for text in ["a / b", "2 / 3", "'a' / 2", "x[0] / 2", "(a + b) / 2", "f(x) / 2 / g(y)"] {
|
||||
assert_eq!(expression_reach(text), names(&[], &[]), "{text}");
|
||||
}
|
||||
}
|
||||
|
||||
struct Fixture {
|
||||
p: Project,
|
||||
main: ItemId,
|
||||
other: ItemId,
|
||||
third: ItemId,
|
||||
unused: ItemId,
|
||||
solid: ItemId,
|
||||
}
|
||||
|
||||
/// Comps "Main" (a solid), "Other" (a solid), "Third" (empty), an unused footage item.
|
||||
fn fixture() -> Fixture {
|
||||
let mut p = Project::default();
|
||||
let comp = Comp::new(64, 64, FrameRate::FPS_30, Tick::from_seconds_f64(2.0));
|
||||
let solid =
|
||||
p.add_item("Solid", effectcraft_color::Label::None, None, ItemKind::Solid(Solid { color: [1.0, 0.0, 0.0], width: 64, height: 64, pixel_aspect: 1.0 }));
|
||||
let main = p.add_item("Main", effectcraft_color::Label::None, None, ItemKind::Comp(comp.clone().into()));
|
||||
let other = p.add_item("Other", effectcraft_color::Label::None, None, ItemKind::Comp(comp.clone().into()));
|
||||
let third = p.add_item("Third", effectcraft_color::Label::None, None, ItemKind::Comp(comp.clone().into()));
|
||||
let unused = p.add_item("unused.png", effectcraft_color::Label::None, None, ItemKind::Footage(crate::Footage { has_video: true, ..Default::default() }));
|
||||
for c in [main, other] {
|
||||
let l = build::layer(&mut p, &comp, "S", LayerSource::Solid { item: solid }, (64, 64), None);
|
||||
p.comp_mut(c).unwrap().layers.push(l);
|
||||
}
|
||||
Fixture { p, main, other, third, unused, solid }
|
||||
}
|
||||
|
||||
fn set_expr(p: &mut Project, comp: ItemId, text: &str) {
|
||||
let l = p.comp_mut(comp).unwrap().layers.first_mut().unwrap();
|
||||
l.props.prop_mut("transform/opacity").unwrap().expr = Some(Expression { text: text.into(), enabled: true });
|
||||
}
|
||||
|
||||
fn reach(p: &Project, comp: ItemId) -> PixelReach {
|
||||
p.pixel_reach(comp, &p.heard_layers())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pixel_reach_is_what_the_comp_draws_and_what_its_expressions_name() {
|
||||
let mut f = fixture();
|
||||
let ids = |r: &PixelReach| r.items.clone().map(|s| s.into_iter().collect::<Vec<_>>());
|
||||
assert_eq!(reach(&f.p, f.main), PixelReach { items: Some([f.solid, f.main].into()), expressions: false, names: vec![] });
|
||||
// An expression reading only its own comp: what it draws, with expressions.
|
||||
set_expr(&mut f.p, f.main, "thisComp.layer(1).transform.opacity");
|
||||
let r = reach(&f.p, f.main);
|
||||
assert!(r.expressions);
|
||||
assert_eq!(ids(&r), Some(vec![f.solid, f.main]));
|
||||
// An expression in another comp doesn't reach this one.
|
||||
set_expr(&mut f.p, f.other, "wiggle(1, 1)");
|
||||
assert_eq!(ids(&reach(&f.p, f.main)), Some(vec![f.solid, f.main]));
|
||||
// A literal name: that comp and what it draws, with the name and the comps that have it.
|
||||
set_expr(&mut f.p, f.main, "comp(\"Other\").layer(1).transform.opacity");
|
||||
let r = reach(&f.p, f.main);
|
||||
assert_eq!(ids(&r), Some(vec![f.solid, f.main, f.other]));
|
||||
assert_eq!(r.names, vec![(true, "Other".to_string(), vec![f.other])]);
|
||||
// Another comp taking the name is part of it, whichever the lookup finds.
|
||||
f.p.item_mut(f.third).unwrap().name = "Other".into();
|
||||
let r = reach(&f.p, f.main);
|
||||
assert_eq!(r.names, vec![(true, "Other".to_string(), vec![f.other, f.third])]);
|
||||
assert!(r.items.unwrap().contains(&f.third));
|
||||
// A name no item has yet still counts (with no item).
|
||||
set_expr(&mut f.p, f.main, "footage(\"later.json\").sourceData");
|
||||
assert_eq!(reach(&f.p, f.main).names, vec![(false, "later.json".to_string(), vec![])]);
|
||||
// A computed name reaches everything.
|
||||
set_expr(&mut f.p, f.main, "comp(\"Ot\" + \"her\").width");
|
||||
assert_eq!(reach(&f.p, f.main), PixelReach { items: None, expressions: true, names: vec![] });
|
||||
// Footage reached as a layer's source brings the footage of its name (its data is read by
|
||||
// name).
|
||||
let comp = f.p.comp(f.main).unwrap().clone();
|
||||
let l = build::layer(&mut f.p, &comp, "U", LayerSource::Footage { item: f.unused }, (64, 64), None);
|
||||
f.p.comp_mut(f.main).unwrap().layers.push(l);
|
||||
let twin = f.p.add_item("unused.png", effectcraft_color::Label::None, None, ItemKind::Footage(crate::Footage::default()));
|
||||
set_expr(&mut f.p, f.main, "value");
|
||||
let r = reach(&f.p, f.main).items.unwrap();
|
||||
assert!(r.contains(&f.unused) && r.contains(&twin), "{r:?}");
|
||||
}
|
||||
|
||||
/// A comp nested in the reach is scanned too: its expression's names count for the outer comp.
|
||||
#[test]
|
||||
fn nested_comps_bring_their_expressions_reach() {
|
||||
let mut f = fixture();
|
||||
let comp = f.p.comp(f.main).unwrap().clone();
|
||||
let pre = build::layer(&mut f.p, &comp, "Pre", LayerSource::Comp { item: f.other }, (64, 64), None);
|
||||
f.p.comp_mut(f.main).unwrap().layers.push(pre);
|
||||
set_expr(&mut f.p, f.other, "comp(\"Third\").width");
|
||||
let r = reach(&f.p, f.main);
|
||||
assert!(r.expressions && r.items.unwrap().contains(&f.third));
|
||||
// A cycle through names ends.
|
||||
let l = build::layer(&mut f.p, &comp, "S", LayerSource::Solid { item: f.solid }, (64, 64), None);
|
||||
f.p.comp_mut(f.third).unwrap().layers.push(l);
|
||||
set_expr(&mut f.p, f.third, "comp(\"Main\").width");
|
||||
assert!(reach(&f.p, f.main).items.unwrap().contains(&f.main));
|
||||
}
|
||||
@@ -1183,44 +1183,38 @@ pub fn layer_disk_key(key: u64) -> u128 {
|
||||
|
||||
/// Content key of a composition's pixels, from the project in memory alone (no file is looked
|
||||
/// at: the frame entries check their own source files when read, see [`EntryFiles`]): project
|
||||
/// render settings, the comp and everything it uses (nested comps, footage items with their
|
||||
/// settings and paths, solids, their proxies and Use Proxy switches). With expressions in play
|
||||
/// (which can read any comp) the whole project counts. Switches that don't change pixels (Audio,
|
||||
/// Lock, Shy, Hide Shy Layers) don't count, and neither do markers unless an expression mentions
|
||||
/// them.
|
||||
/// render settings, the comp and the items it can draw (nested comps, footage items with their
|
||||
/// settings and paths, solids, Media Replacement footage, their proxies and Use Proxy switches;
|
||||
/// [`effectcraft_project::Project::pixel_reach`]). With expressions among them, everything those
|
||||
/// expressions can read counts too: every layer of their comps, markers, the comps and footage
|
||||
/// they name with literal names (and which items have those names), or the whole project when
|
||||
/// they compute a name or reach items another way. An edit to an item the comp can't reach keeps
|
||||
/// its key and its frames on disk (#3184, #1492). Switches that don't change pixels (Audio, Lock,
|
||||
/// Shy, Hide Shy Layers) don't count, and neither do markers unless an expression can read them.
|
||||
pub fn comp_content_key(project: &effectcraft_project::Project, comp: effectcraft_project::ItemId) -> u128 {
|
||||
comp_content_key_for_renderer(project, comp, RENDER_VERSION)
|
||||
}
|
||||
|
||||
fn comp_content_key_for_renderer(project: &effectcraft_project::Project, comp: effectcraft_project::ItemId, renderer: &str) -> u128 {
|
||||
use effectcraft_project::{ItemKind, LayerSource};
|
||||
use effectcraft_project::ItemKind;
|
||||
let mut h = Hash128::default();
|
||||
h.write(renderer.as_bytes());
|
||||
hash_debug(&mut h, &project.settings);
|
||||
// Expressions can read anything (every item counts); without them, layers that can't
|
||||
// change the picture (music, hidden layers nothing reads) and their files don't count.
|
||||
let expressions = project.reads_markers();
|
||||
let heard = project.heard_layers();
|
||||
let reach = project.pixel_reach(comp, &heard);
|
||||
// Expressions can read any layer of the comps they reach, hidden or not, and their markers
|
||||
// (#1083); without them, layers that can't change the picture (music, hidden layers nothing
|
||||
// reads) don't count.
|
||||
let expressions = reach.expressions;
|
||||
let silent = |id, c: &effectcraft_project::Comp| if expressions { Default::default() } else { project.silent_layers(id, c, &heard) };
|
||||
let mut seen = std::collections::BTreeSet::new();
|
||||
let mut stack = vec![comp];
|
||||
while let Some(id) = stack.pop() {
|
||||
if !seen.insert(id) {
|
||||
continue;
|
||||
}
|
||||
let Some(it) = project.item(id) else { continue };
|
||||
if let ItemKind::Comp(c) = &it.kind {
|
||||
let quiet = silent(id, c);
|
||||
for l in c.layers.iter().filter(|l| !quiet.contains(&l.id)) {
|
||||
if let LayerSource::Comp { item } | LayerSource::Footage { item } | LayerSource::Solid { item } = l.source {
|
||||
stack.push(item);
|
||||
}
|
||||
}
|
||||
}
|
||||
// (the names expressions look items up by: which items have them now)
|
||||
if !reach.names.is_empty() {
|
||||
hash_debug(&mut h, &reach.names);
|
||||
}
|
||||
// Markers are pixels only to the expressions that read them (#1083).
|
||||
let markers = expressions;
|
||||
let ids: Vec<effectcraft_project::ItemId> = if expressions { project.items.keys().copied().collect() } else { seen.into_iter().collect() };
|
||||
let ids: Vec<effectcraft_project::ItemId> = match reach.items {
|
||||
Some(items) => items.into_iter().collect(),
|
||||
None => project.items.keys().copied().collect(),
|
||||
};
|
||||
for id in ids {
|
||||
let Some(it) = project.item(id) else { continue };
|
||||
h.write_u64(id.0);
|
||||
@@ -1230,11 +1224,11 @@ fn comp_content_key_for_renderer(project: &effectcraft_project::Project, comp: e
|
||||
let quiet = silent(id, c);
|
||||
let heard = |l| heard.contains(id, l);
|
||||
if quiet.is_empty() {
|
||||
hash_debug(&mut h, &c.pixel_form_with(markers, &heard));
|
||||
hash_debug(&mut h, &c.pixel_form_with(expressions, &heard));
|
||||
} else {
|
||||
let mut pic = (**c).clone();
|
||||
pic.layers.retain(|l| !quiet.contains(&l.id));
|
||||
hash_debug(&mut h, &pic.pixel_form_with(markers, &heard));
|
||||
hash_debug(&mut h, &pic.pixel_form_with(expressions, &heard));
|
||||
}
|
||||
}
|
||||
k => hash_debug(&mut h, k),
|
||||
|
||||
@@ -1975,6 +1975,80 @@ fn disk_frames_outlive_an_edit_that_cant_change_them() {
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
}
|
||||
|
||||
/// With expressions the disk key covers what they can read (#3184, #1492): an edit to a comp no
|
||||
/// expression names keeps every frame on disk under the same key; an edit to the comp one names
|
||||
/// gives the comp a new key, and the frames outside the layer with that expression are carried to
|
||||
/// it (the dirty spans of #2795).
|
||||
#[test]
|
||||
fn disk_frames_outlive_edits_their_expressions_cant_read() {
|
||||
use effectcraft_engine::Session;
|
||||
use effectcraft_engine::project::{Expression, LayerId, Value};
|
||||
use serde_json::json;
|
||||
let dir = std::env::temp_dir().join(format!("ec-disk-carry-expr-{}", std::process::id()));
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
let disk = DiskCache::open(&dir, 1 << 30).unwrap();
|
||||
let mut s = Session::default();
|
||||
let comp = |s: &mut Session, name: &str| {
|
||||
ItemId(s.execute("comp.new", json!({"name": name, "width": 8, "height": 8, "duration": 1, "frameRate": 30})).unwrap()["comp"].as_u64().unwrap())
|
||||
};
|
||||
let solid = |s: &mut Session, c: ItemId| LayerId(s.execute("layer.newSolid", json!({"comp": c.0, "color": "#ff0000"})).unwrap()["layer"].as_u64().unwrap());
|
||||
let cid = comp(&mut s, "A");
|
||||
let (a, b) = (solid(&mut s, cid), solid(&mut s, cid));
|
||||
let other = comp(&mut s, "Other");
|
||||
let o = solid(&mut s, other);
|
||||
let third = comp(&mut s, "Third");
|
||||
let t = solid(&mut s, third);
|
||||
let fr = s.project.comp(cid).unwrap().frame_rate;
|
||||
let mut p0 = (*s.project).clone();
|
||||
for (l, i, out) in [(a, 0, 15), (b, 15, 30)] {
|
||||
let l = p0.comp_mut(cid).unwrap().layer_mut(l).unwrap();
|
||||
(l.start_time, l.in_point, l.out_point) = (fr.tick_of(i), fr.tick_of(i), fr.tick_of(out));
|
||||
}
|
||||
p0.comp_mut(cid).unwrap().layer_mut(a).unwrap().props.prop_mut("transform/opacity").unwrap().expr =
|
||||
Some(Expression { text: "comp(\"Other\").layer(1).transform.opacity".into(), enabled: true });
|
||||
let p0 = Arc::new(p0);
|
||||
let opts = RenderOpts::default();
|
||||
let oh = opts_hash(&opts);
|
||||
let src = |p: &Arc<Project>| RenderSource {
|
||||
project: p.clone(),
|
||||
footage: Arc::new(effectcraft_engine::render::NoFootage),
|
||||
expr: None,
|
||||
layer_cache: Arc::default(),
|
||||
gpu: None,
|
||||
gpu_display: false,
|
||||
disk: Some(disk.clone()),
|
||||
};
|
||||
let content0 = disk_cache::comp_content_key(&p0, cid);
|
||||
for f in 0..30 {
|
||||
disk.put_frame_now(disk_cache::frame_key(content0, f, 1000, oh), 1, 1, &[1, 2, 3, 255], &ReadFiles::default());
|
||||
}
|
||||
let opacity = |p: &mut Project, c: ItemId, l: LayerId| {
|
||||
p.comp_mut(c).unwrap().layer_mut(l).unwrap().props.prop_mut("transform/opacity").unwrap().value = Value::Scalar(40.0)
|
||||
};
|
||||
for (name, edited, layer, same_key, kept) in [("Third", third, t, true, (0..30).collect::<Vec<i64>>()), ("Other", other, o, false, (17..30).collect())] {
|
||||
let f = Frames::default();
|
||||
let series = |p: &Arc<Project>, rev: u64| FrameKey { revision: rev, content: f.content_of(p, rev, cid), comp: cid.0, opts: oh, ..key(0, 0, 0) };
|
||||
let blue = |p: &Arc<Project>, rev: u64, want: &[i64]| {
|
||||
let base = series(p, rev);
|
||||
let mut got = vec![];
|
||||
for _ in 0..1000 {
|
||||
got = f.disk_frames(&src(p), &base, 0..30, &opts);
|
||||
if got == want {
|
||||
break;
|
||||
}
|
||||
std::thread::sleep(std::time::Duration::from_millis(5));
|
||||
}
|
||||
got
|
||||
};
|
||||
assert_eq!(blue(&p0, 1, &(0..30).collect::<Vec<_>>()), (0..30).collect::<Vec<_>>(), "{name}: before");
|
||||
let mut p1 = p0.clone();
|
||||
opacity(Arc::make_mut(&mut p1), edited, layer);
|
||||
assert_eq!(disk_cache::comp_content_key(&p1, cid) == content0, same_key, "{name}: the key");
|
||||
assert_eq!(blue(&p1, 2, &kept), kept, "{name}: after");
|
||||
}
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
}
|
||||
|
||||
/// A keyframe edit re-renders only around the keys it changed: two keys either side (auto-Bezier
|
||||
/// and continuous tangents reach the neighbouring segments), and from the layer's in point when
|
||||
/// the first key changes. A static value or an expression still reaches the whole layer. Every
|
||||
|
||||
Reference in new issue
Block a user