Files
effectcraft/crates/host/src/tests.rs
T
vangel76 8d4c37a38c Disk cache: follow 3D model sources in the comp's reach
The reach walk followed comp, footage and solid sources but not
LayerSource::Model. An expression reading a model layer's source
(thisComp.layer("Model").source.name) left the model item out of the
comp's content key, so renaming the model kept the key and the old
frames on disk were served. Every source item is followed now
(LayerSource::item), which also counts the model when no expression
reads it (Advanced 3D draws it).

The same omission is fixed in the RAM preview's content walk
(frames.rs) and in the layer key's walk of referenced layers
(cache/dependencies.rs).
2026-11-08 00:56:53 +01:00

661 lines
38 KiB
Rust

use serde_json::json;
#[test]
#[cfg(not(target_arch = "wasm32"))]
fn storage_overflow_cannot_bypass_duplicate_output_protection() {
for same_folder in [true, false] {
refuse_overflow_collision(same_folder);
}
}
#[cfg(not(target_arch = "wasm32"))]
fn refuse_overflow_collision(same_folder: bool) {
use std::{path::PathBuf, sync::Arc};
struct OverflowOnly(PathBuf);
impl effectcraft_project::render_queue::StorageQuota for OverflowOnly {
fn has_room(&self, path: &str, _: u64) -> bool {
std::path::Path::new(path).starts_with(&self.0)
}
}
let dir = std::env::temp_dir().join(format!("ec-duplicate-overflow-{}-{same_folder}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
let overflow = dir.join("overflow");
std::fs::create_dir_all(&overflow).unwrap();
let mut s = effectcraft_engine::Session {
exporter: Some(Arc::new(super::FileExporter::default())),
storage_quota: Some(Arc::new(OverflowOnly(overflow.clone()))),
..Default::default()
};
Arc::make_mut(&mut s.project).render_prefs.overflow_folders = vec![overflow.to_string_lossy().into_owned(); 2];
s.execute("comp.new", json!({"width": 16, "height": 16, "frameRate": 10, "duration": 0.2})).unwrap();
for index in 0..2 {
let folder = if same_folder { dir.clone() } else { dir.join(index.to_string()) };
s.execute("renderQueue.add", json!({"format": "png", "output": folder.join("frames_[#####].png"), "skipExisting": true, "storageOverflow": true}))
.unwrap();
}
let result = s.execute("renderQueue.render", json!({}));
let written = std::fs::read_dir(&overflow).unwrap().count();
assert!(result.is_err(), "overflow destinations cannot skip previous frames: {result:?}");
assert_eq!(written, 0, "refused before any overflow file is written");
s.execute("renderQueue.remove", json!({"index": 2})).unwrap();
let result = s.execute("renderQueue.render", json!({})).unwrap();
assert_eq!(result["items"][0]["status"], "Done", "one output's alternatives are not separate outputs: {result}");
assert_eq!(std::fs::read_dir(&overflow).unwrap().count(), 2);
std::fs::remove_dir_all(&dir).unwrap();
}
#[test]
fn memory_sink_cannot_overwrite_a_previous_output_even_with_skip_existing() {
use std::sync::{
Arc,
atomic::{AtomicUsize, Ordering},
};
let writes = Arc::new(AtomicUsize::new(0));
let count = writes.clone();
let sink: Arc<effectcraft_export::Sink> = Arc::new(move |_, _| {
count.fetch_add(1, Ordering::Relaxed);
});
let mut s = effectcraft_engine::Session { exporter: Some(Arc::new(super::FileExporter { sink: Some(sink) })), ..Default::default() };
s.execute("comp.new", json!({"name": "Main", "width": 16, "height": 16, "frameRate": 10, "duration": 0.2})).unwrap();
for _ in 0..2 {
s.execute("renderQueue.add", json!({"format": "png", "output": "/virtual/frames_[#####].png", "skipExisting": true})).unwrap();
}
let result = s.execute("renderQueue.render", json!({}));
assert!(result.is_err(), "a sink cannot skip previous paths: {result:?}");
assert_eq!(writes.load(Ordering::Relaxed), 0, "refused before the sink receives bytes");
}
#[test]
fn host_runs_tasks_scheduled_by_panel_handlers() {
let mut s = super::session();
let result = s.execute("script.run", json!({"code": "var w=new Window('palette','Timer regression'); var b=w.add('button',undefined,'Import'); b.onClick=function(){app.scheduleTask(\"app.project.items.addComp('Scheduled',64,64,1,1,25)\",0,false);};w.show();"})).unwrap();
assert_eq!(result["ok"], true, "{result}");
s.execute("scriptui.click", json!({"window":"Timer regression","widget":"Import"})).unwrap();
assert!(s.project.items.is_empty());
let tick = s.execute("script.runTasks", json!({})).unwrap();
assert_eq!(tick["ran"], 1, "{tick}");
assert_eq!(tick["errors"], json!([]), "{tick}");
assert!(s.project.items.values().any(|item| item.name == "Scheduled"));
s.execute("scriptui.close", json!({"window":"Timer regression"})).unwrap();
}
/// Layer ▸ Camera ▸ Link Focus Distance to Point of Interest / to Layer: the expressions
/// evaluate to the camera's focus on the target.
#[test]
fn focus_link_expressions_track_the_target() {
use effectcraft_engine::geom::vec3;
let mut s = super::session();
s.execute("comp.new", json!({"name": "F", "width": 400, "height": 300, "duration": 2})).unwrap();
let t = s.execute("layer.newSolid", json!({"color": "#ffffff", "width": 50, "height": 50})).unwrap()["layer"].as_u64().unwrap();
s.execute("layer.setSwitch", json!({"layers": [t], "switch": "threeD", "value": true})).unwrap();
s.execute("layer.setTransform", json!({"layer": t, "prop": "position", "value": [260, 120, 400]})).unwrap();
let cam = s.execute("layer.newCamera", json!({})).unwrap()["layer"].as_u64().unwrap();
let cid = s.active_comp_id().unwrap();
let focus = |s: &effectcraft_engine::Session| {
let comp = s.project.comp(cid).unwrap();
let mut ctx = effectcraft_engine::render::EvalCtx::new(&s.project, cid, comp, s.time());
ctx.expr = s.expr.as_deref();
let l = comp.layer(effectcraft_engine::project::LayerId(cam)).unwrap();
ctx.value(l, l.props.prop("cameraOptions/focusDistance").unwrap()).as_f64()
};
let depth = |s: &effectcraft_engine::Session| {
let comp = s.project.comp(cid).unwrap();
let ctx = effectcraft_engine::render::EvalCtx::new(&s.project, cid, comp, s.time());
let c = comp.layer(effectcraft_engine::project::LayerId(cam)).unwrap();
let tl = comp.layer(effectcraft_engine::project::LayerId(t)).unwrap();
let cs = effectcraft_engine::render::three_d::camera::layer_camera(&ctx, c);
cs.depth(ctx.world_matrix(tl).apply(vec3(25.0, 25.0, 0.0)))
};
s.execute("layer.select", json!({"layers": [cam, t]})).unwrap();
let set = s.execute("camera.setFocusToLayer", json!({})).unwrap()["focusDistance"].as_f64().unwrap();
assert!((set - depth(&s)).abs() < 1e-6 && (focus(&s) - set).abs() < 1e-6);
s.execute("camera.linkFocusToLayer", json!({})).unwrap();
// Move the target: the linked focus follows.
s.execute("layer.setTransform", json!({"layer": t, "prop": "position", "value": [200, 150, 900]})).unwrap();
assert!((focus(&s) - depth(&s)).abs() < 1e-3, "{} vs {}", focus(&s), depth(&s));
s.execute("camera.linkFocusToPoi", json!({"camera": cam})).unwrap();
let poi = {
let l = s.active_comp().unwrap().layer(effectcraft_engine::project::LayerId(cam)).unwrap();
let p = l.props.prop("transform/position").unwrap().value.as_vec3();
let q = l.props.prop("transform/poi").unwrap().value.as_vec3();
((p[0] - q[0]).powi(2) + (p[1] - q[1]).powi(2) + (p[2] - q[2]).powi(2)).sqrt()
};
assert!((focus(&s) - poi).abs() < 1e-6, "{} vs {poi}", focus(&s));
}
#[test]
fn wired_session_renders_demo_with_expressions() {
let mut s = super::session();
s.execute("file.openDemoProject", json!({})).unwrap();
let cid = s.active_comp_id().unwrap();
let lid = s.active_comp().unwrap().layers[1].id.0;
s.execute("prop.setExpression", json!({"layer": lid, "path": "transform/rotation", "expression": "time * 90"})).unwrap();
let img = s.render(cid, s.time(), effectcraft_engine::render::RenderOpts { scale: 0.25, ..Default::default() });
assert!(img.data.iter().any(|p| p[3] > 0.5));
}
/// File ▸ Import of glTF/GLB/OBJ models through the media layer, placed as model layers and
/// drawn by the Advanced 3D renderer.
#[test]
fn imported_models_render_in_advanced_3d() {
let fx = |n: &str| format!("{}/../model/tests/fixtures/{n}", env!("CARGO_MANIFEST_DIR"));
let mut s = super::session();
s.execute("comp.new", json!({"name": "M", "width": 160, "height": 120, "renderer": "advanced3d"})).unwrap();
let r = s.execute("file.import", json!({"paths": [fx("cube.obj"), fx("quad.glb"), fx("quad.gltf")]})).unwrap();
assert_eq!(r["errors"], json!([]), "{r}");
let items: Vec<u64> = r["items"].as_array().unwrap().iter().map(|v| v.as_u64().unwrap()).collect();
assert_eq!(items.len(), 3);
let cube = s.execute("layer.addItem", json!({"item": items[0]})).unwrap()["layer"].as_u64().unwrap();
s.execute("prop.set", json!({"layer": cube, "path": "transform/rotationY", "value": 30})).unwrap();
s.execute("prop.set", json!({"layer": cube, "path": "transform/rotationX", "value": 20})).unwrap();
let cid = s.active_comp_id().unwrap();
let opts = effectcraft_engine::render::RenderOpts::default();
let img = s.render(cid, s.time(), opts);
let covered = img.data.iter().filter(|p| p[3] > 0.99).count();
assert!(covered > 1000, "the cube covers part of the frame: {covered}");
// Red faces (material Red) are visible.
assert!(img.data.iter().any(|p| p[3] > 0.99 && p[0] > 0.5 && p[1] < 0.2));
// The textured binary glTF quad.
for _ in 0..3 {
s.execute("edit.undo", json!({})).unwrap();
}
s.execute("layer.addItem", json!({"item": items[1]})).unwrap();
let img = s.render(cid, s.time(), opts);
assert!(img.data.iter().filter(|p| p[3] > 0.99).count() > 1000);
// Classic 3D doesn't draw models.
s.execute("comp.renderer", json!({"renderer": "classic3d"})).unwrap();
assert!(s.render(cid, s.time(), opts).data.iter().all(|p| p[3] == 0.0));
}
/// A binary glTF of a red cube 2 units wide (positions and indices only).
fn glb_cube() -> Vec<u8> {
let mut bin: Vec<u8> = (0..8u32).flat_map(|i| [i & 1, (i >> 1) & 1, (i >> 2) & 1].map(|b| b as f32 * 2.0 - 1.0)).flat_map(f32::to_le_bytes).collect();
let faces: [[u16; 4]; 6] = [[0, 2, 3, 1], [4, 5, 7, 6], [0, 1, 5, 4], [2, 6, 7, 3], [0, 4, 6, 2], [1, 3, 7, 5]];
bin.extend(faces.iter().flat_map(|f| [f[0], f[1], f[2], f[0], f[2], f[3]]).flat_map(u16::to_le_bytes));
let gltf = json!({
"asset": {"version": "2.0"},
"scene": 0,
"scenes": [{"nodes": [0]}],
"nodes": [{"mesh": 0}],
"meshes": [{"primitives": [{"attributes": {"POSITION": 0}, "indices": 1, "material": 0}]}],
"materials": [{"pbrMetallicRoughness": {"baseColorFactor": [1, 0, 0, 1], "metallicFactor": 0, "roughnessFactor": 1}}],
"buffers": [{"byteLength": bin.len()}],
"bufferViews": [{"buffer": 0, "byteOffset": 0, "byteLength": 96}, {"buffer": 0, "byteOffset": 96, "byteLength": 72}],
"accessors": [
{"bufferView": 0, "componentType": 5126, "count": 8, "type": "VEC3", "min": [-1, -1, -1], "max": [1, 1, 1]},
{"bufferView": 1, "componentType": 5123, "count": 36, "type": "SCALAR"}
]
});
let mut text = gltf.to_string().into_bytes();
text.resize(text.len().div_ceil(4) * 4, b' ');
let chunk = |kind: &[u8; 4], data: &[u8]| [&(data.len() as u32).to_le_bytes()[..], kind, data].concat();
let body = [chunk(b"JSON", &text), chunk(b"BIN\0", &bin)].concat();
[&b"glTF"[..], &2u32.to_le_bytes(), &(12 + body.len() as u32).to_le_bytes(), &body].concat()
}
/// #264: a model imported into a new composition (Classic 3D by default) was invisible on
/// every renderer, because only Advanced 3D draws models. Adding it now switches the comp,
/// and the software renderer (no GPU, as on the reporter's Intel HD Graphics 5500) draws it.
#[test]
fn imported_glb_shows_in_a_new_composition() {
let path = std::env::temp_dir().join(format!("effectcraft-264-cube-{}.glb", std::process::id()));
std::fs::write(&path, glb_cube()).unwrap();
let mut s = super::session();
assert!(s.accel.is_none(), "renders in software");
let r = s.execute("file.import", json!({"paths": [path.to_string_lossy()]})).unwrap();
assert_eq!(r["errors"], json!([]), "{r}");
s.state.project_selection = vec![effectcraft_project::ItemId(r["items"][0].as_u64().unwrap())];
s.execute("file.newCompFromSelection", json!({})).unwrap();
let comp = s.active_comp().unwrap();
assert_eq!(comp.renderer, effectcraft_project::Renderer::Advanced3D);
let layer = comp.layers[0].id.0;
s.execute("prop.set", json!({"layer": layer, "path": "transform/rotationY", "value": 30})).unwrap();
s.execute("prop.set", json!({"layer": layer, "path": "transform/rotationX", "value": 20})).unwrap();
let cid = s.active_comp_id().unwrap();
let img = s.render(cid, s.time(), effectcraft_engine::render::RenderOpts { scale: 0.25, ..Default::default() });
let red = img.data.iter().filter(|p| p[3] > 0.99 && p[0] > 0.2 && p[1] < 0.05 && p[2] < 0.05).count();
let _ = std::fs::remove_file(&path);
// Half the comp height wide, seen at an angle: well over 5% of the frame.
assert!(red * 20 > img.data.len(), "red cube pixels: {red} of {}", img.data.len());
}
/// #651: an animated GIF imported from disk plays: the layer shows each frame at its time,
/// in the viewer's renders and in exports alike.
#[test]
fn an_imported_animated_gif_plays() {
let dir = std::env::temp_dir().join(format!("ec-gif-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
let path = dir.join("anim.gif");
let mut bytes = Vec::new();
{
let mut enc = gif::Encoder::new(&mut bytes, 4, 4, &[]).unwrap();
for rgb in [[255u8, 0, 0], [0, 255, 0], [0, 0, 255]] {
let mut f = gif::Frame::from_rgb(4, 4, &rgb.repeat(16));
f.delay = 10;
enc.write_frame(&f).unwrap();
}
}
std::fs::write(&path, bytes).unwrap();
let mut s = super::session();
s.execute("comp.new", json!({"name": "G", "width": 4, "height": 4, "frameRate": 30, "duration": 1})).unwrap();
s.execute("file.import", json!({"paths": [path.to_string_lossy()], "addToComp": true})).unwrap();
let cid = s.active_comp_id().unwrap();
let rgb = |t: f64| {
let img = s.render(cid, effectcraft_time::Tick::from_seconds_f64(t), effectcraft_engine::render::RenderOpts::default());
let p = img.data[5];
[p[0].round(), p[1].round(), p[2].round()]
};
assert_eq!(rgb(0.05), [1.0, 0.0, 0.0]);
assert_eq!(rgb(0.15), [0.0, 1.0, 0.0]);
assert_eq!(rgb(0.25), [0.0, 0.0, 1.0]);
let _ = std::fs::remove_dir_all(dir);
}
/// The web app's path: outputs go to a sink (downloads), never to the file system.
#[test]
fn render_queue_exports_to_a_sink() {
use std::sync::{Arc, Mutex};
let got: Arc<Mutex<Vec<(String, Vec<u8>)>>> = Arc::default();
let g = got.clone();
let mut s = super::session();
s.exporter = Some(Arc::new(super::FileExporter { sink: Some(Arc::new(move |p: &str, d: Vec<u8>| g.lock().unwrap().push((p.to_string(), d)))) }));
s.execute("file.openDemoProject", json!({})).unwrap();
// Rooted without a drive letter is not absolute on Windows, where the engine joins it to the home drive.
let dir = if cfg!(windows) { "C:/no-such-dir-effectcraft-sink-test" } else { "/no-such-dir-effectcraft-sink-test" };
s.execute(
"renderQueue.add",
json!({"format": "gif", "output": format!("{dir}/a.gif"), "resolution": 0.0625, "timeSpan": "custom", "start": 0.0, "end": 0.2}),
)
.unwrap();
s.execute(
"renderQueue.add",
json!({"format": "png", "output": format!("{dir}/seq_[##].png"), "resolution": 0.0625, "timeSpan": "custom", "start": 0.0, "end": 0.1}),
)
.unwrap();
s.execute("renderQueue.render", json!({"wait": true})).unwrap();
s.poll_render();
let mut got = got.lock().unwrap().clone();
got.sort_by(|a, b| a.0.cmp(&b.0));
let names: Vec<std::path::PathBuf> = got.iter().map(|(p, _)| std::path::PathBuf::from(p)).collect();
let expected = [format!("{dir}/a.gif"), format!("{dir}/seq_00.png"), format!("{dir}/seq_01.png"), format!("{dir}/seq_02.png")]
.map(|p| std::path::absolute(p).unwrap());
assert_eq!(names, expected);
assert!(got[0].1.starts_with(b"GIF89a"));
assert!(got[1].1.starts_with(b"\x89PNG"));
assert!(!std::path::Path::new(dir).exists());
}
#[test]
fn render_queue_exports_demo_comp() {
let dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../target/test-out/host-rq");
let _ = std::fs::remove_dir_all(&dir);
let mut s = super::session();
s.execute("file.openDemoProject", json!({})).unwrap();
let out = dir.join("[compName]_[width]x[height].[fileExtension]");
let r = s
.execute(
"renderQueue.add",
json!({"format": "h264", "output": out.to_string_lossy(), "resolution": 0.125, "timeSpan": "custom", "start": 0.0, "end": 0.4}),
)
.unwrap();
let path = r["outputPath"].as_str().unwrap().to_string();
assert!(path.ends_with("_240x134.mp4"), "{path}");
// A second item: PNG sequence, rendered in the background.
s.execute(
"renderQueue.add",
json!({"format": "png", "output": dir.join("seq_[###].png").to_string_lossy(), "resolution": 0.0625, "timeSpan": "custom", "start": 0.0, "end": 0.2}),
)
.unwrap();
let r = s.execute("renderQueue.render", json!({"wait": false})).unwrap();
assert_eq!(r["items"].as_array().unwrap().len(), 2);
let t0 = std::time::Instant::now();
while s.is_rendering() {
assert!(t0.elapsed().as_secs() < 300, "render timed out");
std::thread::sleep(std::time::Duration::from_millis(20));
s.poll_render();
}
s.poll_render();
let list = s.execute("renderQueue.list", json!({})).unwrap();
for it in list["items"].as_array().unwrap() {
assert_eq!(it["statusLabel"], "Done", "{it}");
assert!(it["render_time"].as_f64().is_some());
assert!(std::path::Path::new(it["last_output"].as_str().unwrap()).exists(), "{it}");
}
assert!(std::path::Path::new(&path).metadata().unwrap().len() > 500);
assert!(dir.join("seq_000.png").exists() && dir.join("seq_005.png").exists() && !dir.join("seq_006.png").exists());
// Rendering again needs a re-queue.
assert!(s.execute("renderQueue.render", json!({})).is_err());
s.execute("renderQueue.setRender", json!({"index": 1, "render": true})).unwrap();
assert_eq!(s.project.render_queue[0].status, effectcraft_engine::project::render_queue::RenderStatus::Queued);
}
/// Value of a property of layer `l` at time 0 (keys + expression).
fn value(s: &effectcraft_engine::Session, l: u64, path: &str) -> effectcraft_engine::keyframe::Value {
let cid = s.active_comp_id().unwrap();
let comp = s.project.comp(cid).unwrap();
let layer = comp.layer(effectcraft_engine::project::LayerId(l)).unwrap();
let ctx = effectcraft_engine::render::EvalCtx {
project: &s.project,
comp_id: cid,
comp,
time: Default::default(),
expr: s.expr.as_deref(),
footage: None,
property_overrides: &[],
media_overrides: &[],
reads: None,
};
ctx.value(layer, layer.props.prop(path).unwrap())
}
#[test]
fn pick_whip_expressions_evaluate() {
let mut s = super::session();
s.execute("comp.new", json!({"name": "C", "width": 200, "height": 200, "frameRate": 30, "duration": 2})).unwrap();
let a = s.execute("layer.newSolid", json!({"color": "#ffffff"})).unwrap()["layer"].as_u64().unwrap();
let b = s.execute("layer.newSolid", json!({"name": "Src", "color": "#ff0000"})).unwrap()["layer"].as_u64().unwrap();
s.execute("prop.set", json!({"layer": b, "path": "transform/rotation", "value": 33})).unwrap();
s.execute("prop.set", json!({"layer": b, "path": "transform/position", "value": [12, 34]})).unwrap();
s.execute("effect.apply", json!({"layer": b, "effect": "Gaussian Blur"})).unwrap();
s.execute("prop.set", json!({"layer": b, "path": "effects/#1/blurriness", "value": 21})).unwrap();
s.execute("layer.addMask", json!({"layer": b})).unwrap();
s.execute("prop.set", json!({"layer": b, "path": "masks/#1/feather", "value": [7, 7]})).unwrap();
let link = |s: &mut effectcraft_engine::Session, from: &str, to: &str| {
s.execute("prop.pickWhip", json!({"layer": a, "path": from, "target": {"layer": b, "path": to}})).unwrap();
};
link(&mut s, "transform/opacity", "transform/rotation");
assert_eq!(value(&s, a, "transform/opacity").as_f64(), 33.0);
link(&mut s, "transform/scale", "transform/rotation");
let cid = s.active_comp_id().unwrap();
let ep = effectcraft_expr::eval_property(&s.project, cid, effectcraft_engine::project::LayerId(a), "transform/scale", 0.0);
assert!(ep.is_ok(), "{ep:?}");
assert_eq!(value(&s, a, "transform/scale").as_vec2(), [33.0, 33.0]);
link(&mut s, "transform/position", "transform/position");
assert_eq!(value(&s, a, "transform/position").as_vec2(), [12.0, 34.0]);
link(&mut s, "transform/rotation", "effects/#1/blurriness");
assert_eq!(value(&s, a, "transform/rotation").as_f64(), 21.0);
link(&mut s, "transform/opacity", "masks/#1/feather");
assert_eq!(value(&s, a, "transform/opacity").as_f64(), 7.0);
// Separated dimensions: X Position reference.
s.execute("prop.separateDimensions", json!({"layer": b})).unwrap();
link(&mut s, "transform/rotation", "transform/positionX");
assert_eq!(value(&s, a, "transform/rotation").as_f64(), 12.0);
}
/// The expression error bar's list: evaluation errors and syntax errors, with the layer and
/// property they belong to.
#[test]
fn expression_errors_are_collected() {
let mut s = super::session();
s.execute("comp.new", json!({"name": "C", "width": 100, "height": 100, "frameRate": 30, "duration": 2})).unwrap();
let a = s.execute("layer.newSolid", json!({"name": "Box", "color": "#ffffff"})).unwrap()["layer"].as_u64().unwrap();
s.execute("prop.setExpression", json!({"layer": a, "path": "transform/opacity", "expression": "50"})).unwrap();
assert_eq!(s.execute("expr.errors", json!({})).unwrap()["count"], 0);
s.execute("prop.setExpression", json!({"layer": a, "path": "transform/rotation", "expression": "thisComp.layer(\"Nope\").rotation"})).unwrap();
s.execute("prop.setExpression", json!({"layer": a, "path": "transform/opacity", "expression": "1 +* ("})).unwrap();
let r = s.execute("expr.errors", json!({})).unwrap();
assert_eq!(r["count"], 2, "{r}");
let errs = r["errors"].as_array().unwrap();
let rot = errs.iter().find(|e| e["path"] == "transform/rotation").unwrap();
assert!(rot["message"].as_str().unwrap().contains("Nope"), "{rot}");
assert_eq!(rot["layerIndex"], 1);
assert_eq!(rot["layerName"], "Box");
assert_eq!(rot["disabled"], false);
let op = errs.iter().find(|e| e["path"] == "transform/opacity").unwrap();
assert_eq!(op["disabled"], true);
assert!(r["text"][0].as_str().unwrap().contains("of layer 1 ('Box') in comp 'C'"), "{r}");
// A user-disabled (but valid) expression is not an error.
s.execute("prop.setExpression", json!({"layer": a, "path": "transform/rotation", "expression": "45"})).unwrap();
s.execute("prop.setExpression", json!({"layer": a, "path": "transform/rotation", "enabled": false})).unwrap();
assert_eq!(s.execute("expr.errors", json!({})).unwrap()["count"], 1);
// The Expression Language menu is categorised.
let m = s.execute("expr.languageMenu", json!({})).unwrap();
assert!(m.as_array().unwrap().iter().any(|c| c["category"] == "Footage" && c["items"].as_array().unwrap().iter().any(|i| i["text"] == "sourceData")));
}
/// File ▸ Import of JSON/CSV data files as data footage, read by expressions.
#[test]
fn imported_data_files_drive_expressions() {
let dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../target/test-out/host-data");
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
std::fs::write(dir.join("levels.csv"), "label,value\nlow,10\nhigh,90\n").unwrap();
std::fs::write(dir.join("cfg.json"), r#"{"angle": 33}"#).unwrap();
std::fs::write(dir.join("broken.json"), "{nope").unwrap();
let mut s = super::session();
s.execute("comp.new", json!({"name": "C", "width": 100, "height": 100, "frameRate": 30, "duration": 2})).unwrap();
let paths: Vec<String> = ["levels.csv", "cfg.json", "broken.json"].iter().map(|n| dir.join(n).to_string_lossy().to_string()).collect();
let r = s.execute("file.import", json!({"paths": paths})).unwrap();
assert_eq!(r["items"].as_array().unwrap().len(), 2, "{r}");
assert_eq!(r["errors"].as_array().unwrap().len(), 1, "{r}");
let csv = r["items"][0].as_u64().unwrap();
assert_eq!(s.project.item(effectcraft_engine::project::ItemId(csv)).unwrap().type_name(), "Data");
assert!(s.execute("layer.addItem", json!({"item": csv})).is_err(), "data files are not layers");
let a = s.execute("layer.newSolid", json!({"color": "#ffffff"})).unwrap()["layer"].as_u64().unwrap();
s.execute("prop.setExpression", json!({"layer": a, "path": "transform/opacity", "expression": "footage(\"levels.csv\").sourceData[1].value"})).unwrap();
s.execute("prop.setExpression", json!({"layer": a, "path": "transform/rotation", "expression": "footage(\"cfg.json\").sourceData.angle"})).unwrap();
assert_eq!(value(&s, a, "transform/opacity").as_f64(), 90.0);
assert_eq!(value(&s, a, "transform/rotation").as_f64(), 33.0);
}
/// sampleImage through the renderer: a box's Fill colour follows the solid under it.
#[test]
fn sample_image_drives_a_colour() {
let mut s = super::session();
s.execute("comp.new", json!({"name": "C", "width": 100, "height": 100, "frameRate": 30, "duration": 2})).unwrap();
s.execute("layer.newSolid", json!({"name": "Bg", "color": "#00ff00"})).unwrap();
let a = s.execute("layer.newSolid", json!({"name": "Fg", "color": "#ffffff", "width": 20, "height": 20})).unwrap()["layer"].as_u64().unwrap();
s.execute("effect.apply", json!({"layer": a, "effect": "Fill"})).unwrap();
s.execute(
"prop.setExpression",
json!({"layer": a, "path": "effects/#1/color", "expression": "thisComp.layer(\"Bg\").sampleImage(thisComp.layer(\"Bg\").fromComp(toComp(anchorPoint)))"}),
)
.unwrap();
let cid = s.active_comp_id().unwrap();
let img = s.render(cid, s.time(), effectcraft_engine::render::RenderOpts::default());
let px = img.get(50, 50);
assert!(px[1] > 0.99 && px[0] < 0.01, "the box is filled with the sampled green: {px:?}");
}
/// Proxies through the real media and export layers: Render Settings ▸ Proxy Use decides
/// whether an export uses the proxy, and Create Proxy renders and attaches one.
#[test]
fn proxies_in_exports_and_create_proxy() {
let dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../target/test-out/host-proxy");
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
let p = |n: &str| dir.join(n).to_string_lossy().to_string();
let mut s = super::session();
// Source and proxy stills, written by the app itself.
s.execute("comp.new", json!({"name": "Red", "width": 16, "height": 16, "frameRate": 10, "duration": 1})).unwrap();
let red = s.active_comp_id().unwrap();
s.execute("layer.newSolid", json!({"color": "#ff0000"})).unwrap();
s.execute("comp.saveFrameAs", json!({"path": p("red.png")})).unwrap();
s.execute("comp.new", json!({"name": "Blue", "width": 8, "height": 8, "frameRate": 10, "duration": 1})).unwrap();
s.execute("layer.newSolid", json!({"color": "#0000ff"})).unwrap();
s.execute("comp.saveFrameAs", json!({"path": p("blue.png")})).unwrap();
let foot = s.execute("file.import", json!({"paths": [p("red.png")]})).unwrap()["items"][0].as_u64().unwrap();
s.execute("file.setProxy", json!({"item": foot, "path": p("blue.png")})).unwrap();
s.execute("comp.new", json!({"name": "Out", "width": 16, "height": 16, "frameRate": 10, "duration": 1})).unwrap();
let out = s.active_comp_id().unwrap();
s.execute("layer.addItem", json!({"item": foot})).unwrap();
// Export one frame with each Proxy Use.
for (name, using) in [("all", "use_all_[#].png"), ("none", "use_none_[#].png")] {
s.execute(
"renderQueue.add",
json!({"comp": out.0, "format": "png", "output": p(using), "timeSpan": "custom", "start": 0.0, "end": 0.1, "proxyUse": name}),
)
.unwrap();
}
s.execute("renderQueue.render", json!({"wait": true})).unwrap();
s.poll_render();
let centre = |s: &mut effectcraft_engine::Session, path: &str| {
let id = s.execute("file.import", json!({"paths": [path]})).unwrap()["items"][0].as_u64().unwrap();
s.execute("comp.new", json!({"name": "Probe", "width": 16, "height": 16, "frameRate": 10, "duration": 1})).unwrap();
s.execute("layer.addItem", json!({"item": id})).unwrap();
let c = s.active_comp_id().unwrap();
s.render(c, Default::default(), Default::default()).get(8, 8)
};
let all = centre(&mut s, &p("use_all_0.png"));
assert!(all[2] > 0.99 && all[0] < 0.01, "Use All Proxies renders the blue proxy: {all:?}");
let none = centre(&mut s, &p("use_none_0.png"));
assert!(none[0] > 0.99 && none[2] < 0.01, "Use No Proxies renders the red source: {none:?}");
// Create Proxy ▸ Still: rendered at half size and attached to the comp.
s.execute("file.createProxy", json!({"kind": "still", "comp": red.0, "path": p("red_proxy_[#####].png")})).unwrap();
s.execute("renderQueue.render", json!({"wait": true})).unwrap();
s.poll_render();
let px = s.project.item(red).unwrap().proxy.clone().expect("Create Proxy attached the rendered still");
assert!(px.enabled);
assert_eq!((px.footage.width, px.footage.height), (8, 8));
assert!(std::path::Path::new(&px.footage.path).exists(), "{}", px.footage.path);
}
/// A script builds a comp, queues it and renders it through the Render Queue.
#[test]
fn script_renders_through_the_render_queue() {
let dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../target/test-out/host-script");
let _ = std::fs::remove_dir_all(&dir);
let out = dir.join("scripted.gif");
let mut s = super::session();
let code = format!(
r#"
var comp = app.project.items.addComp("Scripted", 64, 48, 1, 0.2, 10);
var sq = comp.layers.addSolid([1, 0.5, 0], "Square", 16, 16, 1);
sq.transform.position.setValueAtTime(0, [8, 24]);
sq.transform.position.setValueAtTime(0.1, [56, 24]);
var item = app.project.renderQueue.items.add(comp);
item.outputModule(1).applyTemplate("GIF");
item.outputModule(1).file = new File({});
app.project.renderQueue.render();
[item.status == RQItemStatus.DONE, item.outputModule(1).file.fsName, app.project.renderQueue.numItems]
"#,
serde_json::to_string(&out.to_string_lossy()).unwrap()
);
let r = s.execute("script.run", json!({"code": code})).unwrap();
assert_eq!(r["ok"], json!(true), "{r}");
assert_eq!(r["result"][0], json!(true), "{r}");
assert_eq!(r["result"][2], json!(1));
let bytes = std::fs::read(&out).unwrap();
assert!(bytes.starts_with(b"GIF89a"));
}
/// importFile, layers.add(footage) and project save/open from a script.
#[test]
fn script_imports_footage_and_saves() {
let dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../target/test-out/host-script-import");
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
let q = |n: &str| serde_json::to_string(&dir.join(n).to_string_lossy()).unwrap();
let mut s = super::session();
let code = format!(
r#"
var c = app.project.items.addComp("Src", 32, 32, 1, 1, 10);
c.layers.addSolid([0, 1, 0], "G", 32, 32, 1);
app.run("comp.saveFrameAs", {{comp: c.id, path: {png}}});
var still = app.project.importFile(new ImportOptions(new File({png})));
var main = app.project.items.addComp("Main", 64, 64, 1, 1, 10);
var l = main.layers.add(still);
app.project.save(new File({proj}));
[still instanceof FootageItem, still.width, still.mainSource.isStill, l.source.name, app.project.file.name]
"#,
png = q("frame.png"),
proj = q("p.ecproj")
);
let r = s.execute("script.run", json!({"code": code})).unwrap();
assert_eq!(r["ok"], json!(true), "{r}");
assert_eq!(r["result"], json!([true, 32, true, "frame.png", "p.ecproj"]), "{r}");
let r = s.execute("script.run", json!({"code": format!("app.open(new File({})); app.project.numItems", q("p.ecproj"))})).unwrap();
assert_eq!(r["result"], json!(5), "{r}"); // Src, Solids, G, frame.png, Main
}
#[test]
fn expression_syntax_errors_disable_the_expression() {
let mut s = super::session();
s.execute("comp.new", json!({"name": "C", "width": 100, "height": 100, "frameRate": 30, "duration": 2})).unwrap();
let a = s.execute("layer.newSolid", json!({"color": "#ffffff"})).unwrap()["layer"].as_u64().unwrap();
let r = s.execute("prop.setExpression", json!({"layer": a, "path": "transform/opacity", "expression": "1 +* ("})).unwrap();
assert!(r["error"].is_string(), "{r}");
let pr = s.active_comp().unwrap().layers[0].props.prop("transform/opacity").unwrap().clone();
assert!(!pr.expr.unwrap().enabled);
assert_eq!(value(&s, a, "transform/opacity").as_f64(), 100.0);
s.execute("prop.setExpression", json!({"layer": a, "path": "transform/opacity", "expression": "50"})).unwrap();
assert_eq!(value(&s, a, "transform/opacity").as_f64(), 50.0);
}
/// Create Stereo 3D Rig: the eye cameras' expressions follow the master camera and the
/// Stereo 3D Controls (and agree with the values the command wrote).
#[test]
fn stereo_rig_expressions_follow_the_master_camera() {
let mut s = super::session();
s.execute("comp.new", json!({"name": "Shot", "width": 640, "height": 360, "frameRate": 30, "duration": 2})).unwrap();
let src = s.active_comp_id().unwrap();
let cam = s.execute("layer.newCamera", json!({"name": "Main", "position": [320, 180, -800], "poi": [320, 180, 0], "zoom": 900})).unwrap()["layer"]
.as_u64()
.unwrap();
let r = s.execute("camera.stereoRig", json!({"sceneDepth": 4})).unwrap();
let ctl = r["controls"].as_u64().unwrap();
let left = effectcraft_engine::project::ItemId(r["leftComp"].as_u64().unwrap());
// The left eye camera's evaluated value (expressions on).
let v3 = |s: &effectcraft_engine::Session, path: &str| {
let comp = s.project.comp(left).unwrap();
let layer = &comp.layers[0];
let ctx = effectcraft_engine::render::EvalCtx {
project: &s.project,
comp_id: left,
comp,
time: Default::default(),
expr: s.expr.as_deref(),
footage: None,
property_overrides: &[],
media_overrides: &[],
reads: None,
};
ctx.value(layer, layer.props.prop(path).unwrap()).as_vec3()
};
let close = |a: [f64; 3], b: [f64; 3]| (0..3).all(|i| (a[i] - b[i]).abs() < 1e-6);
let d = 0.04 * 640.0;
assert!(close(v3(&s, "transform/position"), [320.0 - d / 2.0, 180.0, -800.0]), "{:?}", v3(&s, "transform/position"));
assert!(close(v3(&s, "transform/poi"), [320.0 - d / 2.0, 180.0, 0.0]), "{:?}", v3(&s, "transform/poi"));
// Moving the master moves the eyes.
s.execute("comp.open", json!({"comp": src.0})).unwrap();
s.execute("prop.set", json!({"layer": cam, "path": "transform/position", "value": [300, 180, -800]})).unwrap();
s.execute("prop.set", json!({"layer": cam, "path": "transform/poi", "value": [300, 180, 0]})).unwrap();
assert!(close(v3(&s, "transform/position"), [300.0 - d / 2.0, 180.0, -800.0]), "{:?}", v3(&s, "transform/position"));
// Controls: Center & Left puts the left eye a full separation left; convergence toes in.
s.execute("prop.set", json!({"layer": ctl, "path": "effects/#1/configuration", "value": 2})).unwrap();
s.execute("prop.set", json!({"layer": ctl, "path": "effects/#1/convergence", "value": true})).unwrap();
assert!(close(v3(&s, "transform/position"), [300.0 - d, 180.0, -800.0]), "{:?}", v3(&s, "transform/position"));
assert!(close(v3(&s, "transform/poi"), [300.0, 180.0, 0.0]), "{:?}", v3(&s, "transform/poi"));
}
/// A text layer showing a 3D model's name (`thisComp.layer("Model").source.name`): renaming the
/// model gives the comp a new disk key and the text shows the new name (expressions on).
#[test]
fn renaming_a_model_a_text_expression_reads_changes_the_key_and_the_text() {
use effectcraft_engine::Session;
let mut s = super::session();
let cid = effectcraft_project::ItemId(
s.execute("comp.new", json!({"name": "M", "width": 160, "height": 60, "frameRate": 30, "duration": 1})).unwrap()["comp"].as_u64().unwrap(),
);
let model = s
.edit("add model", None, |p, _| {
let f = effectcraft_project::Footage { kind: effectcraft_project::FootageKind::Model, ..Default::default() };
let model = p.add_item("chair.glb", Default::default(), None, effectcraft_project::ItemKind::Footage(f));
let comp = p.comp(cid).cloned().unwrap();
let mut l = effectcraft_project::build::layer(p, &comp, "Model", effectcraft_project::LayerSource::Model { item: model }, (16, 16), None);
// (not drawn: no model file; an expression still reads its source)
l.switches.video = false;
p.comp_mut(cid).unwrap().layers.push(l);
Ok(model)
})
.unwrap();
let text = s.execute("layer.newText", json!({"comp": cid.0, "text": "x"})).unwrap()["layer"].as_u64().unwrap();
s.execute("prop.setExpression", json!({"comp": cid.0, "layer": text, "path": "text/sourceText", "expression": "thisComp.layer(\"Model\").source.name"}))
.unwrap();
let key = effectcraft_engine::render::disk_cache::comp_content_key(&s.project, cid);
let shown = |s: &mut Session| s.execute("prop.get", json!({"comp": cid.0, "layer": text, "path": "text/sourceText"})).unwrap()["evaluated"].to_string();
assert!(shown(&mut s).contains("chair.glb"), "{}", shown(&mut s));
s.execute("project.rename", json!({"item": model.0, "name": "table.glb"})).unwrap();
assert_ne!(effectcraft_engine::render::disk_cache::comp_content_key(&s.project, cid), key, "the comp's frames on disk hold the old name");
assert!(shown(&mut s).contains("table.glb"), "the text shows the new name: {}", shown(&mut s));
}