ch

Author: arrxy

crates/processing_glfw/src/lib.rs

@@ -300,6 +300,19 @@ impl GlfwContext {
                 WindowEvent::Focus(focused) => {
                     input_set_focus(surface, focused).unwrap();
                 }
+                WindowEvent::Size(width, height) => {
+                    let scale = self.content_scale();
+                    let logical_w = ((width as f32) / scale).max(1.0) as i32;
+                    let logical_h = ((height as f32) / scale).max(1.0) as i32;
+                    if logical_w != width || logical_h != height {
+                        // processing_render::surface_resize(
+                        //     surface,
+                        //     logical_w as u32,
+                        //     logical_h as u32,
+                        // )
+                        // .unwrap();
+                    }
+                }
                 _ => {}
             }
         }

crates/processing_pyo3/src/lib.rs

@@ -34,6 +34,7 @@ use graphics::{
 };
 use material::Material;
 
+use processing_render::surface_logical_width;
 use pyo3::{
     BoundObject,
     exceptions::PyRuntimeError,
@@ -120,13 +121,14 @@ pub(crate) fn reset_tracked_globals() {
 fn sync_globals(module: &Bound<'_, PyModule>, globals: &Bound<'_, PyAny>) -> PyResult<()> {
     let graphics =
         get_graphics(module)?.ok_or_else(|| PyRuntimeError::new_err("call size() first"))?;
-    input::sync_globals(
-        globals,
-        graphics.surface.entity,
-        graphics.width,
-        graphics.height,
-    )?;
-    surface::sync_globals(globals, &graphics.surface, graphics.width, graphics.height)?;
+    // let width = ::processing::prelude::surface_logical_width(graphics.surface.entity)
+    //     .map_err(|e| PyRuntimeError::new_err(format!("{e}")))?;
+    // let height = ::processing::prelude::surface_logical_height(graphics.surface.entity)
+    //     .map_err(|e| PyRuntimeError::new_err(format!("{e}")))?;
+    let width = graphics.width;
+    let height = graphics.height;
+    input::sync_globals(globals, graphics.surface.entity, width, height)?;
+    surface::sync_globals(globals, &graphics.surface, width, height)?;
     time::sync_globals(globals)?;
     Ok(())
 }

crates/processing_render/src/graphics.rs

@@ -118,6 +118,8 @@ impl CameraProjection for ProcessingProjection {
         // this gets called with the render target's physical dimensions (i.e. accounting for
         // scale factor), but our projection is in logical pixel units
         // TODO: handle resizes?
+        // self.width = _width;
+        // self.height = _height;
     }
 
     fn far(&self) -> f32 {

crates/processing_render/src/lib.rs

@@ -1702,6 +1702,24 @@ pub fn surface_physical_height(entity: Entity) -> error::Result<u32> {
     })
 }
 
+pub fn surface_logical_width(entity: Entity) -> error::Result<u32> {
+    app_mut(|app| {
+        Ok(app
+            .world_mut()
+            .run_system_cached_with(surface::logical_width, entity)
+            .unwrap())
+    })
+}
+
+pub fn surface_logical_height(entity: Entity) -> error::Result<u32> {
+    app_mut(|app| {
+        Ok(app
+            .world_mut()
+            .run_system_cached_with(surface::logical_height, entity)
+            .unwrap())
+    })
+}
+
 pub fn monitor_list() -> error::Result<Vec<Entity>> {
     app_mut(|app| Ok(app.world_mut().run_system_cached(monitor::list).unwrap()))
 }

crates/processing_render/src/surface.rs

@@ -21,13 +21,14 @@
 use bevy::{
     app::{App, Plugin},
     asset::Assets,
+    camera::{CameraProjection, Projection, RenderTarget},
     ecs::query::QueryEntityError,
     math::{IRect, IVec2},
     prelude::{Commands, Component, Entity, In, Query, ResMut, Window, With, default},
     render::render_resource::{Extent3d, TextureFormat},
     window::{
         CompositeAlphaMode, Monitor, RawHandleWrapper, WindowLevel, WindowMode, WindowPosition,
-        WindowResolution, WindowWrapper,
+        WindowRef, WindowResolution, WindowWrapper,
     },
 };
 use raw_window_handle::{
@@ -39,7 +40,10 @@ use processing_core::error::{self, ProcessingError, Result};
 #[cfg(not(target_os = "windows"))]
 use std::ptr::NonNull;
 
-use crate::image::Image;
+use crate::{
+    graphics::{ProcessingProjection, SurfaceSize},
+    image::Image,
+};
 
 #[derive(Component, Debug, Clone)]
 pub struct Surface;
@@ -394,7 +398,19 @@ pub fn destroy(
 pub fn resize(
     In((window_entity, width, height)): In<(Entity, u32, u32)>,
     mut windows: Query<&mut Window>,
+    mut graphics_query: Query<(&RenderTarget, &mut SurfaceSize, &mut Projection)>,
 ) -> Result<()> {
+    let width = width.max(1);
+    let height = height.max(1);
+
+    // let Ok(window) = windows.get_mut(window_entity) else {
+    //     return Ok(());
+    // };
+    //
+    // if window.mode != WindowMode::Windowed {
+    //     return Ok(());
+    // }
+
     if let Ok(mut window) = windows.get_mut(window_entity) {
         let scale = window.resolution.scale_factor();
         let physical_w = (width as f32 * scale) as u32;
@@ -403,6 +419,17 @@ pub fn resize(
             .resolution
             .set_physical_resolution(physical_w, physical_h);
     }
+
+    // for (target, mut surface_size, mut projection) in graphics_query.iter_mut() {
+    //     if let RenderTarget::Window(WindowRef::Entity(surface)) = *target {
+    //         if surface == window_entity {
+    //             *surface_size = SurfaceSize(width, height);
+    //             if let Projection::Custom(ref mut custom) = *projection {
+    //                 custom.update(width as f32, height as f32);
+    //             }
+    //         }
+    //     }
+    // }
     Ok(())
 }
 
@@ -448,6 +475,20 @@ pub fn physical_height(In(entity): In<Entity>, query: Query<&Window>) -> u32 {
         .unwrap_or(0)
 }
 
+pub fn logical_width(In(entity): In<Entity>, query: Query<&Window>) -> u32 {
+    query
+        .get(entity)
+        .map(|w| w.resolution.width() as u32)
+        .unwrap_or(0)
+}
+
+pub fn logical_height(In(entity): In<Entity>, query: Query<&Window>) -> u32 {
+    query
+        .get(entity)
+        .map(|w| w.resolution.height() as u32)
+        .unwrap_or(0)
+}
+
 pub fn set_title(
     In((entity, title)): In<(Entity, String)>,
     mut windows: Query<&mut Window>,