docs: panopticon auto-update for snow_trail

.pi/skills/panopticon/SKILL.md

@@ -0,0 +1,24 @@
+---
+name: panopticon
+description: >-
+  Auto-generated project overview for snow_trail. Structure, conventions,
+  and recent activity. Updated nightly by Panopticon.
+---
+
+# snow_trail — Project Overview
+
+Pure Rust retro-aesthetic 3D game using SDL3 windowing, wgpu rendering, and rapier3d physics. Implements a pure ECS architecture with intent-based cross-system communication, state machines via TypeId polymorphism, and compute-shader snow deformation. Content authored in Blender 5.0 (glTF meshes + EXR heightmaps).
+
+## Quick Reference
+
+- **Language:** Rust (stable)
+- **Key dependencies:** sdl3, wgpu, rapier3d, glam, bladeink
+- **Build:** `cargo build --release`
+- **Test:** `cargo test`
+- **Entry point:** `src/main.rs::main()`
+
+## Documentation
+
+- [Structure](structure.md) — modules, types, data flow, dependencies
+- [Guide](guide.md) — conventions, patterns, anti-patterns, testing
+- [Changelog](changelog.md) — recent changes, active areas, stability

.pi/skills/panopticon/changelog.md

@@ -0,0 +1,97 @@
+# Changelog
+
+*Last updated: Tuesday, April 7, 2026*
+
+## Active Areas
+
+| Area | Changes (30d) | Status |
+|------|---|---|
+| Main loop & systems | 9 churn | Active — explicit storage parameters |
+| Dialog system | 10 churn | Active — projectiles, camera, rendering |
+| Render core | 15 churn | Active — text pipeline, font atlas, globals |
+| World state | 8 churn | Active — intent storage, component management |
+| Player mechanics | 6 churn | Stable — character bundle, player states |
+| Shader system | 4 churn | Active — gizmo lines, dissolve, snow light |
+| Content pipeline | 1 churn | New — Blender export addon |
+
+## Recent Changes
+
+### System Signature Refactor (Major)
+- **Completed**: All 16 systems refactored to take explicit `Storage<T>` parameters instead of `&World`/`&mut World`.
+- **Pattern**: Functions receive only storages they need (e.g., `camera_follow_system` takes `&Storage<FollowComponent>`, `&Storage<CameraComponent>`, `&mut Storage<Transform>`).
+- **Benefit**: Explicit data dependencies improve borrow checker clarity and code readability.
+- **Main loop** (`src/main.rs`): Updated to pass individual storage fields at call sites rather than whole `World` reference.
+- **Affected systems**: `camera_input_system`, `camera_intent_system`, `camera_follow_system`, `camera_noclip_system`, `camera_ground_clamp_system`, `dialog_camera_transition_system`, `dialog_camera_system`, `player_input_system`, `physics_sync_system`, `render_system`, `particle_intent_system`, `particle_update_system`, `trigger_system`, `dialog_system`, `dialog_projectile_system`, all state machines.
+
+### Intent-Based Architecture
+- **Completed major refactor** (3 weeks ago): Systems communicate through one-frame `Storage<T>` intents instead of direct function calls.
+- **Intent types**: `FollowPlayerIntent`, `StopFollowingIntent`, `CameraTransitionIntent`, `SpawnParticleIntent`.
+- **Consumer pattern**: Systems read intents from world storage, act on them, then remove them. Producers don't import consumer modules.
+
+### Dialog System Suite
+- **Dialog state machine**: Ink-based story progression with display timer, projectile phases, parry mechanics.
+- **Projectile system**: Spawns physics-driven projectiles with parry windows; detects hits vs. evasion vs. parries (I/J/L buttons).
+- **Dialog camera**: Auto-frames all dialog participants; transitions smoothly between follow-cam and dialog-cam via intent; computes centroid + spread.
+- **Bubble rendering**: Billboard-based text with word-wrap, dynamic sizing (tail height → body dimensions), border/fill colors, RGBA text atlas.
+
+### Text & Font Rendering
+- **Font atlas pipeline**: Pre-rasterized glyphs (16×8 grid, 124px cells) from Departure Mono font.
+- **Text measurement**: Character-width aware layout with line wrapping against max bubble width.
+- **Vertex-based text**: Custom `TextVertex` (position, UV) fed into dedicated text pipeline with view-proj uniform.
+
+### Particle System
+- **Intent-driven spawning**: `particle_intent_system` reads `spawn_particle_intents` Vec, transfers configs into persistent `ParticleBuffers`.
+- **Configurable emitters**: Burst count, lifetime range, speed range, directional spread (cone), gravity, size range, color gradient.
+- **Snow particle integration**: Spawned continuously at camera position for screen-fill effect; `spawn_snow_particles` adds particles to `ParticleBuffers`.
+
+### Render Pipeline
+- **Global renderer via thread-local**: `render::global` module centralizes `Device`/`Queue` access for loaders and systems.
+- **Draw call generation**: `render_system` reads `entities`, `transforms`, `meshes`, `dissolves` storages; generates `DrawCall` per visible entity.
+- **Gizmo shader**: Fragment shader outputs world-normal as axis color (X=red, Y=green, Z=blue).
+- **Snow light accumulation**: Persistent texture tracking deformation; blue-noise dithering maps snow brightness into tile pattern.
+- **Dissolve shader**: Blue-noise masked alpha cutoff; controlled by `enable_dissolve` uniform.
+
+### Tree Occlusion & Instances
+- **Tree dissolve system**: Per-instance dissolve amounts lerp toward targets; updated via `tree_occlusion_system` which reads player transforms and cameras.
+- **Instance buffer sync**: `tree_instance_buffer_update_system` syncs dissolve state changes to GPU buffer after state updates.
+
+### Trigger & Event Flow
+- **Sphere-based triggers**: `trigger_system` runs each fixed step; reads `triggers`, `transforms`, `player_tags` storages; fires `TriggerEvent` with `Entered`/`Exited` kinds.
+- **Activation filtering**: `TriggerFilter::Player` specifies which entity types can activate.
+- **Event queue**: Events collected in `world.trigger_events` and consumed by `dialog_system` to spawn bubbles.
+
+### Player State Machine
+- **State hierarchy**: Idle, Walking, Jumping, Falling, Leaping (dash), Rolling.
+- **Physics per-state**: `state_machine_physics_system` applies damping on enter (Idle), horizontal input application (Walking), vertical velocity control (Jumping).
+- **Transition logic**: Grounded checks, input presence, airtime duration.
+
+### Editor & Inspector
+- **Dear ImGui integration**: Inspector window with player state display, entity transform gizmos.
+- **Entity selection**: Right-click picking calls `picking::pick_entity` with ray; gizmo renders for selected entity when editor active.
+- **UI mode gating**: Systems check `editor.wants_keyboard()`/`wants_mouse()` to suppress game input during inspector focus.
+
+### Blender Export Addon
+- **Plugin**: `blender/addons/snow_trail_export.py` provides one-click glTF + EXR export from Blender 5.0.
+- **glTF operator** (`SNOWTRAIL_OT_export_gltf`): Exports selected mesh objects to `assets/meshes/{blend_filename}.gltf` with configurable modifiers, vertex colors, materials.
+- **Heightmap bake operator** (`SNOWTRAIL_OT_export_heightmap`): Calls `generate_heightmap.py` to bake terrain Z-position as 32-bit EXR to `assets/textures/terrain_heightmap.exr` (1024px default).
+- **UI panel**: "Snow Trail" category in 3D viewport; auto-discovers project root by walking directory tree until `assets/` and `blender/` found.
+
+## Stability
+
+| Area | Last Changed | Status |
+|---|---|---|
+| Physics manager | 80+ days | Stable |
+| Camera follow | 30 days | Stable — now takes explicit storage params |
+| Movement component | 30+ days | Stable |
+| Mesh loader | 30+ days | Stable |
+| Spotlight sync | 30 days | Stable — explicit storage params applied |
+| State machine physics | 30 days | Stable |
+| Debug colliders | 30+ days | Stable |
+| System signatures | New | Stable — refactor complete, no behavioral changes |
+
+## Open Threads
+
+- **Global renderer thread-local**: Marked for gradual migration to explicit `RenderContext` parameters on systems/loaders.
+- **Dialog parry mechanics**: Gameplay tuning (PARRY_WINDOW_RADIUS, HIT_RADIUS) ongoing.
+- **Tree occlusion performance**: Occlusion system runs every frame; no visibility culling yet. Scalability unknown for >100 trees.
+- **Heightmap bake normalization**: Exported EXR uses raw Z-coordinate; game may need per-level scale application.

.pi/skills/panopticon/guide.md

@@ -0,0 +1,362 @@
+# Guide
+
+## Conventions
+
+### Naming
+- **Bundles**: `*Bundle` suffix (e.g., `PlayerBundle`, `TerrainBundle`)
+- **Components**: `*Component` suffix (e.g., `MeshComponent`, `MovementComponent`)
+- **States**: Plain names without suffix (e.g., `IdleState`, `WalkingState`); impl `State` trait
+- **Intents**: `*Intent` suffix for one-frame events (e.g., `CameraTransitionIntent`, `FollowPlayerIntent`)
+- **Systems**: `*_system` suffix for functions (e.g., `player_input_system`, `trigger_system`)
+- **Storage containers**: lowercase plural (e.g., `world.transforms`, `world.movements`)
+- **Tags** (marker components): bare unit type in `Storage<()>` (e.g., `player_tags`, `bubble_tags`)
+
+### Formatting
+- Run `cargo fmt` with `brace_style = "AlwaysNextLine"`, `control_brace_style = "AlwaysNextLine"`
+- **NO inline comments** unless absolutely necessary—code must be self-documenting
+- Doc comments (`///`) **only** for public APIs and complex algorithms
+- **NO inline paths** in code—always use `use` statements at file level
+- **NO `use` statements inside functions or impl blocks**—all imports at module level
+
+### Imports
+- Group imports: standard library, external crates, internal modules (in that order)
+- Use fully-qualified module paths in `use` statements; never nest unnecessarily
+- Example:
+  ```rust
+  use crate::components::{CameraComponent, FollowComponent};
+  use crate::world::World;
+  use glam::Vec3;
+  ```
+
+## Patterns
+
+### Intent-Based Communication (One-Frame Queues)
+**Why**: Systems don't call each other directly. This decouples producer from consumer and maintains a flat pipeline.
+
+**How**: Intent is a simple struct in a queue (`Vec<T>`). Producer inserts, consumer reads and removes.
+
+```rust
+// components/intent.rs
+pub struct CameraTransitionIntent {
+    pub duration: f32,
+}
+
+// systems/camera.rs - consumer
+pub fn camera_intent_system(
+    follow_player_intents: &mut Storage<FollowPlayerIntent>,
+    stop_following_intents: &mut Storage<StopFollowingIntent>,
+    camera_transition_intents: &mut Storage<CameraTransitionIntent>,
+    follows: &mut Storage<FollowComponent>,
+    transforms: &mut Storage<Transform>,
+    cameras: &mut Storage<CameraComponent>,
+    player_tags: &Storage<()>,
+    camera_transitions: &mut Storage<CameraTransition>,
+) {
+    let transition_entities: Vec<EntityHandle> = camera_transition_intents.all();
+    for entity in transition_entities {
+        let duration = camera_transition_intents
+            .get(entity)
+            .map(|i| i.duration)
+            .unwrap_or(0.5);
+        start_camera_transition(camera_transitions, transforms, cameras, entity, duration);
+        camera_transition_intents.remove(entity);
+    }
+}
+```
+
+### Bundle Pattern (Entity Factory)
+**Why**: Encapsulate all initialization logic for related components into one spawnable unit.
+
+```rust
+// bundles/player.rs
+pub struct PlayerBundle {
+    pub position: Vec3,
+}
+
+impl Bundle for PlayerBundle {
+    fn spawn(self, world: &mut World) -> Result<EntityHandle, String> {
+        let entity = world.spawn();
+        
+        // Physics
+        let rigidbody = RigidBodyBuilder::kinematic_position_based()
+            .translation(self.position.into())
+            .build();
+        let rigidbody_handle = PhysicsManager::add_rigidbody(rigidbody);
+        world.physics.insert(entity, PhysicsComponent { rigidbody: rigidbody_handle, .. });
+        
+        // State machine with transitions
+        let mut state_machine = StateMachine::new::<FallingState>();
+        state_machine.register_state(|w: &mut World| &mut w.falling_states);
+        state_machine.add_transition::<FallingState, IdleState>(move |world| {
+            is_grounded(world, entity_id) && !has_input(world, entity_id)
+        });
+        world.state_machines.insert(entity, state_machine);
+        
+        // Tags
+        world.player_tags.insert(entity, ());
+        
+        Ok(entity)
+    }
+}
+```
+
+### State Machine with Type-Safe Transitions
+**Why**: Encapsulate state logic (on_enter, on_exit, physics_update) and guard transitions with closures.
+
+```rust
+// states/player_states.rs - implement State trait
+impl State for IdleState {
+    fn tick_time(&mut self, delta: f32) {
+        self.time_in_state += delta;
+    }
+    
+    fn on_enter(&mut self, world: &mut World, entity: EntityHandle) {
+        // Apply damping on enter
+        world.physics.with(entity, |physics| {
+            PhysicsManager::with_rigidbody_mut(physics.rigidbody, |rb| {
+                let current_velocity = *rb.linvel();
+                rb.set_linvel(Vector::new(0.0, current_velocity.y, 0.0), true);
+            });
+        });
+    }
+    
+    fn on_physics_update(&mut self, world: &mut World, entity: EntityHandle, _delta: f32) {
+        // Ground snapping
+        let current_y = world.physics.with(entity, |p| {
+            PhysicsManager::with_rigidbody_mut(p.rigidbody, |rb| rb.translation().y)
+        }).flatten();
+        // ...
+    }
+}
+
+// bundles/player.rs - register transitions
+state_machine.add_transition::<IdleState, WalkingState>(move |world| {
+    world
+        .inputs
+        .with(entity_id, |i| i.move_direction.length() > 0.01)
+        .unwrap_or(false)
+});
+```
+
+### Storage.with/with_mut Pattern (Closure-Based Access)
+**Why**: Avoids holding mutable references across multiple accesses; satisfies borrow checker.
+
+```rust
+// systems/spotlight_sync.rs
+pub fn spotlight_sync_system(spotlights: &Storage<SpotlightComponent>, transforms: &Storage<Transform>) -> Vec<Spotlight> {
+    let mut result = Vec::new();
+    for entity in spotlights.all() {
+        if let Some(spotlight_component) = spotlights.get(entity) {
+            if let Some(transform) = transforms.get(entity) {
+                let position = transform.position + spotlight_component.offset;
+                result.push(Spotlight::new(position, ..));
+            }
+        }
+    }
+    result
+}
+
+// With mutation
+world.movements.with_mut(entity, |movement| {
+    movement.movement_context.is_floored = true;
+});
+```
+
+### System Function Signature (Explicit Storage Parameters)
+**Why**: Pass only the specific storages (or read-only `&World`) that the system needs. Makes data dependencies explicit for the reader and borrow checker. **This is the standard pattern—all systems follow this.**
+
+```rust
+// Good: explicit dependencies
+pub fn camera_follow_system(
+    follows: &mut Storage<FollowComponent>,
+    cameras: &Storage<CameraComponent>,
+    transforms: &mut Storage<Transform>,
+) {
+    let camera_entities: Vec<_> = follows.all();
+    for camera_entity in camera_entities {
+        if let Some(follow) = follows.get(camera_entity) {
+            if let Some(camera) = cameras.get(camera_entity) {
+                transforms.with_mut(camera_entity, |t| {
+                    t.position = follow.target_position + new_offset;
+                });
+            }
+        }
+    }
+}
+
+// Read-only system
+pub fn spotlight_sync_system(spotlights: &Storage<SpotlightComponent>, transforms: &Storage<Transform>) -> Vec<Spotlight> { .. }
+
+// Dialog system example
+pub fn dialog_system(
+    entities: &mut EntityManager,
+    trigger_events: &[TriggerEvent],
+    dialog_sources: &Storage<DialogSourceComponent>,
+    bubble_tags: &mut Storage<()>,
+    dialog_bubbles: &mut Storage<DialogBubbleComponent>,
+    transforms: &mut Storage<Transform>,
+    names: &mut Storage<String>,
+    player_tags: &Storage<()>,
+    projectile_tags: &mut Storage<()>,
+    dialog_projectiles: &mut Storage<DialogProjectileComponent>,
+    dialog_outcomes: &mut Vec<DialogOutcomeEvent>,
+    delta: f32,
+) { .. }
+```
+
+### Default Trait for Configuration Components
+**Why**: Sensible defaults allow bundle code to be cleaner; override what's needed.
+
+```rust
+// components/jump.rs
+impl Default for JumpComponent {
+    fn default() -> Self {
+        Self {
+            jump_height: 5.0,
+            jump_duration: 0.5,
+            air_control_force: 100.0,
+            max_air_momentum: 3.0,
+            air_damping_active: 0.95,
+            air_damping_passive: 0.9,
+            jump_curve: CubicBez::new((0.0, 0.0), (0.4, 1.0), (0.6, 1.0), (1.0, 0.0)),
+            jump_context: JumpContext::default(),
+        }
+    }
+}
+
+// Usage in bundle
+world.jumps.insert(entity, JumpComponent::default());
+```
+
+### Physics Closure Pattern
+**Why**: Avoids lifetime tangles when borrowing rigidbody from PhysicsManager static storage.
+
+```rust
+// states/player_states.rs
+world.physics.with(entity, |physics| {
+    PhysicsManager::with_rigidbody_mut(physics.rigidbody, |rigidbody| {
+        let vel = *rigidbody.linvel();
+        rigidbody.set_linvel(Vector::new(vel.x, 0.0, vel.z), true);
+    });
+});
+```
+
+## Anti-Patterns
+
+### Direct System-to-System Calls
+**Don't do this:**
+```rust
+// ❌ Bad: tightly coupled, hard to debug
+fn system_a(world: &mut World) {
+    system_b_logic(world);  // Hidden dependency
+}
+```
+
+**Do this instead:**
+```rust
+// ✅ Good: intent in queue, flat pipeline
+pub fn system_a(cameras: &mut Storage<CameraComponent>) {
+    cameras.insert(entity, CameraTransitionIntent { .. });
+}
+
+pub fn system_b(camera_transitions: &mut Storage<CameraTransition>) {
+    for entity in camera_transitions.all() {
+        // process
+        camera_transitions.remove(entity);
+    }
+}
+```
+
+### Holding Mutable References Across Multiple Storage Accesses
+**Don't do this:**
+```rust
+// ❌ Bad: won't compile (borrow checker)
+let mut movement = world.movements.get_mut(entity).unwrap();
+let mut transform = world.transforms.get_mut(entity).unwrap();
+movement.foo = transform.position.x;
+```
+
+**Do this instead:**
+```rust
+// ✅ Good: use closures
+world.movements.with_mut(entity, |movement| {
+    world.transforms.with(entity, |transform| {
+        movement.foo = transform.position.x;
+    });
+});
+```
+
+### Inline Paths in Code
+**Don't do this:**
+```rust
+// ❌ Bad
+let velocity = *crate::physics::PhysicsManager::with_rigidbody_mut(..);
+```
+
+**Do this instead:**
+```rust
+// ✅ Good: use statements at top
+use crate::physics::PhysicsManager;
+// ... in code
+let velocity = *PhysicsManager::with_rigidbody_mut(..);
+```
+
+### Overly Generic (World/&mut World) Parameters
+**Don't do this:**
+```rust
+// ❌ Bad: implicit dependencies, breaks borrow checker
+pub fn camera_follow_system(world: &mut World) {
+    // What storages do we actually need?
+}
+```
+
+**Do this instead:**
+```rust
+// ✅ Good: explicit, focused dependencies
+pub fn camera_follow_system(
+    follows: &mut Storage<FollowComponent>,
+    cameras: &Storage<CameraComponent>,
+    transforms: &mut Storage<Transform>,
+) {
+    // Clear what data is needed
+}
+```
+
+## Testing
+
+### Structure
+Tests are inline with source (`#[cfg(test)] mod tests`). Focus on:
+- Component initialization and state transitions
+- Bundle spawning and validation
+- Physics helper calculations
+- Intent queue ordering
+
+### What to Test
+- **State transitions**: Verify conditions gate transitions correctly
+  ```rust
+  #[test]
+  fn test_idle_to_walking_transition() {
+      let world = setup_test_world();
+      world.inputs.with_mut(player, |i| i.move_direction = Vec3::X);
+      assert!(should_transition_to_walking(&world, player));
+  }
+  ```
+
+- **Bundle spawning**: Ensure all components are inserted
+- **Default values**: Verify sensible defaults in `Default` impls
+- **Physics calculations**: Unit-test slope calculations, terrain queries
+
+### Running Tests
+```bash
+cargo test
+cargo test --lib  # Unit tests only
+cargo test -- --nocapture  # Show output
+```
+
+## References
+- See **CLAUDE.md** in project root for authoritative style rules (no inline comments, doc comments for public APIs only)
+- See **docs/self-gating-systems.md** for detailed intent-based pipeline patterns
+- See `src/states/player_states.rs` for canonical State impl examples
+- See `src/bundles/player.rs` for complete Bundle pattern with state machine setup
+- See `src/systems/camera.rs` for canonical system function signatures with explicit storage parameters
+- See `src/systems/dialog_system.rs` for complex multi-storage system example

.pi/skills/panopticon/structure.md

@@ -0,0 +1,163 @@
+# Structure
+
+## Modules
+
+### `src/entity.rs`
+Manages entity lifecycle with `EntityHandle` (u64 alias) and `EntityManager` tracking alive entities. Entities are opaque IDs; all data lives in component storages on `World`.
+
+### `src/world.rs`
+Core ECS container holding `EntityManager`, 20+ typed `Storage<T>` collections (one per component type), and intent queues (`follow_player_intents`, `stop_following_intents`, `camera_transition_intents`). One-frame intents are inserted and consumed within a single frame. World also holds singleton state: `snow_layer`, `debug_mode`, `gizmo_mesh`.
+
+### `src/components/`
+Component types define entity data. Key storages:
+- **Transforms** (`Transform`): position, rotation, scale
+- **Physics** (`PhysicsComponent`): rapier3d rigidbody/collider handles
+- **Movement** (`MovementComponent`): walking speed, acceleration, damping state
+- **Jump** (`JumpComponent`): jump height, air control, jump curve
+- **State machines** (stored per-entity): `IdleState`, `WalkingState`, `JumpingState`, `FallingState`, `LeapingState`, `RollingState`
+- **Input** (`InputComponent`): current move direction, jump/parry key states
+- **Camera** (`CameraComponent`): FOV, aspect, yaw/pitch; `CameraTransition` for animated transitions
+- **Dialog** (`DialogBubbleComponent`, `DialogProjectileComponent`, `DialogSourceComponent`): Ink story state, projectile tracking, outcome events
+- **Rendering** (`MeshComponent`): mesh reference, pipeline, instance buffer, dissolve/snow-light flags
+- **Misc**: `FollowComponent`, `RotateComponent`, `DissolveComponent`, `TriggerComponent`, `ParticleEmitterConfig`
+
+### `src/states/state.rs`
+Per-entity state machine: `StateMachine` holds current `TypeId`, registered state types, and transitions. `State` trait defines lifecycle (`on_enter`, `on_physics_update`, `on_exit`). Transitions are condition predicates checked each update. Player entity uses this for locomotion states.
+
+### `src/systems/`
+Flat list of update functions called in main loop. Systems receive specific storage parameters (e.g., `&mut Storage<Transform>`, `&Storage<PhysicsComponent>`) instead of `&World`/`&mut World`. This makes data dependencies explicit for both borrow checker and reader. No cross-system coupling; all communication via world state and intents.
+- **Camera**: `camera_input_system(cameras, follows, input_state)` → generates intents; `camera_intent_system(follow_player_intents, stop_following_intents, camera_transition_intents, ...)` consumes them; `camera_follow_system(follows, cameras, transforms)`, `camera_noclip_system(cameras, follows, transforms, input_state, delta)`, `camera_transition_system(camera_transitions, transforms, cameras, delta)`, `camera_ground_clamp_system(cameras, follows, transforms)`
+- **Input**: `player_input_system(cameras, follows, player_tags, inputs, input_state)` reads SDL3 `InputState`, writes `InputComponent`
+- **Physics**: `state_machine_physics_system(&mut World, FIXED_TIMESTEP)` (fixed-step), `PhysicsManager::physics_step()`, `physics_sync_system(entities, physics, transforms)` copies rapier bodies back to transforms, `trigger_system(trigger_events, triggers, transforms, player_tags)` (AABB overlap → events)
+- **Dialog**: `dialog_system(entities, trigger_events, dialog_sources, bubble_tags, dialog_bubbles, transforms, names, player_tags, projectile_tags, dialog_projectiles, dialog_outcomes, delta)` ticks story state; `dialog_projectile_system(player_tags, transforms, projectile_tags, dialog_projectiles, spawn_particle_intents, dialog_outcomes, leaping_states, rolling_states, input_state)` moves projectiles; `dialog_camera_system(cameras, transforms, bubble_tags, player_pos, delta)` focuses camera on speaker; `dialog_bubble_render_system(transforms, dialog_bubbles, bubble_tags, camera_pos, view_proj)` generates billboard/text draw calls
+- **Rendering**: `render_system(entities, transforms, meshes, dissolves)` → `Vec<DrawCall>` from all meshes; snow layer adds clipmap draw calls; debug adds collider/gizmo calls; `spotlight_sync_system(spotlights, transforms)` syncs light positions to shader uniform
+- **State machine**: `state_machine_system(&mut World, delta)` (per-frame), `state_machine_physics_system(&mut World, FIXED_TIMESTEP)` (fixed-step) tick state lifecycle
+- **Trees**: `tree_occlusion_system(player_tags, transforms, cameras, tree_instances)` culls trees behind camera; `tree_dissolve_update_system(tree_instances, delta)` animates dissolve; `tree_instance_buffer_update_system(tree_instances)` writes GPU buffer
+- **Snow**: `snow_system(cameras, transforms, player_tags, follows, snow_layer)` deforms snow layer at physics contacts; `particle_intent_system(particle_buffers, spawn_particle_intents)`/`particle_update_system(particle_buffers, delta)` manage particle emitters
+- **Rotate**: `rotate_system(rotates, transforms, delta)` rotates entities by delta
+
+### `src/bundles/`
+Factory functions to spawn pre-configured entity groups:
+- `PlayerBundle`: player character with all locomotion components
+- `TestCharBundle`: test NPC
+- `CameraBundle`: camera entity
+- `TerrainBundle`: terrain mesh + collider
+- `SpotlightBundle` + `spawn_spotlights()`: light entities from scene data
+
+### `src/render/`
+GPU rendering pipeline via wgpu. Singleton `Renderer` stored in thread-local (global.rs).
+- **`Renderer`**: wgpu device/queue/surface, framebuffer, pipelines, bind groups, shadow map texture, spotlight data
+- **`DrawCall`** (types.rs): vertex/index buffers, model matrix, pipeline enum, instance buffer, entity ref
+- **Pipelines** (pipeline.rs): `create_main_pipeline()`, `create_snow_clipmap_pipeline()`, `create_wireframe_pipeline()`, `create_shadow_pipeline()`, `create_debug_lines_pipeline()`
+- **`Uniforms`** (types.rs): model/view/projection, 4 spotlights, camera position, height scale, player position, time, tile scale, debug mode
+- **Shadow**: `render_shadow_pass()` renders scene depth to shadow map from each spotlight
+- **Snow**: `SnowLayer` deforms snow heightfield via compute; `ClipmapConfig` manages multi-level clipmap grid; `deform_at_position()` marks terrain changed
+- **Snow light**: `SnowLightAccumulation` ping-pong texture accumulates light contributions from spotlights onto snow surface
+- **Billboard pipeline** + **Text pipeline**: render dialog bubbles and text overlays
+- **Particle pipeline**: billboarded particles with per-instance color/velocity
+- **Font atlas**: pre-rasterized glyph texture from embedded font file
+
+### `src/loaders/`
+Load scene data from glTF files:
+- **`scene.rs`** `Space::load_space()`: loads meshes, lights, player spawn, test char spawn from single glTF
+- **`mesh.rs`** `Mesh::load_gltf_with_instances()`: parses glTF buffers, vertex/index data, multi-instance mesh batches; `InstanceData` (position/rotation/scale/dissolve); `Vertex` (position/normal/UV)
+- **`lights.rs`**: extracts spotlight transforms/params from glTF nodes
+- **`empty.rs`**: extracts named empty (spawn point) transforms from glTF
+- **`heightmap.rs`**: loads EXR heightfield texture for terrain collision
+- **`terrain.rs`**: builds rapier heightfield collider from EXR matrix
+
+### `src/physics.rs`
+Thread-local `PhysicsManager` wrapping rapier3d. `physics_step()` runs one integration step; `add_rigidbody()`, `add_collider()` register bodies; `raycast()` queries. `HeightfieldData` caches terrain height matrix.
+
+### `src/utility/`
+- **`transform.rs`** `Transform`: matrix conversions to/from nalgebra `Isometry3`; getters/setters for position/rotation/scale
+- **`input.rs`** `InputState`: SDL3 key states (WASD, Space, Shift, Ctrl) and mouse delta; `handle_event()` updates state; `clear_just_pressed()` resets one-frame flags
+- **`time.rs`**: `Time::get_time_elapsed()` returns seconds since init (static Instant)
+
+### `src/debug/`
+- **`mode.rs`** `DebugMode` enum: None, Normals, UV, Depth, Wireframe, Colliders, ShadowMap, SnowLight; `cycle()` steps through
+- **`collider_debug.rs`**: renders rapier collider AABBs as line meshes
+- **`gizmo.rs`**: renders 3D transform gizmo (position/rotation/scale) for editor
+
+### `src/editor/`
+- **`inspector.rs`** `Inspector`: wraps Dear ImGui context; `render()` draws frame to texture; `build_ui()` draws entity inspector panels
+- **`mod.rs`** `EditorState`: manages editor active state, selected entity, mouse capture; `editor_loop()` calls inspector, handles picking
+
+### `src/picking.rs`, `src/postprocess.rs`, `src/texture.rs`, `src/paths.rs`
+Utility modules: ray casting for mouse pick, fullscreen blit/framebuffer downsampling, dither/flowmap texture loading, paths to asset files.
+
+## Data Flow
+
+1. **Initialization** (`main.rs` `init()`): SDL3 window → wgpu renderer (Vulkan) → World creation → load scene (Space from glTF) → spawn bundles (player, terrain, camera, lights) → initialize physics
+2. **Main loop** (`main.rs` `main()` with 60 Hz fixed physics + variable-rate graphics):
+   - **Per-frame** (delta): Input events → `player_input_system(cameras, follows, player_tags, inputs, input_state)` (fills `InputComponent`) + `camera_input_system(cameras, follows, input_state)` (generates intents)
+   - **Intent processing**: `camera_intent_system(follow_player_intents, stop_following_intents, camera_transition_intents, follows, transforms, cameras, player_tags, camera_transitions)` consumes intents, updates `CameraComponent`/`CameraTransition`
+   - **Camera systems**: `camera_follow_system(follows, cameras, transforms)` follows player; `camera_noclip_system(cameras, follows, transforms, input_state, delta)` noclip mode; `camera_transition_system(camera_transitions, transforms, cameras, delta)` animated transitions; `camera_ground_clamp_system(cameras, follows, transforms)` clamps to ground
+   - **Fixed physics** (1/60s accumulator):
+     - `state_machine_physics_system(&mut World, FIXED_TIMESTEP)`: tick state's `on_physics_update()`
+     - `PhysicsManager::physics_step()`: rapier integration
+     - `physics_sync_system(entities, physics, transforms)`: copy rigidbody poses to `Transform`
+     - `trigger_system(trigger_events, triggers, transforms, player_tags)`: detect collisions, emit events
+     - `dialog_system(entities, trigger_events, dialog_sources, bubble_tags, dialog_bubbles, transforms, names, player_tags, projectile_tags, dialog_projectiles, dialog_outcomes, delta)` ticks story state; `dialog_projectile_system(player_tags, transforms, projectile_tags, dialog_projectiles, spawn_particle_intents, dialog_outcomes, leaping_states, rolling_states, input_state)` moves projectiles
+   - **Per-frame systems**: `state_machine_system(&mut World, delta)` ticks state lifecycle; `rotate_system(rotates, transforms, delta)` rotates entities; `particle_intent_system(particle_buffers, spawn_particle_intents)`/`particle_update_system(particle_buffers, delta)` manage particles; `tree_occlusion_system(player_tags, transforms, cameras, tree_instances)` culls; `tree_dissolve_update_system(tree_instances, delta)`/`tree_instance_buffer_update_system(tree_instances)` updates dissolve; `snow_system(cameras, transforms, player_tags, follows, snow_layer)` deforms snow; `spotlight_sync_system(spotlights, transforms)` syncs lights
+   - **Render collection**: `render_system(entities, transforms, meshes, dissolves)` → `Vec<DrawCall>` from all meshes; snow layer adds clipmap draw calls; debug adds collider/gizmo calls
+   - **Submission**: `submit_frame()` renders draw calls, dialog bubbles/text, particles to framebuffer; blit to screen; optional ImGui overlay
+3. **Frame cleanup**: `InputState::clear_just_pressed()` resets one-frame flags
+
+## Key Types
+
+| Type | Module | Description |
+|------|--------|-------------|
+| `EntityHandle` | entity | u64 opaque entity ID |
+| `Storage<T>` | world | HashMap storage for per-entity component data; exposes `.get()`, `.get_mut()`, `.with_mut()`, `.all()` methods |
+| `World` | world | ECS container: entities, 20+ storages, intent queues, singleton state |
+| `Transform` | utility/transform | Position (Vec3), rotation (Quat), scale (Vec3); matrix conversions |
+| `StateMachine` | states/state | Per-entity state machine: current state TypeId, registered states, transitions |
+| `State` trait | states/state | Lifecycle: `on_enter`, `on_physics_update`, `on_exit`, `on_update` |
+| `PhysicsComponent` | components/physics | Rapier3d rigidbody + optional collider handles |
+| `MovementComponent` | components/movement | Walking speed, acceleration, damping, context (floored, last floor time) |
+| `JumpComponent` | components/jump | Jump height, duration, air control, context (in progress, origin height) |
+| `CameraComponent` | components/camera | FOV, aspect, yaw/pitch angles, is_active flag |
+| `InputComponent` | components/input | Current frame: move direction, jump/parry key states (flags) |
+| `MeshComponent` | components/mesh | Mesh ref, pipeline enum, instance buffer, dissolve/snow-light flags |
+| `DialogBubbleComponent` | components/dialog | Ink story, current text, dialog phase (displaying/projectile in flight), parry button |
+| `DrawCall` | render/types | GPU command: vertex/index buffers, model matrix, pipeline, instance count, entity ID |
+| `Uniforms` | render/types | Per-frame shader data: matrices, spotlight array, debug flags |
+| `Renderer` | render/mod | GPU state: device, queue, surface, all pipelines, framebuffer, texture samplers |
+| `Space` | loaders/scene | Loaded scene: mesh batches, spotlight data, spawn positions |
+| `Mesh` | loaders/mesh | GPU vertex/index buffers, AABB, CPU vertex data for physics |
+| `SnowLayer` | render/snow | Snow heightfield: deform bind groups, depth texture, clipmap grid levels |
+| `SnowLightAccumulation` | render/snow_light | Ping-pong textures + pipeline accumulating spotlight contributions onto snow |
+| `InputState` | utility/input | SDL3 event state: key flags, mouse delta, relative mode |
+| `PhysicsManager` | physics | Rapier3d bodies/colliders/pipeline; thread-local singleton |
+| `DebugMode` | debug/mode | Enum: None, Normals, UV, Depth, Wireframe, Colliders, ShadowMap, SnowLight |
+
+## Entry Points
+
+1. **`main()` in src/main.rs**
+   - Calls `init()` → initializes SDL3, wgpu, loads world from scene glTF, spawns entities
+   - Runs infinite loop: event poll → systems (camera/input/physics/render) → frame submit → sleep to 60 Hz
+2. **`Game::init()` in src/main.rs**
+   - SDL3 window + Vulkan surface
+   - `Renderer::new()` initializes all GPU pipelines and textures
+   - `init_world()` loads space, spawns bundles, sets up terrain/snow/lights
+3. **`World::new()` in src/world.rs**
+   - Creates empty storages for all 20+ component types and intent queues
+
+## Dependencies
+
+- **Engine**: wgpu (GPU), rapier3d (physics), glam (math), nalgebra (physics conversions), SDL3 (windowing/input)
+- **Content**: bladeink (Ink story scripting), image crate (EXR heightmaps), gltf (scene loading)
+- **Editor**: Dear ImGui via imgui crate + SDL3 integration
+- **Internal**: All systems take explicit storage parameters from `World`; systems are called in fixed sequence from main loop; no circular dependencies
+- **Thread-local singletons**: `Renderer` (render/global.rs), `PhysicsManager` (physics.rs), `GLOBAL_RENDERER`, `GLOBAL_PHYSICS`
+
+## Initialization Order
+
+1. SDL3 init → window creation → Vulkan adapter/device
+2. `Renderer::new()` → wgpu device/queue, create all pipelines, load textures (dither, flowmap, font atlas, shadow map, blue noise)
+3. Load scene from glTF → meshes, lights, spawns
+4. Spawn bundles: player (with input/movement/jump/state machine), terrain (mesh + heightfield collider), camera (follows player), lights (spotlights)
+5. Initialize snow layer (deform by tree positions)
+6. Initialize snow light accumulation (bind to spotlight data)
+7. Main loop: process events → run systems in sequence → submit frame

blender/addons/snow_trail_export.py

@@ -0,0 +1,218 @@
+bl_info = {
+    "name": "Snow Trail Export",
+    "author": "Snow Trail",
+    "version": (1, 0, 0),
+    "blender": (5, 0, 0),
+    "location": "3D Viewport > Sidebar > Snow Trail",
+    "description": "One-click glTF export to project assets folder",
+    "category": "Import-Export",
+}
+
+import bpy
+from pathlib import Path
+
+
+def find_project_root():
+    blend_path = Path(bpy.data.filepath)
+    if not blend_path.exists():
+        return None
+    candidate = blend_path.parent
+    while candidate != candidate.parent:
+        if (candidate / "assets").is_dir() and (candidate / "blender").is_dir():
+            return candidate
+        candidate = candidate.parent
+    return None
+
+
+def get_export_path():
+    blend_path = Path(bpy.data.filepath)
+    project_root = find_project_root()
+    if project_root is None:
+        return None
+    stem = blend_path.stem
+    return project_root / "assets" / "meshes" / f"{stem}.gltf"
+
+
+class SNOWTRAIL_OT_export_gltf(bpy.types.Operator):
+    bl_idname = "snow_trail.export_gltf"
+    bl_label = "Export to Project"
+    bl_description = "Export selected objects as glTF to assets/meshes/"
+    bl_options = {'REGISTER'}
+
+    def execute(self, context):
+        if not bpy.data.filepath:
+            self.report({'ERROR'}, "Save the .blend file first")
+            return {'CANCELLED'}
+
+        export_path = get_export_path()
+        if export_path is None:
+            self.report({'ERROR'}, "Could not find project root (looking for assets/ + blender/ dirs)")
+            return {'CANCELLED'}
+
+        export_path.parent.mkdir(parents=True, exist_ok=True)
+
+        selected = [obj for obj in context.selected_objects if obj.type == 'MESH']
+        if not selected:
+            self.report({'ERROR'}, "No mesh objects selected")
+            return {'CANCELLED'}
+
+        props = context.scene.snow_trail_export
+
+        bpy.ops.export_scene.gltf(
+            filepath=str(export_path),
+            export_format='GLTF_SEPARATE',
+            use_selection=True,
+            export_apply=props.apply_modifiers,
+            export_yup=True,
+            export_texcoords=True,
+            export_normals=True,
+            export_colors=props.export_vertex_colors,
+            export_materials='NONE' if not props.export_materials else 'EXPORT',
+            export_animations=props.export_animations,
+        )
+
+        rel_path = export_path.relative_to(find_project_root())
+        self.report({'INFO'}, f"Exported → {rel_path}")
+        return {'FINISHED'}
+
+
+class SNOWTRAIL_OT_export_heightmap(bpy.types.Operator):
+    bl_idname = "snow_trail.export_heightmap"
+    bl_label = "Bake Heightmap"
+    bl_description = "Run heightmap bake script for selected terrain"
+    bl_options = {'REGISTER'}
+
+    def execute(self, context):
+        project_root = find_project_root()
+        if project_root is None:
+            self.report({'ERROR'}, "Could not find project root")
+            return {'CANCELLED'}
+
+        script_path = project_root / "blender" / "scripts" / "generate_heightmap.py"
+        if not script_path.exists():
+            self.report({'ERROR'}, f"Script not found: {script_path}")
+            return {'CANCELLED'}
+
+        import importlib.util
+        spec = importlib.util.spec_from_file_location("generate_heightmap", str(script_path))
+        mod = importlib.util.module_from_spec(spec)
+        spec.loader.exec_module(mod)
+
+        terrain_obj = context.active_object
+        if terrain_obj is None or terrain_obj.type != 'MESH':
+            self.report({'ERROR'}, "Select a mesh object first")
+            return {'CANCELLED'}
+
+        output_path = project_root / "assets" / "textures" / "terrain_heightmap.exr"
+        mod.bake_heightmap(
+            terrain_obj=terrain_obj,
+            resolution=context.scene.snow_trail_export.heightmap_resolution,
+            output_path=str(output_path),
+        )
+
+        self.report({'INFO'}, f"Heightmap → assets/textures/terrain_heightmap.exr")
+        return {'FINISHED'}
+
+
+class SNOWTRAIL_ExportProperties(bpy.types.PropertyGroup):
+    apply_modifiers: bpy.props.BoolProperty(
+        name="Apply Modifiers",
+        default=True,
+        description="Apply modifiers before export",
+    )
+    export_vertex_colors: bpy.props.BoolProperty(
+        name="Vertex Colors",
+        default=True,
+        description="Export vertex colors",
+    )
+    export_materials: bpy.props.BoolProperty(
+        name="Materials",
+        default=False,
+        description="Export materials (usually not needed for retro aesthetic)",
+    )
+    export_animations: bpy.props.BoolProperty(
+        name="Animations",
+        default=False,
+        description="Export animations",
+    )
+    heightmap_resolution: bpy.props.IntProperty(
+        name="Heightmap Resolution",
+        default=1024,
+        min=128,
+        max=4096,
+        description="Resolution for heightmap bake",
+    )
+
+
+class SNOWTRAIL_PT_export_panel(bpy.types.Panel):
+    bl_label = "Snow Trail Export"
+    bl_idname = "SNOWTRAIL_PT_export_panel"
+    bl_space_type = 'VIEW_3D'
+    bl_region_type = 'UI'
+    bl_category = "Snow Trail"
+
+    def draw(self, context):
+        layout = self.layout
+        props = context.scene.snow_trail_export
+
+        export_path = get_export_path()
+        if export_path:
+            project_root = find_project_root()
+            rel = export_path.relative_to(project_root)
+            layout.label(text=f"Target: {rel}", icon='FILE')
+        elif not bpy.data.filepath:
+            layout.label(text="Save .blend file first!", icon='ERROR')
+        else:
+            layout.label(text="Project root not found!", icon='ERROR')
+
+        layout.separator()
+
+        box = layout.box()
+        box.label(text="glTF Options:", icon='MESH_DATA')
+        box.prop(props, "apply_modifiers")
+        box.prop(props, "export_vertex_colors")
+        box.prop(props, "export_materials")
+        box.prop(props, "export_animations")
+
+        selected_meshes = [o for o in context.selected_objects if o.type == 'MESH']
+        row = layout.row()
+        row.scale_y = 1.5
+        row.operator("snow_trail.export_gltf", icon='EXPORT')
+        if not selected_meshes:
+            row.enabled = False
+
+        if selected_meshes:
+            layout.label(text=f"{len(selected_meshes)} mesh(es) selected")
+        else:
+            layout.label(text="Select mesh objects to export", icon='INFO')
+
+        layout.separator()
+
+        box = layout.box()
+        box.label(text="Terrain Tools:", icon='WORLD')
+        box.prop(props, "heightmap_resolution")
+        box.operator("snow_trail.export_heightmap", icon='IMAGE_DATA')
+
+
+classes = (
+    SNOWTRAIL_ExportProperties,
+    SNOWTRAIL_OT_export_gltf,
+    SNOWTRAIL_OT_export_heightmap,
+    SNOWTRAIL_PT_export_panel,
+)
+
+
+def register():
+    for cls in classes:
+        bpy.utils.register_class(cls)
+    bpy.types.Scene.snow_trail_export = bpy.props.PointerProperty(type=SNOWTRAIL_ExportProperties)
+
+
+def unregister():
+    del bpy.types.Scene.snow_trail_export
+    for cls in reversed(classes):
+        bpy.utils.unregister_class(cls)
+
+
+if __name__ == "__main__":
+    register()

src/main.rs

@@ -305,7 +305,11 @@ fn toggle_editor(game: &mut Game)
 
 fn handle_editor_pick(game: &mut Game, x: f32, y: f32)
 {
-    let view = match camera_view_matrix(&game.world)
+    let view = match camera_view_matrix(
+        &game.world.cameras,
+        &game.world.transforms,
+        &game.world.follows,
+    )
     {
         Some(v) => v,
         None => return,
@@ -340,7 +344,11 @@ fn submit_frame(
         Some(t) => t,
         None => return,
     };
-    let view = match camera_view_matrix(&game.world)
+    let view = match camera_view_matrix(
+        &game.world.cameras,
+        &game.world.transforms,
+        &game.world.follows,
+    )
     {
         Some(v) => v,
         None => return,
@@ -350,8 +358,13 @@ fn submit_frame(
     let view_proj = projection * view;
     let player_pos = game.world.player_position();
 
-    let (billboard_calls, text_vertices) =
+    let (billboard_calls, text_vertices) = dialog_bubble_render_system(
-        dialog_bubble_render_system(&game.world, camera_transform.position, view_proj);
+        &game.world.transforms,
+        &game.world.dialog_bubbles,
+        &game.world.bubble_tags,
+        camera_transform.position,
+        view_proj,
+    );
 
     let frame = render::render(
         &view,
@@ -414,17 +427,67 @@ fn main() -> Result<(), Box<dyn std::error::Error>>
         }
 
         // --- intent generation ---
-        camera_input_system(&mut game.world, &game.input_state);
+        camera_input_system(
-        player_input_system(&mut game.world, &game.input_state);
+            &mut game.world.cameras,
-        dialog_camera_transition_system(&mut game.world, game.camera_entity);
+            &game.world.follows,
+            &game.input_state,
+        );
+        player_input_system(
+            &game.world.cameras,
+            &game.world.follows,
+            &game.world.player_tags,
+            &mut game.world.inputs,
+            &game.input_state,
+        );
+        dialog_camera_transition_system(
+            &game.world.bubble_tags,
+            &mut game.world.camera_transition_intents,
+            &mut game.world.was_dialog_active,
+            game.camera_entity,
+        );
 
         // --- intent processing + camera ---
-        camera_intent_system(&mut game.world);
+        camera_intent_system(
-        camera_noclip_system(&mut game.world, &game.input_state, delta);
+            &mut game.world.follow_player_intents,
-        dialog_camera_system(&mut game.world, delta);
+            &mut game.world.stop_following_intents,
-        camera_follow_system(&mut game.world);
+            &mut game.world.camera_transition_intents,
-        camera_transition_system(&mut game.world, delta);
+            &mut game.world.follows,
-        camera_ground_clamp_system(&mut game.world);
+            &mut game.world.transforms,
+            &mut game.world.cameras,
+            &game.world.player_tags,
+            &mut game.world.camera_transitions,
+        );
+        camera_noclip_system(
+            &game.world.cameras,
+            &game.world.follows,
+            &mut game.world.transforms,
+            &game.input_state,
+            delta,
+        );
+        let player_pos = game.world.player_position();
+        dialog_camera_system(
+            &mut game.world.cameras,
+            &mut game.world.transforms,
+            &game.world.bubble_tags,
+            player_pos,
+            delta,
+        );
+        camera_follow_system(
+            &mut game.world.follows,
+            &game.world.cameras,
+            &mut game.world.transforms,
+        );
+        camera_transition_system(
+            &mut game.world.camera_transitions,
+            &mut game.world.transforms,
+            &mut game.world.cameras,
+            delta,
+        );
+        camera_ground_clamp_system(
+            &game.world.cameras,
+            &game.world.follows,
+            &mut game.world.transforms,
+        );
 
         // --- editor overlay ---
         if game.editor.active
@@ -444,10 +507,42 @@ fn main() -> Result<(), Box<dyn std::error::Error>>
         {
             state_machine_physics_system(&mut game.world, FIXED_TIMESTEP);
             PhysicsManager::physics_step();
-            physics_sync_system(&mut game.world);
+            physics_sync_system(
-            trigger_system(&mut game.world);
+                &game.world.entities,
-            dialog_system(&mut game.world, FIXED_TIMESTEP);
+                &game.world.physics,
-            dialog_projectile_system(&mut game.world, &game.input_state);
+                &mut game.world.transforms,
+            );
+            trigger_system(
+                &mut game.world.trigger_events,
+                &mut game.world.triggers,
+                &game.world.transforms,
+                &game.world.player_tags,
+            );
+            dialog_system(
+                &mut game.world.entities,
+                &game.world.trigger_events,
+                &game.world.dialog_sources,
+                &mut game.world.bubble_tags,
+                &mut game.world.dialog_bubbles,
+                &mut game.world.transforms,
+                &mut game.world.names,
+                &game.world.player_tags,
+                &mut game.world.projectile_tags,
+                &mut game.world.dialog_projectiles,
+                &mut game.world.dialog_outcomes,
+                FIXED_TIMESTEP,
+            );
+            dialog_projectile_system(
+                &game.world.player_tags,
+                &mut game.world.transforms,
+                &mut game.world.projectile_tags,
+                &mut game.world.dialog_projectiles,
+                &mut game.world.spawn_particle_intents,
+                &mut game.world.dialog_outcomes,
+                &game.world.leaping_states,
+                &game.world.rolling_states,
+                &game.input_state,
+            );
             game.physics_accumulator -= FIXED_TIMESTEP;
         }
 
@@ -455,19 +550,33 @@ fn main() -> Result<(), Box<dyn std::error::Error>>
 
         // --- per-frame systems ---
         state_machine_system(&mut game.world, delta);
-        rotate_system(&mut game.world, delta);
+        rotate_system(&game.world.rotates, &mut game.world.transforms, delta);
 
-        tree_occlusion_system(&mut game.world);
+        tree_occlusion_system(
-        tree_dissolve_update_system(&mut game.world, delta);
+            &game.world.player_tags,
-        tree_instance_buffer_update_system(&mut game.world);
+            &game.world.transforms,
+            &game.world.cameras,
+            &mut game.world.tree_instances,
+        );
+        tree_dissolve_update_system(&mut game.world.tree_instances, delta);
+        tree_instance_buffer_update_system(&game.world.tree_instances);
 
-        let spotlights = spotlight_sync_system(&game.world);
+        let spotlights = spotlight_sync_system(&game.world.spotlights, &game.world.transforms);
         render::update_spotlights(spotlights);
 
-        snow_system(&mut game.world);
+        snow_system(
+            &game.world.cameras,
+            &game.world.transforms,
+            &game.world.player_tags,
+            &game.world.follows,
+            &mut game.world.snow_layer,
+        );
 
-        particle_intent_system(&mut game.world);
+        particle_intent_system(
-        particle_update_system(&mut game.world, delta);
+            &mut game.world.particle_buffers,
+            &mut game.world.spawn_particle_intents,
+        );
+        particle_update_system(&mut game.world.particle_buffers, delta);
         let particle_cam_pos = game.world.active_camera_position();
         if let Some(ref mut buffers) = game.world.particle_buffers
         {
@@ -475,7 +584,12 @@ fn main() -> Result<(), Box<dyn std::error::Error>>
         }
 
         // --- draw call collection ---
-        let mut draw_calls = render_system(&game.world);
+        let mut draw_calls = render_system(
+            &game.world.entities,
+            &game.world.transforms,
+            &game.world.meshes,
+            &game.world.dissolves,
+        );
         if let Some(ref snow_layer) = game.world.snow_layer
         {
             draw_calls.extend(snow_layer.get_draw_calls());

src/systems/camera.rs

@@ -1,22 +1,32 @@
 use glam::Vec3;
 
-use crate::components::camera::CameraTransition;
+use crate::components::camera::{CameraComponent, CameraTransition};
+use crate::components::intent::{CameraTransitionIntent, FollowPlayerIntent, StopFollowingIntent};
 use crate::components::FollowComponent;
 use crate::entity::EntityHandle;
 use crate::physics::PhysicsManager;
 use crate::utility::input::InputState;
-use crate::world::{Transform, World};
+use crate::utility::transform::Transform;
+use crate::world::Storage;
 
 const CAMERA_GROUND_OFFSET: f32 = 2.0;
 
-pub fn camera_view_matrix(world: &World) -> Option<glam::Mat4>
+pub fn camera_view_matrix(
+    cameras: &Storage<CameraComponent>,
+    transforms: &Storage<Transform>,
+    follows: &Storage<FollowComponent>,
+) -> Option<glam::Mat4>
 {
-    let (camera_entity, camera_component) = world.active_camera()?;
+    let (camera_entity, camera_component) = cameras
-    let camera_transform = world.transforms.get(camera_entity)?;
+        .components
+        .iter()
+        .find(|(_, cam)| cam.is_active)
+        .map(|(e, c)| (*e, c))?;
+    let camera_transform = transforms.get(camera_entity)?;
 
-    if let Some(follow) = world.follows.get(camera_entity)
+    if let Some(follow) = follows.get(camera_entity)
     {
-        if let Some(target_transform) = world.transforms.get(follow.target)
+        if let Some(target_transform) = transforms.get(follow.target)
         {
             return Some(glam::Mat4::look_at_rh(
                 camera_transform.position,
@@ -35,13 +45,17 @@ pub fn camera_view_matrix(world: &World) -> Option<glam::Mat4>
     ))
 }
 
-pub fn camera_input_system(world: &mut World, input_state: &InputState)
+pub fn camera_input_system(
+    cameras: &mut Storage<CameraComponent>,
+    follows: &Storage<FollowComponent>,
+    input_state: &InputState,
+)
 {
-    let cameras: Vec<_> = world.cameras.all();
+    let camera_entities: Vec<_> = cameras.all();
 
-    for camera_entity in cameras
+    for camera_entity in camera_entities
     {
-        if let Some(camera) = world.cameras.get_mut(camera_entity)
+        if let Some(camera) = cameras.get_mut(camera_entity)
         {
             if !camera.is_active
             {
@@ -50,7 +64,7 @@ pub fn camera_input_system(world: &mut World, input_state: &InputState)
 
             if input_state.mouse_delta.0.abs() > 0.0 || input_state.mouse_delta.1.abs() > 0.0
             {
-                let is_following = world.follows.get(camera_entity).is_some();
+                let is_following = follows.get(camera_entity).is_some();
 
                 camera.yaw += input_state.mouse_delta.0 * 0.0008;
 
@@ -71,49 +85,61 @@ pub fn camera_input_system(world: &mut World, input_state: &InputState)
     }
 }
 
-pub fn camera_intent_system(world: &mut World)
+pub fn camera_intent_system(
+    follow_player_intents: &mut Storage<FollowPlayerIntent>,
+    stop_following_intents: &mut Storage<StopFollowingIntent>,
+    camera_transition_intents: &mut Storage<CameraTransitionIntent>,
+    follows: &mut Storage<FollowComponent>,
+    transforms: &mut Storage<Transform>,
+    cameras: &mut Storage<CameraComponent>,
+    player_tags: &Storage<()>,
+    camera_transitions: &mut Storage<CameraTransition>,
+)
 {
-    let follow_entities: Vec<EntityHandle> = world.follow_player_intents.all();
+    let follow_entities: Vec<EntityHandle> = follow_player_intents.all();
     for entity in follow_entities
     {
-        start_camera_following(world, entity);
+        start_camera_following(follows, transforms, cameras, player_tags, entity);
-        world.follow_player_intents.remove(entity);
+        follow_player_intents.remove(entity);
     }
 
-    let stop_entities: Vec<EntityHandle> = world.stop_following_intents.all();
+    let stop_entities: Vec<EntityHandle> = stop_following_intents.all();
     for entity in stop_entities
     {
-        stop_camera_following(world, entity);
+        stop_camera_following(follows, transforms, cameras, entity);
-        world.stop_following_intents.remove(entity);
+        stop_following_intents.remove(entity);
     }
 
-    let transition_entities: Vec<EntityHandle> = world.camera_transition_intents.all();
+    let transition_entities: Vec<EntityHandle> = camera_transition_intents.all();
     for entity in transition_entities
     {
-        let duration = world
+        let duration = camera_transition_intents
-            .camera_transition_intents
             .get(entity)
             .map(|i| i.duration)
             .unwrap_or(0.5);
-        start_camera_transition(world, entity, duration);
+        start_camera_transition(camera_transitions, transforms, cameras, entity, duration);
-        world.camera_transition_intents.remove(entity);
+        camera_transition_intents.remove(entity);
     }
 }
 
-pub fn camera_follow_system(world: &mut World)
+pub fn camera_follow_system(
+    follows: &mut Storage<FollowComponent>,
+    cameras: &Storage<CameraComponent>,
+    transforms: &mut Storage<Transform>,
+)
 {
-    let camera_entities: Vec<_> = world.follows.all();
+    let camera_entities: Vec<_> = follows.all();
 
     for camera_entity in camera_entities
     {
-        if let Some(camera) = world.cameras.get(camera_entity)
+        if let Some(camera) = cameras.get(camera_entity)
         {
-            if let Some(follow) = world.follows.get(camera_entity)
+            if let Some(follow) = follows.get(camera_entity)
             {
                 let target_entity = follow.target;
                 let offset = follow.offset.position;
 
-                if let Some(target_transform) = world.transforms.get(target_entity)
+                if let Some(target_transform) = transforms.get(target_entity)
                 {
                     let target_position = target_transform.position;
                     let distance = offset.length();
@@ -126,13 +152,11 @@ pub fn camera_follow_system(world: &mut World)
 
                     let new_offset = Vec3::new(offset_x, offset_y, offset_z);
 
-                    world
+                    transforms.with_mut(camera_entity, |camera_transform| {
-                        .transforms
-                        .with_mut(camera_entity, |camera_transform| {
                         camera_transform.position = target_position + new_offset;
                     });
 
-                    world.follows.components.get_mut(&camera_entity).map(|f| {
+                    follows.components.get_mut(&camera_entity).map(|f| {
                         f.offset.position = new_offset;
                     });
                 }
@@ -141,23 +165,29 @@ pub fn camera_follow_system(world: &mut World)
     }
 }
 
-pub fn camera_noclip_system(world: &mut World, input_state: &InputState, delta: f32)
+pub fn camera_noclip_system(
+    cameras: &Storage<CameraComponent>,
+    follows: &Storage<FollowComponent>,
+    transforms: &mut Storage<Transform>,
+    input_state: &InputState,
+    delta: f32,
+)
 {
     if !input_state.mouse_captured
     {
         return;
     }
 
-    let cameras: Vec<_> = world.cameras.all();
+    let camera_entities: Vec<_> = cameras.all();
 
-    for camera_entity in cameras
+    for camera_entity in camera_entities
     {
-        if world.follows.get(camera_entity).is_some()
+        if follows.get(camera_entity).is_some()
         {
             continue;
         }
 
-        if let Some(camera) = world.cameras.get(camera_entity)
+        if let Some(camera) = cameras.get(camera_entity)
         {
             if !camera.is_active
             {
@@ -201,7 +231,7 @@ pub fn camera_noclip_system(world: &mut World, input_state: &InputState, delta:
                 speed *= 10.0;
             }
 
-            if let Some(camera_transform) = world.transforms.get_mut(camera_entity)
+            if let Some(camera_transform) = transforms.get_mut(camera_entity)
             {
                 camera_transform.position += forward * input_vec.z * speed;
                 camera_transform.position += right * input_vec.x * speed;
@@ -211,28 +241,34 @@ pub fn camera_noclip_system(world: &mut World, input_state: &InputState, delta:
     }
 }
 
-fn start_camera_following(world: &mut World, camera_entity: crate::entity::EntityHandle)
+fn start_camera_following(
+    follows: &mut Storage<FollowComponent>,
+    transforms: &mut Storage<Transform>,
+    cameras: &mut Storage<CameraComponent>,
+    player_tags: &Storage<()>,
+    camera_entity: EntityHandle,
+)
 {
-    if let Some(camera_transform) = world.transforms.get(camera_entity)
+    if let Some(camera_transform) = transforms.get(camera_entity)
     {
-        let player_entities = world.player_tags.all();
+        let player_entities = player_tags.all();
         if let Some(&player_entity) = player_entities.first()
         {
-            if let Some(target_transform) = world.transforms.get(player_entity)
+            if let Some(target_transform) = transforms.get(player_entity)
             {
                 let offset = camera_transform.position - target_transform.position;
                 let distance = offset.length();
 
                 if distance > 0.0
                 {
-                    if let Some(camera) = world.cameras.get_mut(camera_entity)
+                    if let Some(camera) = cameras.get_mut(camera_entity)
                     {
                         camera.pitch = (offset.y / distance).asin();
                         camera.yaw = offset.z.atan2(offset.x) + std::f32::consts::PI;
                     }
                 }
 
-                world.follows.insert(
+                follows.insert(
                     camera_entity,
                     FollowComponent {
                         target: player_entity,
@@ -246,20 +282,25 @@ fn start_camera_following(world: &mut World, camera_entity: crate::entity::Entit
     }
 }
 
-fn stop_camera_following(world: &mut World, camera_entity: crate::entity::EntityHandle)
+fn stop_camera_following(
+    follows: &mut Storage<FollowComponent>,
+    transforms: &Storage<Transform>,
+    cameras: &mut Storage<CameraComponent>,
+    camera_entity: EntityHandle,
+)
 {
-    if let Some(follow) = world.follows.get(camera_entity)
+    if let Some(follow) = follows.get(camera_entity)
     {
         let target_entity = follow.target;
 
-        if let Some(camera_transform) = world.transforms.get(camera_entity)
+        if let Some(camera_transform) = transforms.get(camera_entity)
         {
-            if let Some(target_transform) = world.transforms.get(target_entity)
+            if let Some(target_transform) = transforms.get(target_entity)
             {
                 let look_direction =
                     (target_transform.position - camera_transform.position).normalize();
 
-                if let Some(camera) = world.cameras.get_mut(camera_entity)
+                if let Some(camera) = cameras.get_mut(camera_entity)
                 {
                     camera.yaw = look_direction.z.atan2(look_direction.x);
                     camera.pitch = look_direction.y.asin();
@@ -267,24 +308,34 @@ fn stop_camera_following(world: &mut World, camera_entity: crate::entity::Entity
             }
         }
 
-        world.follows.remove(camera_entity);
+        follows.remove(camera_entity);
     }
 }
 
-pub fn camera_ground_clamp_system(world: &mut World)
+pub fn camera_ground_clamp_system(
+    cameras: &Storage<CameraComponent>,
+    follows: &Storage<FollowComponent>,
+    transforms: &mut Storage<Transform>,
+)
 {
-    let Some((camera_entity, _)) = world.active_camera()
+    let camera_entity = cameras
+        .components
+        .iter()
+        .find(|(_, cam)| cam.is_active)
+        .map(|(e, _)| *e);
+
+    let Some(camera_entity) = camera_entity
     else
     {
         return;
     };
 
-    if world.follows.get(camera_entity).is_none()
+    if follows.get(camera_entity).is_none()
     {
         return;
     }
 
-    world.transforms.with_mut(camera_entity, |t| {
+    transforms.with_mut(camera_entity, |t| {
         let ground_y =
             PhysicsManager::get_terrain_height_at(t.position.x, t.position.z).unwrap_or(0.0);
         let min_y = ground_y + CAMERA_GROUND_OFFSET;
@@ -295,9 +346,15 @@ pub fn camera_ground_clamp_system(world: &mut World)
     });
 }
 
-fn start_camera_transition(world: &mut World, camera_entity: EntityHandle, duration: f32)
+fn start_camera_transition(
+    camera_transitions: &mut Storage<CameraTransition>,
+    transforms: &mut Storage<Transform>,
+    cameras: &mut Storage<CameraComponent>,
+    camera_entity: EntityHandle,
+    duration: f32,
+)
 {
-    let Some(camera) = world.cameras.get(camera_entity)
+    let Some(camera) = cameras.get(camera_entity)
     else
     {
         return;
@@ -306,12 +363,11 @@ fn start_camera_transition(world: &mut World, camera_entity: EntityHandle, durat
     let source_yaw = camera.yaw;
     let source_pitch = camera.pitch;
 
-    let source_position = world
+    let source_position = transforms
-        .transforms
         .with(camera_entity, |t| t.position)
         .unwrap_or(Vec3::ZERO);
 
-    world.camera_transitions.insert(
+    camera_transitions.insert(
         camera_entity,
         CameraTransition {
             source_position,
@@ -323,14 +379,19 @@ fn start_camera_transition(world: &mut World, camera_entity: EntityHandle, durat
     );
 }
 
-pub fn camera_transition_system(world: &mut World, delta: f32)
+pub fn camera_transition_system(
+    camera_transitions: &mut Storage<CameraTransition>,
+    transforms: &mut Storage<Transform>,
+    cameras: &mut Storage<CameraComponent>,
+    delta: f32,
+)
 {
-    let entities: Vec<EntityHandle> = world.camera_transitions.all();
+    let entities: Vec<EntityHandle> = camera_transitions.all();
 
     for entity in entities
     {
         let finished = {
-            let Some(transition) = world.camera_transitions.get_mut(entity)
+            let Some(transition) = camera_transitions.get_mut(entity)
             else
             {
                 continue;
@@ -345,11 +406,11 @@ pub fn camera_transition_system(world: &mut World, delta: f32)
             let source_pitch = transition.source_pitch;
             let finished = t >= 1.0;
 
-            world.transforms.with_mut(entity, |transform| {
+            transforms.with_mut(entity, |transform| {
                 transform.position = source_position.lerp(transform.position, t);
             });
 
-            if let Some(camera) = world.cameras.get_mut(entity)
+            if let Some(camera) = cameras.get_mut(entity)
             {
                 camera.yaw = lerp_angle(source_yaw, camera.yaw, t);
                 camera.pitch = source_pitch + (camera.pitch - source_pitch) * t;
@@ -357,13 +418,12 @@ pub fn camera_transition_system(world: &mut World, delta: f32)
 
             if !finished
             {
-                if let Some(transition) = world.camera_transitions.get_mut(entity)
+                if let Some(transition) = camera_transitions.get_mut(entity)
                 {
-                    let pos = world
+                    let pos = transforms
-                        .transforms
                         .with(entity, |tr| tr.position)
                         .unwrap_or(Vec3::ZERO);
-                    let cam = world.cameras.get(entity);
+                    let cam = cameras.get(entity);
                     transition.source_position = pos;
                     if let Some(cam) = cam
                     {
@@ -378,7 +438,7 @@ pub fn camera_transition_system(world: &mut World, delta: f32)
 
         if finished
         {
-            world.camera_transitions.remove(entity);
+            camera_transitions.remove(entity);
         }
     }
 }

src/systems/dialog_camera.rs

@@ -1,18 +1,23 @@
 use glam::Vec3;
 
+use crate::components::camera::CameraComponent;
 use crate::components::intent::CameraTransitionIntent;
 use crate::entity::EntityHandle;
-use crate::world::World;
+use crate::utility::transform::Transform;
+use crate::world::Storage;
 
-pub fn dialog_camera_transition_system(world: &mut World, camera_entity: EntityHandle)
+pub fn dialog_camera_transition_system(
+    bubble_tags: &Storage<()>,
+    camera_transition_intents: &mut Storage<CameraTransitionIntent>,
+    was_dialog_active: &mut bool,
+    camera_entity: EntityHandle,
+)
 {
-    let dialog_active = !world.bubble_tags.all().is_empty();
+    let dialog_active = !bubble_tags.all().is_empty();
-    if dialog_active != world.was_dialog_active
+    if dialog_active != *was_dialog_active
     {
-        world
+        camera_transition_intents.insert(camera_entity, CameraTransitionIntent { duration: 0.8 });
-            .camera_transition_intents
+        *was_dialog_active = dialog_active;
-            .insert(camera_entity, CameraTransitionIntent { duration: 0.8 });
-        world.was_dialog_active = dialog_active;
     }
 }
 
@@ -21,21 +26,30 @@ const VERTICAL_BIAS: f32 = 0.4;
 const MIN_DISTANCE: f32 = 8.0;
 const MAX_DISTANCE: f32 = 24.0;
 
-pub fn dialog_camera_system(world: &mut World, delta: f32)
+pub fn dialog_camera_system(
+    cameras: &mut Storage<CameraComponent>,
+    transforms: &mut Storage<Transform>,
+    bubble_tags: &Storage<()>,
+    player_pos: Vec3,
+    delta: f32,
+)
 {
-    let Some((camera_entity, _)) = world.active_camera()
+    let camera_entity = cameras
+        .components
+        .iter()
+        .find(|(_, cam)| cam.is_active)
+        .map(|(e, _)| *e);
+
+    let Some(camera_entity) = camera_entity
     else
     {
         return;
     };
 
-    let player_pos = world.player_position();
+    let bubble_positions: Vec<Vec3> = bubble_tags
-
-    let bubble_positions: Vec<Vec3> = world
-        .bubble_tags
         .all()
         .iter()
-        .filter_map(|&bubble| world.transforms.with(bubble, |t| t.position))
+        .filter_map(|&bubble| transforms.with(bubble, |t| t.position))
         .collect();
 
     if bubble_positions.is_empty()
@@ -63,20 +77,19 @@ pub fn dialog_camera_system(world: &mut World, delta: f32)
     let target_camera_pos =
         centroid + camera_back_dir * camera_distance + Vec3::Y * camera_distance * VERTICAL_BIAS;
 
-    let current_camera_pos = world
+    let current_camera_pos = transforms
-        .transforms
         .with(camera_entity, |t| t.position)
         .unwrap_or(target_camera_pos);
 
     let smoothed = current_camera_pos.lerp(target_camera_pos, (CAMERA_LAG * delta).min(1.0));
 
-    world.transforms.with_mut(camera_entity, |t| {
+    transforms.with_mut(camera_entity, |t| {
         t.position = smoothed;
     });
 
     let look_target = centroid;
 
-    if let Some(camera) = world.cameras.get_mut(camera_entity)
+    if let Some(camera) = cameras.get_mut(camera_entity)
     {
         let look_dir = (look_target - smoothed).normalize_or(-Vec3::Z);
         camera.yaw = look_dir.z.atan2(look_dir.x);

src/systems/dialog_projectile.rs

@@ -2,39 +2,53 @@ use std::f32::consts::PI;
 
 use glam::Vec3;
 
-use crate::components::dialog::{DialogOutcome, DialogOutcomeEvent, ParryButton};
+use crate::components::dialog::{
+    DialogOutcome, DialogOutcomeEvent, DialogProjectileComponent, ParryButton,
+};
 use crate::components::particle::{ParticleEmitterConfig, SpawnParticleIntent};
+use crate::components::player_states::{LeapingState, RollingState};
 use crate::entity::EntityHandle;
 use crate::utility::input::InputState;
-use crate::world::World;
+use crate::utility::transform::Transform;
+use crate::world::Storage;
 
 const PROJECTILE_SPEED: f32 = 6.0;
 const PARRY_WINDOW_RADIUS: f32 = 3.5;
 const HIT_RADIUS: f32 = 1.2;
 
-pub fn dialog_projectile_system(world: &mut World, input_state: &InputState)
+pub fn dialog_projectile_system(
+    player_tags: &Storage<()>,
+    transforms: &mut Storage<Transform>,
+    projectile_tags: &mut Storage<()>,
+    dialog_projectiles: &mut Storage<DialogProjectileComponent>,
+    spawn_particle_intents: &mut Vec<SpawnParticleIntent>,
+    dialog_outcomes: &mut Vec<DialogOutcomeEvent>,
+    leaping_states: &Storage<LeapingState>,
+    rolling_states: &Storage<RollingState>,
+    input_state: &InputState,
+)
 {
-    let player_entity = world.player_tags.all().into_iter().next();
+    let player_entity = player_tags.all().into_iter().next();
     let Some(player_entity) = player_entity
     else
     {
         return;
     };
 
-    let player_pos = world
+    let player_pos = transforms
-        .transforms
         .with(player_entity, |t| t.position)
         .unwrap_or(Vec3::ZERO);
 
-    let player_is_evading = is_player_evading(world, player_entity);
+    let player_is_evading =
+        leaping_states.get(player_entity).is_some() || rolling_states.get(player_entity).is_some();
 
-    let projectiles: Vec<EntityHandle> = world.projectile_tags.all();
+    let projectiles: Vec<EntityHandle> = projectile_tags.all();
     let mut outcomes: Vec<DialogOutcomeEvent> = Vec::new();
     let mut to_despawn: Vec<EntityHandle> = Vec::new();
 
     for proj_entity in projectiles
     {
-        let proj_pos = match world.transforms.with(proj_entity, |t| t.position)
+        let proj_pos = match transforms.with(proj_entity, |t| t.position)
         {
             Some(p) => p,
             None => continue,
@@ -43,17 +57,20 @@ pub fn dialog_projectile_system(world: &mut World, input_state: &InputState)
         let to_player = player_pos - proj_pos;
         let distance = to_player.length();
 
-        let window_open = world
+        let window_open = dialog_projectiles
-            .dialog_projectiles
             .with(proj_entity, |p| p.parry_window_open)
             .unwrap_or(false);
 
         if window_open
         {
-            if let Some(outcome) = resolve_parry(world, proj_entity, input_state, player_is_evading)
+            if let Some(outcome) = resolve_parry(
+                dialog_projectiles,
+                proj_entity,
+                input_state,
+                player_is_evading,
+            )
             {
-                let bubble_entity = world
+                let bubble_entity = dialog_projectiles
-                    .dialog_projectiles
                     .with(proj_entity, |p| p.bubble_entity)
                     .unwrap();
                 outcomes.push(DialogOutcomeEvent {
@@ -67,8 +84,7 @@ pub fn dialog_projectile_system(world: &mut World, input_state: &InputState)
 
         if distance < HIT_RADIUS
         {
-            let bubble_entity = world
+            let bubble_entity = dialog_projectiles
-                .dialog_projectiles
                 .with(proj_entity, |p| p.bubble_entity)
                 .unwrap();
             let outcome = if player_is_evading
@@ -89,7 +105,7 @@ pub fn dialog_projectile_system(world: &mut World, input_state: &InputState)
 
         if distance < PARRY_WINDOW_RADIUS
         {
-            world.dialog_projectiles.with_mut(proj_entity, |p| {
+            dialog_projectiles.with_mut(proj_entity, |p| {
                 p.parry_window_open = true;
             });
         }
@@ -103,14 +119,14 @@ pub fn dialog_projectile_system(world: &mut World, input_state: &InputState)
             Vec3::ZERO
         };
 
-        world.transforms.with_mut(proj_entity, |t| {
+        transforms.with_mut(proj_entity, |t| {
             t.position += direction * PROJECTILE_SPEED * (1.0 / 60.0);
         });
 
-        let proj_pos = world.transforms.with(proj_entity, |t| t.position);
+        let proj_pos = transforms.with(proj_entity, |t| t.position);
         if let Some(pos) = proj_pos
         {
-            world.spawn_particle_intents.push(SpawnParticleIntent {
+            spawn_particle_intents.push(SpawnParticleIntent {
                 origin: pos,
                 config: projectile_swarm_config(),
             });
@@ -119,14 +135,16 @@ pub fn dialog_projectile_system(world: &mut World, input_state: &InputState)
 
     for entity in to_despawn
     {
-        world.despawn(entity);
+        transforms.remove(entity);
+        projectile_tags.remove(entity);
+        dialog_projectiles.remove(entity);
     }
 
-    world.dialog_outcomes.extend(outcomes);
+    dialog_outcomes.extend(outcomes);
 }
 
 fn resolve_parry(
-    world: &World,
+    dialog_projectiles: &Storage<DialogProjectileComponent>,
     proj_entity: EntityHandle,
     input_state: &InputState,
     player_is_evading: bool,
@@ -137,9 +155,7 @@ fn resolve_parry(
         return Some(DialogOutcome::Evaded);
     }
 
-    let correct_parry = world
+    let correct_parry = dialog_projectiles.with(proj_entity, |p| p.correct_parry)?;
-        .dialog_projectiles
-        .with(proj_entity, |p| p.correct_parry)?;
 
     if input_state.i_just_pressed
     {
@@ -200,9 +216,3 @@ fn projectile_swarm_config() -> ParticleEmitterConfig
         color_end: [0.2, 0.05, 0.0, 0.0],
     }
 }
-
-fn is_player_evading(world: &World, player_entity: EntityHandle) -> bool
-{
-    world.leaping_states.get(player_entity).is_some()
-        || world.rolling_states.get(player_entity).is_some()
-}

src/systems/dialog_render.rs

@@ -1,8 +1,10 @@
 use glam::{Mat4, Vec3};
 
+use crate::components::dialog::DialogBubbleComponent;
 use crate::render::billboard::{BillboardDrawCall, BillboardVertex, BubbleUniforms};
 use crate::render::{with_font_atlas, TextVertex};
-use crate::world::World;
+use crate::utility::transform::Transform;
+use crate::world::Storage;
 
 const MAX_BUBBLE_WIDTH: f32 = 8.0;
 const MIN_BUBBLE_WIDTH: f32 = 0.5;
@@ -19,7 +21,9 @@ const TEXT_PADDING: f32 = 0.06;
 const LINE_SPACING: f32 = 0.01;
 
 pub fn dialog_bubble_render_system(
-    world: &World,
+    transforms: &Storage<Transform>,
+    dialog_bubbles: &Storage<DialogBubbleComponent>,
+    bubble_tags: &Storage<()>,
     camera_pos: Vec3,
     view_proj: Mat4,
 ) -> (Vec<BillboardDrawCall>, Vec<TextVertex>)
@@ -27,17 +31,15 @@ pub fn dialog_bubble_render_system(
     let mut calls = Vec::new();
     let mut all_text: Vec<TextVertex> = Vec::new();
 
-    for bubble_entity in world.bubble_tags.all()
+    for bubble_entity in bubble_tags.all()
     {
-        let bubble_pos = match world.transforms.with(bubble_entity, |t| t.position)
+        let bubble_pos = match transforms.with(bubble_entity, |t| t.position)
         {
             Some(p) => p,
             None => continue,
         };
 
-        let text = match world
+        let text = match dialog_bubbles.with(bubble_entity, |b| b.current_text.clone())
-            .dialog_bubbles
-            .with(bubble_entity, |b| b.current_text.clone())
         {
             Some(t) => t,
             None => continue,
@@ -57,7 +59,7 @@ pub fn dialog_bubble_render_system(
             // Compute body height analytically.
             // border_world = BORDER_W * body_height  (body is the smaller dimension)
             // body_height = text_h + 2 * (border_world + TEXT_PADDING)
-            // → body_height * (1 - 2*BORDER_W) = text_h + 2*TEXT_PADDING
+            // -> body_height * (1 - 2*BORDER_W) = text_h + 2*TEXT_PADDING
             let text_h = n_lines as f32 * CHAR_WORLD_HEIGHT
                 + n_lines.saturating_sub(1) as f32 * LINE_SPACING;
             let body_height = (text_h + 2.0 * TEXT_PADDING) / (1.0 - 2.0 * BORDER_W);

src/systems/dialog_system.rs

@@ -2,30 +2,74 @@ use bladeink::story::Story;
 use glam::Vec3;
 
 use crate::components::dialog::{
-    DialogBubbleComponent, DialogPhase, DialogProjectileComponent, ParryButton,
+    DialogBubbleComponent, DialogOutcomeEvent, DialogPhase, DialogProjectileComponent,
+    DialogSourceComponent, ParryButton,
 };
-use crate::components::trigger::TriggerEventKind;
+use crate::components::trigger::{TriggerEvent, TriggerEventKind};
-use crate::entity::EntityHandle;
+use crate::entity::{EntityHandle, EntityManager};
-use crate::world::{Transform, World};
+use crate::utility::transform::Transform;
+use crate::world::Storage;
 
 const DEFAULT_DISPLAY_TIME: f32 = 3.0;
 const PARRY_TAG_PREFIX: &str = "parry:";
 const TIMER_TAG_PREFIX: &str = "timer:";
 
-pub fn dialog_system(world: &mut World, delta: f32)
+pub fn dialog_system(
+    entities: &mut EntityManager,
+    trigger_events: &[TriggerEvent],
+    dialog_sources: &Storage<DialogSourceComponent>,
+    bubble_tags: &mut Storage<()>,
+    dialog_bubbles: &mut Storage<DialogBubbleComponent>,
+    transforms: &mut Storage<Transform>,
+    names: &mut Storage<String>,
+    player_tags: &Storage<()>,
+    projectile_tags: &mut Storage<()>,
+    dialog_projectiles: &mut Storage<DialogProjectileComponent>,
+    dialog_outcomes: &mut Vec<DialogOutcomeEvent>,
+    delta: f32,
+)
 {
-    process_trigger_events(world);
+    process_trigger_events(
-    tick_displaying_bubbles(world, delta);
+        entities,
-    process_outcomes(world);
+        trigger_events,
+        dialog_sources,
+        bubble_tags,
+        dialog_bubbles,
+        transforms,
+        names,
+        projectile_tags,
+        dialog_projectiles,
+    );
+    tick_displaying_bubbles(
+        entities,
+        bubble_tags,
+        dialog_bubbles,
+        transforms,
+        player_tags,
+        projectile_tags,
+        dialog_projectiles,
+        delta,
+    );
+    process_outcomes(bubble_tags, dialog_bubbles, dialog_outcomes);
 }
 
-fn process_trigger_events(world: &mut World)
+fn process_trigger_events(
+    entities: &mut EntityManager,
+    trigger_events: &[TriggerEvent],
+    dialog_sources: &Storage<DialogSourceComponent>,
+    bubble_tags: &mut Storage<()>,
+    dialog_bubbles: &mut Storage<DialogBubbleComponent>,
+    transforms: &mut Storage<Transform>,
+    names: &mut Storage<String>,
+    projectile_tags: &mut Storage<()>,
+    dialog_projectiles: &mut Storage<DialogProjectileComponent>,
+)
 {
-    let events: Vec<_> = world.trigger_events.iter().cloned().collect();
+    let events: Vec<_> = trigger_events.iter().cloned().collect();
 
     for event in events
     {
-        let has_source = world.dialog_sources.get(event.trigger_entity).is_some();
+        let has_source = dialog_sources.get(event.trigger_entity).is_some();
         if !has_source
         {
             continue;
@@ -35,9 +79,8 @@ fn process_trigger_events(world: &mut World)
         {
             TriggerEventKind::Entered =>
             {
-                let already_active = world.bubble_tags.all().iter().any(|&b| {
+                let already_active = bubble_tags.all().iter().any(|&b| {
-                    world
+                    dialog_bubbles
-                        .dialog_bubbles
                         .with(b, |db| db.character_entity == event.trigger_entity)
                         .unwrap_or(false)
                 });
@@ -47,22 +90,43 @@ fn process_trigger_events(world: &mut World)
                     continue;
                 }
 
-                spawn_bubble(world, event.trigger_entity);
+                spawn_bubble(
+                    entities,
+                    dialog_sources,
+                    bubble_tags,
+                    dialog_bubbles,
+                    transforms,
+                    names,
+                    event.trigger_entity,
+                );
             }
 
             TriggerEventKind::Exited =>
             {
-                despawn_bubbles_for_character(world, event.trigger_entity);
+                despawn_bubbles_for_character(
+                    bubble_tags,
+                    dialog_bubbles,
+                    transforms,
+                    projectile_tags,
+                    dialog_projectiles,
+                    event.trigger_entity,
+                );
             }
         }
     }
 }
 
-fn spawn_bubble(world: &mut World, character_entity: EntityHandle)
+fn spawn_bubble(
+    entities: &mut EntityManager,
+    dialog_sources: &Storage<DialogSourceComponent>,
+    bubble_tags: &mut Storage<()>,
+    dialog_bubbles: &mut Storage<DialogBubbleComponent>,
+    transforms: &mut Storage<Transform>,
+    names: &mut Storage<String>,
+    character_entity: EntityHandle,
+)
 {
-    let ink_json = match world
+    let ink_json = match dialog_sources.with(character_entity, |s| s.ink_json.clone())
-        .dialog_sources
-        .with(character_entity, |s| s.ink_json.clone())
     {
         Some(json) => json,
         None => return,
@@ -80,21 +144,18 @@ fn spawn_bubble(world: &mut World, character_entity: EntityHandle)
 
     let (text, parry, display_time) = advance_story(&mut story);
 
-    let character_pos = world
+    let character_pos = transforms
-        .transforms
         .with(character_entity, |t| t.position)
         .unwrap_or(Vec3::ZERO);
 
-    let bubble_entity = world.spawn();
+    let bubble_entity = entities.spawn();
-    world.transforms.insert(
+    transforms.insert(
         bubble_entity,
         Transform::from_position(character_pos + Vec3::new(0.0, 8.0, 0.0)),
     );
-    world
+    names.insert(bubble_entity, "DialogBubble".to_string());
-        .names
+    bubble_tags.insert(bubble_entity, ());
-        .insert(bubble_entity, "DialogBubble".to_string());
+    dialog_bubbles.insert(
-    world.bubble_tags.insert(bubble_entity, ());
-    world.dialog_bubbles.insert(
         bubble_entity,
         DialogBubbleComponent {
             story,
@@ -109,14 +170,20 @@ fn spawn_bubble(world: &mut World, character_entity: EntityHandle)
     );
 }
 
-fn despawn_bubbles_for_character(world: &mut World, character_entity: EntityHandle)
+fn despawn_bubbles_for_character(
+    bubble_tags: &mut Storage<()>,
+    dialog_bubbles: &mut Storage<DialogBubbleComponent>,
+    transforms: &mut Storage<Transform>,
+    projectile_tags: &mut Storage<()>,
+    dialog_projectiles: &mut Storage<DialogProjectileComponent>,
+    character_entity: EntityHandle,
+)
 {
-    let bubbles: Vec<EntityHandle> = world.bubble_tags.all();
+    let bubbles: Vec<EntityHandle> = bubble_tags.all();
 
     for bubble_entity in bubbles
     {
-        let matches = world
+        let matches = dialog_bubbles
-            .dialog_bubbles
             .with(bubble_entity, |b| b.character_entity == character_entity)
             .unwrap_or(false);
 
@@ -125,26 +192,38 @@ fn despawn_bubbles_for_character(world: &mut World, character_entity: EntityHand
             continue;
         }
 
-        if let Some(bubble) = world.dialog_bubbles.get(bubble_entity)
+        if let Some(bubble) = dialog_bubbles.get(bubble_entity)
         {
             if let DialogPhase::ProjectileInFlight { projectile_entity } = bubble.phase
             {
-                world.despawn(projectile_entity);
+                transforms.remove(projectile_entity);
+                projectile_tags.remove(projectile_entity);
+                dialog_projectiles.remove(projectile_entity);
             }
         }
 
-        world.despawn(bubble_entity);
+        transforms.remove(bubble_entity);
+        bubble_tags.remove(bubble_entity);
+        dialog_bubbles.remove(bubble_entity);
     }
 }
 
-fn tick_displaying_bubbles(world: &mut World, delta: f32)
+fn tick_displaying_bubbles(
+    entities: &mut EntityManager,
+    bubble_tags: &mut Storage<()>,
+    dialog_bubbles: &mut Storage<DialogBubbleComponent>,
+    transforms: &mut Storage<Transform>,
+    player_tags: &Storage<()>,
+    projectile_tags: &mut Storage<()>,
+    dialog_projectiles: &mut Storage<DialogProjectileComponent>,
+    delta: f32,
+)
 {
-    let bubbles: Vec<EntityHandle> = world.bubble_tags.all();
+    let bubbles: Vec<EntityHandle> = bubble_tags.all();
 
     for bubble_entity in bubbles
     {
-        let expired = world
+        let expired = dialog_bubbles
-            .dialog_bubbles
             .with_mut(bubble_entity, |b| {
                 if let DialogPhase::Displaying { ref mut timer } = b.phase
                 {
@@ -160,45 +239,37 @@ fn tick_displaying_bubbles(world: &mut World, delta: f32)
 
         if expired
         {
-            let correct_parry = match world
+            let correct_parry = match dialog_bubbles.with(bubble_entity, |b| b.correct_parry)
-                .dialog_bubbles
-                .with(bubble_entity, |b| b.correct_parry)
             {
                 Some(Some(p)) => p,
                 _ =>
                 {
-                    world.despawn(bubble_entity);
+                    transforms.remove(bubble_entity);
+                    bubble_tags.remove(bubble_entity);
+                    dialog_bubbles.remove(bubble_entity);
                     continue;
                 }
             };
 
-            let bubble_pos = world
+            let bubble_pos = transforms
-                .transforms
                 .with(bubble_entity, |t| t.position)
                 .unwrap_or(Vec3::ZERO);
 
-            let player_entity = world
+            let player_entity = player_tags
-                .player_tags
                 .all()
                 .into_iter()
                 .next()
                 .expect("no player entity");
-            let player_pos = world
+            let player_pos = transforms
-                .transforms
                 .with(player_entity, |t| t.position)
                 .unwrap_or(Vec3::ZERO);
 
             let velocity = player_pos - bubble_pos;
 
-            let projectile_entity = world.spawn();
+            let projectile_entity = entities.spawn();
-            world
+            transforms.insert(projectile_entity, Transform::from_position(bubble_pos));
-                .transforms
+            projectile_tags.insert(projectile_entity, ());
-                .insert(projectile_entity, Transform::from_position(bubble_pos));
+            dialog_projectiles.insert(
-            world
-                .names
-                .insert(projectile_entity, "DialogProjectile".to_string());
-            world.projectile_tags.insert(projectile_entity, ());
-            world.dialog_projectiles.insert(
                 projectile_entity,
                 DialogProjectileComponent {
                     bubble_entity,
@@ -208,29 +279,33 @@ fn tick_displaying_bubbles(world: &mut World, delta: f32)
                 },
             );
 
-            world.dialog_bubbles.with_mut(bubble_entity, |b| {
+            dialog_bubbles.with_mut(bubble_entity, |b| {
                 b.phase = DialogPhase::ProjectileInFlight { projectile_entity };
             });
         }
     }
 }
 
-fn process_outcomes(world: &mut World)
+fn process_outcomes(
+    bubble_tags: &mut Storage<()>,
+    dialog_bubbles: &mut Storage<DialogBubbleComponent>,
+    dialog_outcomes: &mut Vec<DialogOutcomeEvent>,
+)
 {
-    let outcomes: Vec<_> = world.dialog_outcomes.drain(..).collect();
+    let outcomes: Vec<_> = dialog_outcomes.drain(..).collect();
 
     for event in outcomes
     {
         let bubble_entity = event.bubble_entity;
 
-        if world.dialog_bubbles.get(bubble_entity).is_none()
+        if dialog_bubbles.get(bubble_entity).is_none()
         {
             continue;
         }
 
         let choice_tag = event.outcome.to_choice_tag();
 
-        let next = world.dialog_bubbles.with_mut(bubble_entity, |b| {
+        let next = dialog_bubbles.with_mut(bubble_entity, |b| {
             let choices = b.story.get_current_choices();
             let idx = choices
                 .iter()
@@ -264,7 +339,7 @@ fn process_outcomes(world: &mut World)
         {
             Some(Some((text, parry, display_time))) =>
             {
-                world.dialog_bubbles.with_mut(bubble_entity, |b| {
+                dialog_bubbles.with_mut(bubble_entity, |b| {
                     b.current_text = text;
                     b.correct_parry = parry;
                     b.display_time = display_time;
@@ -276,7 +351,8 @@ fn process_outcomes(world: &mut World)
 
             Some(None) =>
             {
-                world.despawn(bubble_entity);
+                bubble_tags.remove(bubble_entity);
+                dialog_bubbles.remove(bubble_entity);
             }
 
             None =>

src/systems/follow.rs

@@ -1,15 +1,17 @@
-use crate::world::World;
+use crate::components::FollowComponent;
+use crate::utility::transform::Transform;
+use crate::world::Storage;
 
-pub fn follow_system(world: &mut World)
+pub fn follow_system(follows: &mut Storage<FollowComponent>, transforms: &mut Storage<Transform>)
 {
-    let following_entities: Vec<_> = world.follows.all();
+    let following_entities: Vec<_> = follows.all();
 
     for entity in following_entities
     {
-        if let Some(follow) = world.follows.get(entity)
+        if let Some(follow) = follows.get(entity)
         {
             let target = follow.target;
-            if let Some(target_transform) = world.transforms.get(target)
+            if let Some(target_transform) = transforms.get(target)
             {
                 let target_pos = target_transform.position;
                 let target_rot = target_transform.rotation;
@@ -18,7 +20,7 @@ pub fn follow_system(world: &mut World)
                 let inherit_rot = follow.inherit_rotation;
                 let inherit_scale = follow.inherit_scale;
 
-                world.transforms.with_mut(entity, |transform| {
+                transforms.with_mut(entity, |transform| {
                     transform.position = target_pos;
 
                     if inherit_rot

src/systems/input.rs

@@ -1,29 +1,45 @@
 use glam::Vec3;
 
+use crate::components::camera::CameraComponent;
+use crate::components::FollowComponent;
+use crate::components::InputComponent;
 use crate::utility::input::InputState;
-use crate::world::World;
+use crate::world::Storage;
 
-pub fn player_input_system(world: &mut World, input_state: &InputState)
+pub fn player_input_system(
+    cameras: &Storage<CameraComponent>,
+    follows: &Storage<FollowComponent>,
+    player_tags: &Storage<()>,
+    inputs: &mut Storage<InputComponent>,
+    input_state: &InputState,
+)
 {
-    if !world.camera_is_following()
+    let camera_is_following = cameras
+        .components
+        .iter()
+        .find(|(_, cam)| cam.is_active)
+        .map(|(e, _)| follows.get(*e).is_some())
+        .unwrap_or(false);
+
+    if !camera_is_following
     {
         return;
     }
 
-    let Some((_, camera)) = world.active_camera()
+    let (_, camera) = match cameras.components.iter().find(|(_, cam)| cam.is_active)
-    else
     {
-        return;
+        Some((e, c)) => (*e, c),
+        None => return,
     };
 
     let forward = camera.get_forward_horizontal();
     let right = camera.get_right_horizontal();
 
-    let players = world.player_tags.all();
+    let players = player_tags.all();
 
     for player in players
     {
-        world.inputs.with_mut(player, |input_component| {
+        inputs.with_mut(player, |input_component| {
             let mut local_input = Vec3::ZERO;
 
             if input_state.w

src/systems/particle.rs

@@ -2,7 +2,6 @@ use rand::Rng;
 
 use crate::components::particle::{ParticleEmitterConfig, SpawnParticleIntent};
 use crate::render::particle_types::ParticleInstanceRaw;
-use crate::world::World;
 
 pub struct Particle
 {
@@ -92,24 +91,27 @@ fn spawn_from_config(
     }
 }
 
-pub fn particle_intent_system(world: &mut World)
+pub fn particle_intent_system(
+    particle_buffers: &mut Option<ParticleBuffers>,
+    spawn_particle_intents: &mut Vec<SpawnParticleIntent>,
+)
 {
-    if world.particle_buffers.is_none()
+    if particle_buffers.is_none()
     {
-        world.particle_buffers = Some(ParticleBuffers {
+        *particle_buffers = Some(ParticleBuffers {
             particles: Vec::new(),
             instances: Vec::new(),
             emit_accumulator: 0.0,
         });
     }
 
-    let intents: Vec<SpawnParticleIntent> = world.spawn_particle_intents.drain(..).collect();
+    let intents: Vec<SpawnParticleIntent> = spawn_particle_intents.drain(..).collect();
     if intents.is_empty()
     {
         return;
     }
 
-    let buffers = world.particle_buffers.as_mut().unwrap();
+    let buffers = particle_buffers.as_mut().unwrap();
     let mut rng = rand::rng();
     for intent in intents
     {
@@ -117,9 +119,9 @@ pub fn particle_intent_system(world: &mut World)
     }
 }
 
-pub fn particle_update_system(world: &mut World, delta: f32)
+pub fn particle_update_system(particle_buffers: &mut Option<ParticleBuffers>, delta: f32)
 {
-    let Some(ref mut buffers) = world.particle_buffers
+    let Some(ref mut buffers) = particle_buffers
     else
     {
         return;

src/systems/physics_sync.rs

@@ -1,21 +1,27 @@
+use crate::components::PhysicsComponent;
+use crate::entity::EntityManager;
 use crate::physics::PhysicsManager;
 use crate::utility::transform::Transform;
-use crate::world::World;
+use crate::world::Storage;
 
-pub fn physics_sync_system(world: &mut World)
+pub fn physics_sync_system(
+    entities: &EntityManager,
+    physics: &Storage<PhysicsComponent>,
+    transforms: &mut Storage<Transform>,
+)
 {
-    let all_entities = world.entities.all_entities();
+    let all_entities = entities.all_entities();
 
     for entity in all_entities
     {
-        if let Some(physics) = world.physics.get(entity)
+        if let Some(physics) = physics.get(entity)
         {
             if let Some(rigidbody_position) =
                 PhysicsManager::get_rigidbody_position(physics.rigidbody)
             {
                 let transform = Transform::from(rigidbody_position);
 
-                world.transforms.with_mut(entity, |t| {
+                transforms.with_mut(entity, |t| {
                     *t = transform;
                 });
             }

src/systems/render.rs

@@ -1,17 +1,25 @@
+use crate::components::{DissolveComponent, MeshComponent};
+use crate::entity::EntityManager;
 use crate::loaders::mesh::InstanceRaw;
 use crate::render::DrawCall;
-use crate::world::World;
+use crate::utility::transform::Transform;
+use crate::world::Storage;
 use bytemuck::cast_slice;
 
-pub fn render_system(world: &World) -> Vec<DrawCall>
+pub fn render_system(
+    entities: &EntityManager,
+    transforms: &Storage<Transform>,
+    meshes: &Storage<MeshComponent>,
+    dissolves: &Storage<DissolveComponent>,
+) -> Vec<DrawCall>
 {
-    let all_entities = world.entities.all_entities();
+    let all_entities = entities.all_entities();
 
     all_entities
         .iter()
         .filter_map(|&entity| {
-            let transform = world.transforms.get(entity)?;
+            let transform = transforms.get(entity)?;
-            let mesh_component = world.meshes.get(entity)?;
+            let mesh_component = meshes.get(entity)?;
 
             let model_matrix = transform.to_matrix();
 
@@ -22,7 +30,7 @@ pub fn render_system(world: &World) -> Vec<DrawCall>
             }
             else
             {
-                let dissolve_amount = world.dissolves.get(entity).map(|d| d.amount).unwrap_or(0.0);
+                let dissolve_amount = dissolves.get(entity).map(|d| d.amount).unwrap_or(0.0);
 
                 let instance_data = InstanceRaw {
                     model: model_matrix.to_cols_array_2d(),

src/systems/rotate.rs

@@ -1,18 +1,24 @@
 use glam::Quat;
 
-use crate::world::World;
+use crate::components::RotateComponent;
+use crate::utility::transform::Transform;
+use crate::world::Storage;
 
-pub fn rotate_system(world: &mut World, delta: f32)
+pub fn rotate_system(
+    rotates: &Storage<RotateComponent>,
+    transforms: &mut Storage<Transform>,
+    delta: f32,
+)
 {
-    let entities = world.rotates.all();
+    let entities = rotates.all();
 
     for entity in entities
     {
-        if let Some(rotate) = world.rotates.get(entity)
+        if let Some(rotate) = rotates.get(entity)
         {
             let rotation_delta = Quat::from_axis_angle(rotate.axis, rotate.speed * delta);
 
-            world.transforms.with_mut(entity, |transform| {
+            transforms.with_mut(entity, |transform| {
                 transform.rotation = rotation_delta * transform.rotation;
             });
         }

src/systems/snow.rs

@@ -1,11 +1,40 @@
-use crate::world::World;
+use crate::components::camera::CameraComponent;
+use crate::components::FollowComponent;
+use crate::render::snow::SnowLayer;
+use crate::utility::transform::Transform;
+use crate::world::Storage;
 
-pub fn snow_system(world: &mut World)
+pub fn snow_system(
+    cameras: &Storage<CameraComponent>,
+    transforms: &Storage<Transform>,
+    player_tags: &Storage<()>,
+    follows: &Storage<FollowComponent>,
+    snow_layer: &mut Option<SnowLayer>,
+)
 {
-    let camera_pos = world.active_camera_position();
+    let camera_pos = cameras
-    let player_pos = world.player_position();
+        .components
-    let is_following = world.camera_is_following();
+        .iter()
-    if let Some(ref mut snow_layer) = world.snow_layer
+        .find(|(_, cam)| cam.is_active)
+        .and_then(|(e, _)| transforms.get(*e))
+        .map(|t| t.position)
+        .unwrap_or(glam::Vec3::ZERO);
+
+    let player_pos = player_tags
+        .all()
+        .first()
+        .and_then(|e| transforms.get(*e))
+        .map(|t| t.position)
+        .unwrap_or(glam::Vec3::ZERO);
+
+    let is_following = cameras
+        .components
+        .iter()
+        .find(|(_, cam)| cam.is_active)
+        .map(|(e, _)| follows.get(*e).is_some())
+        .unwrap_or(false);
+
+    if let Some(ref mut snow_layer) = snow_layer
     {
         if is_following
         {

src/systems/spotlight_sync.rs

@@ -1,23 +1,28 @@
+use crate::components::lights::spot::SpotlightComponent;
 use crate::render::Spotlight;
-use crate::world::World;
+use crate::utility::transform::Transform;
+use crate::world::Storage;
 
-pub fn spotlight_sync_system(world: &World) -> Vec<Spotlight>
+pub fn spotlight_sync_system(
+    spotlights: &Storage<SpotlightComponent>,
+    transforms: &Storage<Transform>,
+) -> Vec<Spotlight>
 {
-    let mut entities = world.spotlights.all();
+    let mut entities = spotlights.all();
     entities.sort();
 
-    let mut spotlights = Vec::new();
+    let mut result = Vec::new();
 
     for entity in entities
     {
-        if let Some(spotlight_component) = world.spotlights.get(entity)
+        if let Some(spotlight_component) = spotlights.get(entity)
         {
-            if let Some(transform) = world.transforms.get(entity)
+            if let Some(transform) = transforms.get(entity)
             {
                 let position = transform.position + spotlight_component.offset;
                 let direction = transform.rotation * spotlight_component.direction;
 
-                spotlights.push(Spotlight::new(
+                result.push(Spotlight::new(
                     position,
                     direction,
                     spotlight_component.inner_angle,
@@ -28,5 +33,5 @@ pub fn spotlight_sync_system(world: &World) -> Vec<Spotlight>
         }
     }
 
-    spotlights
+    result
 }

src/systems/tree_dissolve.rs

@@ -1,12 +1,15 @@
+use crate::components::camera::CameraComponent;
+use crate::components::tree_instances::TreeInstancesComponent;
 use crate::loaders::mesh::InstanceRaw;
-use crate::world::World;
+use crate::utility::transform::Transform;
+use crate::world::Storage;
 use bytemuck::cast_slice;
 
-pub fn tree_dissolve_update_system(world: &mut World, delta: f32)
+pub fn tree_dissolve_update_system(tree_instances: &mut Storage<TreeInstancesComponent>, delta: f32)
 {
-    for entity in world.tree_instances.all()
+    for entity in tree_instances.all()
     {
-        if let Some(tree_instances) = world.tree_instances.get_mut(entity)
+        if let Some(tree_instances) = tree_instances.get_mut(entity)
         {
             for i in 0..tree_instances.dissolve_amounts.len()
             {
@@ -20,15 +23,24 @@ pub fn tree_dissolve_update_system(world: &mut World, delta: f32)
     }
 }
 
-pub fn tree_occlusion_system(world: &mut World)
+pub fn tree_occlusion_system(
+    player_tags: &Storage<()>,
+    transforms: &Storage<Transform>,
+    cameras: &Storage<CameraComponent>,
+    tree_instances: &mut Storage<TreeInstancesComponent>,
+)
 {
-    let player_entity = world.player_tags.all().first().copied();
+    let player_entity = player_tags.all().first().copied();
-    let player_pos = player_entity.and_then(|e| world.transforms.get(e).map(|t| t.position));
+    let player_pos = player_entity.and_then(|e| transforms.get(e).map(|t| t.position));
 
     if let Some(player_pos) = player_pos
     {
-        let camera_entity = world.active_camera().map(|(e, _)| e);
+        let camera_entity = cameras
-        let camera_pos = camera_entity.and_then(|e| world.transforms.get(e).map(|t| t.position));
+            .components
+            .iter()
+            .find(|(_, cam)| cam.is_active)
+            .map(|(e, _)| *e);
+        let camera_pos = camera_entity.and_then(|e| transforms.get(e).map(|t| t.position));
 
         if let Some(camera_pos) = camera_pos
         {
@@ -43,9 +55,9 @@ pub fn tree_occlusion_system(world: &mut World)
             let to_player_normalized = to_player.normalize();
             let occlusion_radius = 10.0;
 
-            for tree_entity in world.tree_instances.all()
+            for tree_entity in tree_instances.all()
             {
-                if let Some(tree_instances) = world.tree_instances.get_mut(tree_entity)
+                if let Some(tree_instances) = tree_instances.get_mut(tree_entity)
                 {
                     for (idx, instance) in tree_instances.instances.iter().enumerate()
                     {
@@ -81,11 +93,11 @@ pub fn tree_occlusion_system(world: &mut World)
     }
 }
 
-pub fn tree_instance_buffer_update_system(world: &mut World)
+pub fn tree_instance_buffer_update_system(tree_instances: &Storage<TreeInstancesComponent>)
 {
-    for entity in world.tree_instances.all()
+    for entity in tree_instances.all()
     {
-        if let Some(tree_instances) = world.tree_instances.get(entity)
+        if let Some(tree_instances) = tree_instances.get(entity)
         {
             let instance_data_vec: Vec<InstanceRaw> = tree_instances
                 .instances

src/systems/trigger.rs

@@ -1,41 +1,47 @@
 use glam::Vec3;
 
 use crate::components::trigger::{
-    TriggerEvent, TriggerEventKind, TriggerFilter, TriggerShape, TriggerState,
+    TriggerComponent, TriggerEvent, TriggerEventKind, TriggerFilter, TriggerShape, TriggerState,
 };
 use crate::entity::EntityHandle;
-use crate::world::World;
+use crate::utility::transform::Transform;
+use crate::world::Storage;
 
-pub fn trigger_system(world: &mut World)
+pub fn trigger_system(
+    trigger_events: &mut Vec<TriggerEvent>,
+    triggers: &mut Storage<TriggerComponent>,
+    transforms: &Storage<Transform>,
+    player_tags: &Storage<()>,
+)
 {
-    world.trigger_events.clear();
+    trigger_events.clear();
 
-    let trigger_entities: Vec<EntityHandle> = world.triggers.all();
+    let trigger_entities: Vec<EntityHandle> = triggers.all();
     let mut pending_events: Vec<TriggerEvent> = Vec::new();
 
     for trigger_entity in trigger_entities
     {
-        let trigger_pos = match world.transforms.get(trigger_entity)
+        let trigger_pos = match transforms.get(trigger_entity)
         {
             Some(t) => t.position,
             None => continue,
         };
 
-        let candidate_entities: Vec<EntityHandle> = match world.triggers.get(trigger_entity)
+        let candidate_entities: Vec<EntityHandle> = match triggers.get(trigger_entity)
         {
             Some(trigger) => match &trigger.filter
             {
-                TriggerFilter::Player => world.player_tags.all(),
+                TriggerFilter::Player => player_tags.all(),
             },
             None => continue,
         };
 
         let activator_positions: Vec<(EntityHandle, Vec3)> = candidate_entities
             .into_iter()
-            .filter_map(|e| world.transforms.get(e).map(|t| (e, t.position)))
+            .filter_map(|e| transforms.get(e).map(|t| (e, t.position)))
             .collect();
 
-        let overlapping = match world.triggers.get(trigger_entity)
+        let overlapping = match triggers.get(trigger_entity)
         {
             Some(trigger) => activator_positions
                 .iter()
@@ -48,7 +54,7 @@ pub fn trigger_system(world: &mut World)
 
         let first_activator = activator_positions.first().map(|(e, _)| *e);
 
-        if let Some(trigger) = world.triggers.get_mut(trigger_entity)
+        if let Some(trigger) = triggers.get_mut(trigger_entity)
         {
             match (&trigger.state, overlapping)
             {
@@ -82,5 +88,5 @@ pub fn trigger_system(world: &mut World)
         }
     }
 
-    world.trigger_events.extend(pending_events);
+    trigger_events.extend(pending_events);
 }