Remove UI multi cam setup

## Summary

Fixes #20.

- Reuse fighter animation scratch and output buffers across rollback frames.
- Select air-collision hits in one pass without candidate allocations or sorting.
- Index contiguous replay input frames directly and binary-search checksums.
- Add regression tests for buffer reuse and replay lookup/validation.

Reviewed-on: #53
Co-authored-by: Álex Román Núñez <eirexe@eirteam.moe>

src/fighter/baked_animation/mod.rs

@@ -4,8 +4,8 @@ mod asset_baking;
 mod runtime;
 mod visual_binding;
 
-pub use asset_baking::{BakedAnimationAssetProcessingPlugin, BakedAnimationPlugin};
 pub use crate::math::fixed_transform::FixedMat4;
+pub use asset_baking::{BakedAnimationAssetProcessingPlugin, BakedAnimationPlugin};
 pub use runtime::{
     BakedAnimationClip, BakedFighterAnimations, FighterBoneIndexMap, FighterBoneMatrices,
     update_fighter_bone_matrices,
@@ -164,6 +164,20 @@ mod tests {
         );
     }
 
+    #[test]
+    fn repeated_pose_updates_reuse_scratch_and_output_buffers() {
+        let mut matrices = FighterBoneMatrices::default();
+        let names = ["root".into(), "hand".into()];
+        let parents = [None, Some(0)];
+        let pose = [FixedMat4::IDENTITY, FixedMat4::IDENTITY];
+
+        matrices.set_pose(&names, &parents, &pose, FGi32::ONE);
+        let capacities = matrices.buffer_capacities();
+        matrices.set_pose(&names, &parents, &pose, FGi32::ONE);
+
+        assert_eq!(capacities, matrices.buffer_capacities());
+    }
+
     #[test]
     fn model_scale_affects_gameplay_bones_without_changing_visual_locals() {
         let mut root = FixedMat4::IDENTITY;

src/fighter/baked_animation/runtime.rs

@@ -3,7 +3,7 @@ use std::collections::HashMap;
 use bevy::prelude::*;
 use serde::{Deserialize, Serialize};
 
-use super::{BAKED_ANIMATION_FPS};
+use super::BAKED_ANIMATION_FPS;
 
 use crate::{
     fighter::{
@@ -12,8 +12,8 @@ use crate::{
         manifest::FighterManifest,
         visual::FighterAnimations,
     },
+    math::fixed_transform::FixedMat4,
     math::int::FGi32,
-    math::fixed_transform::FixedMat4
 };
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
@@ -70,12 +70,24 @@ pub struct FighterBoneMatrices {
     previous_frame_matrices: Vec<FixedMat4>,
     local_matrices: Vec<FixedMat4>,
     previous_local_matrices: Vec<FixedMat4>,
+    model_matrices: Vec<Option<FixedMat4>>,
 }
 
 #[derive(Component, Clone, Debug, Default)]
 pub struct FighterBoneIndexMap(pub HashMap<String, usize>);
 
 impl FighterBoneMatrices {
+    #[cfg(test)]
+    pub(super) fn buffer_capacities(&self) -> [usize; 5] {
+        [
+            self.matrices.capacity(),
+            self.local_matrices.capacity(),
+            self.previous_frame_matrices.capacity(),
+            self.previous_local_matrices.capacity(),
+            self.model_matrices.capacity(),
+        ]
+    }
+
     pub fn get(&self, bone: &str) -> Option<(FixedMat4, FixedMat4)> {
         let index = self.bone_names.iter().position(|name| name == bone)?;
         Some((
@@ -142,13 +154,19 @@ impl FighterBoneMatrices {
             assert_eq!(self.bone_names, bone_names, "baked bone names changed");
             assert_eq!(self.parents, parents, "baked bone parents changed");
         }
+        self.matrices.reserve(local.len());
+        self.previous_frame_matrices.reserve(local.len());
+        self.local_matrices.reserve(local.len());
+        self.previous_local_matrices.reserve(local.len());
+        self.model_matrices.reserve(local.len());
         std::mem::swap(&mut self.matrices, &mut self.previous_frame_matrices);
         std::mem::swap(&mut self.local_matrices, &mut self.previous_local_matrices);
         self.local_matrices.clear();
         self.local_matrices.extend_from_slice(local);
-        let mut model = vec![None; local.len()];
+        self.model_matrices.resize(local.len(), None);
+        self.model_matrices.fill(None);
         for index in 0..local.len() {
-            resolve_model_transform(index, parents, local, &mut model)
+            resolve_model_transform(index, parents, local, &mut self.model_matrices)
                 .expect("baked bone hierarchy should be valid");
         }
         let model_scale = FixedMat4 {
@@ -159,10 +177,12 @@ impl FighterBoneMatrices {
                 [FGi32::ZERO, FGi32::ZERO, FGi32::ZERO, FGi32::ONE],
             ],
         };
-        self.matrices = model
+        self.matrices.clear();
-            .into_iter()
+        self.matrices.extend(
-            .map(|matrix| model_scale.mul(matrix.expect("baked bone hierarchy should be valid")))
+            self.model_matrices.iter().map(|matrix| {
-            .collect();
+                model_scale.mul(matrix.expect("baked bone hierarchy should be valid"))
+            }),
+        );
     }
 }
 

src/fighter/collision.rs

@@ -50,31 +50,29 @@ pub fn air_collide_with_stage(
         translation.0 + ecb.get_bottom_point(),
     );
 
-    let mut intersect_results = vec![];
+    stage_collision
-
+        .stage_polys
-    for (poly_idx, poly) in stage_collision.stage_polys.iter().enumerate() {
-        if let Some(intersect_result) = poly.intersect_ray(ray_segment) {
-            intersect_results.push((
-                AirCollisionWithStageResult {
-                    line_id: {
-                        StageLineID {
-                            polygon: poly_idx,
-                            segment: intersect_result.segment_idx,
-                        }
-                    },
-                    hit_position: intersect_result.position,
-                    hit_normal: intersect_result.normal,
-                },
-                intersect_result
-                    .position
-                    .distance_squared(ray_segment.point2()),
-            ));
-        }
-    }
-    intersect_results.sort_by(|(_, a), (_, b)| a.cmp(b));
-
-    intersect_results
         .iter()
-        .last()
+        .enumerate()
-        .map(|(val, _)| val.to_owned().clone())
+        .filter_map(|(poly_idx, poly)| {
+            poly.intersect_ray(ray_segment).map(|intersect_result| {
+                (
+                    AirCollisionWithStageResult {
+                        line_id: {
+                            StageLineID {
+                                polygon: poly_idx,
+                                segment: intersect_result.segment_idx,
+                            }
+                        },
+                        hit_position: intersect_result.position,
+                        hit_normal: intersect_result.normal,
+                    },
+                    intersect_result
+                        .position
+                        .distance_squared(ray_segment.point2()),
+                )
+            })
+        })
+        .max_by(|(_, a), (_, b)| a.cmp(b))
+        .map(|(result, _)| result)
 }

src/menus/character_select/mod.rs

@@ -241,7 +241,7 @@ pub fn copy_cursor_transform_to_token(
     character_boxes: Query<(&CharacterBox, &ComputedNode, &UiGlobalTransform)>,
     match_config: Res<MenuMatchConfig>,
     cursors: Query<&UiGlobalTransform, With<FGMenuCursor>>,
-    cam: Single<&Camera, With<IsDefaultUiCamera>>,
+    cam: Single<&Camera>,
     ui_scale: Res<UiScale>,
 ) -> Result {
     let camera = cam.into_inner();

src/menus/cursor.rs

@@ -181,7 +181,7 @@ pub fn cursor_input(
 }
 
 pub fn update_cursor_transform(
-    camera: Single<&Camera, With<IsDefaultUiCamera>>,
+    camera: Single<&Camera>,
     query: Query<(&mut Node, &PointerLocation), With<FGMenuCursor>>,
     ui_scale: Res<UiScale>,
 ) {

src/menus/mod.rs

@@ -25,6 +25,8 @@ pub mod style;
 
 #[derive(Component, Clone, Default)]
 pub struct MenuMarker {}
+#[derive(Component, Clone, Default)]
+pub struct MenuCameraMarker {}
 
 pub struct MenuPlugin;
 
@@ -38,6 +40,7 @@ pub fn wrap_menu(menu: impl Scene) -> impl Scene {
     bsn! {
         #MenuRoot
         MenuMarker
+        Transform
         Node {
             width: percent(100),
             height: percent(100),
@@ -46,6 +49,11 @@ pub fn wrap_menu(menu: impl Scene) -> impl Scene {
             flex_direction: FlexDirection::Column,
         }
         Children [
+            (
+                #MenuCamera
+                Camera
+                Camera2d
+            ),
             (
                 #MenuContainer
                 Node {
@@ -65,15 +73,18 @@ pub fn wrap_menu(menu: impl Scene) -> impl Scene {
 
 pub fn despawn_menu(
     existing_menu: Option<Single<Entity, With<MenuMarker>>>,
+    existing_menu_camera: Option<Single<Entity, With<MenuCameraMarker>>>,
     mut commands: Commands,
 ) {
     if let Some(entity) = existing_menu {
         commands
             .entity(entity.into_inner())
-            .remove::<Camera2d>()
-            .remove::<Camera>()
             .despawn();
     }
+
+    if let Some(menu_cam) = existing_menu_camera {
+        commands.entity(*menu_cam).despawn();
+    }
 }
 
 pub fn spawn_menu(
@@ -84,8 +95,6 @@ pub fn spawn_menu(
     if let Some(entity) = existing_menu {
         commands
             .entity(entity.into_inner())
-            .remove::<Camera2d>()
-            .remove::<Camera>()
             .despawn();
     }
     commands.queue_spawn_scene(wrap_menu(menu));
@@ -114,14 +123,6 @@ impl Plugin for MenuPlugin {
         app.add_systems(
             OnEnter(AppState::MainMenu),
             (build_menu::<MainMenu>, |mut commands: Commands| {
-                commands.spawn((Camera2d, IsDefaultUiCamera));
-                commands.spawn((
-                    Camera2d,
-                    Camera {
-                        order: 1,
-                        ..default()
-                    },
-                ));
             }),
         )
         .add_message::<character_select::PlayerSlotAssigned>()

src/replay.rs

@@ -152,6 +152,20 @@ fn validate(replay: &Replay) -> Result<(), String> {
     {
         return Err("replay frames must be strictly ordered".into());
     }
+    if replay
+        .frames
+        .windows(2)
+        .any(|frames| frames[0].frame.checked_add(1) != Some(frames[1].frame))
+    {
+        return Err("replay frames must be contiguous".into());
+    }
+    if replay
+        .checksums
+        .windows(2)
+        .any(|checksums| checksums[0].frame >= checksums[1].frame)
+    {
+        return Err("replay checksums must be strictly ordered".into());
+    }
     if replay
         .frames
         .iter()
@@ -173,6 +187,21 @@ impl Replay {
         handles.sort_unstable();
         handles != (0..handles.len()).collect::<Vec<_>>()
     }
+
+    fn frame(&self, frame: i32) -> Option<&ReplayFrame> {
+        let first_frame = self.frames.first()?.frame;
+        let index = frame.checked_sub(first_frame)? as usize;
+        self.frames
+            .get(index)
+            .filter(|recorded| recorded.frame == frame)
+    }
+
+    fn checksum(&self, frame: i32) -> Option<u128> {
+        self.checksums
+            .binary_search_by_key(&frame, |checksum| checksum.frame)
+            .ok()
+            .map(|index| self.checksums[index].checksum)
+    }
 }
 
 fn start_replay(mut commands: Commands, args: Res<Args>, loaded: Option<Res<LoadedReplay>>) {
@@ -210,11 +239,7 @@ fn replay_inputs(
                 .insert(frame.0, inputs.iter().map(|(input, _)| *input).collect());
         }
         ReplayMode::Playback { replay, mismatch } if !*mismatch => {
-            let Some(recorded) = replay
+            let Some(recorded) = replay.frame(frame.0) else {
-                .frames
-                .iter()
-                .find(|recorded| recorded.frame == frame.0)
-            else {
                 error!("Replay has no input for frame {}", frame.0);
                 *mismatch = true;
                 return;
@@ -235,21 +260,15 @@ fn record_checksum(
     let Some(mut runtime) = runtime else { return };
     if matches!(&runtime.mode, ReplayMode::Record { .. }) {
         runtime.checksums.insert(frame.0, checksum.0);
-    } else if let ReplayMode::Playback { replay, mismatch } = &mut runtime.mode {
+    } else if let ReplayMode::Playback { replay, mismatch } = &mut runtime.mode
-        if let Some(expected) = replay
+        && let Some(expected) = replay.checksum(frame.0)
-            .checksums
+        && expected != checksum.0
-            .iter()
+    {
-            .find(|value| value.frame == frame.0)
+        error!(
-            .map(|value| value.checksum)
+            "Replay desync at frame {}: expected {:X}, got {:X}",
-        {
+            frame.0, expected, checksum.0
-            if expected != checksum.0 {
+        );
-                error!(
+        *mismatch = true;
-                    "Replay desync at frame {}: expected {:X}, got {:X}",
-                    frame.0, expected, checksum.0
-                );
-                *mismatch = true;
-            }
-        }
     }
 }
 
@@ -407,4 +426,41 @@ mod tests {
             "unsupported replay version 1"
         );
     }
+
+    #[test]
+    fn playback_lookups_use_frame_offsets_and_support_sparse_checksums() {
+        let mut replay = sample();
+        replay.frames[0].frame = 10;
+        replay.frames.push(ReplayFrame {
+            frame: 11,
+            inputs: replay.frames[0].inputs.clone(),
+        });
+        replay.checksums.push(ReplayChecksum {
+            frame: 11,
+            checksum: 84,
+        });
+        replay.checksums[0].frame = 10;
+        validate(&replay).unwrap();
+
+        assert_eq!(replay.frame(10).unwrap().frame, 10);
+        assert_eq!(replay.frame(11).unwrap().frame, 11);
+        assert!(replay.frame(9).is_none());
+        assert_eq!(replay.checksum(10), Some(42));
+        assert_eq!(replay.checksum(11), Some(84));
+        assert_eq!(replay.checksum(12), None);
+    }
+
+    #[test]
+    fn noncontiguous_input_frames_are_rejected() {
+        let mut replay = sample();
+        replay.frames.push(ReplayFrame {
+            frame: 3,
+            inputs: replay.frames[0].inputs.clone(),
+        });
+
+        assert_eq!(
+            validate(&replay).unwrap_err(),
+            "replay frames must be contiguous"
+        );
+    }
 }

src/stage/manifest.rs

@@ -7,14 +7,10 @@ use strum::IntoEnumIterator;
 use strum_macros::EnumIter;
 
 use crate::{
-    AppState,
+    AppState, game_settings::GameSettings, math::{int::FGi32, vec::FGVec2}, stage::{
-    game_settings::GameSettings,
-    math::vec::FGVec2,
-    stage::{
         StagePoly,
         line::{StageCollision, StagePolyLineSegmentType, StagePolyType},
-    },
+    }, texture_reference::TextureReference,
-    texture_reference::TextureReference,
 };
 use bevy::prelude::*;
 
@@ -87,6 +83,14 @@ pub struct StageManifest {
     pub icon: TextureReference,
     pub camera: StageCameraProfile,
     pub polygons: Vec<StagePolyDefinition>,
+    #[reflect(ignore)]
+    pub blast_zone_left: FGi32,
+    #[reflect(ignore)]
+    pub blast_zone_right: FGi32,
+    #[reflect(ignore)]
+    pub blast_zone_top: FGi32,
+    #[reflect(ignore)]
+    pub blast_zone_bottom: FGi32,
 }
 
 #[derive(Resource)]