fix panning

Yatekii · Yatekii · commit ffe81e6df0d6 · 2025-07-13T08:42:46.000+02:00
diff --git a/src/bin/app_state.rs b/src/bin/app_state.rs
@@ -40,10 +40,10 @@ impl AppState {
                 .expect("Unable to load the style file. Please consult the log."),
             screen: Screen::new(
                 center,
-                size.width,
-                size.height,
-                CONFIG.renderer.tile_size,
-                hidpi_factor,
+                size.width as f32,
+                size.height as f32,
+                CONFIG.renderer.tile_size as f32,
+                hidpi_factor as f32,
             ),
             zoom,
             hovered_objects: Arc::new(Mutex::new(Vec::new())),
@@ -216,7 +216,7 @@ impl AppState {
         self.screen.center = tile_to_world_space(&tile_coordinate);
     }
 
-    pub(crate) fn scale_factor_updated(&mut self, scale_factor: f64) {
+    pub(crate) fn scale_factor_updated(&mut self, scale_factor: f32) {
         self.screen = Screen::new(
             self.screen.center,
             self.screen.width,
diff --git a/src/bin/drawing/painter.rs b/src/bin/drawing/painter.rs
@@ -428,7 +428,7 @@ impl Painter {
         let mut i = 0;
         for vt in visible_tiles {
             let extent = vt.extent() as f32;
-            let matrix = screen.tile_to_global_space(z, &vt.tile_id());
+            let matrix = screen.tile_to_screen(z, &vt.tile_id());
             for float in matrix.as_slice() {
                 data[i] = *float;
                 i += 1;
@@ -741,9 +741,7 @@ impl Painter {
                     ) / 2.0;
 
                     for (i, tile_id) in app_state.visible_tiles().iter().enumerate() {
-                        let matrix = app_state
-                            .screen
-                            .tile_to_global_space(app_state.zoom, tile_id);
+                        let matrix = app_state.screen.tile_to_screen(app_state.zoom, tile_id);
                         let start = (matrix * vec).xy() + vec2(1.0, 1.0);
                         let s = vec2(
                             (start.x * screen_dimensions.x)
@@ -755,7 +753,7 @@ impl Painter {
                                 .max(0.0)
                                 .min(screen_dimensions.y * 2.0),
                         );
-                        let matrix = app_state.screen.tile_to_global_space(
+                        let matrix = app_state.screen.tile_to_screen(
                             app_state.zoom,
                             &(*tile_id + TileId::new(tile_id.z, 1, 1)),
                         );
diff --git a/src/bin/drawing/ui/mod.rs b/src/bin/drawing/ui/mod.rs
@@ -2,7 +2,6 @@ pub mod state;
 pub mod views;
 pub mod widgets;
 
-use std::fmt::format;
 use std::sync::Arc;
 
 use egui::color_picker::Alpha;
diff --git a/src/bin/main.rs b/src/bin/main.rs
@@ -7,7 +7,11 @@ use std::sync::Arc;
 
 use crate::config::CONFIG;
 use clap::Parser;
-use lyon::math::vector;
+use lyon::{
+    geom::euclid::{self, point2},
+    math::vector,
+};
+use nalgebra_glm::{vec2, vec3, vec4, Mat4};
 use osm::math::{deg2num, tile_to_world_space, TileId};
 use winit::{
     application::ApplicationHandler,
@@ -83,8 +87,8 @@ fn main() {
         .hud
         .platform
         .handle_event(&winit::event::WindowEvent::Resized(PhysicalSize::new(
-            screen.width,
-            screen.height,
+            screen.width as u32,
+            screen.height as u32,
         )));
 
     event_loop.run_app(&mut application).unwrap();
@@ -115,13 +119,15 @@ impl ApplicationHandler for Application {
         match event {
             WindowEvent::Destroyed => event_loop.exit(),
             WindowEvent::Resized(physical_size) => {
-                self.app_state.screen.width = physical_size.width.min(8192);
-                self.app_state.screen.height = physical_size.height.min(8192);
-                self.painter
-                    .resize(self.app_state.screen.width, self.app_state.screen.height);
+                self.app_state.screen.width = physical_size.width.min(8192) as f32;
+                self.app_state.screen.height = physical_size.height.min(8192) as f32;
+                self.painter.resize(
+                    self.app_state.screen.width as u32,
+                    self.app_state.screen.height as u32,
+                );
             }
             WindowEvent::ScaleFactorChanged { scale_factor, .. } => {
-                self.app_state.scale_factor_updated(scale_factor)
+                self.app_state.scale_factor_updated(scale_factor as f32)
             }
             WindowEvent::KeyboardInput {
                 event:
@@ -174,30 +180,25 @@ impl ApplicationHandler for Application {
                 }
             }
             WindowEvent::CursorMoved { position, .. } => {
-                let logical_position = position.to_logical(self.painter.get_hidpi_factor());
-                let size = self.app_state.screen.tile_size() as f32;
-                let mut delta = vector(
-                    (logical_position.x - self.last_pos.x) as f32,
-                    (logical_position.y - self.last_pos.y) as f32,
-                );
-                let zoom_x = (self.app_state.screen.width as f32)
-                    / size
-                    / 2f32.powf(self.app_state.zoom)
-                    / size
-                    / 1.13;
-                let zoom_y = (self.app_state.screen.height as f32)
-                    / size
-                    / 2f32.powf(self.app_state.zoom)
-                    / size
-                    / 1.13;
-                delta.x *= zoom_x;
-                delta.y *= zoom_y;
+                let logical_position = position.to_logical(self.painter.get_hidpi_factor() / 2.0);
+
+                let screen_to_global = self.app_state.screen.screen_to_world(self.app_state.zoom);
+                let new_pos = screen_to_global
+                    * vec4(
+                        logical_position.x as f32,
+                        logical_position.y as f32,
+                        0.0,
+                        0.0,
+                    );
+                let old_pos = screen_to_global
+                    * vec4(self.last_pos.x as f32, self.last_pos.y as f32, 0.0, 0.0);
+                let delta_new = new_pos - old_pos;
 
                 self.last_pos = logical_position;
 
                 if !ui_event {
                     if self.mouse_down {
-                        self.app_state.screen.center -= delta;
+                        self.app_state.screen.center -= euclid::vec2(delta_new.x, delta_new.y);
                     }
 
                     self.app_state.update_hovered_objects((
@@ -210,8 +211,8 @@ impl ApplicationHandler for Application {
                 self.hud
                     .platform
                     .handle_event(&winit::event::WindowEvent::Resized(PhysicalSize::new(
-                        self.app_state.screen.width,
-                        self.app_state.screen.height,
+                        self.app_state.screen.width as u32,
+                        self.app_state.screen.height as u32,
                     )));
                 if !event_loop.exiting() {
                     self.painter.update_shader();
diff --git a/src/lib/interaction/collider.rs b/src/lib/interaction/collider.rs
@@ -15,6 +15,9 @@ use super::tile_collider::TileCollider;
 pub struct Collider {}
 
 impl Collider {
+    /// Get the hovered objects
+    ///
+    /// * point: The pointer in logical coordinates (divided by DPI ratio)
     pub fn get_hovered_objects(
         visible_tiles: &[VisibleTile],
         screen: &Screen,
@@ -30,11 +33,12 @@ impl Collider {
             objects,
         } in visible_tiles
         {
-            let matrix = screen.tile_to_global_space(zoom, tile_id);
+            let matrix = screen.tile_to_screen(zoom, tile_id);
             let matrix = nalgebra_glm::inverse(&matrix);
+            // The point in GPU coordinates.
             let screen_point = Point::new(
-                point.0 / (screen.width / 2) as f32 - 1.0,
-                point.1 / (screen.height / 2) as f32 - 1.0,
+                point.0 / (screen.width / 2f32) - 1.0,
+                point.1 / (screen.height / 2f32) - 1.0,
             );
             let global_point = matrix * Vector4::new(screen_point.x, screen_point.y, 0.0, 1.0);
             let tile_point = Point::new(global_point.x, global_point.y) * *extent;
diff --git a/src/lib/math/screen.rs b/src/lib/math/screen.rs
@@ -4,31 +4,31 @@ use nalgebra_glm as glm;
 #[derive(Debug, Clone)]
 pub struct Screen {
     pub center: Point,
-    pub width: u32,
-    pub height: u32,
-    tile_size: u32,
+    pub width: f32,
+    pub height: f32,
+    tile_size: f32,
 }
 
 impl Screen {
-    pub fn new(center: Point, width: u32, height: u32, tile_size: u32, hidpi_factor: f64) -> Self {
+    pub fn new(center: Point, width: f32, height: f32, tile_size: f32, hidpi_factor: f32) -> Self {
         Self {
             center,
             width,
             height,
-            tile_size: (tile_size as f64 * hidpi_factor) as u32,
+            tile_size: tile_size * hidpi_factor,
         }
     }
 
-    pub fn tile_size(&self) -> u32 {
+    pub fn tile_size(&self) -> f32 {
         self.tile_size
     }
 
     pub fn get_tile_boundaries_for_zoom_level(&self, z: f32, scale: u32) -> TileField {
         let z = z.min(14.0);
         let px_to_world =
-            self.width as f32 / self.tile_size() as f32 / 2.0 / 2f32.powi(z as i32) / scale as f32;
+            self.width as f32 / self.tile_size() / 2.0 / 2f32.powi(z as i32) / scale as f32;
         let py_to_world =
-            self.height as f32 / self.tile_size() as f32 / 2.0 / 2f32.powi(z as i32) / scale as f32;
+            self.height as f32 / self.tile_size() / 2.0 / 2f32.powi(z as i32) / scale as f32;
 
         let top_left: TileId =
             world_to_tile_space(&(self.center - vector(px_to_world, py_to_world)), z as u32).into();
@@ -37,18 +37,64 @@ impl Screen {
         TileField::new(top_left, bottom_right + TileId::new(z as u32, 1, 0))
     }
 
-    pub fn tile_to_global_space(&self, z: f32, coordinate: &TileId) -> glm::TMat4<f32> {
+    pub fn tile_to_screen(&self, z: f32, coordinate: &TileId) -> glm::TMat4<f32> {
         let zoom = 1.0 / 2f32.powi(coordinate.z as i32);
         let zoom = glm::scaling(&glm::vec3(zoom, zoom, 1.0));
         let pos = glm::translation(&glm::vec3(coordinate.x as f32, coordinate.y as f32, 0.0));
         self.global_to_screen(z) * zoom * pos
     }
 
     pub fn global_to_screen(&self, z: f32) -> glm::TMat4<f32> {
-        let zoom_x = 2.0f32.powf(z) / (self.width as f32 / 2.0) * self.tile_size() as f32;
-        let zoom_y = 2.0f32.powf(z) / (self.height as f32 / 2.0) * self.tile_size() as f32;
+        let zoom_x = 2.0f32.powf(z) / (self.width as f32 / 2.0) * self.tile_size();
+        let zoom_y = 2.0f32.powf(z) / (self.height as f32 / 2.0) * self.tile_size();
         let zoom = glm::scaling(&glm::vec3(zoom_x, zoom_y, 1.0));
         let position = glm::translation(&glm::vec3(-self.center.x, -self.center.y, 0.0));
         zoom * position
     }
+
+    pub fn screen_to_gpu(&self) -> glm::TMat4<f32> {
+        let scale = glm::vec3(1.0, 1.0, 1.0).component_div(&glm::vec3(
+            self.width / 2.0,
+            self.height / 2.0,
+            1.0,
+        ));
+        glm::scaling(&scale)
+    }
+
+    pub fn screen_to_world(&self, z: f32) -> glm::TMat4<f32> {
+        // TODO: make logical width instead of phyiscal.
+        glm::translation2d(&glm::vec2(dbg!(self.center.x), self.center.y))
+            * glm::scaling2d(&glm::vec2(
+                1.0 / 2.0 * f32::powf(2.0, -z) / self.tile_size(),
+                1.0 / 2.0 * f32::powf(2.0, -z) / self.tile_size(),
+            ));
+
+        let matrix = self.global_to_screen(z);
+        let screen_to_global = nalgebra_glm::inverse(&matrix);
+
+        let pixel_to_screen = glm::translation(&glm::vec3(-1.0, -1.0, 0.0))
+            * glm::scaling(&glm::vec3(
+                1.0 / (self.width / 2.0),
+                1.0 / (self.height / 2.0),
+                1.0,
+            ));
+
+        screen_to_global * pixel_to_screen
+    }
+
+    pub fn global_to_tile_space(&self, z: f32, coordinate: &TileId) -> glm::TMat4<f32> {
+        self.tile_to_screen(z, coordinate).try_inverse().unwrap()
+    }
+
+    // pub fn screen_to_global(&self, z: f32) -> glm::TMat4<f32> {
+    //     // self.global_to_screen(z).try_inverse().unwrap()
+    //     let zoom_x = 2.0f32.powf(z) / (self.width / 2.0) * self.tile_size() * 2.0;
+    //     let zoom_y = 2.0f32.powf(z) / (self.height / 2.0) * self.tile_size() * 2.0;
+    //     let zoom = glm::scaling(&glm::vec3(zoom_x, zoom_y, 1.0));
+    //     (zoom).try_inverse().unwrap()
+
+    //     glm::
+    // }
+
+    // screen (px distorted) -> screen (square normalized coordinates) -> world (square coordinates) -> mercator lat lon
 }
diff --git a/src/lib/math/tile_field.rs b/src/lib/math/tile_field.rs
@@ -81,7 +81,7 @@ impl<'a> Iterator for TileIterator<'a> {
 #[test]
 fn get_tile_boundaries_for_8_zoom() {
     use super::*;
-    let bb = Screen::new(point(47.607_372, 6.114297), 800, 800, 256, 1.0);
+    let bb = Screen::new(point(47.607_372, 6.114297), 800f32, 800f32, 256f32, 1.0);
     let tile_field = bb.get_tile_boundaries_for_zoom_level(8.0, 1);
 
     assert_eq!(tile_field.iter().count(), 20);
diff --git a/src/lib/vector_tile/tile.rs b/src/lib/vector_tile/tile.rs
@@ -470,7 +470,7 @@ impl Tile {
         screen: &'a Screen,
         z: f32,
     ) -> impl Iterator<Item = TextArea<'a>> {
-        let matrix = screen.tile_to_global_space(z, &self.tile_id());
+        let matrix = screen.tile_to_screen(z, &self.tile_id());
         self.text
             .iter()
             .zip(self.text_buffers.iter())
