Fix retina DPI blur and add pixel_density API.

Author: tychedelia

crates/processing_glfw/src/lib.rs

@@ -177,6 +177,11 @@ impl GlfwContext {
         true
     }
 
+    pub fn content_scale(&self) -> f32 {
+        let (s, _) = self.window.get_content_scale();
+        s
+    }
+
     fn sync_cursor(&mut self, surface: Entity) {
         use bevy::window::CursorGrabMode;
 

crates/processing_pyo3/src/graphics.rs

@@ -146,6 +146,19 @@ impl Surface {
             None => true, // no-op, offscreen surfaces never close
         }
     }
+
+    #[getter]
+    pub fn display_density(&self) -> PyResult<f32> {
+        match &self.glfw_ctx {
+            Some(ctx) => Ok(ctx.content_scale()),
+            None => Ok(1.0),
+        }
+    }
+
+    pub fn set_pixel_density(&self, density: f32) -> PyResult<()> {
+        surface_set_pixel_density(self.entity, density)
+            .map_err(|e| PyRuntimeError::new_err(format!("{e}")))
+    }
 }
 
 impl Drop for Surface {

crates/processing_pyo3/src/lib.rs

@@ -1432,4 +1432,18 @@ mod mewnala {
     fn key_just_pressed(key_code: u32) -> PyResult<bool> {
         input::key_just_pressed(key_code)
     }
+
+    #[pyfunction]
+    #[pyo3(pass_module)]
+    fn pixel_density(module: &Bound<'_, PyModule>, density: f32) -> PyResult<()> {
+        graphics!(module).surface.set_pixel_density(density)
+    }
+
+    #[pyfunction]
+    #[pyo3(pass_module)]
+    fn display_density(module: &Bound<'_, PyModule>) -> PyResult<f32> {
+        let graphics =
+            get_graphics(module)?.ok_or_else(|| PyRuntimeError::new_err("call size() first"))?;
+        graphics.surface.display_density()
+    }
 }

crates/processing_render/src/graphics.rs

@@ -40,7 +40,8 @@ pub struct GraphicsPlugin;
 
 impl Plugin for GraphicsPlugin {
     fn build(&self, app: &mut App) {
-        app.init_resource::<RenderLayersManager>();
+        app.init_resource::<RenderLayersManager>()
+            .add_systems(PostUpdate, sync_to_surface);
     }
 }
 
@@ -149,14 +150,26 @@ pub fn create(
     mut commands: Commands,
     mut layer_manager: ResMut<RenderLayersManager>,
     p_images: Query<&Image, With<Surface>>,
+    windows: Query<&Window, With<Surface>>,
     render_device: Res<RenderDevice>,
 ) -> Result<Entity> {
     // find the surface entity, if it is an image, we will render to that image
     // otherwise we will render to the window
-    let target = match p_images.get(surface_entity) {
-        Ok(p_image) => RenderTarget::Image(ImageRenderTarget::from(p_image.handle.clone())),
+    let (target, physical_width, physical_height) = match p_images.get(surface_entity) {
+        Ok(p_image) => (
+            RenderTarget::Image(ImageRenderTarget::from(p_image.handle.clone())),
+            p_image.size.width,
+            p_image.size.height,
+        ),
         Err(QueryEntityError::QueryDoesNotMatch(..)) => {
-            RenderTarget::Window(WindowRef::Entity(surface_entity))
+            let window = windows
+                .get(surface_entity)
+                .map_err(|_| ProcessingError::SurfaceNotFound)?;
+            (
+                RenderTarget::Window(WindowRef::Entity(surface_entity)),
+                window.resolution.physical_width(),
+                window.resolution.physical_height(),
+            )
         }
         Err(_) => return Err(ProcessingError::SurfaceNotFound),
     };
@@ -165,14 +178,14 @@ pub fn create(
     let render_layer = layer_manager.allocate();
 
     let size = Extent3d {
-        width,
-        height,
+        width: physical_width,
+        height: physical_height,
         depth_or_array_layers: 1,
     };
     let readback_buffer = create_readback_buffer(
         &render_device,
-        width,
-        height,
+        physical_width,
+        physical_height,
         texture_format,
         "Graphics Readback Buffer",
     )
@@ -241,6 +254,39 @@ pub fn resize(
     }
 }
 
+pub fn sync_to_surface(
+    mut graphics_query: Query<(&mut Graphics, &RenderTarget)>,
+    windows: Query<&Window, (With<Surface>, Changed<Window>)>,
+    render_device: Res<RenderDevice>,
+) {
+    for (mut graphics, target) in graphics_query.iter_mut() {
+        let RenderTarget::Window(WindowRef::Entity(surface_entity)) = *target else {
+            continue;
+        };
+        let Ok(window) = windows.get(surface_entity) else {
+            continue;
+        };
+        let physical_w = window.resolution.physical_width();
+        let physical_h = window.resolution.physical_height();
+        if graphics.size.width == physical_w && graphics.size.height == physical_h {
+            continue;
+        }
+        graphics.size = Extent3d {
+            width: physical_w,
+            height: physical_h,
+            depth_or_array_layers: 1,
+        };
+        graphics.readback_buffer = create_readback_buffer(
+            &render_device,
+            physical_w,
+            physical_h,
+            graphics.texture_format,
+            "Graphics Readback Buffer",
+        )
+        .expect("Failed to reallocate readback buffer");
+    }
+}
+
 pub fn mode_3d(
     In(entity): In<Entity>,
     mut projections: Query<&mut Projection>,

crates/processing_render/src/lib.rs

@@ -249,6 +249,14 @@ pub fn surface_resize(graphics_entity: Entity, width: u32, height: u32) -> error
     })
 }
 
+pub fn surface_set_pixel_density(entity: Entity, density: f32) -> error::Result<()> {
+    app_mut(|app| {
+        app.world_mut()
+            .run_system_cached_with(surface::set_pixel_density, (entity, density))
+            .unwrap()
+    })
+}
+
 /// Create a new graphics surface for rendering.
 pub fn graphics_create(
     surface_entity: Entity,

crates/processing_render/src/surface.rs

@@ -94,10 +94,13 @@ fn spawn_surface(
     let window_wrapper = WindowWrapper::new(glfw_window);
     let handle_wrapper = RawHandleWrapper::new(&window_wrapper)?;
 
+    let physical_width = (width as f32 * scale_factor) as u32;
+    let physical_height = (height as f32 * scale_factor) as u32;
+
     Ok(commands
         .spawn((
             Window {
-                resolution: WindowResolution::new(width, height)
+                resolution: WindowResolution::new(physical_width, physical_height)
                     .with_scale_factor_override(scale_factor),
                 ..default()
             },
@@ -362,8 +365,28 @@ pub fn resize(
     mut windows: Query<&mut Window>,
 ) -> Result<()> {
     if let Ok(mut window) = windows.get_mut(window_entity) {
-        window.resolution.set_physical_resolution(width, height);
+        let scale = window.resolution.scale_factor();
+        let physical_w = (width as f32 * scale) as u32;
+        let physical_h = (height as f32 * scale) as u32;
+        window.resolution.set_physical_resolution(physical_w, physical_h);
+        Ok(())
+    } else {
+        Err(error::ProcessingError::SurfaceNotFound)
+    }
+}
 
+pub fn set_pixel_density(
+    In((window_entity, density)): In<(Entity, f32)>,
+    mut windows: Query<&mut Window>,
+) -> Result<()> {
+    if let Ok(mut window) = windows.get_mut(window_entity) {
+        let logical_w = window.resolution.width();
+        let logical_h = window.resolution.height();
+        window.resolution.set_scale_factor_override(Some(density));
+        window.resolution.set_physical_resolution(
+            (logical_w * density) as u32,
+            (logical_h * density) as u32,
+        );
         Ok(())
     } else {
         Err(error::ProcessingError::SurfaceNotFound)