From ded721f62e661bb7d53e99c01fb71bf7900e8178 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Mon, 16 Nov 2026 19:20:26 -0800 Subject: [PATCH 01/25] chore(quest): claim quest/m1/auto-place.md Quest-Claim: 9aca337475494867 From 850cb08d506be70dc667b4b332ea8e76016038a1 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Mon, 16 Nov 2026 20:21:09 -0800 Subject: [PATCH 02/25] feat: a layer that keeps out of the way Co-Authored-By: Claude Opus 5.5 --- rs/moq-scene/src/collection.rs | 131 ++++ rs/moq-scene/src/compositor.rs | 228 +++++- rs/moq-scene/src/lib.rs | 5 +- rs/moq-scene/src/place.rs | 1180 +++++++++++++++++++++++++++++ rs/moq-scene/src/place.wgsl | 76 ++ rs/moq-studio/shots/keep.toml | 73 ++ rs/moq-studio/src/shots.rs | 31 + rs/moq-studio/src/ui.rs | 3 +- rs/moq-studio/src/ui/build.rs | 46 +- rs/moq-studio/src/ui/inspector.rs | 29 +- rs/moq-studio/src/ui/keep.rs | 509 +++++++++++++ 11 files changed, 2295 insertions(+), 16 deletions(-) create mode 100644 rs/moq-scene/src/place.rs create mode 100644 rs/moq-scene/src/place.wgsl create mode 100644 rs/moq-studio/shots/keep.toml create mode 100644 rs/moq-studio/src/ui/keep.rs diff --git a/rs/moq-scene/src/collection.rs b/rs/moq-scene/src/collection.rs index 7f8b9eff..18233850 100644 --- a/rs/moq-scene/src/collection.rs +++ b/rs/moq-scene/src/collection.rs @@ -451,7 +451,21 @@ impl Collection { .validate() .map_err(|err| Error::Invalid(format!("{on}: {err}")))?; self.validate_chain(&item.filters, &on)?; + if let Some(keep) = &item.keep_clear + && keep.glide > KeepClear::LONGEST + { + return Err(Error::Invalid(format!( + "{on} glides for {:?} to keep clear, longer than the {:?} a glide may take", + keep.glide, + KeepClear::LONGEST + ))); + } if layer.scene.is_none() { + if item.keep_clear.is_some() { + return Err(Error::Invalid(format!( + "{on} keeps clear, but only a scene's item has a picture under it to keep clear of" + ))); + } if !item.keyframes.is_empty() { return Err(Error::Invalid(format!( "{on} has keyframes, but an always-on-top layer never goes on to start them" @@ -1124,6 +1138,12 @@ pub struct Item { /// layer never goes on. #[serde(default, skip_serializing_if = "Vec::is_empty")] pub keyframes: Vec, + /// Whether it moves itself off what matters in the picture under it, and + /// what that is. Its rect gives its size, and where it rests until it + /// first moves; the [`Compositor`](crate::Compositor) chooses where it + /// is drawn. Only a scene's item keeps clear. + #[serde(default, skip_serializing_if = "Option::is_none")] + pub keep_clear: Option, } impl Item { @@ -1139,6 +1159,7 @@ impl Item { filters: Vec::new(), blend: Blend::Normal, keyframes: Vec::new(), + keep_clear: None, } } @@ -1166,6 +1187,7 @@ impl Item { filters, blend: self.blend, keyframes: Vec::new(), + keep_clear: self.keep_clear, }) } @@ -1194,6 +1216,61 @@ impl Item { } } +/// What an item keeping out of the way stays clear of in the picture under +/// it, and how it moves. +/// +/// It chooses among the corners and edge middles of the canvas, inside a +/// margin, and moves when the content under it changes, or when its place +/// has been the worst of them for a while, never for a single busy moment. +/// A move by hand holds until the content changes. The choice is made on +/// this machine from the picture alone. +#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)] +#[serde(deny_unknown_fields)] +pub struct KeepClear { + /// Whether it stays clear of where the picture moves. + #[serde(default = "yes", skip_serializing_if = "is_true")] + pub motion: bool, + /// Whether it stays clear of text and other dense detail. + #[serde(default = "yes", skip_serializing_if = "is_true")] + pub text: bool, + /// Whether it stays clear of what holds still while the rest moves, such + /// as a game's HUD or minimap. + #[serde(default = "yes", skip_serializing_if = "is_true")] + pub hud: bool, + /// How long it takes to glide to a new place. + #[serde( + default = "KeepClear::default_glide", + with = "humantime_serde", + skip_serializing_if = "KeepClear::is_default_glide" + )] + pub glide: Duration, +} + +impl KeepClear { + /// The longest glide, so a typo cannot park an item mid-canvas for minutes. + pub const LONGEST: Duration = Duration::from_secs(5); + + fn default_glide() -> Duration { + Duration::from_millis(400) + } + + fn is_default_glide(glide: &Duration) -> bool { + *glide == Self::default_glide() + } +} + +impl Default for KeepClear { + /// Clear of everything it can see, gliding for 0.4 s. + fn default() -> Self { + Self { + motion: true, + text: true, + hud: true, + glide: Self::default_glide(), + } + } +} + /// Where a moment falls among an item's keyframes: holding the first, between /// two at that moment, or holding the last. Keyframes at the same moment jump, /// so the first keyframe's moment is not the same as before it. @@ -3108,6 +3185,60 @@ background = "remove" assert_eq!(filters(500), Filter::Invert { amount: 1.0 }); } + /// An item keeps clear with `keep_clear = {}`, of everything it can see, + /// writing only what differs from that. + #[test] + fn reads_and_writes_keep_clear() { + let text = r#" +version = 1 + +[canvas] +width = 1920 +height = 1080 +framerate = 30 + +[sources.camera] +kind = "camera" + +[[scenes]] +name = "Game" +items = [ + { source = "camera", rect = { x = 0, y = 0, width = 320, height = 180 }, keep_clear = {} }, + { source = "camera", rect = { x = 0, y = 0, width = 320, height = 180 }, keep_clear = { hud = false, glide = "1s" } }, +] +"#; + let collection = Collection::from_toml(text).unwrap(); + let items = &collection.scenes[0].items; + assert_eq!(items[0].keep_clear, Some(KeepClear::default())); + let partly = KeepClear { + hud: false, + glide: Duration::from_secs(1), + ..KeepClear::default() + }; + assert_eq!(items[1].keep_clear, Some(partly)); + let saved = collection.to_toml().unwrap(); + assert!( + saved.contains("[scenes.items.keep_clear]\nhud = false\nglide = \"1s\"\n"), + "{saved}" + ); + assert_eq!(Collection::from_toml(&saved).unwrap(), collection); + } + + #[test] + fn refuses_keeping_clear_with_nothing_under_it_or_too_slowly() { + let mut collection = example(); + collection.scenes[0].items[1].keep_clear = Some(KeepClear::default()); + collection.validate().unwrap(); + collection.scenes[0].items[1].keep_clear = Some(KeepClear { + glide: Duration::from_secs(6), + ..KeepClear::default() + }); + assert!(matches!(collection.validate(), Err(Error::Invalid(_))), "a glide too long"); + collection.scenes[0].items[1].keep_clear = None; + collection.top[0].keep_clear = Some(KeepClear::default()); + assert!(matches!(collection.validate(), Err(Error::Invalid(_))), "the top layer"); + } + #[test] fn refuses_keyframes_it_cannot_play() { let at = |millis| Keyframe::new(Duration::from_millis(millis)); diff --git a/rs/moq-scene/src/compositor.rs b/rs/moq-scene/src/compositor.rs index ebb2b473..0c76e367 100644 --- a/rs/moq-scene/src/compositor.rs +++ b/rs/moq-scene/src/compositor.rs @@ -17,6 +17,7 @@ use crate::collection::{ use crate::effect::{self, Effects, Frame, Lut, Picture, Prepared}; use crate::matte::Matte; use crate::overlay::{Overlay, Overlays}; +use crate::place::{Look, Placement, Placer, Reducer}; use crate::source::{self, Feed, Sources, Status}; /// The format of every canvas texture: gamma-encoded RGBA, what @@ -110,6 +111,19 @@ pub struct Compositor { /// Whether the last render drew layers over the program. layered: bool, switch: Option, + /// Each scene item keeping clear, by its scene and place in it. + keepers: HashMap<(String, usize), Keeper>, + /// Reduces the pictures under them, made with the first. + reducer: Option, +} + +/// 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, + placer: Placer, + look: Look, } /// The program and the scenes a transition draws whole on its way, as of the @@ -248,11 +262,11 @@ impl Switch { /// A texture drawn into at a canvas's coordinates, and bound to sample: /// canvas-sized, or smaller for a thumbnail. #[derive(Clone)] -struct Target { +pub(crate) struct Target { /// The canvas drawn, at the program's frame rate. - canvas: Canvas, - texture: wgpu::Texture, - picture: Picture, + pub canvas: Canvas, + pub texture: wgpu::Texture, + pub picture: Picture, } /// One source's newest picture or table on the GPU. @@ -397,6 +411,8 @@ impl Compositor { program_shown: Duration::ZERO, layered: false, switch: None, + keepers: HashMap::new(), + reducer: None, }) } @@ -480,6 +496,15 @@ 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()) + } + /// Keep the scenes `outputs` names as outputs from now on, each with /// whether the next [`render`](Self::render) draws it, as it does while an /// output reads it. Each plays its keyframes from the first render after @@ -786,6 +811,9 @@ impl Compositor { } self.renders += 1; self.update(collection, sources, now); + // Every draw below reads the items keeping clear where they are placed. + let staged = self.place(collection, now); + let collection = &*staged; self.restart(collection, preview_start, program_start); self.paint(collection, now); let thumbnails = self.thumbnail_targets(collection, now); @@ -951,12 +979,93 @@ impl Compositor { Shows::Nothing => unreachable!("a thumbnail showing nothing is not drawn"), } } + + // The picture under each item keeping clear, read a few times a + // second while its scene is drawn: on program, in preview, for an + // output, or through a scene source. + let mut drawn: HashMap<&str, Duration> = HashMap::new(); + let roots = on_program(program, switch) + .into_iter() + .chain(previewing.then_some(preview)) + .chain(outputs.iter().map(|(on, _)| *on)); + for On(scene, since) in roots { + if let Some(scene) = scene { + drawn.entry(scene).or_insert(since); + } + } + for nest in &nesting.order { + drawn.entry(nest.scene).or_insert(nest.since); + } + let mut reads = Vec::new(); + for ((scene, index), keeper) in &mut self.keepers { + let Some(&since) = drawn.get(scene.as_str()) else { + continue; + }; + keeper.placer.shown(since, now); + let item = collection.scene(scene).and_then(|shown| shown.items.get(*index)); + if !item.is_some_and(|item| item.visible) || !keeper.look.due(now) { + continue; + } + let canvas = canvas_of(Some(scene)); + let target = keeper.look.target(draw.effects, canvas); + draw.size = canvas; + draw.target(&target); + draw.under(&target, Place::scene(scene.as_str()), *index, since); + reads.push((scene.clone(), *index)); + } self.previewed = previewing; 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"); + keeper.look.start(reducer, now); + } + } Ok(()) } + /// `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 is gone is forgotten. + fn place<'a>(&mut self, collection: &'a Collection, now: Instant) -> Cow<'a, Collection> { + let mut staged = Cow::Borrowed(collection); + let mut keepers = HashMap::new(); + for (number, scene) in collection.scenes.iter().enumerate() { + let canvas = scene.canvas(collection.canvas); + for (index, item) in scene.items.iter().enumerate() { + let Some(keep) = &item.keep_clear else { continue }; + let key = (scene.name.clone(), index); + let mut keeper = match self.keepers.remove(&key) { + Some(keeper) if keeper.source == item.source => keeper, + _ => Keeper { + source: item.source.clone(), + placer: Placer::new(now), + look: Look::new(&self.device, &self.queue), + }, + }; + match keeper.look.finish() { + Some(Ok((tiles, at))) => keeper.placer.see(&tiles, at), + Some(Err(err)) => tracing::warn!( + scene = %scene.name, + source = %item.source, + %err, + "cannot read the picture under an item keeping clear" + ), + None => {} + } + let rect = keeper.placer.place(item.rect, keep, canvas, now); + if rect != item.rect { + staged.to_mut().scenes[number].items[index].rect = rect; + } + keepers.insert(key, keeper); + } + } + self.keepers = keepers; + staged + } + /// Pull the newest picture from every source onto the GPU, and forget the /// sources the collection no longer has or has since edited. An overlay /// that arrives now starts its CSS timeline at `now`. @@ -1845,8 +1954,15 @@ impl Draw<'_> { /// item, a source with no picture yet, or a filter whose source has nothing /// yet draws nothing. fn layer(&mut self, target: &Target, place: Place, since: Duration) { + self.under(target, place, usize::MAX, since); + } + + /// Draw `place`'s items under its `index`th onto `target`, as + /// [`layer`](Self::layer) draws them: what that item covers. + fn under(&mut self, target: &Target, place: Place, index: usize, since: Duration) { let items = self.collection.items(&place).unwrap_or_default(); - for (index, item) in items.iter().enumerate().filter(|(_, item)| item.visible) { + let under = items.iter().enumerate().take(index); + for (index, item) in under.filter(|(_, item)| item.visible) { let key = (place.clone(), index, self.settled(item, since)); self.item(target, key, &item.posed(since), since); } @@ -2180,7 +2296,7 @@ impl Target { } /// A target drawing `canvas` into `size` pixels, labeled `label`. - fn sized(device: &wgpu::Device, effects: &Effects, canvas: Canvas, size: (u32, u32), label: &str) -> Self { + pub fn sized(device: &wgpu::Device, effects: &Effects, canvas: Canvas, size: (u32, u32), label: &str) -> Self { let texture = device.create_texture(&wgpu::TextureDescriptor { label: Some(label), size: wgpu::Extent3d { @@ -2402,6 +2518,106 @@ mod tests { actual.iter().zip(expected).all(|(a, e)| a.abs_diff(e) <= 1) } + /// A 320x180 scene "busy" with a camera keeping clear over the bottom + /// right, where a block moves: a checkerboard in the top right and lines + /// of "text" in the bottom left, on black. + fn busy() -> Collection { + let mut collection = Collection::new(); + collection.canvas = Canvas { + width: 320, + height: 180, + framerate: 30, + }; + for (name, color) in [("black", BLACK), ("white", [255; 4]), ("camera", BLUE)] { + let color = Rgba(color); + collection.sources.insert(name.into(), Source::Color { color }); + } + let rect = |x, y, width, height| Rect { x, y, width, height }; + let mut items = vec![Item::new("black", Rect::fill(&collection.canvas))]; + for row in 0..9 { + for column in (row % 2..10).step_by(2) { + let at = rect(232.0 + 8.0 * column as f32, 4.0 + 8.0 * row as f32, 8.0, 8.0); + items.push(Item::new("white", at)); + } + } + for line in 0..13 { + items.push(Item::new("white", rect(8.0, 130.0 + 3.0 * line as f32, 100.0, 1.0))); + } + items.push(Item::new("white", rect(250.0, 120.0, 40.0, 40.0))); + items.push(Item { + keep_clear: Some(crate::KeepClear::default()), + ..Item::new("camera", rect(247.0, 107.0, 64.0, 64.0)) + }); + collection.scenes = vec![Scene { + items, + ..Scene::new("busy") + }]; + collection.validate().unwrap(); + collection + } + + /// The compositor reads the picture under a camera keeping clear on the + /// GPU, sees the block moving under it, and glides it to the corner that + /// covers nothing, on program and in preview alike. + #[tokio::test] + #[ignore = "needs a Vulkan device; run by just render-sw"] + async fn a_camera_keeping_clear_glides_off_what_moves() { + local(async { + let mut studio = Studio::new(busy()).await; + 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 block = camera - 1; + let saved = studio.collection.scenes[0].items[camera].rect; + let start = Instant::now(); + let mut now = start; + let mut moved = None; + 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(); + let placement = studio.compositor.placement("busy", camera, "camera").unwrap(); + if placement.slot.is_some() { + moved = Some(now); + break; + } + assert_eq!(placement.rect, saved, "it stays put while it looks"); + now = now.saturating_add(Duration::from_millis(100)); + } + let moved = moved.expect("it chose a slot"); + assert!( + moved.saturating_duration_since(start) >= crate::place::SETTLE, + "it looks before it moves" + ); + let placement = studio.compositor.placement("busy", camera, "camera").unwrap().clone(); + assert_eq!(placement.slot, Some(crate::place::Slot::TopLeft)); + let left = placement.left.unwrap(); + assert_eq!(left.rect, saved); + assert_eq!(left.over, Some(crate::place::Signal::Motion)); + let heat = &placement.heat; + let (column, row) = (heat.columns - 2, 1); + let (matters, signal) = heat.tiles[row * heat.columns + column]; + assert!(matters > 0.5, "the checkerboard matters: {matters}"); + assert_eq!(signal, crate::place::Signal::Text, "still edges in a still picture"); + assert_eq!(heat.tiles[heat.columns * 4 + 4].0, 0.0, "black does not"); + + let glide = crate::KeepClear::default().glide; + studio.render(moved.saturating_add(glide / 2)); + let half = studio.compositor.placement("busy", camera, "camera").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); + 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"); + assert_eq!(program, studio.preview(), "the preview shows it alike"); + }) + .await; + } + /// A source published independently is left out of the program and drawn /// over it as its layer, as it is over the scene in preview, wherever its /// scene stacks it; without one showing, the layered program is the diff --git a/rs/moq-scene/src/lib.rs b/rs/moq-scene/src/lib.rs index c7610ac4..0b785b79 100644 --- a/rs/moq-scene/src/lib.rs +++ b/rs/moq-scene/src/lib.rs @@ -54,6 +54,7 @@ mod lut; mod matte; mod media; mod overlay; +pub mod place; mod playout; pub mod publish; pub mod replay; @@ -62,8 +63,8 @@ pub mod source; pub use clip::Clip; pub use collection::{ - Audio, AudioScene, Background, Blend, Canvas, Collection, Crop, Direction, Ease, Filter, Item, Keyframe, Layer, - MaskMode, Nested, Rect, Rgba, Scene, Shape, Size, Source, Transition, Video, + Audio, AudioScene, Background, Blend, Canvas, Collection, Crop, Direction, Ease, Filter, Item, KeepClear, Keyframe, + Layer, MaskMode, Nested, Rect, Rgba, Scene, Shape, Size, Source, Transition, Video, }; pub use compositor::{Compositor, FORMAT, Output, Thumbnail}; pub use edit::{Change, Draft, Edit, History}; diff --git a/rs/moq-scene/src/place.rs b/rs/moq-scene/src/place.rs new file mode 100644 index 00000000..07f56e1a --- /dev/null +++ b/rs/moq-scene/src/place.rs @@ -0,0 +1,1180 @@ +//! Where an item that keeps out of the way goes. +//! +//! A few times a second, the compositor draws the picture under the item, +//! scaled far down, and a compute shader reduces it, with the read before, to +//! a grid of tiles: how much of each moved, how much of it is edges, as text +//! and a HUD are, and how much of those held still. Only the grid comes back, +//! a frame or so later. A [`Placer`] weighs it into what matters where, and +//! keeps the item in the [`Slot`] that covers the least of it: it chooses +//! when its scene goes on and when the content under it changes, and moves +//! otherwise only once its place has been the worst for a while, gliding +//! there. A move by hand holds until the content changes. + +use std::sync::{Arc, Mutex}; +use std::time::Duration; + +use kio::clock::Instant; + +use crate::collection::{Canvas, Ease, KeepClear, Rect, mix}; +use crate::compositor::Target; +use crate::effect::Effects; + +/// How often the picture under an item is read, at most. +pub const INTERVAL: Duration = Duration::from_millis(250); + +/// The longest side of the picture read, in pixels: text a 1080p canvas +/// shows at a readable size still has edges at this size. +const SIDE: u32 = 512; + +/// A tile's side in pixels of the picture read, as `place.wgsl`'s workgroup. +const TILE: u32 = 16; + +/// The bytes of the largest grid, four a tile. +const BYTES: u64 = ((SIDE / TILE) * (SIDE / TILE) * 4) as u64; + +/// How long what matters lingers once it stops, so one busy moment is never +/// a reason to move. +const LINGER: Duration = Duration::from_secs(2); + +/// How long the layout of the picture is averaged over to tell a new kind of +/// content from the one before, which is averaged over [`USUAL`]. +const RECENT: Duration = Duration::from_millis(500); + +/// How long the layout the content usually has is averaged over. +const USUAL: Duration = Duration::from_secs(6); + +/// How far apart the recent and usual layouts get, per tile on average out of +/// 1 for its brightness and its edges, once the content changed kind. +const APART: f32 = 0.12; + +/// How long the layouts stay [`APART`] before the content counts as changed: +/// a flash or a fast pan passes sooner. +const CHANGING: Duration = Duration::from_secs(1); + +/// How long an item looks, once its scene goes on or the content under it +/// changes, before it chooses: long enough to see what moves. +pub const SETTLE: Duration = Duration::from_secs(1); + +/// How long its place must be the worst before it moves without the content +/// changing. +pub const WORST: Duration = Duration::from_secs(10); + +/// How much less a place must matter than where the item is for it to move, +/// on a tile's 0 to 1 scale, so it never wavers between two alike. +const BETTER: f32 = 0.1; + +/// How close two places' costs are to count as alike, past the rounding of +/// summing them tile by tile. +const ALIKE: f32 = 1e-4; + +/// What a slot along an edge's middle costs over a corner covering as much: +/// the middle of an edge is where captions and the game's own bars go. +const MIDDLE: f32 = 0.05; + +/// How much each signal weighs at full strength: a HUD that holds still is +/// what viewers look for, and motion is everywhere in a game. +const WEIGHT: [f32; 3] = [0.5, 0.8, 1.0]; + +/// A place along the canvas's edges an item can keep to. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] +pub enum Slot { + TopLeft, + Top, + TopRight, + Left, + Right, + BottomLeft, + Bottom, + BottomRight, +} + +impl Slot { + /// Every slot, corners first. + pub const ALL: [Self; 8] = [ + Self::TopLeft, + Self::TopRight, + Self::BottomLeft, + Self::BottomRight, + Self::Top, + Self::Left, + Self::Right, + Self::Bottom, + ]; + + /// Whether it is a corner, which a middle slot yields to when both cover + /// as much. + pub fn corner(self) -> bool { + matches!( + self, + Self::TopLeft | Self::TopRight | Self::BottomLeft | Self::BottomRight + ) + } + + /// Its column and row in a 3x3 grid over the canvas, from the top left. + pub fn cell(self) -> (u8, u8) { + match self { + Self::TopLeft => (0, 0), + Self::Top => (1, 0), + Self::TopRight => (2, 0), + Self::Left => (0, 1), + Self::Right => (2, 1), + Self::BottomLeft => (0, 2), + Self::Bottom => (1, 2), + Self::BottomRight => (2, 2), + } + } + + /// Where an item `width` by `height` sits in it on `canvas`, inside the + /// [`margin`], or `None` if it does not fit there. + pub fn rect(self, width: f32, height: f32, canvas: Canvas) -> Option { + let margin = margin(canvas); + let along = |cell: u8, length: f32, size: f32| match cell { + 0 => margin, + 1 => ((length - size) / 2.0).round(), + _ => length - margin - size, + }; + let (w, h) = (canvas.width as f32, canvas.height as f32); + let fits = width > 0.0 && height > 0.0 && width + 2.0 * margin <= w && height + 2.0 * margin <= h; + let (column, row) = self.cell(); + fits.then(|| Rect { + x: along(column, w, width), + y: along(row, h, height), + width, + height, + }) + } +} + +/// How far in from the canvas's edges a slot keeps, in pixels: a twentieth +/// of its shorter side. +pub fn margin(canvas: Canvas) -> f32 { + (canvas.width.min(canvas.height) as f32 / 20.0).round() +} + +/// What makes part of a picture matter. +#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)] +pub enum Signal { + /// It moves. + Motion, + /// It is dense with edges that hold still, as text is. + Text, + /// It holds still while the rest moves, as a game's HUD or minimap does. + Hud, +} + +impl Signal { + const ALL: [Self; 3] = [Self::Motion, Self::Text, Self::Hud]; + + /// Whether `keep` stays clear of it. + fn kept(self, keep: &KeepClear) -> bool { + match self { + Self::Motion => keep.motion, + Self::Text => keep.text, + Self::Hud => keep.hud, + } + } +} + +/// What matters in the picture under an item, as a grid of tiles over its +/// canvas. +#[derive(Clone, Debug, Default, PartialEq)] +pub struct Heat { + /// Tiles across. + pub columns: usize, + /// Tiles down. + pub rows: usize, + /// Each tile, row by row: how much it matters, from 0 to 1, and the + /// signal it matters most for. + pub tiles: Vec<(f32, Signal)>, + /// Where each tile is on the canvas, as fractions of its width and height + /// at the tile edges: `columns + 1` across, then `rows + 1` down. + pub edges: (Vec, Vec), +} + +impl Heat { + /// The tile at `column`, `row` on the canvas, as fractions of its size. + pub fn tile(&self, column: usize, row: usize) -> (f32, f32, f32, f32) { + let (across, down) = &self.edges; + (across[column], down[row], across[column + 1], down[row + 1]) + } +} + +/// Where an item keeping clear is drawn, and why, as of the last render. +#[derive(Clone, Debug, PartialEq)] +pub struct Placement { + /// Where it is drawn, part way along a glide while one is under way. + pub rect: Rect, + /// The slot it is in or gliding to, or `None` while it stays where it + /// was put. + pub slot: Option, + /// Whether it stays where the streamer moved it, until the content under + /// it changes. + pub held: bool, + /// Where it last moved from, and what it left there. + pub left: Option, + /// The places it may go: each slot it fits in. + pub slots: Vec<(Slot, Rect)>, + /// What matters under it, once it has looked. + pub heat: Heat, +} + +/// Where an item moved from. +#[derive(Clone, Copy, Debug, PartialEq)] +pub struct Left { + /// Where it was. + pub rect: Rect, + /// What mattered most there, if anything did. + pub over: Option, +} + +/// One read of the picture under an item: each tile's share of pixels that +/// moved, that are edges, and that are edges that held still, and its +/// brightness, each out of 255. +#[derive(Clone, Debug, PartialEq)] +pub(crate) struct Tiles { + /// The picture's size in pixels, which the tiles cover [`TILE`] at a + /// time, those at the right and bottom only as far as it goes. + pub size: (u32, u32), + /// Whether there was a read before to compare with, without which + /// nothing moved. + pub compared: bool, + pub tiles: Vec<[u8; 4]>, +} + +impl Tiles { + const MOVED: usize = 0; + const EDGES: usize = 1; + const STILL: usize = 2; + const LIGHT: usize = 3; +} + +/// The fraction `amount` of the way to `full`, at most 1. +fn ramp(amount: f32, full: f32) -> f32 { + (amount / full).clamp(0.0, 1.0) +} + +/// How much of the way to a new value an average kept over `over` goes when +/// a value arrives `dt` after the last. +fn weight(dt: Duration, over: Duration) -> f32 { + 1.0 - (-dt.as_secs_f32() / over.as_secs_f32()).exp() +} + +/// What the reads of the picture under an item show over time. +#[derive(Default)] +struct Sight { + /// The picture size the reads are of; a read of another starts over. + size: (u32, u32), + /// Each tile's signals, lingering, in [`Signal::ALL`]'s order. + signals: Vec<[f32; 3]>, + /// Each tile's brightness and edges, recently and usually. + recent: Vec<[f32; 2]>, + usual: Vec<[f32; 2]>, + /// Since when the recent and usual layouts have been [`APART`]. + apart: Option, + /// When the last read was taken. + last: Option, + /// How many reads compared with the one before since it started over. + compared: u32, + /// Bumped with every read, so what is drawn from it is redrawn. + generation: u64, +} + +impl Sight { + /// Take in a read taken `at`, returning whether the content changed kind. + fn see(&mut self, read: &Tiles, at: Instant) -> bool { + self.generation += 1; + let count = read.tiles.len(); + if read.size != self.size || self.signals.len() != count { + *self = Self { + size: read.size, + generation: self.generation, + ..Self::default() + }; + } + let unit = |value: u8| f32::from(value) / 255.0; + let moving = match read.compared { + true => read.tiles.iter().map(|tile| unit(tile[Tiles::MOVED])).sum::() / count.max(1) as f32, + false => 0.0, + }; + // Edges that hold still are text, and a HUD while the rest moves; + // edges that move are motion. A first read, with nothing to compare, + // takes every edge for still. + let hud = ramp(moving - 0.03, 0.1); + let raw = read.tiles.iter().map(|tile| { + let (moved, still) = match read.compared { + true => (unit(tile[Tiles::MOVED]), unit(tile[Tiles::STILL])), + false => (0.0, unit(tile[Tiles::EDGES])), + }; + [ramp(moved, 0.3), ramp(still, 0.2), ramp(still, 0.15) * hud] + }); + let layout = read + .tiles + .iter() + .map(|tile| [unit(tile[Tiles::LIGHT]), unit(tile[Tiles::EDGES])]); + + let Some(last) = self.last.replace(at) else { + self.signals = raw.collect(); + self.recent = layout.collect(); + self.usual = self.recent.clone(); + self.compared = u32::from(read.compared); + return false; + }; + let dt = at.saturating_duration_since(last); + self.compared += u32::from(read.compared); + let linger = weight(dt, LINGER); + for (signals, raw) in self.signals.iter_mut().zip(raw) { + for (signal, raw) in signals.iter_mut().zip(raw) { + // A signal rises at once and lingers as it falls, so what + // matters counts from the first read that sees it. + *signal = if raw > *signal { raw } else { mix(*signal, raw, linger) }; + } + } + let (recent, usual) = (weight(dt, RECENT), weight(dt, USUAL)); + let mut distance = 0.0; + for ((now, usually), layout) in self.recent.iter_mut().zip(&mut self.usual).zip(layout) { + for channel in 0..2 { + now[channel] = mix(now[channel], layout[channel], recent); + usually[channel] = mix(usually[channel], layout[channel], usual); + distance += (now[channel] - usually[channel]).abs(); + } + } + distance /= count.max(1) as f32; + if distance < APART { + self.apart = None; + return false; + } + let apart = *self.apart.get_or_insert(at); + if at.saturating_duration_since(apart) < CHANGING { + return false; + } + // What it usually looks like is what it looks like now, and what + // mattered in the content before matters no more. + self.usual = self.recent.clone(); + self.signals = self.recent.iter().map(|_| [0.0; 3]).collect(); + self.apart = None; + self.compared = 0; + true + } + + /// Forget what was seen, as when the scene goes on again. + fn forget(&mut self) { + *self = Self { + generation: self.generation + 1, + ..Self::default() + }; + } + + /// How much each tile matters to an item keeping clear as `keep` says, + /// and for what most, or `None` before any read. + fn heat(&self, keep: &KeepClear) -> Option { + self.last?; + let tiles = self + .signals + .iter() + .map(|signals| { + let weighed = Signal::ALL.map(|signal| { + let index = signal as usize; + let weight = if signal.kept(keep) { WEIGHT[index] } else { 0.0 }; + (signals[index] * weight, signal) + }); + weighed + .into_iter() + .max_by(|a, b| a.0.total_cmp(&b.0)) + .expect("three signals") + }) + .collect(); + let (width, height) = self.size; + let fractions = |length: u32| -> Vec { + let tiles = length.div_ceil(TILE); + (0..=tiles) + .map(|tile| (tile * TILE).min(length) as f32 / length as f32) + .collect() + }; + Some(Heat { + columns: width.div_ceil(TILE) as usize, + rows: height.div_ceil(TILE) as usize, + tiles, + edges: (fractions(width), fractions(height)), + }) + } +} + +/// How much `rect` on `canvas` covers of what matters in `heat`: the mean of +/// its tiles, each by how much of it the rect covers, and what mattered most +/// under it. +fn covered(heat: &Heat, rect: &Rect, canvas: Canvas) -> (f32, Option) { + let (w, h) = (canvas.width as f32, canvas.height as f32); + let (left, top) = (rect.x / w, rect.y / h); + let (right, bottom) = ((rect.x + rect.width) / w, (rect.y + rect.height) / h); + let area = (right - left) * (bottom - top); + if area <= 0.0 { + return (0.0, None); + } + let mut sum = 0.0; + let mut most = (0.0, None); + for row in 0..heat.rows { + for column in 0..heat.columns { + let (x0, y0, x1, y1) = heat.tile(column, row); + let overlap = (x1.min(right) - x0.max(left)).max(0.0) * (y1.min(bottom) - y0.max(top)).max(0.0); + if overlap <= 0.0 { + continue; + } + let (matters, signal) = heat.tiles[row * heat.columns + column]; + sum += matters * overlap; + if matters > most.0 { + most = (matters, Some(signal)); + } + } + } + (sum / area, most.1) +} + +/// Where an item is meant to be. +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +enum At { + /// Where its saved rect puts it, before it first chooses. + Rest, + /// Where the streamer moved it, until the content changes. + Held, + /// In a slot. + Slot(Slot), +} + +/// An item's rect easing from one place to the next, on the program clock, +/// as a move transition eases. +struct Glide { + from: Rect, + to: Rect, + /// When the glide under way started, and how long it takes. + start: Option<(Instant, Duration)>, +} + +impl Glide { + /// Glide from where it is drawn at `now` to `to`. + fn go(&mut self, to: Rect, now: Instant, duration: Duration) { + self.from = self.at(now); + self.to = to; + self.start = Some((now, duration)); + } + + /// Where it is drawn at `now`, on its way to `to`: a target it was not + /// gliding to, as a drag or a resize gives, it takes at once. + fn show(&mut self, to: Rect, now: Instant) -> Rect { + if to != self.to { + *self = Self { + from: to, + to, + start: None, + }; + } + let at = self.at(now); + if at == self.to { + self.start = None; + } + at + } + + fn at(&self, now: Instant) -> Rect { + let Some((start, duration)) = self.start else { + return self.to; + }; + let linear = match duration.is_zero() { + true => 1.0, + false => now.saturating_duration_since(start).as_secs_f32() / duration.as_secs_f32(), + }; + if linear >= 1.0 { + return self.to; + } + let progress = Ease::InOut.apply(linear); + Rect { + x: mix(self.from.x, self.to.x, progress), + y: mix(self.from.y, self.to.y, progress), + width: mix(self.from.width, self.to.width, progress), + height: mix(self.from.height, self.to.height, progress), + } + } +} + +/// Chooses where one item keeping clear goes, from what reads of the picture +/// under it show. +pub(crate) struct Placer { + sight: Sight, + /// The rect the scene file gives, as of the last [`place`](Self::place), + /// which tells a move by hand. + saved: Option, + at: At, + /// When it last started looking before choosing: when it began, its + /// scene went on, or the content under it changed. + looking: Option, + /// Since when its place has been the worst. + worst: Option, + /// How long its scene had been on as of the last read, which tells it + /// going on again. + since: Option, + glide: Glide, + placement: Placement, + /// What [`Sight::generation`] and settings the heat was drawn from. + heated: Option<(u64, KeepClear)>, +} + +impl Placer { + /// A placer that starts looking at `now`. + pub fn new(now: Instant) -> Self { + let nowhere = Rect { + x: 0.0, + y: 0.0, + width: 0.0, + height: 0.0, + }; + Self { + sight: Sight::default(), + saved: None, + at: At::Rest, + looking: Some(now), + worst: None, + since: None, + glide: Glide { + from: nowhere, + to: nowhere, + start: None, + }, + placement: Placement { + rect: nowhere, + slot: None, + held: false, + left: None, + slots: Vec::new(), + heat: Heat::default(), + }, + heated: None, + } + } + + /// Take in a read of the picture under the item, taken `at`. + pub fn see(&mut self, read: &Tiles, at: Instant) { + if self.sight.see(read, at) { + self.looking = Some(at); + } + } + + /// Note that the item's scene is drawn, on for `since`, as of `now`: one + /// that went on again since the last is new content to choose for. + pub fn shown(&mut self, since: Duration, now: Instant) { + if self.since.is_some_and(|last| since < last) { + self.sight.forget(); + self.looking = Some(now); + } + self.since = Some(since); + } + + /// Where it is as of the last [`place`](Self::place). + pub fn placement(&self) -> &Placement { + &self.placement + } + + /// Where to draw the item at `now`, saved at `saved` and keeping clear as + /// `keep` says on `canvas`. + pub fn place(&mut self, saved: Rect, keep: &KeepClear, canvas: Canvas, now: Instant) -> Rect { + // Moved by hand, such as dragged: it stays where it was put until the + // content changes. A resize alone keeps its place. + if self.saved.is_some_and(|last| (last.x, last.y) != (saved.x, saved.y)) { + self.at = At::Held; + self.worst = None; + } + self.saved = Some(saved); + let slots: Vec<(Slot, Rect)> = Slot::ALL + .into_iter() + .filter_map(|slot| Some((slot, slot.rect(saved.width, saved.height, canvas)?))) + .collect(); + if let At::Slot(slot) = self.at + && !slots.iter().any(|(fits, _)| *fits == slot) + { + self.at = At::Rest; + } + + let generation = (self.sight.generation, *keep); + if self.heated != Some(generation) { + self.heated = Some(generation); + self.placement.heat = self.sight.heat(keep).unwrap_or_default(); + } + if self.sight.last.is_some() && !slots.is_empty() { + self.choose(saved, &slots, keep, canvas, now); + } + + let target = self.target(saved, &slots); + let rect = self.glide.show(target, now); + self.placement.rect = rect; + self.placement.slot = match self.at { + At::Slot(slot) => Some(slot), + _ => None, + }; + self.placement.held = self.at == At::Held; + self.placement.slots = slots; + rect + } + + /// Where the item is meant to be, gliding or not. + fn target(&self, saved: Rect, slots: &[(Slot, Rect)]) -> Rect { + match self.at { + At::Slot(slot) => slots + .iter() + .find(|(fits, _)| *fits == slot) + .map_or(saved, |(_, rect)| *rect), + At::Rest | At::Held => saved, + } + } + + /// Move to the slot that matters least, if the time has come. + fn choose(&mut self, saved: Rect, slots: &[(Slot, Rect)], keep: &KeepClear, canvas: Canvas, now: Instant) { + let heat = &self.placement.heat; + let cost = |slot: Option, rect: &Rect| { + let (covered, over) = covered(heat, rect, canvas); + let middle = if slot.is_some_and(|slot| !slot.corner()) { + MIDDLE + } else { + 0.0 + }; + (covered + middle, over) + }; + let costs: Vec<(Slot, f32)> = slots + .iter() + .map(|(slot, rect)| (*slot, cost(Some(*slot), rect).0)) + .collect(); + let lowest = costs.iter().map(|(_, cost)| *cost).fold(f32::INFINITY, f32::min); + // Of slots that cover alike, the first: a corner, from the top left. + let (best, _) = *costs + .iter() + .find(|(_, cost)| *cost <= lowest + ALIKE) + .expect("a slot fits"); + let current = match self.at { + At::Slot(slot) => Some(slot), + _ => None, + }; + let here = self.target(saved, slots); + let (cost_here, over) = cost(current, &here); + let better = lowest + BETTER <= cost_here && current != Some(best); + + let looked = self + .looking + .is_some_and(|since| now.saturating_duration_since(since) >= SETTLE && self.sight.compared >= 2); + if looked { + self.looking = None; + self.worst = None; + if self.at == At::Held { + self.at = At::Rest; + } + if better { + self.go(best, here, over, slots, keep, now); + } + return; + } + if self.looking.is_some() || self.at == At::Held { + return; + } + let worst = costs.iter().all(|(_, cost)| *cost <= cost_here + ALIKE); + if !(worst && better) { + self.worst = None; + return; + } + let since = *self.worst.get_or_insert(now); + if now.saturating_duration_since(since) >= WORST { + self.worst = None; + self.go(best, here, over, slots, keep, now); + } + } + + /// Glide to `slot` from `here`, over what mattered most there. + fn go( + &mut self, + slot: Slot, + here: Rect, + over: Option, + slots: &[(Slot, Rect)], + keep: &KeepClear, + now: Instant, + ) { + let (_, to) = slots.iter().find(|(fits, _)| *fits == slot).expect("a slot that fits"); + self.placement.left = Some(Left { rect: here, over }); + self.at = At::Slot(slot); + self.glide.go(*to, now, keep.glide); + } +} + +/// The pipeline every read of the picture under an item goes through. +pub(crate) struct Reducer { + pipeline: wgpu::ComputePipeline, + layout: wgpu::BindGroupLayout, +} + +impl Reducer { + pub fn new(device: &wgpu::Device) -> Self { + let shader = device.create_shader_module(wgpu::include_wgsl!("place.wgsl")); + let picture = |binding| wgpu::BindGroupLayoutEntry { + binding, + visibility: wgpu::ShaderStages::COMPUTE, + ty: wgpu::BindingType::Texture { + sample_type: wgpu::TextureSampleType::Float { filterable: false }, + view_dimension: wgpu::TextureViewDimension::D2, + multisampled: false, + }, + count: None, + }; + let layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor { + label: Some("moq-scene place"), + entries: &[ + picture(0), + picture(1), + wgpu::BindGroupLayoutEntry { + binding: 2, + visibility: wgpu::ShaderStages::COMPUTE, + ty: wgpu::BindingType::Buffer { + ty: wgpu::BufferBindingType::Storage { read_only: false }, + has_dynamic_offset: false, + min_binding_size: wgpu::BufferSize::new(BYTES), + }, + count: None, + }, + ], + }); + let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor { + label: Some("moq-scene place"), + bind_group_layouts: &[Some(&layout)], + immediate_size: 0, + }); + let pipeline = device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor { + label: Some("moq-scene place"), + layout: Some(&pipeline_layout), + module: &shader, + entry_point: Some("reduce"), + compilation_options: Default::default(), + cache: None, + }); + Self { pipeline, layout } + } +} + +/// A read under way: when it was taken, its picture's size, whether it had +/// one before to compare with, and the buffer's mapping once the GPU is done. +struct Reading { + at: Instant, + size: (u32, u32), + compared: bool, + mapped: Arc>>>, +} + +/// One item's reads of the picture under it. +pub(crate) struct Look { + device: wgpu::Device, + queue: wgpu::Queue, + /// The pictures read, by turns: the next read draws into the one the read + /// before last did, and compares with the other. + pictures: [Option; 2], + /// Which of `pictures` the next read draws into. + next: usize, + tiles: wgpu::Buffer, + readback: wgpu::Buffer, + reading: Option, + /// When the last read was taken. + last: Option, +} + +impl Look { + pub fn new(device: &wgpu::Device, queue: &wgpu::Queue) -> Self { + let tiles = device.create_buffer(&wgpu::BufferDescriptor { + label: Some("moq-scene place tiles"), + size: BYTES, + usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC, + mapped_at_creation: false, + }); + let readback = device.create_buffer(&wgpu::BufferDescriptor { + label: Some("moq-scene place tiles"), + size: BYTES, + usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ, + mapped_at_creation: false, + }); + Self { + device: device.clone(), + queue: queue.clone(), + pictures: [None, None], + next: 0, + tiles, + readback, + reading: None, + last: None, + } + } + + /// Whether a read may start at `now`: none is under way, and the last + /// was at least [`INTERVAL`] ago. + pub fn due(&self, now: Instant) -> bool { + self.reading.is_none() + && self + .last + .is_none_or(|last| now.saturating_duration_since(last) >= INTERVAL) + } + + /// What the next read draws the picture under the item into, `canvas` + /// scaled down to at most [`SIDE`] a side. + pub fn target(&mut self, effects: &Effects, canvas: Canvas) -> Target { + let scale = (SIDE as f32 / canvas.width.max(canvas.height) as f32).min(1.0); + let side = |length: u32| ((length as f32 * scale).round() as u32).max(1); + let size = (side(canvas.width), side(canvas.height)); + let picture = &mut self.pictures[self.next]; + match picture { + Some(target) if (target.texture.width(), target.texture.height()) == size => { + target.canvas = canvas; + target.clone() + } + _ => { + // A picture of another size has nothing to compare with. + let other = &mut self.pictures[1 - self.next]; + if other + .as_ref() + .is_some_and(|other| (other.texture.width(), other.texture.height()) != size) + { + *other = None; + } + let target = Target::sized(&self.device, effects, canvas, size, "moq-scene place"); + self.pictures[self.next].insert(target).clone() + } + } + } + + /// Reduce the picture the frame drew into [`target`](Self::target), once + /// submitted, with the one before, and read the tiles back. + pub fn start(&mut self, reducer: &Reducer, now: Instant) { + let read = self.pictures[self.next].as_ref().expect("drawn into"); + let before = self.pictures[1 - self.next].as_ref(); + let compared = before.is_some(); + let view = |target: &Target| target.texture.create_view(&Default::default()); + let bind = self.device.create_bind_group(&wgpu::BindGroupDescriptor { + label: Some("moq-scene place"), + layout: &reducer.layout, + entries: &[ + wgpu::BindGroupEntry { + binding: 0, + resource: wgpu::BindingResource::TextureView(&view(read)), + }, + wgpu::BindGroupEntry { + binding: 1, + resource: wgpu::BindingResource::TextureView(&view(before.unwrap_or(read))), + }, + wgpu::BindGroupEntry { + binding: 2, + resource: self.tiles.as_entire_binding(), + }, + ], + }); + let size = (read.texture.width(), read.texture.height()); + let mut encoder = self.device.create_command_encoder(&Default::default()); + { + let mut pass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor { + label: Some("moq-scene place"), + timestamp_writes: None, + }); + pass.set_pipeline(&reducer.pipeline); + pass.set_bind_group(0, &bind, &[]); + pass.dispatch_workgroups(size.0.div_ceil(TILE), size.1.div_ceil(TILE), 1); + } + let bytes = u64::from(size.0.div_ceil(TILE) * size.1.div_ceil(TILE) * 4); + encoder.copy_buffer_to_buffer(&self.tiles, 0, &self.readback, 0, bytes); + self.queue.submit([encoder.finish()]); + + let mapped = Arc::new(Mutex::new(None)); + let done = mapped.clone(); + // Called from a later submit or poll, once the GPU is done. + self.readback.map_async(wgpu::MapMode::Read, .., move |result| { + *done.lock().unwrap() = Some(result); + }); + self.reading = Some(Reading { + at: now, + size, + compared, + mapped, + }); + self.last = Some(now); + self.next = 1 - self.next; + } + + /// The read under way, once it came back, and when it was taken. + pub fn finish(&mut self) -> Option> { + let reading = self.reading.as_ref()?; + let mapped = reading.mapped.lock().unwrap().take()?; + let Reading { at, size, compared, .. } = self.reading.take().expect("checked above"); + let count = (size.0.div_ceil(TILE) * size.1.div_ceil(TILE)) as usize; + let read = mapped.map_err(|err| err.to_string()).and_then(|()| { + let tiles = match self.readback.slice(..).get_mapped_range() { + Ok(view) => Ok(view.as_chunks::<4>().0[..count].to_vec()), + Err(err) => Err(format!("{err:?}")), + }; + self.readback.unmap(); + tiles + }); + Some(read.map(|tiles| (Tiles { size, compared, tiles }, at))) + } +} + +#[cfg(test)] +mod tests { + use super::*; + + const CANVAS: Canvas = Canvas { + width: 1920, + height: 1080, + framerate: 30, + }; + + /// The picture size a 1080p canvas is read at: 32 by 18 tiles. + const SIZE: (u32, u32) = (512, 288); + + /// A read where every tile is `tile`, except those `marked` returns + /// another for, by column and row. + fn read(tile: [u8; 4], marked: impl Fn(usize, usize) -> Option<[u8; 4]>) -> Tiles { + let mut tiles = Vec::new(); + for row in 0..18 { + for column in 0..32 { + tiles.push(marked(column, row).unwrap_or(tile)); + } + } + Tiles { + size: SIZE, + compared: true, + tiles, + } + } + + /// A game: moving everywhere, with a minimap that holds still in the top + /// right corner. + fn game(column: usize, row: usize) -> Option<[u8; 4]> { + (column >= 26 && row < 7).then_some([0, 60, 50, 90]) + } + + const MOVING: [u8; 4] = [120, 10, 0, 80]; + + /// A slide: still, dark, with text along its bottom left. + fn slide(column: usize, row: usize) -> Option<[u8; 4]> { + (column < 14 && row >= 13).then_some([0, 70, 70, 200]) + } + + const STILL: [u8; 4] = [0, 0, 0, 20]; + + fn camera() -> Rect { + Rect { + x: 1574.0, + y: 54.0, + width: 288.0, + height: 288.0, + } + } + + /// A placer fed `frames` reads a quarter second apart from `start`, + /// placing an item saved at `saved` after each; the time after the last. + fn run(placer: &mut Placer, saved: Rect, start: Instant, reads: impl IntoIterator) -> Instant { + let mut now = start; + for read in reads { + placer.see(&read, now); + placer.place(saved, &KeepClear::default(), CANVAS, now); + now = now.saturating_add(INTERVAL); + } + now + } + + #[test] + fn slots_keep_inside_the_margin() { + let margin = margin(CANVAS); + assert_eq!(margin, 54.0); + let top_left = Slot::TopLeft.rect(288.0, 288.0, CANVAS).unwrap(); + assert_eq!((top_left.x, top_left.y), (54.0, 54.0)); + let bottom = Slot::Bottom.rect(288.0, 288.0, CANVAS).unwrap(); + assert_eq!((bottom.x, bottom.y), (816.0, 738.0)); + let right = Slot::Right.rect(288.0, 288.0, CANVAS).unwrap(); + assert_eq!((right.x, right.y), (1578.0, 396.0)); + // Too tall to fit between the margins. + assert_eq!(Slot::TopLeft.rect(288.0, 1000.0, CANVAS), None); + assert_eq!(Slot::TopLeft.rect(0.0, 100.0, CANVAS), None); + } + + #[test] + fn a_rect_covers_the_tiles_under_it_by_area() { + let mut sight = Sight::default(); + sight.see(&read(STILL, slide), Instant::now()); + let heat = sight.heat(&KeepClear::default()).unwrap(); + assert_eq!((heat.columns, heat.rows), (32, 18)); + let text = Slot::BottomLeft.rect(288.0, 288.0, CANVAS).unwrap(); + let (covered_text, over) = covered(&heat, &text, CANVAS); + // Text weighs 0.8, over the part of the slot below the 13th row. + assert!((covered_text - 0.8 * 246.0 / 288.0).abs() < 1e-3, "{covered_text}"); + assert_eq!(over, Some(Signal::Text)); + let clear = Slot::TopRight.rect(288.0, 288.0, CANVAS).unwrap(); + assert_eq!(covered(&heat, &clear, CANVAS), (0.0, None)); + } + + /// Edges that hold still while the rest moves are a HUD; the same edges + /// in a still picture are text. + #[test] + fn still_edges_are_a_hud_only_while_the_rest_moves() { + let start = Instant::now(); + let mut sight = Sight::default(); + sight.see(&read(MOVING, game), start); + sight.see(&read(MOVING, game), start.saturating_add(INTERVAL)); + let heat = sight.heat(&KeepClear::default()).unwrap(); + assert_eq!(heat.tiles[30].1, Signal::Hud); + assert_eq!(heat.tiles[0].1, Signal::Motion); + + let mut sight = Sight::default(); + let still = |column, row| game(column, row).map(|tile| [0, tile[1], tile[2], tile[3]]); + sight.see(&read(STILL, still), start); + sight.see(&read(STILL, still), start.saturating_add(INTERVAL)); + let heat = sight.heat(&KeepClear::default()).unwrap(); + assert_eq!(heat.tiles[30].1, Signal::Text); + } + + /// Over a game's minimap, it waits a moment to see what moves, then + /// glides to the corner that covers the least, easing as a move + /// transition does. + #[test] + fn it_glides_off_a_hud_once_it_has_looked() { + let start = Instant::now(); + let mut placer = Placer::new(start); + let saved = camera(); + assert_eq!(placer.place(saved, &KeepClear::default(), CANVAS, start), saved); + // Not yet: it has not looked for long enough. + let now = run(&mut placer, saved, start, (0..3).map(|_| read(MOVING, game))); + assert_eq!(placer.placement().slot, None); + let now = run(&mut placer, saved, now, (0..2).map(|_| read(MOVING, game))); + let placement = placer.placement().clone(); + assert_eq!(placement.slot, Some(Slot::TopLeft)); + let left = placement.left.unwrap(); + assert_eq!(left.rect, saved); + assert_eq!(left.over, Some(Signal::Hud)); + + let moved = now.saturating_sub(INTERVAL); + let to = Slot::TopLeft.rect(288.0, 288.0, CANVAS).unwrap(); + let glide = KeepClear::default().glide; + let half = placer.place(saved, &KeepClear::default(), CANVAS, moved.saturating_add(glide / 2)); + assert_eq!(half.x, (saved.x + to.x) / 2.0, "halfway, eased in and out"); + let landed = placer.place(saved, &KeepClear::default(), CANVAS, moved.saturating_add(glide)); + assert_eq!(landed, to); + } + + /// One busy read is never a reason to move: what it covers lingers, but + /// only a place that stays the worst for [`WORST`] moves it. + #[test] + fn a_busy_moment_does_not_move_it() { + let start = Instant::now(); + let mut placer = Placer::new(start); + let saved = Slot::TopLeft.rect(288.0, 288.0, CANVAS).unwrap(); + let now = run(&mut placer, saved, start, (0..8).map(|_| read(MOVING, game))); + assert_eq!(placer.placement().slot, None, "already clear"); + + // Something flares under it for one read. + let flare = |column, row| { + (column < 10 && row < 8) + .then_some([255, 200, 200, 200]) + .or(game(column, row)) + }; + let now = run(&mut placer, saved, now, [read(MOVING, flare)]); + let now = run(&mut placer, saved, now, (0..80).map(|_| read(MOVING, game))); + assert_eq!(placer.placement().slot, None); + assert_eq!(placer.placement().rect, saved); + + // Something that stays there moves it, once it has been the worst + // place for long enough. + let reads = (WORST.as_millis() / INTERVAL.as_millis()) as usize; + let now = run(&mut placer, saved, now, (0..reads - 4).map(|_| read(MOVING, flare))); + assert_eq!(placer.placement().slot, None, "not yet"); + run(&mut placer, saved, now, (0..8).map(|_| read(MOVING, flare))); + assert_ne!(placer.placement().slot, None); + assert_eq!(placer.placement().left.unwrap().over, Some(Signal::Hud)); + } + + /// A move by hand holds, however much it covers, until the content under + /// it changes; then it chooses again. + #[test] + fn a_move_by_hand_holds_until_the_content_changes() { + let start = Instant::now(); + let mut placer = Placer::new(start); + let saved = camera(); + let now = run(&mut placer, saved, start, (0..6).map(|_| read(MOVING, game))); + assert_eq!(placer.placement().slot, Some(Slot::TopLeft)); + + // Dragged back over the minimap. + let dragged = Rect { x: 1600.0, ..saved }; + assert_eq!(placer.place(dragged, &KeepClear::default(), CANVAS, now), dragged); + let now = run(&mut placer, dragged, now, (0..80).map(|_| read(MOVING, game))); + let placement = placer.placement(); + assert!(placement.held); + assert_eq!(placement.rect, dragged); + + // A slide replaces the game: it looks again, and leaves the text alone. + let mut now = now; + while placer.placement().held { + now = run(&mut placer, dragged, now, [read(STILL, slide)]); + assert!(now.saturating_duration_since(start) < Duration::from_secs(60)); + } + let now = run(&mut placer, dragged, now, (0..8).map(|_| read(STILL, slide))); + let placement = placer.placement(); + assert!(!placement.held); + // Its own place covers no text, so nothing is clearly better. + assert_eq!(placement.slot, None); + assert_eq!(placement.rect, dragged); + let _ = now; + } + + /// The content changing kind is a new choice: a camera in the clear + /// corner of a slide moves when a game puts its minimap there. + #[test] + fn new_content_is_a_new_choice() { + let start = Instant::now(); + let mut placer = Placer::new(start); + let saved = camera(); + let now = run(&mut placer, saved, start, (0..8).map(|_| read(STILL, slide))); + assert_eq!(placer.placement().slot, None, "the top right is clear of text"); + let mut now = now; + for _ in 0..16 { + now = run(&mut placer, saved, now, [read(MOVING, game)]); + if placer.placement().slot.is_some() { + break; + } + } + assert_eq!(placer.placement().slot, Some(Slot::TopLeft)); + assert!( + now.saturating_duration_since(start) < Duration::from_secs(2) + CHANGING + SETTLE + INTERVAL * 4, + "soon after the change, not the worst-place wait" + ); + } + + /// What it is told not to stay clear of does not matter to it. + #[test] + fn a_signal_switched_off_does_not_matter() { + let start = Instant::now(); + let mut placer = Placer::new(start); + let saved = camera(); + let keep = KeepClear { + hud: false, + text: false, + ..KeepClear::default() + }; + let mut now = start; + for _ in 0..8 { + placer.see(&read(MOVING, game), now); + placer.place(saved, &keep, CANVAS, now); + now = now.saturating_add(INTERVAL); + } + assert_eq!(placer.placement().slot, None); + } + + /// Going on again is a new choice too, made from what it sees then. + #[test] + fn the_scene_going_on_again_looks_again() { + let start = Instant::now(); + let mut placer = Placer::new(start); + let saved = camera(); + placer.shown(Duration::from_secs(5), start); + let now = run(&mut placer, saved, start, (0..8).map(|_| read(STILL, slide))); + assert_eq!(placer.placement().slot, None); + placer.shown(Duration::ZERO, now); + run(&mut placer, saved, now, (0..6).map(|_| read(MOVING, game))); + assert_eq!(placer.placement().slot, Some(Slot::TopLeft)); + } +} diff --git a/rs/moq-scene/src/place.wgsl b/rs/moq-scene/src/place.wgsl new file mode 100644 index 00000000..206b4aae --- /dev/null +++ b/rs/moq-scene/src/place.wgsl @@ -0,0 +1,76 @@ +// The picture under an item keeping clear, as a grid of tiles, against the +// read before: each tile's share of pixels whose brightness moved, that are +// edges, and that are edges that held still, and its mean brightness. One +// workgroup reduces each tile, a thread to a pixel. + +@group(0) @binding(0) var picture: texture_2d; +// The read before, or this one when there was none. +@group(0) @binding(1) var before: texture_2d; +// Each tile, row by row, as packed RGBA8: moved, edges, still, brightness. +@group(0) @binding(2) var tiles: array; + +// A tile's side, as place.rs's TILE. +const SIDE = 16u; +// How far brightness steps to a neighbor at an edge, out of 1. +const EDGE = 0.1; +// How far a pixel's brightness changes when it moved. +const MOVED = 0.06; +// How little an edge's brightness changes when it held still. +const STILL = 0.02; + +var moved: atomic; +var edges: atomic; +var still: atomic; +var light: atomic; + +fn luma(texture: texture_2d, at: vec2, size: vec2) -> f32 { + let color = textureLoad(texture, clamp(at, vec2(0), size - 1), 0).rgb; + return dot(color, vec3(0.2126, 0.7152, 0.0722)); +} + +// How far brightness steps from `at` to its right and lower neighbors, the +// larger of the two. +fn rise(texture: texture_2d, at: vec2, size: vec2, here: f32) -> f32 { + let right = luma(texture, at + vec2(1, 0), size); + let below = luma(texture, at + vec2(0, 1), size); + return max(abs(right - here), abs(below - here)); +} + +@compute @workgroup_size(16, 16) +fn reduce( + @builtin(workgroup_id) tile: vec3, + @builtin(num_workgroups) grid: vec3, + @builtin(global_invocation_id) pixel: vec3, + @builtin(local_invocation_index) index: u32, +) { + let size = vec2(textureDimensions(picture)); + let at = vec2(pixel.xy); + if all(at < size) { + let now = luma(picture, at, size); + let then = luma(before, at, size); + let change = abs(now - then); + if change > MOVED { + atomicAdd(&moved, 1u); + } + if rise(picture, at, size, now) > EDGE { + atomicAdd(&edges, 1u); + if change < STILL && rise(before, at, size, then) > EDGE { + atomicAdd(&still, 1u); + } + } + atomicAdd(&light, u32(round(now * 255.0))); + } + workgroupBarrier(); + if index == 0u { + let start = vec2(tile.xy * SIDE); + let end = min(start + vec2(i32(SIDE)), size); + let count = f32((end.x - start.x) * (end.y - start.y)); + let shares = vec4( + f32(atomicLoad(&moved)), + f32(atomicLoad(&edges)), + f32(atomicLoad(&still)), + f32(atomicLoad(&light)) / 255.0, + ) / count; + tiles[tile.y * grid.x + tile.x] = pack4x8unorm(shares); + } +} diff --git a/rs/moq-studio/shots/keep.toml b/rs/moq-studio/shots/keep.toml new file mode 100644 index 00000000..cb6a24cf --- /dev/null +++ b/rs/moq-studio/shots/keep.toml @@ -0,0 +1,73 @@ +# The show the Keep out of the way view renders: a game, as an overlay whose +# road rolls and sun bobs on the program clock, under a facecam that keeps +# out of the way. It starts over the minimap, and leaves it. +version = 1 + +[canvas] +width = 1920 +height = 1080 +framerate = 30 + +[sources.facecam] +kind = "image" +path = "person.jpg" + +[sources.game] +kind = "overlay" +width = 1920 +height = 1080 +html = """ + +
+
+
+
HP 82 / 100
+
+
+
+
+
+
+
+
+
+
+
+
+
24 / 120
+
KIXELATEDRanked grind, day 12
+""" + +[[scenes]] +name = "Gameplay" +items = [ + { source = "game", rect = { x = 0, y = 0, width = 1920, height = 1080 } }, + { source = "facecam", rect = { x = 1578, y = 54, width = 288, height = 288 }, crop = { left = 0.21875, right = 0.21875 }, shape = { corners = [0.5, 0.5, 0.5, 0.5], border = 6 }, keep_clear = {} }, +] + +[[audio_scenes]] +name = "Program" +program = true diff --git a/rs/moq-studio/src/shots.rs b/rs/moq-studio/src/shots.rs index 0aac43e4..ad50eb49 100644 --- a/rs/moq-studio/src/shots.rs +++ b/rs/moq-studio/src/shots.rs @@ -110,6 +110,9 @@ enum View { Cued(Page), /// A scene, by name, open for editing off air on BUILD. OffAir(&'static str), + /// BUILD with the front layer selected, once it kept out of the way: + /// moved off what mattered and landed. + KeepClear, } /// BUILD with the host's layer, the middle of the scene on program's three, @@ -221,6 +224,10 @@ views! { build_off_air_refused: Still, studio(View::OffAir("Vertical")); /// Too narrow for the banner beside the live picture, it goes under it. build_off_air_compact: Still, Open::Studio { view: View::OffAir("Break"), size: HALF, show: "show.toml", relay: false }; + /// A facecam keeping out of the way of a game: what matters glowing on the + /// picture, the places it may go, where it was and the glide to where it + /// went, the legend under the picture, and its settings in the inspector. + build_keep_clear: Live, Open::Studio { view: View::KeepClear, size: SIZE, show: "keep.toml", relay: false }; /// MIX: a strip per sound and per audio scene, with their sends, and a /// small live picture in the sound's place. mix: Still, mixing(MixView::Strips, None, SIZE); @@ -1147,6 +1154,7 @@ fn shoot(open: &Open, gpu: &engine::Gpu, runtime: &tokio::runtime::Runtime, show View::Mix(view, opened) => studio.mix(*view, *opened), View::MixMenu => studio.mix(MixView::Strips, None), View::Build { side, inspect, index } => studio.build(*side, *inspect, *index), + View::KeepClear => studio.build(Side::Layers, Inspect::Layer, Some(0)), View::Menu => studio.build(Side::Layers, Inspect::Layer, Some(1)), View::Setting(setting) | View::OnAirSetting(setting) => studio.open(*setting), View::Restart | View::CustomCanvas => studio.open(Setting::Show), @@ -1222,6 +1230,29 @@ fn shoot(open: &Open, gpu: &engine::Gpu, runtime: &tokio::runtime::Runtime, show } })) .expect("the room fails to join at launch"), + View::KeepClear => runtime + .block_on(kio::clock::timeout(SETTLE, async { + loop { + 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); + placement.is_some_and(|placement| { + let slot = placement + .slot + .and_then(|slot| placement.slots.iter().find(|(fits, _)| *fits == slot)); + placement.left.is_some() && slot.is_some_and(|(_, rect)| *rect == placement.rect) + }) + }; + if landed { + break; + } + harness.step(); + kio::clock::sleep(Duration::from_millis(20)).await; + } + harness.run_steps(2); + })) + .expect("the facecam moves off the minimap and lands"), View::OnAirHealth => { let pill = ["Healthy", "Starting", "Degraded", "Unhealthy"] .into_iter() diff --git a/rs/moq-studio/src/ui.rs b/rs/moq-studio/src/ui.rs index e9131882..12dc1e25 100644 --- a/rs/moq-studio/src/ui.rs +++ b/rs/moq-studio/src/ui.rs @@ -33,6 +33,7 @@ mod build; mod cue; mod graph; mod inspector; +mod keep; mod layers; mod layout; mod levels; @@ -2055,7 +2056,7 @@ fn others(state: &State, scene: Option<&str>, dragged: &Picked, since: Duration) let items = collection.items(&shown).unwrap_or_default(); for (at, item) in items.iter().enumerate() { if item.visible && !(shown == dragged.layer && at == dragged.index) { - rects.push(item.posed(since).rect); + rects.push(keep::placed(state, &shown, at, item).posed(since).rect); } } } diff --git a/rs/moq-studio/src/ui/build.rs b/rs/moq-studio/src/ui/build.rs index d6689db3..4c28fa2b 100644 --- a/rs/moq-studio/src/ui/build.rs +++ b/rs/moq-studio/src/ui/build.rs @@ -47,7 +47,15 @@ impl Panels { room.min.y = self.off_air_header(ui, cued, room, snapshot.shape); shape = cued.shape(); } - self.stage(ui, fx, snapshot, super::layout::fit(room, shape)); + let keeping = self.keeping_clear(); + if keeping { + room.max.y -= keep::LEGEND; + } + let at = super::layout::fit(room, shape); + self.stage(ui, fx, snapshot, at); + if keeping { + keep::legend(ui, at); + } self.build_keys(ui); } @@ -162,6 +170,17 @@ impl Panels { } } + /// Whether the selected layer keeps out of the way, so the stage explains + /// what it saw under the picture. + fn keeping_clear(&self) -> bool { + let Some(picked) = &self.selection else { + return false; + }; + let state = self.engine.state.lock().unwrap(); + let item = picked.item(state.collection()); + item.is_some_and(|item| item.visible && keep::placement(&state, &picked.layer, picked.index, item).is_some()) + } + /// The web page the selected layer shows, while it is a visible layer of /// the picture that shows one. fn interacted(&self, state: &State) -> Option { @@ -186,7 +205,8 @@ impl Panels { /// The layers the picture edits, front last, each with its place: the /// scene's, then the always-on-top ones over it, unless the scene is open - /// off air, as they are drawn on program. + /// off air, as they are drawn on program, those keeping clear where they + /// were placed. fn shown(&self, state: &State) -> Vec<(Picked, Item)> { let (_, since) = self.edited_since(state); let collection = state.collection(); @@ -195,8 +215,8 @@ impl Panels { layers .flat_map(|layer| { let items = collection.items(&layer).unwrap_or_default(); - let posed = items.iter().map(move |item| item.posed(since).into_owned()); - posed.enumerate().map(move |(index, item)| { + items.iter().enumerate().map(move |(index, item)| { + let item = keep::placed(state, &layer, index, item).posed(since).into_owned(); let picked = Picked { layer: layer.clone(), index, @@ -265,7 +285,10 @@ impl Panels { let picked = shown[index].0.clone(); self.select(Some(picked.clone())); let collection = state.collection(); - let resting = picked.item(collection).cloned(); + // A layer keeping clear moves from where it was placed. + let resting = picked + .item(collection) + .map(|item| keep::placed(state, &picked.layer, picked.index, item)); if let Some(resting) = resting { let source = collection.sources.get(collection.capture(&resting.source)); self.drag = Some(Drag { @@ -351,6 +374,15 @@ impl Panels { let shown = self.shown(state); let selected = shown.iter().find(|(picked, _)| Some(picked) == self.selection.as_ref()); let accent = ui.visuals().selection.stroke.color; + // What a layer keeping clear saw, under its handles, unless it is + // 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) + && let Some(keep) = resting.keep_clear + { + keep::overlay(&painter, &view, placement, &item.shape, keep.glide); + } // A hidden layer has no handles, as the picture cannot grab it, and a // locked one only its outline. if let Some((picked, item)) = selected.filter(|(_, item)| item.visible) { @@ -433,9 +465,11 @@ impl Panels { fresh |= !repeat; } }); - let Some(item) = picked.item(state.collection()).filter(|item| !item.locked).cloned() else { + let Some(item) = picked.item(state.collection()).filter(|item| !item.locked) else { return (None, Ok(())); }; + // A layer keeping clear moves from where it was placed. + let item = keep::placed(state, &picked.layer, picked.index, item); if delta == [0.0; 2] { return (None, Ok(())); } diff --git a/rs/moq-studio/src/ui/inspector.rs b/rs/moq-studio/src/ui/inspector.rs index d66ac25f..0bc7a584 100644 --- a/rs/moq-studio/src/ui/inspector.rs +++ b/rs/moq-studio/src/ui/inspector.rs @@ -93,7 +93,10 @@ impl Panels { let mut asked = None; section(ui, "Place"); - let mut rect = item.rect; + // Where the picture draws it: a layer keeping clear where it was + // placed, which a move by hand starts from. + let placement = keep::placement(&state, &picked.layer, picked.index, &item); + let mut rect = placement.map_or(item.rect, |placement| placement.rect); ui.horizontal(|ui| { ui.spacing_mut().item_spacing.x = 4.0; let width = ((ui.available_width() - 12.0) / 4.0).max(40.0); @@ -114,6 +117,16 @@ impl Panels { for (verb, response) in responses { if let Some(gesture) = changed(&response, &mut self.gestures) { let label = format!("{verb} `{name}`"); + // A resize keeps where a layer keeping clear rests, so it + // stays free to move. + let rect = match verb { + "Resize" => Rect { + x: item.rect.x, + y: item.rect.y, + ..rect + }, + _ => rect, + }; asked = Some(Asked::Item(Item { rect, ..item.clone() }, label, gesture)); } } @@ -160,6 +173,20 @@ impl Panels { asked = Some(Asked::Act(LayerAction::Lock(locked))); } }); + // Only a scene's layer has a picture under it to keep clear of. + if picked.layer.scene.is_some() + && let Some((keep_clear, label)) = keep::inspector(ui, item.keep_clear, placement) + { + let label = format!("{label}: `{name}`"); + asked = Some(Asked::Item( + Item { + keep_clear, + ..item.clone() + }, + label, + None, + )); + } section(ui, "Shape"); if let Some(corners) = shapes(ui, item.shape.corners) { diff --git a/rs/moq-studio/src/ui/keep.rs b/rs/moq-studio/src/ui/keep.rs new file mode 100644 index 00000000..2448e841 --- /dev/null +++ b/rs/moq-studio/src/ui/keep.rs @@ -0,0 +1,509 @@ +//! Keep out of the way: where the picture draws a layer that moves itself +//! off what matters, what it saw there, and its settings in the inspector. + +use std::time::Duration; + +use egui::{Color32, Pos2, Stroke}; +use moq_scene::place::{Placement, Signal, Slot}; +use moq_scene::{KeepClear, Shape}; + +use super::*; + +/// What matters on screen, as the stage shows it. +const HEAT: Color32 = Color32::from_rgb(0x4d, 0xe3, 0xff); + +/// The glides the inspector offers. +const GLIDES: [Duration; 5] = [ + Duration::ZERO, + Duration::from_millis(200), + Duration::from_millis(400), + Duration::from_millis(800), + Duration::from_millis(1500), +]; + +/// 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`, while it +/// keeps clear. +pub(super) fn placement<'a>(state: &'a State, layer: &Layer, index: usize, item: &Item) -> Option<&'a Placement> { + item.keep_clear?; + let scene = layer.scene.as_deref()?; + state.compositor.placement(scene, index, &item.source) +} + +/// `item`, the `index`th of `layer`, resting where the picture draws it: a +/// layer keeping clear where it was placed. +pub(super) fn placed(state: &State, layer: &Layer, index: usize, item: &Item) -> Item { + match placement(state, layer, index, item) { + Some(placement) => Item { + rect: placement.rect, + ..item.clone() + }, + None => item.clone(), + } +} + +fn slot_name(slot: Slot) -> &'static str { + match slot { + Slot::TopLeft => "Top left", + Slot::Top => "Top", + Slot::TopRight => "Top right", + Slot::Left => "Left", + Slot::Right => "Right", + Slot::BottomLeft => "Bottom left", + Slot::Bottom => "Bottom", + Slot::BottomRight => "Bottom right", + } +} + +/// Its chip in the inspector, its tag on the stage, and what a layer left +/// over it. +fn signal_names(signal: Signal) -> (&'static str, &'static str, &'static str) { + match signal { + Signal::Motion => ("Motion", "MOVING", "the action"), + Signal::Text => ("Text", "TEXT", "the text"), + Signal::Hud => ("HUD", "HUD", "the HUD"), + } +} + +/// The inspector's Keep out of the way, for a layer keeping clear as `keep` +/// says, placed as `placement` says: its switch and, while on, what it stays +/// clear of, where it is, and how it glides. The settings asked for, with a +/// label, if any changed. +pub(super) fn inspector( + ui: &mut Ui, + keep: Option, + placement: Option<&Placement>, +) -> Option<(Option, &'static str)> { + let mut asked = None; + ui.horizontal(|ui| { + ui.label("Keep out of the way"); + ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| { + let mut on = keep.is_some(); + if ui + .add(kit::Toggle::new(&mut on)) + .on_hover_text( + "Move off what matters in the picture under it: motion, text, and a HUD that holds still. \ + Decided on this machine.", + ) + .changed() + { + let label = if on { + "Keep out of the way" + } else { + "Stop keeping out of the way" + }; + asked = Some((on.then(KeepClear::default), label)); + } + ui.label( + egui::RichText::new("moves off what matters") + .color(kit::DIM) + .font(kit::ui(11.0)), + ); + }); + }); + let Some(mut keep) = keep else { return asked }; + ui.add_space(4.0); + egui::Frame::new() + .fill(kit::P2) + .stroke(Stroke::new(1.0, kit::LINE)) + .corner_radius(kit::RADIUS) + .inner_margin(10.0) + .show(ui, |ui| { + ui.set_width(ui.available_width()); + ui.spacing_mut().item_spacing.y = 9.0; + ui.label( + egui::RichText::new("Stays clear of") + .color(kit::DIM) + .font(kit::ui(12.0)), + ); + ui.horizontal_wrapped(|ui| { + ui.spacing_mut().item_spacing.x = 6.0; + for signal in [Signal::Motion, Signal::Text, Signal::Hud] { + let on = match signal { + Signal::Motion => &mut keep.motion, + Signal::Text => &mut keep.text, + Signal::Hud => &mut keep.hud, + }; + let (name, _, _) = signal_names(signal); + if chip(ui, name, on).clicked() { + asked = Some((Some(keep), "Change what it stays clear of")); + } + } + }); + ui.horizontal(|ui| { + ui.spacing_mut().item_spacing.x = 10.0; + let (slot, held) = placement.map_or((None, false), |placement| (placement.slot, placement.held)); + cells(ui, slot); + let (name, note) = match (slot, held) { + (Some(slot), _) => (slot_name(slot), "Corners first"), + (None, true) => ("Where you put it", "Until the content changes"), + (None, false) => ("Where it was put", "Until a corner is clearer"), + }; + ui.vertical(|ui| { + ui.spacing_mut().item_spacing.y = 2.0; + ui.label(egui::RichText::new(name).font(kit::ui(12.0))); + ui.label(egui::RichText::new(note).color(kit::FAINT).font(kit::ui(10.5))); + }); + ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| { + let mut glide = keep.glide; + egui::ComboBox::from_id_salt("keep clear glide") + .selected_text(format!("Glide · {}", seconds(glide))) + .width(96.0) + .show_ui(ui, |ui| { + for choice in GLIDES { + let text = match choice.is_zero() { + true => "Jump".to_string(), + false => seconds(choice), + }; + ui.selectable_value(&mut glide, choice, text); + } + }); + if glide != keep.glide { + keep.glide = glide; + asked = Some((Some(keep), "Change how it glides")); + } + }); + }); + ui.label( + egui::RichText::new("Moves only when the content changes.") + .color(kit::DIM) + .font(kit::ui(12.0)), + ); + }); + asked +} + +/// `duration` in seconds, as the glide reads. +fn seconds(duration: Duration) -> String { + format!("{:.1} s", duration.as_secs_f32()) +} + +/// A chip that is on or off, ticked while on. +fn chip(ui: &mut Ui, text: &str, on: &mut bool) -> egui::Response { + let galley = ui + .painter() + .layout_no_wrap(text.into(), kit::ui_medium(12.0), kit::TEXT); + let size = egui::vec2(10.0 + 14.0 + 5.0 + galley.size().x + 10.0, 26.0); + let (rect, mut response) = ui.allocate_exact_size(size, egui::Sense::click()); + if response.clicked() { + *on = !*on; + response.mark_changed(); + } + let lit = *on; + response.widget_info(|| egui::WidgetInfo::selected(egui::WidgetType::Checkbox, true, lit, text)); + let painter = ui.painter(); + let (fill, stroke, ink) = match lit { + true => (kit::ACCENT.gamma_multiply(0.14), kit::ACCENT, kit::TEXT), + false => (Color32::TRANSPARENT, kit::LINE, kit::DIM), + }; + let stroke = match response.hovered() { + true => stroke.gamma_multiply(1.3), + false => stroke, + }; + painter.rect(rect, 6, fill, Stroke::new(1.0, stroke), egui::StrokeKind::Inside); + let mark = egui::Rect::from_center_size(egui::pos2(rect.left() + 17.0, rect.center().y), egui::Vec2::splat(14.0)); + if lit { + Icon::Check.paint(ui, mark, 13.0, kit::TEXT); + } + let at = egui::pos2(mark.right() + 5.0, rect.center().y - galley.size().y / 2.0); + ui.painter().galley(at, galley, ink); + response +} + +/// The slots as a 3x3 grid, `slot` lit and the middle, where it never goes, +/// dashed. +fn cells(ui: &mut Ui, slot: Option) { + let (cell, gap) = (egui::vec2(17.0, 11.0), 3.0); + let size = egui::vec2(cell.x * 3.0 + gap * 2.0, cell.y * 3.0 + gap * 2.0); + let (rect, _) = ui.allocate_exact_size(size, egui::Sense::hover()); + let painter = ui.painter(); + let lit = slot.map(Slot::cell); + for row in 0..3u8 { + for column in 0..3u8 { + let min = rect.min + egui::vec2(f32::from(column) * (cell.x + gap), f32::from(row) * (cell.y + gap)); + let at = egui::Rect::from_min_size(min, cell); + let grey = Color32::from_rgb(0x3d, 0x3d, 0x4b); + match (column, row) { + (1, 1) => super::dashed(painter, at, Stroke::new(1.0, grey)), + _ if lit == Some((column, row)) => drop(painter.rect_filled(at, 2, kit::ACCENT)), + _ => drop(painter.rect_filled(at, 2, grey)), + } + } + } +} + +/// What a layer keeping clear saw and did, over the stage: what matters on +/// screen, glowing and tagged by kind; the slots it may go to, dashed in its +/// shape; and where it last moved from, with an arrow to where it went. +pub(super) fn overlay(painter: &egui::Painter, view: &View, placement: &Placement, shape: &Shape, glide: Duration) { + let heat = &placement.heat; + let screen = |x: f32, y: f32| view.rect.min + egui::vec2(x * view.rect.width(), y * view.rect.height()); + glow(painter, heat, screen); + // A tag for each kind of thing that matters, in the middle of where it + // matters most: the tile whose neighbors matter most for it with it. + let mut tags: Vec<(Signal, f32, Pos2)> = Vec::new(); + let mattering = |column: usize, row: usize, kind: Signal| { + let (matters, signal) = heat.tiles[row * heat.columns + column]; + if signal == kind { matters } else { 0.0 } + }; + for row in 0..heat.rows { + for column in 0..heat.columns { + let (matters, signal) = heat.tiles[row * heat.columns + column]; + if matters < 0.35 { + continue; + } + let near = |at: usize, length: usize| at.saturating_sub(1)..(at + 2).min(length); + let around: f32 = near(row, heat.rows) + .flat_map(|row| near(column, heat.columns).map(move |column| (column, row))) + .map(|(column, row)| mattering(column, row, signal)) + .sum(); + let (x0, y0, x1, y1) = heat.tile(column, row); + let center = screen((x0 + x1) / 2.0, (y0 + y1) / 2.0); + match tags.iter_mut().find(|(kind, _, _)| *kind == signal) { + Some(tag) if tag.1 < around => *tag = (signal, around, center), + Some(_) => {} + None => tags.push((signal, around, center)), + } + } + } + + let dashed = Stroke::new(1.5, Color32::from_white_alpha(128)); + for (slot, rect) in &placement.slots { + // Its own slot shows as it, and the one it left as that. + let left = placement.left.is_some_and(|left| left.rect == *rect); + if Some(*slot) == placement.slot || left { + continue; + } + let outline = outline(view.screen(rect), shape); + painter.extend(egui::Shape::dashed_line(&outline, dashed, 5.0, 4.0)); + } + + if let Some(left) = placement.left { + moved(painter, view, placement, left, shape, glide); + } + for (signal, _, at) in tags { + let (_, tag, _) = signal_names(signal); + let galley = painter.layout_no_wrap(tag.into(), kit::display_bold(10.0), Color32::from_rgb(0xc9, 0xf6, 0xff)); + let rect = egui::Rect::from_center_size(at, galley.size() + egui::vec2(10.0, 6.0)); + painter.rect_filled(rect, 3, Color32::from_rgba_unmultiplied(0x06, 0x22, 0x2b, 0xd9)); + painter.galley(rect.min + egui::vec2(5.0, 3.0), galley, Color32::WHITE); + } +} + +/// Where a layer keeping clear moved from, what it left there, and an arrow +/// to where it went. +fn moved( + painter: &egui::Painter, + view: &View, + placement: &Placement, + left: moq_scene::place::Left, + shape: &Shape, + glide: Duration, +) { + let was = view.screen(&left.rect); + let outline_was = outline(was, shape); + painter.add(egui::Shape::convex_polygon( + outline_was.clone(), + Color32::from_white_alpha(30), + Stroke::NONE, + )); + painter.extend(egui::Shape::dashed_line( + &outline_was, + Stroke::new(2.0, Color32::WHITE), + 6.0, + 4.0, + )); + let to = view.screen(&placement_target(placement)); + if was.center().distance(to.center()) > 4.0 { + arrow(painter, was, to); + if !glide.is_zero() { + let mid = was.center() + (to.center() - was.center()) / 2.0; + note(painter, mid, &format!("{} glide", seconds(glide))); + } + } + let text = match left.over { + Some(signal) => format!("Was here, over {}", signal_names(signal).2), + None => "Was here".to_string(), + }; + note(painter, egui::pos2(was.center().x, was.top() - 14.0), &text); +} + +/// What matters, as a soft glow: each corner of the tiles as bright as the +/// tiles around it, blended between. +fn glow(painter: &egui::Painter, heat: &moq_scene::place::Heat, screen: impl Fn(f32, f32) -> Pos2) { + let (columns, rows) = (heat.columns, heat.rows); + if columns == 0 || rows == 0 { + return; + } + let (across, down) = &heat.edges; + let mut mesh = egui::Mesh::default(); + for (row, y) in down.iter().enumerate() { + for (column, x) in across.iter().enumerate() { + let mut sum = 0.0; + let mut count = 0.0; + for (c, r) in [ + (column, row), + (column.wrapping_sub(1), row), + (column, row.wrapping_sub(1)), + (column.wrapping_sub(1), row.wrapping_sub(1)), + ] { + if c < columns && r < rows { + sum += heat.tiles[r * columns + c].0; + count += 1.0; + } + } + let matters = sum / count; + // Faint for what barely matters, so the picture shows through. + let alpha = ((matters - 0.08) / 0.62).clamp(0.0, 1.0) * 0.55; + mesh.colored_vertex(screen(*x, *y), HEAT.gamma_multiply(alpha)); + } + } + let stride = (columns + 1) as u32; + for row in 0..rows as u32 { + for column in 0..columns as u32 { + let at = row * stride + column; + mesh.add_triangle(at, at + 1, at + stride); + mesh.add_triangle(at + 1, at + stride + 1, at + stride); + } + } + painter.add(egui::Shape::mesh(mesh)); +} + +/// Where a layer keeping clear is going: its slot, or where it is. +fn placement_target(placement: &Placement) -> Rect { + let slot = placement + .slot + .and_then(|slot| placement.slots.iter().find(|(fits, _)| *fits == slot)); + slot.map_or(placement.rect, |(_, rect)| *rect) +} + +/// A note in a dark pill, centered on `at`, kept on the picture. +fn note(painter: &egui::Painter, at: Pos2, text: &str) { + let galley = painter.layout_no_wrap(text.into(), kit::ui_medium(11.5), kit::TEXT); + let size = galley.size() + egui::vec2(16.0, 10.0); + let mut rect = egui::Rect::from_center_size(at, size); + let clip = painter.clip_rect().shrink(4.0); + rect = rect.translate(egui::vec2( + (clip.left() - rect.left()).max(0.0) - (rect.right() - clip.right()).max(0.0), + (clip.top() - rect.top()).max(0.0) - (rect.bottom() - clip.bottom()).max(0.0), + )); + painter.rect( + rect, + 6, + Color32::from_black_alpha(204), + Stroke::new(1.0, Color32::from_white_alpha(51)), + egui::StrokeKind::Inside, + ); + painter.galley(rect.min + egui::vec2(8.0, 5.0), galley, kit::TEXT); +} + +/// A curved arrow from the edge of `from` to the edge of `to`. +fn arrow(painter: &egui::Painter, from: egui::Rect, to: egui::Rect) { + let (start, end) = (from.center(), to.center()); + let along = end - start; + let length = along.length(); + let direction = along / length; + // Out of each rect, so the arrow runs between them. + let start = start + direction * (from.width().min(from.height()) / 2.0 + 4.0); + let end = end - direction * (to.width().min(to.height()) / 2.0 + 6.0); + let normal = egui::vec2(-direction.y, direction.x); + let control = start + (end - start) / 2.0 + normal * (length * 0.25); + let points: Vec = (0..=24) + .map(|step| { + let t = step as f32 / 24.0; + let (a, b) = (start + (control - start) * t, control + (end - control) * t); + a + (b - a) * t + }) + .collect(); + let stroke = Stroke::new(2.5, Color32::WHITE); + let shadow = Stroke::new(4.5, Color32::from_black_alpha(90)); + painter.add(egui::Shape::line(points.clone(), shadow)); + painter.add(egui::Shape::line(points.clone(), stroke)); + let tip = points[points.len() - 1]; + let back = (points[points.len() - 3] - tip).normalized() * 12.0; + let side = egui::vec2(-back.y, back.x) * 0.5; + painter.add(egui::Shape::line( + vec![tip + back + side, tip, tip + back - side], + stroke, + )); +} + +/// The outline of `shape` around `rect` on screen, as points round it. +fn outline(rect: egui::Rect, shape: &Shape) -> Vec { + let side = rect.width().min(rect.height()); + let radius = |corner: f32| (corner.clamp(0.0, 0.5) * side).max(0.0); + // Top left, top right, bottom right, bottom left, each with the angle its + // arc starts at. + let corners = [ + (rect.left_top(), egui::vec2(1.0, 1.0), std::f32::consts::PI), + (rect.right_top(), egui::vec2(-1.0, 1.0), 1.5 * std::f32::consts::PI), + (rect.right_bottom(), egui::vec2(-1.0, -1.0), 0.0), + (rect.left_bottom(), egui::vec2(1.0, -1.0), 0.5 * std::f32::consts::PI), + ]; + let mut points = Vec::new(); + for ((corner, inward, start), round) in corners.into_iter().zip(shape.corners) { + let radius = radius(round); + let center = corner + inward * radius; + for step in 0..=8 { + let angle = start + step as f32 / 8.0 * std::f32::consts::FRAC_PI_2; + points.push(center + egui::vec2(angle.cos(), angle.sin()) * radius); + } + } + points.push(points[0]); + points +} + +/// The legend under the stage while a layer keeping clear is selected: what +/// the overlay's marks mean, and that the decision stays on this machine. +pub(super) fn legend(ui: &Ui, below: egui::Rect) { + let painter = ui.painter(); + let y = below.bottom() + 18.0; + let font = kit::ui(12.0); + let mut x = below.left() + 4.0; + let mark = |painter: &egui::Painter, x: f32, kind: u8| { + let center = egui::pos2(x + 7.0, y); + match kind { + 0 => { + painter.circle_filled(center, 7.0, HEAT.gamma_multiply(0.25)); + painter.circle_filled(center, 4.0, HEAT); + } + 1 => { + let ring: Vec = (0..=24) + .map(|step| { + let angle = step as f32 / 24.0 * std::f32::consts::TAU; + center + egui::vec2(angle.cos(), angle.sin()) * 6.5 + }) + .collect(); + painter.extend(egui::Shape::dashed_line( + &ring, + Stroke::new(1.5, Color32::from_white_alpha(150)), + 2.5, + 2.0, + )); + } + _ => { + let square = egui::Rect::from_center_size(center, egui::Vec2::splat(13.0)); + painter.rect_stroke(square, 3, Stroke::new(2.0, kit::ACCENT), egui::StrokeKind::Inside); + } + } + }; + for (kind, text) in [ + (0, "What matters on screen"), + (1, "Places it may go"), + (2, "Where it went"), + ] { + mark(painter, x, kind); + let galley = painter.layout_no_wrap(text.into(), font.clone(), kit::DIM); + let width = galley.size().x; + painter.galley(egui::pos2(x + 21.0, y - galley.size().y / 2.0), galley, kit::DIM); + x += 21.0 + width + 18.0; + } + let galley = painter.layout_no_wrap("Decided on this machine".into(), font, kit::DIM); + let right = below.right() - 4.0; + let at = egui::pos2(right - galley.size().x, y - galley.size().y / 2.0); + let icon = egui::Rect::from_center_size(egui::pos2(at.x - 12.0, y), egui::Vec2::splat(14.0)); + painter.galley(at, galley, kit::DIM); + Icon::Panic.paint(ui, icon, 13.0, kit::DIM); +} From 92e43758f1ab71c8b2887f5834d0471192a7225f Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Mon, 16 Nov 2026 21:28:04 -0800 Subject: [PATCH 03/25] feat: refuse keeping clear where it cannot, document it, and leave the rest as quests A published source and a top-layer item cannot keep out of the way, so validation refuses them. The README covers the feature and its scene-file key, and the quest is rewritten to the per-app memory left, with a follow-up to live with it. Co-Authored-By: Claude Opus 5.5 --- README.md | 41 +++++++++++++++++-- quest/m1/auto-place-check.md | 28 +++++++++++++ quest/m1/auto-place.md | 67 ++++++++++++++----------------- rs/moq-scene/src/collection.rs | 36 +++++++++++++++-- rs/moq-studio/shots/keep.toml | 7 +++- rs/moq-studio/src/ui/inspector.rs | 5 ++- 6 files changed, 138 insertions(+), 46 deletions(-) create mode 100644 quest/m1/auto-place-check.md diff --git a/README.md b/README.md index 7abd2f4e..05b88eb7 100644 --- a/README.md +++ b/README.md @@ -288,7 +288,7 @@ is named for it, with these sections: | Section | Use it to | | --- | --- | -| Place | Type or drag its position and size, and its crop, in percent off each edge, fit or fill it, and lock it. | +| Place | Type or drag its position and size, and its crop, in percent off each edge, fit or fill it, lock it, and switch on **Keep out of the way** (see [Keeping out of the way](#keeping-out-of-the-way)). | | Shape | Pick its outline, square, rounded, circle, or arch, give it a border inside that outline and the border's color, and give it a soft shadow, which follows the outline and is the layer's first drop shadow filter. | | Look | Remove its source's background, which every layer showing the source loses (make it independent to cut out here alone); grade its color through a LUT source; add, order, set, and remove its filters, copy them, or paste copied filters after its own; and set its blend mode. | | Shown in | See how many places show its source, **Linked in 3 scenes**, and **Make independent**, which points this layer at a copy of the source of its own, keeping its look, so editing that look no longer edits the others. A copy says what it copies. | @@ -586,6 +586,35 @@ and speeding up through the rest; a picture stall leaves the sound playing, with the canvas showing the last picture meanwhile. Without audio, the picture plays 100 ms behind. The inspector's Source section shows how far behind each broadcast plays. +### Keeping out of the way + +A scene's layer with **Keep out of the way** on, in the inspector's Place +section, moves itself off what matters in the picture under it, such as a +facecam off a game's minimap or a slide's text. A few times a second the +studio draws the layers under it, scaled far down, and reduces them on the +GPU to a grid: where the picture moves, where it is dense with edges that hold +still, as text is, and what holds still while the rest moves, as a HUD does. +Each can be switched off under **Stays clear of**. Nothing is uploaded: the +choice is made on this machine, from the picture alone. + +It keeps to one of eight places, the canvas's corners and edge middles, +inside a margin of a twentieth of the canvas's shorter side, that its size +fits in, taking the one that covers the least of what matters, a corner over +a middle that covers as much. It chooses a second after its scene goes on, +about two seconds after the content under it changes kind (another layout, or +another app), and otherwise moves only once its place has been the worst of them for +10 seconds, never for a single busy moment. It glides there as a move +transition eases, in 0.4 s unless **Glide** says otherwise. Its rect in the +scene file gives its size, and where it rests until it first moves. + +While it is selected, BUILD shows what it saw: what matters glowing, tagged +**MOVING**, **TEXT**, or **HUD**, the places it may go, dashed, and where it +last moved from, with what it left there and an arrow to where it went. Drag +it, nudge it, or type its X or Y, and it stays where it was put until the +content changes; a resize keeps it free to move. Only a scene's layer keeps +out of the way, and not one showing a source [published +independently](#published-independently), which viewers place themselves. + ### Audio scenes Audio from every source is mixed whether or not its scene is live, and cuts @@ -1079,7 +1108,12 @@ Each entry of a scene's `items` is one of its layers, back to front, and each `[[top]]` an always-on-top layer: the `source` it shows and its `rect` on the canvas, in pixels, and optionally `visible = false`, `locked = true`, which the picture's pointer passes through, and its `crop`, `filters`, `blend`, -`shape`, and `keyframes`. +`shape`, `keyframes`, and `keep_clear`. + +A scene's layer with `keep_clear = {}` [keeps out of the +way](#keeping-out-of-the-way) of motion, text, and a HUD; `motion = false`, +`text = false`, or `hud = false` in it ignores one, and `glide` sets how long +a move takes, `"400ms"` unless it says otherwise, up to `"5s"`. A layer's `shape` cuts it to an outline, before its filters, so a drop shadow follows it: `corners`, how round each corner is (top-left, top-right, @@ -1285,7 +1319,8 @@ published, holding an encode session as one on program does. Every player must reproduce how it is placed, so a layer showing it takes no filter but opacity, no blend mode, and no shape, nor do its source's filters or -its keyframes, and no scene that another scene draws can place it. A source with +its keyframes, it does not keep out of the way, and no scene that another scene +draws can place it. A source with its background removed cannot be published, since H.264 carries no transparency and its track would show the background. diff --git a/quest/m1/auto-place-check.md b/quest/m1/auto-place-check.md new file mode 100644 index 00000000..a9da4eaa --- /dev/null +++ b/quest/m1/auto-place-check.md @@ -0,0 +1,28 @@ +# [XS] Live with a camera that keeps out of the way + +## Goal + +The maintainer has streamed a few times with a facecam set to **Keep out of +the way** over real games and slides, and it moves when it should and no +more often. If it does not, the timings or weights it chooses by change until +it does. + +## Plan + +The analysis, the choice, and the glide are tested in moq-scene on synthetic +reads and on the GPU, and BUILD's `build_keep_clear` view shows what it saw. +How often it moves on real content is a judgment no test makes. The knobs are +constants in `rs/moq-scene/src/place.rs`: `SETTLE` (1 s before a choice), +`WORST` (10 s in the worst place before it moves anyway), `BETTER` (how much +clearer a place must be), `APART` and `CHANGING` (what counts as the content +changing kind), `WEIGHT` (motion 0.5, text 0.8, HUD 1.0), and `MIDDLE` (a +corner's lead over an edge middle). + +## Waiting + +- Maintainer: put a camera over a game and over a slide deck with **Keep out + of the way** on (inspector, Place), stream or record a few sessions, and + note each move that was wrong, late, or too frequent. An agent cannot judge + how a move reads to a viewer or which part of a real game matters; the + tests already check the frames and the rules. Done when it moves as + intended, or the change it needs is written into this Plan. diff --git a/quest/m1/auto-place.md b/quest/m1/auto-place.md index a2b6c79c..ef2266ee 100644 --- a/quest/m1/auto-place.md +++ b/quest/m1/auto-place.md @@ -1,51 +1,44 @@ -# [L] A camera that keeps out of the way +# [S] A camera that keeps out of the way remembers each app ## Goal -A layer with **Keep out of the way** on moves itself so it does not cover what -matters in the picture under it: a game's minimap, a slide's text, the window -the streamer is working in. It chooses among a few slots along the edges, -moves only when the content changes, and glides there. The `autoplace` frame -of [`mock/later.html`](/quest/m0/ux/mock/later.html) shows the slots, what it -saw, and the move. +A layer with **Keep out of the way** on knows the app in front: it chooses +again the moment another app comes to the front, rather than waiting to see +the picture change, and the place it chose for an app is remembered per user, +so a known game is right from its first frame. -The decision is made on the machine. Nothing is uploaded. +The decision stays on the machine. Nothing is uploaded. ## Plan +The rest of the quest landed: moq-scene's `place` module reads the picture +under the layer on the GPU a few times a second, weighs motion, still edges +(text), and still edges while the rest moves (a HUD), and keeps the layer in +the corner or edge middle that covers the least, gliding there; BUILD shows +what it saw, and the inspector its settings (`keep_clear` in the scene file). +What remains needs moq to report the app in front. + +- **When it moves:** a notice that the app in front changed starts a new + choice at once, as the content changing kind does now + (`Placer::see` setting `looking`), for the display capture under the + layer. +- **Memory:** the slot chosen for each app, keyed by the app moq reports, + kept per user with the hotkeys and snap settings, not in the scene file. + A remembered slot is where the layer starts when that app comes to the + front, before it has looked; a move by hand or a new choice updates it. + Decided 2026-11-09 (maintainer, /quest-plan): ✅ local only (rejected: a hosted decision model asked on each content change, cheap but it uploads thumbnails of the streamer's screen and its image input is not production -ready; local first with a hosted model as an opt-in tie-breaker). - -- **What it reads:** the composited picture under the layer, scaled far down - on the GPU a few times a second: where it moves, where it is dense with - edges and text, and what stays put while the rest moves, which is a HUD. - The inspector says which of these it stays clear of, and each can be - switched off. It reads neither the pointer nor the focused window, since - moq reports neither a pointer nor a window's place on its display. -- **What it decides:** the slot whose area matters least, among the corners - and edge middles that fit the layer, inside the canvas's margins. -- **When it moves:** when the scene changes, when the content under it - changes kind (another layout, or another app in front where - [moq reports it](/quest/m1/pin-capture-foreground.md)), or when its slot has been the - worst for a sustained time. Never on a single busy frame, and never while - the streamer is dragging it. A manual move wins and holds until the content - changes. -- **Memory:** the slot chosen for an app is remembered per user, so a known - game is right from its first frame. -- **Where it lives:** the analysis and the choice are UI-free, in moq-scene, - tested on recorded frames with a paused clock. The move is the item's - rect animated as a Move transition eases. - -Measure, per AGENTS.md: the frame time and GPU copies the analysis adds, and -that the encoder's load does not move. Should the signals prove too weak, a -small on-device model is a later quest, not a hosted one. - -Human check: living with it for a few streams. Whether it moves too often is -a judgment no test makes. +ready; local first with a hosted model as an opt-in tie-breaker). Should the +signals prove too weak, a small on-device model is a later quest, not a +hosted one. -## Related +## Required - [moq-video's foreground app is pinned](/quest/m1/pin-capture-foreground.md) - when the app in front changes, and the key its slot is remembered under + +## Related + +- [Living with it](/quest/m1/auto-place-check.md) - whether it moves too often, judged on real streams - [Scenes that lay themselves out](/quest/m1/auto-layout.md) - slots chosen by role rather than by content diff --git a/rs/moq-scene/src/collection.rs b/rs/moq-scene/src/collection.rs index 18233850..2de1767a 100644 --- a/rs/moq-scene/src/collection.rs +++ b/rs/moq-scene/src/collection.rs @@ -685,8 +685,9 @@ impl Collection { /// Refuse an item showing a source published independently that the /// layer layout cannot carry: one blended or filtered past opacity, which - /// not every player can reproduce, or one in a scene another scene draws, - /// which the layout cannot place. + /// not every player can reproduce, one keeping clear, which moves where + /// no player sees, or one in a scene another scene draws, which the + /// layout cannot place. fn validate_published(&self) -> Result<(), Error> { let nested: BTreeSet<&str> = self .sources @@ -713,6 +714,11 @@ impl Collection { "{on} cannot be in a scene another scene draws, since viewers place it over the program" ))); } + if item.keep_clear.is_some() { + return Err(Error::Invalid(format!( + "{on} cannot keep out of the way, since viewers place it where the scene file does" + ))); + } let keyframed = item.keyframes.iter().flat_map(|keyframe| &keyframe.filters); let mut filters = self.filters(item).chain(keyframed); if item.blend != Blend::Normal @@ -3225,7 +3231,7 @@ items = [ } #[test] - fn refuses_keeping_clear_with_nothing_under_it_or_too_slowly() { + fn refuses_keeping_clear_where_it_cannot() { let mut collection = example(); collection.scenes[0].items[1].keep_clear = Some(KeepClear::default()); collection.validate().unwrap(); @@ -3233,10 +3239,32 @@ items = [ glide: Duration::from_secs(6), ..KeepClear::default() }); - assert!(matches!(collection.validate(), Err(Error::Invalid(_))), "a glide too long"); + assert!( + matches!(collection.validate(), Err(Error::Invalid(_))), + "a glide too long" + ); collection.scenes[0].items[1].keep_clear = None; collection.top[0].keep_clear = Some(KeepClear::default()); assert!(matches!(collection.validate(), Err(Error::Invalid(_))), "the top layer"); + collection.top[0].keep_clear = None; + collection.validate().unwrap(); + + // A player of the layer layout places a published source where the + // file does, so it cannot move. + let mut published = Collection::new(); + published.sources.insert("cam".into(), Source::Camera { id: None }); + published.published.insert("cam".into()); + published.scenes = vec![Scene { + items: vec![Item { + keep_clear: Some(KeepClear::default()), + ..Item::new("cam", Rect::fill(&published.canvas)) + }], + ..Scene::new("Main") + }]; + assert!( + matches!(published.validate(), Err(Error::Invalid(_))), + "a published source" + ); } #[test] diff --git a/rs/moq-studio/shots/keep.toml b/rs/moq-studio/shots/keep.toml index cb6a24cf..8fea252e 100644 --- a/rs/moq-studio/shots/keep.toml +++ b/rs/moq-studio/shots/keep.toml @@ -65,7 +65,12 @@ html = """ name = "Gameplay" items = [ { source = "game", rect = { x = 0, y = 0, width = 1920, height = 1080 } }, - { source = "facecam", rect = { x = 1578, y = 54, width = 288, height = 288 }, crop = { left = 0.21875, right = 0.21875 }, shape = { corners = [0.5, 0.5, 0.5, 0.5], border = 6 }, keep_clear = {} }, + { source = "facecam", rect = { x = 1578, y = 54, width = 288, height = 288 }, crop = { left = 0.21875, right = 0.21875 }, shape = { corners = [ + 0.5, + 0.5, + 0.5, + 0.5, + ], border = 6 }, keep_clear = {} }, ] [[audio_scenes]] diff --git a/rs/moq-studio/src/ui/inspector.rs b/rs/moq-studio/src/ui/inspector.rs index 0bc7a584..518a0c41 100644 --- a/rs/moq-studio/src/ui/inspector.rs +++ b/rs/moq-studio/src/ui/inspector.rs @@ -173,8 +173,11 @@ impl Panels { asked = Some(Asked::Act(LayerAction::Lock(locked))); } }); - // Only a scene's layer has a picture under it to keep clear of. + // Only a scene's layer has a picture under it to keep clear of, and + // viewers place a published source where the scene file does. + let published = collection.published.contains(collection.capture(&item.source)); if picked.layer.scene.is_some() + && !published && let Some((keep_clear, label)) = keep::inspector(ui, item.keep_clear, placement) { let label = format!("{label}: `{name}`"); From 4790fbdaa0fb8b2918f1aa0b94bda6ce752ae3c1 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Mon, 16 Nov 2026 21:28:17 -0800 Subject: [PATCH 04/25] chore: views for the PR body (deleted next) Co-Authored-By: Claude Opus 5.5 --- shots/build_keep_clear.webp | Bin 0 -> 58420 bytes shots/live_program.webp | Bin 0 -> 33432 bytes 2 files changed, 0 insertions(+), 0 deletions(-) create mode 100644 shots/build_keep_clear.webp create mode 100644 shots/live_program.webp diff --git a/shots/build_keep_clear.webp b/shots/build_keep_clear.webp new file mode 100644 index 0000000000000000000000000000000000000000..6608864b2e379e652d0fcd616c08bb21aa5b4655 GIT binary patch literal 58420 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 literal 0 HcmV?d00001 diff --git a/shots/live_program.webp b/shots/live_program.webp new file mode 100644 index 0000000000000000000000000000000000000000..59abc6770703657d757bf405241287a6f256b6e1 GIT binary patch literal 33432 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 From cb95bdea7d743aea732b5141d5d4657c39de512f Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Mon, 16 Nov 2026 23:41:52 -0800 Subject: [PATCH 06/25] chore(quest): one readback for the compositor's small GPU reads The maintainer chose to share keep-clear's and the dark probe's readback once both land, so it is a follow-up quest on capture-health. Co-Authored-By: Claude Opus 5.5 --- quest/m1/readback.md | 35 +++++++++++++++++++++++++++++++++++ 1 file changed, 35 insertions(+) create mode 100644 quest/m1/readback.md diff --git a/quest/m1/readback.md b/quest/m1/readback.md new file mode 100644 index 00000000..fb647ae9 --- /dev/null +++ b/quest/m1/readback.md @@ -0,0 +1,35 @@ +# [S] One readback for the compositor's small GPU reads + +## Goal + +The compositor reads a few small pictures back from the GPU, a few times a +second each, through one shared helper: the dark-capture probe +(`rs/moq-scene/src/dark.rs`) and the keep-clear look +(`rs/moq-scene/src/place.rs`) each keep only their shader and what they +make of the tiles, and neither stalls a frame. + +## Plan + +The two landed separately with the same pattern: a compute pass reducing a +picture to 16x16 tiles, at most every 250 ms, its result copied to a buffer +mapped with `map_async` and read on a later frame, a failed or late read +dropped. + +- **Shared:** the rate cap (`due`), the storage and readback buffers sized + to the largest grid, the copy after the pass, the map in flight and its + poll, and discarding a read whose source or feed changed meanwhile. +- **Kept apart:** each pipeline and its bindings. `dark.wgsl` reduces the + capture texture alone to mean color and brightest channel; `place.wgsl` + compares the items drawn under a layer with the last read, so it keeps + two pictures that ping-pong. +- Their tests (`dark::tests::`, `compositor::tests::a_camera_keeping_clear_glides_off_what_moves`, + `a_moment_of_dark_draws_the_last_good_picture`) pass unchanged under + `just render-sw`, and the frame time on the AMD iGPU does not grow. + +Decided 2026-11-17 (maintainer, on +[#194](https://github.com/moq-dev/studio/pull/194#issuecomment-6941200435)): +✅ one helper once both land (rejected: sharing in #194, before #192 lands). + +## Required + +- [A capture that went black says so](/quest/m1/capture-health.md) - lands `dark.rs`'s probe, the other reader From 08677955987042c4bdb84882e7c63c037e997d85 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Tue, 17 Nov 2026 01:07:54 -0800 Subject: [PATCH 07/25] fix: a move by hand says so, and a layer keeping clear follows its item The placer no longer guesses a move by hand from the saved rect: BUILD's drag and nudge and the inspector's X and Y call Compositor::hold, which also drops a choice it was about to make. A resize or a crop of a placed layer keeps the saved position, so it stays free to move. A keeper follows its item when a layer added or removed under it shifts it, or its scene is renamed, and browser input maps the pointer to where the layer is drawn. Co-Authored-By: Claude Opus 5.5 --- rs/moq-scene/src/compositor.rs | 99 ++++++++++++++++++++++++++++--- rs/moq-scene/src/place.rs | 63 ++++++++++++++++---- rs/moq-studio/src/ui/build.rs | 15 ++++- rs/moq-studio/src/ui/inspector.rs | 14 ++++- rs/moq-studio/src/ui/keep.rs | 45 ++++++++++++++ 5 files changed, 213 insertions(+), 23 deletions(-) diff --git a/rs/moq-scene/src/compositor.rs b/rs/moq-scene/src/compositor.rs index 0c76e367..240ac33c 100644 --- a/rs/moq-scene/src/compositor.rs +++ b/rs/moq-scene/src/compositor.rs @@ -505,6 +505,17 @@ impl Compositor { (keeper.source == source).then(|| keeper.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 + { + keeper.placer.hold(); + } + } + /// Keep the scenes `outputs` names as outputs from now on, each with /// whether the next [`render`](Self::render) draws it, as it does while an /// output reads it. Each plays its keyframes from the first render after @@ -1031,20 +1042,18 @@ impl Compositor { /// back show. A keeper whose item is gone is forgotten. fn place<'a>(&mut self, collection: &'a Collection, now: Instant) -> Cow<'a, Collection> { let mut staged = Cow::Borrowed(collection); + let mut kept = self.follow(collection); let mut keepers = HashMap::new(); for (number, scene) in collection.scenes.iter().enumerate() { let canvas = scene.canvas(collection.canvas); for (index, item) in scene.items.iter().enumerate() { let Some(keep) = &item.keep_clear else { continue }; let key = (scene.name.clone(), index); - let mut keeper = match self.keepers.remove(&key) { - Some(keeper) if keeper.source == item.source => keeper, - _ => Keeper { - source: item.source.clone(), - placer: Placer::new(now), - look: Look::new(&self.device, &self.queue), - }, - }; + let mut keeper = kept.remove(&key).unwrap_or_else(|| Keeper { + source: item.source.clone(), + placer: Placer::new(now), + look: Look::new(&self.device, &self.queue), + }); match keeper.look.finish() { Some(Ok((tiles, at))) => keeper.placer.see(&tiles, at), Some(Err(err)) => tracing::warn!( @@ -1066,6 +1075,60 @@ impl Compositor { staged } + /// The keepers, each under where its item keeping clear now is: the same + /// place first; else the same source in the same scene, as a layer added + /// or removed under it shifts it; else the same source in a scene that + /// is no longer there, as a rename leaves it, so it goes on from where it + /// was placed. The rest are left out. + fn follow(&mut self, collection: &Collection) -> HashMap<(String, usize), Keeper> { + let mut old = std::mem::take(&mut self.keepers); + let mut kept = HashMap::new(); + let mut missing = Vec::new(); + for scene in &collection.scenes { + for (index, item) in scene.items.iter().enumerate() { + if item.keep_clear.is_none() { + continue; + } + let key = (scene.name.clone(), index); + match old.remove(&key) { + Some(keeper) if keeper.source == item.source => { + kept.insert(key, keeper); + } + Some(other) => { + old.insert(key.clone(), other); + missing.push((key, &item.source)); + } + None => missing.push((key, &item.source)), + } + } + } + let gone = |scene: &str| collection.scene(scene).is_none(); + for same_scene in [true, false] { + missing.retain(|(key, source)| { + let mut candidates: Vec<&(String, usize)> = old + .iter() + .filter(|((scene, _), keeper)| { + &keeper.source == *source + && match same_scene { + true => *scene == key.0, + false => gone(scene), + } + }) + .map(|(old_key, _)| old_key) + .collect(); + // The nearest, so two alike keep their order. + candidates.sort_by_key(|(_, index)| index.abs_diff(key.1)); + let Some(found) = candidates.first().map(|found| (*found).clone()) else { + return true; + }; + let keeper = old.remove(&found).expect("listed above"); + kept.insert(key.clone(), keeper); + false + }); + } + kept + } + /// Pull the newest picture from every source onto the GPU, and forget the /// sources the collection no longer has or has since edited. An overlay /// that arrives now starts its CSS timeline at `now`. @@ -2614,6 +2677,26 @@ mod tests { 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"); assert_eq!(program, studio.preview(), "the preview shows it alike"); + + // A layer added under it shifts it, but it stays where it went. + let added = Item { + visible: false, + ..studio.collection.scenes[0].items[0].clone() + }; + studio.collection.scenes[0].items.insert(0, added); + let camera = camera + 1; + let after = moved.saturating_add(glide * 2); + studio.render(after); + let placement = studio.compositor.placement("busy", camera, "camera").unwrap(); + assert_eq!(placement.rect, to, "it goes on from where it was placed"); + assert_eq!(placement.slot, Some(crate::place::Slot::TopLeft)); + + // Moved by hand, it stays where the scene file puts it. + studio.compositor.hold("busy", camera, "camera"); + studio.render(after.saturating_add(Duration::from_millis(100))); + let placement = studio.compositor.placement("busy", camera, "camera").unwrap(); + assert!(placement.held); + assert_eq!(placement.rect, saved); }) .await; } diff --git a/rs/moq-scene/src/place.rs b/rs/moq-scene/src/place.rs index 07f56e1a..3e01ad69 100644 --- a/rs/moq-scene/src/place.rs +++ b/rs/moq-scene/src/place.rs @@ -499,9 +499,6 @@ impl Glide { /// under it show. pub(crate) struct Placer { sight: Sight, - /// The rect the scene file gives, as of the last [`place`](Self::place), - /// which tells a move by hand. - saved: Option, at: At, /// When it last started looking before choosing: when it began, its /// scene went on, or the content under it changed. @@ -528,7 +525,6 @@ impl Placer { }; Self { sight: Sight::default(), - saved: None, at: At::Rest, looking: Some(now), worst: None, @@ -567,6 +563,16 @@ impl Placer { self.since = Some(since); } + /// Moved by hand, such as dragged or nudged: it stays where the scene + /// file has it until the content under it changes, and a choice it was + /// about to make is dropped. A resize alone is no move: it keeps its + /// place. + pub fn hold(&mut self) { + self.at = At::Held; + self.looking = None; + self.worst = None; + } + /// Where it is as of the last [`place`](Self::place). pub fn placement(&self) -> &Placement { &self.placement @@ -575,13 +581,6 @@ impl Placer { /// Where to draw the item at `now`, saved at `saved` and keeping clear as /// `keep` says on `canvas`. pub fn place(&mut self, saved: Rect, keep: &KeepClear, canvas: Canvas, now: Instant) -> Rect { - // Moved by hand, such as dragged: it stays where it was put until the - // content changes. A resize alone keeps its place. - if self.saved.is_some_and(|last| (last.x, last.y) != (saved.x, saved.y)) { - self.at = At::Held; - self.worst = None; - } - self.saved = Some(saved); let slots: Vec<(Slot, Rect)> = Slot::ALL .into_iter() .filter_map(|slot| Some((slot, slot.rect(saved.width, saved.height, canvas)?))) @@ -1100,6 +1099,7 @@ mod tests { // Dragged back over the minimap. let dragged = Rect { x: 1600.0, ..saved }; + placer.hold(); assert_eq!(placer.place(dragged, &KeepClear::default(), CANVAS, now), dragged); let now = run(&mut placer, dragged, now, (0..80).map(|_| read(MOVING, game))); let placement = placer.placement(); @@ -1121,6 +1121,47 @@ mod tests { let _ = now; } + /// A move by hand while it is still looking drops the choice it was about + /// to make: it stays where it was put, over the minimap, as the same game + /// plays on. + #[test] + fn a_move_by_hand_while_it_looks_drops_the_choice() { + let start = Instant::now(); + let mut placer = Placer::new(start); + let saved = camera(); + let now = run(&mut placer, saved, start, (0..2).map(|_| read(MOVING, game))); + assert_eq!(placer.placement().slot, None, "still looking"); + let dragged = Rect { x: 1600.0, ..saved }; + placer.hold(); + let now = run(&mut placer, dragged, now, (0..40).map(|_| read(MOVING, game))); + let placement = placer.placement(); + assert!(placement.held); + assert_eq!(placement.slot, None); + assert_eq!(placement.rect, dragged); + let _ = now; + } + + /// A resize is no move by hand: it stays in its corner at its new size. + #[test] + fn a_resize_keeps_its_place() { + let start = Instant::now(); + let mut placer = Placer::new(start); + let saved = camera(); + let now = run(&mut placer, saved, start, (0..6).map(|_| read(MOVING, game))); + assert_eq!(placer.placement().slot, Some(Slot::TopLeft)); + let resized = Rect { + width: 200.0, + height: 200.0, + ..saved + }; + let now = run(&mut placer, resized, now, (0..8).map(|_| read(MOVING, game))); + let placement = placer.placement(); + assert!(!placement.held); + assert_eq!(placement.slot, Some(Slot::TopLeft)); + assert_eq!(Some(placement.rect), Slot::TopLeft.rect(200.0, 200.0, CANVAS)); + let _ = now; + } + /// The content changing kind is a new choice: a camera in the clear /// corner of a slide moves when a game puts its minimap there. #[test] diff --git a/rs/moq-studio/src/ui/build.rs b/rs/moq-studio/src/ui/build.rs index ae4c1876..058e842b 100644 --- a/rs/moq-studio/src/ui/build.rs +++ b/rs/moq-studio/src/ui/build.rs @@ -127,7 +127,10 @@ impl Panels { // `interacted` found the page through the selection, so one is. let picked = self.selection.clone().expect("interacting with the selected layer"); let only = Some((&picked.layer, picked.index)); - let delivered = self.interact.update(ui, image, state.collection(), scene, only); + // A layer keeping clear takes the pointer where it is drawn. + let drawn = keep::drawn(&state); + let delivered = self.interact.update(ui, image, &drawn, scene, only); + drop(drawn); deliver(&state.sources, delivered); self.rebind(&state.sources); let stop = interacting_banner(ui, image, &page); @@ -359,6 +362,15 @@ impl Panels { let label = format!("{verb} `{}`", item.source); spot = Some(Spot::Layer(drag.picked.layer.clone(), item.source.clone())); let picked = &drag.picked; + // A move by hand holds a layer keeping clear where it is put; + // a resize or a crop leaves it where it rests. + let rect = match verb { + "Move" => { + keep::hold(state, &picked.layer, picked.index, &item); + rect + } + _ => keep::resized(state, &picked.layer, picked.index, &item, rect), + }; result = edit(state, label, drag.gesture, |draft| { draft.set_item(&picked.layer, picked.index, Item { rect, crop, ..item }) }); @@ -485,6 +497,7 @@ impl Panels { }; let label = format!("Move `{}`", item.source); let spot = Spot::Layer(picked.layer.clone(), item.source.clone()); + keep::hold(state, &picked.layer, picked.index, &item); let result = edit(state, label, Some(gesture), |draft| { draft.set_item(&picked.layer, picked.index, Item { rect, ..item }) }); diff --git a/rs/moq-studio/src/ui/inspector.rs b/rs/moq-studio/src/ui/inspector.rs index 518a0c41..baf94b97 100644 --- a/rs/moq-studio/src/ui/inspector.rs +++ b/rs/moq-studio/src/ui/inspector.rs @@ -91,6 +91,8 @@ impl Panels { } let name = item.source.clone(); let mut asked = None; + // Whether the edit asked for is a move by hand. + let mut moved = false; section(ui, "Place"); // Where the picture draws it: a layer keeping clear where it was @@ -127,6 +129,7 @@ impl Panels { }, _ => rect, }; + moved = verb == "Move"; asked = Some(Asked::Item(Item { rect, ..item.clone() }, label, gesture)); } } @@ -445,9 +448,14 @@ impl Panels { let Some(asked) = asked else { return }; let result = match asked { - Asked::Item(item, label, gesture) => edit(&mut state, label, gesture, |draft| { - draft.set_item(&picked.layer, picked.index, item) - }), + Asked::Item(item, label, gesture) => { + if moved { + keep::hold(&mut state, &picked.layer, picked.index, &item); + } + edit(&mut state, label, gesture, |draft| { + draft.set_item(&picked.layer, picked.index, item) + }) + } Asked::Look(selection, look, label, gesture) => { edit(&mut state, label, gesture, |draft| selection.set_look(draft, look)) } diff --git a/rs/moq-studio/src/ui/keep.rs b/rs/moq-studio/src/ui/keep.rs index 2448e841..7f31f6b1 100644 --- a/rs/moq-studio/src/ui/keep.rs +++ b/rs/moq-studio/src/ui/keep.rs @@ -1,6 +1,7 @@ //! Keep out of the way: where the picture draws a layer that moves itself //! off what matters, what it saw there, and its settings in the inspector. +use std::borrow::Cow; use std::time::Duration; use egui::{Color32, Pos2, Stroke}; @@ -44,6 +45,50 @@ pub(super) fn placed(state: &State, layer: &Layer, index: usize, item: &Item) -> } } +/// `rect`, a new rect 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) -> Rect { + match placement(state, layer, index, item) { + Some(placement) if placement.rect != item.rect => Rect { + x: item.rect.x, + y: item.rect.y, + ..rect + }, + _ => rect, + } +} + +/// Note that `item`, the `index`th of `layer`, was moved by hand: a layer +/// keeping clear stays where it was put until the content under it changes. +pub(super) fn hold(state: &mut State, layer: &Layer, index: usize, item: &Item) { + if item.keep_clear.is_some() + && let Some(scene) = layer.scene.as_deref() + { + state.compositor.hold(scene, index, &item.source); + } +} + +/// The collection as the picture draws it: each layer keeping clear where +/// it was placed, so a pointer over the picture finds what it sees. +pub(super) fn drawn(state: &State) -> Cow<'_, Collection> { + let collection = state.collection(); + let mut drawn = Cow::Borrowed(collection); + for (number, scene) in collection.scenes.iter().enumerate() { + for (index, item) in scene.items.iter().enumerate() { + if item.keep_clear.is_none() { + continue; + } + if let Some(placement) = state.compositor.placement(&scene.name, index, &item.source) + && placement.rect != item.rect + { + drawn.to_mut().scenes[number].items[index].rect = placement.rect; + } + } + } + drawn +} + fn slot_name(slot: Slot) -> &'static str { match slot { Slot::TopLeft => "Top left", From 91cb8e215f528dc764d8a3dc7e2b47c1c61bac46 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Tue, 17 Nov 2026 01:27:56 -0800 Subject: [PATCH 08/25] fix: keepers tell alike layers apart, and a reloaded move holds A keeper matches its item by source and saved rect before index, so two layers keeping clear of the same camera keep their own histories when a layer added under both shifts them. A saved position that changed, as a reload or an undo gives, holds the layer too, beside Compositor::hold; BUILD's resizes keep the saved position, so they never do. Co-Authored-By: Claude Opus 5.5 --- rs/moq-scene/src/compositor.rs | 166 ++++++++++++++++++++++----------- rs/moq-scene/src/place.rs | 20 +++- 2 files changed, 126 insertions(+), 60 deletions(-) diff --git a/rs/moq-scene/src/compositor.rs b/rs/moq-scene/src/compositor.rs index 240ac33c..7a1317aa 100644 --- a/rs/moq-scene/src/compositor.rs +++ b/rs/moq-scene/src/compositor.rs @@ -122,6 +122,9 @@ pub struct Compositor { 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, placer: Placer, look: Look, } @@ -1042,7 +1045,9 @@ impl Compositor { /// back show. A keeper whose item is gone is forgotten. fn place<'a>(&mut self, collection: &'a Collection, now: Instant) -> Cow<'a, Collection> { let mut staged = Cow::Borrowed(collection); - let mut kept = self.follow(collection); + let mut kept = follow(std::mem::take(&mut self.keepers), collection, |keeper| { + (keeper.source.as_str(), keeper.rect) + }); let mut keepers = HashMap::new(); for (number, scene) in collection.scenes.iter().enumerate() { let canvas = scene.canvas(collection.canvas); @@ -1051,6 +1056,7 @@ impl Compositor { let key = (scene.name.clone(), index); let mut keeper = kept.remove(&key).unwrap_or_else(|| Keeper { source: item.source.clone(), + rect: item.rect, placer: Placer::new(now), look: Look::new(&self.device, &self.queue), }); @@ -1064,6 +1070,7 @@ impl Compositor { ), None => {} } + keeper.rect = item.rect; let rect = keeper.placer.place(item.rect, keep, canvas, now); if rect != item.rect { staged.to_mut().scenes[number].items[index].rect = rect; @@ -1075,60 +1082,6 @@ impl Compositor { staged } - /// The keepers, each under where its item keeping clear now is: the same - /// place first; else the same source in the same scene, as a layer added - /// or removed under it shifts it; else the same source in a scene that - /// is no longer there, as a rename leaves it, so it goes on from where it - /// was placed. The rest are left out. - fn follow(&mut self, collection: &Collection) -> HashMap<(String, usize), Keeper> { - let mut old = std::mem::take(&mut self.keepers); - let mut kept = HashMap::new(); - let mut missing = Vec::new(); - for scene in &collection.scenes { - for (index, item) in scene.items.iter().enumerate() { - if item.keep_clear.is_none() { - continue; - } - let key = (scene.name.clone(), index); - match old.remove(&key) { - Some(keeper) if keeper.source == item.source => { - kept.insert(key, keeper); - } - Some(other) => { - old.insert(key.clone(), other); - missing.push((key, &item.source)); - } - None => missing.push((key, &item.source)), - } - } - } - let gone = |scene: &str| collection.scene(scene).is_none(); - for same_scene in [true, false] { - missing.retain(|(key, source)| { - let mut candidates: Vec<&(String, usize)> = old - .iter() - .filter(|((scene, _), keeper)| { - &keeper.source == *source - && match same_scene { - true => *scene == key.0, - false => gone(scene), - } - }) - .map(|(old_key, _)| old_key) - .collect(); - // The nearest, so two alike keep their order. - candidates.sort_by_key(|(_, index)| index.abs_diff(key.1)); - let Some(found) = candidates.first().map(|found| (*found).clone()) else { - return true; - }; - let keeper = old.remove(&found).expect("listed above"); - kept.insert(key.clone(), keeper); - false - }); - } - kept - } - /// Pull the newest picture from every source onto the GPU, and forget the /// sources the collection no longer has or has since edited. An overlay /// that arrives now starts its CSS timeline at `now`. @@ -2387,6 +2340,53 @@ impl Target { } } +/// `old`, the keepers, each under where its item keeping clear now is, so it +/// goes on from where it was placed. 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. The rest are left out. +fn follow( + mut old: HashMap<(String, usize), T>, + collection: &Collection, + shows: impl Fn(&T) -> (&str, Rect), +) -> HashMap<(String, usize), T> { + let mut kept = HashMap::new(); + let mut missing: Vec<((String, usize), &Item)> = Vec::new(); + for scene in &collection.scenes { + for (index, item) in scene.items.iter().enumerate() { + if item.keep_clear.is_some() { + 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 +} + #[cfg(test)] mod tests { use std::time::Duration; @@ -2701,6 +2701,62 @@ mod tests { .await; } + /// 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 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, shows); + 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, shows); + 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, shows); + assert_eq!(which(&keepers, "renamed", 1), Some("first")); + assert_eq!(which(&keepers, "renamed", 2), Some("second")); + + // One that stops keeping clear has no keeper. + collection.scenes[0].items[1].keep_clear = None; + keepers = follow(keepers, &collection, shows); + assert_eq!(keepers.len(), 1); + assert_eq!(which(&keepers, "renamed", 2), Some("second")); + } + /// A source published independently is left out of the program and drawn /// over it as its layer, as it is over the scene in preview, wherever its /// scene stacks it; without one showing, the layered program is the diff --git a/rs/moq-scene/src/place.rs b/rs/moq-scene/src/place.rs index 3e01ad69..65e1d195 100644 --- a/rs/moq-scene/src/place.rs +++ b/rs/moq-scene/src/place.rs @@ -499,6 +499,10 @@ impl Glide { /// under it show. pub(crate) struct Placer { sight: Sight, + /// The rect the scene file gives, as of the last [`place`](Self::place): + /// one saved elsewhere since, as a reload or an undo gives, was moved by + /// hand. + saved: Option, at: At, /// When it last started looking before choosing: when it began, its /// scene went on, or the content under it changed. @@ -525,6 +529,7 @@ impl Placer { }; Self { sight: Sight::default(), + saved: None, at: At::Rest, looking: Some(now), worst: None, @@ -581,6 +586,12 @@ impl Placer { /// Where to draw the item at `now`, saved at `saved` and keeping clear as /// `keep` says on `canvas`. pub fn place(&mut self, saved: Rect, keep: &KeepClear, canvas: Canvas, now: Instant) -> Rect { + // Saved elsewhere, it was moved by hand, though not through + // [`hold`](Self::hold). A resize alone keeps its place. + if self.saved.is_some_and(|last| (last.x, last.y) != (saved.x, saved.y)) { + self.hold(); + } + self.saved = Some(saved); let slots: Vec<(Slot, Rect)> = Slot::ALL .into_iter() .filter_map(|slot| Some((slot, slot.rect(saved.width, saved.height, canvas)?))) @@ -1097,9 +1108,8 @@ mod tests { let now = run(&mut placer, saved, start, (0..6).map(|_| read(MOVING, game))); assert_eq!(placer.placement().slot, Some(Slot::TopLeft)); - // Dragged back over the minimap. + // Dragged back over the minimap, or saved there and reloaded. let dragged = Rect { x: 1600.0, ..saved }; - placer.hold(); assert_eq!(placer.place(dragged, &KeepClear::default(), CANVAS, now), dragged); let now = run(&mut placer, dragged, now, (0..80).map(|_| read(MOVING, game))); let placement = placer.placement(); @@ -1131,13 +1141,13 @@ mod tests { let saved = camera(); let now = run(&mut placer, saved, start, (0..2).map(|_| read(MOVING, game))); assert_eq!(placer.placement().slot, None, "still looking"); - let dragged = Rect { x: 1600.0, ..saved }; + // Put back where it was: the saved rect alone cannot tell. placer.hold(); - let now = run(&mut placer, dragged, now, (0..40).map(|_| read(MOVING, game))); + let now = run(&mut placer, saved, now, (0..40).map(|_| read(MOVING, game))); let placement = placer.placement(); assert!(placement.held); assert_eq!(placement.slot, None); - assert_eq!(placement.rect, dragged); + assert_eq!(placement.rect, saved); let _ = now; } From 61cce155788762399980359707004d651ed3be03 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Tue, 17 Nov 2026 01:54:32 -0800 Subject: [PATCH 09/25] fix: only a move by hand, an undo, or a reload holds a layer keeping clear Per the round-3 checkpoint, the placer no longer reads a changed saved x/y as a move by hand, so a resize from the top or left never holds it. Undo, redo, and reload hold each layer keeping clear whose saved x/y they change. A runtime identity for items, which ends matching placers by source and rect, is a follow-up quest. Co-Authored-By: Claude Opus 5.5 --- quest/m1/item-identity.md | 45 ++++++++++++ rs/moq-scene/src/place.rs | 38 ++++++---- rs/moq-studio/src/engine.rs | 134 ++++++++++++++++++++++++++++++++++++ 3 files changed, 204 insertions(+), 13 deletions(-) create mode 100644 quest/m1/item-identity.md diff --git a/quest/m1/item-identity.md b/quest/m1/item-identity.md new file mode 100644 index 00000000..9fa02273 --- /dev/null +++ b/quest/m1/item-identity.md @@ -0,0 +1,45 @@ +# [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. Auto-layout's slots pair by id where both sides have one. +- **Tests:** duplicates of one camera keep their own placers across an + insert under both, a reorder, an undo of a removal, 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 +- [Scenes that lay themselves out](/quest/m1/auto-layout.md) - its glide pairs items by source today diff --git a/rs/moq-scene/src/place.rs b/rs/moq-scene/src/place.rs index 65e1d195..c947bef5 100644 --- a/rs/moq-scene/src/place.rs +++ b/rs/moq-scene/src/place.rs @@ -499,10 +499,6 @@ impl Glide { /// under it show. pub(crate) struct Placer { sight: Sight, - /// The rect the scene file gives, as of the last [`place`](Self::place): - /// one saved elsewhere since, as a reload or an undo gives, was moved by - /// hand. - saved: Option, at: At, /// When it last started looking before choosing: when it began, its /// scene went on, or the content under it changed. @@ -529,7 +525,6 @@ impl Placer { }; Self { sight: Sight::default(), - saved: None, at: At::Rest, looking: Some(now), worst: None, @@ -586,12 +581,6 @@ impl Placer { /// Where to draw the item at `now`, saved at `saved` and keeping clear as /// `keep` says on `canvas`. pub fn place(&mut self, saved: Rect, keep: &KeepClear, canvas: Canvas, now: Instant) -> Rect { - // Saved elsewhere, it was moved by hand, though not through - // [`hold`](Self::hold). A resize alone keeps its place. - if self.saved.is_some_and(|last| (last.x, last.y) != (saved.x, saved.y)) { - self.hold(); - } - self.saved = Some(saved); let slots: Vec<(Slot, Rect)> = Slot::ALL .into_iter() .filter_map(|slot| Some((slot, slot.rect(saved.width, saved.height, canvas)?))) @@ -1108,8 +1097,9 @@ mod tests { let now = run(&mut placer, saved, start, (0..6).map(|_| read(MOVING, game))); assert_eq!(placer.placement().slot, Some(Slot::TopLeft)); - // Dragged back over the minimap, or saved there and reloaded. + // Dragged back over the minimap. let dragged = Rect { x: 1600.0, ..saved }; + placer.hold(); assert_eq!(placer.place(dragged, &KeepClear::default(), CANVAS, now), dragged); let now = run(&mut placer, dragged, now, (0..80).map(|_| read(MOVING, game))); let placement = placer.placement(); @@ -1141,7 +1131,7 @@ mod tests { let saved = camera(); let now = run(&mut placer, saved, start, (0..2).map(|_| read(MOVING, game))); assert_eq!(placer.placement().slot, None, "still looking"); - // Put back where it was: the saved rect alone cannot tell. + // Moved by hand: only the caller can say so. placer.hold(); let now = run(&mut placer, saved, now, (0..40).map(|_| read(MOVING, game))); let placement = placer.placement(); @@ -1151,6 +1141,28 @@ mod tests { let _ = now; } + /// A rect saved elsewhere is no move by hand unless the caller says so, + /// as a resize from the top left saves one: it stays in its corner. + #[test] + fn a_rect_saved_elsewhere_is_no_move_by_hand() { + let start = Instant::now(); + let mut placer = Placer::new(start); + let saved = camera(); + let now = run(&mut placer, saved, start, (0..6).map(|_| read(MOVING, game))); + assert_eq!(placer.placement().slot, Some(Slot::TopLeft)); + let resized = Rect { + x: 1600.0, + y: 80.0, + width: 262.0, + height: 262.0, + }; + let now = run(&mut placer, resized, now, (0..8).map(|_| read(MOVING, game))); + let placement = placer.placement(); + assert!(!placement.held); + assert_eq!(placement.slot, Some(Slot::TopLeft)); + let _ = now; + } + /// A resize is no move by hand: it stays in its corner at its new size. #[test] fn a_resize_keeps_its_place() { diff --git a/rs/moq-studio/src/engine.rs b/rs/moq-studio/src/engine.rs index c8ce20e6..c28b0319 100644 --- a/rs/moq-studio/src/engine.rs +++ b/rs/moq-studio/src/engine.rs @@ -213,12 +213,23 @@ impl State { } else { entries[from..position].iter().map(|&edit| edit.clone()).collect() }; + let moved = moved(&self.collection, &collection); self.adopt(collection, &made)?; + self.hold(&moved); self.history = history; self.edited(); Ok(()) } + /// Note each layer keeping clear in `moved`, as [`moved`] lists them, as + /// moved by hand: an undo, a redo, or a reload put it elsewhere, so it + /// stays where the scene file has it until the content under it changes. + fn hold(&mut self, moved: &[(String, usize, String)]) { + for (scene, index, source) in moved { + self.compositor.hold(scene, *index, source); + } + } + /// Make `collection`, which the edits `made` led to from the current one, /// the one drawn, once the compositor fits its scenes' sizes. The scenes /// in preview and on program follow the renames and removals `made` holds, @@ -600,7 +611,9 @@ impl autosave::Document for State { } = loaded; // 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 = moved(&self.collection, &collection); self.adopt(collection, &[])?; + self.hold(&moved); self.history = history; self.dropped = dropped; self.reloads += 1; @@ -609,6 +622,27 @@ impl autosave::Document for State { } } +/// Each scene item keeping clear in `after` that `before` saved elsewhere, +/// as its scene, index, and source: the same scene's item at the same index +/// showing the same source, at another x or y. Its keeper is still under +/// that place, as the compositor follows items only as it renders. +fn moved(before: &Collection, after: &Collection) -> Vec<(String, usize, String)> { + let mut moved = Vec::new(); + for scene in &after.scenes { + let Some(was) = before.scene(&scene.name) else { continue }; + for (index, item) in scene.items.iter().enumerate() { + let Some(old) = was.items.get(index) else { continue }; + if item.keep_clear.is_some() + && old.source == item.source + && (old.rect.x, old.rect.y) != (item.rect.x, item.rect.y) + { + moved.push((scene.name.clone(), index, item.source.clone())); + } + } + } + moved +} + /// Refuse edits, each read as its [`Collection::renames`], that remove a /// scene `on_air` program draws, so a slip cannot put black on air, that /// leave one drawing the program in `collection`, which it would draw into @@ -3305,6 +3339,106 @@ mod tests { } } + /// A layer keeping clear that an undo, a redo, or a reload saved + /// elsewhere is listed as moved by hand; one only resized, another + /// source, or one that does not keep clear is not. + #[test] + fn an_undo_or_a_reload_moves_by_hand() { + let mut before = red_canvas().collection; + let rect = moq_scene::Rect { + x: 400.0, + y: 200.0, + width: 100.0, + height: 100.0, + }; + 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.push(moq_scene::Item::new("red", rect)); + let main = before.scenes[0].name.clone(); + 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; + assert_eq!(moved(&before, &after), [(main, 1, "red".to_string())]); + } + + /// An undo that puts a layer keeping clear back where it was saved holds + /// it there, as a move by hand does; the edit it undid, made in the + /// collection rather than by a gesture, did not. + #[tokio::test(flavor = "multi_thread")] + #[ignore = "needs a Vulkan device; run by just render-sw"] + async fn an_undo_holds_a_layer_keeping_clear() { + let dir = tempfile::tempdir().unwrap(); + let mut loaded = red_canvas(); + let rect = moq_scene::Rect { + x: 400.0, + y: 200.0, + width: 100.0, + height: 100.0, + }; + loaded.collection.scenes[0].items.push(moq_scene::Item { + keep_clear: Some(moq_scene::KeepClear::default()), + ..moq_scene::Item::new("red", rect) + }); + let main = loaded.collection.scenes[0].name.clone(); + 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) + .await + .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(); + if placement.is_some_and(|placement| placement.rect == at && placement.held == held) { + return; + } + kio::clock::sleep(Duration::from_millis(10)).await; + } + } + }; + kio::clock::timeout(TIMEOUT, placed(rect, false)) + .await + .expect("placed where it is saved"); + + let moved = moq_scene::Rect { x: 200.0, ..rect }; + { + let mut state = engine.state.lock().unwrap(); + let collection = state.collection(); + let item = collection.scenes[0].items[1].clone(); + let mut draft = collection.draft("Move `red`"); + let layer = moq_scene::Layer::scene(main.as_str()); + draft + .set_item(&layer, 1, moq_scene::Item { rect: moved, ..item }) + .unwrap(); + state.commit(draft, None).unwrap(); + } + kio::clock::timeout(TIMEOUT, placed(moved, false)) + .await + .expect("an edit is no move by hand"); + + engine.state.lock().unwrap().undo().unwrap(); + kio::clock::timeout(TIMEOUT, placed(rect, true)) + .await + .expect("the undo holds it"); + } + /// Frames the recording's own encoder encoded. fn recorded(engine: &Engine) -> u64 { engine.stats.recording.renditions[Role::Record as usize] From c5157a797213ecba74bac58f97d24d8678c96a3f Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Tue, 17 Nov 2026 02:51:16 -0800 Subject: [PATCH 10/25] refactor: a layer keeping clear glides with glide::Glide Per decision 5, place.rs drops its own Glide for auto-layout's, keyed by how many times the layer moved: a move by hand or a change of glide length starts a new one, so the first place shows at once and the next glides from where it is. A Jump glides in no time. Co-Authored-By: Claude Opus 5.5 --- rs/moq-scene/src/place.rs | 144 ++++++++++++++++++-------------------- 1 file changed, 68 insertions(+), 76 deletions(-) diff --git a/rs/moq-scene/src/place.rs b/rs/moq-scene/src/place.rs index c947bef5..6ddaee76 100644 --- a/rs/moq-scene/src/place.rs +++ b/rs/moq-scene/src/place.rs @@ -15,9 +15,10 @@ use std::time::Duration; use kio::clock::Instant; -use crate::collection::{Canvas, Ease, KeepClear, Rect, mix}; +use crate::collection::{Canvas, Item, KeepClear, Rect, mix}; use crate::compositor::Target; use crate::effect::Effects; +use crate::glide::Glide; /// How often the picture under an item is read, at most. pub const INTERVAL: Duration = Duration::from_millis(250); @@ -440,61 +441,6 @@ enum At { Slot(Slot), } -/// An item's rect easing from one place to the next, on the program clock, -/// as a move transition eases. -struct Glide { - from: Rect, - to: Rect, - /// When the glide under way started, and how long it takes. - start: Option<(Instant, Duration)>, -} - -impl Glide { - /// Glide from where it is drawn at `now` to `to`. - fn go(&mut self, to: Rect, now: Instant, duration: Duration) { - self.from = self.at(now); - self.to = to; - self.start = Some((now, duration)); - } - - /// Where it is drawn at `now`, on its way to `to`: a target it was not - /// gliding to, as a drag or a resize gives, it takes at once. - fn show(&mut self, to: Rect, now: Instant) -> Rect { - if to != self.to { - *self = Self { - from: to, - to, - start: None, - }; - } - let at = self.at(now); - if at == self.to { - self.start = None; - } - at - } - - fn at(&self, now: Instant) -> Rect { - let Some((start, duration)) = self.start else { - return self.to; - }; - let linear = match duration.is_zero() { - true => 1.0, - false => now.saturating_duration_since(start).as_secs_f32() / duration.as_secs_f32(), - }; - if linear >= 1.0 { - return self.to; - } - let progress = Ease::InOut.apply(linear); - Rect { - x: mix(self.from.x, self.to.x, progress), - y: mix(self.from.y, self.to.y, progress), - width: mix(self.from.width, self.to.width, progress), - height: mix(self.from.height, self.to.height, progress), - } - } -} - /// Chooses where one item keeping clear goes, from what reads of the picture /// under it show. pub(crate) struct Placer { @@ -508,7 +454,12 @@ pub(crate) struct Placer { /// How long its scene had been on as of the last read, which tells it /// going on again. since: Option, - glide: Glide, + /// The item gliding from one place to the next as a move transition + /// eases, keyed by how many times it moved. + glide: Glide, + /// How long [`glide`](Self::glide) takes. + glides: Duration, + moves: u64, placement: Placement, /// What [`Sight::generation`] and settings the heat was drawn from. heated: Option<(u64, KeepClear)>, @@ -529,11 +480,9 @@ impl Placer { looking: Some(now), worst: None, since: None, - glide: Glide { - from: nowhere, - to: nowhere, - start: None, - }, + glide: Glide::new(KeepClear::default().glide, |_| true), + glides: KeepClear::default().glide, + moves: 0, placement: Placement { rect: nowhere, slot: None, @@ -571,6 +520,7 @@ impl Placer { self.at = At::Held; self.looking = None; self.worst = None; + self.glide = Glide::new(self.glides, |_| true); } /// Where it is as of the last [`place`](Self::place). @@ -601,7 +551,9 @@ impl Placer { } let target = self.target(saved, &slots); - let rect = self.glide.show(target, now); + // Another target with no move, as a resize gives, shows at once. + self.glide.show(self.moves, &[shown(target)], now); + let rect = self.glide.placed()[0].rect; self.placement.rect = rect; self.placement.slot = match self.at { At::Slot(slot) => Some(slot), @@ -663,7 +615,7 @@ impl Placer { self.at = At::Rest; } if better { - self.go(best, here, over, slots, keep, now); + self.go(best, here, over, keep, now); } return; } @@ -678,27 +630,29 @@ impl Placer { let since = *self.worst.get_or_insert(now); if now.saturating_duration_since(since) >= WORST { self.worst = None; - self.go(best, here, over, slots, keep, now); + self.go(best, here, over, keep, now); } } /// Glide to `slot` from `here`, over what mattered most there. - fn go( - &mut self, - slot: Slot, - here: Rect, - over: Option, - slots: &[(Slot, Rect)], - keep: &KeepClear, - now: Instant, - ) { - let (_, to) = slots.iter().find(|(fits, _)| *fits == slot).expect("a slot that fits"); + fn go(&mut self, slot: Slot, here: Rect, over: Option, keep: &KeepClear, now: Instant) { self.placement.left = Some(Left { rect: here, over }); self.at = At::Slot(slot); - self.glide.go(*to, now, keep.glide); + if keep.glide != self.glides { + // 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.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) +} + /// The pipeline every read of the picture under an item goes through. pub(crate) struct Reducer { pipeline: wgpu::ComputePipeline, @@ -1056,6 +1010,44 @@ mod tests { assert_eq!(landed, to); } + /// It glides for as long as its settings say, or jumps. + #[test] + fn it_glides_as_long_as_it_is_set_to() { + let to = Slot::TopLeft.rect(288.0, 288.0, CANVAS).unwrap(); + for glide in [Duration::ZERO, Duration::from_millis(1500)] { + let keep = KeepClear { + glide, + ..KeepClear::default() + }; + let start = Instant::now(); + let mut placer = Placer::new(start); + let saved = camera(); + let mut now = start; + let mut moved = None; + for _ in 0..8 { + placer.see(&read(MOVING, game), now); + placer.place(saved, &keep, CANVAS, now); + if placer.placement().slot.is_some() { + moved = Some(now); + break; + } + now = now.saturating_add(INTERVAL); + } + let moved = moved.expect("it chose a slot"); + let first = placer.placement().rect; + match glide.is_zero() { + true => assert_eq!(first, to, "a jump lands at once"), + false => { + assert_eq!(first, saved, "a glide starts where it was"); + let half = placer.place(saved, &keep, CANVAS, moved.saturating_add(glide / 2)); + assert_eq!(half.x, (saved.x + to.x) / 2.0, "halfway at half its length"); + let landed = placer.place(saved, &keep, CANVAS, moved.saturating_add(glide)); + assert_eq!(landed, to); + } + } + } + } + /// One busy read is never a reason to move: what it covers lingers, but /// only a place that stays the worst for [`WORST`] moves it. #[test] From 7a9ab713f673784a15147fccf0020fbf935c4a2e Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Tue, 17 Nov 2026 03:12:31 -0800 Subject: [PATCH 11/25] fix: a hidden layer keeping clear waits, a resize mid-glide lands, and more A layer keeping clear chooses only while its picture is read, its scene drawn and it shown, and looks again once it is; a resize part way along a glide lands at once; Keep always on top switches keeping clear off and keeps where it was drawn; BUILD's legend shortens its labels, then drops its note, in a narrow window, and the notes draw over the tags they name. Co-Authored-By: Claude Opus 5.5 --- rs/moq-scene/src/compositor.rs | 7 ++++ rs/moq-scene/src/place.rs | 75 +++++++++++++++++++++++++++++++++- rs/moq-studio/src/shots.rs | 3 ++ rs/moq-studio/src/ui/build.rs | 6 ++- rs/moq-studio/src/ui/keep.rs | 33 ++++++++++----- 5 files changed, 110 insertions(+), 14 deletions(-) diff --git a/rs/moq-scene/src/compositor.rs b/rs/moq-scene/src/compositor.rs index 0b67e2f5..d12c443f 100644 --- a/rs/moq-scene/src/compositor.rs +++ b/rs/moq-scene/src/compositor.rs @@ -131,6 +131,9 @@ struct Keeper { /// 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, placer: Placer, look: Look, } @@ -1099,6 +1102,7 @@ impl Compositor { } let mut reads = Vec::new(); for ((scene, index), keeper) in &mut self.keepers { + keeper.watched = false; let Some(&since) = drawn.get(scene.as_str()) else { continue; }; @@ -1115,6 +1119,7 @@ impl Compositor { let Some(at) = at.filter(|&at| shown.items[at].visible) else { continue; }; + keeper.watched = true; if !keeper.look.due(now) { continue; } @@ -1155,6 +1160,7 @@ impl Compositor { 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), }); @@ -1169,6 +1175,7 @@ impl Compositor { None => {} } keeper.rect = item.rect; + keeper.placer.watch(keeper.watched, now); let rect = keeper.placer.place(item.rect, keep, canvas, now); if rect != item.rect { staged.to_mut().scenes[number].items[index].rect = rect; diff --git a/rs/moq-scene/src/place.rs b/rs/moq-scene/src/place.rs index 6ddaee76..b516d916 100644 --- a/rs/moq-scene/src/place.rs +++ b/rs/moq-scene/src/place.rs @@ -460,6 +460,13 @@ pub(crate) struct Placer { /// How long [`glide`](Self::glide) takes. glides: Duration, moves: u64, + /// Where it was meant to be as of the last [`place`](Self::place), and + /// after how many moves: another place with no move, as a resize gives, + /// is taken at once, even part way along a glide. + aimed: Option<(Rect, u64)>, + /// Whether its picture is read: its scene drawn and the item shown. It + /// chooses only while it is. + watched: bool, placement: Placement, /// What [`Sight::generation`] and settings the heat was drawn from. heated: Option<(u64, KeepClear)>, @@ -483,6 +490,8 @@ impl Placer { glide: Glide::new(KeepClear::default().glide, |_| true), glides: KeepClear::default().glide, moves: 0, + aimed: None, + watched: true, placement: Placement { rect: nowhere, slot: None, @@ -523,6 +532,20 @@ impl Placer { self.glide = Glide::new(self.glides, |_| true); } + /// Note whether its picture is read as of `now`: while its scene is not + /// drawn or the item is hidden it sees nothing new, so it neither + /// chooses nor counts its place the worst, and it looks again once it is + /// read again. + pub fn watch(&mut self, watched: bool, now: Instant) { + if watched && !self.watched { + self.looking = Some(now); + } + if !watched { + self.worst = None; + } + self.watched = watched; + } + /// Where it is as of the last [`place`](Self::place). pub fn placement(&self) -> &Placement { &self.placement @@ -546,12 +569,20 @@ impl Placer { self.heated = Some(generation); self.placement.heat = self.sight.heat(keep).unwrap_or_default(); } - if self.sight.last.is_some() && !slots.is_empty() { + if self.watched && self.sight.last.is_some() && !slots.is_empty() { self.choose(saved, &slots, keep, canvas, now); } let target = self.target(saved, &slots); - // Another target with no move, as a resize gives, shows at once. + // Another target with no move, as a resize gives, shows at once, even + // part way along a glide. + if self + .aimed + .is_some_and(|(aimed, moves)| aimed != target && moves == self.moves) + { + self.glide = Glide::new(self.glides, |_| true); + } + self.aimed = Some((target, self.moves)); self.glide.show(self.moves, &[shown(target)], now); let rect = self.glide.placed()[0].rect; self.placement.rect = rect; @@ -1048,6 +1079,46 @@ mod tests { } } + /// A resize part way along a glide takes its new size at once, in the + /// slot it was gliding to. + #[test] + fn a_resize_while_it_glides_lands_at_once() { + let start = Instant::now(); + let mut placer = Placer::new(start); + let saved = camera(); + let now = run(&mut placer, saved, start, (0..5).map(|_| read(MOVING, game))); + assert_eq!(placer.placement().slot, Some(Slot::TopLeft)); + let resized = Rect { + width: 200.0, + height: 200.0, + ..saved + }; + let rect = placer.place(resized, &KeepClear::default(), CANVAS, now); + assert_eq!(Some(rect), Slot::TopLeft.rect(200.0, 200.0, CANVAS)); + } + + /// Unwatched, as when its scene is not drawn or it is hidden, it neither + /// chooses nor counts toward [`WORST`], and it looks again once watched. + #[test] + fn it_chooses_only_while_watched() { + let start = Instant::now(); + let mut placer = Placer::new(start); + let saved = camera(); + placer.watch(false, start); + let now = run(&mut placer, saved, start, (0..8).map(|_| read(MOVING, game))); + assert_eq!(placer.placement().slot, None, "unwatched, it stays"); + let later = now.saturating_add(WORST * 2); + placer.place(saved, &KeepClear::default(), CANVAS, later); + assert_eq!(placer.placement().slot, None); + + placer.watch(true, later); + placer.place(saved, &KeepClear::default(), CANVAS, later); + assert_eq!(placer.placement().slot, None, "it looks again first"); + let now = run(&mut placer, saved, later, (0..8).map(|_| read(MOVING, game))); + assert_eq!(placer.placement().slot, Some(Slot::TopLeft)); + let _ = now; + } + /// One busy read is never a reason to move: what it covers lingers, but /// only a place that stays the worst for [`WORST`] moves it. #[test] diff --git a/rs/moq-studio/src/shots.rs b/rs/moq-studio/src/shots.rs index 5ebdc58c..ab2b39e8 100644 --- a/rs/moq-studio/src/shots.rs +++ b/rs/moq-studio/src/shots.rs @@ -287,6 +287,9 @@ views! { /// picture, the places it may go, where it was and the glide to where it /// went, the legend under the picture, and its settings in the inspector. build_keep_clear: Live, Open::Studio { view: View::KeepClear, size: SIZE, show: "keep.toml", relay: false }; + /// The same in the smallest window: the legend's labels shortened to fit + /// beside the note, or the note left out. + build_keep_clear_compact: Live, Open::Studio { view: View::KeepClear, size: crate::ui::MIN_SIZE, show: "keep.toml", relay: false }; /// A logo dragged over the picture: where it lands, outlined and named /// for the kind of layer it becomes, and Add's row for that kind lit. build_drop: Still, dropping(Drop::Hover); diff --git a/rs/moq-studio/src/ui/build.rs b/rs/moq-studio/src/ui/build.rs index 4105aedc..c3fefc32 100644 --- a/rs/moq-studio/src/ui/build.rs +++ b/rs/moq-studio/src/ui/build.rs @@ -768,11 +768,15 @@ impl Panels { }; let count = collection.items(&to).map_or(0, <[Item]>::len); // The always-on-top layers never go on, so they have no - // keyframes to play, nor slots; it stays where it was drawn. + // keyframes to play, nor slots, nor a picture under them to + // keep clear of; it stays where it was drawn. + let placed = keep::placed(state, layer, index, &item).rect; let (rect, crop) = super::slots::drawn(state, layer, index).unwrap_or((item.rect, item.crop)); + let rect = if item.slot.is_none() { placed } else { rect }; let moved = Item { keyframes: if top { Vec::new() } else { item.keyframes.clone() }, slot: None, + keep_clear: if top { None } else { item.keep_clear }, rect, crop, ..item.clone() diff --git a/rs/moq-studio/src/ui/keep.rs b/rs/moq-studio/src/ui/keep.rs index 10234b16..c9f8f492 100644 --- a/rs/moq-studio/src/ui/keep.rs +++ b/rs/moq-studio/src/ui/keep.rs @@ -329,9 +329,6 @@ pub(super) fn overlay(painter: &egui::Painter, view: &View, placement: &Placemen painter.extend(egui::Shape::dashed_line(&outline, dashed, 5.0, 4.0)); } - if let Some(left) = placement.left { - moved(painter, view, placement, left, shape, glide); - } for (signal, _, at) in tags { let (_, tag, _) = signal_names(signal); let galley = painter.layout_no_wrap(tag.into(), kit::display_bold(10.0), Color32::from_rgb(0xc9, 0xf6, 0xff)); @@ -339,6 +336,10 @@ pub(super) fn overlay(painter: &egui::Painter, view: &View, placement: &Placemen painter.rect_filled(rect, 3, Color32::from_rgba_unmultiplied(0x06, 0x22, 0x2b, 0xd9)); painter.galley(rect.min + egui::vec2(5.0, 3.0), galley, Color32::WHITE); } + // Its notes over the tags, which they name again where they meet. + if let Some(left) = placement.left { + moved(painter, view, placement, left, shape, glide); + } } /// Where a layer keeping clear moved from, what it left there, and an arrow @@ -538,20 +539,30 @@ pub(super) fn legend(ui: &Ui, below: egui::Rect) { } } }; - for (kind, text) in [ - (0, "What matters on screen"), - (1, "Places it may go"), - (2, "Where it went"), - ] { - mark(painter, x, kind); - let galley = painter.layout_no_wrap(text.into(), font.clone(), kit::DIM); + let right = below.right() - 4.0; + let laid = |labels: [&str; 3]| { + let galleys = labels.map(|text| painter.layout_no_wrap(text.into(), font.clone(), kit::DIM)); + let width: f32 = galleys.iter().map(|galley| 21.0 + galley.size().x + 18.0).sum(); + (galleys, width - 18.0) + }; + // Narrow, as BUILD is in a small window, the labels shorten. + let (galleys, width) = laid(["What matters on screen", "Places it may go", "Where it went"]); + let galleys = match x + width <= right { + true => galleys, + false => laid(["What matters", "May go", "Went"]).0, + }; + for (kind, galley) in galleys.into_iter().enumerate() { + mark(painter, x, kind as u8); let width = galley.size().x; painter.galley(egui::pos2(x + 21.0, y - galley.size().y / 2.0), galley, kit::DIM); x += 21.0 + width + 18.0; } + // The note goes where it fits beside them. let galley = painter.layout_no_wrap("Decided on this machine".into(), font, kit::DIM); - let right = below.right() - 4.0; let at = egui::pos2(right - galley.size().x, y - galley.size().y / 2.0); + if at.x - 20.0 < x { + return; + } let icon = egui::Rect::from_center_size(egui::pos2(at.x - 12.0, y), egui::Vec2::splat(14.0)); painter.galley(at, galley, kit::DIM); Icon::Panic.paint(ui, icon, 13.0, kit::DIM); From 5c8730e702785f9639eb81f589729a50f6a129a5 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Tue, 17 Nov 2026 03:19:58 -0800 Subject: [PATCH 12/25] fix: a layer held by hand stays held when shown again Co-Authored-By: Claude Opus 5.5 --- rs/moq-scene/src/place.rs | 18 ++++++++++++++++-- 1 file changed, 16 insertions(+), 2 deletions(-) diff --git a/rs/moq-scene/src/place.rs b/rs/moq-scene/src/place.rs index b516d916..ed4ebb05 100644 --- a/rs/moq-scene/src/place.rs +++ b/rs/moq-scene/src/place.rs @@ -535,9 +535,10 @@ impl Placer { /// Note whether its picture is read as of `now`: while its scene is not /// drawn or the item is hidden it sees nothing new, so it neither /// chooses nor counts its place the worst, and it looks again once it is - /// read again. + /// read again, unless a move by hand holds it, which only the content + /// changing ends. pub fn watch(&mut self, watched: bool, now: Instant) { - if watched && !self.watched { + if watched && !self.watched && self.at != At::Held { self.looking = Some(now); } if !watched { @@ -1116,6 +1117,19 @@ mod tests { assert_eq!(placer.placement().slot, None, "it looks again first"); let now = run(&mut placer, saved, later, (0..8).map(|_| read(MOVING, game))); assert_eq!(placer.placement().slot, Some(Slot::TopLeft)); + + // Moved by hand, then hidden and shown over the same game: it stays + // where it was put. + let dragged = Rect { x: 1600.0, ..saved }; + placer.hold(); + let now = run(&mut placer, dragged, now, (0..4).map(|_| read(MOVING, game))); + placer.watch(false, now); + let now = run(&mut placer, dragged, now, (0..4).map(|_| read(MOVING, game))); + placer.watch(true, now); + let now = run(&mut placer, dragged, now, (0..40).map(|_| read(MOVING, game))); + let placement = placer.placement(); + assert!(placement.held, "still held"); + assert_eq!(placement.rect, dragged); let _ = now; } From db67621b1b1c09f461c92aa49ab725895d90f7d1 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Tue, 17 Nov 2026 03:20:39 -0800 Subject: [PATCH 13/25] chore: the compact view for the PR body (deleted next) Co-Authored-By: Claude Opus 5.5 --- shots/build_keep_clear_compact.webp | Bin 0 -> 25678 bytes 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 shots/build_keep_clear_compact.webp diff --git a/shots/build_keep_clear_compact.webp b/shots/build_keep_clear_compact.webp new file mode 100644 index 0000000000000000000000000000000000000000..ba8b06de517b530e07d4c3d25f0e74c657f0a25a GIT binary patch literal 25678 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 FfB;Xz0Js1E literal 0 HcmV?d00001 From a76c6aaa8c83d0a7913c3c3c4f2ffdf3785cb6cc Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Tue, 17 Nov 2026 03:20:41 -0800 Subject: [PATCH 14/25] chore: drop the PR body's compact view Co-Authored-By: Claude Opus 5.5 --- shots/build_keep_clear_compact.webp | Bin 25678 -> 0 bytes 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 shots/build_keep_clear_compact.webp diff --git a/shots/build_keep_clear_compact.webp b/shots/build_keep_clear_compact.webp deleted file mode 100644 index ba8b06de517b530e07d4c3d25f0e74c657f0a25a..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 25678 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 FfB;Xz0Js1E From 795e4502c6232e396bd9a3e7245df7653065797e Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Tue, 17 Nov 2026 03:38:47 -0800 Subject: [PATCH 15/25] fix: a layer keeping clear stays put while a drag has it in hand BUILD tells the compositor which layer a drag holds, each frame of it, and a layer keeping clear neither chooses nor counts its place the worst while in hand: a resize or a crop no longer races a choice, and a move that has not yet moved is not re-armed. Let go, it goes on as the gesture left it. Co-Authored-By: Claude Opus 5.5 --- rs/moq-scene/src/compositor.rs | 15 +++++++++++++++ rs/moq-scene/src/place.rs | 33 ++++++++++++++++++++++++++++++++- rs/moq-studio/src/ui/build.rs | 2 ++ rs/moq-studio/src/ui/keep.rs | 16 ++++++++++++++++ 4 files changed, 65 insertions(+), 1 deletion(-) diff --git a/rs/moq-scene/src/compositor.rs b/rs/moq-scene/src/compositor.rs index d12c443f..d986cdf5 100644 --- a/rs/moq-scene/src/compositor.rs +++ b/rs/moq-scene/src/compositor.rs @@ -116,6 +116,9 @@ pub struct Compositor { switch: Option, /// Each scene item keeping clear, by its scene and place in it. keepers: HashMap<(String, usize), Keeper>, + /// The item keeping clear a gesture has in hand, by its scene, place, and + /// source. + grabbed: Option<(String, usize, String)>, /// Reduces the pictures under them, made with the first. reducer: Option, /// Each scene with items in slots, by name: where its arrangement put @@ -456,6 +459,7 @@ impl Compositor { layered: false, switch: None, keepers: HashMap::new(), + grabbed: None, reducer: None, reflows: HashMap::new(), }) @@ -550,6 +554,13 @@ impl Compositor { (keeper.source == source).then(|| keeper.placer.placement()) } + /// Note the item a gesture has in hand, 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. + pub fn grab(&mut self, item: Option<(&str, usize, &str)>) { + self.grabbed = item.map(|(scene, index, source)| (scene.to_string(), index, source.to_string())); + } + /// 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. @@ -1176,6 +1187,10 @@ impl Compositor { } keeper.rect = item.rect; keeper.placer.watch(keeper.watched, now); + let grabbed = self.grabbed.as_ref().is_some_and(|(at, number, source)| { + *at == scene.name && *number == index && *source == item.source + }); + keeper.placer.grab(grabbed); let rect = keeper.placer.place(item.rect, keep, canvas, now); if rect != item.rect { staged.to_mut().scenes[number].items[index].rect = rect; diff --git a/rs/moq-scene/src/place.rs b/rs/moq-scene/src/place.rs index ed4ebb05..22bd0fc2 100644 --- a/rs/moq-scene/src/place.rs +++ b/rs/moq-scene/src/place.rs @@ -467,6 +467,9 @@ pub(crate) struct Placer { /// Whether its picture is read: its scene drawn and the item shown. It /// chooses only while it is. watched: bool, + /// Whether a gesture has it in hand, such as a drag: it chooses only once + /// let go. + grabbed: bool, placement: Placement, /// What [`Sight::generation`] and settings the heat was drawn from. heated: Option<(u64, KeepClear)>, @@ -492,6 +495,7 @@ impl Placer { moves: 0, aimed: None, watched: true, + grabbed: false, placement: Placement { rect: nowhere, slot: None, @@ -547,6 +551,17 @@ impl Placer { self.watched = watched; } + /// Note whether a gesture has it in hand, such as a drag that moves, + /// resizes, or crops it: while it does, it neither chooses nor counts its + /// place the worst, and once let go it goes on as the gesture left it, a + /// move holding it. + pub fn grab(&mut self, grabbed: bool) { + if grabbed { + self.worst = None; + } + self.grabbed = grabbed; + } + /// Where it is as of the last [`place`](Self::place). pub fn placement(&self) -> &Placement { &self.placement @@ -570,7 +585,7 @@ impl Placer { self.heated = Some(generation); self.placement.heat = self.sight.heat(keep).unwrap_or_default(); } - if self.watched && self.sight.last.is_some() && !slots.is_empty() { + if self.watched && !self.grabbed && self.sight.last.is_some() && !slots.is_empty() { self.choose(saved, &slots, keep, canvas, now); } @@ -1080,6 +1095,22 @@ mod tests { } } + /// In hand, as a drag has it, it does not choose, though the time to has + /// come; let go, it does. + #[test] + fn it_chooses_only_once_let_go() { + let start = Instant::now(); + let mut placer = Placer::new(start); + let saved = camera(); + placer.grab(true); + let now = run(&mut placer, saved, start, (0..12).map(|_| read(MOVING, game))); + assert_eq!(placer.placement().slot, None, "in hand, it stays"); + placer.grab(false); + let now = run(&mut placer, saved, now, [read(MOVING, game)]); + assert_eq!(placer.placement().slot, Some(Slot::TopLeft)); + let _ = now; + } + /// A resize part way along a glide takes its new size at once, in the /// slot it was gliding to. #[test] diff --git a/rs/moq-studio/src/ui/build.rs b/rs/moq-studio/src/ui/build.rs index c3fefc32..e4382762 100644 --- a/rs/moq-studio/src/ui/build.rs +++ b/rs/moq-studio/src/ui/build.rs @@ -436,6 +436,8 @@ impl Panels { if !response.dragged() { self.drag = None; } + // A layer keeping clear stays put while in hand. + keep::grab(state, self.drag.as_ref().map(|drag| &drag.picked)); if response.has_focus() && self.drag.is_none() && result.is_ok() { (spot, result) = self.nudge(ui, state, response.id); } diff --git a/rs/moq-studio/src/ui/keep.rs b/rs/moq-studio/src/ui/keep.rs index c9f8f492..8525bbdc 100644 --- a/rs/moq-studio/src/ui/keep.rs +++ b/rs/moq-studio/src/ui/keep.rs @@ -69,6 +69,22 @@ pub(super) fn hold(state: &mut State, layer: &Layer, index: usize, item: &Item) } } +/// Note the layer a gesture on the picture has in hand, if any: a layer +/// keeping clear does not choose a place while in hand. +pub(super) fn grab(state: &mut State, picked: Option<&Picked>) { + let collection = state.collection(); + let grabbed = picked.and_then(|picked| { + let scene = picked.layer.scene.clone()?; + let item = picked.item(collection)?; + item.keep_clear?; + Some((scene, picked.index, item.source.clone())) + }); + let grabbed = grabbed + .as_ref() + .map(|(scene, index, source)| (scene.as_str(), *index, source.as_str())); + state.compositor.grab(grabbed); +} + /// `staged`, the collection as the picture draws it, with each layer /// keeping clear where it was placed, so a pointer over the picture finds /// what it sees. From 60b4dd5b60c04f663b06066b0f05a29bc8e8e23f Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Tue, 17 Nov 2026 03:45:37 -0800 Subject: [PATCH 16/25] fix: a drag's hold on a layer keeping clear lapses if not renewed The grab is a lease of half a second that each frame of the drag renews, as BUILD redraws at the canvas rate, so a window hidden mid-drag lets go. Co-Authored-By: Claude Opus 5.5 --- rs/moq-scene/src/compositor.rs | 27 ++++++++++++++++++--------- rs/moq-studio/src/ui/keep.rs | 2 +- 2 files changed, 19 insertions(+), 10 deletions(-) diff --git a/rs/moq-scene/src/compositor.rs b/rs/moq-scene/src/compositor.rs index d986cdf5..f5f30772 100644 --- a/rs/moq-scene/src/compositor.rs +++ b/rs/moq-scene/src/compositor.rs @@ -22,6 +22,10 @@ use crate::overlay::{Overlay, Overlays}; use crate::place::{Look, Placement, Placer, Reducer}; use crate::source::{self, Feed, Sources, Status}; +/// How long a gesture holds an item keeping clear in hand after it last +/// said so: a few frames of the window, so one hidden mid-drag lets go. +pub const GRAB: Duration = Duration::from_millis(500); + /// The format of every canvas texture: gamma-encoded RGBA, what /// `moq_video::render` produces and what its exporter hands an encoder. pub const FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba8Unorm; @@ -117,8 +121,8 @@ pub struct Compositor { /// Each scene item keeping clear, by its scene and place in it. keepers: HashMap<(String, usize), Keeper>, /// The item keeping clear a gesture has in hand, by its scene, place, and - /// source. - grabbed: Option<(String, usize, String)>, + /// source, until when, unless the gesture says so again. + grabbed: Option<((String, usize, String), Instant)>, /// Reduces the pictures under them, made with the first. reducer: Option, /// Each scene with items in slots, by name: where its arrangement put @@ -554,11 +558,16 @@ impl Compositor { (keeper.source == source).then(|| keeper.placer.placement()) } - /// Note the item a gesture has in hand, 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. - pub fn grab(&mut self, item: Option<(&str, usize, &str)>) { - self.grabbed = item.map(|(scene, index, source)| (scene.to_string(), index, source.to_string())); + /// 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)) + }); } /// Note that the `index`th item of the scene called `scene`, one showing @@ -1187,8 +1196,8 @@ impl Compositor { } keeper.rect = item.rect; keeper.placer.watch(keeper.watched, now); - let grabbed = self.grabbed.as_ref().is_some_and(|(at, number, source)| { - *at == scene.name && *number == index && *source == item.source + let grabbed = self.grabbed.as_ref().is_some_and(|((at, number, source), until)| { + *at == scene.name && *number == index && *source == item.source && now < *until }); keeper.placer.grab(grabbed); let rect = keeper.placer.place(item.rect, keep, canvas, now); diff --git a/rs/moq-studio/src/ui/keep.rs b/rs/moq-studio/src/ui/keep.rs index 8525bbdc..f4bd2ba3 100644 --- a/rs/moq-studio/src/ui/keep.rs +++ b/rs/moq-studio/src/ui/keep.rs @@ -82,7 +82,7 @@ pub(super) fn grab(state: &mut State, picked: Option<&Picked>) { let grabbed = grabbed .as_ref() .map(|(scene, index, source)| (scene.as_str(), *index, source.as_str())); - state.compositor.grab(grabbed); + state.compositor.grab(grabbed, kio::clock::now()); } /// `staged`, the collection as the picture draws it, with each layer From 442404bfc2c655b7d69680e1e176dd2a6c3c3a2e Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Tue, 17 Nov 2026 03:50:19 -0800 Subject: [PATCH 17/25] fix: a drag renews its hold four times a lease, at any canvas rate Co-Authored-By: Claude Opus 5.5 --- rs/moq-scene/src/compositor.rs | 6 +----- rs/moq-scene/src/place.rs | 5 +++++ rs/moq-studio/src/ui/build.rs | 6 +++++- 3 files changed, 11 insertions(+), 6 deletions(-) diff --git a/rs/moq-scene/src/compositor.rs b/rs/moq-scene/src/compositor.rs index f5f30772..eada7a33 100644 --- a/rs/moq-scene/src/compositor.rs +++ b/rs/moq-scene/src/compositor.rs @@ -19,13 +19,9 @@ use crate::effect::{self, Effects, Frame, Lut, Picture, Prepared}; use crate::glide::{Glide, REFLOW, mixed, pair, stack}; use crate::matte::Matte; use crate::overlay::{Overlay, Overlays}; -use crate::place::{Look, Placement, Placer, Reducer}; +use crate::place::{GRAB, Look, Placement, Placer, Reducer}; use crate::source::{self, Feed, Sources, Status}; -/// How long a gesture holds an item keeping clear in hand after it last -/// said so: a few frames of the window, so one hidden mid-drag lets go. -pub const GRAB: Duration = Duration::from_millis(500); - /// The format of every canvas texture: gamma-encoded RGBA, what /// `moq_video::render` produces and what its exporter hands an encoder. pub const FORMAT: wgpu::TextureFormat = wgpu::TextureFormat::Rgba8Unorm; diff --git a/rs/moq-scene/src/place.rs b/rs/moq-scene/src/place.rs index 22bd0fc2..af043d2b 100644 --- a/rs/moq-scene/src/place.rs +++ b/rs/moq-scene/src/place.rs @@ -23,6 +23,11 @@ use crate::glide::Glide; /// How often the picture under an item is read, at most. pub const INTERVAL: Duration = Duration::from_millis(250); +/// How long a gesture holds an item keeping clear in hand after it last +/// said so: a window that stops drawing mid-drag, as a hidden one does, +/// lets go this long after. +pub const GRAB: Duration = Duration::from_millis(500); + /// The longest side of the picture read, in pixels: text a 1080p canvas /// shows at a readable size still has edges at this size. const SIDE: u32 = 512; diff --git a/rs/moq-studio/src/ui/build.rs b/rs/moq-studio/src/ui/build.rs index e4382762..93372bf7 100644 --- a/rs/moq-studio/src/ui/build.rs +++ b/rs/moq-studio/src/ui/build.rs @@ -436,8 +436,12 @@ impl Panels { if !response.dragged() { self.drag = None; } - // A layer keeping clear stays put while in hand. + // A layer keeping clear stays put while in hand, which each frame + // says again, at least four times a lease, whatever the canvas rate. keep::grab(state, self.drag.as_ref().map(|drag| &drag.picked)); + if self.drag.is_some() { + ui.ctx().request_repaint_after(moq_scene::place::GRAB / 4); + } if response.has_focus() && self.drag.is_none() && result.is_ok() { (spot, result) = self.nudge(ui, state, response.id); } From cb393471e21d9b82606aebd8c1be54bed65d62e3 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Tue, 17 Nov 2026 03:58:18 -0800 Subject: [PATCH 18/25] fix: switching keep-clear off leaves the layer where it is drawn Co-Authored-By: Claude Opus 5.5 --- README.md | 3 ++- rs/moq-studio/src/ui/inspector.rs | 7 +++++++ 2 files changed, 9 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index a09cac26..66b8edf7 100644 --- a/README.md +++ b/README.md @@ -734,7 +734,8 @@ While it is selected, BUILD shows what it saw: what matters glowing, tagged last moved from, with what it left there and an arrow to where it went. Drag it, nudge it, or type its X or Y, and it stays where it was put until the content changes, as it does where an undo, a redo, or a reload of the scene -file moves it; a resize keeps it free to move. Only a scene's layer set +file moves it; a resize keeps it free to move. Switched off, it stays where +it is drawn. Only a scene's layer set free of its [slots](#slots-and-roles) keeps out of the way, and not one showing a source [published independently](#published-independently), which viewers place themselves; putting one in a slot switches it off. diff --git a/rs/moq-studio/src/ui/inspector.rs b/rs/moq-studio/src/ui/inspector.rs index 55aa84bb..425df3cf 100644 --- a/rs/moq-studio/src/ui/inspector.rs +++ b/rs/moq-studio/src/ui/inspector.rs @@ -227,9 +227,16 @@ impl Panels { && let Some((keep_clear, label)) = keep::inspector(ui, item.keep_clear, placement) { let label = format!("{label}: `{name}`"); + // Switched off, it stays where it is drawn, as keeping it always + // on top does, rather than going back over what it moved off. + let rect = match (keep_clear, placement) { + (None, Some(placement)) => placement.rect, + _ => item.rect, + }; asked = Some(Asked::Item( Item { keep_clear, + rect, ..item.clone() }, label, From 3c0b4856b92b475651adee0dec05e37221c13411 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Tue, 17 Nov 2026 04:16:03 -0800 Subject: [PATCH 19/25] fix: a glide under way pauses while a gesture has the layer in hand Taken in hand part way along a glide, as a crop started then is, a layer keeping clear stops where it is drawn, so it stays under the pointer, and glides on from there once let go. A move by hand still holds it at once. Co-Authored-By: Claude Opus 5.5 --- rs/moq-scene/src/place.rs | 90 +++++++++++++++++++++++++++++++++++---- 1 file changed, 82 insertions(+), 8 deletions(-) diff --git a/rs/moq-scene/src/place.rs b/rs/moq-scene/src/place.rs index af043d2b..b2b47ad1 100644 --- a/rs/moq-scene/src/place.rs +++ b/rs/moq-scene/src/place.rs @@ -475,6 +475,12 @@ pub(crate) struct Placer { /// Whether a gesture has it in hand, such as a drag: it chooses only once /// let go. grabbed: bool, + /// Until when the glide of its last choice runs. + gliding: Option, + /// Where a glide under way stopped when a gesture took it in hand: it + /// stays there, at the size it is meant to have, until let go, then + /// glides on from there. + paused: Option, placement: Placement, /// What [`Sight::generation`] and settings the heat was drawn from. heated: Option<(u64, KeepClear)>, @@ -501,6 +507,8 @@ impl Placer { aimed: None, watched: true, grabbed: false, + gliding: None, + paused: None, placement: Placement { rect: nowhere, slot: None, @@ -539,6 +547,8 @@ impl Placer { self.looking = None; self.worst = None; self.glide = Glide::new(self.glides, |_| true); + self.gliding = None; + self.paused = None; } /// Note whether its picture is read as of `now`: while its scene is not @@ -595,17 +605,49 @@ impl Placer { } let target = self.target(saved, &slots); - // Another target with no move, as a resize gives, shows at once, even - // part way along a glide. - if self - .aimed - .is_some_and(|(aimed, moves)| aimed != target && moves == self.moves) + // Taken in hand part way along a glide, as a crop started then is, it + // stops where it is drawn, so it stays under the pointer; let go, it + // glides on from there. + let gliding = self.gliding.is_some_and(|until| now < until); + if self.grabbed && gliding && self.paused.is_none() { + self.paused = Some(self.placement.rect); + } + if !self.grabbed + && let Some(paused) = self.paused.take() { + let at = Rect { + width: target.width, + height: target.height, + ..paused + }; self.glide = Glide::new(self.glides, |_| true); + self.glide.show(self.moves, &[shown(at)], now); + self.moves += 1; + self.gliding = Some(now.saturating_add(self.glides)); } - self.aimed = Some((target, self.moves)); - self.glide.show(self.moves, &[shown(target)], now); - let rect = self.glide.placed()[0].rect; + let rect = match self.paused { + Some(paused) => { + self.aimed = Some((target, self.moves)); + Rect { + width: target.width, + height: target.height, + ..paused + } + } + None => { + // Another target with no move, as a resize gives, shows at + // once, even part way along a glide. + if self + .aimed + .is_some_and(|(aimed, moves)| aimed != target && moves == self.moves) + { + self.glide = Glide::new(self.glides, |_| true); + } + self.aimed = Some((target, self.moves)); + self.glide.show(self.moves, &[shown(target)], now); + self.glide.placed()[0].rect + } + }; self.placement.rect = rect; self.placement.slot = match self.at { At::Slot(slot) => Some(slot), @@ -697,6 +739,7 @@ impl Placer { self.glide.show(self.moves, &[shown(self.placement.rect)], now); } self.moves += 1; + self.gliding = Some(now.saturating_add(keep.glide)); } } @@ -1116,6 +1159,37 @@ mod tests { let _ = now; } + /// Taken in hand part way along a glide, as a crop started then is, it + /// stops where it is drawn; let go, it glides on from there to its slot. + #[test] + fn a_glide_pauses_while_in_hand() { + let start = Instant::now(); + let mut placer = Placer::new(start); + let saved = camera(); + let now = run(&mut placer, saved, start, (0..5).map(|_| read(MOVING, game))); + assert_eq!(placer.placement().slot, Some(Slot::TopLeft)); + let moved = now.saturating_sub(INTERVAL); + let glide = KeepClear::default().glide; + let to = Slot::TopLeft.rect(288.0, 288.0, CANVAS).unwrap(); + + let half = moved.saturating_add(glide / 2); + let at = placer.place(saved, &KeepClear::default(), CANVAS, half); + assert!(at.x < saved.x && at.x > to.x, "on its way: {at:?}"); + placer.grab(true); + for later in [half, half.saturating_add(glide), half.saturating_add(glide * 4)] { + let held = placer.place(saved, &KeepClear::default(), CANVAS, later); + assert_eq!(held, at, "in hand, it stays where it is drawn"); + } + + placer.grab(false); + let released = half.saturating_add(glide * 4); + assert_eq!(placer.place(saved, &KeepClear::default(), CANVAS, released), at); + let on = placer.place(saved, &KeepClear::default(), CANVAS, released.saturating_add(glide / 2)); + assert!(on.x < at.x && on.x > to.x, "it glides on: {on:?}"); + let landed = placer.place(saved, &KeepClear::default(), CANVAS, released.saturating_add(glide)); + assert_eq!(landed, to); + } + /// A resize part way along a glide takes its new size at once, in the /// slot it was gliding to. #[test] From 6a538cea8c9242c74bf44a7f8a45b2812cf08675 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Tue, 17 Nov 2026 04:36:02 -0800 Subject: [PATCH 20/25] feat: an undo of a move by hand puts back where a layer keeping clear was A move by hand remembers where the scene file put the layer and where it was meant to be, such as the corner it had glided to. An undo back to that saved rect puts that place back at once instead of holding there, so the undo shows what the streamer saw before the move. Every other undo, and every redo or reload, still holds. Co-Authored-By: Claude Opus 5.5 --- README.md | 14 +++-- rs/moq-scene/src/compositor.rs | 13 ++++ rs/moq-scene/src/place.rs | 106 +++++++++++++++++++++++++++++++- rs/moq-studio/src/engine.rs | 107 +++++++++++++++++++++++++-------- 4 files changed, 209 insertions(+), 31 deletions(-) diff --git a/README.md b/README.md index 66b8edf7..3dac8cf3 100644 --- a/README.md +++ b/README.md @@ -733,12 +733,14 @@ While it is selected, BUILD shows what it saw: what matters glowing, tagged **MOVING**, **TEXT**, or **HUD**, the places it may go, dashed, and where it last moved from, with what it left there and an arrow to where it went. Drag it, nudge it, or type its X or Y, and it stays where it was put until the -content changes, as it does where an undo, a redo, or a reload of the scene -file moves it; a resize keeps it free to move. Switched off, it stays where -it is drawn. Only a scene's layer set -free of its [slots](#slots-and-roles) keeps out of the way, and not one -showing a source [published independently](#published-independently), which -viewers place themselves; putting one in a slot switches it off. +content changes, as it does where a redo or a reload of the scene file +moves it, or an undo moves it anywhere but back before such a move. Undo +that move and it goes back to where it was, such as the corner it had +glided to. A resize keeps it free to move. Switched off, it stays where it +is drawn. Only a scene's layer set free of its [slots](#slots-and-roles) +keeps out of the way, and not one showing a source +[published independently](#published-independently), which viewers place +themselves; putting one in a slot switches it off. ### Audio scenes diff --git a/rs/moq-scene/src/compositor.rs b/rs/moq-scene/src/compositor.rs index eada7a33..9e52f3de 100644 --- a/rs/moq-scene/src/compositor.rs +++ b/rs/moq-scene/src/compositor.rs @@ -577,6 +577,19 @@ impl Compositor { } } + /// 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, + /// 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.keepers.get_mut(&(scene.to_string(), index)) + && keeper.source == source + { + keeper.placer.undone(saved, now); + } + } + /// Keep the scenes `outputs` names as outputs from now on, each with /// whether the next [`render`](Self::render) draws it, as it does while an /// output reads it. Each plays its keyframes from the first render after diff --git a/rs/moq-scene/src/place.rs b/rs/moq-scene/src/place.rs index b2b47ad1..347023f6 100644 --- a/rs/moq-scene/src/place.rs +++ b/rs/moq-scene/src/place.rs @@ -446,6 +446,18 @@ enum At { Slot(Slot), } +/// What a move by hand held an item from, so an undo back there can put it +/// back. +#[derive(Clone, Copy, Debug, PartialEq)] +struct Before { + /// Where its scene file put it. + saved: Rect, + /// Where it was meant to be, such as the slot it had glided to. + at: At, + /// Whether it was looking before choosing. + looking: bool, +} + /// Chooses where one item keeping clear goes, from what reads of the picture /// under it show. pub(crate) struct Placer { @@ -482,6 +494,10 @@ pub(crate) struct Placer { /// glides on from there. paused: Option, placement: Placement, + /// Where its scene file put it as of the last [`place`](Self::place). + saved: Option, + /// What the move by hand that holds it, or last held it, held it from. + before: Option, /// What [`Sight::generation`] and settings the heat was drawn from. heated: Option<(u64, KeepClear)>, } @@ -517,6 +533,8 @@ impl Placer { slots: Vec::new(), heat: Heat::default(), }, + saved: None, + before: None, heated: None, } } @@ -541,8 +559,18 @@ impl Placer { /// Moved by hand, such as dragged or nudged: it stays where the scene /// file has it until the content under it changes, and a choice it was /// about to make is dropped. A resize alone is no move: it keeps its - /// place. + /// place. The first move of a hold remembers where it was, for + /// [`undone`](Self::undone). pub fn hold(&mut self) { + if self.at != At::Held + && let Some(saved) = self.saved + { + self.before = Some(Before { + saved, + at: self.at, + looking: self.looking.is_some(), + }); + } self.at = At::Held; self.looking = None; self.worst = None; @@ -551,6 +579,30 @@ impl Placer { self.paused = None; } + /// Moved by an undo, saved at `saved` as of `now`: back where its scene + /// file put it before the move by hand that held it, it goes back to + /// where it was meant to be then, such as the slot it had glided to, so + /// the undo puts back what the streamer saw. Anywhere else, it holds, as + /// after a move by hand. + pub fn undone(&mut self, saved: Rect, now: Instant) { + match self.before.take() { + Some(before) if before.saved == saved => { + self.at = before.at; + self.looking = before.looking.then_some(now); + self.worst = None; + self.glide = Glide::new(self.glides, |_| true); + self.gliding = None; + self.paused = None; + } + before => { + self.hold(); + // What it was held from is still what an undo further back + // returns to. + self.before = before; + } + } + } + /// Note whether its picture is read as of `now`: while its scene is not /// drawn or the item is hidden it sees nothing new, so it neither /// chooses nor counts its place the worst, and it looks again once it is @@ -585,6 +637,7 @@ impl Placer { /// Where to draw the item at `now`, saved at `saved` and keeping clear as /// `keep` says on `canvas`. pub fn place(&mut self, saved: Rect, keep: &KeepClear, canvas: Canvas, now: Instant) -> Rect { + self.saved = Some(saved); let slots: Vec<(Slot, Rect)> = Slot::ALL .into_iter() .filter_map(|slot| Some((slot, slot.rect(saved.width, saved.height, canvas)?))) @@ -1328,6 +1381,57 @@ mod tests { let _ = now; } + /// An undo back to where it was saved before a move by hand puts back + /// where it was meant to be then, the slot it had glided to, at once, + /// though moves since held it; a redo holds it again. An undo to anywhere + /// else holds, as does one with no move by hand to undo. + #[test] + fn an_undo_of_a_move_by_hand_puts_back_its_place() { + let start = Instant::now(); + let mut placer = Placer::new(start); + let saved = camera(); + let keep = KeepClear::default(); + let now = run(&mut placer, saved, start, (0..6).map(|_| read(MOVING, game))); + let now = now.saturating_add(keep.glide); + let to = Slot::TopLeft.rect(288.0, 288.0, CANVAS).unwrap(); + assert_eq!(placer.place(saved, &keep, CANVAS, now), to); + + // Dragged over the minimap, then on, a move each. + let first = Rect { x: 1000.0, ..saved }; + let second = Rect { x: 1600.0, ..saved }; + for dragged in [first, second] { + placer.hold(); + assert_eq!(placer.place(dragged, &keep, CANVAS, now), dragged); + } + let now = run(&mut placer, second, now, (0..8).map(|_| read(MOVING, game))); + + placer.undone(first, now); + assert_eq!( + placer.place(first, &keep, CANVAS, now), + first, + "back one move, it holds" + ); + assert!(placer.placement().held); + placer.undone(saved, now); + assert_eq!(placer.place(saved, &keep, CANVAS, now), to, "back in its slot, at once"); + let placement = placer.placement(); + assert_eq!((placement.slot, placement.held), (Some(Slot::TopLeft), false)); + let now = run(&mut placer, saved, now, (0..40).map(|_| read(MOVING, game))); + assert_eq!(placer.placement().rect, to, "it stays as the game plays on"); + + // Redone, it holds; undone again, it is back. + placer.hold(); + assert_eq!(placer.place(first, &keep, CANVAS, now), first); + assert!(placer.placement().held); + placer.undone(saved, now); + assert_eq!(placer.place(saved, &keep, CANVAS, now), to); + + // An undo of an edit that held nothing holds. + placer.undone(first, now); + assert_eq!(placer.place(first, &keep, CANVAS, now), first); + assert!(placer.placement().held); + } + /// A rect saved elsewhere is no move by hand unless the caller says so, /// as a resize from the top left saves one: it stays in its corner. #[test] diff --git a/rs/moq-studio/src/engine.rs b/rs/moq-studio/src/engine.rs index f4b085f4..2f122398 100644 --- a/rs/moq-studio/src/engine.rs +++ b/rs/moq-studio/src/engine.rs @@ -228,18 +228,34 @@ impl State { }; let moved = moved(&self.collection, &collection); self.adopt(collection, &made)?; - self.hold(&moved); + match position < from { + true => self.undone(&moved), + false => self.hold(&moved), + } self.history = history; self.edited(); Ok(()) } /// Note each layer keeping clear in `moved`, as [`moved`] lists them, as - /// moved by hand: an undo, a redo, or a reload put it elsewhere, so it - /// stays where the scene file has it until the content under it changes. - fn hold(&mut self, moved: &[(String, usize, String)]) { - for (scene, index, source) in moved { - self.compositor.hold(scene, *index, source); + /// moved by hand: a redo or a reload put it elsewhere, so it stays where + /// the scene file has it until the content under it changes. + fn hold(&mut self, moved: &[Moved]) { + for moved in moved { + self.compositor.hold(&moved.scene, moved.index, &moved.source); + } + } + + /// Note each layer keeping clear in `moved`, as [`moved`] lists them, as + /// put back by an undo: one back where it was saved before a move by hand + /// held it goes back to where it was then, such as the slot it had + /// glided to, so the undo puts back what the streamer saw; any other + /// holds, as [`hold`](Self::hold) says. + 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); } } @@ -635,11 +651,22 @@ impl autosave::Document for State { } } -/// Each scene item keeping clear in `after` that `before` saved elsewhere, -/// as its scene, index, and source: the same scene's item at the same index -/// showing the same source, at another x or y. Its keeper is still under -/// that place, as the compositor follows items only as it renders. -fn moved(before: &Collection, after: &Collection) -> Vec<(String, usize, String)> { +/// A scene item keeping clear that an edit saved elsewhere, as [`moved`] +/// finds it. +#[derive(Clone, Debug, PartialEq)] +struct Moved { + scene: String, + index: usize, + source: String, + /// Where it is saved now. + rect: moq_scene::Rect, +} + +/// Each scene item keeping clear in `after` that `before` saved elsewhere: +/// the same scene's item at the same index showing the same source, at +/// another x or y. Its keeper is still under that place, as the compositor +/// follows items only as it renders. +fn moved(before: &Collection, after: &Collection) -> Vec { let mut moved = Vec::new(); for scene in &after.scenes { let Some(was) = before.scene(&scene.name) else { continue }; @@ -649,7 +676,12 @@ fn moved(before: &Collection, after: &Collection) -> Vec<(String, usize, String) && old.source == item.source && (old.rect.x, old.rect.y) != (item.rect.x, item.rect.y) { - moved.push((scene.name.clone(), index, item.source.clone())); + moved.push(Moved { + scene: scene.name.clone(), + index, + source: item.source.clone(), + rect: item.rect, + }); } } } @@ -3396,15 +3428,23 @@ mod tests { items[3].source = "blue".into(); items[3].rect.x = 300.0; items[4].rect.x = 300.0; - assert_eq!(moved(&before, &after), [(main, 1, "red".to_string())]); + let rect = moq_scene::Rect { x: 300.0, ..rect }; + let moved = Moved { + scene: main, + index: 1, + source: "red".into(), + rect, + }; + assert_eq!(super::moved(&before, &after), [moved]); } - /// An undo that puts a layer keeping clear back where it was saved holds - /// it there, as a move by hand does; the edit it undid, made in the - /// collection rather than by a gesture, did not. + /// An undo of a move by hand puts a layer keeping clear back as it was + /// before the move, and a redo holds it again. An undo of an edit made + /// in the collection rather than by a gesture, which held nothing, holds + /// it where it puts it. #[tokio::test(flavor = "multi_thread")] #[ignore = "needs a Vulkan device; run by just render-sw"] - async fn an_undo_holds_a_layer_keeping_clear() { + async fn an_undo_puts_back_a_layer_keeping_clear() { let dir = tempfile::tempdir().unwrap(); let mut loaded = red_canvas(); let rect = moq_scene::Rect { @@ -3446,22 +3486,41 @@ mod tests { .await .expect("placed where it is saved"); - let moved = moq_scene::Rect { x: 200.0, ..rect }; - { + 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"); + } let collection = state.collection(); let item = collection.scenes[0].items[1].clone(); let mut draft = collection.draft("Move `red`"); let layer = moq_scene::Layer::scene(main.as_str()); - draft - .set_item(&layer, 1, moq_scene::Item { rect: moved, ..item }) - .unwrap(); + draft.set_item(&layer, 1, moq_scene::Item { rect: to, ..item }).unwrap(); state.commit(draft, None).unwrap(); - } + }; + + let moved = moq_scene::Rect { x: 200.0, ..rect }; + commit(moved, true); + kio::clock::timeout(TIMEOUT, placed(moved, true)) + .await + .expect("a move by hand holds it"); + engine.state.lock().unwrap().undo().unwrap(); + kio::clock::timeout(TIMEOUT, placed(rect, false)) + .await + .expect("the undo puts it back as it was"); + engine.state.lock().unwrap().redo().unwrap(); + kio::clock::timeout(TIMEOUT, placed(moved, true)) + .await + .expect("the redo holds it"); + engine.state.lock().unwrap().undo().unwrap(); + kio::clock::timeout(TIMEOUT, placed(rect, false)) + .await + .expect("undone again, it is back"); + + commit(moved, false); kio::clock::timeout(TIMEOUT, placed(moved, false)) .await .expect("an edit is no move by hand"); - engine.state.lock().unwrap().undo().unwrap(); kio::clock::timeout(TIMEOUT, placed(rect, true)) .await From 67d644665a1546259b1198b047a06faad4047f14 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Tue, 17 Nov 2026 04:41:53 -0800 Subject: [PATCH 21/25] feat: an undo of switching keep-clear off puts the layer back where it was A layer that stops keeping clear parks its placer, held, for as long as it is there. An undo that turns keeping clear back on, saving the rect it had before, revives it, so it goes back to the slot it had glided to rather than starting over from its saved rect. Co-Authored-By: Claude Opus 5.5 --- README.md | 5 +- rs/moq-scene/src/compositor.rs | 124 +++++++++++++++++++++++++++------ rs/moq-studio/src/engine.rs | 4 +- 3 files changed, 108 insertions(+), 25 deletions(-) diff --git a/README.md b/README.md index 3dac8cf3..eb98ca05 100644 --- a/README.md +++ b/README.md @@ -737,8 +737,9 @@ content changes, as it does where a redo or a reload of the scene file moves it, or an undo moves it anywhere but back before such a move. Undo that move and it goes back to where it was, such as the corner it had glided to. A resize keeps it free to move. Switched off, it stays where it -is drawn. Only a scene's layer set free of its [slots](#slots-and-roles) -keeps out of the way, and not one showing a source +is drawn, and undoing that puts it back keeping clear where it was. Only a +scene's layer set free of its [slots](#slots-and-roles) keeps out of the +way, and not one showing a source [published independently](#published-independently), which viewers place themselves; putting one in a slot switches it off. diff --git a/rs/moq-scene/src/compositor.rs b/rs/moq-scene/src/compositor.rs index 9e52f3de..9aba6087 100644 --- a/rs/moq-scene/src/compositor.rs +++ b/rs/moq-scene/src/compositor.rs @@ -116,6 +116,9 @@ pub struct Compositor { switch: Option, /// Each scene item keeping clear, by its scene and place in it. 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)>, @@ -141,6 +144,16 @@ 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's items in slots, arranged. struct Reflow { /// Its items where its arrangement puts them, in order. @@ -459,6 +472,7 @@ impl Compositor { layered: false, switch: None, keepers: HashMap::new(), + parked: HashMap::new(), grabbed: None, reducer: None, reflows: HashMap::new(), @@ -580,10 +594,23 @@ impl Compositor { /// 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, - /// 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. + /// 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.keepers.get_mut(&(scene.to_string(), index)) + let key = (scene.to_string(), index); + if !self.keepers.contains_key(&key) && self.parked.get(&key).is_some_and(|parked| parked.source == source) { + let parked = self.parked.remove(&key).expect("found above"); + let keeper = Keeper { + source: parked.source, + rect: saved, + watched: true, + placer: parked.placer, + look: Look::new(&self.device, &self.queue), + }; + self.keepers.insert(key.clone(), keeper); + } + if let Some(keeper) = self.keepers.get_mut(&key) && keeper.source == source { keeper.placer.undone(saved, now); @@ -1174,12 +1201,31 @@ 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 is gone is forgotten. + /// 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. fn place<'a>(&mut self, collection: &'a Collection, now: Instant) -> Cow<'a, Collection> { let mut staged = Cow::Borrowed(collection); - let mut kept = follow(std::mem::take(&mut self.keepers), collection, |keeper| { + 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 keepers = HashMap::new(); for (number, scene) in collection.scenes.iter().enumerate() { let canvas = scene.canvas(collection.canvas); @@ -1215,6 +1261,11 @@ impl Compositor { } 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; + } + } } self.keepers = keepers; staged @@ -2448,23 +2499,30 @@ impl Target { } } -/// `old`, the keepers, each under where its item keeping clear now is, so it -/// goes on from where it was placed. 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 +/// 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. The rest are left out. +/// longer there, as a rename leaves it. fn follow( - mut old: HashMap<(String, usize), T>, + mut old: Placed, collection: &Collection, + keeps: impl Fn(&Item) -> bool, shows: impl Fn(&T) -> (&str, Rect), -) -> HashMap<(String, usize), T> { +) -> (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 item.keep_clear.is_some() { + if keeps(item) { missing.push(((scene.name.clone(), index), item)); } } @@ -2492,7 +2550,7 @@ fn follow( false }); } - kept + (kept, old) } #[cfg(test)] @@ -2729,7 +2787,9 @@ mod tests { /// The compositor reads the picture under a camera keeping clear on the /// GPU, sees the block moving under it, and glides it to the corner that - /// covers nothing, on program and in preview alike. + /// covers nothing, on program and in preview alike. It stays there as a + /// layer is added under it, and as an undo switches keeping clear back + /// on. #[tokio::test] #[ignore = "needs a Vulkan device; run by just render-sw"] async fn a_camera_keeping_clear_glides_off_what_moves() { @@ -2799,6 +2859,25 @@ mod tests { 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, it stays where it is drawn; + // an undo of that puts it back in its slot, keeping clear. + 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()); + let item = &mut studio.collection.scenes[0].items[camera]; + item.keep_clear = keep; + item.rect = saved; + studio.compositor.undone("busy", camera, "camera", saved, after); + let after = after.saturating_add(Duration::from_millis(100)); + studio.render(after); + let placement = studio.compositor.placement("busy", camera, "camera").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.render(after.saturating_add(Duration::from_millis(100))); @@ -2833,6 +2912,7 @@ mod tests { 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")), @@ -2842,27 +2922,29 @@ mod tests { }; collection.scenes[0].items.insert(0, Item::new("camera", rect(90.0))); - keepers = follow(keepers, &collection, shows); + 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, shows); + 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, shows); + keepers = follow(keepers, &collection, keeping_clear, shows).0; assert_eq!(which(&keepers, "renamed", 1), Some("first")); assert_eq!(which(&keepers, "renamed", 2), Some("second")); - // One that stops keeping clear has no keeper. + // One that stops keeping clear has no keeper; its is left over. collection.scenes[0].items[1].keep_clear = None; - keepers = follow(keepers, &collection, shows); + 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")); } /// A source published independently is left out of the program and drawn diff --git a/rs/moq-studio/src/engine.rs b/rs/moq-studio/src/engine.rs index 2f122398..444d1274 100644 --- a/rs/moq-studio/src/engine.rs +++ b/rs/moq-studio/src/engine.rs @@ -248,8 +248,8 @@ impl State { /// Note each layer keeping clear in `moved`, as [`moved`] lists them, as /// put back by an undo: one back where it was saved before a move by hand - /// held it goes back to where it was then, such as the slot it had - /// glided to, so the undo puts back what the streamer saw; any other + /// held it, or before keeping clear was switched off, goes back to where + /// it was then, such as the slot it had glided to, so the undo puts back what the streamer saw; any other /// holds, as [`hold`](Self::hold) says. fn undone(&mut self, moved: &[Moved]) { let now = kio::clock::now(); From 30c0f422ceb27ff6e06052d7fbed531e474df5d9 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Tue, 17 Nov 2026 04:52:22 -0800 Subject: [PATCH 22/25] fix: an undo puts a layer keeping clear back whenever it renders - Switching keeping clear off in the inspector holds the layer as it was, so an undo before the next render still finds where it was. - An undo that switches keeping clear back on tells the compositor even when the rect is unchanged, so a parked placer that was held stays held. - Undo and redo set the placer's saved rect at once, so an undo, redo, and undo between renders, as on a slow canvas, still puts the slot back. - item-identity: an undo of Keep always on top, whose layer leaves its scene, waits on the runtime identity. Co-Authored-By: Claude Opus 5.5 --- quest/m1/item-identity.md | 9 ++++-- rs/moq-scene/src/compositor.rs | 48 +++++++++++++++++++++++++++++-- rs/moq-scene/src/place.rs | 20 +++++++++++++ rs/moq-studio/src/engine.rs | 30 ++++++++++--------- rs/moq-studio/src/ui/inspector.rs | 16 +++++++++-- 5 files changed, 102 insertions(+), 21 deletions(-) diff --git a/quest/m1/item-identity.md b/quest/m1/item-identity.md index 5eb8b84c..e7d8e2e3 100644 --- a/quest/m1/item-identity.md +++ b/quest/m1/item-identity.md @@ -31,9 +31,14 @@ for the same reason. - **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, and a reload of an - unchanged file. + 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)): diff --git a/rs/moq-scene/src/compositor.rs b/rs/moq-scene/src/compositor.rs index 9aba6087..cdbfa703 100644 --- a/rs/moq-scene/src/compositor.rs +++ b/rs/moq-scene/src/compositor.rs @@ -591,6 +591,17 @@ impl Compositor { } } + /// 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.keepers.get_mut(&(scene.to_string(), index)) + && keeper.source == source + { + 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, @@ -2859,8 +2870,24 @@ mod tests { 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, it stays where it is drawn; - // an undo of that puts it back in its slot, keeping clear. + // 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"); + 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); + let after = after.saturating_add(Duration::from_millis(100)); + studio.render(after); + let placement = studio.compositor.placement("busy", camera, "camera").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"); let item = &mut studio.collection.scenes[0].items[camera]; let keep = item.keep_clear.take(); item.rect = to; @@ -2880,10 +2907,25 @@ mod tests { // Moved by hand, it stays where the scene file puts it. studio.compositor.hold("busy", camera, "camera"); + 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(); assert!(placement.held); - assert_eq!(placement.rect, saved); + 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.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); + let after = after.saturating_add(Duration::from_millis(100)); + studio.render(after); + let placement = studio.compositor.placement("busy", camera, "camera").unwrap(); + assert_eq!((placement.rect, placement.held), (dragged, true), "still held"); }) .await; } diff --git a/rs/moq-scene/src/place.rs b/rs/moq-scene/src/place.rs index 347023f6..d97f5185 100644 --- a/rs/moq-scene/src/place.rs +++ b/rs/moq-scene/src/place.rs @@ -585,6 +585,8 @@ impl Placer { /// the undo puts back what the streamer saw. Anywhere else, it holds, as /// after a move by hand. pub fn undone(&mut self, saved: Rect, now: Instant) { + // What another undo or a redo before the next place starts from. + self.saved = Some(saved); match self.before.take() { Some(before) if before.saved == saved => { self.at = before.at; @@ -603,6 +605,15 @@ impl Placer { } } + /// Moved by an edit already made, such as a redo or a reload, that saved + /// it at `saved`: it holds, as [`hold`](Self::hold) says, and another + /// undo or redo before the next [`place`](Self::place) starts from + /// there. + pub fn redone(&mut self, saved: Rect) { + self.hold(); + self.saved = Some(saved); + } + /// Note whether its picture is read as of `now`: while its scene is not /// drawn or the item is hidden it sees nothing new, so it neither /// chooses nor counts its place the worst, and it looks again once it is @@ -1426,6 +1437,15 @@ mod tests { placer.undone(saved, now); assert_eq!(placer.place(saved, &keep, CANVAS, now), to); + // Redone and undone twice before it is placed again, as on a slow + // canvas, it is still back. + for _ in 0..2 { + placer.redone(first); + placer.undone(saved, now); + } + assert_eq!(placer.place(saved, &keep, CANVAS, now), to); + assert!(!placer.placement().held); + // An undo of an edit that held nothing holds. placer.undone(first, now); assert_eq!(placer.place(first, &keep, CANVAS, now), first); diff --git a/rs/moq-studio/src/engine.rs b/rs/moq-studio/src/engine.rs index 444d1274..f1ad5490 100644 --- a/rs/moq-studio/src/engine.rs +++ b/rs/moq-studio/src/engine.rs @@ -242,7 +242,8 @@ 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.hold(&moved.scene, moved.index, &moved.source); + self.compositor + .redone(&moved.scene, moved.index, &moved.source, moved.rect); } } @@ -662,10 +663,11 @@ struct Moved { rect: moq_scene::Rect, } -/// Each scene item keeping clear in `after` that `before` saved elsewhere: -/// the same scene's item at the same index showing the same source, at -/// another x or y. Its keeper is still under that place, as the compositor -/// follows items only as it renders. +/// 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. Its keeper is +/// still under that place, as the compositor follows items only as it +/// renders. fn moved(before: &Collection, after: &Collection) -> Vec { let mut moved = Vec::new(); for scene in &after.scenes { @@ -674,7 +676,7 @@ fn moved(before: &Collection, after: &Collection) -> Vec { let Some(old) = was.items.get(index) else { continue }; if item.keep_clear.is_some() && old.source == item.source - && (old.rect.x, old.rect.y) != (item.rect.x, item.rect.y) + && (old.keep_clear.is_none() || (old.rect.x, old.rect.y) != (item.rect.x, item.rect.y)) { moved.push(Moved { scene: scene.name.clone(), @@ -3401,8 +3403,8 @@ mod tests { } /// A layer keeping clear that an undo, a redo, or a reload saved - /// elsewhere is listed as moved by hand; one only resized, another - /// source, or one that does not keep clear is not. + /// 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. #[test] fn an_undo_or_a_reload_moves_by_hand() { let mut before = red_canvas().collection; @@ -3420,6 +3422,7 @@ mod tests { .items .extend([keeping.clone(), keeping.clone(), 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 mut after = before.clone(); let items = &mut after.scenes[0].items; @@ -3428,14 +3431,15 @@ mod tests { items[3].source = "blue".into(); items[3].rect.x = 300.0; items[4].rect.x = 300.0; - let rect = moq_scene::Rect { x: 300.0, ..rect }; - let moved = Moved { - scene: main, - index: 1, + items[5].keep_clear = Some(moq_scene::KeepClear::default()); + let moved = |index, rect| Moved { + scene: main.clone(), + index, source: "red".into(), rect, }; - assert_eq!(super::moved(&before, &after), [moved]); + let elsewhere = moq_scene::Rect { x: 300.0, ..rect }; + assert_eq!(super::moved(&before, &after), [moved(1, elsewhere), moved(5, rect)]); } /// An undo of a move by hand puts a layer keeping clear back as it was diff --git a/rs/moq-studio/src/ui/inspector.rs b/rs/moq-studio/src/ui/inspector.rs index 425df3cf..a741a714 100644 --- a/rs/moq-studio/src/ui/inspector.rs +++ b/rs/moq-studio/src/ui/inspector.rs @@ -93,8 +93,10 @@ impl Panels { } let name = item.source.clone(); let mut asked = None; - // Whether the edit asked for is a move by hand. + // Whether the edit asked for is a move by hand, or switches keeping + // clear off, which leaves it where it is drawn as a move would. let mut moved = false; + let kept = item.keep_clear; section(ui, "Place"); if picked.layer.scene.is_some() { @@ -230,7 +232,10 @@ impl Panels { // Switched off, it stays where it is drawn, as keeping it always // on top does, rather than going back over what it moved off. let rect = match (keep_clear, placement) { - (None, Some(placement)) => placement.rect, + (None, Some(placement)) => { + moved = true; + placement.rect + } _ => item.rect, }; asked = Some(Asked::Item( @@ -531,7 +536,12 @@ impl Panels { let result = match asked { Asked::Item(item, label, gesture) => { if moved { - keep::hold(&mut state, &picked.layer, picked.index, &item); + // Held as it was before the edit, so an undo puts it back. + let was = Item { + keep_clear: kept, + ..item.clone() + }; + keep::hold(&mut state, &picked.layer, picked.index, &was); } edit(&mut state, label, gesture, |draft| { draft.set_item(&picked.layer, picked.index, item) From 94ceaeb25f19dc3ed610494727cb70a0b5fdf099 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Tue, 17 Nov 2026 05:07:51 -0800 Subject: [PATCH 23/25] fix: nudges between renders add up, and a drag keeps the picture still - A move by hand marks the placement held at once, and a held layer is drawn where it is saved, so each nudge before the next render starts from the last one rather than the last rendered place. - The keep-clear legend's room under the picture holds for a drag, so a drag that selects a layer keeping clear does not resize the picture under the pointer. Co-Authored-By: Claude Opus 5.5 --- rs/moq-scene/src/place.rs | 42 ++++++++++++++++++++++++++++++- rs/moq-studio/src/ui.rs | 5 ++++ rs/moq-studio/src/ui/build.rs | 7 +++++- rs/moq-studio/src/ui/inspector.rs | 4 +-- rs/moq-studio/src/ui/keep.rs | 9 ++++--- 5 files changed, 59 insertions(+), 8 deletions(-) diff --git a/rs/moq-scene/src/place.rs b/rs/moq-scene/src/place.rs index d97f5185..d7f078c7 100644 --- a/rs/moq-scene/src/place.rs +++ b/rs/moq-scene/src/place.rs @@ -214,7 +214,7 @@ pub struct Placement { /// was put. pub slot: Option, /// Whether it stays where the streamer moved it, until the content under - /// it changes. + /// it changes. A move by hand says so at once, before the next render. pub held: bool, /// Where it last moved from, and what it left there. pub left: Option, @@ -224,6 +224,18 @@ pub struct Placement { pub heat: Heat, } +impl Placement { + /// Where the item is drawn, saved at `saved`: where it was placed, or, + /// held, where it is saved, which an edit since the last render, such as + /// a nudge, may have moved. + pub fn drawn(&self, saved: Rect) -> Rect { + match self.held { + true => saved, + false => self.rect, + } + } +} + /// Where an item moved from. #[derive(Clone, Copy, Debug, PartialEq)] pub struct Left { @@ -572,6 +584,8 @@ impl Placer { }); } self.at = At::Held; + self.placement.held = true; + self.placement.slot = None; self.looking = None; self.worst = None; self.glide = Glide::new(self.glides, |_| true); @@ -590,6 +604,11 @@ impl Placer { match self.before.take() { Some(before) if before.saved == saved => { self.at = before.at; + self.placement.held = false; + self.placement.slot = match before.at { + At::Slot(slot) => Some(slot), + _ => None, + }; self.looking = before.looking.then_some(now); self.worst = None; self.glide = Glide::new(self.glides, |_| true); @@ -1392,6 +1411,27 @@ mod tests { let _ = now; } + /// A move by hand says it is held at once, before the next place, so + /// moves that come faster than renders, as nudges on a slow canvas do, + /// each start from where the last saved it; an undo says it is not. + #[test] + fn a_move_by_hand_is_held_at_once() { + let start = Instant::now(); + let mut placer = Placer::new(start); + let saved = camera(); + let now = run(&mut placer, saved, start, (0..6).map(|_| read(MOVING, game))); + assert_eq!(placer.placement().slot, Some(Slot::TopLeft)); + let nudged = Rect { x: 20.0, ..saved }; + placer.hold(); + let placement = placer.placement(); + assert_eq!((placement.held, placement.slot), (true, None)); + assert_eq!(placement.drawn(nudged), nudged); + placer.undone(saved, now); + let placement = placer.placement(); + assert_eq!((placement.held, placement.slot), (false, Some(Slot::TopLeft))); + assert_eq!(placement.drawn(saved), placement.rect); + } + /// An undo back to where it was saved before a move by hand puts back /// where it was meant to be then, the slot it had glided to, at once, /// though moves since held it; a redo holds it again. An undo to anywhere diff --git a/rs/moq-studio/src/ui.rs b/rs/moq-studio/src/ui.rs index 99017568..8cdc8b3d 100644 --- a/rs/moq-studio/src/ui.rs +++ b/rs/moq-studio/src/ui.rs @@ -256,6 +256,7 @@ impl Studio { duration: Transition::default().duration().unwrap_or_default(), cut: STINGER_CUT, drag: None, + legend: false, renaming: None, title_needs: 0.0, renaming_audio: None, @@ -663,6 +664,10 @@ struct Panels { cut: Duration, /// The layer a drag on the BUILD page's picture holds. drag: Option, + /// Whether the BUILD page's picture leaves room for the keep-clear + /// legend under it, which a drag leaves as it found it, so the picture + /// under the pointer neither moves nor resizes mid-gesture. + legend: bool, /// The layer row being dragged to a new place, by its index. moving: Option, /// The scene being renamed, by index, and the name typed so far. diff --git a/rs/moq-studio/src/ui/build.rs b/rs/moq-studio/src/ui/build.rs index 93372bf7..e1e7ab57 100644 --- a/rs/moq-studio/src/ui/build.rs +++ b/rs/moq-studio/src/ui/build.rs @@ -47,7 +47,12 @@ impl Panels { room.min.y = self.off_air_header(ui, cued, room, snapshot.shape); shape = cued.shape(); } - let keeping = self.keeping_clear(); + // A drag that selects a layer keeping clear leaves the picture where + // it was until let go, so the pointer stays over what it moves. + if self.drag.is_none() { + self.legend = self.keeping_clear(); + } + let keeping = self.legend; if keeping { room.max.y -= keep::LEGEND; } diff --git a/rs/moq-studio/src/ui/inspector.rs b/rs/moq-studio/src/ui/inspector.rs index a741a714..4865f2ed 100644 --- a/rs/moq-studio/src/ui/inspector.rs +++ b/rs/moq-studio/src/ui/inspector.rs @@ -129,7 +129,7 @@ impl Panels { // Where the picture draws it: a layer keeping clear where it was // placed, which a move by hand starts from. let placement = keep::placement(&state, &picked.layer, picked.index, &item); - let mut rect = placement.map_or(item.rect, |placement| placement.rect); + let mut rect = placement.map_or(item.rect, |placement| placement.drawn(item.rect)); if item.slot.is_some() { ui.label( egui::RichText::new("Placed by the scene's arrangement; drag it onto another slot to swap them") @@ -234,7 +234,7 @@ impl Panels { let rect = match (keep_clear, placement) { (None, Some(placement)) => { moved = true; - placement.rect + placement.drawn(item.rect) } _ => item.rect, }; diff --git a/rs/moq-studio/src/ui/keep.rs b/rs/moq-studio/src/ui/keep.rs index f4bd2ba3..5081633f 100644 --- a/rs/moq-studio/src/ui/keep.rs +++ b/rs/moq-studio/src/ui/keep.rs @@ -38,7 +38,7 @@ pub(super) fn placement<'a>(state: &'a State, layer: &Layer, index: usize, item: pub(super) fn placed(state: &State, layer: &Layer, index: usize, item: &Item) -> Item { match placement(state, layer, index, item) { Some(placement) => Item { - rect: placement.rect, + rect: placement.drawn(item.rect), ..item.clone() }, None => item.clone(), @@ -50,7 +50,7 @@ pub(super) fn placed(state: &State, layer: &Layer, index: usize, item: &Item) -> /// did, so the resize leaves it free to keep clear. pub(super) fn resized(state: &State, layer: &Layer, index: usize, item: &Item, rect: Rect) -> Rect { match placement(state, layer, index, item) { - Some(placement) if placement.rect != item.rect => Rect { + Some(placement) if placement.drawn(item.rect) != item.rect => Rect { x: item.rect.x, y: item.rect.y, ..rect @@ -101,8 +101,9 @@ pub(super) fn drawn<'a>(state: &State, staged: Cow<'a, Collection>) -> Cow<'a, C }; // A scene staged one frame behind an edit may lack it. let staged = drawn.scenes.get(number).and_then(|staged| staged.items.get(index)); - if staged.is_some_and(|staged| staged.source == item.source && staged.rect != placement.rect) { - drawn.to_mut().scenes[number].items[index].rect = placement.rect; + let rect = placement.drawn(item.rect); + if staged.is_some_and(|staged| staged.source == item.source && staged.rect != rect) { + drawn.to_mut().scenes[number].items[index].rect = rect; } } } From 827f503baac592b2b6d89cad47316ec9c7b98e99 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Tue, 17 Nov 2026 05:18:53 -0800 Subject: [PATCH 24/25] quest: readback no longer waits on capture-health, which landed Co-Authored-By: Claude Opus 5.5 --- quest/m1/readback.md | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/quest/m1/readback.md b/quest/m1/readback.md index fb647ae9..85c14a2b 100644 --- a/quest/m1/readback.md +++ b/quest/m1/readback.md @@ -11,7 +11,8 @@ make of the tiles, and neither stalls a frame. ## Plan The two landed separately with the same pattern: a compute pass reducing a -picture to 16x16 tiles, at most every 250 ms, its result copied to a buffer +picture to a grid of tiles (64x36 for the probe, 32x18 for the look), at +most every 250 ms, its result copied to a buffer mapped with `map_async` and read on a later frame, a failed or late read dropped. @@ -29,7 +30,3 @@ dropped. Decided 2026-11-17 (maintainer, on [#194](https://github.com/moq-dev/studio/pull/194#issuecomment-6941200435)): ✅ one helper once both land (rejected: sharing in #194, before #192 lands). - -## Required - -- [A capture that went black says so](/quest/m1/capture-health.md) - lands `dark.rs`'s probe, the other reader From ad6568c998fb7f30b72f1bb744029fd45761b60b Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Tue, 17 Nov 2026 05:31:29 -0800 Subject: [PATCH 25/25] fix: a glide taken in hand stops where it was last drawn, however late Whether a glide was under way when a gesture takes the layer now comes from the last render, which drew it short of where it aimed, rather than from when the glide would land, so a grab whose first render comes after that, as on a slow canvas, still stops it under the pointer. Co-Authored-By: Claude Opus 5.5 --- rs/moq-scene/src/place.rs | 34 ++++++++++++++++++++++++---------- 1 file changed, 24 insertions(+), 10 deletions(-) diff --git a/rs/moq-scene/src/place.rs b/rs/moq-scene/src/place.rs index d7f078c7..432cfe42 100644 --- a/rs/moq-scene/src/place.rs +++ b/rs/moq-scene/src/place.rs @@ -499,8 +499,6 @@ pub(crate) struct Placer { /// Whether a gesture has it in hand, such as a drag: it chooses only once /// let go. grabbed: bool, - /// Until when the glide of its last choice runs. - gliding: Option, /// Where a glide under way stopped when a gesture took it in hand: it /// stays there, at the size it is meant to have, until let go, then /// glides on from there. @@ -535,7 +533,6 @@ impl Placer { aimed: None, watched: true, grabbed: false, - gliding: None, paused: None, placement: Placement { rect: nowhere, @@ -589,7 +586,7 @@ impl Placer { self.looking = None; self.worst = None; self.glide = Glide::new(self.glides, |_| true); - self.gliding = None; + self.aimed = None; self.paused = None; } @@ -612,7 +609,7 @@ impl Placer { self.looking = before.looking.then_some(now); self.worst = None; self.glide = Glide::new(self.glides, |_| true); - self.gliding = None; + self.aimed = None; self.paused = None; } before => { @@ -689,9 +686,9 @@ impl Placer { let target = self.target(saved, &slots); // Taken in hand part way along a glide, as a crop started then is, it - // stops where it is drawn, so it stays under the pointer; let go, it - // glides on from there. - let gliding = self.gliding.is_some_and(|until| now < until); + // stops where it was last drawn, so it stays under the pointer, however + // late the next render comes; let go, it glides on from there. + let gliding = self.aimed.is_some_and(|(aimed, _)| aimed != self.placement.rect); if self.grabbed && gliding && self.paused.is_none() { self.paused = Some(self.placement.rect); } @@ -706,7 +703,6 @@ impl Placer { self.glide = Glide::new(self.glides, |_| true); self.glide.show(self.moves, &[shown(at)], now); self.moves += 1; - self.gliding = Some(now.saturating_add(self.glides)); } let rect = match self.paused { Some(paused) => { @@ -822,7 +818,6 @@ impl Placer { self.glide.show(self.moves, &[shown(self.placement.rect)], now); } self.moves += 1; - self.gliding = Some(now.saturating_add(keep.glide)); } } @@ -1273,6 +1268,25 @@ mod tests { assert_eq!(landed, to); } + /// Taken in hand part way along a glide, as last drawn, it stops there + /// though the next render comes after the glide would have landed, as on + /// a slow canvas. + #[test] + fn a_glide_pauses_where_last_drawn() { + let start = Instant::now(); + let mut placer = Placer::new(start); + let saved = camera(); + let now = run(&mut placer, saved, start, (0..5).map(|_| read(MOVING, game))); + assert_eq!(placer.placement().slot, Some(Slot::TopLeft)); + let moved = now.saturating_sub(INTERVAL); + let glide = KeepClear::default().glide; + let half = moved.saturating_add(glide / 2); + let at = placer.place(saved, &KeepClear::default(), CANVAS, half); + placer.grab(true); + let late = half.saturating_add(glide * 2); + assert_eq!(placer.place(saved, &KeepClear::default(), CANVAS, late), at); + } + /// A resize part way along a glide takes its new size at once, in the /// slot it was gliding to. #[test]

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 literal 0 HcmV?d00001 From 4928053c281762077b867d1b0e4287a07737a96b Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Mon, 16 Nov 2026 21:28:20 -0800 Subject: [PATCH 05/25] chore: drop the PR body's views Co-Authored-By: Claude Opus 5.5 --- shots/build_keep_clear.webp | Bin 58420 -> 0 bytes shots/live_program.webp | Bin 33432 -> 0 bytes 2 files changed, 0 insertions(+), 0 deletions(-) delete mode 100644 shots/build_keep_clear.webp delete mode 100644 shots/live_program.webp diff --git a/shots/build_keep_clear.webp b/shots/build_keep_clear.webp deleted file mode 100644 index 6608864b2e379e652d0fcd616c08bb21aa5b4655..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 58420 zcmZU(b95(B(=8m^n%K5&+qNdQZ95a&$z+mDY}>YN+xdN&=Xvj4-@Uj0>UFx;Ij5_u zcGcc>l%>SQX%B#aG{l4z)fG7j3BT`e$iQ-dsq?`@K>2Oi()!Iee~bHy{gQYBZ2kCx zydvl@xX!!y4Co#P^gRv(8UcV!?+^1&ef_;G}Zwde7&!rd3uT_BcGb*6Fivmz> zhzR(~C-~&v{pfxleyYATs3TbSMg1E6-2Xs)&AS8a`Ko+49|Kwdo&bigviIgm|6PFi z>+-4nOWtv(!k5C6{hh%EU<|MTKzy%%{vN&GKInGwAMjGRWqI?z?LPFs^iTX;cnAMT zdzE-)xad9rocp_eUO$@vU_S-C|Mq^(e<}QCsP~ry=zZQldw(2v4|f7mzaHNUzE}W& z(e2;fKbAkI@4CK>c{Zg z^hfoL!HIxX_xIEHS-|@h!7~nE`y(%OdX3-YPodjzf|;nD$ZimBj}$2C~bwXF!o8$45E9$Jc)fw7D(9#$|y zG2Pq6{2o3s(-e++Q;)`RgOVGF4JkfR7>w&S=-{Icg7?|s5cgc1DUQ2dzj)dP`W;<=e>(?v4o05m$0(W)lZl=aOY)=T zy=I-qM%>8#s3(-}k1tD1hajsTkq$H{mGKwp2q72QsZaW`K*#V;(QP{JXynlOS0kju zH#?47)Gw?1z9k~@T7EWi=^~k@7jRCOqHzt)3%m_i@H|ZR{hdT+cuP6x^)r{_Q!Xk2ZwMLCoXC}AM6ef$Z# zW`QIk@azgfn&NsZ?>vmdsok$vuMx0Crj-vG0|i1oj_SSL3{sb!;D1|oNFv$P7uLPD z4%9nn(#3C!iq4sK@44Y*K08LdSh*fPg#QwAxk~7h_X9B~cdKsz^CpY+)+*cJr!gwf z^1#-=H0h4GIfU=NV=|J+MSih!=V2&tNgK~!E>J}vn#-5`jylPT3#1@Apo+eTld_}* zUw#yOyi87HVV3M&^@yO5H>4!I1Ztrvp>+AOj>mmLLj=%xRe|M?jD8sr!CAij{6IXA z-2#Gq9wq%uWRTbwGt0-aVN+2;F=SS(y8; zdg)jZY2@?mL`O7>#w%ze&XZ!JK@Jjq%jQV(O0J^wBcM_zqmwosCN4Qn1G)s4V;AZm zu`@lG#K>0cP+gjwa6b!Citzd0FdP8EN6+==Xas*>!2=KkGtr+(QL^C-?k)P2fu7ig zhv9eu0pHHjkyo(8(2W)G+<=aNN}oBZ#-*ku1N*3eGf3yvTd5{bARNlqByEvqF7Y&{ z<)cK)cJb}4H?cW5_Z<8PC|lZtciS78@}qGesI{SfsaBY+FjMznWbd~Pf&|Z8l!k|vcx7*%aW_a^{YKAxu2r(@ZpqRo9DP*>HOP-nQu=zj-Q(R6xE+HX_yh+% zBx7cN5@_&TjjG^y3ZQJ;6854z>{`aybXL)Ey$@Il=~E|}6EBuqDE2P|@m??}L-ttn zaWzK3gdEl9E+v!Ib(YN5ws6g$?gl&z06qPtAz(Pv*cJ}U)|ggBF@{{W@fpagFK>f` zrA8rM#^k>S>)0#W<#6%V65>rKCpZ@cGE#Wg@ri?=tmxzh7tGG{FUzMP{8<%n9vK;+ zE`>tG|DaEvBq&hMqClLGEs23w)|d(_e-ba|vo^$Ywc$B3YVCUPQVKbln~tL4uMTuW zbptyT7N^Z^q%wQCeUQI-H_bvMLe#XPss||Uz7~q6Dvp@2YTq6nAi*{qVtK1eY(nQn z9lb~w$Lo2n>2JER&_ky+lW%N1i45-XZPO{@wp56 zTg=@CwduW3=Ph@BcS1;h3*hw}d#)r8M?e*KjJE1(2p+4;MhLzo&#C-^-NPwV{~?nI zP00w{a>4?xP^jt9gxw()!JB^Qc9$sd_s+GkL(g5Gn{VzLo)q)X14&Y`$)S2py0>7k z(gm=8*ngvQ5dX{=Dw~mfyQmAVkgyJ++fllzI0tYU+ISC(jkfpVm6A+g=kRMpY2;=w zA2%=RB6d@Dn=B{#5afJ%cBSe;(w+)KKc;4}7WrO~*9^QUWbKcBimzwudhn5pj(J01 zyBT^I0s1_+NG_1x)0R#M$cZw-dF{!TBd+r3! zp9p3$mG0RIB$XG@9hX}{OPC*6`pS;s#&1=sVt)Dd2m#mydJ?vUdtz6QLeSmg^@7UC z88r~hKTIvu)tRBTE{-?(Q36k(op|FGx&!JjYb|;nE}NC9x7H!Tsr35`&Xg>_wzzCI zZEaAwqY(wA(Adtdu}=#qlj7XMfBN^Zh!;aDPx{2c8~iG^@s+XXbzZK?7U*hcNSnxO|b3946Skj zcMq||I9&!gGk8x^5ekf;dhoG#Fg$j84zj*x&GHp(eLjCBG{~~@IAG^}CjhFckb-MD z1Il*H4ToiJCzl>`le<+S;Xm-~tRvdm1w*m7sGnDC`*;?Nvq8o-kO(hB4ST zfLukt480tPr@wte1P4C2$Z)Tb_Y$$ec}J9>aezGXHyZWO;|@)BB@oe`HaeZKZOIO- zhIv6y?=p9 zedlV&gUFDi6Duosm^2IH*(0kksxa{#7WJcv`-I$lO!xj2kdgy}{w5j7ewpn{6>%27 z@sLjG$k3etgi+;B0jOQ~DOl|X7pPkY8U?;{&|(n?H1To*G2eyW4ifEV0qP8?97WFg zZxr%h-3+NSBvrx>;wK9RPKgS~%=BKF{jq77xCH>d(Qa$5h|%l3S>`P!*HS z+G*g454BrWns^r9@Z|2=wcrhQBImq=hD6j z8&sNtsL_fZEWtW8ys*~)AsK_~(xJ5NiziLKUAvFQ?}{(1jT635eRV1NArbeSXWv^y z6drL$Mj}b{F2_qbIgfB8y1(~FBVsf4Fgyqr@*PbE3`oDN^Y(Jj-q&>q>PFv>q;JiC zBxz}>>V_v7)~?-K+&GW;e)XlfwB*!FfDa-@)6+3#`=} z=+wzqq!z^y&$Bf}u)cTxfNW@5k|qP${3I|Qi}YaRA1_IS9)A|_S3k!~uCrjRhhW^@ z6|40s*wFP_1^bzsL9oSGQs!p#6E;M1gAxZ|iK&FEtiu1kHGER`3OmS_eaW1{T8N5rx6?M06t(M>0rrWNYWjiyK;(` zymaP2(C-Pf#F@3HJ3yzh_d3OvphK=eFEXBi6-ue&u_eIt0|j;$tPJb#V~HnuiF7I| z=nMOQNEfKIfHbm@7ERb!^F{O)H8F5l91F0w$~~qvZakYW9fGrSZs8|q^e~_rgOU}U zH68w{jrFBQJzb;rDv=}y#};AJ{e zBX0otiZSnKo+o4F?k|4KSXb&>KlZmNUwTN4Cw+~}E?{{)tlfJzl3aTDmj`CS^|Rdp zlsm2D@Ql+Z@8ZNOl~lzRvDm)A?x)1iAEpJGbRa7*N;{>*a5>}tfJr^fbGqJZCBJ0G z$>$-?>S47%&L~9zg`h9~BIxio)bvIv$uBJ&7QYsOg)24(V{GN8>~3Xe;(-nDkttu9 zeuZ;-jjRz_V7Nu$BYpVk3C5Y$FOW*~nb+VAod=#$%He9ew=4^E+czOLR)X#Pm6(#W zu?6~9`nb0-G@E=e%Q1fwcfjkr>GP?Pl5f0i+Zu|nG#S{kEO%GD>BX20f>zZ;dPIPA4k5{Cx z^6li?INx$%pDE3LJ^MsrL6KrgP9k0KWpS$($}}6T{uvZi6JBn3-;IWuQ-z3PR}ME* z#qw$HQ7xsO4)P-#@M1FB6+K~E$(EY7IBe(iSgr|)VmMvs=db*Ixg@~F+`2N0ixyTJ zZESL6b;!N}SG_&ecKO-~W~XEf0+SjpNb12Zp8j3%He^by;y`TYz=+8iYn?0D_TEBB z31rgH6Oa*81*^lGfG{4pg0$w+H&!N1JuX0_k^4Ya%BmSv)4%aVYMV_e9LA+V4FTcq z9g{id(+)pW%PMrNhQYb?gGdNKlQDRgk^5;Or&-3+7x|~DL$yB>EP)IkY-bPF55_q( z=AWDS>l*W{`1Z){i}0mZnP2%<`zQK zEbGD;uQNK+k2oJk;6~a-xTgE9AaVv*Ynp{n&<6u~5-K4HkLBL3qR6MB#^z^mJO0cF z%kHj25@X)}nq4p!NVsC;zfEl`P6eqc?Ap(ZpC~V12p5*h_Z@$MTsP$ZIMC0y1^|PJ z4x>0aI=U+7VulzMnwSKlTwTgoI3p;Q!j(-0Xt}T1NpiN4rEOKoV$Ld+o#TvC5K^I* z!p9PXCr=1jI~n@f4g&Q5$mFsm zv&o{h!%a!ZhVaRB8qcWP4Nrc6+?;5bs4G+{W2ms?GxH_q{qbGImOXH%#v6d0?+`ys zcS36r+PwDU~0>J{lW-Lsr-DHJ-Au3ue!LO2=U&_x;)zQAUsAef`+u27XDCiy^u{&wLXrin1HMXk`Tprl4_7RnS{h{L~;AMm;) zE2;Yrc1B1`(Sok!pRWZ(?q*N9VG$QWO_;iVA^`K4dkUl;{cJ|k)E$mTVa#Yc-X8y< zvbOe8<&P3}U6GrKwgG4E{I%ru|5F6Z-o@2mcuK_Y(jG(MT<}KO?zKltbOw1TS=s1; z>^Nv-EBW;4t~Rt24*FKxAiA`zp?N)Laqs+5Jy*-JZ9xEo?W&T+55;fbqxx4=&sTiUa1*KcjmXgXA*LX0Pcwe2MbCtW9+h?W+@piCVfrifP<%ST6x&lZ5eICQD zYK_UgnSbKRe`=UOHn&;BD#|`ADs)ec6CJYbcboU8&o`^0`Ug-*tmB3@c)_ssB9y!p z&V4*3cI#jzCKx(8fzY_5DsWQ*=WF3TZp$SSpSD_TT@BqhRckt;*@7Y5;{7}!dTCyS zkelO3oxE;W0r7zOQ@vKay=R!onQpXECJjPblP4wvI?F*|8|HLJI}2`^IYX?Q=fpWy z&>ZS5AGDp{5OqH@V^}2+Qb7L4X}UaoHU?Bvb|>l2cpTE$dX)Uv-S)Z5wzO08H1jDA z7cM@v3RSjP_j7JCeVGWeenA)cs##Mbk{w80UwmE1CiJ-9Z}v3pniO5=@ZkCh%Zp@5 z(KCbd;4_m=!a~JZKYKN?+0;E6ci^+f2gvQbp-8$VZ3k?59a3Pr;fpC;xb~;)z`AS@ z*@xUElot{}rT`JZxLznO)d{HA_`U%-Bm!GwTdbkzXe)+Fl{>N6C?!IeoC;wu>cdwj zONpAHHiHYvou$k12pT_kMvac#R?`1~I#nc<`{vo-KVyng*qo|;#i(DKumZjKNJu_) zM8`BV5+qY+&TmSq&7J$1A00J+b#mMjD(!?+Tz~&%St}^Zv2m~u8AA+@rtxkcIm>0Y zd;Is(h1p%gV9Y+MXVh{FMC05t9OB6_=y}4t4O~74(J%%grT6pLVxEb0>VPm_?>m_4ID_V^uCe%7}bQdeQo@zw4S zxrD20T^Exb6F2absoRcpc{zd14#0qH*2>*~U8DG3>4x74T)X=;W?#oE_DfF+E}@@m zy0>&wux%r-7B7|l8zM|OoVTa-qL%aptkww{(`vQHhb@*QH0>DHvtg^cB+v~+UyNHR zhzGU1ThX;F5zGjU`ihAr3ooL-i-EhJW)U#>zrSOKpEw}&=6CAZbt9YF#N&0qpV1hM zNN8lla43jMP^tI{<&vvMS% zApr^aV@lC)b}4oU`#_#oqat*)cyfjT$AZ*f?UHfBv;f#KU-b1#F#7=Kgi+6fj%P!VKjhV=1l- z{b-6L$c|qXNc#>02D#U^c~qPW_LcvgB2azWpiszPU6B3-36_Hh*vpkH1lUeHa)3+J zPc*MkzzR}Qyu0dEnp)QSWXwyiY!g$i9jl3*xm8t)(cOddT)yeqX7zUuC-4>xj3JcM zHWPlvbu3$!k8Rm3kDuxWKMfMwdb(Z?9P9+Wb9qdNY^sjmF?Zf|L z$Nx^2$T7jK%mZK|t`{7##ZAxaZ9n=TTz&>_F?h`#K=qpjHh2bmiepz|sbvb26HhDs zxTrYtZmeJ`44Hu7RJKr}U4iG8kHe!n=Y!TDGUF7P_d*g?377t#LgfE2F2WS<>x0b8 zh(#H1Y>*@HX@(DTLwy6h8e_J$Kbt2YSX+nr+Cf!!*sF%iqcS`5-`KYd^)1i*YZd*k z+qZbFQkE24gHZ;^J$2K)V3t9A`C0x^AMjdqQZ32Nq_JPFVP&@mV}9Q%KB^~kOK|sq z!fVC!<&@2z04JA95JZKe(0$Ps)RkH84&J|7g06!}90Y=7RVvhqr$I@g)47x0l~d6n z+Bsg~MpskBIhCq28I1#U;hl){@JzXhd{K)v_tOpr$!~mW+=1?bR7VggUUaSfH4Z7v z3C7s}To#mXJW5v9K27jNA;D!QLD^BtcZjlO-R^5{o~6GRm8OBaG>f9l4C;vcetJfT0PK0tq(;iw39 z!Rzm9sKlB?RUtrMWuTFAv8dX@Hg+plD56QpLlk6n3I4WlT5(x&G#F~*xwQrPkGlq% zmjnNI0f+v;muE3{Yi;Ff{`AQxIbxqEY4&(|>A)ZJ2T7(JUC@qqj{kYH7$`?VqRGz1 zeU2Fd7M@0wlh-RAv>}C%b}vzKFR#Ef?Dvu!D(h;^5W43@l)AxpC)W9`efeL;T!oYu z`vxKb;zo-<%vh%%S`1&BmU#iuynI0Z<#2ifZ*w#TLLgk9+Q#|8PrOp~h|r~j$U)=j zw`9t3Xxd#lPFvVoF7&;LdZ~L~Ql?ktNhZ!f8_5H#@4ZK1Fjqs@%GOC0wl`o__Ion_ z5l{-9OurF`Kov*yNV;Q!Fj<}+1jMCSB7thDmYSM4ft5*PJfDm7A2fIdA^-Yo7s+eg zQ6<@a5d}}4>rR7zjqZDYH`U6cgknIn;g8GB{GaIvB?KyDRgwI*fyxk4Pa04=XgnkE zF>KeU4Y6N`!>5V~ntP}k)vEewX7UOj8ItY9kCf@cP<{mzE%V2P&WP1q+>!1*s)3ve zBO$^5>8>NOrI8JRuk|YH%j_vUzAc0M{HI1xUdwDcxBWLe2eQfHcF~-bQbT<=lodIL zZwY@Pm|o^ZgB4YN11<9O*|pw((2Wc1Oz8a|(0{{FgecUB?SCJPV0ag$3Z@5_-mMkd zr*S^rCI07&v*l%7VE)mk|CEyjjtj#g_BQ{NJWFf+#aNIXps!B=Bg69H058AxPJ6(9 zsa~>!4cO+0rD23zO>mqtfZD)l>*Mog`Mu1RS9j>?JlQC{t!*v}5@_^EMJ7uTNJN|$ ztgwk>ZWbjfLngz=IyzEREy*8Du*b3-yuM=#v>K1vnu#fWcIiRwST`&rvpa?aHc7q4 zU?zk076?lv-t$sN^h<(s2CD~WAP_FfWw(5MU=$>8V{2cJr})zYI8qMSSNLc}oB*44=1?HM2uvV33CfzFGik52(Cr>EVJivP+>X zf1x?JvR+LrDp_SCzs@zy2uQniGlu6el^Z=~WcP?~)(OrgVts{6yz6WT$q+dwuUMf` z%mT3_H%-2ubPeu@JQqD}_p=0sW}NbYAdhKzdA#(&7n9M$M6{=ym4cpp4}-ox8o)m4 zF8K%<)}?9VA)zn=-}^kJe26>1`q1bjc~QO(Cu6FPpmFJXF_%i>(4rs_mI3zfh;H>^ z?N&z)u>fz^tb>SasN3JPa>$Q?pr5x&znrNTBu_xKn6`QC^$$I9PI2<1{hR>@YMazC zVKQkF+0bvLdDld>pG-T56{X{w*N2e~qDft8{FiEW%F&5F-uaPAVMj-rQ*L;U;&q3r zRVlmSZ@0HXEp_pAscCWzpQ8m3d|Jnh!lb<7g%+)}-}w z=R7d#eb?1RXqGJh%kS9Bw)_WZ_lN-Lzs<5lhdcVYxzYT;hSp90D%Jp@L=g2;5{er?#9RJo#E$ucu3J_cd8-kq^j39filD7~v@f_@1_kGFa+8wKr6JvYkaW1gXS z8=hlFq#WS&t_@R_)@NltqCQdv3&v;qLjrwaE&@cv2X8Mp6wHxSxUgIbn#fib3+K@H zQwT!szo`n&Sl_LjOU>Zfk%av^IkSzdlT*W{$hjsqWC$GJ-IePh(=;4BptnmpNEfg<|*Mh+g*T-n~%?10)O z!rsUs=r;s`AN1c2->`%_p3uxd^juq-4E#ABta`b+G-8wF9huZKtu-HlHnI%9?YBmg zyjpdNcvcHh7BdPs^@7$Tlsoe{gFj}A;9sr$AoXFg4Q+oLgNnG)E1UGU=v$3Bh4nm= z%Kg2GHzoB`(4+LGg-KFUXRnoTtSi`2BtAa=NaTE=3?Sx@n{q%Wk41Q3l7*6e5eqFi zu=jvLq5jsA5Rya#kKI|T8KYxJF7LCfoE&aX;`C0N^lqMBV7vgc@7amI*Wd9&y5!z4y5aTOSQQ-;jT&ya!?)E7+JU* z)tjUxf+Mmvh+B+`yYKL@-*i69&eqRIcZw|*j$;t9(Cc zd+;A$p)JRw}^1$9QH?HHup zKB95cz&kg)Fub(7Gd5|vz2#I^5MekiLC^~u@Cp4y{%0iu%#ezcQv?lVD*x>lyV4L_|n2~5p-)NaO>6Gz6J3>*>LHxp6XDhoO0JrNf19Uaf=jM!Q zD_BnwADIQS=R7kt`hq@7v3+gTF4R=!_+F@&IGMINyFOJ4|Io(-{_3MnN{!(+WwND- zzZs?0;UH`Af$POo?m9AE(h{M^Ypo~QLw5Xi+^M$7i}>O__xiv9nsSoSL96s~j=+Lm zn|qKK-1Cuqe1EFuOS&QQE8Eb^u2er4$BoikB-KL}N>0&3ifmv8|G7!F+$fS_T+vAnY|Butk+^4D!D5>5yyuUK-tGd^htpnXg+;LoRdj!dF=@%~gSA zAeFEQlwq9Ut&;kxk%8QFb^CUm&wLBHABYsvGZ#GC=@wqSeZDi@dcH)rGlHxu*dQq( zv3z4r4E@Q450WombrL=!eRqTX;bRfKqf2=R!#Fg;J)oV6t?B+YOvh$u>MOw_w?HT*`Y+kLey~(2T0Eic$c2|%5^6N5w2iQMs*kX zo%1%j(XdilpsVqwj9QnaKfyDo5fg92o`Hi9x}x6iK494lnnB@^gE14KJpe@jqfyC= zhabcxA>sJ`E`RzEdFBKirhH-+X%F58(F)$SS;QlcBXFcL(+~yDY&0r*%y_MO$Bz2a>pF4VZpc7TJ(+*oN8xDVOW_`CQ30;9`XDA{bF^78B!2vWQ~}Iwg;sWb z{3yG}1qjYq*#sh*V;NqY3i-IZi;b@#45subu6SkDN7x@!lgdZy3@dLO`xq{bAbrSX zS;jOho3`A?l>}$*xV;nDwEA)dzV*ph;wX{<9!9c5lI9&U`Lt4LCp?fRI1YsaFRi)q zC84GVf&r7u)L3H7oOpMWGVF+ES%LWVN~8h~3=B}}!{a}Aq?8(z`xv(=6*a@bG(8mK z)!E3!y^X37G=Ss<$u?2#GTn{A{{X3v?{~kITk(oxH&XW$8y73i2q;2RV_`0$BO~(y z0n^eLLW_bh0^#gBs|twO{IxE+uLuQhA~?FC9JZR98)R+5umHb#lg#Ajd?8oQ?w4|Nh%0TbX}LCr_`(Xni}}Cad7b3_>V5edL<`lfKBLU=m4F+XJt$|4_Mu} z2hy<}P)#keI*}h$SgV^0?o#zW)p@4zuJZLq!aG(}v?iX(mm+r!6(%d~bMA_uu!^9{ zA4;^3VSdI&KUT2KPrU0Zu-+}14{IVs@XP24WH3S%Evk@0s=V1Yib;acOD!o4YhW>uO_I4T9IqUvfrn5G-(DEZl zO)NX>-Rw_M_6jW2jLThM0TdV>zp#~FcQtIFTy6`Z#6+Dc{G+~Jpp)0}d}=J1-#w1$^G36%picLeI?~b){mD7j>M!PjaDm3kRd+03wX^lOnrq z@a1Pv7fY>xA#cdC*U|2ltCx9|r>58A)P#qS?Fphx44^;G5^gNz37ol+%85QA<`YBQ z_>ykZFjODn8&b(J7bso+C`RSUUr_B^+Rz@Y#nIoZr*7xZ;5>n&&3j-}x@W04O4>5` z0R68ExOY@mI+!JBLEZHMj%*Vy{--lMv9%UDTQ>Sl5quO)wQx*H;29lJb%$>zs>BU= z(~KZv2tQVdv&)&=n8fbOBkb*N>w9u=(J#o$z)jpg~jjxk_`B^Xh`*Yvv<@`?n=B02lyju zjvP-2Wr--)^w?tPU*W;ETP@9fA1^sq#}`p7=kvH^rHa}DxdOK0mTM-hVE|YdDL|-W zjtf4A93T}}#SMsWd+v8tm@v9pK4S9GOL6Z_SaSCKE=b87bLN?0-dE5bwWtnDh>8nD3H~tpf?Lz(2w%f zhDE3?`#wfX4KW1^3^w6Z^;ph6v&OMq!d>6X8~+|e($bG!E-wVrxiccn{Q7op_b4_SQx79VMJ|JZbLlMSqG4WO!85skT~tdAx>=Zw`#HX zr)`Up2da}V;3Z^t`-Gm?&LmM6g!0KYQyb0qYpj>z0^_O0EZ`AQ*#PjH2S)R+)QXJfaTB zZRYudZOQ(WxA#yxCHe(Ept#uPuB>p^^wUx#<~=J!VRLbkWdq#DW^92UpZ%r}>|18d zST2#qC*&|!we+842YoU*j4%m9U0|#jhrw?6v7CUvO+vpQ<>2J6yGg+KF(eJ zA%w8m#2zEk z2(G?xC7}|=#K2piiDz?uTWw|gN5ukNfEj6#u;s86Jp7jzKKJpdrJLd}{;G?hCb1-U zCibeKT^-BVR;z1u1EYj5-+**7CUmC`;GT9wBvd*hV5e zeAoV~c+d=-D~qz*Cc;vsi;(TsBNx;56n{a(m(;PHkM3?If|+^tkEQa~H-j-$rK%_z z$uu8X_XHz)w##_OGzmX4)p5YpsB;oC4Cj^o!#i-v6ZJ{%%Wr8{DVbgRStZ}wrV0% zFBmVQz2FrFG+t5qfgaXl65&BdP(Lv}$cURHyHH{SJB1Aa1u7@Mg7vcAB3&wC;c6eg_YsgVzdSCXa!4nk(F=bJPmg;e+T$9f`W;K@OI>5E_MX z7Q*cLi!L-r%8ERAIhf?)3T1#mI7k{>&TUR}qyQscAA(a{1&mHWSx9I3?Q@bt9nl@S zx70+74~F1^C2r5IJJC&D^grf-o*DT9vaIVBMlPYh;8B2oc$_r}pRcO+<}_i!z-%(#`*S<}t~j(>eZ930NzRJZ&y>*`waA#`{nuQ*i<{od|n5>@M=0AoGK z;Qd!DegmeX80D9GF<*)Z!OW0`_COuspVoF?2y`4a6mnwj+6!fbfY9b0Nf5PtSkZ?C z?wi{geQIPRB;#~SWVrRsbXuTG6Y0T2Ac!n5!*^`y@T_Y~W7ek%Ud~1HZfQZtE(UZh zsEBx6dh8hqa}YJ9U93mLHayeF3g$6*FJ(A=)WY!kWO&5bm!o~%|fx+^!k{6+ED8+cu@vp~+C z=1O|AbQ{+AdQ8!rA6dYqeH;L>T(3WAxWn)QsT+DIF4bJwDd$N@)$b!Y{O)>_;=@yt zdi6VbxaZbb;u2asn<-gm_q`jZA;={l@li$EuT~ zNYgfW9=1i?x-STz;9om#Gf(h0(eWHwg?OdrHCmE?H1wquforG&?mKlTuz_uXc9p?^ zQgK%PT#>jsw8y($php>j*t~hRF(bO{_ss6kFw%m-u|&4WPnxC9ea2w1nVXVdhjlEO zFQc+5I7DDFXf}O9Z$l$s>JVZnI*T@wr$E(YAFUH#Sx>)B!`65?awd?|w$4F$vT7J< zX{M%$y?1o^Gm*k@wdJ%eai62%icc%cAaS2|g&8}3n4u_3sO=n2aP{0wCpx1lCkpNU zeEFr0C}fy5dc8gl$I4p7E)u7S2&RcGL;kIOIb& zHpOxV_1BbE{~=JJNREH?Im1ETeopEKpDiwGX9GzW4M#Cl6bxOB)KL_6MtOrfJ&w@< zJO)PgEBK3HeAWWP+tQkyh}MCVPECHbP*sy?)0-U8FjMbOV^do~smT|YQgXk<2S{B{ zV^j1csvoAYU797R26_NIc0Oa=;U%mVve0gEby3@g=Ss=pJdfEiKF>SNzsHjevs*um zZhkco*lUEWR_JUen7z;)Lafvh*?epyXyuH`muB(6uAUoB?JC~ocmBRd=j!hLEga#A zy5fy%(P^$_*n0-97>A8Z4f$RsNs>h$Zn_8VJ_`=xkdU+Sc)|6YwRuIKy zU~U@W%n(N|4~*^MQn6VLtq5m7vv3NIlnJBqRj*WS6)*7^AYMdmS5i)!#81_075o}7 z4G?&8f~fx!n9HA@SOBWNA(svR_{#A|Rz2FHx%NY+n?G=Kq8{q@QW4W(8W-2Sr1d=` z_}$d>0tiHJwYt;OLe;_JB=GCmb%!jh(Ek0S%>xq1kpkQ*CvXgCkDc?ej!+$Cv#_3g z4xf#Yx#6l-qMk4PX}lMVry5&^2i;2KqH9Vseh|jE0=dOaoB!wdlTA5F@Cn#zq!!h$ zg6Kb203bAnhARrppm*hf#QfK19rPbj{V-gQia`UuGxdU8WSH2^=wfpvZlAO_qA;z4 zROReXGEcSY_PTP8GSI{>&i4L8!eX5CW2BtR@|%Vl1}fOHg|axH46pW4vzQNcEU;GO zXVmSUL39UtlG(x*ub$$Cp=T*Ec~ug&ZCJkC%=~%tunGp(R7uW+d$|lVi>H5XFuP~H z+S!4&{a7Sf+JI-4lzhjmt&VUVZYAwhK_}`LP%&Sb@|`&o`YdZzwRa?6@4BaeKoNm} zqXRY}#LA8e=)vNTDv?KB3=p)Pe?9LqQ5)JzkgZ7zMj&;bOD@T9ePSY8utwq6MfUZ* zORvsaT>x{FhHV%*N1it$f|t5$a#HuAkw`OwC$aRFOI;YfRvU-HU<3-ZcN(hEuh8P# z9{QNDVX|dT8kT}np`-*4LjWmt7_P<7?f6g*^4@J);Bn5K%G-n&6Wb<_*r)#RvtN7& zM_S@1Z&&eE2836E@x||`{ZjQmjwi2A0HFn4@2EL0_SwxzZnvL^3uiyX0;c(imSV6<5|^{!>c3wg&u#nLU`pfsq7G&kGnI z=!fkV#BMsnPxfmVS}wNYS3@RdW)G!L!EGP)Ay=_!BHunPQxL5OC`-2l2Mp;XT%e_?TS?oGS z@$G^N2`ZnsK1#(eI^SrEQc8PeS|<|Yr>(0%SX7|wM!SVx*Zks|&vWyk;o{zBH%)G< ztvveMF819|gBb0n+tBv7_xLO$ zrfAK2A){J?s{>&!TJ4Z_+cK*uY*T0KDLt2i9$4(c1F&ocn#ZR=B4oHBrTZOa4C~`E zA#8SH@GmY)({gKHRWU%&OdAj+T;)TZuUnbTPPrAQ5pjtxi~ft|v7cnD)U~9tWx6VO zaj_p`(zC(*kd!lxoRsF+cJY^53X?+8vGlQf04#&*>wEmN|Begz{4ySFS;8Bpf z08~pk_dG$WDponGWQj<8UZLLS{Sc~p?5kXN z3+X8|nMvDus@@?O`qella&jESgO$@qGMrOV>|!jvJw`4~$z_p3QD?_TA!sjQl}n+8 zGieItu$e-ThmSb3S{Q0ii%ZpoCj-YV{MF}k`^1%yIVs&8XpX25{Pnd5f;Mt0F{!2O zEE?0@&+XqW9GA?Jw$$-3v5yzIsG_n)!?0--b_Dfu8{JiSL3|o&!ywI=--Fja6!FGa zJst#=aw=haUV>*L(%L1K8$Ln$KKp*TQYc|Y{E|@jx20dWi*4h>LOjeA1{iG`EhY%N?;fv)*`;%lI1NMQv5kl^O z7_!?`Wf~JUxNMQJ2r6LRi8&0vGrpkwPLVY|X=ta%S`Jh{Pue2H zTasQ6JWhxRy>c~syKRHvYOSS{)wABq;y6h#_f^#3|1oD$($Wk^hv>iW!|QNI?@%^x7!E;+PU2zdd4bWJE&!gdsQ$98+H_Z?WBEd=WX%l47 z*=n5>>jr)$E^12EAz_w0eKcx3^Pa3hY#t>c>kEFpqNtO4BWVomd;%jCMYp6nZ@THR zks5l_wjsB;Is<>>_01=K(W8M|GZ4>NwpsgXNBrCis3&~O5p2|E5~%1)n0)|97Hyt}_Xb~Bbg53;R+!6^ zPW<@jev$Im!Qro0PG?LhaIM#U0aG{K3iMdKCl-V}6$G^E-v$VskGOGAL80Cu59oPgw-eyDhhXSgb5M;)RE z=SgpGPPta+B61!`8xJ)vySILDQZDG#%W_{!344c@+1Mz7SJkP;Uz=2K?~&KWpFDmL}n?y)HQ_Wpd@ zyCbQwDh;O%Y2+9r7%wkWT@&k;p@{mMcEnEJg>;I`==@lmm}^qZRc zP^~QI=+B)h)Qa%UKM-u~(@6JA;3sLqoI(VED9qm3cPgz10z%`PB(zf|rM#LwL3v$S zl!{$>;++oXGFtWJW-{Vl`(B0u4OE~2#9{tQM@ZUp zc_|@Z;zYSVP&J>d8ybj+J`?feX)FqZWEpPOk#58oz}CI8@qve}!DtnbhK|i-^TOBM z>!6+!>oceei1)aiz?b>m;bM2PlDAhEzktLFls5R&eAUVf106<6U9hpx$Ozg8ls&*i zk5O_zhWcHU``k1$ZNdGpV3a0xKagPqHDb+Oi>^k|dY>AEb|auWP4(zE3>Nq z&ymINnPbUdM`tIhm!8+164;a)3TifV)L*&P;9Y1hX{w7F5KXYZFI|%mT(OHxWB(38 z9ZpPMvL8B=mXgF~@?|jTYw)$qoNfX*5-@iaoZ1pzilj%7iFi^atN>x3FrY&Tl7Hm1 zS&abxp4>j*ULJWSLG!2kEy{>`nQ;El+M-3~#yCP>T!qkN=EJ`z*Kt|2Sk{?_59u(@ z@IY<55^ngJW!{yl6{wECSi^qzH4HFZ@kAxnOcshjkMRO+e~BHmx_1WlwbAUK!W31N zhAbD7hyfL`sv-u4znoSUJwOVT1}&JQ2PkwqdO^2)@j9X)zxN+>RGDRyE2<>rH<8VF zSSklkRscgcB%S1-4R6gU*n$mub|xNPt(kSy7Unb&Qv+o_mHN#lR5}jN_iXGkJ7DPU z7otS>qd4G(Em9;nc56^;)Ti}ci_{BJw-%2S{j;fpVH;c1d-77gQukefw9r9CF;UAZsU9gKJ&Qk6ie+Q@73lHd~L#&o%_o7JB^S89G7@vR(N6W z$W$+0LZ_Kr^>()@qMPZr9Lb8w35SQpGiDaEz{?F6N-@fGmWQne1h%yDVc-dPf(Anc z6MP^F!ZT0j)9=*T7vV~dwe0>>< znOcoPQUKBl4}NVe5bOm_HleMsWVKyAzh0&?D{Sd#c9KLo?24BiB^RZdtJ0@vsYCz7 zm^c_Kf*yWQ*Lp_!)Ah8MmO}sqLiP@#5OA>5KY4m22M0a8oo!^N1r zIbVNy8lrg6me%O?xYJZV5Nk`u0zznf$Qo-}9%V|evrPr90V>%TA=+7E;_d-nS~x(# zb(ov`$ESj!m0G$a>q`~K+9oyw;p+wel3gRpS5*1UL{ZA-?MxOk~D!MyYoFtW|xkUKo}Qw_!`tyy<+4P_}8k&8>BK(A-ee*N4q;N-)hVEhQv|dOuJ$ zD-aTGv@$Lmf}ONxkW)UOHXfJ2_hHq0K8QW!^hq%!X{O(`N8R_}WJCoF#x&{$jJyGb zW-L9JIyyzSd)}-h8|gid29))EyQrYfbLfd?)zWBRZ~pDH3(G@?d!=KTQqfgSdtk}H zG-qAmEM86%?{aCo!sv%=LrU5c=R&DD5H;$^NEV6Pxe%LY)2qc;>9^H7 z&x)y0gdCtz)CP+bBX)-ia-VPw{3@H9lup$4U_~0Cn(GsEMwGL7Ve##YkE+YP16#XE zgumTzrG{+f>R&K89Mu*nbD-PsfvIg$a*5rwZ8NdGr}1(Y$|;zODOkhJbHInHK`ohf zH$*&}FH6miZ@37kY^%hqPe?PCyHH&&IJ!I7+*)oTqDH+@m2EMA-nhbQrNFeY>5>sz zB=GQ2WWIRTJse~`@f$o7&?YOTn=gUN;AAXs%In!dbvZCu@% zscEj#_EOd5#oRNA3bP zX-n2(#K@}79@dy?=AQ0wHmXR=& ztT)w|BWCDAWA^FA2y?K1VaO7>?>w zl=BMO!2Qmw>U*V6LM8|1ro*&dnE}caF(82Ar@bE+KYX|uPSu-6h`<^5(sO}m8YuwF zc&UGBh?F-ZvVSylB#2BJ0jf08!zEd z8W8UpJe4OxDz>fELN`0jt~pNJf%x&pAp)omG(wfe3wWJdMzfvc=MlE{ER=T2Z{y zd6EVaQ5>0=oV=o{mwoi&`E|>s>nt;`10sZcNwAUH$eI*d7|(o^{vy|B;kqIVd?5@| z8?L)o@x2*p%bG%C%P(+70W#FwTLHPM_DS(Lq;N^v?>mh&;I>-&vUf|p;Pl%uRt|7qnG7ncQY<=tUIHNV``N2yUWm|Cm|uq_l0Q_ z-|CL%xGvKwk9W^T5`FD)d3LLhVd-ZUhsNp47`+wJ=3w6EBYs<*Ib|(jzsuU?9=r22 zPyX#O$XQey^H6ZK;sHo6O-5wTfyKJX+I()r=w3ube z5DvIlH_KrfJpj4*>F-JC{d7OvMmma3VNk&SDM-ay8AM)pj=R~1Prg-X2_abhn`&=* zzFPaFG?SPhUuIs8qNMBCaCYnglF}KxA|{4>OK3U=3NE39t4%Vb|-mhS4ok zh4o@7nDM@k%Yj!IFs{aeU2YNiz9>>1IvbW@drnk}>A>glQK8hT>(&~~k1E=75#vG@ zp6`Dgo7tJ*lQ#WG0bn*$R?UE{QVOz*p~;ilS&ortU#c5+UwS8!G1dQVY)!=mpsVrq z{Y%7EQ{qfrY;i^$k(HQER&n4_s(4GcEmBAaTTSF;1#5VO^UDTjs*B&AUM$ON>YP zl8H!Ob6bsP_i?Q6kckw6tZU#;UN|ztn7!MjjQF5a(=rPB^wnL64Q|^T_h&JukTY`k z;a325OQ9N8G2Cv~AU}=0Z5CbJt2bOQ-!76fY=!OKWSS_?%Fhs6`)8LRzr~^tm3 zeU=H~j&xU5V4mo=P}MEiv%s6l8|VvAR*juRKwifNMef1@Mlj+X_FkzOl$k5OZg*xo z1+U}Q{(rsfA-qoJuMTi*^nR3Gyz;jE#-6xVXJ|N?aztHI?VWfUr z@SGYbKY3lQ9?f~{&}rkxsmTd#_qJJuE=*~tvP?Mw23pbE8*D!|6*_p6M}h&P3Cd{B z-|sf)ARV5f4)_nNC4Qy@#-XZvndOHS+_-ZAA%B*>X^MwK`ngZ2U&*YAU!yh`tDu8s za^p$6`#55&zb#qDgiQNhw;fhazbMkt)A_#m&Y4%4BSL3ToAVC_9O5gH+Q0s;kAwS^ zVZ^;C>T&;aKF8+#(nJCL{OV*Y#UTk+^46vwfBauwKi5}7s_;mvg4B-EV~5$xJDk}S zcEI1($_cncdQXgh!}{fAK&PlC==+?oGQQXzYH!Axd-atY+hp}Vq)3)j3aWKR*NJRc%O?r`79}aR;NzSqr!cqZ^S@>XpN- z@~r4x7&DjgrJS>C6ms1$!Z;VZ_+SDx~%8wIYgww+c+%99O zaCQdNHz0g7H_5nj{d4JP@qMK*e=;@8 z4J5%L?R7BLQU2H8h2I87&NPd3T2i`*_zO5ZMLV%UCFQ7f!cY5A25k*5FOJ^%Gs;IZ zGj^}nHLaDlv~;OJAKcOWt>q;iogW#El#+V>wp)>BM=(-KJV2B+1m}m*PTtp91aZ@B z4nv#d-eD)Mo?HEy93RbSB>6;LTMu6zxSJC!$MFhTYcr>Ey1 z!lqbf>YSB?=<4Sb2t2&99LqA)O^@rgj~lkq-}c6tcXOJ(0MNAX$`ab?=dVPQamnFe z;zj5Ts`}RPM_%cPFreK+d_LjN- z{cE3teKW``FNGxhgB_53t}%Ckzyc(~g9A$QB7(9k>+lDDs3)OMFtWQkRy8G4M8EmSm z2SwLm2|2{dHu&-TZ08v^*|2};mk5@E4ex6^?r6_>VAZM0UVJej-y}vkKJcLrByf_` zG;iD#`a<0rwl)0wo0hz%8%^VJvGp8}T#WTrQegb8D;aQ_)kc!w(^Wn0Jf3yWt|zVE5QR)ShC^ zQsJ?-M{B4yd*+jbie#TJLtN(OANPqnE|Ni=Rw%7R#m-qL2W7oRu*&9iknJ=k`n^G8 z!uvy)T4BLUgd@lNb=bf63SblMPqhT=scC%#OSUl_{qP~Q6gWdjG!|{Q?IBkargF79 zVBwJl0d-z|HdfbM5tKA6f!#ukaQ;pR@^FB!Qdf`m=**kQCMgYO6GS#kY7(g)6Q(jFI*(CScF`=u+c>c_DDk@(E{lef6tpm?)_L+VOLg!l;P33 zmojy~`gVY(3-5T1hq(&e6i+;)DCE>YW~Tfz7_b(6K~2G~mm|IU$71qa_hmk1%>T$j_6SDwv#6ZDD%pUvGJ_ zzCi2S3hR?{vBp}8Hy6WOgKYCHibd`>0W3cN&B+aPb{A7`P|Mf1j4SIQ+&lK}i=xd{(2A;LJXXwI2A{&{z9L>iCTCV#ekf#$a2Z_LrI!gC95~nQ z?VX?NyL$vIF>WbIyqPsTlKv|^`y$G7mO|6c8IO^Kl85#b+p-Q3TPv~0$NPt5i_(5wAtd_sl|_gmn;u&I-5EPqt#LS-ri=AtoH_Lu;{k6o=%ANcu2-xXcy#&UQZ zZpUsLY!>g(fuu6@F|qkv8V*vOi4QZd`7NL#w_vVAW9jklD$-<&f3sHb0(zWCZ_3Z* zCw*+4%j}T~0+NgPTX{W9y-)}4y|g9d-xGhJ#H>d&PKMs=Zqij^3j8Lz0N@ zMp!$hvw||B+tLrKX*te)Q*U40UtL#rqZACZLnty|L&ur zA7!AhsD_5VV_pA%Dj~8i&H1|I;Dpm=*HT;bq~m;V;9s(DaOQ{x)B&ymDm#t>EE|A9 zkguz%s)j=v9Y5Y_^^BQ z(5r*M>%U?pct6xD>nCuI;k=k{)!C{|hr2-egxowpz!a&iH|AflsWiG<^e4@N6bEco z@DBIC?`|5#FGB)oFz$o^{^y$8vjw&q&f|RbGA@jtm&DK-%8YZ`2oU@{w&iG%< zGX@Ai?IBZ_Zr~CgMj#@rOo^cJfPav6!4|S3o)z~SlZ77Rog(CF?EvUblX*PU$T&f$ zRzVTNejEg`++EPth#It~WOS_%?ev~0SX&C(*ZWDmM}z%!pfP7;h06x0j|lYyR`qL8 zW)#@D_@1k+RQmw|f>fGEtkQz~b}az5^*)9L4X z40H|Z<7>_M`T+^!k=l*MuJYA8xR3c@qrBIM@189^YmNR*N7!D}%_FHy7s368c~5?j zEgo+j1zR?Ft6nK{cjz46a_+N4iBnfHz9q2>fl3JW{7A1MP&6e^4T7q9kFAe3{}FZg zk~%`iJO3jD7d38^a-h-VYaP45hk1N5pvt-3xxnf4sQjHlqioGVuv}e#IE9oy&8B4%{SCd8U{q!+-QDWefgxQY{gY+@ zE~`_R?>9uFJR>4g;d{sV5O48W5gZ)!oSugS2gEs<)!PUKH%HI1(#RRF`c+h}je9rp z2el?+2@unkmGm71xR4%3g^`3QEKS+=GzoyK7~&yo<#u5LRfLZ=cWUq&T4Gcdwr~^C zjI%X(L48}Q_!DC;MRSuaE4ZFwmke+w&5Iu)vI0y#TN0Euj5;Y>$uXmbh#{6ZNY>Jv zw-n!$?N(=!c9kB>!jcHFnUtm=+gv?i8~Jq34$nwXuK5OtS~Lf9s@6_6PD!M-N|~tn z{5uB(Wsw1|Um(BhNZP~B7f2Ci{vVC7h4DoLi8oT!Js5=rO&Oo1@JR8eW~=~%nk@QS zZ@JjxC%0R&Vc;$brNP(muJC{aeM%_3*ErQuZ zt)3LWqSZ-io!aUO+Y&r8=1EPOnko#nD$(6jWp5pmPG8utMxC;;+M-{tdkAv_bPC*9 zdsa<1ncVT8xx(MN9YYKCE zR*VMmz-`MzzT+NDa3gB(2nTZR7V;VKRXwIhAg0NTsy9yb zzq5jA6R6dlcx`fjbM73tQHWnmOL6lyO|#NgQGbr+FnR3G%Aj(}J@MD+MN(^D-M3OL zgAF4c?Ux|6U=n6(xL(k;v4QgQA`Shav`=j!f zgQI3hDXT>7`yt#34+e-Iq{IN0YLV#%-NsMe!cd`9Wc1x7EuirODNQzmV%wF3XYn%T zcU>mVT+9>ljWW`&L&w3MH$7&_t$%QPVk}f|nz{j6UTIx089Xf(gdq19X;y8*AMx=@ z1n*Y%bu&@QX61i=;fPzK>P)Q^l2S?xO1VI&dn{u^swvmCo%;D%29SdivgfyE`(mbB zQUrOLNLVODnDbtUYyTi&_+*z0nR5f(EepB4AO#tE%~{Y!MbQTF1#FE2a`YgjY%Uf! z3Ss7X-0Qb!NgG30PqOIGGI-Tyc$uMbvdOW`jCU?ka6=B{mGNIWR61Z;|1_P?ZMNG2 z!W?^X#9X;cxIeQ3yL@;3$O{6r@^4k6fW`>msTiyI7pEJ6szd6D1XGd^Q~6C><2I6J z#NCHdg-Cp-ohqoKZ0HX`AMi8^RgGz1d2PqjnN>s%QK{g1@k%;AtTH{;(+Vq(qR>s} zLWpa-P7h+OLtu>)eCgw&0NDzEPD45L2qBUWHxk}FZa)ZIxwhtK*_~lJ5mK+dXK((g z__1`)=Y)hMNlkS+e{oQ??>ScgL-Z6y{vFCcNDH|I8_BiC#ly#9owYz@*hBg0v#z{T`XCuOR~L(v5s=;roB~{EWK1d9bxh)+eg>> zXK(-qi6qz{P^7m zc<(PG%J_QlqcusIdj;QQbG^@_(3YgO(Y)#F$!RJHtCd#OV#&3hHT|U*45@pCZ5XOu zkOUg*9=Ci;V-FX=?1w7}pPm>xvr?Kk|Cf~Z3sdF}`LGgjeLKsKFrL)3HSCUqC)K9y zNSGW2C9;=6-}ihDQ;Ej`l+-t_jwB|piZoBVx8qAxU^zpf?NgS|fl1@)Q(-CRb|{>??zeEx&}saUXnYj@dgIM3R}|{uLr0ss z1-e>tT8`Dny4`tnNZ^4Li5WwmB?m(6~^Nz$%{#`!>}o9 z7SAev@y#U>3A7J0_2-MQX7c zZW3vz^Q2z;K69>_NnMo{Pv2a6ER#WZPac5I8+WbJD1Y_iQMj^H_YZ^VToW(X506R? z%99cS)H(TX=oi(jJy982m#5c^3rkQ(`erXjv zQQbqtP{HE6b#`O@48s!{uT8i-`~DG9l0Tj%P%Z8=0mfS_H8t^22bBl>4U2;8+C^m| z2~vd}fAovKZR8!3_^hzWVdc9+oU@M+C-$1jbfFmT<|%-7{orju`)UN08|??IQVgh_ ze$3v1W1(g)BLFzVboloRC|tYepJQEYNq#elXeu@ZFwK#0l2BNB7{u&nLGF3->K*Ly zLrXxulT`<~Xc1+AA-NGT8^=DS*?Kdi@mpKoxqUetwH&kJsAsLj-Y?%+S(oRkph2WFoNE0Z(Yzon|TNEjOSGND%Yj zt1Bu;7@0`y``7)736t$dm7;T3m_8`2sJ!VcRlWi4$$jPX0undJNh5=wa0*M95KN+9 zwCfZvkm@UY@N~8bZugTewfbkj&|8M{7C16VmAq^3J)1K9urb9GxaLwqgb@bsv%N|n zModUUGb?poDyw)j=pv!!%YZiK2}pW`o#TD$=7g-BXa0u0$=@&=4 z`7%%8eI{C=kB@dMK0e_pTi34d@L8r*5i)%P_#r*Y25>jE1ri!yAM|WKVnS>W2Qgi| zY5-hIym>9)n0|P^?esU9ZThC_}`R>ML{|yEEU(8um0al z&uTK0n?rC3Z0k$ul$jaR4WKHG@Pq|UqSBad)I!q(HHn+@=W!O|&aSo~GI@HrFK_tk zW%korc1^8^kxzF(vI6&)2fu2-N(!`MGdq{ROpyl{n3PAipaKb10)O17i7Wxpd!B3v zn|d}t>kH%Kju&0 z!OtJ;%td2zbFwD2B;G<(66UfcBHx3s(r|KDid=S9Cd^I|+2 zw!cN?L=m4=4B`ttSHM<@ix+t6Jim=N z2Ja>Iw>gDx_~iv^A_5uH``n-Mz|Eb(29Awl>F_ag(;^iQUe~1}Dw_yDmlhVq{&DW9 z_JwNEa*Y@ZebM$Bn9NgzV<{iXx$U@b%q5_3@VDf5A+!JIH~w4!2}E}Z1fHtR+D`PI z7N*=vMAgtmR=mL&{9r)Gx9hqO%{IbcgfN27jOU+HHUTJ(#JI77MEN6XQOv2dQb-1j z2IWlyVw&aj>|{w0$UGHqo1>#GttZWY%?n+J@3eeA9vnGDwxlIH_&eTgC;?R-x@7%qsE z2jwnq2%HF0zc^-xyf0s33;@@)Zp1j?bKV&l*|9D6H7xFE+vvz2SQuBM%z}0+eCMIwWY#}0`JV!TJZ5I4KL6!)iR~Mrd zI5lwf__XId`!~kWm{`Gt?CZ5GX;lLjKN5OJjVL4>{ z7vFxH{{^I4e5<1UgMl|pklIu!`baFwaaPj&pg^7_6-ewEzE4*opcyeTDyOuSI-1;; z;Pr5ADEQ+B-dW-#e9#o$-2Ah}DTfsf>s4L>OnY%R=BiBeSRTPJv>#(0Iw!`mNFYJj z#;4kxs_=+T0ez>~#Y3Z)q){9E#F4w0wvE$xh*@PFt@9Fgb^tmE3pS3E?GpAHw(D8I z=!BKZJA-+u;CoR(>E8<%l2-t&B4Vx0F8!=yj6bVucx!thda=y)vjr);X$s?rl#Io$I<{&HK~qsE}2fx;|pQFu~& zE2Ejj#rEe378OM{FxpiZ%^IZHtiR`S#pkpZO)v^3B1Vk5a;Zs< z+sAFR@&BX6&iKG17#03bk`3RLj?NTXUyzUcAK;s`PTgLKlE`?AtMSQjMszWYdpmEz z6*LOu9cbviT4bxxypKQEJh6ce%nCOi8JgyU^dPg}H4ZseytW9Z`YH-sAyEmLPKa+N z(`s4&ZotibvvF{N+%ag4Q2?=YJ=LTYaXpmozf>PNJvV&*3DA_PM7H;$Fv`u<4s5D4 zLv2|;39Hkg5eUFVQ6qPkPG)*Prnxvb!iQZL=-xBX;?i%(a!F#jI0U!(quRxXjtA}n zt6Qq`c)2k}P`D>LgpAw--Au$!0Niah8|FP=xu&4I%UXBw3m9$t(o<`uJ~I7dR4EQcydBS)jN}L zkbMgDbAflrOSt+evh&iDb~SF8#AqY(txjXD$=7uJCnp3HdUrv}twiESAL42&eZPe2 zzUg}MX&^cVHzhKG{(&L3-D4*@j5Lt{Pc7K7l36HrYt%HTH9LMNCt9+;000mHArc*1 zv`|rVF8)eH*73~SOOr-VD5}R7S5d762M4WG#LB~%I|xSRnDQNh@5*nS!T<%(V1i(; zy$kb5Yo`q}k^!+8AoIQJ?5%aa-ah(@;G;{vw# zNg~@cEa)CZ49mK6C#Vcn%x;iJmiu@u*bd4cQ6p(`VxEY*lA0KZZG7D2Bk^B1b_1#C z)TY256jW$tn(ZVga1K+4vXWqIwJ}7XJa~>g)3hg)7k`&g_v$1XZh=lYXorQ&zB_=q z0|BouMwc?4-d-cq@7^Dzbi1nrUCLw6DfCO2go%ohR&NL%+vvp&cg8z@1PF2UM7n@L zJ>=GYFOzKfp2Xsmq}U9ehxt|76%-s0XBg>a>&mZIqLC&uCk)o*omG}1#PvO^sA(F* z!(9srlhBik^$E!B@4n4gh7kPXDrulguk-FnGdth+g8t8k;UZl))1lCw$0{ODD+=)! ztxR=|F$k>uWxFJ^=wBG%<*d*p@+tVMX42{NsecVU0U&!&LkZ7p)_KbKwFyHRdPzLO z8W(hQmp8-t&^Dvh+z96*7!VZ}G3Qup9e#jeZ7AXj;HuBJdFdYbcN%}IR3j4Kk5Y@y zycS;kT$^vu`_6WvZ|(7FA8C4=>Yf%UPJuoUvZ(!|z>78gTfRu&#LIs!U<{-JiPKZ= zcnR}hHv-jQ=WA}#JO=GxTWzc`?C8QAI9YVZ%0U}q5F9m z3DD~2tuELys2D94S2Se$^sopUrUDB9h7_wAGZ_-bLlQ=yy8J`l{*9C=x#5rfjAmgg zK1edF(Uw{p|AKGfj}e3TBPGoLUQR8}HSud!87EScb^DATp4rLOte7sYg+$A+@;kV4BxICd3` z8-MkBys`}Z!xPg(1pr$(nQhCH|HYzKS93vAe)2iQlx2LOP+J@^T49h6IxkFd_tA3M z@Wg-&KgXWG-rqY%y2&Gk<~2o#qv;@EDFWaLs(U5i)Ib0qwRJD{d^dAX+BUnfKu7&f zU5z8f)+I3WN|$Mt_Y5^pVw0Q32X%t#eA*WFox5_}h({S;axSf!Fi?gK67zCFWG8$J z$2yLTXzELP(=n6_O45R&AmtugbMcArk?V!bJD9ZH2f={K5w_c{(nL>rs}=j9pVv?s zFZFHNmyOl82c(&9?pkAh)M`1@*)r=_y%j-F|1td%Vr|ylwHNK!82TZhQhwqQ zkBY=!ahZ=;6HabOKprXOUKH`>!EVd$r0l1N%jCmsU$bH+2_BvG6T{yOO)9dt&+UVv zQ%UGuc@*363sV_#S5$@r+yI|e9UxA~XJW8QDEDp!Y=Oz?V?ivd5<#97m}3{)5N~9Z zr6F#7;5F6!P8#LxDKcIQ-qg$c8lFg{-EXGmJrYC}@UcK`+hvY=Wps4{6p@OgfO-d! zIs2t^L=!bO3PcN{1Mm|Ff7X|9f_~X?N@y4HZ$7D5woF~8xxfvtP@xS3@a+R-NF8KX zXP%D|=nB1$`rvk4`l!aPQy?lkv6~TOuZB;l(QSP6z@p@<0=Bhnxl?J+To64c_ z$YyR{649@|j@dZva<#AmNdND_P*bWXE)E)E2-W%Emg?q;4}pN*nyc1yu3hV#cVIT| zR}#Lw2c~jaf-hr1l@!?4-xTj5kAfS2vLAzpssQzu8P!)d9u>7B*V?_ApIxdDuJ$`T zc2SXg&LYrPJU6ibzHDZpVOx+K6r4TPNzP$alD{nQibM82a(olS5Ay^KH|N4^UurOF zJ7widf8lF(ipcYm4YBT!yLrn_PD=i&Q)=|+^X!k&mfbS;qQ=XG{+ngV$^yE|rmZGW z#(gAhl}oDga=P}2d4qa(-kzQAIhB)o!o-qqk8E$jrIRhgXKrjkuJ&2;#iTrEstZsT zn&2gXf#CoC{x>$SPXGc%Ao(v=t^g5t*q-MHhQv$x$*=C5Ns6 z(Vnv8>QzgtOhNs zcSZmY{C`?0}D;0 zlBA?yt}Tt7J{|?}C5@M@_LZKjB~PTF-H1`Fry=r?A9=wtT?5`P{hsMB`kEZpIin0P zWPo8hD$E;%6e=tQsSv`*f3;SmTd|zYMInbT7wM)Z@8J7U;DAx{Z2na3a*_}?KBx_= z#=*@hYzNpZ=YLsm-=pzDeK}$FAh}xC8)x&<8JbbVMnGJZqm&1VjgG z=soq{N9j=`fVbmm|kg|c+f5}8NU7I=Q zXVK+2F{j)iXEMHz=Jc~W;#qIeB4hLB4^GIIu}TNFTKC=33ix*m1quH-GU8b;X3>*P z0u0`FeoaEh4+#ToPE2T*kem|f1k-5wb)Vi6+4J#~mYWQ=B^x=`sk$Xy!v@pd+yOO~ z7(cUPI6S1etczW*v-S>Dn0)Sz2bRiw8ioSnqGmmTE z;unK+P{!1uYCwPu5@~48g9l?R2v;=l0^J?`l5Cn?(elYQOz_hkT-@;~Isj^b0PAPw z_tHtshEPno0)&Almg6&nr!{pC9Z^)rVbrS6|g9g&xJ!iXNKSUZ7Z4w+h1@b^Hm_?gS^CscFNgM zrtC;OLpoa3bFqkjV-07g+=+B#UG&CYG|drbdE<0Z(;*DTpoNx8t|vFYJz= zSpD{;O_6knxd+yFN}{L+UrxrB4HZRGA1}n;*+iU-I}G#EX6t8&$NZtz5A!!>G3wsR zp&q1{`Q>Iti2e^3SIc!{VF&-0PO1(7w{+}bQXEVDg zeq=D`Y_^RSyWa7OObk9h>k)Gy?$>Y5cM}@XrN{$%d_Tj|Civupt}u<9Ba!uojiZ7( zrtkvQujMu0Oz&U!yo!Uo6SFBvKyHbsL&s@Z#7(5;7Kt{zZb=;JMB?Ir|shmgp z=!nKEeeQ9jRF{onDFiNRPkVFbIoph|HMBw!D{at9dP@92Z&{U))z>unAA!f6Sa@um zRVq5$a9ykc!U;@@l$D}vzY_Fd0LICTkU4%MZIfJSyV7xweaRNRA~KoKk^A9`nL7|x~*Oa zC;(kRqQ9Z?5Tm-?;0hb-qkwMRssO0_dGa zFuht|vywk6{X83zm0_?E@f$b2k>~fqKW_b6(0~hjq7+w1=PPdp1a1#SQr^n`VBOsf z{6vlqbp_l(0Kuf3d;ihq*A(YJ@s7%Oe_#*b2lx=ZXORH}Mg^Td>etlTFnBKf745d7 z5-_Xys>fi$8eCdb^bL?E-b~rxZHfUyq?k+)*Zv-GwP<^1sOW=L*>5);Oxv&}x|r{_Nd-iPKU%v}InS!awXHK)|7=j}n+xotjVrnNUgTr1)2ACUq{6plsjYxom}Y$x@;(!RJ}JjZrn*>aC9|as=8nDku?SHs{M9A% z-crYNftpKwQ*{!9`rgh;N)jpKO zjKx+n$0~Df(B;^}uBqad?WE^+|*eq)pwp51jA2CY9Ip_BNlL zV72fx?7LgV5L9p0IANrKbMDYtc5KKVk~J_lX3Z7tK415kv&}%Mg#F|ysfXnWU3%;O zM6-co?oJMl9^2gd1HvK!ae^Jvjcj8~zRV3Z(m!`G*+rI~jD(*#kN^M`9R7)^rIHf! z+ul0R5DBtgqQJJG0m-dE0Gi`y8E+shcj?|bk?8b^gR`eWn{^t9I-=QV1c%4lqYlJD z#tn-F*^L{yCkO>leX*MM8btHg7dWy;xgQ|l{JMx(YudK~6?t%b#Q&u$67!*FeA2Ul z1gLK204ROW<{g0cP~CAKRUe{3yT$6y-YiLcxCpz?Wan($-k~@CS|16U_tRnP1h7!J z+W?mGF;u6{RIdwDbkMN8_R2OW-p4K_irJAU@FZ0|E*tU+8Oj#`@vj%2aZ=%_68&tq zwmhvUxjJGgOrkH+U08|AQavn$S1J+eEI74(AG2UQj(8UiVb&GLXH+nFJg z=i{2_hXd`}=|J#sZe#d7xHSOM|F1zn(X5$QodQfG5xWkaSjZh{YgPd2DNMmXvA(ZR zJ^k_#s^^iG@hctpTsX4cZQ|Z4-uC6(&<5X6rn7A?&B51Bu{I8l3>%DX)C&b5t#HN~ zV}7LZ7JkU1IEIxG)9RoBcg4$Qc5Vh}K%xFKZl)ZnjI@1Faw+&*E%b?0W>{36s|ZB* zBJErX9BlO4R47aq9^%a#5-AbFSqdGMDvPmQo`|6c<`3q9T0M_+0fHi4L^4JH5c7T9 zCH;a_rK5VR2a#jQDJ`Y{)|nmRAt#G803}t?M4jP@*ZiGL6!$6u3Zr%^pcs4ehK109 z<5R5z%C5pYAa%=ZUrj#+=>(X70AtKMPhSNLA0J$he~HZaMVu8p1G1B=d0D9q=e{et z>MCP3Scu{M!!S*SCUfRDSF9;1D5g{=IcT=j9wePbWLGq=-V zT$5<^QVL!5nHoTBM>S+EciBN7UOzqW71TvN06z62IUPkhAvjOgsQhsYoDg5nWikrl z%k7~qxT;r)<+6TuiuV@01VWs08mMrA3zFk3U{%K|gba))<;2>3C9&o9B<`d^33!CJ zRk;Gzh1>fw{f(8`<8~`Xf}dUPnAZopMI=k>_4>(W@tl9sv02Qm=Zr1x8|9hRQ6s}l z?YXkE|F*{$&#VHjWgY>P)UzM)D9qwfc+?s8zF1Sb>5=$heH?{9xI;#_3TprdP)#a``#wpbSV8IxYDX{al(Z8Ewhs&{0zVG54*31G|&Q zsAP=x>z57w#wWJLyXet63s7>2$&zg>S=$`6FrJBAm{Y9TXMMsi++#Kpx%!b0b7x1- z?06(|G+4@OYEv>Nt^2EKQ)F~#WdiEO4VF`_Kr8h4}j0@Tiq^6Y*SNc`Gi^JQ10QY#(e<3$H_W{9}0 z%-*RMhD)r_iShN4=7|%shK4~-$H6rGX(SOqQ=oa+X&gPv7qIP^al&S1b;ggEtXC?q z$}U90q!m3i6d!)?r<3D7y*I`b^CK<3$DGg}28NKxE+yFNW{AKZFr^&KA-+x9 z8|5~f^Pn;BvXot2n{i5HGE;AkA3V$FQ*Vl7XmFs1%ZEZ5Sjt!@aX&>W5Nx|{cCXD` z6sv87DvA^)R=I_h_m{h|Wa%~OL+BH0KCvR$ffgd`aBJ6m+Br8a#{A*$zTcee5WQ-A zn&C*Cz_F$aiy>-1rPR|itsr_;>lb#6OqHcEm00W^%Xt^NzRi_rn zkl1jy`LbhHTF7@EClm=mFCx_RFr=IYDnXs{Hnd^c`f&JAjgOE|ZgRq~CC3cBl?6Lv zy$5`b<%II4ws?tGfA)u;B<)ka%nau@dK2!ck%TcDv1VSPN~^?iLtr$RlNe}!@8SZ= zor3{~8udYEO`Cwkm;j#zzF1*zF_EWOy=!)M8XyV6Oh06#Qqv{N`5s2)lRM<#MvTMV0%PX;Y!w79&Hnhk38os7U2kIn_@>)@yRe z<@*e$&7R@cug#nlJu_V92yBR|yv?JoxJKs{BNP%0ih)>Krp>;R-M6`cH|1ix z<^^-({udghY>Z!1l2SaiA}XHaM~Iy&z=-sW?MgD^wu2miSr8;`gGK%FuPhTnUl%N? zn@>$8En_M$5PbH_tu>MU(oTjqfQt#6w0=a5v^P@?sgxtLg0dq$+yd}Xq@Hm|q?c6d zZ;{;v+vnaxk zWm;By>Ir=WzONCmC++3`>;j4a8eZA~8W5WP2d%n~^A6pyGoiczVU1q zkYigeiZqrDqY@Dl6dyZNhLJva_lUe3Ju=R#m6tn3%E*AL#T$av?BHi4{gX?4fl zB9H`D0E@iSHx#}YThO{|7&%CJ8=TrqO1l6;n%j(-`>>l$cBXbqO7knsPtlm&d7j-X zn|W$`{U2Q}dEGCJ|Gtu5mV6b7CER~5^Xw><2+{H?3qo;Lf?pauh4Oz(Q17li4*f1L z!n^7cs11+uRg^lN>iEHkCkVEm-1Vg?A}yxma#aYBY0kQ^;D%HXm^d^vGzfve5oH-8 zw~-?jkbkB6m9Tg$Xl5b%ong!V5?5XWK_V|&SM>+iwk%6-uzAFtPp8^RJC`yRgye$a z4GNo!p>0YKnB@wHX83>ADW}dRG}C3$1NP+S9;aA(XR)Tu>FdFxsEi3H>SSj9irsw@ z`@cQ+=8yBvm#p zn%T)d0$F2UfIQl(MSw|`Ef-^2{e1pI8jy@-m4Rc%qq-`$+m^95`ZmRNc?-AT?a9#r z3{ibg35S%2>croqlgMfXSX9kE-qoqS>e5{GRjb?cEAIV|6@HLmlr)!sy8&pJMRWAk z8rSH;4CH{f@MpLXZEz^C+Il|~%rYQS>V)D_6>U}H?MgjVXu8tYAHtygC=oJP)s3Ah ztY$2WI1On0IP%IJZ^vDG$4`?Z^QmZ&k8a(qUwwE=-K#}?sCF@-%cHoE@WZbC8iqO2 zq1~vZESUG3ijnrd!!4XFvn{F;D$QsFERS>$%P}}ZI2JRO_Ul_=#6ltlrw#zhwwtZz zEsYBY>@J+i1XZ%180Ij1fybbdlv7IxF@DEo`g_N!TMzAZHxnj^_`2YG;}HuJg~r+6 z<(;|aEi-8N04C|_Sr?H~b^SOk8g%AIEo?!@eQauG!Xj0`0009Zi~43vcHIRhqthap z8(1Ra_1Oh`>vZ1<;Jm*e17lvoG0v;H3$qPG+5gHA{fKgwh&er5=6ncqm)x-lA0y5xgH9hVjk4m0$T;NC%p=8ai!L)-Y$I+qlaLL569c6fr9d^pTn{Dh*^X#?)dh* zdjuE&ZxiQS5s&C#Wv!7xKWgZ!fniYgR&T8OqHxjT9pWwbaai&2jK{g`O``MP3I&;}ItpmHgI$RLI0s48fv!QSwAHb#^PfEn5u z@KFk1aig}lOLnmkb{a`9(DtUuYo82 zbYFM%^pd{o5q5XfRV&z4pV0f#dCi9za(-erHz6qlC>sby1RV&1dT}37r{xf0Ok@V{ z9d6=MV4`cB_JmW(zzv4-gXg#_Oz=zC;~8JA>c=JOcoYFR&EOC`^`~4t5bVZ=EMpe) zF?9meF!b8-mRT|#EH_wrn3=V-s_kx;JJk^-M(zKx{AB*m-fl|j$oDacA|M~pTBy;OGP?=~ z^{Aes$>rsr0{)$Oyv4FtPy=qq3DMQ)+vblnQ=-wu6jBI#E2ym&Wx&9Hg=}w>4qT&3 z7YkETvD3#odyil?I&7e(-_ZA1B=Mqfye(tE;|aXj17V{6Fy4b+n~~mTC4#e|hz6K$ zYKES*hL4ssELt(+J8#D8#6Fj5Ucu4wN+^o{%3|NTNVYy)`uZiqV2)g}k)J=#v=!at zD*Xs0U)8a)aPqqSHLAty9y^@%RA&@YKm+YDJNhYpP`jpQ3|@v; z=p47?&^FB>lFyCGR(PShq9Z*DYhs^;F5^wctnMIj@!Kd(v7s=5b}8k+k<}ae%Kk?e z_d1Ft!ser9-sc#kR9IEKxuIDBA%gE$EYMs9q{!fVyn1P(Mkqt(67$>k{$bSA*Bcc5 zxyN#R^@ISNjJCblBupN?L{y$Aa92s8=fI}_A&9>#Sl)Bp_Q8lzA}_G8(%!QpnEJCST#k!muvk|_kcnJ{6Ni`QOQl|G%> zCkc%#=77?#Tq|dVmw*PF0R>K6@~LPZ6#+dcL!i0!M%aags`E`kh8*_T9C-6E=lt|i zL?b#K1^BUCYK>*y0$IgwG(i*l=E`E30dEqv~hsNIEXbolLIsgh`+97tF7%`8Co{d1MCG#0md7LY!!UVTt)QeT-lm!>O$(=aVpoGssZ|B{LOmtv~GY`hVfsW&OYynHv4e$PceiG#8XQ2bfnw)8HO3TE{el?YSrRTf+Lm9N5>() zi~D(cTce){0dWRm3yOU>8b(WI2-0!j8*&#Bi~C?zqJ4k3+AZE z9!b=V{ER?w;t72tAFdIJlR&elr!fy3w!=D}NG3&#iu`9$1$U<9nL(mv`D7HS;LSxj zo9Rok&j6B7NB%q7S1GctDZ6$;BJ6OkSidmMZO%7=8LWBUSi6N9@;Fe0ekx&fiH$#$lJKCmmmsB)R8)wKXB z16y1^s%Tty>~mB%v&DHaS>T=`H5j@HW47o)eOo`l*())LZ5F)R)ftM}c0&lGa;L^e zUcU)}lm_bZHU^Cc2q?aTx<5=coHaa2iZ?^37o&Ijvu^3;V$m?g@9PmljUuhBwVGduSq+cM4hy!u|fko2mk;InJ}}NXQte9 z!;m1^{7&7}8S_HFpvUm@j!n~Wr`)DYPV+_Og}nAy8Q-*9X6Ll;;Vyna`3B+(w7D+F z*lfe`|KwPTA|aJ*@mSxZ)xZqIADAy`IA`y*6ib+wms{0%^Ni?+6~v1z`$#TN0E46{MBM25=3y}k3>^7TjfTpM(I3(L97STeR`SDF&XQv(%> z4G)@%abq9OcZm~6et@7K7(4yF(?)V^NxW~KVd-CpDq1%19e77VOz|KzH9IqS0HO;^}W@)xUhvoszGpMGsRN4`vtA?x(u}2y4w4Sed1P+;KPSXR~M7Jwy-#9(u z-_cR6AVnVyoTn$wtt{OLeSPaM+xQegO=^iCh0B&!PIoqd7VQqbZ`BwC>B>iO*j3V@ zuP+eOROXZ*bOMH?!5gc7)@vOUo!Y(_!nDq<>SR>^(pBn2Z2R*kNc!*|CTFdLBN#1R5v4mhm>{YkjE zTg!y-4F+^hdW)Rlc;Dt0sZ%;L%WKS;X4Ij{Y>1`c+j-b$MO@25Toie`l`-`jof2}^ zWed;hs%D-f*5z*M1kFR#CwCm9hFtx-HcTB%9DDyK!;kogD23yM7ylOk0k`PqWQj^| z8Ea-CgqU3qhbKQtcF^$ZL&=Nq$BWoEp-5YkaOj%BXchB<@})D*x!o4H&x8une&ima zYq}tHyR-wi`?^gnobfk~7ok+2QAF84plEy;Qb9c}9n--^!KP|ANiFuS2=Biz002Ca zxj4k6Hqm_&zn;{}R@dHm-o$$DqA>OheX&U!s!nD5JSh7U>_^=V3af=D#^lw~nRf<9 zVb~H4>U2Z>?=5XTuMHUY{X(T+kWjWOS_J(V6#_$pJMJZ7CGpx;jkCsE_YZ1GhHnaL z#(kJ`$yGXYP4yqj72ax6<7y znv=zJ4l2Zd+VL6onV^AC_NJGgxk_zFq-Q@Abh2tFP-D4Wz0}zVFG9rbZ~2zqNbG=d z*%FcDeCcR>9ZZgje#~lYGkN6+V!q;~EpS#R<~1_?p!bzs%^NuuSNGh$YThE13R2_J z%iLTxESBgVV8=q?fWBUkti`G1E^x>k;rLt4!Ab@sd?W(Pfuj8|>$4vQAd_X4zSyYl zO4OeCF=GiMiD$`TWV$hbKbe{e9%DDhkY;3}9h*C9#VO350vg~xg(4Fiz9hwL1PMBr zfL~>;>jSZ;9p;tmyeZb}P`AT)+t%9TvM>(IYsJ(}Ux?cuT8UAwi2=C!s$)`tfsO~1 zF_q7W33d6r7z-85Ye(QTp$#pAv*yE118?C~!1unZ#ID!hqL0tF7&oa@UYn2d>KX#R z8}AX+EgIq`7yu{3=!ogcQL?K8Tg2RE+i~$)EdrK0-ad(JqgQL+OTiibX6`br2i?;^ zxO7nUlK=u9EB4D%zb7OAM~tN+^y-o9beqJNjW`#wYSXuio!^XJ){@w=XU*2I74+JT z>WokcN$EgvS5PE~*6~M2ptm!+;4A${HeCa5g_vnd?rPiqPP^bA88Yh?4^GC?-9dV) zT|8;QMB1)(-$WES1`^|I3mxH-jll?+Eq;ZP$Eb^gH0D|xO6-Pol41+eEAu42njVLq zk9_I$xzQ-UedQGo0VPR<1#kGNy5AZlvag0jpZRy5X^T$hTTs9#efU(i?*N?b!?=23CGR^bafO3MDyL6uvc-|IE{-}f`+1+Z?zr*RYA8@T}C}Y z^nA&$Jg5hM*C(IOa=?oJNc@cufSuZtJ(H`pfr-N$%`e0RZy%IH&cb4#mp*^`aoAXU zAa5Z{_{6}!l48KTT7{NiT#XR2A?>mC$x@h~zvJ<(b(+7>6?YvU+e@()wiL%|t4>&U zLFnZ21W2b=9N*E${AAY!M9fk+nN9i*_TS{UIxzQEfe6vjcXek)i`G`9?aRlt38UJT!7<~2J3q*%H0!i7wnoy&+ckfeK*Q_+s%|#6Z48a0nZD5 z?kwYC{eAMxR;+tWMYs@YiHnm`-rS9Y074)sbV&^I&}@L=j_jPyiqI$Y(C&&PUBDTD zqF4F=>od;eLvlPppP6eTf6`mkIg%VC1CEBrU$`INnIH$@Id5JJ4n1d_1&`oZ-UY|Z zlu64dvLY|Q001jFwP=F+Opq`Pm*pDI@=3$~J<3K_l}z!S%`y@%H(e8l5z?bhET>Ou zskU_9@IRslvPXtpKHvlHvo0Eq>=hk>I{;`gSP)&`$^UTHgQbQt#ukKBPb9;Ya41e8 z4Mh`^)fc)MWD9T=J%DPe>gnS{s*R}hkP@7ba^YuGUl&Ev5)kJtm|pB2DRRpWrPiII z2PTm2_shvODQcL=ImxBNWQ1?4pWfRHP}uGTXW{u8oG(UQ2#1uiKUQxb8ICU>;qM5o$F>g{f|{!wC&?T-oz9Bj zve9dr%I{K~93qKz0hu0oneJ2?kvQ9wVGzZNbu~8LlKlsJ99fU0tDCv^#&6;kb4i@k zAJ@v(RdvmJmcJZ(k$fUJ5bb?SkcAG(YdTp8mi_+9MO3H5t}=<^#bBF7BXQ=9Os>M< zr*K{8Sf^g@kL#2LwqmBVMD^GM4`2nc#1yUo;<*w4M)YO%6>*W; zXg>%d%H169meD6?tHvTOG$4M~FhXpg_nu)z$VlF?+e@=p=9GlOyQ5cYvDOJ-8BhgJ zl8wL|093Ro8p@MI9(69mp3TLkxIn?g=Pb)EonvAoyZ8Q1 z=Qv*<+4btX%x1#=ZqtTA8=HPUkohANrJjQ#^+|$ZgVSQmd+;l^Z>&yM%+P?H1s^eC z!1ns|?6<*cu-f6Khr+WyBqOC;yb=znNka$2bp4Xy+78NGihDWpBx-H}6JHH5dr7$? zj%W{|ieb@wG^N0>C4iwiQDJcv=TkJ3d)-u5g!_Vdu@q5fB8&&~posLTH?z91V+6ma zuwFp*@9E5PxNSiN(DqO-w2)^H1uSWUN385M8ATLn-FXV?F5h8+PT>=F296F{BT64B z<$nZV(f9i5DbjP(=)Egs$eQ$Ts;6;>!zf~JHLl>h8kCrEODscexhA;!6>`uQW&cpX zgzBu+q%SlA^;QIKf-qzui0aqyO~P?+QP-95TC_dXT@S4h%wy0s%)gU8in}Xa!rQ1- zaTF{7D`s%7CjVfSDY~P!+5l>SX}2`egp+Lgc0jSMN!Ry{debImw-x6D z8q?w&h>9`0EKzj@42}vT8aSb1&98mpk2^lmARC)hG=G%*c>b7c7N7YvnU2EOnG2J-M zbM*LWfuMD5wA-f%=L<16laiJkYISESGg1WsWGcS${0#kP9A@_S-y3n)PZIAgfjD=b zguDYB4MwM@NLpZCA)~P>0IQG2h@CS7efF`|aK#q&<=%Y4s3L0-&fVxc+rJbq0c|;Q z%k^L-fjlKsM zP4^d{=FRY-0#m}t63?G?%5yE1&=+Ua8h47M8W1<9M32OvGYB%C|3hf>(WXU}mi9gBPR$OFp>Z3W10h2yhMBHe?Jr z)3J1qyC1C7T^%|iDGnCJ7uc*9t-9Fzm|H)p*oQ8P+HVY`)dOWyjTGc?)rxFSP*0?fFjaV zgfypc^tQ`_FefJ~ z#1~AwX5U^i35yTv>eX+PYTjYQu1W@&n(qKK-%B!lquwa$D@y@@WX!47kEYC|Nns#f!oU(m0In9j&Rk>NZ{# zPL`Stix#bKJ@#u;Sgk|g&ieMNYWz3l5^}zn_VkPEFzhYFT2^aGw}pmy?yjADHbyCj z%X6`D1pr?F2gzR*asEdJIA1%d8252-It@4%2})HB=3SEjLn$5Yb88XxklYNagbX)c zD<)#`93dgyQj-|t?)E6Wq(b}JT!+$R)#iWRBC{9>OYYDO1U;40YGYXkR)B$G9?=8K zd?^=#2P!wBY$#ZM(Cy%yj;gs)^f z+*5<7mq7mPjj=jHv)wxbIbw|w(HHRpwQyxZ5G*;(aq~N_YRkK!tr~k#w}dIUXy4Ck zqCC!H?Tr!C)=YMl!Q6b<-)6~O=F2OvkI({gG$4=dQhPJFnX9#TeHl$(*M_~PV*X=A z-HgaHYq__gK)s8FL);`I07=0YaL9Fr$->eK-ZxN#LMiklA3QXCvx>jVXnli?F%@l|+Nx+#()++z6C_~e6b4ee}`Y6dBE z4a>plIbsa#c5eSoT?53~JG554lo_fq+{8?nJ zIgYTNz){Q9;xxR1az9-yDmh1WBmqI0>Kv|=N)&)?@gH6%g%aT^jqqmt8{J8K)(Z)D zs^(;2W(Pd1-c+gQV|)+I`;DY$l(-q1y2`IUT-of>!1&yKzwZrpqQMVkbrqZN5y?Vp zLI3~&)gJ3pYGhehR_&oAF^E4{)^!B^=P*OQN&7VaI9-CE`sn@{_AB}xTpLiXWH?_G zDv+3Fy6&&&rxwM#XM&|6=$1lgK!u(#w?IPqMWt&?!p`Qg7x~wF=IJKCe~0+?D2n1_0P_+=;9_4nqjsDCzm<=`>7hy9@t zz$Gzsk|P>;yLt!jJg^JlF1@NW#X}#V3LRn9oS?;mHtP#2FjmXgV<94;ELNunR<4tj zWQd!yfXyF3?@^vhTlw$ek0PmfxU>69btkIx;v{b&`rss- z6K7?Z^oy!+IS*3Mo}gq#b$AUs*?g_uGj8E4U+Uwx_g0M@6(`0Jr~iz-tMG3jrs{hK zR$X}ce9cvBuzwaWCD{iQoXeo2EkKmT+VWWu6A>qGSA=Is1CYSQuCExILu{B~W+X+! z8(7kYAmnKQm6K(N6tcOuX^y!Ej%I##p|CR*8r7B80~Rrti>wurWRzW_W#oazf00U3 zC07q&`uy;t8yE|Jtykj?iMin^`9Qesge7w9&0=B096thsu7f(;`K~k{a?jphE5L+{ z2k2Z_vZ;Ul()L)cYo8f`cj8i5PElduV0>?WE$M)uNvVcXKCUH+Tqp(kj+n$2zNi7D zhS1`cEuG>;ri}@27)>PyompAu2?w%0gqccFFJNBXZoe32uqBJhjXi(fw!fQD=bTLR z`8jE2w@JuT)WCmb7(^$mj3E$CcIjb~(agdPlyB8sPdl60J`i+vhBy?orQ1FAZFAlwo=BpH%_Am2_ROCX>4!2MYwLqI}{GD*+P`5 zfHL2(%prgxZ+>LL`0^6#@OHqXR-d?fgyy}S*qd^%%1$N6C^i!$;hvM3S;mm_Fa z*DDBnkdK4<*K{%eK=VYq3@j~_H`^LTsv7bcG*P_D)z;ESY;Izv_OlJQjmf{|JfaUE zBwuJlqgT3{vzdpqwLV`mhl^auK*=dSZR@_MC0j8_y$_aDsYFn?pp*bZo7Y~+3(c}6 zB&^w7Ji|dUVph5s?S$L8Iy}C2Njwbh1!ZYR(Po85>eUs?y*$(1@r>c%3`HYLdW&uRl5bmepr8!g5tE9-z2y=d1@GN=GwE{OJqPvoDdPzs#J!wZC6>;!{>B zAD*)GmHB|t{HWn)8%hmCu}#K`gH+!v^3H>r1v#S>d=&@h%4kzSkiM8fpIIaz(xu;& z$oW`S$JERA^7G$xg*2oCjkvfvSBLF~=n;%U=41fR! zod5^$r>Lj0EqVEV!H8t;e{&yK&)WEi^Qm) z`NHIMV_CHncSP0at(0~IGHnt8g*v=;M=Bz;v66E#yqw^{s=Q~2<&r=fCo${WWLDH}Lv?0*3;t5wZO(7MR zh&Pfcpix#&at6aQ?O?f?Lj^TDTb13~H+WpGP0dtt#tV&~aEeF21v_L$c;CM0PN5jh zPlOoV{m+aK8>l=bNAB*(Yr2~@^S)6vm%Kmn{Bkk=0qBvPE2=;w1c*?CnT!3{*PN0% zdZg$KlzF1m@1a|?md)```#1&D$TfYn_-(Vo+!)0`5QYJ(@j$0cEz?MwpS74{+afLg_sRY&P$N^-Tnzz_A*|OS}lL zKLG}4>`ml^kl1|j*-l8a|b&u~_LgC4lmP~jO=3J)EB^#eV(uk_nn~-0qy<#%5hyByXu(E`u`|-E{ z;-pIb#5`@-7;U9Gl+wgZRBSI3w5^8RO=4iS;~soKdO?gq&!P2~y2z6C|3*?!;hHzQi8%000K4 z0T>c@T>iPiM>sG^uiF4J<)!xGcb=lN8m4Gw=7x=46rYuC)&Hh;wy36w&B7+_*`4vrhE&}U=Zc#Y-zlXzHzH-jwG;LJjjkVN#p&E`1L;x1?3r4uV=@wcT=>OE~yyn$*FWxpI0_K4hDtNeyk3-z&1~r_LG{p1xMhG!n^CX;=wA$(qKn~ z0&QH$Hr@;r2Vna2P(AcBI2oLjEzAnfcqSu%qg;*?{xw1Kzo~Vj1h(dG>mOWQ*gWAI zq2Be$7)px_m*j)?1pK|2EgG8IUEeR2BF?4sd}eusqg+Cs)>S_+Qh%*3D2h;iw*tQV zM~zPuDFJERXfVEEEb(IhDENevQfzi-WPrGaHMJiYrS~IkvbIu-{8wV!GkCdy1NDVf z`)f2}b>be`1a^7-|Gbic`%h7q*Dro^U5xof?WXV>JZoY-tzEOVioFsTH#dyI%m>W__%0Rf zW#Hg)wFlD?X=;O3(3Ku6et+sR$ApRl=C-Nta*!y=+|ZqUA@;G(nHMr6U~GrBRxo)DEpA@5(^R$4JUG5} zRsEZD-!uVRGu&jJYW+rkN&91$!o$SvSE#~X;=!(jXfDoI3A#BV*n@_4$J|G#&I{~@6Hi_02mu>y{m+ixCb=Bl3Jvi-YYhcPXV4NJ#}P(%C^;Wm z<;agJG8L#e zR^XAQOk~3ml^q`Ec>bgiy!-%cy581dOVrK$k`YwWJcx1F7sHnGJf?a#wo!Z{hs}-J zH+0;eQK8G6<4WxX)T#nZG6jxM2NTJ{I?gZkBEl;Ag-H?eN#QXR(CuaL60Sk;-MBwa z5!hpP&&{Uwvl;&Y*}J))}$Oy|5sbCwi^Q2gSFMu(*vJYO5Y-(8xFBj_tC09g&HHJ$Rd1s^ktP#DA zJUQdQy4qccNQ4Rz!X@_Mw!BP+W;hu6>O4y`;V9M~5H6PH56!+B!#o)HB)+|@2x~&B z+bdx!$Y}kAmd02@*@|G{k4na1D3HYC2gP$I<g9<5IFLCIT#*EPqW@*_!wZ*WfauU#2jakW47(}GNv1+V@4Xy-xc37+s7A{gLss9 zu3ys^&U}fP0$xuw@hvOcs`OQ%nf1y?96U5BQ^_btJlTJ%@T*7J{SAoFGCaZx3N~%8 zflQri0mmYGjsK>km?r&MV5y*Veb`vw90iu1s<+C5i^?mFafISrFcagXiW&5@^ecR) znhVgB^3o{tcIkU!Xjj#Ec|huZdJRih_26`YnZ;T_J(ApI@`{Xc>`fY}#&T0*Zr=Ut zRfV}GX>~G^=+R#hHY;n$TJ2*12^Y=(q`)0=6#1t-sr_h^;ceIqfY!^D`br3_BrVD( zy*GI0xj#*@3Mgama>dPPvcg62$(BE?Kd%&{OvFlM&rGEIwMZ?nm^3_990X#MV`UVU z)y2S{6Lra~G{A64=|Vo$4mkX9p4NKA`Fq^ju&rdUP!}R7QRCB}+$hI22b=IlxQN54 z=xm~Q4yL}Wl9X(X8sfpU0kx{xWY+~USSJm5-cR%J-bDZynfsZWjF9h|3#X|!v;F%n z8#v5qFGX9dNQH!4 znPGdXu{5;sVDWwHGboO`ii_$1S~M8^Hhfpn@2kETpkAkQBD=ei0hlA!pyDfyTDVQa zJ1SdO>w}`pTMe`CKOXS z)(QNVK8`jH9D@@vYUTD4bg$Ueyk6-!vD^9m(=P79Igq%@6k99DAY5C zc$F2SZ}|=uqcdO7eg^h~cYHguM3ph=ARA=}s{b(+-(CnBRg_>4yOWmdzcK%XM*GJiKdwRaH!GB(h9Tcb}$npe=@iH6I{@cDP_^ z?(j<&UV;gDeG`tFMw$k4()P?l0Qc%^4C5UgMmNf!kH{`uCj6b6=_!^Z#y7dP3q(Ik z)s;PDu!{V5_d}t+2tb-d-(+Bsfua7twVojCiLFON<9;>EyC#q z(r=fEgbH(epIq+>d*joS?&N1@4e9O0)tYlj5RD*4X{3I{doMchOJ`S0{%fK6X*vt1 zxJ=6+Seo$)7z0#n>_I^@uvt2gzlkjRKk2WnrHFPU2KBe|GO=!Krtz8Oqb!;?n$n0e z4S(MEEkLv7y!I9uXUZuX+UJwx=IS@vHmuvvW^dLH>-PF?r&C%3*D@w2AFlA*$kSN}vksROa2g*r`ejGd?2)NYk}NfGkv~=brE1rFYtpVMgB7WxFZ2V4RoUj58B(kvyQljNLiV>f<*8SL zDJ1;8*Tq?&%^(FR+UirSE9&0({3`pqD6`% z!s(vW6{h1fCkk&Q^W*@qdR5%VtKNHJ07Uu}c#1G@vSnHeNmV8F|1CPK8}lEnd|A}_ znlmy&fWW`>h2R3%F)-6Elg-t^fcAr~p_>kN^Mx0000001CK60E6^? z$^YN_3_w8_$J&~;_)zw`XNZ6ePx8=yC6nY@YGQOP9Q028%l+NOQI7VRdfZ&PQzsZP zjQqS{3CuH06;629WUS0&y0#L?Ns%w#VUz~%@#-{&ZY0_k?WQHCm%rxCA<;Z~YvTZu>QF~;^-GS( z;Y=K^$}*w$My>yXlZ65bE~Ar4P8)v(r31w}=F0UORA&(L`j4bhxq-OtmkClWf98%P za;iG>av&3I9*)iow}Nw$Fjzw$-&9eQxt~}5k9CBMzvuRxf7kwGdDFXORUoMuLlB^a zNW#SrX1JMx~6aR2}ZtpEV-NPqwU0003eIy5qF`lxd9Umv{-Oiz%qjotgUHg=H# z4SY={{il#3bk|jpLMn(<<#cfF*(I}K=-|M5>X=20M^(W^S*uPO@oqemTV&$iTwWA3 zxV;Pe1tvxpGUKSK^{4))=0FF~jlF#d`_(NU{gC20ojiTJ(NDHtOKlyZ&*Ihe+P)al z=@=7#QX^FgzuIAyNKRp^czD$pXZF zp$8rWf!-dl!&IJIs$pI`IFUeZyHaUGR*3UMRqI#K;ZgGVMLaG3gxY_i5}5N=Rcn{Z z>2%oA1*%sk7m_$ei>E{9Wi=LRUF<<;Ou!eOR#M~^u zoYiJqYZ~DwEcSnN}$* zyU{d@U*h!Z!WdKKKpQjl(GVPg1HOne5cMPCfrHY5Gm}}18MndcVX_7g#)=jna{x~w zl{k0BSWyULW+%Iih}~u!GiYDbY9MTK9BA5 zD48z?Vo^e{AH4p-F)fF`%?zzJ-hb?Nr5vPT~Z*{&SIoSRdS90^9d_OrE$QWinx|6g`eW?+BnkgQb0L|kKxCvi%EpzOG>{5{JM_k3&ot|!M`|-k-kqS zOYL6bMdA7rpUO@ob-^*H4FxmIZ<`I~bwxZ#BCKLum+iS>KqR}i)h^v}A%cmNOuHDl zOs=U{{LLqxs_sNk^8U)yyR=~=Yq+uS^Tajtsc>6_SI)kBxlB(Ej?DQsG?R|@0;i#j zI6RKmpmN8^c9xwpWf*D}yD7(lRV|3zvC!IJ(*dE7E4K}q=(+=n1ONa4000sFlosUX z=9aY6)7diAmn(=r{%rq!Fye-kwoTCmL}Jd((a@sw!n#Io@AZtc!Aw|PMyLsB0NDdb z;SPaFki)~Z*pHv_>&VkX+-GdA(DUsW)Ek~b#~46&uq@2i?Vk^CgEx-3-`pJ9#WVOI zKi#Jg%ew*Dw7iR_mu(7}Jq(w#k@(Dlmm_y;?ZVj;XW1ZXrZnZ~N!_>SGMQNi`J)rY zaDvKe;(pQO5!U~Spqanr^$VxuN?8R~CX{FR8=)W;1Lg~C#?R?No=w2pwsUUZ5^n3N z6}PZF13N;pFXzKIjcU4QMAxU(#zghr5&6md$1DQZsP_H;gE7LoC zH|SY&)Mf`6QWZ|~-n=9~APg6qk}A><^(|c~(hm*rAOHXW00AuLcjaqy{fTxO9{zw> z%!&WWL_%?Se=J*+K}tOQX#*0bop0f+?umDR4L6a1=i1aNM<)z_8PzdfPA z|EXRheM0V;ZWC&leZth-h-eFV0b{2xO#24JjOo8Lb1D0K&u7*AC$dubUrpXCH9CEz zg^9p;^fLHyhwzWsiF4(v6@@pJfJEDO5y+`ZHI%)0-)Q}|2&5!LA!9oV8JgZhdF20U zWwM9q{3l+1&pU#^?wj`dHC_(8<<2?CZ@nhes&7&~01EA#9>+9aI9DYb4)Cdo!%X=OP>e~=O5U0(uL7`9L9-0h$yyaJ=%W8SmSzP72^yV3)1GU z)|y#nV|TdA+L_McgAKXIhgwIa92(+@({%WU4zuMxZ6mycGYghWncMBFUhwDw;Z$gz zcbM?;`}lZfH9C=OW(@wdQ?DdhEn^VyGYk5$KdzXsG_QYHWEH?cVAjUXel9i&gc9qZ4yvY#( z;K$rMVJrhi&T341Q{m2eeebIxS?>w-t>7h{^Md+hY61!R!`{@zYak9J4{=}mF!O(y z7u5_wTHah5^%)?c&yt=qWGTOnoAg;Ges z%1!jh3-BS_(-8mw00000000pl8lZ_dN<(EKqiEixW_F8{9sP>dq4&~=dq6TQy8|N2 zurey8PRgk4D&yR#_XrSA2D0cAh{8%)41szA2SKoMJ1)c4Rhj2STd zgSP_tns#DO-Cq7hQ`l!;3X4*VP97l7JkN3t!@ToTv1E^<-gUNPlKM7sNIFjqOaEJG zIDcrHM{XQ>gxNB8ElKn!xcv~W+gNnnHI}JjMGBaEMkZ%;3ux-oy(pdv1q3l?bnhhjDe*T(|t7jCAfz ztML3V4l@?JrLPXIG(niMv24|B&#u-MAy5z+TrdIWh*)uElE6|H4fU5`8H(BP#om0- zZTCI?K247x&9eJMh{Ofb&26~WjU9DNS&q`>+6GR2kom?_XSBt2vhW5=>MTh2X7&Pm zHAdl`*-f{Nc?fko{2vDYNKVYE2$ge+GU&t=quo8Wu2VdXuzY9T==2>!m?ylzo7hr@r+;+;01zabyqgQRQ0NWO3o+R8?=c%b{vb|!EeDL60M zgD0x_tZ(e$^zplsa%@stqMcZEf+dK%8!ssPb;@kyl~V{!c3En$?G)o{spN0sH(bXo zU5WXkkkq~Zg98l}rT<rUWwF2 zsyj|=vn-UFt5Ezgq#kslGHZvC>`yl7qb2GTCy%yds>Ps?C-|SF$@jwp*L-l#pzk}b z6&pYXkn&0L?`Bwut&ypoe|mRt43R$0O#`?yX%2Lc9*O;!QqR-9(Vq)V>>3aT7~ksu z3UwRe6^Un#8YB0fZJ7KHY*_+%q)glG%|)Vc`jH(+Ze8*S*KxcK48EzZ%Oe2t%}_E|`DaICoEDN}X;>5-dNVIBg+4m+2qmhIhX;4Em&mhW(=X16;H8_t zuqZ+@9b4=sct*T8Q6h*uUGD<^?eYZI+XJJ+8CC;q&F+!FWEpDF$SNCs=^H{5ZQ~5c zcek4S)1=bq0GU=T1m-(6$$rVd~q>%kL>^=(T7)Cwh%guS$ zSw!~Ni{MHNT zWZK)HE`vYnG?Na$jgTp-$SRWb0xg?{%Ml=Mqh_+JVB%U_sohE+430i64@?Db)5{vU z4ik7@uB3Jr^+*%!2$3qsi>49mxxy`LPr3q>pC+zjT4T0Z13hHY=yoe&dBAbA8yopz z&7Q_hNcT?n{pet_!0KaorEgosh*$IKVm0AbxSU-l0UbDqKFIZmH z#nff#lM=K}$qqO@Z2KI>WYiCJfdkT3u)HRn$J~Z{z&+#R=}w&>?VDP>p8o<&DmvSZ zQ{{CeYo=|y7;arlQoGc9c{{mHc=sZqd zM}~;0FLuW%KNdUD)49B!<9+H3NXY_9`rnIu-h!3Y72BE9@oSUfO0M=>AE^b40fSfy zrRAD7jfZc`5U=aCn1a$|eRsybtmiAjU7H5N;go;l@0<8c`y&Zl!xtxt%v^>Ghu0z_ z^w2x8t=o&uC}l`tElW#7s5a$DDe*Yvw5`KHW#wQBK1-nm$9*$WeKn6I7|Pn9WQJ1j z#1zE%WC1QT51&RK9g!KYr3uR&eKJzja^8f8!l>y5UwwcOaYLA+QRA}5gsX86FVqrU z`DJhji>^^e#H@i1%LP9h!(V|*)tqJDlUuIk-+mt^%p+ih#-%KI0blzdqGP)Qc66_< z$8R`c4YSX~b##bL%Qg(5t*O^X92Hq8c6dhiyNSTyJ_W>df2WFyhAN*pSKeDV3n*ZA zb@6Y`yk$V%`2D~LYaHCoAVpNTH@fM4j4*kEO~&wVeU=vzJoS%mMsE_6evX3zH{lY~ z5T7DL&5Fqprh~D(rPkN{R41?-{c?xFSnxSc6>vFSjDbRiyk5_&Bj9l)mJ-5B^otZ#r54E9+0xWVi)ZOegUh1jG1VLM3oMpep>q3Vn_3TAd4fa0E z$y1iY*_5;YVXE}Gp1X=w3KTmv4rpn|Y$Q|^oquB13uJr}1KHR^a?vE5)azqqW0w^U zT}?_IvLFzJi}o_82KC^#~=*;?LqRlaPh9h8(oiM-v2 zo|uws9+f}tc({z#+wb$e;_7b|HUuB?KC2HeSPz$@CJMQ3!T{ZvjlE5Is(D3rgwi(j zjrT&CMTwR-tG9!n)?tCnZ&i2>nHQ z=QnAsaOWa-3-?rAMU#tUJMY7g%e^(*<4GUQF2E1m;v$WpfG z#fQme`-H!A7|#4wunP16dKu+uNh!D`z_GXN-2R)PGC4=5dlfK^2xk$IYCtJqD|`;H3Zz23nx^}DXF(h^cHQ_sPmaFD{-JIY?1;WUWd8jbnit6w z6vnK&G!GqbwX+oH%WKZ5Qh_}JKwrm+kI(MchW0IDHc$o(!DHKi5;#lY)}o{k~x}UlN2dRj5B~(FsL%17H%7@>I<-&d)5V{OYLh_Ej)v zXr6b_06%B|0&M^o(9TtG&6r_pa}{M5hRvoPaq^$ykmtoSGz4V!uPEZ`ne?!V{7 zv51&pVIm@e^=#~Hr-j8<-~c#~lIJQ^RdN=g^&?@syPOg~H3e41TUk^&Q*cL`3EPg-`6FdeSY|AKcJqRE%)RW_XjT&zghK2NUV^-Q5&zXEt5nGJ`b=&q-;<2 zJL9%Pm9E795kv2vjYNQC%C#yl%iBHYCp0>~z5R<5nZUPKrvj>SGWF~+urnf|rV08x z@%H?TFl?D}h!_?vR03XN%{*1GRq{&V@&RvmItvbS-kZ>u0|+`%-{oX5mt#4(1}VC> z7ejpS-O`d{Fp$%AMlj~@O!|-cWA|#uz3=1EXD{3u@;W8?4pUaf7*F!yksw8_(I~Yx z(MUw{XJqyxt+)2A9CTg71ECnUfC1}303WmgzaJsnPs-w9Wn=eF{d2oUYXKX{z%X=UgDZFAx^aeqWH?OWw2~ z&IggFzAC7#Cq-+;x&A6$Di&U$4B%O~(LMy*xyJdv$N?$iDLU(^ouWyNSOwIQ^5*Uq1CkGZwl?;Q+?=SeD}-rk1Ix=Z$D=-|crp5;pqrgNr$N*Ub5Bm-; zK+?cLsR0P~yyuADpT*I3hlkYc)f=rHHjmsJ@Tqlwtz%@Cz5++>m0x8&;dm4GfPRJf zAET-zI+GRE>0)lzcFF_2ZOLfT##jrER5~oDlRg;B%u9L2_k6JsL&Q~lhiLKpYa$3B z-OA-LlCBhS#U~#9Ncg~M14SL(FLN4Y>j89&%*bmftE~`UD> zZRA118X(?I7Gcgq@I49u2kig?;(!8{4P_OLj;kq_cnb^Y`^-4gkMQC(VUINB$7x=S zb#(1{^?ixneC{F08Y|%P1FuKCf?;-&nz;}TpJhS1;IKk&QM#Ym7BEG}c6VA~2fn*m zE!}?U=1!oB!dN8a1AULeav%OIm_|5!L)LRf^`)@1xy&B%a7+cMaI19(zN7=_! z2^*mksKres5n*XB8XlsrKucrC)|c^hl}X$vPYu2c#uibH z6$yX26h;@3@M%m^x(0vvPI(7osX+Ch0IP-poZya*K|`p`J14leHhj*TH$U~x;<}3- zRd>9@R}xweJpACqPkWniKMEq`?9AQK((~nHS%IdW(p*eib2f zHZ_!9y6toW#{E&z9ojtYeC1;36UkpP%9}mCbxdM*`dBPGsWlFCyb?TXjt{tdm}n24 zboD3>nfIBQbm2j2=E`#pQqDa-QPT@(QiDx_H`nKRZ&-oo~jF_RU&mpDLi(N-70eI#YsDJ*?CxDt*=v z<4$5~6+hAfUsI-K*&e#-J2erwy)wDhqcg|oL6dytqe;?EtM%}rCLfZbuL&b^9+@M4 zz?Fvc>17(Ky`OGgPr?4SfI#dnB?0MH&ZMT@2cO6@rs&R0GjM2ncwarGN;2{%jf{y= zfTP zSBAw`ft47DAV^)fO+jK0mUo;(x~d7br&DPe$>B*q!A1K2#BSsK2|jkhJ{f+O$gLf@ zlt}!w>4}fq=E*2Ez5j@BFQ+0lX`fa5cgTpd01x+eSgG|+j7Q+iOj4)CY-!LlcHCD{ z(VcFg(7Fp`cR6~J!D%9n|8do%81 z2xAYf;Uo3_FlA{YQs{Qw?7^xv1WTce=2#2jXRbUab6RgpC=D9`%UflroqcmC$DwM* zCoZLB&dff2!G@ASfePlabN*T{CI|mSS@X?nCEcGC_tK(tew-fEITJZb$8W;ZJha|M zn7D=g{>!mjVU1|vv6=1BF|BMXoPY77S;D1A&bvm)qPMkFEzP;1=pZy9-1AjFGvlvT z6K#SWI-EZrM@ejJ>Fs)p0sKuyW4!5_O@Oxzno?o``~&@y@4&Rjh*)80`CJv)U>|T3 z&^NoIw8JOwStHg?aZ}wnU_Ft)7A+mNS?&CgOrrwfWNKW`GT*v|XyS`SP9m(AMl*AP z6hse|+J{taYCk;|{s8GLe9tMAUvG8XY*@d_2o6^%kXcQ2k9uJwvL55UteHqBkW9jfHPWG=tGa3 zCWNCC_J9DMCf~rbW)lF-H5{;vZ)kS(of&X;2-h&rB*kr5c)~Pr&4#8c)`NOnuRnX} zo+U0l0_Zyts)>_KvbiRqfwA&BFGxH}PT4t+*dZOtM#BA8~ zis%8g@J-b`V#Eo^xmn`%cQ+T;s1e4krOYdsE|m8Q2V1yNGyh$m{+Fvzc_*_3j5|!i zRJF?bh$qQ+z69k%h+VdkP|#r5O8LB%(ubiuR&Au~vK%ZQjOKa(+iyy0V@r4}M;mBmYo&b15Lgfzj{`+%Us05q1>Kplk28v_e^F&K6FL}kT>KMSI3_>uP zFuqkLZxFZk$BM$@59C~buY{o?S$EW}odk}}iNjEeEBjTPw+xLg$gcE;xW65%Q2X>I zdSdvzy6Ir|fTBOnMZaqp8<)T1QkRi%)yc5S8aN74-DQsjB8SbEUU*2zhNr&o;?u0{ z=c(E5Fx>*GA1+VAh%@6J$lS_I6wz7+*GTvWXXr5D?=chgCnp;PbdNBKmnb=0000F+5iFj mL&Bf(^37Z*(aU9IX9NHPlrF3QB*eS`000gI008}<0002l0-p8& diff --git a/shots/live_program.webp b/shots/live_program.webp deleted file mode 100644 index 59abc6770703657d757bf405241287a6f256b6e1..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 33432 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