Test.NativeLaunch: Implement a kinda clunky zoom/pan

- zoom middle mouse scroll
- pan: left shift + middle mouse button drag (same as blender)

Author: jmquigs

Test.NativeLaunch/src/main.rs

@@ -75,6 +75,7 @@ another is that its much easier to change that than a binary file.
 */
 
 use std::ptr::null_mut;
+use std::sync::Mutex;
 use std::{path::PathBuf, time::SystemTime};
 
 use glam::Vec3;
@@ -140,20 +141,80 @@ mod render;
 mod d3d11_utilfn;
 mod util;
 
-unsafe extern "system"
-fn wnd_proc(hwnd: HWND, msg: UINT, wparam: WPARAM, lparam: LPARAM) -> LRESULT {
+
+static WINEVENTS: Mutex<Vec<WinEvent>> = Mutex::new(vec![]);
+fn add_winevent(evt:WinEvent) {
+    {
+        match WINEVENTS.lock() {
+            Ok(mut lck) => {
+                lck.push(evt);
+            },
+            Err(e) => eprintln!("failed to lock winevents: {:?}", e)
+        }
+    }
+}
+
+
+enum WinEvent {
+    MouseWheel(i16),
+    MousePan(i16, i16),
+}
+
+fn get_x_lparam(lparam: LPARAM) -> i16 {
+    (lparam & 0xFFFF) as i16 
+}
+
+fn get_y_lparam(lparam: LPARAM) -> i16 {
+    ((lparam >> 16) & 0xFFFF) as i16
+}
+
+unsafe extern "system" fn wnd_proc(hwnd: HWND, msg: UINT, wparam: WPARAM, lparam: LPARAM) -> LRESULT {
     // println!("wnd proc: {:x}", msg);
 
+    static mut LAST_MOUSE_POS: (i16, i16) = (0, 0);
+    static mut MOUSE_PAN_ACTIVE: bool = false;
+
     match msg {
         WM_DESTROY => {
             //println!("destroy");
             PostQuitMessage(0);
             //println!("post quit message");
             0
-        },
-        _ => {
-            DefWindowProcW(hwnd, msg, wparam, lparam)
         }
+        // Handling the mouse wheel event
+        winapi::um::winuser::WM_MOUSEWHEEL => {
+            let delta = winapi::um::winuser::GET_WHEEL_DELTA_WPARAM(wparam) as i16;
+            add_winevent(WinEvent::MouseWheel(delta));
+            0
+        }
+        winapi::um::winuser::WM_MOUSEMOVE => {
+            if MOUSE_PAN_ACTIVE {
+                let x_pos = get_x_lparam(lparam);
+                let y_pos = get_y_lparam(lparam);
+
+                let delta_x = x_pos.saturating_sub(LAST_MOUSE_POS.0 as i16);
+                let delta_y = y_pos.saturating_sub(LAST_MOUSE_POS.1 as i16);
+
+                add_winevent(WinEvent::MousePan(delta_x as i16, delta_y as i16));
+                LAST_MOUSE_POS = (x_pos as i16, y_pos as i16);
+            }
+            0
+        }
+        winapi::um::winuser::WM_MBUTTONDOWN => {
+            if winapi::um::winuser::GetKeyState(winapi::um::winuser::VK_SHIFT) < 0 {
+                MOUSE_PAN_ACTIVE = true;
+                LAST_MOUSE_POS = (
+                    get_x_lparam(lparam),
+                    get_y_lparam(lparam),
+                );
+            }
+            0
+        }
+        winapi::um::winuser::WM_MBUTTONUP => {
+            MOUSE_PAN_ACTIVE = false;
+            0
+        }
+        _ => DefWindowProcW(hwnd, msg, wparam, lparam),
     }
 }
 
@@ -926,6 +987,8 @@ unsafe fn runapp() -> anyhow::Result<()> {
         let mut total_dip_calls = 0;
         let mut info_start = SystemTime::now();
         let mut removed_once = false;
+        let mut zoom: i16 = 0;
+        let (mut pan_x, mut pan_y): (i16, i16) = (0,0);
         while !done {
             if SystemTime::now().duration_since(info_start).expect("whatever").as_secs() >= 1 {
                 println!("dip calls: {}, prim/vert count: {:?}", dip_calls, (prim_count,vert_count));
@@ -965,9 +1028,35 @@ unsafe fn runapp() -> anyhow::Result<()> {
             if done {
                 break;
             }
+
             let now = SystemTime::now();
             let _elapsed = now.duration_since(start).expect("whatever").as_millis();
 
+            
+            {
+                match WINEVENTS.lock() {
+                    Ok(mut evts) => {
+                        for e in evts.iter() {
+                            match e {
+                                WinEvent::MouseWheel(delta) => {
+                                    zoom = zoom.saturating_add(*delta * 10);
+                                    //println!("zoom {}", zoom);
+                                },
+                                WinEvent::MousePan(x, y) => {
+                                    pan_x = pan_x.saturating_add( (- *x * 50) as i16 );
+                                    pan_y = pan_y.saturating_add( (- *y * 50) as i16 );
+                                    
+                                    //println!("pan: {pan_x},{pan_y}")
+                                }
+                            }
+                        }
+                        evts.clear();
+                    },
+                    Err(e) => eprintln!("failed to lock winevents: {:?}", e)
+                }
+            }
+            
+
             // if the sync interval in present below is > than zero this will slow down the dip rate to 
             // the something like the refresh rate of display or some safe value like 30/sec
             let mut do_present = true;
@@ -1006,7 +1095,7 @@ unsafe fn runapp() -> anyhow::Result<()> {
                         let rotation = Vec3::new(rx, ry, rz);
                         (rotation,origin)
                     } else {
-                        let origin = Vec3::new(0.0, 1.0, 0.0);
+                        let origin = Vec3::new(0.0, 2.0, 0.0);
                         let rz = 0.0;
                         let rotation = Vec3::new(rx, ry, rz);
                         (rotation,origin)
@@ -1021,6 +1110,8 @@ unsafe fn runapp() -> anyhow::Result<()> {
                     prepare_shader_constants(
                         context,
                         rend_data,
+                        zoom,
+                        (pan_x,pan_y),
                         origin,
                         eye,
                         rotation,

Test.NativeLaunch/src/render.rs

@@ -62,6 +62,8 @@ pub unsafe fn create_data(device:*mut ID3D11Device) -> anyhow::Result<RendData>
 /// - A 4x4 matrix (`Mat4`) representing the MVP transformation.
 
 pub fn generate_mvp_matrix(
+    zoom: i16,
+    pan: (i16,i16),
     origin: Vec3,
     eye: Vec3,
     rotation_radians: Vec3,
@@ -79,7 +81,14 @@ pub fn generate_mvp_matrix(
     );
 
 
-    let model = Mat4::from_rotation_translation(rotation, Vec3::ZERO);
+    let zoom_normalized = 1.0 + zoom as f32 / i16::MAX as f32;
+    let scale_factor = zoom_normalized * 2.0;
+    let scale_matrix = Mat4::from_scale(Vec3::splat(scale_factor));
+
+    let pan_x = pan.0 as f32 / i16::MAX as f32 * 2.0; // Range from -2.0 to 2.0
+    let pan_y = pan.1 as f32 / i16::MAX as f32 * 2.0; // Range from -2.0 to 2.0
+    let pan_translation = Vec3::new(pan_x, pan_y, 0.0);
+    let model = Mat4::from_rotation_translation(rotation, pan_translation) * scale_matrix;
 
     let col0 = model.x_axis.truncate(); // Vec3 from first column
     let col1 = model.y_axis.truncate(); // Vec3 from second column
@@ -104,6 +113,8 @@ pub fn generate_mvp_matrix(
 pub unsafe fn prepare_shader_constants(
     context: *mut ID3D11DeviceContext,
     shape_data:&RendData,
+    zoom: i16,
+    pan: (i16,i16),
     origin: Vec3,
     eye: Vec3,    
     rotation: Vec3,
@@ -115,7 +126,7 @@ pub unsafe fn prepare_shader_constants(
     has_tex0: bool,
 ) -> anyhow::Result<()> {
     // 1. Compute the MVP matrix
-    let (mvp, normal_mat) = generate_mvp_matrix(origin, eye, rotation, aspect_ratio, fov_y_radians, z_near, z_far);
+    let (mvp, normal_mat) = generate_mvp_matrix(zoom, pan, origin, eye, rotation, aspect_ratio, fov_y_radians, z_near, z_far);
 
     // 2. No transpose needed unless your shader uses 'row_major'
     // If needed, use: let mvp = mvp.transpose();