Switch to a single GPU context in Blade (#20853)

Closes #17005

Release Notes:

- Improved GPU context management: share a single context with multiple
surfaces.

### High Level

Blade got a proper support for Surface objects in
kvark/blade#203.
That was mainly motivated by Zed needing to draw multiple windows. With
the Surface API, Zed is now able to have the GPU context tied to the
"Platform" instead of "Window". Practically speaking, this means:
  - architecture more sound
  - faster to open/close windows
  - less surprises, more robust

### Concerns

1. Zed has been using a temporary workaround for the platform bug on
some Intel+Nvidia machines that makes us unable to present -
kvark/blade#144 . This workaround is no longer
available with the new architecture. I'm looking for ideas on how to
approach this better.
- we are now picking up the change in
kvark/blade#210, which allows forcing a specific
Device ID. This should allow Zed users to work around the issue. We
could help them to automate it, too.
2. ~~Metal-rs dependency is switched to
https://github.com/kvark/metal-rs/tree/blade, since upstream isn't
responsive in merging changes that are required for Blade. Hopefully,
temporary.~~
- ~~we can also hack around it by just transmuting the texture
references, since we know those are unchanged in the branch. That would
allow Blade to use it's own version of Metal, temporarily, if switching
metal-rs in the workspace is a concern.~~
- merged my metal-rs changes and updated Zed to use the upstream github
reference

---------

Co-authored-by: Mikayla Maki <mikayla@zed.dev>
Co-authored-by: Mikayla Maki <mikayla.c.maki@gmail.com>
Co-authored-by: Conrad Irwin <conrad.irwin@gmail.com>

Cargo.toml

@@ -355,9 +355,9 @@ async-watch = "0.3.1"
 async_zip = { version = "0.0.17", features = ["deflate", "deflate64"] }
 base64 = "0.22"
 bitflags = "2.6.0"
-blade-graphics = { git = "https://github.com/kvark/blade", rev = "e142a3a5e678eb6a13e642ad8401b1f3aa38e969" }
-blade-macros = { git = "https://github.com/kvark/blade", rev = "e142a3a5e678eb6a13e642ad8401b1f3aa38e969" }
-blade-util = { git = "https://github.com/kvark/blade", rev = "e142a3a5e678eb6a13e642ad8401b1f3aa38e969" }
+blade-graphics = { git = "https://github.com/kvark/blade", rev = "099555282605c7c4cca9e66a8f40148298347f80" }
+blade-macros = { git = "https://github.com/kvark/blade", rev = "099555282605c7c4cca9e66a8f40148298347f80" }
+blade-util = { git = "https://github.com/kvark/blade", rev = "099555282605c7c4cca9e66a8f40148298347f80" }
 blake3 = "1.5.3"
 bytes = "1.0"
 cargo_metadata = "0.19"
@@ -525,6 +525,12 @@ wasmtime-wasi = "24"
 which = "6.0.0"
 wit-component = "0.201"
 zstd = "0.11"
+# Custom metal-rs is only needed for "macos-blade" feature of GPUI
+#TODO: switch to crates once these are published:
+# - https://github.com/gfx-rs/metal-rs/pull/335
+# - https://github.com/gfx-rs/metal-rs/pull/336
+# - https://github.com/gfx-rs/metal-rs/pull/337
+metal = { git = "https://github.com/gfx-rs/metal-rs", rev = "ef768ff9d742ae6a0f4e83ddc8031264e7d460c4" }
 
 [workspace.dependencies.async-stripe]
 git = "https://github.com/zed-industries/async-stripe"

crates/gpui/Cargo.toml

@@ -136,8 +136,8 @@ font-kit = { git = "https://github.com/zed-industries/font-kit", rev = "40391b7"
 foreign-types = "0.5"
 log.workspace = true
 media.workspace = true
-metal = "0.29"
 objc = "0.2"
+metal.workspace = true
 
 [target.'cfg(any(target_os = "linux", target_os = "freebsd", target_os = "macos"))'.dependencies]
 pathfinder_geometry = "0.5"

crates/gpui/src/platform/blade.rs

@@ -1,5 +1,11 @@
+#[cfg(target_os = "macos")]
+mod apple_compat;
 mod blade_atlas;
+mod blade_context;
 mod blade_renderer;
 
+#[cfg(target_os = "macos")]
+pub(crate) use apple_compat::*;
 pub(crate) use blade_atlas::*;
+pub(crate) use blade_context::*;
 pub(crate) use blade_renderer::*;

crates/gpui/src/platform/blade/apple_compat.rs

@@ -0,0 +1,60 @@
+use super::{BladeContext, BladeRenderer, BladeSurfaceConfig};
+use blade_graphics as gpu;
+use std::{ffi::c_void, ptr::NonNull};
+
+#[derive(Clone)]
+pub struct Context {
+    inner: BladeContext,
+}
+impl Default for Context {
+    fn default() -> Self {
+        Self {
+            inner: BladeContext::new().unwrap(),
+        }
+    }
+}
+
+pub type Renderer = BladeRenderer;
+
+pub unsafe fn new_renderer(
+    context: Context,
+    _native_window: *mut c_void,
+    native_view: *mut c_void,
+    bounds: crate::Size<f32>,
+    transparent: bool,
+) -> Renderer {
+    use raw_window_handle as rwh;
+    struct RawWindow {
+        view: *mut c_void,
+    }
+
+    impl rwh::HasWindowHandle for RawWindow {
+        fn window_handle(&self) -> Result<rwh::WindowHandle, rwh::HandleError> {
+            let view = NonNull::new(self.view).unwrap();
+            let handle = rwh::AppKitWindowHandle::new(view);
+            Ok(unsafe { rwh::WindowHandle::borrow_raw(handle.into()) })
+        }
+    }
+    impl rwh::HasDisplayHandle for RawWindow {
+        fn display_handle(&self) -> Result<rwh::DisplayHandle, rwh::HandleError> {
+            let handle = rwh::AppKitDisplayHandle::new();
+            Ok(unsafe { rwh::DisplayHandle::borrow_raw(handle.into()) })
+        }
+    }
+
+    BladeRenderer::new(
+        &context.inner,
+        &RawWindow {
+            view: native_view as *mut _,
+        },
+        BladeSurfaceConfig {
+            size: gpu::Extent {
+                width: bounds.width as u32,
+                height: bounds.height as u32,
+                depth: 1,
+            },
+            transparent,
+        },
+    )
+    .unwrap()
+}

crates/gpui/src/platform/blade/blade_atlas.rs

@@ -268,7 +268,7 @@ impl BladeAtlasState {
     fn flush(&mut self, encoder: &mut gpu::CommandEncoder) {
         self.flush_initializations(encoder);
 
-        let mut transfers = encoder.transfer();
+        let mut transfers = encoder.transfer("atlas");
         for upload in self.uploads.drain(..) {
             let texture = &self.storage[upload.id];
             transfers.copy_buffer_to_texture(

crates/gpui/src/platform/blade/blade_context.rs

@@ -0,0 +1,24 @@
+use blade_graphics as gpu;
+use std::sync::Arc;
+
+#[cfg_attr(target_os = "macos", derive(Clone))]
+pub struct BladeContext {
+    pub(super) gpu: Arc<gpu::Context>,
+}
+
+impl BladeContext {
+    pub fn new() -> anyhow::Result<Self> {
+        let gpu = Arc::new(
+            unsafe {
+                gpu::Context::init(gpu::ContextDesc {
+                    presentation: true,
+                    validation: false,
+                    device_id: 0, //TODO: hook up to user settings
+                    ..Default::default()
+                })
+            }
+            .map_err(|e| anyhow::anyhow!("{:?}", e))?,
+        );
+        Ok(Self { gpu })
+    }
+}