665bfac0b339
ui_camera_tracker.rs
//! Headless checks for the 3D Camera Tracker UI (egui_kittest, UI logic only): the viewer's track
//! points and selection, the Effect Controls buttons and the Tracker panel's Track Camera button.
//! The solve is a synthetic one written into the effect (the analysis itself is tested in the
//! engine and track crates).
use crate::gpu_test::RenderSerial;
use effectcraft_engine::Session;
use effectcraft_engine::effects::camera_tracker as ct;
use effectcraft_engine::track::camtrack::{CameraSolve, ShotType, SolveMethod, SolvedFrame, SolvedPoint};
use effectcraft_ui_egui::EffectcraftApp;
use effectcraft_ui_egui::dock::PanelKind;
use egui_kittest::Harness;
use serde_json::json;
const W: f64 = 640.0;
const H: f64 = 360.0;
fn app() -> (EffectcraftApp, u64, u64) {
let mut s = Session::default();
s.execute("comp.new", json!({"name": "Shot", "width": W as u32, "height": H as u32, "duration": 2, "frameRate": 30})).unwrap();
let plate =
s.execute("layer.newSolid", json!({"name": "Plate", "color": "#406080", "width": W as u32, "height": H as u32})).unwrap()["layer"].as_u64().unwrap();
let r = s.execute("effect.apply", json!({"effect": ct::ID, "layers": [plate]})).unwrap();
let uid = r["effects"][0].as_u64().unwrap();
// A synthetic solve: a static camera (focal 600) looking at a 6 ร 4 grid of points on z = 1.
let frames = 60;
let solve = CameraSolve {
version: 1,
size: [W, H],
start: 0.0,
frame_duration: 1.0 / 30.0,
shot: ShotType::FixedAngle,
method_used: SolveMethod::Typical,
average_error: 0.21,
frames: vec![SolvedFrame { rot: [0.0; 3], center: [0.0; 3], focal: 600.0, solved: true }; frames],
points: (0..24)
.map(|i| SolvedPoint {
id: i,
pos: [((i % 6) as f64 - 2.5) * 0.15, ((i / 6) as f64 - 1.5) * 0.12, 1.0 + 0.01 * (i % 3) as f64],
error: 0.2,
first: 0,
last: frames as u32 - 1,
})
.collect(),
ground: None,
distortion: None,
};
s.execute("prop.set", json!({"layer": plate, "path": "effects/#1/solve", "value": solve.to_json()})).unwrap();
s.camera_pending.clear();
s.state.selected_props = vec![(effectcraft_engine::project::LayerId(plate), uid)];
s.execute("layer.select", json!({"layers": [plate]})).unwrap();
s.state.selected_props = vec![(effectcraft_engine::project::LayerId(plate), uid)];
(EffectcraftApp::new(s), plate, uid)
}
fn ids(h: &Harness<'_, EffectcraftApp>) -> Vec<String> {
h.state().auto.previous.iter().chain(h.state().auto.elements.iter()).map(|e| e.id.clone()).collect()
}
fn rect(h: &Harness<'_, EffectcraftApp>, id: &str) -> egui::Rect {
let e = h.state().auto.find(id).unwrap_or_else(|| panic!("no {id}"));
egui::Rect::from_min_size(egui::pos2(e.rect[0], e.rect[1]), egui::vec2(e.rect[2], e.rect[3]))
}
fn click(h: &mut Harness<'_, EffectcraftApp>, at: egui::Pos2, modifiers: egui::Modifiers) {
h.input_mut().events.push(egui::Event::ModifiersChanged(modifiers));
h.input_mut().events.push(egui::Event::PointerMoved(at));
h.input_mut().events.push(egui::Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed: true, modifiers });
h.input_mut().events.push(egui::Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed: false, modifiers });
h.run_steps(3);
h.input_mut().events.push(egui::Event::ModifiersChanged(Default::default()));
h.step();
}
#[test]
fn deleting_viewer_track_points_preserves_the_effect_and_layer() {
let (a, plate, uid) = app();
let mut h = Harness::builder().with_size(egui::vec2(1600.0, 1000.0)).build_eframe(|_| a);
h.state_mut().show_panel(PanelKind::Composition);
h.run_steps(4);
let point = rect(&h, "viewer.cameraTracker.point.7").center();
click(&mut h, point, Default::default());
h.state_mut().ui.focused = PanelKind::Composition;
h.input_mut().events.push(egui::Event::Key { key: egui::Key::Delete, physical_key: None, pressed: true, repeat: false, modifiers: Default::default() });
h.run_steps(3);
let layer = h.state().session.active_comp().unwrap().layer(effectcraft_engine::project::LayerId(plate)).unwrap();
let effect = layer.props.find_group(uid).expect("tracker effect survived");
let params = effectcraft_engine::camera_track::static_params(effect);
assert!(ct::deleted(¶ms).contains(&7));
}
#[test]
fn viewer_points_selection_and_effect_controls() {
let (a, plate, uid) = app();
let mut h = Harness::builder().with_size(egui::vec2(1600.0, 1000.0)).build_eframe(|_| a);
h.state_mut().show_panel(PanelKind::Composition);
h.run_steps(4);
let all = ids(&h);
assert!(all.iter().any(|i| i == "viewer.cameraTracker"), "track point overlay registered");
let mut pts: Vec<&String> = all.iter().filter(|i| i.starts_with("viewer.cameraTracker.point.")).collect();
pts.sort();
pts.dedup();
let n = pts.len();
assert_eq!(n, 24, "every visible point is drawn");
// Click a point: it is selected; Shift-click another adds it.
let r = rect(&h, "viewer.cameraTracker.point.7");
click(&mut h, r.center(), Default::default());
assert_eq!(h.state().session.state.camera_points, vec![7]);
let r = rect(&h, "viewer.cameraTracker.point.9");
click(&mut h, r.center(), egui::Modifiers::SHIFT);
assert_eq!(h.state().session.state.camera_points, vec![7, 9]);
// Marquee over the first row selects its six points.
let (a0, a5) = (rect(&h, "viewer.cameraTracker.point.0"), rect(&h, "viewer.cameraTracker.point.5"));
let from = a0.left_top() - egui::vec2(6.0, 6.0);
let to = a5.right_bottom() + egui::vec2(6.0, 6.0);
h.input_mut().events.push(egui::Event::PointerMoved(from));
h.input_mut().events.push(egui::Event::PointerButton { pos: from, button: egui::PointerButton::Primary, pressed: true, modifiers: Default::default() });
h.step();
for i in 1..=8 {
h.input_mut().events.push(egui::Event::PointerMoved(from + (to - from) * (i as f32 / 8.0)));
h.step();
}
h.input_mut().events.push(egui::Event::PointerButton { pos: to, button: egui::PointerButton::Primary, pressed: false, modifiers: Default::default() });
h.run_steps(3);
let mut sel = h.state().session.state.camera_points.clone();
sel.sort();
assert_eq!(sel, vec![0, 1, 2, 3, 4, 5]);
// The right-click menu's Create Solid and Camera (via its command).
let ctx = h.ctx.clone();
effectcraft_ui_egui::menus::invoke(h.state_mut(), &ctx, "camera.createFromSolve", json!({"kind": "solid"})).unwrap();
let comp = h.state().session.active_comp().unwrap();
assert!(comp.layers.iter().any(|l| l.name == "3D Tracker Camera" && l.is_camera()));
assert!(comp.layers.iter().any(|l| l.name.starts_with("Track Solid")));
// Effect Controls: Analyze and Create Camera.
h.state_mut().session.execute("layer.select", json!({"layers": [plate]})).unwrap();
h.state_mut().show_panel(PanelKind::EffectControls);
h.run_steps(4);
let all = ids(&h);
for want in [
format!("effectControls.cameraTracker.{uid}.analyze"),
format!("effectControls.cameraTracker.{uid}.createCamera"),
format!("effectControls.cameraTracker.{uid}.exportBlender"),
] {
assert!(all.contains(&want), "missing {want}");
}
// Tracker panel: Track Camera is available for the selected layer.
h.state_mut().show_panel(PanelKind::Tracker);
h.run_steps(3);
assert!(ids(&h).iter().any(|i| i == "tracker.trackCamera"));
assert!(h.state().session.is_enabled("track.camera"));
}
#[test]
fn blender_export_button_opens_python_dialog_and_writes_scene() {
use effectcraft_engine::project::{Footage, FootageKind, ItemKind, LayerId, LayerSource};
let (mut a, plate, uid) = app();
let cid = a.session.active_comp_id().unwrap();
a.session
.edit("video fixture", None, |p, _| {
let item = p.add_item(
"Video",
Default::default(),
None,
ItemKind::Footage(Footage {
path: "/tmp/effectcraft-ui-synthetic.mp4".into(),
kind: FootageKind::Video,
width: W as u32,
height: H as u32,
has_video: true,
duration: effectcraft_engine::time::Tick::from_seconds_f64(2.0),
..Default::default()
}),
);
p.comp_mut(cid).unwrap().layer_mut(LayerId(plate)).unwrap().source = LayerSource::Footage { item };
Ok(())
})
.unwrap();
a.session.camera_pending.clear();
let output = std::env::temp_dir().join(format!("effectcraft-ui-blender-{}.py", std::process::id()));
let selected_path = output.clone();
a.hooks.pick_save_file = Some(Box::new(move |name, ext| {
assert!(name.ends_with(".py"));
assert_eq!(ext, "py");
Some(selected_path.to_string_lossy().into_owned())
}));
let shot = std::env::var("EFFECTCRAFT_BLENDER_UI_SNAPSHOT").ok();
let builder = Harness::builder().with_size(egui::vec2(1600.0, 1000.0));
let builder = if shot.is_some() { builder.wgpu() } else { builder };
let _device = shot.is_some().then(crate::gpu_test::lock);
let mut h = builder.build_eframe(|_| a);
h.state_mut().show_panel(PanelKind::EffectControls);
h.run_steps(5);
let button = rect(&h, &format!("effectControls.cameraTracker.{uid}.exportBlender"));
if let Some(path) = shot {
h.render().expect("render export button").save(path).unwrap();
}
click(&mut h, button.center(), Default::default());
assert!(output.exists(), "UI export failed: {}", h.state().ui.status);
let script = std::fs::read_to_string(output).expect("clicking the export button saves a Python scene");
assert!(script.contains("def import_scene():"));
assert_eq!(h.state().session.active_comp().unwrap().layers.len(), 1, "export does not create a camera in the source project");
}
/// A solve with unsolved (interpolated) frames says so in Effect Controls, with the count, on a
/// line of its own that pushes the Export button down.
#[test]
fn effect_controls_show_how_many_frames_a_partial_solve_solved() {
let (a, plate, uid) = app();
let mut h = Harness::builder().with_size(egui::vec2(1600.0, 1000.0)).build_eframe(|_| a);
h.state_mut().show_panel(PanelKind::EffectControls);
h.run_steps(4);
let line = format!("effectControls.cameraTracker.{uid}.partialSolve");
let export = format!("effectControls.cameraTracker.{uid}.exportBlender");
assert!(!ids(&h).contains(&line), "a full solve has no partial-solve line");
let before = rect(&h, &export);
let g = h.state().session.active_comp().unwrap().layer(effectcraft_engine::project::LayerId(plate)).unwrap().props.find_group(uid).unwrap();
let mut solve = ct::solve(&effectcraft_engine::camera_track::static_params(g)).unwrap().as_ref().clone();
for f in solve.frames.iter_mut().skip(24) {
f.solved = false;
}
let s = &mut h.state_mut().session;
s.execute("prop.set", json!({"layer": plate, "path": "effects/#1/solve", "value": solve.to_json()})).unwrap();
s.camera_pending.clear();
h.run_steps(4);
let e = h.state().auto.find(&line).expect("the partial-solve line is drawn");
assert_eq!(e.label, "Partial solve: 24 of 60 frames solved");
assert!((rect(&h, &export).min.y - before.min.y - 18.0).abs() < 0.5, "the Export button moves down one line");
}
/// Drag with `button` from `from` to `to` in steps, then release.
fn drag_with(h: &mut Harness<'_, EffectcraftApp>, button: egui::PointerButton, from: egui::Pos2, to: egui::Pos2) {
h.input_mut().events.push(egui::Event::PointerMoved(from));
h.input_mut().events.push(egui::Event::PointerButton { pos: from, button, pressed: true, modifiers: Default::default() });
h.step();
for i in 1..=8 {
h.input_mut().events.push(egui::Event::PointerMoved(from + (to - from) * (i as f32 / 8.0)));
h.step();
}
h.input_mut().events.push(egui::Event::PointerButton { pos: to, button, pressed: false, modifiers: Default::default() });
h.run_steps(3);
}
/// #505: with the track points shown, the wheel still zooms the viewer, and a middle-button drag
/// and a Spacebar (Hand tool) drag over the points still pan it.
#[test]
fn viewer_zooms_and_pans_over_the_track_points() {
let (a, ..) = app();
let mut h = Harness::builder().with_size(egui::vec2(1600.0, 1000.0)).build_eframe(|_| a);
h.state_mut().show_panel(PanelKind::Composition);
h.run_steps(4);
// Wheel over a point: zooms.
let at = rect(&h, "viewer.cameraTracker.point.7").center();
let zoom = h.state().ui.viewer.zoom;
h.input_mut().events.push(egui::Event::PointerMoved(at));
h.input_mut().events.push(egui::Event::MouseWheel {
unit: egui::MouseWheelUnit::Line,
delta: egui::vec2(0.0, 3.0),
modifiers: Default::default(),
phase: egui::TouchPhase::Move,
source: egui::MouseWheelSource::Wheel,
});
h.run_steps(20);
assert_ne!(h.state().ui.viewer.zoom, zoom, "the wheel zooms over the track points");
// Middle-button drag from a point: pans, and selects nothing.
let at = rect(&h, "viewer.cameraTracker.point.7").center();
let before = h.state().ui.viewer.pan;
drag_with(&mut h, egui::PointerButton::Middle, at, at + egui::vec2(120.0, 60.0));
let after = h.state().ui.viewer.pan;
assert!((after[0] - before[0] - 120.0).abs() < 1.0 && (after[1] - before[1] - 60.0).abs() < 1.0, "{before:?} โ {after:?}");
assert!(h.state().session.state.camera_points.is_empty(), "a pan selects no points");
// Spacebar held: a primary drag from a point pans instead of drawing a marquee.
let at = rect(&h, "viewer.cameraTracker.point.7").center();
let space = |h: &mut Harness<'_, EffectcraftApp>, pressed: bool| {
h.input_mut().events.push(egui::Event::Key { key: egui::Key::Space, physical_key: None, pressed, repeat: false, modifiers: Default::default() });
h.step();
};
space(&mut h, true);
drag_with(&mut h, egui::PointerButton::Primary, at, at + egui::vec2(80.0, 40.0));
space(&mut h, false);
let end = h.state().ui.viewer.pan;
assert!((end[0] - after[0] - 80.0).abs() < 1.0 && (end[1] - after[1] - 40.0).abs() < 1.0, "{after:?} โ {end:?}");
assert!(h.state().session.state.camera_points.is_empty(), "a Spacebar pan selects no points");
}
/// Step the UI until background frame renders have landed.
fn settle(h: &mut Harness<'_, EffectcraftApp>) {
for _ in 0..600 {
h.step();
if h.state().frames.inflight() == 0 && h.state().frames.last_ms.lock().map(|v| *v > 0.0).unwrap_or(false) {
break;
}
std::thread::sleep(std::time::Duration::from_millis(20));
}
for _ in 0..4 {
h.step();
}
}
#[test]
#[ignore = "analyses the demo's 3D Showcase and renders with wgpu; run with --ignored (set EC_SNAPSHOT_DIR to keep PNGs)"]
fn snapshot_showcase_track() {
let _device = crate::gpu_test::lock();
let dir = std::env::var("EC_SNAPSHOT_DIR").ok();
let mut s = Session::default();
s.execute("file.openDemoProject", json!({})).unwrap();
s.execute("comp.new", json!({"name": "Camera Track", "width": 1920, "height": 1080, "duration": 4, "frameRate": 29.97})).unwrap();
s.execute("layer.addItem", json!({"item": "3D Showcase"})).unwrap();
s.execute("layer.select", json!({"layers": ["#1"]})).unwrap();
s.execute("track.camera", json!({"layer": "#1", "wait": true})).unwrap();
s.execute("time.set", json!({"time": 2.0})).unwrap();
let mut h = Harness::builder().with_size(egui::vec2(1600.0, 1000.0)).with_pixels_per_point(1.0).wgpu().build_eframe(|_| EffectcraftApp::new(s));
h.state_mut().show_panel(PanelKind::Composition);
settle(&mut h);
let pts: Vec<String> = ids(&h).into_iter().filter(|i| i.starts_with("viewer.cameraTracker.point.")).collect();
assert!(pts.len() > 10, "{}", pts.len());
// Hover between points to show a target, then select three and show the selection's target.
let r = rect(&h, &pts[0]);
h.input_mut().events.push(egui::Event::PointerMoved(r.center() + egui::vec2(12.0, 12.0)));
h.run_steps(2);
if let Some(d) = &dir {
h.render_serialized().expect("render").save(format!("{d}/camera_tracker_hover.png")).unwrap();
}
let sel: Vec<u64> = pts.iter().take(5).filter_map(|i| i.rsplit('.').next()?.parse().ok()).collect();
h.state_mut().session.execute("camera.selectPoints", json!({"points": sel})).unwrap();
h.state_mut().session.execute("camera.createFromSolve", json!({"kind": "solid"})).unwrap();
h.state_mut().session.execute("layer.select", json!({"layers": ["#3"]})).unwrap();
settle(&mut h);
if let Some(d) = &dir {
h.render_serialized().expect("render").save(format!("{d}/camera_tracker_solid.png")).unwrap();
}
}
No file is open. Choose one in the tree, or press Ctrl+O (โO on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.