From b5ef186ccf25f533a03635acddee93526f72990d Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Thu, 19 Nov 2026 04:16:41 -0800 Subject: [PATCH 1/8] chore(quest): claim quest/m1/item-identity.md Quest-Claim: 72483bc6b5d392a8 From 50b0bdea2a1d617308d5dd8d2f7dd759714cc3b9 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Thu, 19 Nov 2026 05:48:18 -0800 Subject: [PATCH 2/8] feat(scene): each layer has an identity the studio keeps while it runs Items carry a runtime Id, never saved and ignored by equality. The compositor keys keep-clear placers, parks, and grabs by it; glides pair by it; undo, redo, and a reload keep it. Co-Authored-By: Claude Opus 5.5 --- quest/m1/item-identity.md | 50 --- rs/moq-scene/src/clip.rs | 3 +- rs/moq-scene/src/collection.rs | 202 +++++++++- rs/moq-scene/src/compositor.rs | 598 ++++++++++++------------------ rs/moq-scene/src/edit.rs | 194 +++++++++- rs/moq-scene/src/format.rs | 3 + rs/moq-scene/src/glide.rs | 35 +- rs/moq-scene/src/lib.rs | 2 +- rs/moq-scene/src/place.rs | 21 +- rs/moq-studio/src/engine.rs | 241 ++++-------- rs/moq-studio/src/shots.rs | 2 +- rs/moq-studio/src/ui/build.rs | 19 +- rs/moq-studio/src/ui/inspector.rs | 6 +- rs/moq-studio/src/ui/keep.rs | 56 ++- rs/moq-studio/src/ui/slots.rs | 7 +- rs/moq-studio/src/watch.rs | 6 +- 16 files changed, 807 insertions(+), 638 deletions(-) delete mode 100644 quest/m1/item-identity.md diff --git a/quest/m1/item-identity.md b/quest/m1/item-identity.md deleted file mode 100644 index e7d8e2e3..00000000 --- a/quest/m1/item-identity.md +++ /dev/null @@ -1,50 +0,0 @@ -# [M] Each layer has an identity the studio keeps while it runs - -## Goal - -Each item of a scene and of the top layer carries a runtime identity: a new -item gets a new one, an edit that changes an item keeps its own, undo and -redo bring back the one it had, and the scene file never saves it. What the -compositor keeps about a layer between frames is matched to its item by -that identity, not by where it sits, so adding, removing, reordering, or -duplicating layers never hands one layer's state to another. - -## Plan - -Keep out of the way (`rs/moq-scene/src/place.rs`) keeps a placer per layer: -what it saw, the slot it chose, and whether a move by hand holds it. With no -identity on an item, `compositor::follow` matches placers to items by -source, then saved rect, then index, after each edit. Two layers of the same -source at the same rect, as Duplicate makes them, can still trade placers -when a layer is added under both. Auto-layout's glide pairs items by source -for the same reason. - -- **The identity:** a counter-made id on `Item`, outside serde, that - `Item::new`, loading, and every edit that adds an item as a new one - assign: BUILD's Duplicate (`LayerAction::Duplicate`), paste, a drop on the - picture (`ui/drop.rs`), an Add, and a guest joining. `set_item` and the - history keep the id of the item they change, so an undo restores it. -- **Equality:** two collections that differ only in ids are equal, so - autosave, reload, and every change check behave as now. A reload assigns - fresh ids, then matches them to the items before by the same rule - `follow` uses, so a reload of an unchanged file keeps every placer. -- **Users:** the compositor's keepers key by id; `follow` keeps only the - reload match. The slots' glide (`rs/moq-scene/src/glide.rs`, which pairs - items by source) pairs by id where both sides have one. -- **Undo across layers:** a placer whose layer leaves its scene, as Keep - always on top does, stays parked under its id - while the history can bring the layer back, so the undo puts it back where - it was, as an undo of switching keep-clear off does now (#194's decision - 11). Today such an undo starts a fresh placer at the saved rect. -- **Tests:** duplicates of one camera keep their own placers across an - insert under both, a reorder, an undo of a removal, an undo of Keep always - on top, and a reload of an unchanged file. - -Decided 2026-11-17 (maintainer, on -[#194](https://github.com/moq-dev/studio/pull/194#issuecomment-6944247792)): -✅ a runtime identity, as its own quest (rejected: in #194, more matching -heuristics in #194). - -## Related - -- [A camera that keeps out of the way remembers each app](/quest/m1/auto-place.md) - another user of the placers this keys diff --git a/rs/moq-scene/src/clip.rs b/rs/moq-scene/src/clip.rs index f0bf54ee..4d2ea419 100644 --- a/rs/moq-scene/src/clip.rs +++ b/rs/moq-scene/src/clip.rs @@ -8,7 +8,7 @@ use serde::{Deserialize, Serialize}; use crate::Error; use crate::collection::{ - Audio, Collection, Filter, Item, Layer, Rect, Scene, Slot, Source, Video, validate_filters, versioned, + Audio, Collection, Filter, Id, Item, Layer, Rect, Scene, Slot, Source, Video, validate_filters, versioned, }; use crate::edit::Draft; @@ -278,6 +278,7 @@ impl Draft { layer, index, Item { + id: Id::fresh(), source, filters, slot, diff --git a/rs/moq-scene/src/collection.rs b/rs/moq-scene/src/collection.rs index d6ce3394..915d6605 100644 --- a/rs/moq-scene/src/collection.rs +++ b/rs/moq-scene/src/collection.rs @@ -5,6 +5,7 @@ use std::collections::{BTreeMap, BTreeSet}; use std::fmt; use std::path::PathBuf; use std::str::FromStr; +use std::sync::atomic::{AtomicU64, Ordering}; use std::time::Duration; use serde::{Deserialize, Serialize}; @@ -155,6 +156,35 @@ impl Collection { scenes.chain([(Layer::top(), self.top.as_slice())]) } + /// Give each item the [identity](Item::id) of the one it was in `before`, + /// as a reload of the scene file, which makes each fresh, needs. Each + /// layer is matched with the one of its name, or a renamed scene with + /// the scene no longer there it shares the most items with, and their + /// items in order, as [`recognized`] matches them: a layer added or + /// removed among them, or one edited, leaves the rest themselves, even + /// two alike. An item none matches stays new. + pub fn recognize(&mut self, before: &Collection) { + recognized(&before.top, &mut self.top); + let mut gone: Vec<&Scene> = (before.scenes.iter()) + .filter(|was| self.scene(&was.name).is_none()) + .collect(); + for scene in &mut self.scenes { + let was = match before.scene(&scene.name) { + Some(was) => was, + None => { + let shared = |was: &&Scene| recognized(&was.items, &mut scene.items.clone()); + let most = (gone.iter().enumerate()) + .map(|(at, was)| (shared(was), at)) + .filter(|(shared, _)| *shared > 0) + .min_by_key(|(shared, at)| (std::cmp::Reverse(*shared), *at)); + let Some((_, at)) = most else { continue }; + gone.remove(at) + } + }; + recognized(&was.items, &mut scene.items); + } + } + /// The scene recordings hold, or `None` for the program. pub fn recorded(&self) -> Option<&str> { let recorded = self.scenes.iter().find(|scene| scene.recorded); @@ -484,8 +514,17 @@ impl Collection { first.name, second.name ))); } + let mut ids = BTreeSet::new(); for (layer, items) in self.layers() { for item in items { + // Only a bug copies a layer without a fresh identity; refused, + // it never shares one layer's state with another. + if !ids.insert(item.id) { + return Err(Error::Invalid(format!( + "`{}` in {layer} is another layer under the same identity", + item.source + ))); + } let Some(source) = self.sources.get(&item.source) else { return Err(Error::Invalid(format!( "{layer} places `{}`, which is not a source", @@ -1256,9 +1295,18 @@ pub enum Nested<'a> { /// Every item naming the same source shows the same capture, with the /// source's filters: the items are linked. A [`Source::Clone`] shows another /// source's capture with filters of its own. -#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] +/// +/// Two items equal when all but their [`id`](Self::id) does, so a reload or +/// a change check reads the file's content alone. +#[derive(Clone, Debug, Serialize, Deserialize)] #[serde(deny_unknown_fields)] pub struct Item { + /// Who it is while the studio runs: a clone, and so an edit made to it + /// or an undo putting it back, is the same item, while a copy that is + /// another, such as a duplicate or a paste, takes a [fresh](Id::fresh) + /// one. The scene file never saves it, so loading one makes each fresh. + #[serde(skip, default = "Id::fresh")] + pub id: Id, /// The [`Collection::sources`] entry to draw. pub source: String, /// Where on the canvas, stretched to fill it. Empty, and left out of the @@ -1322,10 +1370,63 @@ pub struct Item { pub keep_clear: Option, } +impl PartialEq for Item { + fn eq(&self, other: &Self) -> bool { + // Listed whole, so a field added later is compared or left out on + // purpose. + let Self { + id: _, + source, + rect, + slot, + format, + portrait, + auto, + visible, + locked, + shape, + crop, + filters, + blend, + keyframes, + keep_clear, + } = self; + *source == other.source + && *rect == other.rect + && *slot == other.slot + && *format == other.format + && *portrait == other.portrait + && *auto == other.auto + && *visible == other.visible + && *locked == other.locked + && *shape == other.shape + && *crop == other.crop + && *filters == other.filters + && *blend == other.blend + && *keyframes == other.keyframes + && *keep_clear == other.keep_clear + } +} + +/// An [`Item`]'s identity while the studio runs, unique among every item +/// made since it started. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)] +pub struct Id(u64); + +impl Id { + /// One no item has had yet. + pub fn fresh() -> Self { + static NEXT: AtomicU64 = AtomicU64::new(0); + Self(NEXT.fetch_add(1, Ordering::Relaxed)) + } +} + impl Item { - /// `source` shown, uncropped, unfiltered, and still, at `rect`. + /// `source` shown, uncropped, unfiltered, and still, at `rect`: a new + /// item. pub fn new(source: impl Into, rect: Rect) -> Self { Self { + id: Id::fresh(), source: source.into(), rect, slot: None, @@ -1352,6 +1453,7 @@ impl Item { let mut filters = self.filters.clone(); filters.extend(offset.filters); Cow::Owned(Self { + id: self.id, source: self.source.clone(), slot: self.slot, format: self.format, @@ -2461,6 +2563,54 @@ impl Default for Audio { } } +/// Give each item of `new` the identity of the one of `old` it was, +/// returning how many it found: the longest run of items in order showing +/// the same source at the same rect, then of the rest, the longest showing +/// the same source. +pub(crate) fn recognized(old: &[Item], new: &mut [Item]) -> usize { + let mut taken = vec![false; old.len()]; + let mut found = vec![false; new.len()]; + for same_rect in [true, false] { + let left: Vec = (0..old.len()).filter(|&at| !taken[at]).collect(); + let missing: Vec = (0..new.len()).filter(|&at| !found[at]).collect(); + let same = |was: &Item, item: &Item| was.source == item.source && (!same_rect || was.rect == item.rect); + for (was, at) in common(&left, &missing, |was, at| same(&old[was], &new[at])) { + new[at].id = old[was].id; + taken[was] = true; + found[at] = true; + } + } + found.iter().filter(|&&found| found).count() +} + +/// The pairs of the longest common subsequence of `a` and `b`, as `same` +/// matches their elements, in order. +fn common(a: &[usize], b: &[usize], same: impl Fn(usize, usize) -> bool) -> Vec<(usize, usize)> { + // How long the common run of `a[i..]` and `b[j..]` is. + let mut runs = vec![vec![0usize; b.len() + 1]; a.len() + 1]; + for i in (0..a.len()).rev() { + for j in (0..b.len()).rev() { + runs[i][j] = match same(a[i], b[j]) { + true => runs[i + 1][j + 1] + 1, + false => runs[i + 1][j].max(runs[i][j + 1]), + }; + } + } + let (mut i, mut j) = (0, 0); + let mut pairs = Vec::new(); + while i < a.len() && j < b.len() { + if same(a[i], b[j]) && runs[i][j] == runs[i + 1][j + 1] + 1 { + pairs.push((a[i], b[j])); + (i, j) = (i + 1, j + 1); + } else if runs[i + 1][j] >= runs[i][j + 1] { + i += 1; + } else { + j += 1; + } + } + pairs +} + fn is_center(pan: &f32) -> bool { *pan == 0.0 } @@ -2511,6 +2661,52 @@ impl FromStr for Rgba { mod tests { use super::*; + /// A reload of an unchanged file gives each item the identity it had, + /// two showing one source at one rect included; one the file adds under + /// them, or a rename of their scene, takes none from another. + #[test] + fn a_reload_recognizes_each_item() { + let mut before = Collection::new(); + let color = Source::Color { color: Rgba([0; 4]) }; + before.sources.insert("camera".into(), color.clone()); + before.sources.insert("logo".into(), color); + let corner = Rect { + x: 10.0, + y: 10.0, + width: 20.0, + height: 20.0, + }; + let camera = Item::new("camera", corner); + let copy = Item { + id: Id::fresh(), + ..camera.clone() + }; + let moved = Item::new("camera", Rect { x: 50.0, ..corner }); + before.scenes[0].items = vec![camera, copy, moved]; + before.top.push(Item::new("logo", corner)); + let ids = |collection: &Collection| -> Vec { + let layers = collection.layers().flat_map(|(_, items)| items); + layers.map(|item| item.id).collect() + }; + + let mut reloaded = Collection::from_toml(&before.to_toml().unwrap()).unwrap(); + assert!( + ids(&reloaded).iter().all(|id| !ids(&before).contains(id)), + "loaded fresh" + ); + reloaded.recognize(&before); + assert_eq!(ids(&reloaded), ids(&before)); + + let mut edited = Collection::from_toml(&before.to_toml().unwrap()).unwrap(); + edited.scenes[0].name = "Renamed".into(); + edited.scenes[0].items.insert(0, Item::new("logo", corner)); + edited.scenes[0].items[3].rect.y = 70.0; + edited.recognize(&before); + let added = edited.scenes[0].items[0].id; + assert!(!ids(&before).contains(&added), "an added layer is new"); + assert_eq!(ids(&edited)[1..], ids(&before)[..]); + } + fn example() -> Collection { let mut collection = Collection::new(); collection.sources.insert( @@ -4005,6 +4201,7 @@ rect = { x = 1700, y = 40, width = 160, height = 90 } refused( &|c| { let mut item = c.scenes[0].items[0].clone(); + item.id = Id::fresh(); item.source = "Game".into(); c.top.push(item); }, @@ -4048,6 +4245,7 @@ rect = { x = 1700, y = 40, width = 160, height = 90 } let mut collection = Collection::from_toml(SLOTS).unwrap(); collection.sources.insert("Cam".into(), Source::Camera { id: None }); let mut guest = collection.scenes[0].items[1].clone(); + guest.id = Id::fresh(); guest.source = "Cam".into(); collection.scenes[0].items.insert(2, guest); collection.validate().unwrap(); diff --git a/rs/moq-scene/src/compositor.rs b/rs/moq-scene/src/compositor.rs index b9951da6..fc1d4730 100644 --- a/rs/moq-scene/src/compositor.rs +++ b/rs/moq-scene/src/compositor.rs @@ -12,7 +12,7 @@ use moq_video::render::Renderer; use crate::Error; use crate::arrange::cover; use crate::collection::{ - Background, Canvas, Collection, Crop, Direction, Filter, Item, Layer as Place, Nested, Rect, Settled, Shape, + Background, Canvas, Collection, Crop, Direction, Filter, Id, Item, Layer as Place, Nested, Rect, Settled, Shape, Source, Transition, }; use crate::dark::{Probe, Prober}; @@ -116,15 +116,16 @@ pub struct Compositor { /// How long the program scene had been on program as of the last render. program_shown: Duration, switch: Option, - /// Each scene item keeping clear, by its scene and place in it. It - /// places only the landscape picture: its portrait place stays as set. - keepers: HashMap<(String, usize), Keeper>, - /// Each scene item that stopped keeping clear, by its scene and place in - /// it, for as long as it is there and keeps clear of nothing. - parked: HashMap<(String, usize), Parked>, - /// The item keeping clear a gesture has in hand, by its scene, place, and - /// source, until when, unless the gesture says so again. - grabbed: Option<((String, usize, String), Instant)>, + /// Each scene item keeping clear, by its identity. It places only the + /// landscape picture: its portrait place stays as set. + keepers: HashMap, + /// The placer of each item that stopped keeping clear or left its scene, + /// by its identity, held where it was, so an undo that brings it back + /// puts it back, until [`remember`](Compositor::remember) leaves it out. + parked: HashMap, + /// The item keeping clear a gesture has in hand, until when, unless the + /// gesture says so again. + grabbed: Option<(Id, Instant)>, /// Reduces the pictures under them, made with the first. reducer: Option, } @@ -193,11 +194,6 @@ impl View { /// A scene item keeping clear: where it goes, and its reads of the picture /// under it. struct Keeper { - /// The source it shows: an item showing another is another keeper. - source: String, - /// The rect the scene file gave its item, as of the last render, which - /// tells it from another showing the same source. - rect: Rect, /// Whether the last render read its picture: its scene drawn and it /// shown. watched: bool, @@ -205,16 +201,6 @@ struct Keeper { look: Look, } -/// A scene item that stopped keeping clear: where it went, held since, so an -/// undo that turns keeping clear back on puts it back. -struct Parked { - /// The source it shows. - source: String, - /// The rect the scene file gave its item, as of the last render. - rect: Rect, - placer: Placer, -} - /// A scene a render draws, as [`Compositor::watched`] finds it. #[derive(Clone, Copy)] struct Watched { @@ -669,93 +655,76 @@ impl Compositor { self.program_shown } - /// Where the `index`th item of the scene called `scene`, one showing - /// `source` that keeps clear, was drawn as of the last - /// [`render`](Self::render), and why: `None` for any other item, or before - /// a render placed it. - pub fn placement(&self, scene: &str, index: usize, source: &str) -> Option<&Placement> { - let keeper = self.keepers.get(&(scene.to_string(), index))?; - (keeper.source == source).then(|| keeper.placer.placement()) - } - - /// Note the item a gesture has in hand as of `now`, such as a drag, as - /// its scene, index, and source, or `None` once let go: an item keeping - /// clear does not choose a place while in hand. Each frame of the gesture - /// says so again; one that stops saying so, as when the window is hidden - /// mid-drag, lets go after [`GRAB`]. - pub fn grab(&mut self, item: Option<(&str, usize, &str)>, now: Instant) { - self.grabbed = item.map(|(scene, index, source)| { - let key = (scene.to_string(), index, source.to_string()); - (key, now.saturating_add(GRAB)) - }); + /// Where the scene item `id`, one that keeps clear, was drawn as of the + /// last [`render`](Self::render), and why: `None` for any other item, or + /// before a render placed it. + pub fn placement(&self, id: Id) -> Option<&Placement> { + Some(self.keepers.get(&id)?.placer.placement()) } - /// Note that the `index`th item of the scene called `scene`, one showing - /// `source` that keeps clear, was moved by hand: it stays where the scene - /// file puts it until the content under it changes. A resize is no move. - pub fn hold(&mut self, scene: &str, index: usize, source: &str) { - if let Some(keeper) = self.keepers.get_mut(&(scene.to_string(), index)) - && keeper.source == source - { + /// Note the item a gesture has in hand as of `now`, such as a drag, or + /// `None` once let go: an item keeping clear does not choose a place + /// while in hand. Each frame of the gesture says so again; one that stops + /// saying so, as when the window is hidden mid-drag, lets go after + /// [`GRAB`]. + pub fn grab(&mut self, item: Option, now: Instant) { + self.grabbed = item.map(|id| (id, now.saturating_add(GRAB))); + } + + /// Note that the scene item `id`, one that keeps clear, was moved by + /// hand: it stays where the scene file puts it until the content under + /// it changes. A resize is no move. + pub fn hold(&mut self, id: Id) { + if let Some(keeper) = self.keepers.get_mut(&id) { keeper.placer.hold(); } } - /// Note that a redo or a reload saved the `index`th item of the scene - /// called `scene`, one showing `source` that keeps clear, at `saved`: it - /// holds there, as [`hold`](Self::hold) says. - pub fn redone(&mut self, scene: &str, index: usize, source: &str, saved: Rect) { - if let Some(keeper) = self.unpark(scene, index, source, saved) { + /// Note that a redo or a reload saved the scene item `id`, one that + /// keeps clear, at `saved`: it holds there, as [`hold`](Self::hold) + /// says. + pub fn redone(&mut self, id: Id, saved: Rect) { + if let Some(keeper) = self.unpark(id) { keeper.placer.redone(saved); } } - /// Note that an undo saved the `index`th item of the scene called - /// `scene`, one showing `source` that keeps clear, at `saved` as of - /// `now`: back where it was saved before the move by hand that held it, - /// or before keeping clear was switched off, it goes back to where it was - /// then, such as the slot it had glided to. Anywhere else, it holds, as - /// [`hold`](Self::hold) says. - pub fn undone(&mut self, scene: &str, index: usize, source: &str, saved: Rect, now: Instant) { - if let Some(keeper) = self.unpark(scene, index, source, saved) { + /// Note that an undo saved the scene item `id`, one that keeps clear, at + /// `saved` as of `now`: back where it was saved before the move by hand + /// that held it, or before it stopped keeping clear or left its scene, + /// it goes back to where it was then, such as the slot it had glided to. + /// Anywhere else, it holds, as [`hold`](Self::hold) says. + pub fn undone(&mut self, id: Id, saved: Rect, now: Instant) { + if let Some(keeper) = self.unpark(id) { keeper.placer.undone(saved, now); } } - /// The keeper of the `index`th item of the scene called `scene`, one - /// showing `source` saved at `saved`, taking it back from where it was - /// parked when an undo or a redo switches keeping clear back on: under - /// that item, or under the only other of the scene's items parked - /// showing `source`, as an undo of a swap into a slot moves it. - fn unpark(&mut self, scene: &str, index: usize, source: &str, saved: Rect) -> Option<&mut Keeper> { - let key = (scene.to_string(), index); - let found = match self.parked.get(&key) { - Some(parked) if parked.source == source => Some(key.clone()), - _ => { - let mut others = self - .parked - .iter() - .filter(|((at, _), parked)| at == scene && parked.source == source); - match (others.next(), others.next()) { - (Some((at, _)), None) => Some(at.clone()), - _ => None, - } - } - }; - if !self.keepers.contains_key(&key) - && let Some(found) = found + /// The keeper of the item `id`, taken back from where it was parked when + /// an undo or a redo brings it back keeping clear. + fn unpark(&mut self, id: Id) -> Option<&mut Keeper> { + if !self.keepers.contains_key(&id) + && let Some(placer) = self.parked.remove(&id) { - let parked = self.parked.remove(&found).expect("found above"); let keeper = Keeper { - source: parked.source, - rect: saved, watched: true, - placer: parked.placer, + placer, look: Look::new(&self.device, &self.queue), }; - self.keepers.insert(key.clone(), keeper); + self.keepers.insert(id, keeper); + } + self.keepers.get_mut(&id) + } + + /// Keep the parked placers only of the items among `ids`, those an undo + /// or a redo can still bring back, such as the ones the history holds, + /// and forget the rest. + pub fn remember(&mut self, ids: impl IntoIterator) { + if self.parked.is_empty() { + return; } - self.keepers.get_mut(&key).filter(|keeper| keeper.source == source) + let ids: HashSet = ids.into_iter().collect(); + self.parked.retain(|id, _| ids.contains(id)); } /// Keep the scenes `outputs` names as outputs from now on, each with @@ -960,17 +929,6 @@ impl Compositor { if let Some(portrait) = &mut self.portrait { portrait.rename(renames); } - // Each scene keeps where its items keeping clear went, so two - // swapping names do not take each other's. - self.keepers = renamed(std::mem::take(&mut self.keepers), renames, |(scene, _)| scene); - self.parked = renamed(std::mem::take(&mut self.parked), renames, |(scene, _)| scene); - if let Some(((scene, _, _), _)) = &mut self.grabbed { - match renames.get(scene.as_str()) { - Some(Some(to)) => *scene = to.clone(), - Some(None) => self.grabbed = None, - None => {} - } - } } /// Drop each scene `collection` does not have from preview, program, a @@ -1226,8 +1184,8 @@ impl Compositor { self.effects.submit(frame); if !reads.is_empty() { let reducer = self.reducer.get_or_insert_with(|| Reducer::new(&self.device)); - for key in reads { - let keeper = self.keepers.get_mut(&key).expect("read above"); + for id in reads { + let keeper = self.keepers.get_mut(&id).expect("read above"); keeper.look.start(reducer, now); } } @@ -1284,9 +1242,8 @@ impl Compositor { /// `collection` with each scene item keeping clear where its placer puts /// it at `now`, from what the reads of the picture under it that came - /// back show. A keeper whose item stopped keeping clear is parked, held - /// where it was, until the item keeps clear again or is gone; one whose - /// item is gone is forgotten. + /// back show. The placer of an item that stopped keeping clear or left + /// its scene is parked, held where it was. fn place<'a>( &mut self, collection: &'a Collection, @@ -1294,26 +1251,7 @@ impl Compositor { now: Instant, ) -> Cow<'a, Collection> { let mut staged = Cow::Borrowed(collection); - let keeping = |item: &Item| item.keep_clear.is_some(); - let (mut kept, left) = follow(std::mem::take(&mut self.keepers), collection, keeping, |keeper| { - (keeper.source.as_str(), keeper.rect) - }); - let mut parked = std::mem::take(&mut self.parked); - parked.extend(left.into_iter().map(|(key, mut keeper)| { - keeper.placer.hold(); - let parked = Parked { - source: keeper.source, - rect: keeper.rect, - placer: keeper.placer, - }; - (key, parked) - })); - (self.parked, _) = follow( - parked, - collection, - |item| !keeping(item), - |parked| (parked.source.as_str(), parked.rect), - ); + let mut left = std::mem::take(&mut self.keepers); let mut keepers = HashMap::new(); for (number, scene) in collection.scenes.iter().enumerate() { let canvas = scene.canvas(collection.canvas); @@ -1321,13 +1259,14 @@ impl Compositor { if item.keep_clear.is_none() { continue; } - let key = (scene.name.clone(), index); - let mut keeper = kept.remove(&key).unwrap_or_else(|| Keeper { - source: item.source.clone(), - rect: item.rect, - watched: false, - placer: Placer::new(now), - look: Look::new(&self.device, &self.queue), + let mut keeper = left.remove(&item.id).unwrap_or_else(|| { + // Switched on by hand, it chooses afresh. + self.parked.remove(&item.id); + Keeper { + watched: false, + placer: Placer::new(now), + look: Look::new(&self.device, &self.queue), + } }); // A scene that went on again shows new content, which the // reads of what it showed before say nothing of. @@ -1346,24 +1285,20 @@ impl Compositor { ), None => {} } - keeper.rect = item.rect; keeper.placer.watch(keeper.watched, now); - let grabbed = self.grabbed.as_ref().is_some_and(|((at, number, source), until)| { - *at == scene.name && *number == index && *source == item.source && now < *until - }); + let grabbed = self.grabbed.is_some_and(|(id, until)| id == item.id && now < until); keeper.placer.grab(grabbed); let rect = keeper.placer.place(item, canvas, now); if rect != item.rect { staged.to_mut().scenes[number].items[index].rect = rect; } - keepers.insert(key, keeper); - } - for (index, item) in scene.items.iter().enumerate() { - if let Some(parked) = self.parked.get_mut(&(scene.name.clone(), index)) { - parked.rect = item.rect; - } + keepers.insert(item.id, keeper); } } + for (id, mut keeper) in left { + keeper.placer.hold(); + self.parked.insert(id, keeper.placer); + } self.keepers = keepers; staged } @@ -1898,7 +1833,7 @@ impl Pass<'_, '_> { outputs: &[(On, Target)], thumbnails: &[(Shows, Duration, Target)], keeping: Option, - ) -> Vec<(String, usize)> { + ) -> Vec { let (landscape, landscape_program) = landscape.unzip(); let pictures = Pictures { collection, landscape }; let (preview, program, switch) = (self.preview, self.program, self.switch); @@ -2055,41 +1990,35 @@ impl Pass<'_, '_> { let Some(Keeping { keepers, watched, now }) = keeping else { return reads; }; - for ((scene, index), keeper) in keepers { + for keeper in keepers.values_mut() { keeper.watched = false; - let Some(&Watched { since, nested }) = watched.get(scene) else { + } + for scene in &collection.scenes { + let Some(&Watched { since, nested }) = watched.get(&scene.name) else { continue; }; - let Some(shown) = collection.scene(scene) else { continue }; // While its slots glide, a scene draws only its visible items, in - // the order they stack, so one keeping clear is found by what it - // shows and where it was placed, nearest its place in the file. - let rect = keeper.placer.placement().rect; - let mine = |item: &Item| item.keep_clear.is_some() && item.source == keeper.source && item.rect == rect; - let at = shown - .items - .iter() - .enumerate() - .filter(|(_, item)| mine(item)) - .min_by_key(|(at, _)| at.abs_diff(*index)) - .map(|(at, _)| at); - let Some(at) = at.filter(|&at| shown.items[at].visible) else { - continue; - }; - keeper.watched = true; - if !keeper.look.due(now) { - continue; - } - let canvas = canvas_of(Some(scene)); - let target = keeper.look.target(draw.effects, canvas); - draw.size = canvas; - // What a scene source draws starts transparent, as its nest does. - match nested { - true => draw.frame.target(&target.picture, canvas, wgpu::Color::TRANSPARENT), - false => draw.target(&target), + // the order they stack, so an item keeping clear is found by its + // identity. + for (at, item) in scene.items.iter().enumerate() { + let Some(keeper) = keepers.get_mut(&item.id).filter(|_| item.visible) else { + continue; + }; + keeper.watched = true; + if !keeper.look.due(now) { + continue; + } + let canvas = canvas_of(Some(&scene.name)); + let target = keeper.look.target(draw.effects, canvas); + draw.size = canvas; + // What a scene source draws starts transparent, as its nest does. + match nested { + true => draw.frame.target(&target.picture, canvas, wgpu::Color::TRANSPARENT), + false => draw.target(&target), + } + draw.under(&target, Place::scene(scene.name.as_str()), at, since); + reads.push(item.id); } - draw.under(&target, Place::scene(scene.as_str()), at, since); - reads.push((scene.clone(), *index)); } reads } @@ -2098,7 +2027,7 @@ impl Pass<'_, '_> { /// The items keeping clear whose pictures a [`Pass`] reads, and each scene /// the render draws, as [`Compositor::watched`] finds them, as of `now`. struct Keeping<'a> { - keepers: &'a mut HashMap<(String, usize), Keeper>, + keepers: &'a mut HashMap, watched: &'a HashMap, now: Instant, } @@ -3103,80 +3032,6 @@ impl Target { } } -/// `map` with the scene each key names, as `scene` finds it, renamed as -/// `renames` says, dropping those of scenes it removes. -fn renamed( - map: HashMap, - renames: &BTreeMap>, - scene: for<'k> fn(&'k mut K) -> &'k mut String, -) -> HashMap { - map.into_iter() - .filter_map(|(mut key, value)| { - let name = scene(&mut key); - match renames.get(name.as_str()) { - Some(Some(to)) => *name = to.clone(), - Some(None) => return None, - None => {} - } - Some((key, value)) - }) - .collect() -} - -/// Each of something by the scene and place of the item it is for. -type Placed = HashMap<(String, usize), T>; - -/// `old`, the keepers, each under where its item that `keeps` now is, so it -/// goes on from where it was placed, and the rest. A keeper shows the same -/// source; of those, it is first the one in the same scene saved at the same -/// rect, at the same index or the nearest, as a layer added or removed under -/// it shifts it; then one in the same scene at the same index or the -/// nearest, as an edit to its rect leaves it; then the same in a scene no -/// longer there, as a rename leaves it. -fn follow( - mut old: Placed, - collection: &Collection, - keeps: impl Fn(&Item) -> bool, - shows: impl Fn(&T) -> (&str, Rect), -) -> (Placed, Placed) { - let mut kept = HashMap::new(); - if old.is_empty() { - return (kept, old); - } - let mut missing: Vec<((String, usize), &Item)> = Vec::new(); - for scene in &collection.scenes { - for (index, item) in scene.items.iter().enumerate() { - if keeps(item) { - missing.push(((scene.name.clone(), index), item)); - } - } - } - let gone = |scene: &str| collection.scene(scene).is_none(); - for (same_scene, same_rect) in [(true, true), (true, false), (false, true), (false, false)] { - missing.retain(|(key, item)| { - let found = old - .iter() - .filter(|((scene, _), keeper)| { - let (source, rect) = shows(keeper); - source == item.source - && (!same_rect || rect == item.rect) - && match same_scene { - true => *scene == key.0, - false => gone(scene), - } - }) - .map(|(old_key, _)| old_key) - .min_by_key(|(_, index)| index.abs_diff(key.1)) - .cloned(); - let Some(found) = found else { return true }; - let keeper = old.remove(&found).expect("found above"); - kept.insert(key.clone(), keeper); - false - }); - } - (kept, old) -} - #[cfg(test)] mod tests { use std::time::Duration; @@ -3422,6 +3277,7 @@ mod tests { studio.compositor.set_preview(Some("busy".into())); studio.compositor.cut(&studio.collection, &studio.sources).unwrap(); let camera = studio.collection.scenes[0].items.len() - 1; + let id = studio.collection.scenes[0].items[camera].id; let block = camera - 1; let saved = studio.collection.scenes[0].items[camera].rect; let start = Instant::now(); @@ -3431,7 +3287,7 @@ mod tests { studio.collection.scenes[0].items[block].rect.x = 240.0 + 6.0 * (frame % 7) as f32; studio.render(now); studio.device.poll(wgpu::PollType::wait_indefinitely()).unwrap(); - let placement = studio.compositor.placement("busy", camera, "camera").unwrap(); + let placement = studio.compositor.placement(id).unwrap(); if placement.slot.is_some() { moved = Some(now); break; @@ -3444,7 +3300,7 @@ mod tests { moved.saturating_duration_since(start) >= crate::place::SETTLE, "it looks before it moves" ); - let placement = studio.compositor.placement("busy", camera, "camera").unwrap().clone(); + let placement = studio.compositor.placement(id).unwrap().clone(); assert_eq!(placement.slot, Some(crate::place::Slot::TopLeft)); let left = placement.left.unwrap(); assert_eq!(left.rect, saved); @@ -3458,13 +3314,13 @@ mod tests { let glide = crate::KeepClear::default().glide; studio.render(moved.saturating_add(glide / 2)); - let half = studio.compositor.placement("busy", camera, "camera").unwrap().rect; + let half = studio.compositor.placement(id).unwrap().rect; assert!(half.x < saved.x && half.x > 9.0, "on its way: {half:?}"); studio.render(moved.saturating_add(glide)); let to = crate::place::Slot::TopLeft .rect(64.0, 64.0, studio.collection.canvas) .unwrap(); - assert_eq!(studio.compositor.placement("busy", camera, "camera").unwrap().rect, to); + assert_eq!(studio.compositor.placement(id).unwrap().rect, to); let program = studio.program(); assert_eq!(texel(&program, 320, 41, 41), BLUE, "the camera where it went"); assert_eq!(texel(&program, 320, 279, 139), [255; 4], "the block uncovered"); @@ -3479,76 +3335,76 @@ mod tests { let camera = camera + 1; let after = moved.saturating_add(glide * 2); studio.render(after); - let placement = studio.compositor.placement("busy", camera, "camera").unwrap(); + let placement = studio.compositor.placement(id).unwrap(); assert_eq!(placement.rect, to, "it goes on from where it was placed"); assert_eq!(placement.slot, Some(crate::place::Slot::TopLeft)); // Switched off, as the inspector does, holding it, and the switch // undone before the next render: it is still in its slot. - studio.compositor.hold("busy", camera, "camera"); + studio.compositor.hold(id); let item = &mut studio.collection.scenes[0].items[camera]; let keep = item.keep_clear.take(); item.rect = to; let item = &mut studio.collection.scenes[0].items[camera]; item.keep_clear = keep; item.rect = saved; - studio.compositor.undone("busy", camera, "camera", saved, after); + studio.compositor.undone(id, saved, after); let after = after.saturating_add(Duration::from_millis(100)); studio.render(after); - let placement = studio.compositor.placement("busy", camera, "camera").unwrap(); + let placement = studio.compositor.placement(id).unwrap(); assert_eq!((placement.rect, placement.held), (to, false), "undone before it drew"); // Switched off and drawn so, it stays where it is drawn; an undo of // that puts it back in its slot, keeping clear. - studio.compositor.hold("busy", camera, "camera"); + studio.compositor.hold(id); let item = &mut studio.collection.scenes[0].items[camera]; let keep = item.keep_clear.take(); item.rect = to; let after = after.saturating_add(Duration::from_millis(100)); studio.render(after); - assert!(studio.compositor.placement("busy", camera, "camera").is_none()); + assert!(studio.compositor.placement(id).is_none()); let item = &mut studio.collection.scenes[0].items[camera]; item.keep_clear = keep; item.rect = saved; - studio.compositor.undone("busy", camera, "camera", saved, after); + studio.compositor.undone(id, saved, after); let after = after.saturating_add(Duration::from_millis(100)); studio.render(after); - let placement = studio.compositor.placement("busy", camera, "camera").unwrap(); + let placement = studio.compositor.placement(id).unwrap(); assert_eq!(placement.rect, to, "back where it was drawn"); assert_eq!(placement.slot, Some(crate::place::Slot::TopLeft)); assert!(!placement.held); // Moved by hand, it stays where the scene file puts it. - studio.compositor.hold("busy", camera, "camera"); + studio.compositor.hold(id); let dragged = Rect { x: 200.0, ..saved }; studio.collection.scenes[0].items[camera].rect = dragged; studio.render(after.saturating_add(Duration::from_millis(100))); - let placement = studio.compositor.placement("busy", camera, "camera").unwrap(); + let placement = studio.compositor.placement(id).unwrap(); assert!(placement.held); assert_eq!(placement.rect, dragged); // Switched off where it is held, which leaves its rect as it is, and // that undone: it is still held. let after = after.saturating_add(Duration::from_millis(200)); - studio.compositor.hold("busy", camera, "camera"); + studio.compositor.hold(id); studio.collection.scenes[0].items[camera].keep_clear = None; studio.render(after); studio.collection.scenes[0].items[camera].keep_clear = keep; - studio.compositor.undone("busy", camera, "camera", dragged, after); + studio.compositor.undone(id, dragged, after); let after = after.saturating_add(Duration::from_millis(100)); studio.render(after); - let placement = studio.compositor.placement("busy", camera, "camera").unwrap(); + let placement = studio.compositor.placement(id).unwrap(); assert_eq!((placement.rect, placement.held), (dragged, true), "still held"); // Switched off and drawn so, then back on by a redo: it holds. studio.collection.scenes[0].items[camera].keep_clear = None; let after = after.saturating_add(Duration::from_millis(100)); studio.render(after); - assert!(studio.compositor.placement("busy", camera, "camera").is_none()); + assert!(studio.compositor.placement(id).is_none()); studio.collection.scenes[0].items[camera].keep_clear = keep; - studio.compositor.redone("busy", camera, "camera", dragged); + studio.compositor.redone(id, dragged); studio.render(after.saturating_add(Duration::from_millis(100))); - let placement = studio.compositor.placement("busy", camera, "camera").unwrap(); + let placement = studio.compositor.placement(id).unwrap(); assert_eq!((placement.rect, placement.held), (dragged, true), "a redo holds it"); }) .await; @@ -3569,6 +3425,7 @@ mod tests { studio.compositor.set_preview(Some("busy".into())); studio.compositor.cut(&studio.collection, &studio.sources).unwrap(); let camera = studio.collection.scenes[0].items.len() - 1; + let id = studio.collection.scenes[0].items[camera].id; let block = camera - 1; let mut now = Instant::now(); let mut moved = None; @@ -3576,13 +3433,7 @@ mod tests { studio.collection.scenes[0].items[block].rect.x = 240.0 + 6.0 * (frame % 7) as f32; studio.render(now); studio.device.poll(wgpu::PollType::wait_indefinitely()).unwrap(); - if studio - .compositor - .placement("busy", camera, "camera") - .unwrap() - .slot - .is_some() - { + if studio.compositor.placement(id).unwrap().slot.is_some() { moved = Some(now); break; } @@ -3604,78 +3455,117 @@ mod tests { .await; } - /// Each scene's keepers follow a rename, so two scenes swapping names - /// keep their own, and a removed scene's are dropped. - #[test] - fn keepers_follow_a_rename() { - let key = |scene: &str, index| (scene.to_string(), index); - let keepers = HashMap::from([(key("a", 0), "a's"), (key("b", 0), "b's"), (key("c", 1), "c's")]); - let renames = BTreeMap::from([ - ("a".to_string(), Some("b".to_string())), - ("b".to_string(), Some("a".to_string())), - ("c".to_string(), None), - ]); - let keepers = renamed(keepers, &renames, |(scene, _)| scene); - assert_eq!(keepers, HashMap::from([(key("b", 0), "a's"), (key("a", 0), "b's")])); - } - - /// Two layers keeping clear of the same camera keep their own keepers as - /// a layer added under both shifts them, as an edit to one's rect, and as - /// their scene is renamed. - #[test] - fn keepers_follow_their_items() { - let rect = |x| Rect { - x, - y: 0.0, - width: 10.0, - height: 10.0, - }; - let keeping = |x| Item { - keep_clear: Some(crate::KeepClear::default()), - ..Item::new("camera", rect(x)) - }; - let mut collection = Collection::new(); - collection.scenes = vec![Scene { - items: vec![keeping(0.0), keeping(50.0)], - ..Scene::new("main") - }]; - let named = |name: &str, index| (name.to_string(), index); - fn shows<'a>(keeper: &'a (String, Rect, &'static str)) -> (&'a str, Rect) { - (keeper.0.as_str(), keeper.1) - } - let keeping_clear = |item: &Item| item.keep_clear.is_some(); - let mut keepers = HashMap::from([ - (named("main", 0), ("camera".to_string(), rect(0.0), "first")), - (named("main", 1), ("camera".to_string(), rect(50.0), "second")), - ]); - let which = |keepers: &HashMap<(String, usize), (String, Rect, &'static str)>, scene, index| { - keepers.get(&named(scene, index)).map(|keeper| keeper.2) - }; - - collection.scenes[0].items.insert(0, Item::new("camera", rect(90.0))); - keepers = follow(keepers, &collection, keeping_clear, shows).0; - assert_eq!(which(&keepers, "main", 1), Some("first")); - assert_eq!(which(&keepers, "main", 2), Some("second")); - - // Moved, the second still has its own. - collection.scenes[0].items[2].rect = rect(70.0); - keepers = follow(keepers, &collection, keeping_clear, shows).0; - assert_eq!(which(&keepers, "main", 1), Some("first")); - assert_eq!(which(&keepers, "main", 2), Some("second")); - keepers.get_mut(&named("main", 2)).unwrap().1 = rect(70.0); - - collection.scenes[0].name = "renamed".into(); - keepers = follow(keepers, &collection, keeping_clear, shows).0; - assert_eq!(which(&keepers, "renamed", 1), Some("first")); - assert_eq!(which(&keepers, "renamed", 2), Some("second")); + /// Two cameras keeping clear of one source at one rect, as Duplicate + /// makes them, keep their own placers by identity: one in its slot and + /// one held by hand stay so as a layer is added under both and as they + /// swap places. The one in its slot, removed or kept always on top and + /// then put back by an undo, goes back to its slot, and the other is + /// still held. + #[tokio::test] + #[ignore = "needs a Vulkan device; run by just render-sw"] + async fn duplicates_keep_their_own_placers() { + local(async { + let mut collection = busy(); + let items = &mut collection.scenes[0].items; + let copy = Item { + id: Id::fresh(), + ..items.last().unwrap().clone() + }; + items.push(copy); + let mut studio = Studio::new(collection).await; + studio.compositor.set_preview(Some("busy".into())); + studio.compositor.cut(&studio.collection, &studio.sources).unwrap(); + let items = &studio.collection.scenes[0].items; + // The one under the other sees the block move and leaves it. + let (slotted, held) = (items[items.len() - 2].id, items[items.len() - 1].id); + let block = items.len() - 3; + let saved = items[block + 1].rect; + let mut now = Instant::now(); + for frame in 0..40u32 { + studio.collection.scenes[0].items[block].rect.x = 240.0 + 6.0 * (frame % 7) as f32; + studio.render(now); + studio.device.poll(wgpu::PollType::wait_indefinitely()).unwrap(); + now = now.saturating_add(Duration::from_millis(100)); + if studio.compositor.placement(slotted).unwrap().slot.is_some() { + break; + } + } + now = now.saturating_add(crate::KeepClear::default().glide); + studio.render(now); + let slot = crate::place::Slot::TopLeft; + let corner = slot.rect(64.0, 64.0, studio.collection.canvas).unwrap(); + studio.compositor.hold(held); + let tick = Duration::from_millis(100); + let step = |studio: &mut Studio, now: Instant, why: &str| { + studio.render(now); + let placement = studio.compositor.placement(held).unwrap(); + assert_eq!( + (placement.rect, placement.held), + (saved, true), + "{why}: one held by hand" + ); + let placement = studio.compositor.placement(slotted).unwrap(); + assert_eq!( + (placement.rect, placement.slot, placement.held), + (corner, Some(slot), false), + "{why}: the other in its slot" + ); + }; + now = now.saturating_add(tick); + step(&mut studio, now, "held"); - // One that stops keeping clear has no keeper; its is left over. - collection.scenes[0].items[1].keep_clear = None; - let left; - (keepers, left) = follow(keepers, &collection, keeping_clear, shows); - assert_eq!(keepers.len(), 1); - assert_eq!(which(&keepers, "renamed", 2), Some("second")); - assert_eq!(which(&left, "renamed", 1), Some("first")); + let added = Item { + visible: false, + ..Item::new("black", Rect::fill(&studio.collection.canvas)) + }; + studio.collection.scenes[0].items.insert(0, added); + now = now.saturating_add(tick); + step(&mut studio, now, "a layer added under both"); + + let items = &mut studio.collection.scenes[0].items; + let last = items.len() - 1; + items.swap(last - 1, last); + now = now.saturating_add(tick); + step(&mut studio, now, "swapped"); + + // Removed and drawn so, its placer is parked; the undo brings it + // back to its slot. + let removed = studio.collection.scenes[0].items.remove(last); + now = now.saturating_add(tick); + studio.render(now); + assert!(studio.compositor.placement(slotted).is_none()); + studio.collection.scenes[0].items.insert(last, removed); + studio.compositor.undone(slotted, saved, now); + now = now.saturating_add(tick); + step(&mut studio, now, "removed and put back"); + + // Kept always on top the same way. + let moved = studio.collection.scenes[0].items.remove(last); + studio.collection.top.push(Item { + keep_clear: None, + ..moved.clone() + }); + now = now.saturating_add(tick); + studio.render(now); + assert!(studio.compositor.placement(slotted).is_none()); + studio.collection.top.clear(); + studio.collection.scenes[0].items.insert(last, moved); + studio.compositor.undone(slotted, saved, now); + now = now.saturating_add(tick); + step(&mut studio, now, "kept on top and put back"); + + // Once no undo can bring it back, a parked placer is forgotten. + let moved = studio.collection.scenes[0].items.remove(last); + now = now.saturating_add(tick); + studio.render(now); + studio.compositor.remember([held]); + studio.collection.scenes[0].items.insert(last, moved); + studio.compositor.undone(slotted, saved, now); + studio.render(now.saturating_add(tick)); + let placement = studio.compositor.placement(slotted).unwrap(); + assert_eq!((placement.rect, placement.slot), (saved, None), "it starts over"); + }) + .await; } /// A source published independently is left out of the program and drawn @@ -4635,11 +4525,14 @@ mod tests { async fn scenes_swapping_names_keep_their_own_slots() { local(async { let mut collection = slotted(); - let row = Scene { + let mut row = Scene { name: "row".into(), arrangement: crate::Arrangement::Row, ..collection.scenes[0].clone() }; + for item in &mut row.items { + item.id = Id::fresh(); + } collection.scenes.push(row); collection.validate().unwrap(); let mut studio = Studio::new(collection).await; @@ -6555,7 +6448,10 @@ mod tests { ]); // Blue over the top-right quarter alone, transparent elsewhere. collection.scenes.push(Scene { - items: vec![collection.scenes[0].items[1].clone()], + items: vec![Item { + id: Id::fresh(), + ..collection.scenes[0].items[1].clone() + }], ..Scene::new("corner") }); let corner = Source::Scene { scene: "corner".into() }; diff --git a/rs/moq-scene/src/edit.rs b/rs/moq-scene/src/edit.rs index 1869e1c2..461e8543 100644 --- a/rs/moq-scene/src/edit.rs +++ b/rs/moq-scene/src/edit.rs @@ -14,7 +14,9 @@ use std::collections::{BTreeMap, VecDeque}; use serde::{Deserialize, Serialize}; use crate::Error; -use crate::collection::{Audio, AudioScene, Canvas, Collection, Filter, Item, Layer, Scene, Source, Transition, Video}; +use crate::collection::{ + Audio, AudioScene, Canvas, Collection, Filter, Item, Layer, Scene, Source, Transition, Video, recognized, +}; /// One part of a collection, before and after an edit. /// @@ -157,6 +159,15 @@ impl Change { } } + /// The items it holds, before and after. + fn items(&self) -> Vec<&Item> { + match self { + Self::Item { before, after, .. } => before.iter().chain(after).map(|item| &**item).collect(), + Self::Scene { before, after, .. } => before.iter().chain(after).flat_map(|scene| &scene.items).collect(), + _ => Vec::new(), + } + } + /// Whether the change leaves its part as it was. fn is_noop(&self) -> bool { match self { @@ -1198,13 +1209,86 @@ impl History { edit: edit.clone(), gesture: None, }; - let history = Self { + let mut history = Self { position: undo.len(), entries: undo.iter().rev().chain(&redo).map(|edit| entry(edit)).collect(), }; + history.align(collection); let dropped = total - history.entries.len(); Ok((history, dropped)) } + + /// Give the items each entry holds the [identities](Item::id) of the + /// items of `collection` they are, as a loaded history, whose items are + /// each fresh, needs, so an undo or a redo keeps each item's own. Each + /// entry reads them from the collection as undoing or redoing to it + /// leaves it: an item it replaces keeps its identity, one it adds stays + /// new, and the items of a scene it replaces are matched as + /// [`Collection::recognize`] matches them. It stops at an entry that no + /// longer applies. + pub fn align(&mut self, collection: &Collection) { + let (undo, redo) = self.entries.make_contiguous().split_at_mut(self.position); + let mut state = collection.clone(); + for entry in undo.iter_mut().rev() { + let mut inverse = entry.edit.inverse(); + if aligned(&mut state, &mut inverse).is_err() { + break; + } + entry.edit = inverse.inverse(); + } + let mut state = collection.clone(); + for entry in redo { + let mut edit = entry.edit.clone(); + if aligned(&mut state, &mut edit).is_err() { + break; + } + entry.edit = edit; + } + } + + /// Every item an undo or a redo may put back. + pub fn items(&self) -> impl Iterator { + self.entries().flat_map(|edit| &edit.changes).flat_map(Change::items) + } +} + +/// Make `edit` to `state`, each change first given the identities of the +/// items it replaces there, as [`History::align`] says. +fn aligned(state: &mut Collection, edit: &mut Edit) -> Result<(), Error> { + for change in &mut edit.changes { + match change { + Change::Item { + layer, + index, + before: Some(before), + after, + } => { + if let Some(at) = state.items(layer).and_then(|items| items.get(*index)) { + before.id = at.id; + } + if let Some(after) = after { + after.id = before.id; + } + } + Change::Scene { + index, + before: Some(before), + after, + } => { + if let Some(at) = state.scenes.get(*index) { + for (item, at) in before.items.iter_mut().zip(&at.items) { + item.id = at.id; + } + } + if let Some(after) = after { + recognized(&before.items, &mut after.items); + } + } + _ => {} + } + change.apply(state)?; + } + Ok(()) } #[cfg(test)] @@ -1814,6 +1898,112 @@ mod tests { assert!(collection.sources.is_empty()); } + /// Over many edits of one layer, alike and not, an undo or a redo back to + /// any point brings back the items it had, each under its own identity, + /// before a reload and after one, whose history keeps those it loads. + #[test] + fn every_point_of_a_history_keeps_its_identities() { + let mut collection = collection(); + let mut history = History::new(); + let ids = |collection: &Collection| -> Vec { + collection.scenes[0].items.iter().map(|item| item.id).collect() + }; + let mut seed = 7u64; + let mut next = |below: usize| { + seed = seed.wrapping_mul(6364136223846793005).wrapping_add(1442695040888963407); + (seed >> 33) as usize % below + }; + let mut seen = vec![ids(&collection)]; + for _ in 0..60 { + let items = &collection.scenes[0].items; + let at = next(items.len()); + let mut draft = collection.draft("Edit"); + match next(4) { + // A copy, alike but another. + 0 => { + let copy = Item { + id: crate::Id::fresh(), + ..items[at].clone() + }; + draft.insert_item(&main(), next(items.len() + 1), copy).unwrap(); + } + 1 if items.len() > 1 => { + draft.remove_item(&main(), at).unwrap(); + } + 2 => { + let to = next(items.len()); + draft.move_item(&main(), at, to).unwrap(); + } + _ => { + let mut item = items[at].clone(); + item.rect.x = next(4) as f32; + draft.set_item(&main(), at, item).unwrap(); + } + } + commit(&mut collection, &mut history, draft, None); + seen.truncate(history.position()); + seen.push(ids(&collection)); + } + let total = history.entries().len(); + for _ in 0..40 { + let to = next(total + 1); + history.seek(&mut collection, to).unwrap(); + assert_eq!(ids(&collection), seen[to], "at {to}"); + } + + let text = history.to_toml().unwrap(); + let mut collection = Collection::from_toml(&collection.to_toml().unwrap()).unwrap(); + let (mut loaded, _) = History::from_toml(&text, &collection).unwrap(); + let mut seen: Vec>> = vec![None; total + 1]; + seen[loaded.position()] = Some(ids(&collection)); + for _ in 0..80 { + let to = next(total + 1); + loaded.seek(&mut collection, to).unwrap(); + let now = ids(&collection); + assert_eq!(*seen[to].get_or_insert(now.clone()), now, "at {to} after a reload"); + } + } + + /// A history loaded beside a reloaded scene file gives each item the + /// identity its collection gives it, so an undo or a redo keeps it: a + /// moved item stays itself, and a removed or added one comes back the + /// same each time. + #[test] + fn a_loaded_history_keeps_each_identity() { + let mut collection = collection(); + let mut history = History::new(); + drag(&mut collection, &mut history, 1.0, None); + let mut draft = collection.draft("Add blue"); + draft.set_source("blue", Some(color([0, 0, 255, 255]))).unwrap(); + let blue = Item::new("blue", Rect::fill(&collection.canvas)); + draft.insert_item(&main(), 1, blue).unwrap(); + commit(&mut collection, &mut history, draft, None); + let mut draft = collection.draft("Remove red"); + draft.remove_item(&main(), 0).unwrap(); + commit(&mut collection, &mut history, draft, None); + history.undo(&mut collection).unwrap(); + + let mut reloaded = Collection::from_toml(&collection.to_toml().unwrap()).unwrap(); + let (mut loaded, dropped) = History::from_toml(&history.to_toml().unwrap(), &reloaded).unwrap(); + assert_eq!(dropped, 0); + let ids = |collection: &Collection| { + collection.scenes[0] + .items + .iter() + .map(|item| item.id) + .collect::>() + }; + let (red, blue) = (ids(&reloaded)[0], ids(&reloaded)[1]); + loaded.undo(&mut reloaded).unwrap(); + assert_eq!(ids(&reloaded), [red], "blue undone"); + loaded.undo(&mut reloaded).unwrap(); + assert_eq!(ids(&reloaded), [red], "the move undone"); + loaded.seek(&mut reloaded, 3).unwrap(); + assert_eq!(ids(&reloaded), [blue], "red removed, blue added back"); + loaded.undo(&mut reloaded).unwrap(); + assert_eq!(ids(&reloaded), [red, blue], "red back"); + } + /// After a hand edit, an entry the scene file no longer matches is dropped /// with everything older, and the newer ones still undo. #[test] diff --git a/rs/moq-scene/src/format.rs b/rs/moq-scene/src/format.rs index 2bb4d454..57386a98 100644 --- a/rs/moq-scene/src/format.rs +++ b/rs/moq-scene/src/format.rs @@ -881,6 +881,9 @@ mod tests { show.scenes[1].arrangement = Arrangement::Grid; let mut copy = show.scenes[1].clone(); copy.name = "Row".into(); + for item in &mut copy.items { + item.id = crate::Id::fresh(); + } copy.arrangement = Arrangement::Column; show.scenes.push(copy); let turned = turned(&show); diff --git a/rs/moq-scene/src/glide.rs b/rs/moq-scene/src/glide.rs index a361d549..c1be6ca5 100644 --- a/rs/moq-scene/src/glide.rs +++ b/rs/moq-scene/src/glide.rs @@ -17,7 +17,8 @@ pub(crate) const REFLOW: Duration = Duration::from_millis(400); /// `K`, naming what moves the items, changes, those `glides` says it moves /// glide from where they were shown to where they now are, as a move /// transition takes them; the rest show as they are at once, so one being -/// dragged follows the pointer. +/// dragged follows the pointer. Each item glides from where the item of the +/// same [identity](Item::id) was, so two showing one source keep their own. pub(crate) struct Glide { duration: Duration, glides: fn(&Item) -> bool, @@ -66,7 +67,7 @@ impl Glide { let linear = now.saturating_duration_since(*start).as_secs_f32() / self.duration.as_secs_f32(); (linear < 1.0).then(|| Ease::InOut.apply(linear)) }); - let same = |a: &Item, b: &Item| a.source == b.source; + let same = |a: &Item, b: &Item| a.id == b.id; let glides = self.glides; (self.shown, self.placed) = match (progress, &self.from) { (Some(progress), Some((from, _))) => ( @@ -285,6 +286,14 @@ mod tests { ) } + /// `item` moved to `x`. + fn to(item: &Item, x: f32) -> Item { + Item { + rect: Rect { x, ..item.rect }, + ..item.clone() + } + } + fn opacity(item: &Item) -> f32 { match item.filters.last() { Some(Filter::Opacity { amount }) => *amount, @@ -321,8 +330,8 @@ mod tests { let start = kio::clock::now(); let mut glide = Glide::new(Duration::from_millis(400), |_| true); let one = vec![at("cam", 0.0)]; - let two = vec![at("cam", 0.0), at("guest", 600.0)]; - let three = vec![at("cam", 200.0), at("guest", 600.0)]; + let two = vec![one[0].clone(), at("guest", 600.0)]; + let three = vec![to(&two[0], 200.0), two[1].clone()]; assert_eq!(glide.show(1, &one, start), one.as_slice()); // It starts with the first draw that sees the new arrangement. let joined = glide.show(2, &two, start).to_vec(); @@ -361,7 +370,7 @@ mod tests { let start = kio::clock::now(); let mut glide = Glide::new(REFLOW, |item| item.source != "logo"); let one = vec![at("cam", 0.0), at("logo", 0.0)]; - let two = vec![at("cam", 200.0), at("logo", 100.0)]; + let two = vec![to(&one[0], 200.0), to(&one[1], 100.0)]; glide.show(1, &one, start); glide.show(2, &two, start); let half = glide.show(2, &two, start.saturating_add(REFLOW / 2)).to_vec(); @@ -370,6 +379,22 @@ mod tests { assert_eq!(glide.placed()[1].rect.x, 100.0); } + /// Two items showing one source, such as a duplicate, each glide from + /// where they were, by identity, as they swap places. + #[test] + fn duplicates_glide_from_their_own_places() { + let start = kio::clock::now(); + let mut glide = Glide::new(REFLOW, |_| true); + let one = vec![at("cam", 0.0), at("cam", 400.0)]; + let two = vec![to(&one[1], 200.0), to(&one[0], 600.0)]; + glide.show(1, &one, start); + glide.show(2, &two, start); + let half = glide.show(2, &two, start.saturating_add(REFLOW / 2)).to_vec(); + assert_eq!(half[0].rect.x, 300.0, "from 400 to 200"); + assert_eq!(half[1].rect.x, 300.0, "from 0 to 600"); + assert_eq!(half[0].id, one[1].id); + } + #[test] fn the_first_arrangement_shows_at_once() { let mut glide = Glide::new(REFLOW, |_| true); diff --git a/rs/moq-scene/src/lib.rs b/rs/moq-scene/src/lib.rs index e73169aa..649002f3 100644 --- a/rs/moq-scene/src/lib.rs +++ b/rs/moq-scene/src/lib.rs @@ -70,7 +70,7 @@ pub mod source; pub use clip::Clip; pub use collection::{ - Arrangement, Audio, AudioScene, Background, Blend, Canvas, Collection, Crop, Direction, Ease, Filter, Item, + Arrangement, Audio, AudioScene, Background, Blend, Canvas, Collection, Crop, Direction, Ease, Filter, Id, Item, KeepClear, Keyframe, Layer, MaskMode, Nested, Rect, Rgba, Scene, Shape, Size, Slot, Source, Transition, Video, }; pub use compositor::{Compositor, Detail, FORMAT, Output, Thumbnail}; diff --git a/rs/moq-scene/src/place.rs b/rs/moq-scene/src/place.rs index 6e339334..33c169c9 100644 --- a/rs/moq-scene/src/place.rs +++ b/rs/moq-scene/src/place.rs @@ -15,7 +15,7 @@ use std::time::Duration; use kio::clock::Instant; -use crate::collection::{Canvas, Item, KeepClear, Rect, mix}; +use crate::collection::{Canvas, Id, Item, KeepClear, Rect, mix}; use crate::compositor::Target; use crate::effect::Effects; use crate::glide::Glide; @@ -497,6 +497,8 @@ struct Before { /// under it show. pub(crate) struct Placer { sight: Sight, + /// What its glide calls the item, so it glides on from where it was drawn. + id: Id, at: At, /// When it last started looking before choosing: when it began, its /// scene went on, or the content under it changed. @@ -546,6 +548,7 @@ impl Placer { }; Self { sight: Sight::default(), + id: Id::fresh(), at: At::Rest, looking: Some(now), worst: None, @@ -769,7 +772,7 @@ impl Placer { ..paused }; self.glide = Glide::new(self.glides, |_| true); - self.glide.show(self.moves, &[shown(at)], now); + self.glide.show(self.moves, &[shown(self.id, at)], now); self.moves += 1; } let rect = match self.paused { @@ -791,7 +794,7 @@ impl Placer { self.glide = Glide::new(self.glides, |_| true); } self.aimed = Some((target, self.moves)); - self.glide.show(self.moves, &[shown(target)], now); + self.glide.show(self.moves, &[shown(self.id, target)], now); self.glide.placed()[0].rect } }; @@ -905,15 +908,19 @@ impl Placer { // Another length: a glide of that length, from where it is. self.glides = keep.glide; self.glide = Glide::new(keep.glide, |_| true); - self.glide.show(self.moves, &[shown(self.placement.rect)], now); + self.glide.show(self.moves, &[shown(self.id, self.placement.rect)], now); } self.moves += 1; } } -/// An item at `rect`, standing for the one keeping clear in its glide. -fn shown(rect: Rect) -> Item { - Item::new("keeping clear", rect) +/// An item at `rect`, standing for the one keeping clear in its glide as +/// `id`. +fn shown(id: Id, rect: Rect) -> Item { + Item { + id, + ..Item::new("keeping clear", rect) + } } /// The pipeline every read of the picture under an item goes through. diff --git a/rs/moq-studio/src/engine.rs b/rs/moq-studio/src/engine.rs index 6282b1b0..6a6d1739 100644 --- a/rs/moq-studio/src/engine.rs +++ b/rs/moq-studio/src/engine.rs @@ -29,7 +29,7 @@ //! edits to them settle, and takes or holds an outside edit to the scene file. //! - The UI runs on the main thread and edits [`State`] under its lock. -use std::collections::{BTreeMap, BTreeSet}; +use std::collections::{BTreeMap, BTreeSet, HashMap}; use std::path::{Path, PathBuf}; use std::sync::atomic::{AtomicBool, AtomicU64, Ordering}; use std::sync::{Arc, Mutex, mpsc}; @@ -300,8 +300,7 @@ impl State { /// the scene file has it until the content under it changes. fn hold(&mut self, moved: &[Moved]) { for moved in moved { - self.compositor - .redone(&moved.scene, moved.index, &moved.source, moved.rect); + self.compositor.redone(moved.id, moved.rect); } } @@ -313,8 +312,7 @@ impl State { fn undone(&mut self, moved: &[Moved]) { let now = kio::clock::now(); for moved in moved { - self.compositor - .undone(&moved.scene, moved.index, &moved.source, moved.rect, now); + self.compositor.undone(moved.id, moved.rect, now); } } @@ -334,7 +332,7 @@ impl State { before.apply(edit)?; } keep_on_air(self.compositor.on_air(), &renames, &collection)?; - let moved = moved(&self.collection, &collection, &renames); + let moved = moved(&self.collection, &collection); self.compositor.fit(&collection)?; for renames in &renames { self.compositor.rename(renames); @@ -647,6 +645,15 @@ impl State { fn edited(&mut self) { self.stale = true; self.edits.record(); + self.remember(); + } + + /// Keep the placer of each layer that stopped keeping clear or left its + /// scene only while an undo or a redo can bring it back. + fn remember(&mut self) { + let held = self.collection.layers().flat_map(|(_, items)| items); + let ids = held.chain(self.history.items()).map(|item| item.id); + self.compositor.remember(ids); } } @@ -712,15 +719,20 @@ impl autosave::Document for State { /// Swap in a collection and history reloaded from their files. fn replace(&mut self, loaded: autosave::Loaded) -> anyhow::Result<()> { let autosave::Loaded { - collection, - history, + mut collection, + mut history, dropped, } = loaded; + // Each layer that was here before is the same layer, so its placer + // goes on. + collection.recognize(&self.collection); + history.align(&collection); // A scene in preview or on program that the file no longer has, such as // one renamed by hand, leaves it until another is picked. let moved = self.adopt(collection, &[])?; self.hold(&moved); self.history = history; + self.remember(); self.dropped = dropped; self.reloads += 1; self.stale = true; @@ -732,75 +744,33 @@ impl autosave::Document for State { /// finds it. #[derive(Clone, Debug, PartialEq)] struct Moved { - scene: String, - index: usize, - source: String, + id: moq_scene::Id, /// Where it is saved now. rect: moq_scene::Rect, } -/// Each scene item keeping clear in `after` that `before` saved elsewhere or -/// had not keeping clear: the same scene's item at the same index showing -/// the same source, at another x or y or switched back on, or one switched -/// back on that `before` showed elsewhere in the scene, as an undo of a -/// swap into a slot puts it. A scene is the one `renames`, each edit's -/// between them, oldest first, called it in `before`. Its keeper is still -/// under that place, as the compositor follows items only as it renders. A +/// Each scene item keeping clear in `after` that `before` saved at another +/// x or y, had not keeping clear, or lacked, as an undo of its removal or +/// of Keep always on top brings it back, each matched by its identity. A /// change of order alone moves nothing. -fn moved(before: &Collection, after: &Collection, renames: &[BTreeMap>]) -> Vec { - let mut moved = Vec::new(); - for scene in &after.scenes { - let Some(was) = was_named(renames, &scene.name).and_then(|name| before.scene(&name)) else { - continue; - }; - if reordered(&was.items, &scene.items) { - continue; - } - for (index, item) in scene.items.iter().enumerate() { - let Some(old) = was.items.get(index) else { continue }; - let switched_on = |old: &moq_scene::Item| old.source == item.source && old.keep_clear.is_none(); - if item.keep_clear.is_some() - && (switched_on(old) - || (old.source == item.source && (old.rect.x, old.rect.y) != (item.rect.x, item.rect.y)) - || (old.source != item.source && was.items.iter().any(switched_on))) - { - moved.push(Moved { - scene: scene.name.clone(), - index, - source: item.source.clone(), - rect: item.rect, - }); - } - } - } - moved -} - -/// What the scene called `name` after `renames`, each edit's, oldest first, -/// was called before them, or `None` if one of them added it. -fn was_named(renames: &[BTreeMap>], name: &str) -> Option { - let mut name = name.to_string(); - for renames in renames.iter().rev() { - if let Some((from, _)) = renames.iter().find(|(_, to)| to.as_deref() == Some(name.as_str())) { - name = from.clone(); - } else if renames.contains_key(&name) { - return None; - } - } - Some(name) -} - -/// Whether `after` holds each of `before`'s items once, in any order. -fn reordered(before: &[moq_scene::Item], after: &[moq_scene::Item]) -> bool { - let mut left: Vec<&moq_scene::Item> = before.iter().collect(); - before.len() == after.len() - && after.iter().all(|item| { - let Some(at) = left.iter().position(|old| *old == item) else { - return false; - }; - left.swap_remove(at); - true +fn moved(before: &Collection, after: &Collection) -> Vec { + let was: HashMap = before + .layers() + .flat_map(|(_, items)| items) + .map(|item| (item.id, item)) + .collect(); + let stayed = |item: &moq_scene::Item| { + was.get(&item.id) + .is_some_and(|old| old.keep_clear.is_some() && (old.rect.x, old.rect.y) == (item.rect.x, item.rect.y)) + }; + let keeping = after.scenes.iter().flat_map(|scene| &scene.items); + keeping + .filter(|item| item.keep_clear.is_some() && !stayed(item)) + .map(|item| Moved { + id: item.id, + rect: item.rect, }) + .collect() } /// Refuse edits, each read as its [`Collection::renames`], that remove a @@ -3581,8 +3551,10 @@ mod tests { } /// A layer keeping clear that an undo, a redo, or a reload saved - /// elsewhere, or switched keeping clear back on, is listed as moved; one - /// only resized, another source, or one that does not keep clear is not. + /// elsewhere, switched keeping clear back on, or brought back, as an undo + /// of its removal or of Keep always on top does, is listed as moved, by + /// its identity; one only resized, reordered, renamed with its scene, or + /// that does not keep clear is not. #[test] fn an_undo_or_a_reload_moves_by_hand() { let mut before = red_canvas().collection; @@ -3592,101 +3564,45 @@ mod tests { width: 100.0, height: 100.0, }; - let keeping = moq_scene::Item { + let keeping = || moq_scene::Item { keep_clear: Some(moq_scene::KeepClear::default()), ..moq_scene::Item::new("red", rect) }; - before.scenes[0] - .items - .extend([keeping.clone(), keeping.clone(), keeping]); + (before.scenes[0].items).extend([keeping(), keeping(), keeping()]); before.scenes[0].items.push(moq_scene::Item::new("red", rect)); before.scenes[0].items.push(moq_scene::Item::new("red", rect)); - let main = before.scenes[0].name.clone(); + let id = |collection: &Collection, index: usize| collection.scenes[0].items[index].id; + let moved = |id, rect| Moved { id, rect }; + let elsewhere = moq_scene::Rect { x: 300.0, ..rect }; + let mut after = before.clone(); let items = &mut after.scenes[0].items; items[1].rect.x = 300.0; items[2].rect.width = 50.0; - items[3].source = "blue".into(); - items[3].rect.x = 300.0; items[4].rect.x = 300.0; items[5].keep_clear = Some(moq_scene::KeepClear::default()); - let moved = |index, rect| Moved { - scene: main.clone(), - index, - source: "red".into(), - rect, - }; - let elsewhere = moq_scene::Rect { x: 300.0, ..rect }; assert_eq!( - super::moved(&before, &after, &[]), - [moved(1, elsewhere), moved(5, rect)] + super::moved(&before, &after), + [moved(id(&before, 1), elsewhere), moved(id(&before, 5), rect)] ); // Two keeping clear of the same source swapped, as an undo of a - // change of order does: neither moved. - let mut after = before.clone(); - after.scenes[0].items[1].rect.x = 300.0; - let mut swapped = after.clone(); - swapped.scenes[0].items.swap(1, 2); - assert_eq!(super::moved(&after, &swapped, &[]), []); - - // Switched back on where `before` showed it elsewhere in the scene, as - // an undo of a swap into a slot puts it. - let mut kept = before.clone(); - kept.scenes[0].items.truncate(2); - kept.scenes[0].items.push(moq_scene::Item::new("blue", rect)); - let mut slotted = kept.clone(); - slotted.scenes[0].items.swap(1, 2); - slotted.scenes[0].items[2].keep_clear = None; - assert_eq!(super::moved(&slotted, &kept, &[]), [moved(1, rect)]); - } - - /// Scenes are matched across the renames between them, so two that swap - /// names move nothing, and a move in a renamed scene is the new name's. - #[test] - fn a_renamed_scene_is_the_one_it_was() { - let mut before = red_canvas().collection; - let keeping = |x| moq_scene::Item { - keep_clear: Some(moq_scene::KeepClear::default()), - ..moq_scene::Item::new( - "red", - moq_scene::Rect { - x, - y: 0.0, - width: 100.0, - height: 100.0, - }, - ) - }; - before.scenes[0].name = "a".into(); - before.scenes[0].items = vec![keeping(0.0)]; - before.scenes.push(moq_scene::Scene { - items: vec![keeping(200.0)], - ..moq_scene::Scene::new("b") + // change of order does, in a renamed scene: neither moved. + let mut swapped = before.clone(); + swapped.scenes[0].items.swap(1, 3); + swapped.scenes[0].name = "Renamed".into(); + assert_eq!(super::moved(&before, &swapped), []); + + // Brought back where it was, by an undo of its removal or of Keep + // always on top. + let mut removed = before.clone(); + let gone = removed.scenes[0].items.remove(2); + assert_eq!(super::moved(&removed, &before), [moved(gone.id, rect)]); + removed.top.push(moq_scene::Item { + keep_clear: None, + ..gone }); - let mut after = before.clone(); - after.scenes[0].name = "b".into(); - after.scenes[1].name = "a".into(); - let swap = BTreeMap::from([ - ("a".to_string(), Some("b".to_string())), - ("b".to_string(), Some("a".to_string())), - ]); - assert_eq!(super::moved(&before, &after, &[swap]), []); - - after.scenes[0].items[0].rect.x = 50.0; - let rename = BTreeMap::from([("a".to_string(), Some("c".to_string()))]); - let added = BTreeMap::from([("b".to_string(), None)]); - after.scenes[0].name = "c".into(); - after.scenes[1].name = "b".into(); - assert_eq!( - super::moved(&before, &after, &[rename, added]), - [Moved { - scene: "c".into(), - index: 0, - source: "red".into(), - rect: after.scenes[0].items[0].rect, - }] - ); + assert_eq!(super::moved(&removed, &before), [moved(id(&before, 2), rect)]); } /// An undo of a move by hand puts a layer keeping clear back as it was @@ -3717,6 +3633,7 @@ mod tests { let slot = moq_scene::Rect { y: 0.0, ..rect }; (loaded.collection.scenes[0].items).push(moq_scene::Item::new("blue", slot)); let main = loaded.collection.scenes[0].name.clone(); + let red = loaded.collection.scenes[0].items[1].id; let gpu = Gpu::new(wgpu::Backends::all()).await.expect("a GPU"); let (autosave, _) = Autosave::open(dir.path().join("show.toml")).unwrap(); let engine = start(gpu, Vec::new(), dir.path(), autosave, loaded) @@ -3724,16 +3641,9 @@ mod tests { .expect("the studio starts"); let placed = |at: moq_scene::Rect, held: bool| { let engine = &engine; - let main = &main; async move { loop { - let placement = engine - .state - .lock() - .unwrap() - .compositor - .placement(main, 1, "red") - .cloned(); + let placement = engine.state.lock().unwrap().compositor.placement(red).cloned(); if placement.is_some_and(|placement| placement.rect == at && placement.held == held) { return; } @@ -3748,7 +3658,7 @@ mod tests { let commit = |to: moq_scene::Rect, by_hand: bool| { let mut state = engine.state.lock().unwrap(); if by_hand { - state.compositor.hold(&main, 1, "red"); + state.compositor.hold(red); } let collection = state.collection(); let item = collection.scenes[0].items[1].clone(); @@ -3805,14 +3715,7 @@ mod tests { } // The render that drops its keeper parks it. kio::clock::timeout(TIMEOUT, async { - while engine - .state - .lock() - .unwrap() - .compositor - .placement(&main, 1, "red") - .is_some() - { + while engine.state.lock().unwrap().compositor.placement(red).is_some() { kio::clock::sleep(Duration::from_millis(10)).await; } }) diff --git a/rs/moq-studio/src/shots.rs b/rs/moq-studio/src/shots.rs index 5c3af1ea..f39ed3eb 100644 --- a/rs/moq-studio/src/shots.rs +++ b/rs/moq-studio/src/shots.rs @@ -1808,7 +1808,7 @@ fn shoot(open: &Open, gpu: &engine::Gpu, runtime: &tokio::runtime::Runtime, show let landed = { let state = engine.state.lock().unwrap(); let item = &state.collection().scenes[0].items[1]; - let placement = state.compositor.placement("Gameplay", 1, &item.source); + let placement = state.compositor.placement(item.id); placement.is_some_and(|placement| { let slot = placement .slot diff --git a/rs/moq-studio/src/ui/build.rs b/rs/moq-studio/src/ui/build.rs index c2a6eff4..e5a9560e 100644 --- a/rs/moq-studio/src/ui/build.rs +++ b/rs/moq-studio/src/ui/build.rs @@ -283,8 +283,7 @@ impl Panels { let state = self.engine.state.lock().unwrap(); let item = picked.item(state.collection()); item.is_some_and(|item| { - self.drawn(&state, picked, item) - && keep::placement(&state, &picked.layer, picked.index, item, self.format).is_some() + self.drawn(&state, picked, item) && keep::placement(&state, &picked.layer, item, self.format).is_some() }) } @@ -401,7 +400,7 @@ impl Panels { // A layer keeping clear moves from where it was placed. let resting = picked .rest(collection, self.format) - .map(|item| keep::placed(state, &picked.layer, picked.index, &item, self.format)); + .map(|item| keep::placed(state, &picked.layer, &item, self.format)); if let Some(resting) = resting { let drawn = match resting.slot { Some(_) => super::slots::drawn(state, &picked.layer, picked.index, self.format), @@ -531,10 +530,10 @@ impl Panels { // a resize or a crop leaves it where it rests. let rect = match verb { "Move" => { - keep::hold(state, &picked.layer, picked.index, &item, self.format); + keep::hold(state, &picked.layer, &item, self.format); rect } - _ => keep::resized(state, &picked.layer, picked.index, &item, rect, self.format), + _ => keep::resized(state, &picked.layer, &item, rect, self.format), }; if let Some(placed) = picked.placed(state.collection(), self.format, rect, crop) { result = edit(state, label, drag.gesture, |draft| { @@ -567,7 +566,7 @@ impl Panels { // being dragged, which holds it where it is put. if let Some((picked, item)) = selected.filter(|(_, item)| item.visible && self.drag.is_none()) && let Some(resting) = picked.item(state.collection()) - && let Some(placement) = keep::placement(state, &picked.layer, picked.index, resting, self.format) + && let Some(placement) = keep::placement(state, &picked.layer, resting, self.format) && let Some(keep) = resting.keep_clear { keep::overlay(&painter, &view, placement, &item.shape, keep.glide); @@ -672,7 +671,7 @@ impl Panels { return (None, Ok(())); }; // A layer keeping clear moves from where it was placed. - let item = keep::placed(state, &picked.layer, picked.index, &item, self.format); + let item = keep::placed(state, &picked.layer, &item, self.format); if delta == [0.0; 2] { return (None, Ok(())); } @@ -690,7 +689,7 @@ impl Panels { let Some(moved) = picked.placed(state.collection(), self.format, rect, item.crop) else { return (None, Ok(())); }; - keep::hold(state, &picked.layer, picked.index, &item, self.format); + keep::hold(state, &picked.layer, &item, self.format); let result = edit(state, label, Some(gesture), |draft| { draft.set_item(&picked.layer, picked.index, moved) }); @@ -906,7 +905,7 @@ impl Panels { // keep clear of; it stays where it was drawn, in each picture // it goes to. let drawn = |format| { - let placed = collection.portrayed(&keep::placed(state, layer, index, &item, format), format); + let placed = collection.portrayed(&keep::placed(state, layer, &item, format), format); let (rect, crop) = super::slots::drawn(state, layer, index, format).unwrap_or((item.rect, item.crop)); match item.slot { @@ -948,6 +947,7 @@ impl Panels { } LayerAction::Duplicate { independent } => { let mut copy = Item { + id: moq_scene::Id::fresh(), auto: false, ..item.clone() }; @@ -1488,6 +1488,7 @@ pub(super) fn scene_copy(scene: &Scene, name: String) -> Scene { .items .iter() .map(|item| Item { + id: moq_scene::Id::fresh(), auto: false, ..item.clone() }) diff --git a/rs/moq-studio/src/ui/inspector.rs b/rs/moq-studio/src/ui/inspector.rs index 630c16a8..5b623a08 100644 --- a/rs/moq-studio/src/ui/inspector.rs +++ b/rs/moq-studio/src/ui/inspector.rs @@ -164,8 +164,8 @@ impl Panels { // Where the picture draws it: a layer keeping clear where it was // placed, which a move by hand starts from. Keeping clear places only // the landscape picture, so its switch and what it saw speak of that. - let placement = keep::placement(&state, &picked.layer, picked.index, &item, Format::Landscape); - let drawn = keep::placement(&state, &picked.layer, picked.index, &item, format); + let placement = keep::placement(&state, &picked.layer, &item, Format::Landscape); + let drawn = keep::placement(&state, &picked.layer, &item, format); let mut rect = drawn.map_or(rest.rect, |placement| placement.drawn(rest.rect)); // A layer the picture BUILD edits never shows has no place there. let placeable = item.shown_in(collection.format_of(&picked.layer, format)); @@ -606,7 +606,7 @@ impl Panels { keep_clear: kept, ..item.clone() }; - keep::hold(&mut state, &picked.layer, picked.index, &was, format); + keep::hold(&mut state, &picked.layer, &was, format); } edit(&mut state, label, gesture, |draft| { draft.set_item(&picked.layer, picked.index, item) diff --git a/rs/moq-studio/src/ui/keep.rs b/rs/moq-studio/src/ui/keep.rs index fec84426..de708077 100644 --- a/rs/moq-studio/src/ui/keep.rs +++ b/rs/moq-studio/src/ui/keep.rs @@ -25,28 +25,22 @@ const GLIDES: [Duration; 5] = [ /// The legend's height under the stage, with its gap. pub(super) const LEGEND: f32 = 30.0; -/// How the last render placed `item`, the `index`th of `layer`, in -/// `format`'s picture while it keeps clear. Keeping clear places only the -/// landscape picture, so none in the portrait one. -pub(super) fn placement<'a>( - state: &'a State, - layer: &Layer, - index: usize, - item: &Item, - format: Format, -) -> Option<&'a Placement> { +/// How the last render placed `item`, one of `layer`, in `format`'s +/// picture while it keeps clear. Keeping clear places only the landscape +/// picture, so none in the portrait one. +pub(super) fn placement<'a>(state: &'a State, layer: &Layer, item: &Item, format: Format) -> Option<&'a Placement> { item.keep_clear?; - let scene = layer.scene.as_deref()?; + layer.scene.as_ref()?; if state.collection().format_of(layer, format) != Format::Landscape { return None; } - state.compositor.placement(scene, index, &item.source) + state.compositor.placement(item.id) } -/// `item`, the `index`th of `layer`, resting where `format`'s picture draws -/// it: a layer keeping clear where it was placed. -pub(super) fn placed(state: &State, layer: &Layer, index: usize, item: &Item, format: Format) -> Item { - match placement(state, layer, index, item, format) { +/// `item`, one of `layer`, resting where `format`'s picture draws it: a +/// layer keeping clear where it was placed. +pub(super) fn placed(state: &State, layer: &Layer, item: &Item, format: Format) -> Item { + match placement(state, layer, item, format) { Some(placement) => Item { rect: placement.drawn(item.rect), ..item.clone() @@ -58,8 +52,8 @@ pub(super) fn placed(state: &State, layer: &Layer, index: usize, item: &Item, fo /// `rect`, a new rect in `format`'s picture for `item` from a gesture other /// than a move, such as a resize, to save: a layer placed off where it rests /// keeps resting where it did, so the resize leaves it free to keep clear. -pub(super) fn resized(state: &State, layer: &Layer, index: usize, item: &Item, rect: Rect, format: Format) -> Rect { - match placement(state, layer, index, item, format) { +pub(super) fn resized(state: &State, layer: &Layer, item: &Item, rect: Rect, format: Format) -> Rect { + match placement(state, layer, item, format) { Some(placement) if placement.drawn(item.rect) != item.rect => Rect { x: item.rect.x, y: item.rect.y, @@ -69,16 +63,16 @@ pub(super) fn resized(state: &State, layer: &Layer, index: usize, item: &Item, r } } -/// Note that `item`, the `index`th of `layer`, was moved by hand in -/// `format`'s picture: a layer keeping clear stays where it was put until the -/// content under it changes. A move in the portrait picture, which keeping -/// clear does not place, holds nothing. -pub(super) fn hold(state: &mut State, layer: &Layer, index: usize, item: &Item, format: Format) { +/// Note that `item`, one of `layer`, was moved by hand in `format`'s +/// picture: a layer keeping clear stays where it was put until the content +/// under it changes. A move in the portrait picture, which keeping clear +/// does not place, holds nothing. +pub(super) fn hold(state: &mut State, layer: &Layer, item: &Item, format: Format) { if item.keep_clear.is_some() - && let Some(scene) = layer.scene.as_deref() + && layer.scene.is_some() && state.collection().format_of(layer, format) == Format::Landscape { - state.compositor.hold(scene, index, &item.source); + state.compositor.hold(item.id); } } @@ -88,15 +82,11 @@ pub(super) fn hold(state: &mut State, layer: &Layer, index: usize, item: &Item, pub(super) fn grab(state: &mut State, picked: Option<&Picked>, format: Format) { let collection = state.collection(); let grabbed = picked.and_then(|picked| { - let scene = picked.layer.scene.clone()?; + picked.layer.scene.as_ref()?; let item = picked.item(collection)?; item.keep_clear?; - (collection.format_of(&picked.layer, format) == Format::Landscape).then_some(())?; - Some((scene, picked.index, item.source.clone())) + (collection.format_of(&picked.layer, format) == Format::Landscape).then_some(item.id) }); - let grabbed = grabbed - .as_ref() - .map(|(scene, index, source)| (scene.as_str(), *index, source.as_str())); state.compositor.grab(grabbed, kio::clock::now()); } @@ -114,13 +104,13 @@ pub(super) fn drawn<'a>(state: &State, staged: Cow<'a, Collection>, format: Form if item.keep_clear.is_none() { continue; } - let Some(placement) = state.compositor.placement(&scene.name, index, &item.source) else { + let Some(placement) = state.compositor.placement(item.id) else { continue; }; // A scene staged one frame behind an edit may lack it. let staged = drawn.scenes.get(number).and_then(|staged| staged.items.get(index)); let rect = placement.drawn(item.rect); - if staged.is_some_and(|staged| staged.source == item.source && staged.rect != rect) { + if staged.is_some_and(|staged| staged.id == item.id && staged.rect != rect) { drawn.to_mut().scenes[number].items[index].rect = rect; } } diff --git a/rs/moq-studio/src/ui/slots.rs b/rs/moq-studio/src/ui/slots.rs index 68c0c2a1..345e82fc 100644 --- a/rs/moq-studio/src/ui/slots.rs +++ b/rs/moq-studio/src/ui/slots.rs @@ -16,8 +16,9 @@ pub(super) fn placed(state: &State, layer: &Layer, format: Format) -> Vec let format = collection.format_of(layer, format); let items = collection.items(layer).unwrap_or_default(); // A layer set free that keeps clear, where it was placed. - let items = (items.iter().enumerate()) - .map(|(index, item)| super::keep::placed(state, layer, index, &collection.portrayed(item, format), format)); + let items = items + .iter() + .map(|item| super::keep::placed(state, layer, &collection.portrayed(item, format), format)); let arranged = (layer.scene.as_deref()).and_then(|scene| state.compositor.placed(format, scene)); // One frame behind an edit, until the next render arranges it. let Some(arranged) = arranged.filter(|arranged| arranged.len() == items.len()) else { @@ -188,7 +189,7 @@ pub(super) fn assign(state: &mut State, dragged: &Picked, target: &Picked) -> an // clear may be off where it is saved, cropped to its shape there rather // than stretched. let free = |format: Format| { - let resting = super::keep::placed(state, &dragged.layer, dragged.index, &moved, format); + let resting = super::keep::placed(state, &dragged.layer, &moved, format); let Placement { rect, .. } = state.collection().placement(&resting, format); let (from, crop) = drawn(state, &target.layer, target.index, format).unwrap_or((rect, held.crop)); let shape = |rect: &Rect| rect.width / rect.height; diff --git a/rs/moq-studio/src/watch.rs b/rs/moq-studio/src/watch.rs index 7a11d853..8269a483 100644 --- a/rs/moq-studio/src/watch.rs +++ b/rs/moq-studio/src/watch.rs @@ -329,6 +329,7 @@ fn collection(layout: Option<&Layout>, size: Canvas) -> anyhow::Result CANVAS, }; - let collection = match collection(self.layout.as_ref(), size) { + let mut collection = match collection(self.layout.as_ref(), size) { Ok(collection) => collection, Err(err) => { tracing::error!(error = format!("{err:#}"), "playing the program alone"); @@ -409,6 +410,9 @@ impl Watch { if collection.canvas != self.collection.canvas { self.compositor.fit(&collection)?; } + // A picture the last layout showed too is the same layer, so its + // slot glides on from where it was. + collection.recognize(&self.collection); self.collection = collection; for driver in self.sources.sync(&self.collection) { engine::spawn(driver); From 2f7d276cb2db18cc044b5aa68ae11df236790108 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Thu, 19 Nov 2026 06:00:14 -0800 Subject: [PATCH 3/8] fix(scene): keep identities across a reloaded move, swap, removal, and reorder Co-Authored-By: Claude Opus 5.5 --- rs/moq-scene/src/collection.rs | 35 ++++- rs/moq-scene/src/edit.rs | 228 +++++++++++++++++++++++++++------ rs/moq-studio/src/engine.rs | 1 + 3 files changed, 225 insertions(+), 39 deletions(-) diff --git a/rs/moq-scene/src/collection.rs b/rs/moq-scene/src/collection.rs index 915d6605..e5ec7292 100644 --- a/rs/moq-scene/src/collection.rs +++ b/rs/moq-scene/src/collection.rs @@ -2566,26 +2566,47 @@ impl Default for Audio { /// Give each item of `new` the identity of the one of `old` it was, /// returning how many it found: the longest run of items in order showing /// the same source at the same rect, then of the rest, the longest showing -/// the same source. +/// the same source, so two alike keep their order; then of the rest, out +/// of order, as a reorder leaves them, one showing the same source at the +/// same rect, then one showing the same source, each the nearest. pub(crate) fn recognized(old: &[Item], new: &mut [Item]) -> usize { let mut taken = vec![false; old.len()]; let mut found = vec![false; new.len()]; + let same = |same_rect: bool| { + move |was: &Item, item: &Item| was.source == item.source && (!same_rect || was.rect == item.rect) + }; for same_rect in [true, false] { let left: Vec = (0..old.len()).filter(|&at| !taken[at]).collect(); let missing: Vec = (0..new.len()).filter(|&at| !found[at]).collect(); - let same = |was: &Item, item: &Item| was.source == item.source && (!same_rect || was.rect == item.rect); + let same = same(same_rect); for (was, at) in common(&left, &missing, |was, at| same(&old[was], &new[at])) { new[at].id = old[was].id; taken[was] = true; found[at] = true; } } + for same_rect in [true, false] { + let same = same(same_rect); + for at in 0..new.len() { + if found[at] { + continue; + } + let was = (0..old.len()) + .filter(|&was| !taken[was] && same(&old[was], &new[at])) + .min_by_key(|was| was.abs_diff(at)); + if let Some(was) = was { + new[at].id = old[was].id; + taken[was] = true; + found[at] = true; + } + } + } found.iter().filter(|&&found| found).count() } /// The pairs of the longest common subsequence of `a` and `b`, as `same` /// matches their elements, in order. -fn common(a: &[usize], b: &[usize], same: impl Fn(usize, usize) -> bool) -> Vec<(usize, usize)> { +pub(crate) fn common(a: &[usize], b: &[usize], same: impl Fn(usize, usize) -> bool) -> Vec<(usize, usize)> { // How long the common run of `a[i..]` and `b[j..]` is. let mut runs = vec![vec![0usize; b.len() + 1]; a.len() + 1]; for i in (0..a.len()).rev() { @@ -2705,6 +2726,14 @@ mod tests { let added = edited.scenes[0].items[0].id; assert!(!ids(&before).contains(&added), "an added layer is new"); assert_eq!(ids(&edited)[1..], ids(&before)[..]); + + // Reordered by hand, the moved one is still itself, and the two alike + // keep their order, being indistinguishable. + let mut reversed = Collection::from_toml(&before.to_toml().unwrap()).unwrap(); + reversed.scenes[0].items.reverse(); + reversed.recognize(&before); + let was = ids(&before); + assert_eq!(ids(&reversed), [was[2], was[0], was[1], was[3]]); } fn example() -> Collection { diff --git a/rs/moq-scene/src/edit.rs b/rs/moq-scene/src/edit.rs index 461e8543..8b046fbb 100644 --- a/rs/moq-scene/src/edit.rs +++ b/rs/moq-scene/src/edit.rs @@ -9,13 +9,13 @@ //! Build an edit with a [`Draft`], which reads what each change replaces from //! the collection as the earlier changes left it. -use std::collections::{BTreeMap, VecDeque}; +use std::collections::{BTreeMap, HashMap, HashSet, VecDeque}; use serde::{Deserialize, Serialize}; use crate::Error; use crate::collection::{ - Audio, AudioScene, Canvas, Collection, Filter, Item, Layer, Scene, Source, Transition, Video, recognized, + Audio, AudioScene, Canvas, Collection, Filter, Id, Item, Layer, Scene, Source, Transition, Video, common, }; /// One part of a collection, before and after an edit. @@ -159,6 +159,62 @@ impl Change { } } + /// The items it holds before, or after. + fn items_on(&self, before: bool) -> Vec<&Item> { + match self { + Self::Item { before: b, after, .. } => { + let side = if before { b } else { after }; + side.iter().map(|item| &**item).collect() + } + Self::Scene { before: b, after, .. } => { + let side = if before { b } else { after }; + side.iter().flat_map(|scene| &scene.items).collect() + } + _ => Vec::new(), + } + } + + /// The items it holds before and after, to give identities. + fn sides_mut(&mut self) -> (Vec<&mut Item>, Vec<&mut Item>) { + match self { + Self::Item { before, after, .. } => ( + before.iter_mut().map(|item| &mut **item).collect(), + after.iter_mut().map(|item| &mut **item).collect(), + ), + Self::Scene { before, after, .. } => ( + before.iter_mut().flat_map(|scene| &mut scene.items).collect(), + after.iter_mut().flat_map(|scene| &mut scene.items).collect(), + ), + _ => (Vec::new(), Vec::new()), + } + } + + /// The identities `collection` holds where the items it replaces or + /// removes are, in their order. + fn held(&self, collection: &Collection) -> Vec { + match self { + Self::Item { + layer, + index, + before: Some(_), + .. + } => { + let at = collection.items(layer).and_then(|items| items.get(*index)); + at.map(|item| item.id).into_iter().collect() + } + Self::Scene { + index, before: Some(_), .. + } => { + let at = collection.scenes.get(*index); + at.into_iter() + .flat_map(|scene| &scene.items) + .map(|item| item.id) + .collect() + } + _ => Vec::new(), + } + } + /// The items it holds, before and after. fn items(&self) -> Vec<&Item> { match self { @@ -1246,46 +1302,116 @@ impl History { } } + /// Give the items of each entry here that `before` holds too, alike, + /// the identities they have there, as a reload of a history saved from + /// `before`, already [aligned](Self::align) with its collection, needs + /// for the items no layer shows, such as one removed, so an undo that + /// brings it back brings back the same item. Entries are matched in + /// order. + pub fn recognize(&mut self, before: &History, collection: &Collection) { + let shown: HashSet = collection + .layers() + .flat_map(|(_, items)| items) + .map(|item| item.id) + .collect(); + let now: Vec = (0..self.entries.len()).collect(); + let was: Vec = (0..before.entries.len()).collect(); + let pairs = common(&was, &now, |was, now| { + before.entries[was].edit == self.entries[now].edit + }); + let mut ids = HashMap::new(); + for (was, now) in pairs { + let changes = before.entries[was] + .edit + .changes + .iter() + .zip(&self.entries[now].edit.changes); + for (old, new) in changes { + for side in [true, false] { + for (old, new) in old.items_on(side).into_iter().zip(new.items_on(side)) { + if !shown.contains(&new.id) { + ids.insert(new.id, old.id); + } + } + } + } + } + for entry in &mut self.entries { + for change in &mut entry.edit.changes { + let (befores, afters) = change.sides_mut(); + for item in befores.into_iter().chain(afters) { + if let Some(&id) = ids.get(&item.id) { + item.id = id; + } + } + } + } + } + /// Every item an undo or a redo may put back. pub fn items(&self) -> impl Iterator { self.entries().flat_map(|edit| &edit.changes).flat_map(Change::items) } } -/// Make `edit` to `state`, each change first given the identities of the -/// items it replaces there, as [`History::align`] says. +/// Make `edit` to `state`, first giving the items each change replaces or +/// removes the identities they have there, and each item it puts in place +/// the identity of the one it took from, as [`History::align`] says. fn aligned(state: &mut Collection, edit: &mut Edit) -> Result<(), Error> { + // Made once as loaded, to read the identity of each item a change + // replaces, which may be one an earlier change of the edit put in place. + let mut scratch = state.clone(); for change in &mut edit.changes { - match change { - Change::Item { - layer, - index, - before: Some(before), - after, - } => { - if let Some(at) = state.items(layer).and_then(|items| items.get(*index)) { - before.id = at.id; - } - if let Some(after) = after { - after.id = before.id; - } - } - Change::Scene { - index, - before: Some(before), - after, - } => { - if let Some(at) = state.scenes.get(*index) { - for (item, at) in before.items.iter_mut().zip(&at.items) { - item.id = at.id; - } - } - if let Some(after) = after { - recognized(&before.items, &mut after.items); - } + let held = change.held(&scratch); + for (item, id) in change.sides_mut().0.into_iter().zip(held) { + item.id = id; + } + change.apply(&mut scratch)?; + } + + // Each item put in place takes the identity of one the edit took out + // that it did not put in itself: one alike, then one showing the same + // source, from the same change first, as a set or a scene replaced + // keeps its own, then from any, as a move or a swap carries it. + let afters = |change: &Change| change.items_on(false).into_iter().cloned().collect::>(); + let afters: Vec> = edit.changes.iter().map(afters).collect(); + let added: HashSet = afters.iter().flatten().map(|item| item.id).collect(); + let mut left: Vec<(usize, usize, &Item)> = Vec::new(); + for (number, change) in edit.changes.iter().enumerate() { + let befores = change.items_on(true).into_iter().enumerate(); + left.extend( + befores + .filter(|(_, item)| !added.contains(&item.id)) + .map(|(at, item)| (number, at, item)), + ); + } + let mut missing: Vec<(usize, usize, &Item)> = Vec::new(); + for (number, items) in afters.iter().enumerate() { + missing.extend(items.iter().enumerate().map(|(at, item)| (number, at, item))); + } + let mut ids: HashMap = HashMap::new(); + for (alike, same_change) in [(true, true), (true, false), (false, true), (false, false)] { + missing.retain(|(number, at, item)| { + let found = (left.iter().enumerate()) + .filter(|(_, (from, _, was))| { + was.source == item.source && (!alike || *was == *item) && (!same_change || from == number) + }) + .min_by_key(|(_, (_, was_at, _))| was_at.abs_diff(*at)) + .map(|(found, _)| found); + let Some(found) = found else { return true }; + ids.insert(item.id, left.remove(found).2.id); + false + }); + } + for change in &mut edit.changes { + let (befores, afters) = change.sides_mut(); + for item in befores.into_iter().chain(afters) { + if let Some(&id) = ids.get(&item.id) { + item.id = id; } - _ => {} } + } + for change in &edit.changes { change.apply(state)?; } Ok(()) @@ -1951,16 +2077,26 @@ mod tests { assert_eq!(ids(&collection), seen[to], "at {to}"); } + // After a reload every identity is new, but each item is still one + // item: each point holds the items it held, under one new identity + // each, an item moved or removed and put back included. let text = history.to_toml().unwrap(); let mut collection = Collection::from_toml(&collection.to_toml().unwrap()).unwrap(); let (mut loaded, _) = History::from_toml(&text, &collection).unwrap(); - let mut seen: Vec>> = vec![None; total + 1]; - seen[loaded.position()] = Some(ids(&collection)); + let mut renamed: HashMap = HashMap::new(); + let mut taken: HashSet = HashSet::new(); for _ in 0..80 { let to = next(total + 1); loaded.seek(&mut collection, to).unwrap(); - let now = ids(&collection); - assert_eq!(*seen[to].get_or_insert(now.clone()), now, "at {to} after a reload"); + for (was, now) in seen[to].iter().zip(ids(&collection)) { + match renamed.get(was) { + Some(&had) => assert_eq!(had, now, "at {to} after a reload"), + None => { + assert!(taken.insert(now), "at {to}, two items under one identity"); + renamed.insert(*was, now); + } + } + } } } @@ -2004,6 +2140,26 @@ mod tests { assert_eq!(ids(&reloaded), [red, blue], "red back"); } + /// A history reloaded unchanged takes the identities of the items it + /// held before that no layer shows, so an undo of a removal after a + /// reload brings back the same item. + #[test] + fn a_reloaded_history_keeps_what_it_removed() { + let mut collection = collection(); + let mut history = History::new(); + let red = collection.scenes[0].items[0].id; + let mut draft = collection.draft("Remove red"); + draft.remove_item(&main(), 0).unwrap(); + commit(&mut collection, &mut history, draft, None); + + let mut reloaded = Collection::from_toml(&collection.to_toml().unwrap()).unwrap(); + reloaded.recognize(&collection); + let (mut loaded, _) = History::from_toml(&history.to_toml().unwrap(), &reloaded).unwrap(); + loaded.recognize(&history, &reloaded); + loaded.undo(&mut reloaded).unwrap(); + assert_eq!(reloaded.scenes[0].items[0].id, red); + } + /// After a hand edit, an entry the scene file no longer matches is dropped /// with everything older, and the newer ones still undo. #[test] diff --git a/rs/moq-studio/src/engine.rs b/rs/moq-studio/src/engine.rs index 6a6d1739..f7fcc943 100644 --- a/rs/moq-studio/src/engine.rs +++ b/rs/moq-studio/src/engine.rs @@ -727,6 +727,7 @@ impl autosave::Document for State { // goes on. collection.recognize(&self.collection); history.align(&collection); + history.recognize(&self.history, &collection); // A scene in preview or on program that the file no longer has, such as // one renamed by hand, leaves it until another is picked. let moved = self.adopt(collection, &[])?; From e311bf62d432507d095f44d58900cd0bf3289a3e Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Thu, 19 Nov 2026 06:06:49 -0800 Subject: [PATCH 4/8] fix(scene): save each history item's identity in the history file Aligning a loaded history by content could not tell swapped or re-sourced layers apart; numbering each item in the file makes the link exact. Co-Authored-By: Claude Opus 5.5 --- rs/moq-scene/src/collection.rs | 5 + rs/moq-scene/src/edit.rs | 161 +++++++++++++++++---------------- 2 files changed, 88 insertions(+), 78 deletions(-) diff --git a/rs/moq-scene/src/collection.rs b/rs/moq-scene/src/collection.rs index e5ec7292..d9e931b6 100644 --- a/rs/moq-scene/src/collection.rs +++ b/rs/moq-scene/src/collection.rs @@ -1419,6 +1419,11 @@ impl Id { static NEXT: AtomicU64 = AtomicU64::new(0); Self(NEXT.fetch_add(1, Ordering::Relaxed)) } + + /// The number that names it, unique while the studio runs. + pub(crate) fn number(self) -> u64 { + self.0 + } } impl Item { diff --git a/rs/moq-scene/src/edit.rs b/rs/moq-scene/src/edit.rs index 8b046fbb..3119d002 100644 --- a/rs/moq-scene/src/edit.rs +++ b/rs/moq-scene/src/edit.rs @@ -174,7 +174,7 @@ impl Change { } } - /// The items it holds before and after, to give identities. + /// The items it holds before, then after, to give identities. fn sides_mut(&mut self) -> (Vec<&mut Item>, Vec<&mut Item>) { match self { Self::Item { before, after, .. } => ( @@ -468,6 +468,14 @@ pub struct Edit { } impl Edit { + /// Every item its changes hold, each change's before, then after. + fn items_mut(&mut self) -> impl Iterator { + self.changes.iter_mut().flat_map(|change| { + let (befores, afters) = change.sides_mut(); + befores.into_iter().chain(afters) + }) + } + /// The edit that undoes this one. pub fn inverse(&self) -> Self { Self { @@ -1056,6 +1064,12 @@ struct Entry { #[serde(deny_unknown_fields)] struct File { position: usize, + /// The identity of each item of each entry, in the order + /// [`Change::sides_mut`] lists them, as numbers that name one item + /// within the file, so a load tells an item moved or swapped from another + /// alike. A file without them loads each item as a new one. + #[serde(default, skip_serializing_if = "Vec::is_empty")] + ids: Vec>, #[serde(default)] entries: Vec, } @@ -1217,9 +1231,15 @@ impl History { /// Serialize to the history file format, in the scene file's version, /// since entries hold its sources, scenes, and items. pub fn to_toml(&self) -> Result { + let mut entries: Vec = self.entries().cloned().collect(); + let ids = entries + .iter_mut() + .map(|edit| edit.items_mut().map(|item| item.id.number()).collect()) + .collect(); let file = File { position: self.position, - entries: self.entries().cloned().collect(), + ids, + entries, }; let body = toml::to_string(&file).map_err(|err| Error::Format(err.to_string()))?; Ok(format!("version = {}\n\n{body}", Collection::VERSION)) @@ -1235,7 +1255,14 @@ impl History { /// version fails. pub fn from_toml(text: &str, collection: &Collection) -> Result<(Self, usize), Error> { let table = crate::collection::versioned(text)?; - let file = File::deserialize(table).map_err(|err| Error::Format(err.to_string()))?; + let mut file = File::deserialize(table).map_err(|err| Error::Format(err.to_string()))?; + // Each number one item, under one new identity wherever it appears. + let mut ids: HashMap = HashMap::new(); + for (edit, numbers) in file.entries.iter_mut().zip(&file.ids) { + for (item, number) in edit.items_mut().zip(numbers) { + item.id = *ids.entry(*number).or_insert_with(Id::fresh); + } + } if file.position > file.entries.len() { return Err(Error::Format(format!( "position {} is past the history's {} entries", @@ -1276,29 +1303,31 @@ impl History { /// Give the items each entry holds the [identities](Item::id) of the /// items of `collection` they are, as a loaded history, whose items are - /// each fresh, needs, so an undo or a redo keeps each item's own. Each - /// entry reads them from the collection as undoing or redoing to it - /// leaves it: an item it replaces keeps its identity, one it adds stays - /// new, and the items of a scene it replaces are matched as - /// [`Collection::recognize`] matches them. It stops at an entry that no - /// longer applies. + /// each fresh, needs, so an undo or a redo keeps each item's own: each + /// item an entry replaces or removes takes the identity the collection + /// has there, undone or redone to that entry, and so does every other + /// mention of it. It stops at an entry that no longer applies. pub fn align(&mut self, collection: &Collection) { + let mut renames: HashMap = HashMap::new(); let (undo, redo) = self.entries.make_contiguous().split_at_mut(self.position); let mut state = collection.clone(); - for entry in undo.iter_mut().rev() { - let mut inverse = entry.edit.inverse(); - if aligned(&mut state, &mut inverse).is_err() { + for entry in undo.iter().rev() { + if aligned(&mut state, &entry.edit.inverse(), &mut renames).is_err() { break; } - entry.edit = inverse.inverse(); } let mut state = collection.clone(); - for entry in redo { - let mut edit = entry.edit.clone(); - if aligned(&mut state, &mut edit).is_err() { + for entry in redo.iter() { + if aligned(&mut state, &entry.edit, &mut renames).is_err() { break; } - entry.edit = edit; + } + for entry in &mut self.entries { + for item in entry.edit.items_mut() { + if let Some(&id) = renames.get(&item.id) { + item.id = id; + } + } } } @@ -1337,12 +1366,9 @@ impl History { } } for entry in &mut self.entries { - for change in &mut entry.edit.changes { - let (befores, afters) = change.sides_mut(); - for item in befores.into_iter().chain(afters) { - if let Some(&id) = ids.get(&item.id) { - item.id = id; - } + for item in entry.edit.items_mut() { + if let Some(&id) = ids.get(&item.id) { + item.id = id; } } } @@ -1354,64 +1380,25 @@ impl History { } } -/// Make `edit` to `state`, first giving the items each change replaces or -/// removes the identities they have there, and each item it puts in place -/// the identity of the one it took from, as [`History::align`] says. -fn aligned(state: &mut Collection, edit: &mut Edit) -> Result<(), Error> { - // Made once as loaded, to read the identity of each item a change - // replaces, which may be one an earlier change of the edit put in place. - let mut scratch = state.clone(); - for change in &mut edit.changes { - let held = change.held(&scratch); - for (item, id) in change.sides_mut().0.into_iter().zip(held) { +/// Make `edit` to `state`, noting in `renames` the identity `state` has for +/// each item it replaces or removes that the edit names otherwise. +fn aligned(state: &mut Collection, edit: &Edit, renames: &mut HashMap) -> Result<(), Error> { + for change in &edit.changes { + let mut change = change.clone(); + let held = change.held(state); + let (befores, afters) = change.sides_mut(); + for (item, id) in befores.into_iter().zip(held) { + let named = *renames.entry(item.id).or_insert(id); + if named != id { + return Err(conflict(format!("`{}` is two items", item.source))); + } item.id = id; } - change.apply(&mut scratch)?; - } - - // Each item put in place takes the identity of one the edit took out - // that it did not put in itself: one alike, then one showing the same - // source, from the same change first, as a set or a scene replaced - // keeps its own, then from any, as a move or a swap carries it. - let afters = |change: &Change| change.items_on(false).into_iter().cloned().collect::>(); - let afters: Vec> = edit.changes.iter().map(afters).collect(); - let added: HashSet = afters.iter().flatten().map(|item| item.id).collect(); - let mut left: Vec<(usize, usize, &Item)> = Vec::new(); - for (number, change) in edit.changes.iter().enumerate() { - let befores = change.items_on(true).into_iter().enumerate(); - left.extend( - befores - .filter(|(_, item)| !added.contains(&item.id)) - .map(|(at, item)| (number, at, item)), - ); - } - let mut missing: Vec<(usize, usize, &Item)> = Vec::new(); - for (number, items) in afters.iter().enumerate() { - missing.extend(items.iter().enumerate().map(|(at, item)| (number, at, item))); - } - let mut ids: HashMap = HashMap::new(); - for (alike, same_change) in [(true, true), (true, false), (false, true), (false, false)] { - missing.retain(|(number, at, item)| { - let found = (left.iter().enumerate()) - .filter(|(_, (from, _, was))| { - was.source == item.source && (!alike || *was == *item) && (!same_change || from == number) - }) - .min_by_key(|(_, (_, was_at, _))| was_at.abs_diff(*at)) - .map(|(found, _)| found); - let Some(found) = found else { return true }; - ids.insert(item.id, left.remove(found).2.id); - false - }); - } - for change in &mut edit.changes { - let (befores, afters) = change.sides_mut(); - for item in befores.into_iter().chain(afters) { - if let Some(&id) = ids.get(&item.id) { + for item in afters { + if let Some(&id) = renames.get(&item.id) { item.id = id; } } - } - for change in &edit.changes { change.apply(state)?; } Ok(()) @@ -2024,12 +2011,14 @@ mod tests { assert!(collection.sources.is_empty()); } - /// Over many edits of one layer, alike and not, an undo or a redo back to + /// Over many edits of one layer, alike and not, moves, swaps, and changes + /// of source among them, an undo or a redo back to /// any point brings back the items it had, each under its own identity, /// before a reload and after one, whose history keeps those it loads. #[test] fn every_point_of_a_history_keeps_its_identities() { let mut collection = collection(); + collection.sources.insert("blue".into(), color([0, 0, 255, 255])); let mut history = History::new(); let ids = |collection: &Collection| -> Vec { collection.scenes[0].items.iter().map(|item| item.id).collect() @@ -2044,7 +2033,7 @@ mod tests { let items = &collection.scenes[0].items; let at = next(items.len()); let mut draft = collection.draft("Edit"); - match next(4) { + match next(6) { // A copy, alike but another. 0 => { let copy = Item { @@ -2060,6 +2049,22 @@ mod tests { let to = next(items.len()); draft.move_item(&main(), at, to).unwrap(); } + // Two swapped by replacing each with the other, changed, as a + // drop into a slot does. + 3 => { + let other = next(items.len()); + let (mut one, mut two) = (items[other].clone(), items[at].clone()); + one.rect.y = next(4) as f32; + two.rect.y = next(4) as f32; + draft.set_item(&main(), at, one).unwrap(); + draft.set_item(&main(), other, two).unwrap(); + } + // Another source, as making a layer's copy its own does. + 4 => { + let mut item = items[at].clone(); + item.source = if item.source == "red" { "blue" } else { "red" }.into(); + draft.set_item(&main(), at, item).unwrap(); + } _ => { let mut item = items[at].clone(); item.rect.x = next(4) as f32; From b9833aa54ac2a37847f94f3019dd8b50a681cce4 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Thu, 19 Nov 2026 06:10:55 -0800 Subject: [PATCH 5/8] fix(scene): align a loaded history past a swap Co-Authored-By: Claude Opus 5.5 --- rs/moq-scene/src/edit.rs | 51 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 51 insertions(+) diff --git a/rs/moq-scene/src/edit.rs b/rs/moq-scene/src/edit.rs index 3119d002..d8b6959f 100644 --- a/rs/moq-scene/src/edit.rs +++ b/rs/moq-scene/src/edit.rs @@ -1388,6 +1388,9 @@ fn aligned(state: &mut Collection, edit: &Edit, renames: &mut HashMap) - let held = change.held(state); let (befores, afters) = change.sides_mut(); for (item, id) in befores.into_iter().zip(held) { + // An item an earlier change put in place under the file's + // identity, before a later one named it, is the item named. + let id = renames.get(&id).copied().unwrap_or(id); let named = *renames.entry(item.id).or_insert(id); if named != id { return Err(conflict(format!("`{}` is two items", item.source))); @@ -2145,6 +2148,54 @@ mod tests { assert_eq!(ids(&reloaded), [red, blue], "red back"); } + /// Aligning past a swap, whose first replacement puts an item in place + /// before the second names it, goes on to the edits before it. + #[test] + fn a_loaded_history_aligns_past_a_swap() { + let mut collection = collection(); + collection.sources.insert("blue".into(), color([0, 0, 255, 255])); + let fill = Rect::fill(&collection.canvas); + let items = &mut collection.scenes[0].items; + items.push(Item::new("blue", fill)); + items.push(Item::new("red", Rect { x: 1.0, ..fill })); + let mut history = History::new(); + let set = |collection: &mut Collection, history: &mut History, at: usize, x: f32| { + let mut draft = collection.draft("Edit"); + let mut item = collection.scenes[0].items[at].clone(); + item.rect.y = x; + draft.set_item(&main(), at, item).unwrap(); + commit(collection, history, draft, None); + }; + set(&mut collection, &mut history, 2, 5.0); + set(&mut collection, &mut history, 1, 5.0); + let mut draft = collection.draft("Swap"); + let items = &collection.scenes[0].items; + let (one, two) = (items[0].clone(), items[1].clone()); + draft.set_item(&main(), 0, Item { rect: one.rect, ..two }).unwrap(); + draft + .set_item( + &main(), + 1, + Item { + rect: Rect { y: 9.0, ..one.rect }, + ..one + }, + ) + .unwrap(); + commit(&mut collection, &mut history, draft, None); + + let mut reloaded = Collection::from_toml(&collection.to_toml().unwrap()).unwrap(); + let (mut loaded, _) = History::from_toml(&history.to_toml().unwrap(), &reloaded).unwrap(); + let third = reloaded.scenes[0].items[2].id; + for _ in 0..3 { + loaded.undo(&mut reloaded).unwrap(); + } + assert_eq!( + reloaded.scenes[0].items[2].id, third, + "the first edit undone keeps its item" + ); + } + /// A history reloaded unchanged takes the identities of the items it /// held before that no layer shows, so an undo of a removal after a /// reload brings back the same item. From 72583e826c410064cb4b09a78f7bec5dcdb6485f Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Thu, 19 Nov 2026 06:15:18 -0800 Subject: [PATCH 6/8] test(studio): give copied scenes' layers fresh identities Co-Authored-By: Claude Opus 5.5 --- rs/moq-studio/src/engine.rs | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/rs/moq-studio/src/engine.rs b/rs/moq-studio/src/engine.rs index f7fcc943..2d4117da 100644 --- a/rs/moq-studio/src/engine.rs +++ b/rs/moq-studio/src/engine.rs @@ -3810,6 +3810,9 @@ mod tests { loaded.collection.published.insert("red".into()); let mut two = loaded.collection.scenes[0].clone(); two.name = "Two".into(); + for item in &mut two.items { + item.id = moq_scene::Id::fresh(); + } loaded.collection.scenes.push(two); let (relay, _routes, _) = test_relay().await; let engine = start(gpu, vec![relay], dir.path(), autosave, loaded) @@ -4901,6 +4904,9 @@ mod tests { collection.audio_scenes[0].sounds.insert("tone".into()); let mut published = collection.scenes[0].clone(); published.name = moq_scene::PORTRAIT.into(); + for item in &mut published.items { + item.id = moq_scene::Id::fresh(); + } published.published = true; collection.scenes.push(published); let engine = start(gpu, relays, dir.path(), autosave, loaded) From 2f1ba12d95457664355239cdda7d76182f1a1e7f Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Thu, 19 Nov 2026 07:29:36 -0800 Subject: [PATCH 7/8] fix(studio): the watch window forgets a dropped picture's placer Its compositor parked the placer of a picture keeping clear that a layout dropped and never freed it, since only the engine called remember. Each new layout now remembers only the items it shows. Co-Authored-By: Claude Opus 5.5 --- justfile | 2 +- rs/moq-studio/src/watch.rs | 59 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 60 insertions(+), 1 deletion(-) diff --git a/justfile b/justfile index d6e4d77d..0fe2136e 100644 --- a/justfile +++ b/justfile @@ -59,7 +59,7 @@ render-sw: icd=("$mesa"/share/vulkan/icd.d/lvp_icd.*.json) export VK_DRIVER_FILES="${icd[0]}" cargo nextest run --locked -p moq-scene --lib --run-ignored only -E 'test(/^compositor::tests::/) | test(/^dark::tests::/) | test(/^browser::layers::tests::/)' - cargo nextest run --locked -p moq-studio --features openh264 --run-ignored only -E '(test(/^engine::tests::/) - test(=engine::tests::the_virtual_camera_reaches_a_pipewire_app)) | test(=setup::tests::times_every_canvas)' + cargo nextest run --locked -p moq-studio --features openh264 --run-ignored only -E '(test(/^engine::tests::/) - test(=engine::tests::the_virtual_camera_reaches_a_pipewire_app)) | test(/^watch::tests::/) | test(=setup::tests::times_every_canvas)' cargo nextest run --locked -p moq-studio --features cef --run-ignored only -E 'binary(browser)' sh/pipewire-session.sh cargo nextest run --locked -p moq-studio --features pipewire --run-ignored only -E 'test(=engine::tests::the_virtual_camera_reaches_a_pipewire_app)' diff --git a/rs/moq-studio/src/watch.rs b/rs/moq-studio/src/watch.rs index 8269a483..1513b1f1 100644 --- a/rs/moq-studio/src/watch.rs +++ b/rs/moq-studio/src/watch.rs @@ -414,6 +414,10 @@ impl Watch { // slot glides on from where it was. collection.recognize(&self.collection); self.collection = collection; + // No undo here brings a picture back: one the layout dropped is + // gone, so its parked placer is too. + let shown = self.collection.layers().flat_map(|(_, items)| items); + self.compositor.remember(shown.map(|item| item.id)); for driver in self.sources.sync(&self.collection) { engine::spawn(driver); } @@ -630,6 +634,61 @@ mod tests { reader.abort(); } + /// The placer of a picture keeping clear that a layout dropped is + /// forgotten once the next layout comes, since nothing can bring that + /// picture back. + #[tokio::test(flavor = "multi_thread")] + #[ignore = "needs a Vulkan device; run by just render-sw"] + async fn a_dropped_picture_forgets_its_placer() { + let gpu = Gpu::new(wgpu::Backends::all()).await.expect("a GPU"); + let (bus, driver) = moq_audio::bus::Bus::new(Default::default()).unwrap(); + let (_mixer, mixed) = source::Mixer::new(driver, Instant::now()); + let origin = moq_tokio::origin::spawn(); + let sources = Sources::new(source::Context { + bus, + mixed, + origin: origin.consume(), + dir: ".".into(), + output: moq_video::render::output(&gpu.device), + publish: None, + grants: None, + browser: None, + }); + let collection = collection(None, CANVAS).unwrap(); + let (read, _) = watch::channel(Read::default()); + let mut watch = Watch { + url: String::new(), + read, + compositor: Compositor::new(&gpu.device, &gpu.queue, collection.canvas).unwrap(), + collection, + synced: false, + layout: None, + size: None, + sources, + monitor: None, + shown: None, + }; + let show = |watch: &mut Watch, layout: Option| { + watch.read.send_modify(|read| read.push(layout, None)); + watch.render(Instant::now()).unwrap(); + }; + + let mut keeping = layout(Duration::ZERO); + keeping.pictures.truncate(1); + keeping.pictures[0].item.keep_clear = Some(moq_scene::KeepClear::default()); + show(&mut watch, Some(keeping.clone())); + let item = &watch.collection.scene(SCENE).unwrap().items[1]; + let (id, rect) = (item.id, item.rect); + assert!(watch.compositor.placement(id).is_some(), "it keeps clear"); + + // Dropped, its placer is parked, then forgotten at the next layout. + show(&mut watch, None); + show(&mut watch, Some(keeping)); + assert_ne!(watch.collection.scene(SCENE).unwrap().items[1].id, id, "a new picture"); + watch.compositor.undone(id, rect, Instant::now()); + assert!(watch.compositor.placement(id).is_none(), "the placer is forgotten"); + } + /// A layout of another version, as a newer studio would publish. #[derive(serde::Serialize)] struct Newer { From e5b1905c741749da3585f80686e2f63d402d4f73 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Thu, 19 Nov 2026 20:21:43 -0800 Subject: [PATCH 8/8] fix(scene): a reflow keys its slots by identity, so duplicates swapping places glide Co-Authored-By: Claude Opus 5.5 --- rs/moq-scene/src/compositor.rs | 45 +++++++++++++++++++++++++++++++--- 1 file changed, 41 insertions(+), 4 deletions(-) diff --git a/rs/moq-scene/src/compositor.rs b/rs/moq-scene/src/compositor.rs index 697d7efd..5aff7cda 100644 --- a/rs/moq-scene/src/compositor.rs +++ b/rs/moq-scene/src/compositor.rs @@ -215,7 +215,7 @@ struct Reflow { /// Its items where its arrangement puts them, in order. arranged: Vec, /// Its items as drawn, gliding to `arranged` when a slot opens or closes. - glide: Glide>, + glide: Glide>, } /// The program and the scenes a transition draws whole on its way, as of the @@ -2078,11 +2078,12 @@ fn reflow<'a>( // dragged follows the pointer. glide: Glide::new(REFLOW, |item| item.slot.is_some()), }); - // Only the slots start a glide: what each shows, whether it is - // open, and where. + // Only the slots start a glide: which item each holds, what it + // shows, whether it is open, and where, so two showing one source + // that swap places glide too. let slotted = arranged.iter().filter(|item| item.slot.is_some()); let key = slotted - .map(|item| (item.source.clone(), item.visible, item.rect)) + .map(|item| (item.id, item.source.clone(), item.visible, item.rect)) .collect(); placed.push((index, reflow.glide.show(key, &arranged, now).to_vec())); reflow.arranged = arranged; @@ -4524,6 +4525,42 @@ mod tests { .await; } + /// Two tiles showing one source that swap places each glide from where + /// it was, though the slots show the same source where they did. + #[tokio::test] + #[ignore = "needs a Vulkan device; run by just render-sw"] + async fn duplicate_tiles_swapping_places_glide() { + local(async { + let mut collection = slotted(); + collection.scenes[0].items[2].source = "blue".into(); + collection.validate().unwrap(); + let mut studio = Studio::new(collection).await; + let start = Instant::now(); + studio.render(start); + let before = studio.compositor.arranged(Format::Landscape, "slots").unwrap().to_vec(); + assert_ne!(before[1].rect, before[2].rect, "the tiles are apart"); + + studio.collection.scenes[0].items.swap(1, 2); + studio.render(start); + studio.render(start.saturating_add(REFLOW / 2)); + let placed = studio.compositor.placed(Format::Landscape, "slots").unwrap().to_vec(); + let halfway = |from: f32, to: f32| (from + to) / 2.0; + for (was, now) in [(&before[1], &before[2]), (&before[2], &before[1])] { + let item = placed + .iter() + .find(|item| item.id == was.id) + .expect("each tile is drawn"); + let (x, y) = (halfway(was.rect.x, now.rect.x), halfway(was.rect.y, now.rect.y)); + assert!( + (item.rect.x - x).abs() < 0.01 && (item.rect.y - y).abs() < 0.01, + "each tile is halfway from where it was: {:?}, not ({x}, {y})", + item.rect + ); + } + }) + .await; + } + /// Two slotted scenes swapping names each keep where their slots were, /// so neither glides from the other's arrangement. #[tokio::test]