f67d38b35cc5
multicam.rs
//! Multi-camera UI: the Program monitor's Multi-Camera view (angle grid next to the program) and
//! the Synchronize, Merge Clips and Create Multi-Camera Source Sequence dialogs.
//!
//! The grid is one frame job ([`Target::MulticamGrid`]): every shown angle rendered at the grid
//! cell's size (reduced resolution) and tiled, prefetched like the program while playing.
//! Clicking an angle (or keys 1–9) cuts to it while recording (playing with Multi-Camera Record
//! on) and switches the clip at the playhead when stopped; Ctrl/⌘-click switches the video only.
//!
//! Automation ids:
//! - Multi-Camera view: `program.multicam.grid`, `program.multicam.angle.<n>` (n = 1-based camera
//! in shown order, so cameras on page 2 of a 4×4 grid are 17…), `program.multicam.record`,
//! `program.multicam.pagePrev`, `program.multicam.pageNext` (when there is more than one page).
//! - Edit Cameras dialog (`multicam.editCamerasDialog`): `editCameras.name.<angle>`,
//! `editCameras.enabled.<angle>`, `editCameras.thumb.<angle>`, `editCameras.ok`, `editCameras.cancel`.
//! - Synchronize: `sync.method.<in|out|timecode|marker|audio>`, `sync.ignoreHours`, `sync.marker`,
//! `sync.offset`, `sync.track`, `sync.ok`, `sync.cancel`.
//! - Merge Clips: `merge.name`, `merge.method.<…>`, `merge.ignoreHours`, `merge.marker`,
//! `merge.offset`, `merge.removeVideoAudio`, `merge.ok`, `merge.cancel`.
//! - Create Multi-Camera Source Sequence: `mcam.name`, `mcam.method.<…>`, `mcam.ignoreHours`,
//! `mcam.marker`, `mcam.offset`, `mcam.audio.<camera1|all|switch>`,
//! `mcam.cameraNames.<clip|track|metadata>`, `mcam.processedBin`, `mcam.ok`, `mcam.cancel`.
use egui::{Align2, Color32, Rect, RichText, Sense, Stroke, StrokeKind, pos2, vec2};
use filmcraft_project::ItemId;
use filmcraft_time::Tick;
use serde_json::{Value, json};
use crate::FilmcraftApp;
use crate::frames::{FrameKey, Target};
use crate::state::SyncDraft;
use crate::theme::Tokens;
type Elems = Vec<(String, Rect, String)>;
/// Menu / shortcut entry points: the three dialogs (without params) and the view toggles.
pub fn route(app: &mut FilmcraftApp, id: &str, params: &Value) -> Option<Result<Value, String>> {
match id {
"multicam.toggleView" => {
app.ui.program.multicam = params.get("enabled").and_then(Value::as_bool).unwrap_or(!app.ui.program.multicam);
return Some(Ok(json!({"multicam": app.ui.program.multicam})));
}
"multicam.editCamerasDialog" => {
let Some(src) = filmcraft_engine::multicam::multicam_clip_at(&app.session, app.session.playhead()).map(|c| c.1.item) else {
return Some(Err("no multi-camera clip at the playhead".into()));
};
let cams = app.session.project.sequence(src).map(|q| q.cameras()).unwrap_or_default();
app.ui.edit_cameras = Some(crate::state::EditCamerasDraft {
sequence: src.0,
names: cams.cameras.iter().map(|c| c.name.clone()).collect(),
enabled: cams.cameras.iter().map(|c| c.enabled).collect(),
});
return Some(Ok(json!({"dialog": "editCameras", "sequence": src.0})));
}
"multicam.recordToggle" => {
app.ui.multicam_record = params.get("enabled").and_then(Value::as_bool).unwrap_or(!app.ui.multicam_record);
app.ui.status = if app.ui.multicam_record { tl!("Multi-Camera Record on") } else { tl!("Multi-Camera Record off") }.to_string();
return Some(Ok(json!({"record": app.ui.multicam_record})));
}
_ => {}
}
if !params.as_object().is_none_or(|m| m.is_empty()) {
return None;
}
let kind = match id {
"clip.synchronize" => "synchronize",
"clip.mergeClips" => "merge",
"clip.createMulticam" => "multicam",
_ => return None,
};
if let Err(e) = filmcraft_engine::find_command(id).map_or(Ok(()), |c| (c.enabled)(&app.session)) {
return Some(Err(e));
}
// the Project panel's selection, or the media of the clips selected in the Timeline (#1362)
let selected = filmcraft_engine::multicam::selected_items(&app.session);
let items: Vec<u64> = selected.iter().map(|i| i.0).collect();
let first = selected.first().and_then(|i| app.session.project.item(*i)).map(|i| i.name.clone()).unwrap_or_default();
let name = match kind {
"merge" => tlf!("{first} - Merged", first),
"multicam" => tlf!("{first} Multicam", first),
_ => String::new(),
};
app.ui.sync_dialog = Some(SyncDraft { kind: kind.into(), items, name, ..Default::default() });
Some(Ok(json!({"dialog": kind})))
}
fn push(elems: &mut Elems, id: impl Into<String>, r: &egui::Response, label: impl Into<String>) {
elems.push((id.into(), r.rect, label.into()));
}
/// Synchronize Point choices: (key, label).
fn methods() -> [(&'static str, &'static str); 5] {
[("in", tl!("In Points")), ("out", tl!("Out Points")), ("timecode", tl!("Timecode")), ("marker", tl!("Clip Marker")), ("audio", tl!("Audio"))]
}
/// Draw the open Synchronize / Merge Clips / Create Multi-Camera dialog.
pub fn show_dialog(app: &mut FilmcraftApp, ctx: &egui::Context) {
let Some(mut d) = app.ui.sync_dialog.clone() else { return };
crate::widgets::revert_drag_on_escape(ctx, egui::Id::unique("sync-dialog-before-drag"), &mut d);
let (title, pre) = match d.kind.as_str() {
"merge" => (tl!("Merge Clips"), "merge"),
"multicam" => (tl!("Create Multi-Camera Source Sequence"), "mcam"),
_ => (tl!("Synchronize Clips"), "sync"),
};
let mut elems: Elems = Vec::new();
let mut action: Option<&str> = None;
let accent = app.tokens.accent;
let names: Vec<String> = d.items.iter().filter_map(|i| app.session.project.item(ItemId(*i)).map(|it| it.name.clone())).collect();
egui::Window::new(title)
.id(egui::Id::unique(("sync-dialog", pre)))
.collapsible(false)
.resizable(false)
.default_width(440.0)
.pivot(Align2::CENTER_CENTER)
.default_pos(crate::widgets::dialog_center(ctx))
.show(ctx, |ui| {
if pre != "sync" {
ui.horizontal(|ui| {
ui.label(if pre == "merge" { tl!("Clip Name:") } else { tl!("Sequence Name:") });
let r = crate::widgets::accessible_name(ui.add(egui::TextEdit::singleline(&mut d.name).desired_width(300.0)), "Sequence Name");
push(&mut elems, format!("{pre}.name"), &r, "name");
});
ui.label(RichText::new(tlf!("{n} clip(s): {names}", n = names.len(), names = names.join(", "))).weak().small());
ui.add_space(4.0);
} else {
let n = app.session.state.selection.len();
ui.label(RichText::new(tlf!("{n} clip(s) selected; the clip on the reference track stays put.", n)).weak().small());
}
ui.group(|ui| {
ui.set_min_width(400.0);
ui.label(RichText::new(tl!("Synchronize Point")).strong());
for (m, label) in methods() {
ui.horizontal(|ui| {
let r = ui.radio(d.method == m, label);
push(&mut elems, format!("{pre}.method.{m}"), &r, label);
if r.clicked() {
d.method = m.into();
}
match m {
"timecode" => {
let r = ui.add_enabled(d.method == "timecode", egui::Checkbox::new(&mut d.ignore_hours, tl!("Ignore Hours")));
push(&mut elems, format!("{pre}.ignoreHours"), &r, "Ignore Hours");
}
"marker" => {
let r = crate::widgets::accessible_name(
ui.add_enabled(
d.method == "marker",
egui::TextEdit::singleline(&mut d.marker).hint_text(tl!("first marker")).desired_width(140.0),
),
"first marker",
);
push(&mut elems, format!("{pre}.marker"), &r, "marker name");
}
_ => {}
}
});
}
ui.horizontal(|ui| {
ui.label(if pre == "merge" { tl!("Offset Audio by:") } else { tl!("Offset:") });
let r = ui.add(crate::widgets::number_drag(&mut d.offset).range(-100_000..=100_000).suffix(tl!(" frames")));
push(&mut elems, format!("{pre}.offset"), &r, "offset");
});
});
match pre {
"sync" => {
ui.horizontal(|ui| {
ui.label(tl!("Reference track:"));
let r = crate::widgets::accessible_name(
ui.add(egui::TextEdit::singleline(&mut d.track).hint_text(tl!("lowest (V1…)")).desired_width(90.0)),
"Reference track",
);
push(&mut elems, "sync.track", &r, "reference track");
});
}
"merge" => {
let r = ui.checkbox(&mut d.remove_video_audio, tl!("Remove Audio from AV Clip"));
push(&mut elems, "merge.removeVideoAudio", &r, "Remove Audio from AV Clip");
}
_ => {
ui.group(|ui| {
ui.set_min_width(400.0);
ui.label(RichText::new(tl!("Audio")).strong());
ui.horizontal(|ui| {
for (a, label) in [("camera1", tl!("Camera 1")), ("all", tl!("All Cameras")), ("switch", tl!("Switch Audio"))] {
let r = ui.radio(d.audio == a, label);
push(&mut elems, format!("mcam.audio.{a}"), &r, label);
if r.clicked() {
d.audio = a.into();
}
}
});
ui.label(RichText::new(tl!("Camera Names")).strong());
ui.horizontal(|ui| {
for (a, label) in [("clip", tl!("Clip Names")), ("track", tl!("Enumerate Cameras")), ("metadata", tl!("Camera Angle Metadata"))] {
let r = ui.radio(d.camera_names == a, label);
push(&mut elems, format!("mcam.cameraNames.{a}"), &r, label);
if r.clicked() {
d.camera_names = a.into();
}
}
});
});
let r = ui.checkbox(&mut d.processed_bin, tl!("Move source clips to Processed Clips bin"));
push(&mut elems, "mcam.processedBin", &r, "Move source clips to Processed Clips bin");
}
}
if !d.message.is_empty() {
ui.colored_label(Color32::from_rgb(0xe0, 0x8a, 0x6a), &d.message);
}
ui.add_space(6.0);
ui.horizontal(|ui| {
let r = ui.button(tl!("Cancel"));
push(&mut elems, format!("{pre}.cancel"), &r, "Cancel");
if r.clicked() {
action = Some("cancel");
}
let r = ui.add(egui::Button::new(RichText::new(tl!("OK")).color(Color32::WHITE)).fill(accent));
push(&mut elems, format!("{pre}.ok"), &r, "OK");
if r.clicked() {
action = Some("ok");
}
});
});
for (id, r, l) in elems {
app.auto.add(&id, r, &l);
}
if crate::widgets::escape_closes(ctx) {
action = Some("cancel");
}
match action {
Some("cancel") => {
app.ui.sync_dialog = None;
return;
}
Some("ok") => {
let mut p = json!({"method": d.method, "offset": d.offset, "ignoreHours": d.ignore_hours});
if !d.marker.is_empty() {
p["marker"] = json!(d.marker);
}
let cmd = match pre {
"merge" => {
p["items"] = json!(d.items);
p["removeVideoAudio"] = json!(d.remove_video_audio);
if !d.name.is_empty() {
p["name"] = json!(d.name);
}
"clip.mergeClips"
}
"mcam" => {
p["items"] = json!(d.items);
p["audio"] = json!(d.audio);
p["cameraNames"] = json!(d.camera_names);
p["processedBin"] = json!(d.processed_bin);
if !d.name.is_empty() {
p["name"] = json!(d.name);
}
"clip.createMulticam"
}
_ => {
if !d.track.is_empty() {
p["track"] = json!(d.track);
}
"clip.synchronize"
}
};
match app.session.execute(cmd, p) {
Ok(v) => {
app.ui.status = match pre {
"sync" => tlf!("Synchronized {n} clip group(s)", n = v["moved"]),
"merge" => tl!("Merged clip created").into(),
_ => tlf!("Multi-camera source sequence with {n} camera(s)", n = v["cameras"].as_array().map_or(0, Vec::len)),
};
app.ui.sync_dialog = None;
return;
}
Err(e) => d.message = e.to_string(),
}
}
_ => {}
}
app.ui.sync_dialog = Some(d);
}
/// A revision for grid frames: changes when the multi-camera source (or its cameras' media)
/// changes, not with every edit of the cut (cuts recorded live must not throw away the grid).
fn grid_revision(app: &FilmcraftApp, src: ItemId) -> u64 {
use std::hash::{Hash, Hasher};
let mut h = std::collections::hash_map::DefaultHasher::new();
if let Some(q) = app.session.project.sequence(src) {
serde_json::to_vec(q).unwrap_or_default().hash(&mut h);
for t in &q.video_tracks {
for it in &t.items {
app.item_revision(it.item).hash(&mut h);
}
}
}
h.finish()
}
/// The angle grid of the Multi-Camera view in `area`.
pub fn grid(app: &mut FilmcraftApp, ui: &mut egui::Ui, area: Rect) {
let t = app.tokens;
let ctx = ui.ctx().clone();
ui.painter().rect_filled(area, 0.0, t.panel_bg);
app.auto.add("program.multicam.grid", area, "Multi-Camera");
let playhead = app.session.playhead();
let info = filmcraft_engine::multicam::inspect_at(&app.session, playhead);
let Some(src) = info["source"].as_u64().map(ItemId) else {
ui.painter().text(area.center(), Align2::CENTER_CENTER, tl!("No multi-camera clip at the playhead"), Tokens::ui(12.0), t.text_dim);
return;
};
let Some(q) = app.session.project.sequence(src) else { return };
let cams = q.cameras();
let shown = cams.shown_angles();
let view = app.session.state.multicam_view.clone();
let lay = view.page_layout(shown.len());
let (cols, rows) = (lay.cols, lay.rows);
let (sw, sh) = (q.settings.width as f32, q.settings.height as f32);
let rate = q.settings.frame_rate;
// page arrows under the grid when the angles don't fit on one page
let paged = lay.pages > 1;
let grid_area = if paged { Rect::from_min_max(area.min, pos2(area.max.x, area.max.y - 24.0)) } else { area };
let pic = crate::panels::monitor::fit(grid_area.shrink(2.0), sw * cols as f32, sh * rows as f32);
let (cw, ch) = (pic.width() / cols as f32, pic.height() / rows as f32);
// decode and composite at the cell's size (never more than the playback resolution; lower
// while playing with Auto-Adjust Multi-Camera Playback Quality)
let cell_px = cw * ctx.pixels_per_point();
let scale = crate::panels::monitor::quantize_scale(filmcraft_render::multicam::grid_cell_scale(
q.settings.width,
cell_px,
app.ui.program.res.scale(),
app.playback.playing,
view.auto_quality,
lay.per_page,
));
let mt = Tick(info["sourceTime"].as_i64().unwrap_or(0));
let frame = rate.frame_at(mt);
let target = Target::MulticamGrid(src, view.layout.unwrap_or(0) as u8, lay.page as u16);
let key = FrameKey { target, frame, size: (scale * 1000.0) as u32, revision: grid_revision(app, src), draft: false };
let project = app.session.project.clone();
if app.playback.playing {
app.frames.schedule_playback(key, rate, scale, &project, app.playback.speed, app.playback.preroll.is_some());
} else {
app.frames.request(key, rate.tick_of(frame), scale, &project, 0);
}
let tex = match app.frames.get(&key) {
Some(img) => Some(app.texture_for(&ctx, "monitor-multicam", key, &img)),
None => match app.frames.nearest(key.target, frame, key.size, key.revision, 6) {
Some(img) => Some(app.texture_for(&ctx, "monitor-multicam", FrameKey { frame: frame - 1, ..key }, &img)),
None => app.texture_existing("monitor-multicam").map(|(id, _)| id),
},
};
ui.painter().rect_filled(pic, 0.0, t.monitor_bg);
if let Some(tex) = tex {
ui.painter().image(tex, pic, Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0)), Color32::WHITE);
}
let current = info["angle"].as_u64().map(|a| a as usize);
let recording = app.session.mcrec.active();
let mut click: Option<(usize, bool)> = None;
for (k, &angle) in shown.iter().enumerate().skip(lay.first).take(lay.count) {
let cell_i = k - lay.first;
let cell = Rect::from_min_size(pic.min + vec2((cell_i % cols) as f32 * cw, (cell_i / cols) as f32 * ch), vec2(cw, ch));
let name = cams.cameras.get(angle).map(|c| c.name.clone()).unwrap_or_default();
let resp = ui.interact(cell, egui::Id::unique(("multicam-angle", k)), Sense::click()).on_hover_text(tlf!("Camera {n} — {name}", n = k + 1, name));
app.auto.add(&format!("program.multicam.angle.{}", k + 1), cell, &name);
if resp.clicked() {
// modifiers held now, or carried by the click event (synthetic input)
let video_only = ui.input(|i| {
let ev = i.events.iter().any(|e| matches!(e, egui::Event::PointerButton { modifiers: m, .. } if m.ctrl || m.command));
i.modifiers.ctrl || i.modifiers.command || ev
});
click = Some((k + 1, video_only));
}
if resp.hovered() {
ui.painter().rect_stroke(cell.shrink(1.0), 0.0, Stroke::new(1.0, Color32::from_white_alpha(90)), StrokeKind::Inside);
}
if current == Some(angle) {
// the active angle: yellow, red while recording
let col = if recording { Color32::from_rgb(0xe0, 0x3a, 0x3a) } else { Color32::from_rgb(0xf2, 0xc9, 0x4c) };
ui.painter().rect_stroke(cell.shrink(1.5), 0.0, Stroke::new(3.0, col), StrokeKind::Inside);
}
let label = format!("{} {name}", k + 1);
let galley = ui.painter().layout_no_wrap(label, Tokens::ui(11.0), Color32::WHITE);
let lr = Rect::from_min_size(cell.left_bottom() + vec2(6.0, -galley.size().y - 8.0), galley.size() + vec2(8.0, 4.0));
ui.painter().rect_filled(lr, 3.0, Color32::from_black_alpha(160));
ui.painter().galley(lr.min + vec2(4.0, 2.0), galley, Color32::WHITE);
}
if paged {
let bar = Rect::from_min_max(pos2(area.min.x, area.max.y - 22.0), area.max);
let mid = bar.center();
ui.painter().text(mid, Align2::CENTER_CENTER, tlf!("Page {page} of {pages}", page = lay.page + 1, pages = lay.pages), Tokens::ui(11.0), t.text_dim);
for (id, label, dx, cmd) in [("pagePrev", "◀", -70.0, "multicam.prevPage"), ("pageNext", "▶", 70.0, "multicam.nextPage")] {
let r = Rect::from_center_size(mid + vec2(dx, 0.0), vec2(26.0, 18.0));
let enabled = if cmd == "multicam.prevPage" { lay.page > 0 } else { lay.page + 1 < lay.pages };
let resp = ui.interact(r, egui::Id::unique(("multicam-page", id)), Sense::click()).on_hover_text(if dx < 0.0 {
tl!("Previous page")
} else {
tl!("Next page")
});
ui.painter().rect_filled(r, 3.0, if resp.hovered() && enabled { t.hover } else { t.field_bg });
ui.painter().text(r.center(), Align2::CENTER_CENTER, label, Tokens::ui(10.0), if enabled { t.text } else { t.text_faint });
app.auto.add(&format!("program.multicam.{id}"), r, label);
if resp.clicked() && enabled {
let _ = app.session.execute(cmd, json!({}));
}
}
}
// record indicator
let rr = Rect::from_min_size(area.min + vec2(8.0, 8.0), vec2(64.0, 18.0));
let rec_on = app.ui.multicam_record;
let resp = ui.interact(rr, egui::Id::unique("multicam-record"), Sense::click()).on_hover_text(tl!("Multi-Camera Record On/Off (0)"));
app.auto.add("program.multicam.record", rr, "Multi-Camera Record");
let dot = if recording {
Color32::from_rgb(0xe0, 0x3a, 0x3a)
} else if rec_on {
Color32::from_rgb(0x9a, 0x3a, 0x3a)
} else {
t.text_faint
};
ui.painter().rect_filled(rr, 3.0, Color32::from_black_alpha(140));
ui.painter().circle_filled(rr.left_center() + vec2(9.0, 0.0), 4.5, dot);
ui.painter().text(rr.left_center() + vec2(18.0, 0.0), Align2::LEFT_CENTER, if recording { "REC" } else { tl!("Record") }, Tokens::ui(10.5), Color32::WHITE);
if resp.clicked() {
app.ui.multicam_record = !app.ui.multicam_record;
}
if let Some((n, video_only)) = click
&& let Err(e) = app.session.execute("multicam.cut", json!({"camera": n, "videoOnly": video_only}))
{
app.ui.status = e.to_string();
}
}
/// The Edit Cameras dialog: a thumbnail, name and on/off switch per camera (`multicam.editCameras`).
pub fn show_edit_cameras(app: &mut FilmcraftApp, ctx: &egui::Context) {
let Some(mut d) = app.ui.edit_cameras.clone() else { return };
let src = ItemId(d.sequence);
let Some(q) = app.session.project.sequence(src).cloned() else {
app.ui.edit_cameras = None;
return;
};
let rate = q.settings.frame_rate;
let mt = filmcraft_engine::multicam::inspect_at(&app.session, app.session.playhead())["sourceTime"].as_i64().unwrap_or(0);
let frame = rate.frame_at(Tick(mt));
let rev = grid_revision(app, src);
let mut elems: Elems = Vec::new();
let mut action: Option<&str> = None;
let thumb_w = 96.0;
let scale = crate::panels::monitor::quantize_scale((thumb_w * ctx.pixels_per_point() / q.settings.width.max(1) as f32).clamp(1.0 / 32.0, 1.0));
let project = app.session.project.clone();
let mut thumbs = Vec::new();
for a in 0..d.names.len() {
let has_video = q.angle_video_track_index(a).is_some();
let key = FrameKey { target: Target::MulticamAngle(src, a as u32), frame, size: (scale * 1000.0) as u32, revision: rev, draft: false };
let tex = if has_video {
app.frames.request(key, rate.tick_of(frame), scale, &project, 2);
app.frames.get(&key).map(|img| app.texture_for(ctx, &format!("edit-cameras-{}-{a}", src.0), key, &img))
} else {
None
};
thumbs.push((has_video, tex));
}
let th = thumb_w * q.settings.height.max(1) as f32 / q.settings.width.max(1) as f32;
let tokens = app.tokens;
egui::Window::new(tl!("Edit Cameras"))
.id(egui::Id::unique("Edit Cameras"))
.collapsible(false)
.resizable(false)
.default_width(420.0)
.pivot(Align2::CENTER_CENTER)
.default_pos(crate::widgets::dialog_center(ctx))
.show(ctx, |ui| {
ui.label(RichText::new(tl!("Cameras shown in the Multi-Camera view (uncheck to hide).")).weak().small());
egui::ScrollArea::vertical().max_height(420.0).show(ui, |ui| {
for a in 0..d.names.len() {
ui.horizontal(|ui| {
let r = ui.checkbox(&mut d.enabled[a], "");
push(&mut elems, format!("editCameras.enabled.{a}"), &r, "Enabled");
let (tr, _) = ui.allocate_exact_size(vec2(thumb_w, th), Sense::hover());
ui.painter().rect_filled(tr, 2.0, tokens.monitor_bg);
match thumbs[a] {
(_, Some(tex)) => {
ui.painter().image(tex, tr, Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0)), Color32::WHITE);
}
(false, None) => {
ui.painter().text(tr.center(), Align2::CENTER_CENTER, tl!("Audio"), Tokens::ui(10.0), tokens.text_dim);
}
_ => {}
}
elems.push((format!("editCameras.thumb.{a}"), tr, format!("Camera {}", a + 1)));
ui.label(format!("{}", a + 1));
let r = crate::widgets::accessible_name(
ui.add(egui::TextEdit::singleline(&mut d.names[a]).desired_width(180.0)),
format!("Camera {}", a + 1),
);
push(&mut elems, format!("editCameras.name.{a}"), &r, "Camera name");
});
}
});
ui.add_space(6.0);
ui.horizontal(|ui| {
let r = ui.button(tl!("Cancel"));
push(&mut elems, "editCameras.cancel", &r, "Cancel");
if r.clicked() {
action = Some("cancel");
}
let r = ui.add(egui::Button::new(RichText::new(tl!("OK")).color(Color32::WHITE)).fill(tokens.accent));
push(&mut elems, "editCameras.ok", &r, "OK");
if r.clicked() {
action = Some("ok");
}
});
});
for (id, r, l) in elems {
app.auto.add(&id, r, &l);
}
if crate::widgets::escape_closes(ctx) {
action = Some("cancel");
}
match action {
Some("cancel") => app.ui.edit_cameras = None,
Some("ok") => {
let cameras: Vec<Value> = (0..d.names.len()).map(|a| json!({"angle": a, "name": d.names[a], "enabled": d.enabled[a]})).collect();
match app.session.execute("multicam.editCameras", json!({"sequence": src.0, "cameras": cameras})) {
Ok(_) => app.ui.edit_cameras = None,
Err(e) => {
app.ui.status = e.to_string();
app.ui.edit_cameras = Some(d);
}
}
}
_ => app.ui.edit_cameras = Some(d),
}
}
/// Start a recording pass when playback starts in the Multi-Camera view.
pub fn on_play(app: &mut FilmcraftApp) {
if app.ui.program.multicam && app.ui.multicam_record && !app.session.mcrec.active() && (app.playback.speed - 1.0).abs() < 1e-9 {
let t = app.session.playhead();
if filmcraft_engine::multicam::multicam_clip_at(&app.session, t).is_some() {
let _ = app.session.execute("multicam.recordStart", json!({"time": t.0}));
}
}
}
/// End the recording pass (one undo step) when playback stops.
pub fn on_stop(app: &mut FilmcraftApp) {
if app.session.mcrec.active() {
let t = app.session.playhead();
match app.session.execute("multicam.recordStop", json!({"time": t.0})) {
Ok(v) if v["cuts"].as_u64().unwrap_or(0) > 0 => app.ui.status = tlf!("Recorded {n} multi-camera cut(s)", n = v["cuts"]),
Ok(_) => {}
Err(e) => app.ui.status = e.to_string(),
}
}
}
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.