Apply resizing delay patch gfx-rs#6107 (comment)

Author: polina4096

wgpu-hal/src/metal/surface.rs

@@ -4,24 +4,63 @@ use alloc::borrow::ToOwned as _;
 use core::mem::ManuallyDrop;
 use core::ptr::NonNull;
 use std::thread;
+use std::{borrow::ToOwned as _, sync::Once};
 
 use core_graphics_types::{
     base::CGFloat,
     geometry::{CGRect, CGSize},
 };
 use metal::{foreign_types::ForeignType, MTLTextureType};
+use objc::declare::ClassDecl;
+use objc::runtime::Sel;
 use objc::{
     class, msg_send,
     rc::{autoreleasepool, StrongPtr},
-    runtime::{Object, BOOL, NO, YES},
+    runtime::{Class, Object, BOOL, NO, YES},
     sel, sel_impl,
 };
 use parking_lot::{Mutex, RwLock};
 
-use crate::metal::layer_observer::new_observer_layer;
-
 #[link(name = "QuartzCore", kind = "framework")]
-extern "C" {}
+extern "C" {
+    #[allow(non_upper_case_globals)]
+    static kCAGravityResize: *mut Object;
+}
+
+extern "C" fn layer_should_inherit_contents_scale_from_window(
+    _: &Class,
+    _: Sel,
+    _layer: *mut Object,
+    _new_scale: CGFloat,
+    _from_window: *mut Object,
+) -> BOOL {
+    YES
+}
+
+static CAML_DELEGATE_REGISTER: Once = Once::new();
+
+#[derive(Debug)]
+pub struct HalManagedMetalLayerDelegate(&'static Class);
+
+impl HalManagedMetalLayerDelegate {
+    pub fn new() -> Self {
+        let class_name = format!("HalManagedMetalLayerDelegate@{:p}", &CAML_DELEGATE_REGISTER);
+
+        CAML_DELEGATE_REGISTER.call_once(|| {
+            type Fun = extern "C" fn(&Class, Sel, *mut Object, CGFloat, *mut Object) -> BOOL;
+            let mut decl = ClassDecl::new(&class_name, class!(NSObject)).unwrap();
+            unsafe {
+                // <https://developer.apple.com/documentation/appkit/nsviewlayercontentscaledelegate/3005294-layer?language=objc>
+                decl.add_class_method::<Fun>(
+                    sel!(layer:shouldInheritContentsScale:fromWindow:),
+                    layer_should_inherit_contents_scale_from_window,
+                );
+            }
+            decl.register();
+        });
+        Self(Class::get(&class_name).unwrap())
+    }
+}
 
 impl super::Surface {
     fn new(layer: metal::MetalLayer) -> Self {
@@ -98,14 +137,58 @@ impl super::Surface {
             // they expect us to do.
             unsafe { StrongPtr::retain(root_layer) }
         } else {
-            // The view does not have a `CAMetalLayer` as the root layer (this
-            // is the default for most views).
+            // Create a new sublayer.
+            let new_layer: *mut Object = msg_send![class!(CAMetalLayer), new];
+            let () = msg_send![view.as_ptr(), setLayer: new_layer];
+
+            #[cfg(target_os = "macos")]
+            if false {
+                // Automatically resize the sublayer's frame to match the
+                // superlayer's bounds.
+                //
+                // Note that there is a somewhat hidden design decision in this:
+                // We define the `width` and `height` in `configure` to control
+                // the `drawableSize` of the layer, while `bounds` and `frame` are
+                // outside of the user's direct control - instead, though, they
+                // can control the size of the view (or root layer), and get the
+                // desired effect that way.
+                //
+                // We _could_ also let `configure` set the `bounds` size, however
+                // that would be inconsistent with using the root layer directly
+                // (as we may do, see above).
+                let width_sizable = 1 << 1; // kCALayerWidthSizable
+                let height_sizable = 1 << 4; // kCALayerHeightSizable
+                let mask: std::ffi::c_uint = width_sizable | height_sizable;
+                let () = msg_send![new_layer, setAutoresizingMask: mask];
+            }
+
+            // Specify the relative size that the auto resizing mask above
+            // will keep (i.e. tell it to fill out its superlayer).
+            let frame: CGRect = msg_send![root_layer, bounds];
+            let () = msg_send![new_layer, setFrame: frame];
+
+            // The gravity to use when the layer's `drawableSize` isn't the
+            // same as the bounds rectangle.
             //
-            // This case is trickier! We cannot use the existing layer with
-            // Metal, so we must do something else. There are a few options,
-            // we do the same as outlined in:
-            // https://docs.rs/raw-window-metal/1.1.0/raw_window_metal/#reasoning-behind-creating-a-sublayer
-            unsafe { new_observer_layer(root_layer) }
+            // The desired content gravity is `kCAGravityResize`, because it
+            // masks / alleviates issues with resizing when
+            // `present_with_transaction` is disabled, and behaves better when
+            // moving the window between monitors.
+            //
+            // Unfortunately, it also makes it harder to see changes to
+            // `width` and `height` in `configure`. When debugging resize
+            // issues, swap this for `kCAGravityTopLeft` instead.
+            let _: () = msg_send![new_layer, setContentsGravity: unsafe { kCAGravityResize }];
+
+            // Set initial scale factor of the layer. This is kept in sync by
+            // `configure` (on UIKit), and the delegate below (on AppKit).
+            let scale_factor: CGFloat = msg_send![root_layer, contentsScale];
+            let () = msg_send![new_layer, setContentsScale: scale_factor];
+
+            let delegate = HalManagedMetalLayerDelegate::new();
+            let () = msg_send![new_layer, setDelegate: delegate.0];
+
+            unsafe { StrongPtr::new(new_layer) }
         }
     }