5 files changed, 40 insertions(+), 19 deletions(-)

M starkingdoms-client/src/lib.rs
M starkingdoms-client/src/native/mod.rs
M starkingdoms-client/src/rendering/mod.rs
M starkingdoms-client/src/rendering/renderer.rs
M starkingdoms-client/src/wasm/mod.rs

@@ 2,14 2,12 @@ use crate::ecs::{Camera, Position, Scale, SpriteBundle, SpriteTexture};
 use crate::input::MouseWheelEvent;
 use crate::rendering::ui::UiRenderable;
 use crate::rendering::App;
-use bevy_ecs::event::Events;
+use bevy_ecs::event::{EventReader, Events};
 use bevy_ecs::schedule::Schedule;
+use bevy_ecs::system::ResMut;
 use bevy_ecs::world::World;
 use egui::Context;
-use std::ops::Add;
-use std::time::Duration;
 use tracing::info;
-use web_time::Instant;
 use winit::event_loop::{ControlFlow, EventLoop};
 
 #[cfg(target_arch = "wasm32")]


@@ 53,6 51,7 @@ pub fn start() {
     let mut update_schedule = Schedule::default();
     // Add things to run every frame here
     // Caution: This will run once before there are things on screen
+    update_schedule.add_systems(zoom_camera_on_mouse_events);
 
     world.spawn(SpriteBundle {
         position: Position { x: 0.0, y: 0.0 },


@@ 72,9 71,30 @@ pub fn start() {
         .unwrap();
 }
 
+fn zoom_camera_on_mouse_events(mut events: EventReader<MouseWheelEvent>, mut camera: ResMut<Camera>) {
+    for event in events.read() {
+        let raw_delta = match event {
+            MouseWheelEvent::Line { y, .. } => *y,
+            MouseWheelEvent::Pixel { y, ..} => *y,
+        } as f32;
+
+        let delta = if raw_delta < 0.0 {
+            raw_delta * -0.9
+        } else {
+            raw_delta * 1.1
+        };
+
+        if delta < 0.0 {
+            camera.zoom *= 1.0 / delta;
+        } else {
+            camera.zoom *= delta;
+        }
+    }
+}
+
 pub struct Gui {}
 impl UiRenderable for Gui {
-    fn render(&mut self, ctx: &Context, world: &mut World) {
+    fn render(&mut self, ctx: &Context, _world: &mut World) {
         egui::Window::new("Main Menu")
             .resizable(false)
             .show(ctx, |ui| {

@@ 1,5 1,3 @@
-use wgpu::{Backends, Limits};
-
 /// --- IMPORTANT: THIS IS A DUAL TARGET CRATE ---
 /// THIS WILL ONLY EXECUTE ON NATIVE
 /// DO ONLY PLATFORM SPECIFIC INITIALIZATION HERE

@@ 5,7 5,8 @@ pub mod ui;
 
 use crate::input::MouseWheelEvent;
 use crate::rendering::renderer::RenderInitRes::{Initialized, NotReadyYet};
-use crate::rendering::renderer::{RenderInitRes, Renderer};
+#[allow(unused_imports)]
+use crate::rendering::renderer::{Renderer, RenderInitRes};
 use crate::rendering::ui::UiRenderable;
 use bevy_ecs::schedule::Schedule;
 use bevy_ecs::world::World;


@@ 13,12 14,12 @@ use std::ops::Add;
 use std::process::exit;
 use std::sync::Arc;
 use std::time::Duration;
-use tracing::{debug, error, info};
+use tracing::info;
 use web_time::Instant;
 use winit::application::ApplicationHandler;
 use winit::dpi::LogicalSize;
 use winit::event::{MouseScrollDelta, WindowEvent};
-use winit::event_loop::{ActiveEventLoop, ControlFlow, EventLoop};
+use winit::event_loop::{ActiveEventLoop, ControlFlow};
 use winit::window::{Window, WindowId};
 
 pub struct App<T: UiRenderable> {


@@ 61,7 62,7 @@ impl<T: UiRenderable + 'static> ApplicationHandler for App<T> {
             #[cfg(not(target_arch = "wasm32"))]
             {
                 let renderer = pollster::block_on(async move {
-                    Renderer::new(window.clone(), world, update_schedule, ui_renderable).await
+                    Renderer::try_init(window.clone(), world, update_schedule, ui_renderable).await
                 });
                 match renderer {
                     Initialized(r) => {


@@ 91,8 92,8 @@ impl<T: UiRenderable + 'static> ApplicationHandler for App<T> {
                 self.renderer_rx = Some(rx);
                 wasm_bindgen_futures::spawn_local(async move {
                     let renderer =
-                        Renderer::new(window.clone(), world, update_schedule, ui_renderable).await;
-                    tx.send(renderer.into()).unwrap();
+                        Renderer::try_init(window.clone(), world, update_schedule, ui_renderable).await;
+                    tx.send(renderer).unwrap();
                 });
             }
         }


@@ 101,7 102,7 @@ impl<T: UiRenderable + 'static> ApplicationHandler for App<T> {
     fn window_event(
         &mut self,
         event_loop: &ActiveEventLoop,
-        window_id: WindowId,
+        _window_id: WindowId,
         event: WindowEvent,
     ) {
         if event == WindowEvent::CloseRequested {


@@ 158,6 159,7 @@ impl<T: UiRenderable + 'static> ApplicationHandler for App<T> {
     }
 
     fn about_to_wait(&mut self, event_loop: &ActiveEventLoop) {
+        #[allow(unused_variables)]
         if let Some(window) = self.window.clone() {
             #[cfg(target_arch = "wasm32")]
             {


@@ 173,8 175,8 @@ impl<T: UiRenderable + 'static> ApplicationHandler for App<T> {
                                 let (tx, rx) = futures::channel::oneshot::channel();
                                 self.renderer_rx = Some(rx);
                                 wasm_bindgen_futures::spawn_local(async move {
-                                    let renderer = Renderer::new(window.clone(), w, u, t).await;
-                                    tx.send(renderer.into()).unwrap();
+                                    let renderer = Renderer::try_init(window.clone(), w, u, t).await;
+                                    tx.send(renderer).unwrap();
                                 });
                             }
                         }


@@ 194,7 196,7 @@ impl<T: UiRenderable + 'static> ApplicationHandler for App<T> {
                         let ui_renderable = self.ui_renderable.take().unwrap();
 
                         let renderer = pollster::block_on(async move {
-                            Renderer::new(window.clone(), world, update_schedule, ui_renderable)
+                            Renderer::try_init(window.clone(), world, update_schedule, ui_renderable)
                                 .await
                         });
 

@@ 23,6 23,7 @@ use wgpu::{
 use winit::dpi::{LogicalSize, PhysicalSize};
 use winit::window::Window;
 
+#[allow(unused_attributes, dead_code)]
 pub struct Renderer<T: UiRenderable> {
     pub last_frame_time: Instant,
 


@@ 55,6 56,7 @@ pub struct Renderer<T: UiRenderable> {
     pub logical_size: LogicalSize<u32>,
 }
 
+#[allow(clippy::large_enum_variant)]
 pub enum RenderInitRes<T: UiRenderable> {
     Initialized(Renderer<T>),
     NotReadyYet(World, Schedule, T),


@@ 69,7 71,7 @@ impl<T: UiRenderable> Debug for RenderInitRes<T> {
 }
 
 impl<T: UiRenderable> Renderer<T> {
-    pub async fn new(
+    pub async fn try_init(
         window: Arc<Window>,
         world: World,
         update_schedule: Schedule,

@@ 3,7 3,6 @@ use tracing_subscriber::fmt::format::Pretty;
 use tracing_subscriber::prelude::*;
 use tracing_web::{performance_layer, MakeWebConsoleWriter};
 use wasm_bindgen::prelude::wasm_bindgen;
-use wgpu::{Backends, Limits};
 
 /// --- IMPORTANT: THIS IS A DUAL TARGET CRATE ---
 /// THIS WILL ONLY EXECUTE ON WEBASSEMBLY