Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
Remove `block` dependency from the tree (#65942)
Kirill Bulatov1808df02c0ff
diff --git a/Cargo.lock b/Cargo.lockindex 22969040a95..5ad009b1e59 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -2304,12 +2304,6 @@ dependencies = ["core2",]-[[package]]-name = "block"-version = "0.1.6"-source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "0d8c1fef690941d3e7788d328517591fecc684c084084702d6ff1641e993699a"-[[package]]name = "block-buffer"version = "0.10.4"@@ -3198,36 +3192,6 @@ dependencies = ["thiserror 2.0.17",]-[[package]]-name = "cocoa"-version = "0.25.0"-source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "f6140449f97a6e97f9511815c5632d84c8aacf8ac271ad77c559218161a1373c"-dependencies = [- "bitflags 1.3.2",- "block",- "cocoa-foundation",- "core-foundation 0.9.4",- "core-graphics 0.23.2",- "foreign-types 0.5.0",- "libc",- "objc",-]--[[package]]-name = "cocoa-foundation"-version = "0.1.2"-source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "8c6234cbb2e4c785b456c0644748b1ac416dd045799740356f8363dfe00c93f7"-dependencies = [- "bitflags 1.3.2",- "block",- "core-foundation 0.9.4",- "core-graphics-types 0.1.3",- "libc",- "objc",-]-[[package]]name = "codespan-reporting"version = "0.13.0"@@ -3788,19 +3752,6 @@ version = "0.8.7"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"-[[package]]-name = "core-graphics"-version = "0.23.2"-source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "c07782be35f9e1140080c6b96f0d44b739e2278479f64e02fdab4e32dfd8b081"-dependencies = [- "bitflags 1.3.2",- "core-foundation 0.9.4",- "core-graphics-types 0.1.3",- "foreign-types 0.5.0",- "libc",-]-[[package]]name = "core-graphics"version = "0.24.0"@@ -3809,35 +3760,11 @@ checksum = "fa95a34622365fa5bbf40b20b75dba8dfa8c94c734aea8ac9a5ca38af14316f1"dependencies = ["bitflags 2.13.1","core-foundation 0.10.0",- "core-graphics-types 0.2.0",+ "core-graphics-types","foreign-types 0.5.0","libc",]-[[package]]-name = "core-graphics-helmer-fork"-version = "0.24.0"-source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "32eb7c354ae9f6d437a6039099ce7ecd049337a8109b23d73e48e8ffba8e9cd5"-dependencies = [- "bitflags 2.13.1",- "core-foundation 0.9.4",- "core-graphics-types 0.1.3",- "foreign-types 0.5.0",- "libc",-]--[[package]]-name = "core-graphics-types"-version = "0.1.3"-source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "45390e6114f68f718cc7a830514a96f903cccd70d02a8f6d9f643ac4ba45afaf"-dependencies = [- "bitflags 1.3.2",- "core-foundation 0.9.4",- "libc",-]-[[package]]name = "core-graphics-types"version = "0.2.0"@@ -3865,7 +3792,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "a593227b66cbd4007b2a050dfdd9e1d1318311409c8d600dc82ba1b15ca9c130"dependencies = ["core-foundation 0.10.0",- "core-graphics 0.24.0",+ "core-graphics","foreign-types 0.5.0","libc",]@@ -7509,12 +7436,10 @@ dependencies = ["collections","core-foundation 0.10.0","core-foundation-sys",- "core-graphics 0.24.0",+ "core-graphics","core-text",- "derive_more","dispatch2","etagere",- "foreign-types 0.5.0","futures 0.3.34","gpui","gpui_util",@@ -7522,9 +7447,9 @@ dependencies = ["libc","log","mach2",- "metal","objc2 0.6.3","objc2-core-foundation",+ "objc2-core-graphics","objc2-core-text","objc2-core-video","objc2-foundation 0.3.2",@@ -7614,7 +7539,7 @@ dependencies = ["collections","core-foundation 0.10.0","core-foundation-sys",- "core-graphics 0.24.0",+ "core-graphics","ctor","dispatch2","foreign-types 0.5.0",@@ -10583,15 +10508,6 @@ version = "0.2.3"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "fc04a4c58212d57930a24bf47d3fa87485264a3a054e9c10e042eb373573ad3c"-[[package]]-name = "malloc_buf"-version = "0.0.6"-source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "62bb907fe88d54d8d9ce32a3cceab4218ed2f6b7d35617cafe9adf84e43919cb"-dependencies = [- "libc",-]-[[package]]name = "manatee"version = "0.8.0-alpha.5"@@ -10903,21 +10819,6 @@ dependencies = ["unicode-width 0.2.2",]-[[package]]-name = "metal"-version = "0.33.0"-source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "c7047791b5bc903b8cd963014b355f71dc9864a9a0b727057676c1dcae5cbc15"-dependencies = [- "bitflags 2.13.1",- "block",- "core-graphics-types 0.2.0",- "foreign-types 0.5.0",- "log",- "objc",- "paste",-]-[[package]]name = "micromap"version = "0.3.0"@@ -11686,27 +11587,6 @@ dependencies = ["url",]-[[package]]-name = "objc"-version = "0.2.7"-source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "915b1b472bc21c53464d6c8461c9d3af805ba1ef837e1cac254428f4a77177b1"-dependencies = [- "malloc_buf",- "objc_exception",-]--[[package]]-name = "objc-foundation"-version = "0.1.1"-source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "1add1b659e36c9607c7aab864a76c7a4c2760cd0cd2e120f3fb8b952c7e22bf9"-dependencies = [- "block",- "objc",- "objc_id",-]-[[package]]name = "objc-sys"version = "0.3.5"@@ -12063,24 +11943,6 @@ dependencies = ["objc2-foundation 0.3.2",]-[[package]]-name = "objc_exception"-version = "0.1.2"-source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "ad970fb455818ad6cba4c122ad012fae53ae8b4795f86378bce65e4f6bab2ca4"-dependencies = [- "cc",-]--[[package]]-name = "objc_id"-version = "0.1.1"-source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "c92d4ddb4bd7b50d730c215ff871754d0da6b2178849f8a2a2ab69712d0c073b"-dependencies = [- "objc",-]-[[package]]name = "object"version = "0.37.3"@@ -15942,29 +15804,6 @@ checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"name = "scratch"version = "1.0.9"-[[package]]-name = "screencapturekit"-version = "0.2.8"-source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "1a5eeeb57ac94960cfe5ff4c402be6585ae4c8d29a2cf41b276048c2e849d64e"-dependencies = [- "screencapturekit-sys",-]--[[package]]-name = "screencapturekit-sys"-version = "0.2.8"-source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "22411b57f7d49e7fe08025198813ee6fd65e1ee5eff4ebc7880c12c82bde4c60"-dependencies = [- "block",- "dispatch",- "objc",- "objc-foundation",- "objc_id",- "once_cell",-]-[[package]]name = "scroll"version = "0.12.0"@@ -17948,18 +17787,6 @@ version = "0.2.0"source = "registry+https://github.com/rust-lang/crates.io-index"checksum = "7b2093cf4c8eb1e67749a6762251bc9cd836b6fc171623bd0a9d324d37af2417"-[[package]]-name = "tao-core-video-sys"-version = "0.2.0"-source = "registry+https://github.com/rust-lang/crates.io-index"-checksum = "271450eb289cb4d8d0720c6ce70c72c8c858c93dd61fc625881616752e6b98f6"-dependencies = [- "cfg-if",- "core-foundation-sys",- "libc",- "objc",-]-[[package]]name = "target-lexicon"version = "0.13.5"@@ -22716,7 +22543,7 @@ dependencies = ["bitflags 2.13.1","byteorder","core-foundation 0.10.0",- "core-graphics 0.24.0",+ "core-graphics","core-text","dirs","dwrote",@@ -22784,18 +22611,12 @@ dependencies = [[[package]]name = "zed-scap"version = "0.0.8-zed"-source = "git+https://github.com/zed-industries/scap?rev=4afea48c3b002197176fb19cd0f9b180dd36eaac#4afea48c3b002197176fb19cd0f9b180dd36eaac"+source = "git+https://github.com/zed-industries/scap?rev=b5c86ec58dd4b6b7732bf6ac8be03d6b1f190a82#b5c86ec58dd4b6b7732bf6ac8be03d6b1f190a82"dependencies = ["anyhow",- "cocoa",- "core-graphics-helmer-fork","log",- "objc","rand 0.8.6",- "screencapturekit",- "screencapturekit-sys","sysinfo 0.31.4",- "tao-core-video-sys","windows 0.61.3","windows-capture","x11",diff --git a/Cargo.toml b/Cargo.tomlindex c545f6ad459..02cc09064f3 100644--- a/Cargo.toml+++ b/Cargo.toml@@ -692,7 +692,6 @@ mach2 = "0.6"markup5ever_rcdom = "0.39"mdbook = { version = "=0.4.40", default-features = false, features = ["search"] }merman = { version = "=0.8.0-alpha.5", default-features = false }-metal = "0.33"mime = "0.3.17"minidumper = "0.11"moka = { version = "0.12.10", features = ["sync"] }@@ -885,7 +884,7 @@ rustix = { version = "1.1", features = ["fs"] }rustls = "0.23.26"rustls-platform-verifier = "0.7"# WARNING: If you change this, you must also publish a new version of zed-scap to crates.io-scap = { git = "https://github.com/zed-industries/scap", rev = "4afea48c3b002197176fb19cd0f9b180dd36eaac", default-features = false, package = "zed-scap", version = "0.0.8-zed" }+scap = { git = "https://github.com/zed-industries/scap", rev = "b5c86ec58dd4b6b7732bf6ac8be03d6b1f190a82", default-features = false, package = "zed-scap", version = "0.0.8-zed" }schemars = { version = "1.0", default-features = false, features = ["std", "indexmap2"] }sea-orm = { version = "=1.1.10", default-features = false }seccompiler = "0.5"diff --git a/crates/gpui_apple/Cargo.toml b/crates/gpui_apple/Cargo.tomlindex 23142d504f5..488d1dcab15 100644--- a/crates/gpui_apple/Cargo.toml+++ b/crates/gpui_apple/Cargo.toml@@ -31,10 +31,8 @@ core-foundation.workspace = truecore-foundation-sys.workspace = truecore-graphics.workspace = truecore-text = { workspace = true, optional = true }-derive_more.workspace = true-dispatch2.workspace = true+dispatch2 = { workspace = true, features = ["block2"] }etagere.workspace = true-foreign-types.workspace = truefutures.workspace = true# WARNING: If you change this, you must also publish a new version of zed-font-kit to crates.iofont-kit = { workspace = true, optional = true, features = ["source"] }@@ -43,14 +41,34 @@ image.workspace = truelibc.workspace = truelog.workspace = truemach2.workspace = true-metal.workspace = trueobjc2.workspace = true-objc2-core-foundation = { workspace = true, features = ["std", "CFData", "CFDictionary", "CFString", "CFNumber", "CFBase"] }+objc2-core-foundation = { workspace = true, features = ["std", "CFData", "CFDictionary", "CFString", "CFNumber", "CFBase", "CFCGTypes"] }+objc2-core-graphics = { workspace = true, features = ["CGColorSpace"] }objc2-core-text = { workspace = true, optional = true }objc2-core-video = { workspace = true, features = ["CVPixelBuffer", "CVMetalTexture", "CVMetalTextureCache", "CVReturn", "objc2", "objc2-metal"] }-objc2-metal = { version = "0.3", default-features = false, features = ["MTLDevice", "MTLPixelFormat", "MTLTexture"] }+objc2-metal = { version = "0.3.2", default-features = false, features = [+ "std",+ "block2",+ "dispatch2",+ "MTLAllocation",+ "MTLBlitCommandEncoder",+ "MTLBuffer",+ "MTLCommandBuffer",+ "MTLCommandEncoder",+ "MTLCommandQueue",+ "MTLDevice",+ "MTLDrawable",+ "MTLLibrary",+ "MTLPixelFormat",+ "MTLRenderCommandEncoder",+ "MTLRenderPass",+ "MTLRenderPipeline",+ "MTLResource",+ "MTLTexture",+ "MTLTypes",+] }objc2-foundation = { workspace = true, features = ["NSThread", "NSNotification", "NSOperation", "NSProcessInfo", "block2"] }-objc2-quartz-core.workspace = true+objc2-quartz-core = { workspace = true, features = ["objc2-core-foundation", "objc2-core-graphics", "objc2-metal"] }objc2-security.workspace = trueparking_lot.workspace = truepathfinder_geometry = { workspace = true, optional = true }diff --git a/crates/gpui_apple/src/metal_atlas.rs b/crates/gpui_apple/src/metal_atlas.rsindex a635bc463a8..8bb14d60795 100644--- a/crates/gpui_apple/src/metal_atlas.rs+++ b/crates/gpui_apple/src/metal_atlas.rs@@ -1,23 +1,29 @@-use anyhow::{Context as _, Result};-use derive_more::{Deref, DerefMut};+use anyhow::{Context as _, Result, ensure};use etagere::BucketedAtlasAllocator;use gpui::{AtlasBackend, AtlasKey, AtlasState, AtlasTextureId, AtlasTextureKind, AtlasTextureList,AtlasTile, Bounds, DevicePixels, PlatformAtlas, Point, Size,};-use metal::Device;+use objc2::{rc::Retained, runtime::ProtocolObject};+use objc2_metal::{+ MTLDevice, MTLOrigin, MTLPixelFormat, MTLRegion, MTLSize, MTLStorageMode, MTLTexture,+ MTLTextureDescriptor, MTLTextureUsage,+};use parking_lot::Mutex;-use std::borrow::Cow;+use std::{borrow::Cow, ptr::NonNull};pub struct MetalAtlas(Mutex<AtlasState<MetalAtlasTextures>>);impl MetalAtlas {- pub(crate) fn new(device: Device, supports_shared_storage: bool) -> Self {+ pub(crate) fn new(+ device: Retained<ProtocolObject<dyn MTLDevice>>,+ supports_shared_storage: bool,+ ) -> Self {MetalAtlas(Mutex::new(AtlasState::new(MetalAtlasTextures {- device: AssertSend(device),+ device,supports_shared_storage,- monochrome_textures: Default::default(),- polychrome_textures: Default::default(),+ monochrome_textures: AtlasTextureList::default(),+ polychrome_textures: AtlasTextureList::default(),})))}@@ -25,13 +31,16 @@ impl MetalAtlas {/// has been removed. A scene can still reference such a texture when a/// cached view replays a paint from before the image was dropped, so/// callers must skip those sprites rather than assume the texture exists.- pub(crate) fn metal_texture(&self, id: AtlasTextureId) -> Option<metal::Texture> {+ pub(crate) fn metal_texture(+ &self,+ id: AtlasTextureId,+ ) -> Option<Retained<ProtocolObject<dyn MTLTexture>>> {Some(self.0.lock().backend.texture(id)?.metal_texture.clone())}}struct MetalAtlasTextures {- device: AssertSend<Device>,+ device: Retained<ProtocolObject<dyn MTLDevice>>,supports_shared_storage: bool,monochrome_textures: AtlasTextureList<MetalAtlasTexture>,polychrome_textures: AtlasTextureList<MetalAtlasTexture>,@@ -58,11 +67,12 @@ impl AtlasBackend for MetalAtlasTextures {size: Size<DevicePixels>,bytes: &[u8],) -> Result<AtlasTile> {- let tile = self.allocate(size, kind).context("failed to allocate")?;+ let upload = AtlasUpload::new(kind, size, bytes)?;+ let tile = self.allocate(size, kind)?;let texture = self.texture(tile.texture_id)- .context("allocated tile refers to a missing texture")?;- texture.upload(tile.bounds, bytes);+ .context("looking up allocated atlas texture")?;+ texture.upload(tile.bounds.origin, &upload)?;Ok(tile)}@@ -100,7 +110,7 @@ impl MetalAtlasTextures {&mut self,size: Size<DevicePixels>,texture_kind: AtlasTextureKind,- ) -> Option<AtlasTile> {+ ) -> Result<AtlasTile> {{let textures = match texture_kind {AtlasTextureKind::Monochrome => &mut self.monochrome_textures,@@ -113,19 +123,19 @@ impl MetalAtlasTextures {.rev().find_map(|texture| texture.allocate(size)){- return Some(tile);+ return Ok(tile);}}- let texture = self.push_texture(size, texture_kind);- texture.allocate(size)+ let texture = self.push_texture(size, texture_kind)?;+ texture.allocate(size).context("allocating atlas tile")}fn push_texture(&mut self,min_size: Size<DevicePixels>,kind: AtlasTextureKind,- ) -> &mut MetalAtlasTexture {+ ) -> Result<&mut MetalAtlasTexture> {const DEFAULT_ATLAS_SIZE: Size<DevicePixels> = Size {width: DevicePixels(1024),height: DevicePixels(1024),@@ -136,32 +146,38 @@ impl MetalAtlasTextures {height: DevicePixels(16384),};let size = min_size.min(&MAX_ATLAS_SIZE).max(&DEFAULT_ATLAS_SIZE);- let texture_descriptor = metal::TextureDescriptor::new();- texture_descriptor.set_width(size.width.into());- texture_descriptor.set_height(size.height.into());+ let texture_descriptor = MTLTextureDescriptor::new();+ // SAFETY: Both dimensions are clamped to the existing 1024..=16384 atlas size limits.+ unsafe {+ texture_descriptor.setWidth(size.width.0 as usize);+ texture_descriptor.setHeight(size.height.0 as usize);+ }let pixel_format;let usage;match kind {AtlasTextureKind::Monochrome => {- pixel_format = metal::MTLPixelFormat::A8Unorm;- usage = metal::MTLTextureUsage::ShaderRead;+ pixel_format = MTLPixelFormat::A8Unorm;+ usage = MTLTextureUsage::ShaderRead;}AtlasTextureKind::Polychrome => {- pixel_format = metal::MTLPixelFormat::BGRA8Unorm;- usage = metal::MTLTextureUsage::ShaderRead;+ pixel_format = MTLPixelFormat::BGRA8Unorm;+ usage = MTLTextureUsage::ShaderRead;}AtlasTextureKind::Subpixel => unreachable!(),}- texture_descriptor.set_pixel_format(pixel_format);- texture_descriptor.set_usage(usage);+ texture_descriptor.setPixelFormat(pixel_format);+ texture_descriptor.setUsage(usage);// Shared memory mode can be used only on Apple GPU families// https://developer.apple.com/documentation/metal/mtlresourceoptions/storagemodeshared- texture_descriptor.set_storage_mode(if self.supports_shared_storage {- metal::MTLStorageMode::Shared+ texture_descriptor.setStorageMode(if self.supports_shared_storage {+ MTLStorageMode::Shared} else {- metal::MTLStorageMode::Managed+ MTLStorageMode::Managed});- let metal_texture = self.device.new_texture(&texture_descriptor);+ let metal_texture = self+ .device+ .newTextureWithDescriptor(&texture_descriptor)+ .context("allocating atlas texture")?;let texture_list = match kind {AtlasTextureKind::Monochrome => &mut self.monochrome_textures,@@ -169,28 +185,23 @@ impl MetalAtlasTextures {AtlasTextureKind::Subpixel => unreachable!(),};- let index = texture_list.free_list.pop();+ let index = texture_list.free_list.pop().unwrap_or_else(|| {+ let index = texture_list.textures.len();+ texture_list.textures.push(None);+ index+ });let atlas_texture = MetalAtlasTexture {id: AtlasTextureId {- index: index.unwrap_or(texture_list.textures.len()) as u32,+ index: index as u32,kind,},allocator: etagere::BucketedAtlasAllocator::new(size_to_etagere(size)),- metal_texture: AssertSend(metal_texture),+ metal_texture,live_atlas_keys: 0,};- if let Some(ix) = index {- texture_list.textures[ix] = Some(atlas_texture);- texture_list.textures.get_mut(ix)- } else {- texture_list.textures.push(Some(atlas_texture));- texture_list.textures.last_mut()- }- .unwrap()- .as_mut()- .unwrap()+ Ok(texture_list.textures[index].insert(atlas_texture))}fn texture(&self, id: AtlasTextureId) -> Option<&MetalAtlasTexture> {@@ -206,7 +217,7 @@ impl MetalAtlasTextures {struct MetalAtlasTexture {id: AtlasTextureId,allocator: BucketedAtlasAllocator,- metal_texture: AssertSend<metal::Texture>,+ metal_texture: Retained<ProtocolObject<dyn MTLTexture>>,live_atlas_keys: u32,}@@ -226,28 +237,46 @@ impl MetalAtlasTexture {Some(tile)}- fn upload(&self, bounds: Bounds<DevicePixels>, bytes: &[u8]) {- let region = metal::MTLRegion::new_2d(- bounds.origin.x.into(),- bounds.origin.y.into(),- bounds.size.width.into(),- bounds.size.height.into(),+ fn upload(&self, origin: Point<DevicePixels>, upload: &AtlasUpload<'_>) -> Result<()> {+ ensure!(+ self.id.kind == upload.kind,+ "atlas upload kind does not match texture");- self.metal_texture.replace_region(- region,- 0,- bytes.as_ptr() as *const _,- bounds.size.width.to_bytes(self.bytes_per_pixel()) as u64,+ ensure!(+ origin.x.0 >= 0+ && origin.y.0 >= 0+ && (origin.x.0 as usize)+ .checked_add(upload.size.width.0 as usize)+ .is_some_and(|end| end <= self.metal_texture.width())+ && (origin.y.0 as usize)+ .checked_add(upload.size.height.0 as usize)+ .is_some_and(|end| end <= self.metal_texture.height()),+ "atlas upload is outside texture bounds");- }-- fn bytes_per_pixel(&self) -> u8 {- use metal::MTLPixelFormat::*;- match self.metal_texture.pixel_format() {- A8Unorm | R8Unorm => 1,- RGBA8Unorm | BGRA8Unorm => 4,- _ => unimplemented!(),+ let region = MTLRegion {+ origin: MTLOrigin {+ x: origin.x.0 as usize,+ y: origin.y.0 as usize,+ z: 0,+ },+ size: MTLSize {+ width: upload.size.width.0 as usize,+ height: upload.size.height.0 as usize,+ depth: 1,+ },+ };+ // SAFETY: Validated bytes cover every row of the checked region in this CPU-accessible texture.+ // The borrowed bytes remain live for the copy; GPU ordering is a separate caller requirement.+ unsafe {+ self.metal_texture+ .replaceRegion_mipmapLevel_withBytes_bytesPerRow(+ region,+ 0,+ NonNull::from(upload.bytes).cast(),+ upload.bytes_per_row,+ );}+ Ok(())}fn decrement_ref_count(&mut self) {@@ -259,6 +288,44 @@ impl MetalAtlasTexture {}}+struct AtlasUpload<'a> {+ kind: AtlasTextureKind,+ size: Size<DevicePixels>,+ bytes: &'a [u8],+ bytes_per_row: usize,+}++impl<'a> AtlasUpload<'a> {+ fn new(kind: AtlasTextureKind, size: Size<DevicePixels>, bytes: &'a [u8]) -> Result<Self> {+ ensure!(+ size.width.0 > 0 && size.height.0 > 0,+ "atlas dimensions must be positive"+ );+ let bytes_per_pixel = match kind {+ AtlasTextureKind::Monochrome => 1,+ AtlasTextureKind::Polychrome => 4,+ AtlasTextureKind::Subpixel => unreachable!(),+ };+ let bytes_per_row = (size.width.0 as usize)+ .checked_mul(bytes_per_pixel)+ .context("calculating atlas row byte count")?;+ let byte_count = bytes_per_row+ .checked_mul(size.height.0 as usize)+ .context("calculating atlas byte count")?;+ ensure!(+ bytes.len() >= byte_count,+ "atlas upload byte length is {}, expected at least {byte_count}",+ bytes.len()+ );+ Ok(Self {+ kind,+ size,+ bytes,+ bytes_per_row,+ })+ }+}+fn size_to_etagere(size: Size<DevicePixels>) -> etagere::Size {etagere::Size::new(size.width.into(), size.height.into())}@@ -270,39 +337,13 @@ fn point_from_etagere(value: etagere::Point) -> Point<DevicePixels> {}}-#[derive(Deref, DerefMut)]-struct AssertSend<T>(T);--unsafe impl<T> Send for AssertSend<T> {}-#[cfg(test)]mod tests {use super::*;- use gpui::PlatformAtlas;+ use gpui::{PlatformAtlas, point, size};+ use objc2_metal::{MTLCreateSystemDefaultDevice, MTLGPUFamily};use std::borrow::Cow;- fn create_atlas() -> Option<MetalAtlas> {- let device = metal::Device::system_default()?;- Some(MetalAtlas::new(device, true))- }-- fn make_image_key(image_id: usize, frame_index: usize) -> AtlasKey {- AtlasKey::Image(gpui::RenderImageParams {- image_id: gpui::ImageId(image_id),- frame_index,- })- }-- fn insert_tile(atlas: &MetalAtlas, key: AtlasKey, size: Size<DevicePixels>) -> AtlasTile {- atlas- .get_or_insert_with(key, &mut || {- let byte_count = (size.width.0 as usize) * (size.height.0 as usize) * 4;- Ok(Some((size, Cow::Owned(vec![0u8; byte_count]))))- })- .expect("allocation should succeed")- .expect("callback returns Some")- }-#[test]fn test_remove_clears_stale_keys_from_tiles_by_key() {let Some(atlas) = create_atlas() else {@@ -338,6 +379,7 @@ mod tests {// Re-inserting A must allocate a fresh tile on a new texture,// NOT return a stale tile referencing the deleted texture.let tile_a2 = insert_tile(&atlas, key_a, small);+ assert_eq!(tile_a2.texture_id, tile_a.texture_id);// The texture must actually exist — this would panic before the fix.assert!(atlas.metal_texture(tile_a2.texture_id).is_some());@@ -402,4 +444,129 @@ mod tests {let key = make_image_key(999, 0);atlas.remove(&key);}++ #[test]+ fn test_invalid_upload_does_not_allocate() {+ let Some(atlas) = create_atlas() else {+ return;+ };+ let mut state = atlas.0.lock();+ for (kind, short_bytes, short_error) in [+ (+ AtlasTextureKind::Monochrome,+ &[][..],+ "atlas upload byte length is 0, expected at least 1",+ ),+ (+ AtlasTextureKind::Polychrome,+ &[0][..],+ "atlas upload byte length is 1, expected at least 4",+ ),+ ] {+ for (width, height, bytes, expected_error) in [+ (1, 1, short_bytes, short_error),+ (0, 1, &[][..], "atlas dimensions must be positive"),+ (1, 0, &[][..], "atlas dimensions must be positive"),+ (i32::MIN, 1, &[][..], "atlas dimensions must be positive"),+ (1, i32::MIN, &[][..], "atlas dimensions must be positive"),+ ] {+ assert_eq!(+ state+ .backend+ .insert(kind, size(DevicePixels(width), DevicePixels(height)), bytes)+ .err()+ .map(|error| error.to_string()),+ Some(expected_error.to_owned())+ );+ for textures in [+ &state.backend.monochrome_textures,+ &state.backend.polychrome_textures,+ ] {+ assert_eq!((textures.textures.len(), textures.free_list.len()), (0, 0));+ }+ }+ }+ }++ #[test]+ fn test_texture_upload_preserves_pixel_layout() -> Result<()> {+ let Some(atlas) = create_atlas() else {+ return Ok(());+ };+ let mut state = atlas.0.lock();+ for (kind, bytes_per_pixel) in [+ (AtlasTextureKind::Monochrome, 1),+ (AtlasTextureKind::Polychrome, 4),+ ] {+ let texture = state+ .backend+ .push_texture(size(DevicePixels(8), DevicePixels(8)), kind)?;+ texture.upload(+ Point::default(),+ &AtlasUpload::new(+ kind,+ size(DevicePixels(8), DevicePixels(8)),+ &vec![0; 8 * 8 * bytes_per_pixel],+ )?,+ )?;+ let pixels = (1..=3 * 2 * bytes_per_pixel)+ .map(|value| value as u8)+ .collect::<Vec<_>>();+ texture.upload(+ point(DevicePixels(2), DevicePixels(3)),+ &AtlasUpload::new(kind, size(DevicePixels(3), DevicePixels(2)), &pixels)?,+ )?;+ let mut actual = vec![0; 8 * 8 * bytes_per_pixel];+ unsafe {+ texture+ .metal_texture+ .getBytes_bytesPerRow_fromRegion_mipmapLevel(+ NonNull::from(actual.as_mut_slice()).cast(),+ 8 * bytes_per_pixel,+ MTLRegion {+ origin: MTLOrigin { x: 0, y: 0, z: 0 },+ size: MTLSize {+ width: 8,+ height: 8,+ depth: 1,+ },+ },+ 0,+ );+ }+ let mut expected = vec![0; actual.len()];+ for row in 0..2 {+ let start = ((row + 3) * 8 + 2) * bytes_per_pixel;+ let source = row * 3 * bytes_per_pixel;+ expected[start..start + 3 * bytes_per_pixel]+ .copy_from_slice(&pixels[source..source + 3 * bytes_per_pixel]);+ }+ assert_eq!(actual, expected);+ }+ Ok(())+ }++ fn create_atlas() -> Option<MetalAtlas> {+ let device = MTLCreateSystemDefaultDevice()?;+ let supports_shared_storage =+ cfg!(target_os = "ios") || device.supportsFamily(MTLGPUFamily::Apple1);+ Some(MetalAtlas::new(device, supports_shared_storage))+ }++ fn make_image_key(image_id: usize, frame_index: usize) -> AtlasKey {+ AtlasKey::Image(gpui::RenderImageParams {+ image_id: gpui::ImageId(image_id),+ frame_index,+ })+ }++ fn insert_tile(atlas: &MetalAtlas, key: AtlasKey, size: Size<DevicePixels>) -> AtlasTile {+ atlas+ .get_or_insert_with(key, &mut || {+ let byte_count = (size.width.0 as usize) * (size.height.0 as usize) * 4;+ Ok(Some((size, Cow::Owned(vec![0u8; byte_count]))))+ })+ .expect("inserting atlas tile")+ .expect("retrieving inserted atlas tile")+ }}diff --git a/crates/gpui_apple/src/metal_renderer.rs b/crates/gpui_apple/src/metal_renderer.rsindex 862e62a54ba..e08652c3f6f 100644--- a/crates/gpui_apple/src/metal_renderer.rs+++ b/crates/gpui_apple/src/metal_renderer.rs@@ -1,30 +1,37 @@use crate::metal_atlas::MetalAtlas;use anyhow::{Context as _, Result};use block2::RcBlock;-use core_graphics::geometry::CGSize;use gpui::{AtlasTextureId, Background, Bounds, ContentMask, DevicePixels, PaintSurface, Path, Point,PrimitiveBatch, ScaledPixels, Scene, Size, point, size,};#[cfg(any(test, feature = "bench-support", feature = "test-support"))]use image::RgbaImage;-use objc2::runtime::AnyObject;--use core_graphics::color_space::{CGColorSpace, kCGColorSpaceDisplayP3};-use foreign_types::{ForeignType, ForeignTypeRef};-use metal::{- CAMetalLayer, CommandQueue, MTLGPUFamily, MTLPixelFormat, MTLResourceOptions, NSRange,- NSUInteger,-};-use objc2_core_foundation::CFRetained;+use objc2::{Message, rc::Retained, runtime::ProtocolObject};+use objc2_core_foundation::{CFRetained, CGSize};+use objc2_core_graphics::{CGColorSpace, kCGColorSpaceDisplayP3};use objc2_core_video::{CVMetalTexture, CVMetalTextureCache, CVMetalTextureGetTexture, CVPixelBufferGetHeight,CVPixelBufferGetHeightOfPlane, CVPixelBufferGetPixelFormatType, CVPixelBufferGetWidth,CVPixelBufferGetWidthOfPlane, kCVPixelFormatType_420YpCbCr8BiPlanarFullRange, kCVReturnSuccess,};+use objc2_foundation::{NSRange, NSString};+#[cfg(target_os = "macos")]+use objc2_metal::MTLCopyAllDevices;+use objc2_metal::{+ MTLBlendFactor, MTLBlendOperation, MTLBuffer, MTLClearColor, MTLCommandBuffer,+ MTLCommandEncoder, MTLCommandQueue, MTLCreateSystemDefaultDevice, MTLDevice, MTLDrawable,+ MTLGPUFamily, MTLLibrary, MTLLoadAction, MTLPixelFormat, MTLPrimitiveType,+ MTLRenderCommandEncoder, MTLRenderPassDescriptor, MTLRenderPipelineDescriptor,+ MTLRenderPipelineState, MTLResourceOptions, MTLStorageMode, MTLStoreAction, MTLTexture,+ MTLTextureDescriptor, MTLTextureType, MTLTextureUsage, MTLViewport,+};+#[cfg(any(test, feature = "bench-support", feature = "test-support"))]+use objc2_metal::{MTLBlitCommandEncoder, MTLOrigin, MTLRegion, MTLSize};+use objc2_quartz_core::{CAMetalDrawable, CAMetalLayer};use parking_lot::Mutex;-use std::{cell::Cell, ffi::c_void, mem, mem::MaybeUninit, ops::Range, ptr, slice, sync::Arc};+use std::{cell::Cell, mem, mem::MaybeUninit, ops::Range, ptr, slice, sync::Arc};// Exported to metalpub(crate) type PointF = gpui::Point<f32>;@@ -43,20 +50,17 @@ const MAX_INSTANCE_BUFFER_SIZE: usize = 256 * 1024 * 1024;pub type Context = Arc<Mutex<InstanceBufferPool>>;pub type Renderer = MetalRenderer;-pub unsafe fn new_renderer(+pub fn new_renderer(context: self::Context,- _native_window: *mut c_void,- _native_view: *mut c_void,- _bounds: gpui::Size<f32>,transparent: bool,use_display_p3: bool,-) -> Renderer {+) -> Result<Renderer> {MetalRenderer::new(context, transparent, use_display_p3)}pub struct InstanceBufferPool {buffer_size: usize,- buffers: Vec<metal::Buffer>,+ buffers: Vec<InstanceBuffer>,}impl Default for InstanceBufferPool {@@ -68,76 +72,80 @@ impl Default for InstanceBufferPool {}}-pub(crate) struct InstanceBuffer {- metal_buffer: metal::Buffer,+struct InstanceBuffer {+ metal_buffer: Retained<ProtocolObject<dyn MTLBuffer>>,size: usize,}+// SAFETY: Each buffer has one CPU writer and returns to the mutex-protected pool only after GPU completion.+unsafe impl Send for InstanceBuffer {}+impl InstanceBufferPool {pub(crate) fn reset(&mut self, buffer_size: usize) {self.buffer_size = buffer_size;self.buffers.clear();}- pub(crate) fn acquire(+ fn acquire(&mut self,- device: &metal::Device,+ device: &ProtocolObject<dyn MTLDevice>,unified_memory: bool,- ) -> InstanceBuffer {- let buffer = self.buffers.pop().unwrap_or_else(|| {- let options = if unified_memory {- MTLResourceOptions::StorageModeShared- // Buffers are write only which can benefit from the combined cache- // https://developer.apple.com/documentation/metal/mtlresourceoptions/cpucachemodewritecombined- | MTLResourceOptions::CPUCacheModeWriteCombined- } else {- MTLResourceOptions::StorageModeManaged- };-- device.new_buffer(self.buffer_size as u64, options)- });- InstanceBuffer {+ ) -> Result<InstanceBuffer> {+ if let Some(buffer) = self.buffers.pop() {+ return Ok(buffer);+ }+ let options = if unified_memory {+ MTLResourceOptions::StorageModeShared+ // Buffers are write only which can benefit from the combined cache+ // https://developer.apple.com/documentation/metal/mtlresourceoptions/cpucachemodewritecombined+ | MTLResourceOptions::CPUCacheModeWriteCombined+ } else {+ MTLResourceOptions::StorageModeManaged+ };+ let buffer = device+ .newBufferWithLength_options(self.buffer_size, options)+ .with_context(|| format!("allocating {}-byte instance buffer", self.buffer_size))?;+ Ok(InstanceBuffer {metal_buffer: buffer,size: self.buffer_size,- }+ })}- pub(crate) fn release(&mut self, buffer: InstanceBuffer) {+ fn release(&mut self, buffer: InstanceBuffer) {if buffer.size == self.buffer_size {- self.buffers.push(buffer.metal_buffer)+ self.buffers.push(buffer)}}}pub struct MetalRenderer {- device: metal::Device,- layer: Option<metal::MetalLayer>,+ device: Retained<ProtocolObject<dyn MTLDevice>>,+ layer: Option<Retained<CAMetalLayer>>,is_apple_gpu: bool,is_unified_memory: bool,presents_with_transaction: bool,/// For headless rendering, tracks whether output should be opaqueopaque: bool,- command_queue: CommandQueue,- paths_rasterization_pipeline_state: metal::RenderPipelineState,- path_sprites_pipeline_state: metal::RenderPipelineState,- shadows_pipeline_state: metal::RenderPipelineState,- quads_pipeline_state: metal::RenderPipelineState,- underlines_pipeline_state: metal::RenderPipelineState,- monochrome_sprites_pipeline_state: metal::RenderPipelineState,- polychrome_sprites_pipeline_state: metal::RenderPipelineState,- surfaces_pipeline_state: metal::RenderPipelineState,- unit_vertices: metal::Buffer,- #[allow(clippy::arc_with_non_send_sync)]+ command_queue: Retained<ProtocolObject<dyn MTLCommandQueue>>,+ paths_rasterization_pipeline_state: Retained<ProtocolObject<dyn MTLRenderPipelineState>>,+ path_sprites_pipeline_state: Retained<ProtocolObject<dyn MTLRenderPipelineState>>,+ shadows_pipeline_state: Retained<ProtocolObject<dyn MTLRenderPipelineState>>,+ quads_pipeline_state: Retained<ProtocolObject<dyn MTLRenderPipelineState>>,+ underlines_pipeline_state: Retained<ProtocolObject<dyn MTLRenderPipelineState>>,+ monochrome_sprites_pipeline_state: Retained<ProtocolObject<dyn MTLRenderPipelineState>>,+ polychrome_sprites_pipeline_state: Retained<ProtocolObject<dyn MTLRenderPipelineState>>,+ surfaces_pipeline_state: Retained<ProtocolObject<dyn MTLRenderPipelineState>>,+ unit_vertices: Retained<ProtocolObject<dyn MTLBuffer>>,instance_buffer_pool: Arc<Mutex<InstanceBufferPool>>,sprite_atlas: Arc<MetalAtlas>,core_video_texture_cache: CFRetained<CVMetalTextureCache>,- path_intermediate_texture: Option<metal::Texture>,- path_intermediate_msaa_texture: Option<metal::Texture>,+ path_intermediate_texture: Option<Retained<ProtocolObject<dyn MTLTexture>>>,+ path_intermediate_msaa_texture: Option<Retained<ProtocolObject<dyn MTLTexture>>>,path_sample_count: u32,/// Offscreen render target reused across `render_scene` calls when/// rendering headlessly without reading pixels back.#[cfg(any(test, feature = "bench-support", feature = "test-support"))]- headless_render_target: Option<metal::Texture>,+ headless_render_target: Option<Retained<ProtocolObject<dyn MTLTexture>>>,}#[repr(C)]@@ -154,9 +162,9 @@ impl MetalRenderer {instance_buffer_pool: Arc<Mutex<InstanceBufferPool>>,transparent: bool,use_display_p3: bool,- ) -> Self {- let device = Self::create_device();- let layer = metal::MetalLayer::new();+ ) -> Result<Self> {+ let device = Self::create_device()?;+ let layer = CAMetalLayer::new();Self::configure_layer(&layer, &device, transparent, use_display_p3);Self::new_internal(device, Some(layer), !transparent, instance_buffer_pool)}@@ -166,63 +174,47 @@ impl MetalRenderer {/// `CAMetalLayer`. The renderer retains the layer.pub fn from_layer(instance_buffer_pool: Arc<Mutex<InstanceBufferPool>>,- layer: &objc2_quartz_core::CAMetalLayer,+ layer: &CAMetalLayer,transparent: bool,- ) -> Self {- let device = Self::create_device();- // Both types bind the same Objective-C class, so this only changes which- // Rust wrapper views the live layer. `to_owned` retains it.- let layer = unsafe {- metal::MetalLayerRef::from_ptr(ptr::from_ref(layer).cast_mut().cast::<CAMetalLayer>())- }- .to_owned();+ ) -> Result<Self> {+ let device = Self::create_device()?;+ let layer = layer.retain();Self::configure_layer(&layer, &device, transparent, false);Self::new_internal(device, Some(layer), !transparent, instance_buffer_pool)}fn configure_layer(- layer: &metal::MetalLayerRef,- device: &metal::DeviceRef,+ layer: &CAMetalLayer,+ device: &ProtocolObject<dyn MTLDevice>,transparent: bool,use_display_p3: bool,) {- layer.set_device(device);- layer.set_pixel_format(MTLPixelFormat::BGRA8Unorm);- // metal-rs doesn't bind these setters, so view the same object through- // objc2's typed CAMetalLayer binding.- let objc2_layer: &objc2_quartz_core::CAMetalLayer = unsafe { &*layer.as_ptr().cast() };+ layer.setDevice(Some(device));+ layer.setPixelFormat(MTLPixelFormat::BGRA8Unorm);if use_display_p3 {// SAFETY: The constant is extern, from Core Graphicslet display_p3_name = unsafe { kCGColorSpaceDisplayP3 };- if let Some(display_p3_color_space) = CGColorSpace::create_with_name(display_p3_name) {- // SAFETY: `layer` is a CAMetalLayer and the color space remains valid for the call.- // 'metal-rs' does not expose CAMetalLayer's typed `colorspace` setter.- // Could be replaced with a native binding via objc2-* in future- unsafe {- let _: () = objc2::msg_send![- objc2_layer,- setColorspace: display_p3_color_space.as_ptr().cast::<c_void>()- ];- }+ if let Some(display_p3_color_space) = CGColorSpace::with_name(Some(display_p3_name)) {+ layer.setColorspace(Some(&display_p3_color_space));} else {log::error!("unable to create the Display P3 color space");}}// Support direct-to-display rendering if the window is not transparent// https://developer.apple.com/documentation/metal/managing-your-game-window-for-metal-in-macos- layer.set_opaque(!transparent);- layer.set_maximum_drawable_count(3);+ layer.setOpaque(!transparent);+ layer.setMaximumDrawableCount(3);// Allow texture reading for visual tests and UI automation screenshots// (captures without ScreenCaptureKit). Only debug builds pay the// presentation cost, even when `test-support` is compiled in.#[cfg(all(feature = "test-support", debug_assertions))]- layer.set_framebuffer_only(false);- objc2_layer.setAllowsNextDrawableTimeout(false);- objc2_layer.setNeedsDisplayOnBoundsChange(true);+ layer.setFramebufferOnly(false);+ layer.setAllowsNextDrawableTimeout(false);+ layer.setNeedsDisplayOnBoundsChange(true);// UIKit sizes a view's backing layer itself; only AppKit-hosted// layers need to track their superlayer's bounds.#[cfg(target_os = "macos")]- objc2_layer.setAutoresizingMask(+ layer.setAutoresizingMask(objc2_quartz_core::CAAutoresizingMask::LayerWidthSizable| objc2_quartz_core::CAAutoresizingMask::LayerHeightSizable,);@@ -233,21 +225,21 @@ impl MetalRenderer {/// This renderer can render scenes to images without requiring a CAMetalLayer,/// window, or AppKit. Use `render_scene_to_image()` to render scenes.#[cfg(any(test, feature = "bench-support", feature = "test-support"))]- pub fn new_headless(instance_buffer_pool: Arc<Mutex<InstanceBufferPool>>) -> Self {- let device = Self::create_device();+ pub fn new_headless(instance_buffer_pool: Arc<Mutex<InstanceBufferPool>>) -> Result<Self> {+ let device = Self::create_device()?;Self::new_internal(device, None, true, instance_buffer_pool)}#[cfg(target_os = "macos")]- fn create_device() -> metal::Device {+ fn create_device() -> Result<Retained<ProtocolObject<dyn MTLDevice>>> {// Prefer low‐power integrated GPUs on Intel Mac. On Apple// Silicon, there is only ever one GPU, so this is equivalent to// `metal::Device::system_default()`.- if let Some(d) = metal::Device::all()- .into_iter()- .min_by_key(|d| (d.is_removable(), !d.is_low_power()))+ if let Some(device) = MTLCopyAllDevices()+ .iter()+ .min_by_key(|device| (device.isRemovable(), !device.isLowPower())){- d+ Ok(device)} else {// For some reason `all()` can return an empty list, see https://github.com/zed-industries/zed/issues/37689// In that case, we fall back to the system default device.@@ -259,31 +251,33 @@ impl MetalRenderer {}#[cfg(target_os = "ios")]- fn create_device() -> metal::Device {+ fn create_device() -> Result<Retained<ProtocolObject<dyn MTLDevice>>> {Self::system_default_device()}- fn system_default_device() -> metal::Device {- metal::Device::system_default().unwrap_or_else(|| {- log::error!("unable to access a compatible graphics device");- std::process::exit(1);- })+ fn system_default_device() -> Result<Retained<ProtocolObject<dyn MTLDevice>>> {+ MTLCreateSystemDefaultDevice().context("accessing a compatible Metal device")}fn new_internal(- device: metal::Device,- layer: Option<metal::MetalLayer>,+ device: Retained<ProtocolObject<dyn MTLDevice>>,+ layer: Option<Retained<CAMetalLayer>>,opaque: bool,instance_buffer_pool: Arc<Mutex<InstanceBufferPool>>,- ) -> Self {+ ) -> Result<Self> {#[cfg(feature = "runtime_shaders")]let library = device- .new_library_with_source(&SHADERS_SOURCE_FILE, &metal::CompileOptions::new())- .expect("error building metal library");+ .newLibraryWithSource_options_error(+ &NSString::from_str(SHADERS_SOURCE_FILE),+ Some(&objc2_metal::MTLCompileOptions::new()),+ )+ .context("building Metal library")?;#[cfg(not(feature = "runtime_shaders"))]let library = device- .new_library_with_data(SHADERS_METALLIB)- .expect("error building metal library");+ .newLibraryWithData_error(&dispatch2::DispatchData::from_static_bytes(+ SHADERS_METALLIB,+ ))+ .context("loading Metal library")?;fn to_float2_bits(point: PointF) -> u64 {let mut output = point.y.to_bits() as u64;@@ -296,12 +290,12 @@ impl MetalRenderer {// https://developer.apple.com/documentation/metal/setting-resource-storage-modes// iOS does not support managed resources. Its simulator may report a// non-unified host GPU even though resources must still use shared storage.- let is_unified_memory = cfg!(target_os = "ios") || device.has_unified_memory();+ let is_unified_memory = cfg!(target_os = "ios") || device.hasUnifiedMemory();// Apple GPU families support memoryless textures, which can significantly reduce// memory usage by keeping render targets in on-chip tile memory instead of// allocating backing store in system memory.// https://developer.apple.com/documentation/metal/mtlgpufamily- let is_apple_gpu = device.supports_family(MTLGPUFamily::Apple1);+ let is_apple_gpu = device.supportsFamily(MTLGPUFamily::Apple1);let unit_vertices = [to_float2_bits(point(0., 0.)),@@ -311,16 +305,20 @@ impl MetalRenderer {to_float2_bits(point(1., 0.)),to_float2_bits(point(1., 1.)),];- let unit_vertices = device.new_buffer_with_data(- unit_vertices.as_ptr() as *const c_void,- mem::size_of_val(&unit_vertices) as u64,- if is_unified_memory {- MTLResourceOptions::StorageModeShared- | MTLResourceOptions::CPUCacheModeWriteCombined- } else {- MTLResourceOptions::StorageModeManaged- },- );+ // SAFETY: Metal copies the live array using its exact byte length.+ let unit_vertices = unsafe {+ device.newBufferWithBytes_length_options(+ ptr::NonNull::from(&unit_vertices).cast(),+ mem::size_of_val(&unit_vertices),+ if is_unified_memory {+ MTLResourceOptions::StorageModeShared+ | MTLResourceOptions::CPUCacheModeWriteCombined+ } else {+ MTLResourceOptions::StorageModeManaged+ },+ )+ }+ .context("allocating unit vertex buffer")?;let paths_rasterization_pipeline_state = build_path_rasterization_pipeline_state(&device,@@ -330,7 +328,7 @@ impl MetalRenderer {"path_rasterization_fragment",MTLPixelFormat::BGRA8Unorm,PATH_SAMPLE_COUNT,- );+ )?;let path_sprites_pipeline_state = build_path_sprite_pipeline_state(&device,&library,@@ -338,7 +336,7 @@ impl MetalRenderer {"path_sprite_vertex","path_sprite_fragment",MTLPixelFormat::BGRA8Unorm,- );+ )?;let shadows_pipeline_state = build_pipeline_state(&device,&library,@@ -346,7 +344,7 @@ impl MetalRenderer {"shadow_vertex","shadow_fragment",MTLPixelFormat::BGRA8Unorm,- );+ )?;let quads_pipeline_state = build_pipeline_state(&device,&library,@@ -354,7 +352,7 @@ impl MetalRenderer {"quad_vertex","quad_fragment",MTLPixelFormat::BGRA8Unorm,- );+ )?;let underlines_pipeline_state = build_pipeline_state(&device,&library,@@ -362,7 +360,7 @@ impl MetalRenderer {"underline_vertex","underline_fragment",MTLPixelFormat::BGRA8Unorm,- );+ )?;let monochrome_sprites_pipeline_state = build_pipeline_state(&device,&library,@@ -370,7 +368,7 @@ impl MetalRenderer {"monochrome_sprite_vertex","monochrome_sprite_fragment",MTLPixelFormat::BGRA8Unorm,- );+ )?;let polychrome_sprites_pipeline_state = build_pipeline_state(&device,&library,@@ -378,7 +376,7 @@ impl MetalRenderer {"polychrome_sprite_vertex","polychrome_sprite_fragment",MTLPixelFormat::BGRA8Unorm,- );+ )?;let surfaces_pipeline_state = build_pipeline_state(&device,&library,@@ -386,32 +384,29 @@ impl MetalRenderer {"surface_vertex","surface_fragment",MTLPixelFormat::BGRA8Unorm,- );+ )?;- let command_queue = device.new_command_queue();+ let command_queue = device.newCommandQueue().context("creating command queue")?;let supports_shared_storage = cfg!(target_os = "ios") || is_apple_gpu;+ #[expect(+ clippy::arc_with_non_send_sync,+ reason = "PlatformWindow::sprite_atlas requires Arc, not Send or Sync"+ )]let sprite_atlas = Arc::new(MetalAtlas::new(device.clone(), supports_shared_storage));- // metal and objc2-metal expose the same Objective-C device; the borrowed- // protocol object remains valid while `device` owns it.- let core_video_texture_cache = unsafe {- let mut cache = ptr::null_mut();- let status = CVMetalTextureCache::create(- None,- None,- &*device- .as_ptr()- .cast::<objc2::runtime::ProtocolObject<dyn objc2_metal::MTLDevice>>(),- None,- ptr::NonNull::from(&mut cache),- );- assert_eq!(- status, kCVReturnSuccess,- "failed to create CoreVideo Metal texture cache"- );- CFRetained::from_raw(ptr::NonNull::new(cache).expect("CoreVideo returned a null cache"))+ let mut cache = ptr::null_mut();+ // SAFETY: The output pointer is writable and both optional attribute dictionaries are absent.+ let status = unsafe {+ CVMetalTextureCache::create(None, None, &device, None, ptr::NonNull::from(&mut cache))};+ anyhow::ensure!(+ status == kCVReturnSuccess,+ "creating CoreVideo Metal texture cache: status {status}"+ );+ let cache = ptr::NonNull::new(cache).context("retrieving CoreVideo Metal texture cache")?;+ // SAFETY: The successful create call transfers ownership of this non-null cache.+ let core_video_texture_cache = unsafe { CFRetained::from_raw(cache) };- Self {+ Ok(Self {device,layer,presents_with_transaction: false,@@ -436,17 +431,17 @@ impl MetalRenderer {path_sample_count: PATH_SAMPLE_COUNT,#[cfg(any(test, feature = "bench-support", feature = "test-support"))]headless_render_target: None,- }+ })}- pub fn layer(&self) -> Option<&metal::MetalLayerRef> {- self.layer.as_ref().map(|l| l.as_ref())+ pub fn layer(&self) -> Option<&CAMetalLayer> {+ self.layer.as_deref()}pub fn layer_ptr(&self) -> *mut CAMetalLayer {self.layer.as_ref()- .map(|l| l.as_ptr())+ .map(|layer| Retained::as_ptr(layer).cast_mut()).unwrap_or(ptr::null_mut())}@@ -457,59 +452,76 @@ impl MetalRenderer {pub fn set_presents_with_transaction(&mut self, presents_with_transaction: bool) {self.presents_with_transaction = presents_with_transaction;if let Some(layer) = &self.layer {- layer.set_presents_with_transaction(presents_with_transaction);+ layer.setPresentsWithTransaction(presents_with_transaction);}}pub fn update_drawable_size(&mut self, size: Size<DevicePixels>) {if let Some(layer) = &self.layer {- layer.set_drawable_size(CGSize::new(size.width.0 as f64, size.height.0 as f64));+ layer.setDrawableSize(CGSize::new(size.width.0 as f64, size.height.0 as f64));+ }+ if let Err(error) = self.update_path_intermediate_textures(size) {+ log::error!("failed to resize path textures: {error:#}");}- self.update_path_intermediate_textures(size);}- fn update_path_intermediate_textures(&mut self, size: Size<DevicePixels>) {+ fn update_path_intermediate_textures(&mut self, size: Size<DevicePixels>) -> Result<()> {// We are uncertain when this happens, but sometimes size can be 0 here. Most likely before// the layout pass on window creation. Zero-sized texture creation causes SIGABRT.// https://github.com/zed-industries/zed/issues/36229+ self.path_intermediate_texture = None;+ self.path_intermediate_msaa_texture = None;if size.width.0 <= 0 || size.height.0 <= 0 {- self.path_intermediate_texture = None;- self.path_intermediate_msaa_texture = None;- return;+ return Ok(());}- let texture_descriptor = metal::TextureDescriptor::new();- texture_descriptor.set_width(size.width.0 as u64);- texture_descriptor.set_height(size.height.0 as u64);- texture_descriptor.set_pixel_format(metal::MTLPixelFormat::BGRA8Unorm);- texture_descriptor.set_storage_mode(metal::MTLStorageMode::Private);- texture_descriptor- .set_usage(metal::MTLTextureUsage::RenderTarget | metal::MTLTextureUsage::ShaderRead);- self.path_intermediate_texture = Some(self.device.new_texture(&texture_descriptor));+ let texture_descriptor = MTLTextureDescriptor::new();+ // SAFETY: The dimensions are positive and this descriptor creates a 2D texture.+ unsafe {+ texture_descriptor.setWidth(size.width.0 as usize);+ texture_descriptor.setHeight(size.height.0 as usize);+ }+ texture_descriptor.setPixelFormat(MTLPixelFormat::BGRA8Unorm);+ texture_descriptor.setStorageMode(MTLStorageMode::Private);+ texture_descriptor.setUsage(MTLTextureUsage::RenderTarget | MTLTextureUsage::ShaderRead);+ let intermediate_texture = self+ .device+ .newTextureWithDescriptor(&texture_descriptor)+ .context("allocating path intermediate texture")?;- if self.path_sample_count > 1 {+ let msaa_texture = if self.path_sample_count > 1 {// https://developer.apple.com/documentation/metal/choosing-a-resource-storage-mode-for-apple-gpus// Rendering MSAA textures are done in a single pass, so we can use memory-less storage on Apple Siliconlet storage_mode = if self.is_apple_gpu {- metal::MTLStorageMode::Memoryless+ MTLStorageMode::Memoryless} else {- metal::MTLStorageMode::Private+ MTLStorageMode::Private};let msaa_descriptor = texture_descriptor;- msaa_descriptor.set_texture_type(metal::MTLTextureType::D2Multisample);- msaa_descriptor.set_storage_mode(storage_mode);- msaa_descriptor.set_sample_count(self.path_sample_count as _);- self.path_intermediate_msaa_texture = Some(self.device.new_texture(&msaa_descriptor));+ msaa_descriptor.setTextureType(MTLTextureType::Type2DMultisample);+ msaa_descriptor.setStorageMode(storage_mode);+ // SAFETY: The multisample texture uses the same sample count as its render pipeline.+ unsafe {+ msaa_descriptor.setSampleCount(self.path_sample_count as _);+ }+ Some(+ self.device+ .newTextureWithDescriptor(&msaa_descriptor)+ .context("allocating multisample path texture")?,+ )} else {- self.path_intermediate_msaa_texture = None;- }+ None+ };+ self.path_intermediate_texture = Some(intermediate_texture);+ self.path_intermediate_msaa_texture = msaa_texture;+ Ok(())}pub fn update_transparency(&mut self, transparent: bool) {self.opaque = !transparent;if let Some(layer) = &self.layer {- layer.set_opaque(!transparent);+ layer.setOpaque(!transparent);}}@@ -527,12 +539,12 @@ impl MetalRenderer {return;}};- let viewport_size = layer.drawable_size();+ let viewport_size = layer.drawableSize();let viewport_size: Size<DevicePixels> = size((viewport_size.width.ceil() as i32).into(),(viewport_size.height.ceil() as i32).into(),);- let drawable = if let Some(drawable) = layer.next_drawable() {+ let drawable = if let Some(drawable) = layer.nextDrawable() {drawable} else {log::error!(@@ -542,7 +554,7 @@ impl MetalRenderer {return;};- let command_buffer = match self.render_frame(scene, drawable.texture(), viewport_size) {+ let command_buffer = match self.render_frame(scene, &drawable.texture(), viewport_size) {Ok(command_buffer) => command_buffer,Err(error) => {log::error!("failed to render: {error:#}");@@ -552,10 +564,10 @@ impl MetalRenderer {if self.presents_with_transaction {command_buffer.commit();- command_buffer.wait_until_scheduled();+ command_buffer.waitUntilScheduled();drawable.present();} else {- command_buffer.present_drawable(drawable);+ command_buffer.presentDrawable(ProtocolObject::from_ref(&*drawable));command_buffer.commit();}}@@ -563,17 +575,20 @@ impl MetalRenderer {fn render_frame(&mut self,scene: &Scene,- texture: &metal::TextureRef,+ texture: &ProtocolObject<dyn MTLTexture>,viewport_size: Size<DevicePixels>,- ) -> Result<metal::CommandBuffer> {+ ) -> Result<Retained<ProtocolObject<dyn MTLCommandBuffer>>> {+ if self.path_intermediate_texture.is_none() {+ self.update_path_intermediate_textures(viewport_size)?;+ }let mut writer = InstanceBufferWriter::new(&self.device,&self.instance_buffer_pool,self.is_unified_memory,- );+ )?;let instance_bindings = write_instances(scene, &mut writer).with_context(|| {format!(- "scene too large: {} paths, {} shadows, {} quads, {} underlines, {} mono, {} poly, {} surfaces",+ "writing instance data: {} paths, {} shadows, {} quads, {} underlines, {} mono, {} poly, {} surfaces",scene.paths.len(),scene.shadows.len(),scene.quads.len(),@@ -583,24 +598,29 @@ impl MetalRenderer {scene.surfaces.len(),)})?;+ let mut surface_textures = Vec::new();let command_buffer = self.draw_primitives_to_texture(scene,&instance_bindings,&mut writer,texture,viewport_size,+ &mut surface_textures,)?;let instance_buffer_pool = self.instance_buffer_pool.clone();- let instance_buffer = Cell::new(Some(writer.finish()));- let block = RcBlock::new(move |_: ptr::NonNull<AnyObject>| {- if let Some(instance_buffer) = instance_buffer.take() {- instance_buffer_pool.lock().release(instance_buffer);- }- });- // SAFETY: Both pointee types are opaque views of the same Objective-C block pointer ABI.+ let frame_resources = Cell::new(Some((writer.finish(), surface_textures)));+ let block = RcBlock::new(+ move |_: ptr::NonNull<ProtocolObject<dyn MTLCommandBuffer>>| {+ if let Some((instance_buffer, _surface_textures)) = frame_resources.take() {+ instance_buffer_pool.lock().release(instance_buffer);+ }+ },+ );+ // SAFETY: Metal copies the live block and invokes it once after this frame completes.+ // Its captures own the frame resources and use the pool mutex when returning the buffer.unsafe {- command_buffer.add_completed_handler(&*RcBlock::as_ptr(&block).cast());+ command_buffer.addCompletedHandler(RcBlock::as_ptr(&block));}Ok(command_buffer)@@ -618,22 +638,22 @@ impl MetalRenderer {.layer.clone().ok_or_else(|| anyhow::anyhow!("render_to_image requires a layer-backed renderer"))?;- let viewport_size = layer.drawable_size();+ let viewport_size = layer.drawableSize();let viewport_size: Size<DevicePixels> = size((viewport_size.width.ceil() as i32).into(),(viewport_size.height.ceil() as i32).into(),);let drawable = layer- .next_drawable()+ .nextDrawable().ok_or_else(|| anyhow::anyhow!("Failed to get drawable for render_to_image"))?;- let command_buffer = self.render_frame(scene, drawable.texture(), viewport_size)?;+ let command_buffer = self.render_frame(scene, &drawable.texture(), viewport_size)?;// Commit and wait for completion without presentingcommand_buffer.commit();- command_buffer.wait_until_completed();+ command_buffer.waitUntilCompleted();- read_texture_to_image(drawable.texture())+ read_texture_to_image(&drawable.texture())}/// Renders a scene to an image without requiring a window or CAMetalLayer.@@ -654,25 +674,29 @@ impl MetalRenderer {// autoreleased command buffers and render-pass descriptors.objc2::rc::autoreleasepool(|_| {// Update path intermediate textures for this size- self.update_path_intermediate_textures(size);+ self.update_path_intermediate_textures(size)?;// Create an offscreen texture as render target- let texture_descriptor = metal::TextureDescriptor::new();- texture_descriptor.set_width(size.width.0 as u64);- texture_descriptor.set_height(size.height.0 as u64);- texture_descriptor.set_pixel_format(MTLPixelFormat::BGRA8Unorm);- texture_descriptor.set_usage(- metal::MTLTextureUsage::RenderTarget | metal::MTLTextureUsage::ShaderRead,- );+ let texture_descriptor = MTLTextureDescriptor::new();+ unsafe {+ texture_descriptor.setWidth(size.width.0 as usize);+ texture_descriptor.setHeight(size.height.0 as usize);+ }+ texture_descriptor.setPixelFormat(MTLPixelFormat::BGRA8Unorm);+ texture_descriptor+ .setUsage(MTLTextureUsage::RenderTarget | MTLTextureUsage::ShaderRead);// Like the atlas, only Apple GPUs can create shared textures on macOS;// Intel Macs cannot, even with unified memory. iOS has no managed storage.let uses_shared_storage = cfg!(target_os = "ios") || self.is_apple_gpu;- texture_descriptor.set_storage_mode(if uses_shared_storage {- metal::MTLStorageMode::Shared+ texture_descriptor.setStorageMode(if uses_shared_storage {+ MTLStorageMode::Shared} else {- metal::MTLStorageMode::Managed+ MTLStorageMode::Managed});- let target_texture = self.device.new_texture(&texture_descriptor);+ let target_texture = self+ .device+ .newTextureWithDescriptor(&texture_descriptor)+ .context("allocating headless render target")?;let command_buffer = self.render_frame(scene, &target_texture, size)?;@@ -680,14 +704,16 @@ impl MetalRenderer {// can read back the rendered data. Without this, get_bytes returns// stale zeros.if !uses_shared_storage {- let blit = command_buffer.new_blit_command_encoder();- blit.synchronize_resource(&target_texture);- blit.end_encoding();+ let blit = command_buffer+ .blitCommandEncoder()+ .context("creating blit command encoder")?;+ blit.synchronizeResource(ProtocolObject::from_ref(&*target_texture));+ blit.endEncoding();}// Commit and wait for completioncommand_buffer.commit();- command_buffer.wait_until_completed();+ command_buffer.waitUntilCompleted();read_texture_to_image(&target_texture)})@@ -707,26 +733,32 @@ impl MetalRenderer {}objc2::rc::autoreleasepool(|_| {- self.update_path_intermediate_textures(size);+ self.update_path_intermediate_textures(size)?;let needs_new_target = self.headless_render_target.as_ref().is_none_or(|texture| {- texture.width() != size.width.0 as u64 || texture.height() != size.height.0 as u64+ texture.width() != size.width.0 as usize+ || texture.height() != size.height.0 as usize});if needs_new_target {- let texture_descriptor = metal::TextureDescriptor::new();- texture_descriptor.set_width(size.width.0 as u64);- texture_descriptor.set_height(size.height.0 as u64);- texture_descriptor.set_pixel_format(MTLPixelFormat::BGRA8Unorm);- texture_descriptor.set_usage(- metal::MTLTextureUsage::RenderTarget | metal::MTLTextureUsage::ShaderRead,+ let texture_descriptor = MTLTextureDescriptor::new();+ unsafe {+ texture_descriptor.setWidth(size.width.0 as usize);+ texture_descriptor.setHeight(size.height.0 as usize);+ }+ texture_descriptor.setPixelFormat(MTLPixelFormat::BGRA8Unorm);+ texture_descriptor+ .setUsage(MTLTextureUsage::RenderTarget | MTLTextureUsage::ShaderRead);+ texture_descriptor.setStorageMode(MTLStorageMode::Private);+ self.headless_render_target = Some(+ self.device+ .newTextureWithDescriptor(&texture_descriptor)+ .context("allocating headless render target")?,);- texture_descriptor.set_storage_mode(metal::MTLStorageMode::Private);- self.headless_render_target = Some(self.device.new_texture(&texture_descriptor));}let target_texture = self.headless_render_target.clone()- .expect("just ensured the render target exists");+ .context("retrieving headless render target")?;let command_buffer = self.render_frame(scene, &target_texture, size)?;@@ -742,60 +774,68 @@ impl MetalRenderer {scene: &Scene,instance_bindings: &InstanceBindings,writer: &mut InstanceBufferWriter,- texture: &metal::TextureRef,+ texture: &ProtocolObject<dyn MTLTexture>,viewport_size: Size<DevicePixels>,- ) -> Result<metal::CommandBuffer> {+ surface_textures: &mut Vec<CFRetained<CVMetalTexture>>,+ ) -> Result<Retained<ProtocolObject<dyn MTLCommandBuffer>>> {let command_queue = self.command_queue.clone();- let command_buffer = command_queue.new_command_buffer();+ let command_buffer = command_queue+ .commandBuffer()+ .context("creating command buffer")?;let alpha = if self.opaque { 1. } else { 0. };let mut command_encoder = new_command_encoder_for_texture(- command_buffer,+ &command_buffer,texture,viewport_size,- Some(metal::MTLClearColor::new(0., 0., 0., alpha)),- );+ Some(MTLClearColor {+ red: 0.,+ green: 0.,+ blue: 0.,+ alpha,+ }),+ )?;for batch in scene.batches() {match batch {PrimitiveBatch::Shadows(range) => {- self.draw_shadows(range, instance_bindings, viewport_size, command_encoder)+ self.draw_shadows(range, instance_bindings, viewport_size, &command_encoder)}PrimitiveBatch::Quads(range) => {- self.draw_quads(range, instance_bindings, viewport_size, command_encoder)+ self.draw_quads(range, instance_bindings, viewport_size, &command_encoder)}PrimitiveBatch::Paths(range) => {let paths = &scene.paths[range];- command_encoder.end_encoding();+ command_encoder.endEncoding();let did_draw = self.draw_paths_to_intermediate(paths,writer,viewport_size,- command_buffer,+ &command_buffer,)?;command_encoder = new_command_encoder_for_texture(- command_buffer,+ &command_buffer,texture,viewport_size,None,- );+ )?;if did_draw {if let Err(error) = self.draw_paths_from_intermediate(paths,writer,viewport_size,- command_encoder,+ &command_encoder,) {- command_encoder.end_encoding();+ command_encoder.endEncoding();return Err(error);}}}PrimitiveBatch::Underlines(range) => {- self.draw_underlines(range, instance_bindings, viewport_size, command_encoder)+ self.draw_underlines(range, instance_bindings, viewport_size, &command_encoder)}PrimitiveBatch::MonochromeSprites { texture_id, range } => self.draw_monochrome_sprites(@@ -803,7 +843,7 @@ impl MetalRenderer {range,instance_bindings,viewport_size,- command_encoder,+ &command_encoder,),PrimitiveBatch::PolychromeSprites { texture_id, range } => self.draw_polychrome_sprites(@@ -811,22 +851,28 @@ impl MetalRenderer {range,instance_bindings,viewport_size,- command_encoder,+ &command_encoder,),- PrimitiveBatch::Surfaces(range) => self.draw_surfaces(- &scene.surfaces[range.clone()],- range.start,- instance_bindings,- viewport_size,- command_encoder,- ),+ PrimitiveBatch::Surfaces(range) => {+ if let Err(error) = self.draw_surfaces(+ &scene.surfaces[range.clone()],+ range.start,+ instance_bindings,+ viewport_size,+ &command_encoder,+ surface_textures,+ ) {+ command_encoder.endEncoding();+ return Err(error);+ }+ }PrimitiveBatch::SubpixelSprites { .. } => unreachable!(),}}- command_encoder.end_encoding();+ command_encoder.endEncoding();- Ok(command_buffer.to_owned())+ Ok(command_buffer)}fn draw_paths_to_intermediate(@@ -834,7 +880,7 @@ impl MetalRenderer {paths: &[Path<ScaledPixels>],writer: &mut InstanceBufferWriter,viewport_size: Size<DevicePixels>,- command_buffer: &metal::CommandBufferRef,+ command_buffer: &ProtocolObject<dyn MTLCommandBuffer>,) -> Result<bool> {if paths.is_empty() {return Ok(false);@@ -855,47 +901,61 @@ impl MetalRenderer {}let vertex_instance_bindings = writer.write(&vertices)?;- let render_pass_descriptor = metal::RenderPassDescriptor::new();- let color_attachment = render_pass_descriptor- .color_attachments()- .object_at(0)- .unwrap();- color_attachment.set_load_action(metal::MTLLoadAction::Clear);- color_attachment.set_clear_color(metal::MTLClearColor::new(0., 0., 0., 0.));+ let render_pass_descriptor = MTLRenderPassDescriptor::new();+ // SAFETY: Index zero is within the render pass's color attachment array.+ let color_attachment = unsafe {+ render_pass_descriptor+ .colorAttachments()+ .objectAtIndexedSubscript(0)+ };+ color_attachment.setLoadAction(MTLLoadAction::Clear);+ color_attachment.setClearColor(MTLClearColor {+ red: 0.,+ green: 0.,+ blue: 0.,+ alpha: 0.,+ });if let Some(msaa_texture) = &self.path_intermediate_msaa_texture {- color_attachment.set_texture(Some(msaa_texture));- color_attachment.set_resolve_texture(Some(intermediate_texture));- color_attachment.set_store_action(metal::MTLStoreAction::MultisampleResolve);+ color_attachment.setTexture(Some(msaa_texture));+ color_attachment.setResolveTexture(Some(intermediate_texture));+ color_attachment.setStoreAction(MTLStoreAction::MultisampleResolve);} else {- color_attachment.set_texture(Some(intermediate_texture));- color_attachment.set_store_action(metal::MTLStoreAction::Store);+ color_attachment.setTexture(Some(intermediate_texture));+ color_attachment.setStoreAction(MTLStoreAction::Store);}- let command_encoder = command_buffer.new_render_command_encoder(render_pass_descriptor);- command_encoder.set_render_pipeline_state(&self.paths_rasterization_pipeline_state);- command_encoder.set_vertex_buffer(- PathRasterizationInputIndex::Vertices as u64,- Some(&vertex_instance_bindings.buffer),- vertex_instance_bindings.offset as u64,- );- command_encoder.set_vertex_bytes(- PathRasterizationInputIndex::ViewportSize as u64,- mem::size_of_val(&viewport_size) as u64,- &viewport_size as *const Size<DevicePixels> as *const _,- );- command_encoder.set_fragment_buffer(- PathRasterizationInputIndex::Vertices as u64,- Some(&vertex_instance_bindings.buffer),- vertex_instance_bindings.offset as u64,- );- command_encoder.draw_primitives(- metal::MTLPrimitiveType::Triangle,- 0,- vertices.len() as u64,- );+ let command_encoder = command_buffer+ .renderCommandEncoderWithDescriptor(&render_pass_descriptor)+ .context("creating path render command encoder")?;+ command_encoder.setRenderPipelineState(&self.paths_rasterization_pipeline_state);+ // SAFETY: The binding contains vertices.len() shader-compatible vertices at an aligned offset.+ // Metal retains the buffer, and writer.finish publishes CPU writes before submission.+ // The viewport bytes are copied from a live value into the matching shader slot.+ unsafe {+ command_encoder.setVertexBuffer_offset_atIndex(+ Some(&vertex_instance_bindings.buffer),+ vertex_instance_bindings.offset,+ PathRasterizationInputIndex::Vertices as usize,+ );+ command_encoder.setVertexBytes_length_atIndex(+ ptr::NonNull::from(&viewport_size).cast(),+ mem::size_of_val(&viewport_size),+ PathRasterizationInputIndex::ViewportSize as usize,+ );+ command_encoder.setFragmentBuffer_offset_atIndex(+ Some(&vertex_instance_bindings.buffer),+ vertex_instance_bindings.offset,+ PathRasterizationInputIndex::Vertices as usize,+ );+ command_encoder.drawPrimitives_vertexStart_vertexCount(+ MTLPrimitiveType::Triangle,+ 0,+ vertices.len(),+ );+ }- command_encoder.end_encoding();+ command_encoder.endEncoding();Ok(true)}@@ -904,41 +964,44 @@ impl MetalRenderer {shadows: Range<usize>,instance_bindings: &InstanceBindings,viewport_size: Size<DevicePixels>,- command_encoder: &metal::RenderCommandEncoderRef,+ command_encoder: &ProtocolObject<dyn MTLRenderCommandEncoder>,) {if shadows.is_empty() {return;}- command_encoder.set_render_pipeline_state(&self.shadows_pipeline_state);- command_encoder.set_vertex_buffer(- ShadowInputIndex::Vertices as u64,- Some(&self.unit_vertices),- 0,- );- command_encoder.set_vertex_buffer(- ShadowInputIndex::Shadows as u64,- Some(&instance_bindings.shadows.buffer),- instance_bindings.shadows.offset as u64,- );- command_encoder.set_fragment_buffer(- ShadowInputIndex::Shadows as u64,- Some(&instance_bindings.shadows.buffer),- instance_bindings.shadows.offset as u64,- );- command_encoder.set_vertex_bytes(- ShadowInputIndex::ViewportSize as u64,- mem::size_of_val(&viewport_size) as u64,- &viewport_size as *const Size<DevicePixels> as *const _,- );-- command_encoder.draw_primitives_instanced_base_instance(- metal::MTLPrimitiveType::Triangle,- 0,- 6,- shadows.len() as u64,- shadows.start as u64,- );+ command_encoder.setRenderPipelineState(&self.shadows_pipeline_state);+ // SAFETY: Six unit vertices and the scene's shadow range match the uploaded shader layouts and slots.+ // Metal retains the buffers, writer.finish publishes their writes, and viewport bytes are copied.+ unsafe {+ command_encoder.setVertexBuffer_offset_atIndex(+ Some(&self.unit_vertices),+ 0,+ ShadowInputIndex::Vertices as usize,+ );+ command_encoder.setVertexBuffer_offset_atIndex(+ Some(&instance_bindings.shadows.buffer),+ instance_bindings.shadows.offset,+ ShadowInputIndex::Shadows as usize,+ );+ command_encoder.setFragmentBuffer_offset_atIndex(+ Some(&instance_bindings.shadows.buffer),+ instance_bindings.shadows.offset,+ ShadowInputIndex::Shadows as usize,+ );+ command_encoder.setVertexBytes_length_atIndex(+ ptr::NonNull::from(&viewport_size).cast(),+ mem::size_of_val(&viewport_size),+ ShadowInputIndex::ViewportSize as usize,+ );+ command_encoder.drawPrimitives_vertexStart_vertexCount_instanceCount_baseInstance(+ MTLPrimitiveType::Triangle,+ 0,+ 6,+ shadows.len(),+ shadows.start,+ );+ }}fn draw_quads(@@ -946,41 +1009,44 @@ impl MetalRenderer {quads: Range<usize>,instance_bindings: &InstanceBindings,viewport_size: Size<DevicePixels>,- command_encoder: &metal::RenderCommandEncoderRef,+ command_encoder: &ProtocolObject<dyn MTLRenderCommandEncoder>,) {if quads.is_empty() {return;}- command_encoder.set_render_pipeline_state(&self.quads_pipeline_state);- command_encoder.set_vertex_buffer(- QuadInputIndex::Vertices as u64,- Some(&self.unit_vertices),- 0,- );- command_encoder.set_vertex_buffer(- QuadInputIndex::Quads as u64,- Some(&instance_bindings.quads.buffer),- instance_bindings.quads.offset as u64,- );- command_encoder.set_fragment_buffer(- QuadInputIndex::Quads as u64,- Some(&instance_bindings.quads.buffer),- instance_bindings.quads.offset as u64,- );- command_encoder.set_vertex_bytes(- QuadInputIndex::ViewportSize as u64,- mem::size_of_val(&viewport_size) as u64,- &viewport_size as *const Size<DevicePixels> as *const _,- );-- command_encoder.draw_primitives_instanced_base_instance(- metal::MTLPrimitiveType::Triangle,- 0,- 6,- quads.len() as u64,- quads.start as u64,- );+ command_encoder.setRenderPipelineState(&self.quads_pipeline_state);+ // SAFETY: Six unit vertices and the scene's quad range match the uploaded shader layouts and slots.+ // Metal retains the buffers, writer.finish publishes their writes, and viewport bytes are copied.+ unsafe {+ command_encoder.setVertexBuffer_offset_atIndex(+ Some(&self.unit_vertices),+ 0,+ QuadInputIndex::Vertices as usize,+ );+ command_encoder.setVertexBuffer_offset_atIndex(+ Some(&instance_bindings.quads.buffer),+ instance_bindings.quads.offset,+ QuadInputIndex::Quads as usize,+ );+ command_encoder.setFragmentBuffer_offset_atIndex(+ Some(&instance_bindings.quads.buffer),+ instance_bindings.quads.offset,+ QuadInputIndex::Quads as usize,+ );+ command_encoder.setVertexBytes_length_atIndex(+ ptr::NonNull::from(&viewport_size).cast(),+ mem::size_of_val(&viewport_size),+ QuadInputIndex::ViewportSize as usize,+ );+ command_encoder.drawPrimitives_vertexStart_vertexCount_instanceCount_baseInstance(+ MTLPrimitiveType::Triangle,+ 0,+ 6,+ quads.len(),+ quads.start,+ );+ }}fn draw_paths_from_intermediate(@@ -988,9 +1054,9 @@ impl MetalRenderer {paths: &[Path<ScaledPixels>],writer: &mut InstanceBufferWriter,viewport_size: Size<DevicePixels>,- command_encoder: &metal::RenderCommandEncoderRef,+ command_encoder: &ProtocolObject<dyn MTLRenderCommandEncoder>,) -> Result<()> {- let Some(first_path) = paths.first() else {+ let (Some(first_path), Some(last_path)) = (paths.first(), paths.last()) else {return Ok(());};let intermediate_texture = self@@ -998,22 +1064,25 @@ impl MetalRenderer {.as_ref().context("missing path intermediate texture")?;- command_encoder.set_render_pipeline_state(&self.path_sprites_pipeline_state);- command_encoder.set_vertex_buffer(- SpriteInputIndex::Vertices as u64,- Some(&self.unit_vertices),- 0,- );- command_encoder.set_vertex_bytes(- SpriteInputIndex::ViewportSize as u64,- mem::size_of_val(&viewport_size) as u64,- &viewport_size as *const Size<DevicePixels> as *const _,- );-- command_encoder.set_fragment_texture(- SpriteInputIndex::AtlasTexture as u64,- Some(intermediate_texture),- );+ command_encoder.setRenderPipelineState(&self.path_sprites_pipeline_state);+ // SAFETY: The shader slots match the unit vertices, copied viewport, and retained path texture.+ // The preceding render pass writes this tracked texture before it is sampled.+ unsafe {+ command_encoder.setVertexBuffer_offset_atIndex(+ Some(&self.unit_vertices),+ 0,+ SpriteInputIndex::Vertices as usize,+ );+ command_encoder.setVertexBytes_length_atIndex(+ ptr::NonNull::from(&viewport_size).cast(),+ mem::size_of_val(&viewport_size),+ SpriteInputIndex::ViewportSize as usize,+ );+ command_encoder.setFragmentTexture_atIndex(+ Some(intermediate_texture),+ SpriteInputIndex::AtlasTexture as usize,+ );+ }// When copying paths from the intermediate texture to the drawable,// each pixel must only be copied once, in case of transparent paths.@@ -1023,7 +1092,7 @@ impl MetalRenderer {// batch combines different draw orders, we perform a single copy// for a minimal spanning rect.let sprites;- if paths.last().unwrap().order == first_path.order {+ if last_path.order == first_path.order {sprites = paths.iter().map(|path| PathSprite {@@ -1039,18 +1108,21 @@ impl MetalRenderer {}let sprite_instance_bindings = writer.write(&sprites)?;- command_encoder.set_vertex_buffer(- SpriteInputIndex::Sprites as u64,- Some(&sprite_instance_bindings.buffer),- sprite_instance_bindings.offset as u64,- );-- command_encoder.draw_primitives_instanced(- metal::MTLPrimitiveType::Triangle,- 0,- 6,- sprites.len() as u64,- );+ // SAFETY: The draw uses six unit vertices and exactly the sprites written at this aligned binding.+ // Metal retains the buffer, and writer.finish publishes CPU writes before submission.+ unsafe {+ command_encoder.setVertexBuffer_offset_atIndex(+ Some(&sprite_instance_bindings.buffer),+ sprite_instance_bindings.offset,+ SpriteInputIndex::Sprites as usize,+ );+ command_encoder.drawPrimitives_vertexStart_vertexCount_instanceCount(+ MTLPrimitiveType::Triangle,+ 0,+ 6,+ sprites.len(),+ );+ }Ok(())}@@ -1059,41 +1131,44 @@ impl MetalRenderer {underlines: Range<usize>,instance_bindings: &InstanceBindings,viewport_size: Size<DevicePixels>,- command_encoder: &metal::RenderCommandEncoderRef,+ command_encoder: &ProtocolObject<dyn MTLRenderCommandEncoder>,) {if underlines.is_empty() {return;}- command_encoder.set_render_pipeline_state(&self.underlines_pipeline_state);- command_encoder.set_vertex_buffer(- UnderlineInputIndex::Vertices as u64,- Some(&self.unit_vertices),- 0,- );- command_encoder.set_vertex_buffer(- UnderlineInputIndex::Underlines as u64,- Some(&instance_bindings.underlines.buffer),- instance_bindings.underlines.offset as u64,- );- command_encoder.set_fragment_buffer(- UnderlineInputIndex::Underlines as u64,- Some(&instance_bindings.underlines.buffer),- instance_bindings.underlines.offset as u64,- );- command_encoder.set_vertex_bytes(- UnderlineInputIndex::ViewportSize as u64,- mem::size_of_val(&viewport_size) as u64,- &viewport_size as *const Size<DevicePixels> as *const _,- );-- command_encoder.draw_primitives_instanced_base_instance(- metal::MTLPrimitiveType::Triangle,- 0,- 6,- underlines.len() as u64,- underlines.start as u64,- );+ command_encoder.setRenderPipelineState(&self.underlines_pipeline_state);+ // SAFETY: Six unit vertices and the scene's underline range match the uploaded shader layouts and slots.+ // Metal retains the buffers, writer.finish publishes their writes, and viewport bytes are copied.+ unsafe {+ command_encoder.setVertexBuffer_offset_atIndex(+ Some(&self.unit_vertices),+ 0,+ UnderlineInputIndex::Vertices as usize,+ );+ command_encoder.setVertexBuffer_offset_atIndex(+ Some(&instance_bindings.underlines.buffer),+ instance_bindings.underlines.offset,+ UnderlineInputIndex::Underlines as usize,+ );+ command_encoder.setFragmentBuffer_offset_atIndex(+ Some(&instance_bindings.underlines.buffer),+ instance_bindings.underlines.offset,+ UnderlineInputIndex::Underlines as usize,+ );+ command_encoder.setVertexBytes_length_atIndex(+ ptr::NonNull::from(&viewport_size).cast(),+ mem::size_of_val(&viewport_size),+ UnderlineInputIndex::ViewportSize as usize,+ );+ command_encoder.drawPrimitives_vertexStart_vertexCount_instanceCount_baseInstance(+ MTLPrimitiveType::Triangle,+ 0,+ 6,+ underlines.len(),+ underlines.start,+ );+ }}fn draw_monochrome_sprites(@@ -1102,7 +1177,7 @@ impl MetalRenderer {sprites: Range<usize>,instance_bindings: &InstanceBindings,viewport_size: Size<DevicePixels>,- command_encoder: &metal::RenderCommandEncoderRef,+ command_encoder: &ProtocolObject<dyn MTLRenderCommandEncoder>,) {if sprites.is_empty() {return;@@ -1115,41 +1190,47 @@ impl MetalRenderer {DevicePixels(texture.width() as i32),DevicePixels(texture.height() as i32),);- command_encoder.set_render_pipeline_state(&self.monochrome_sprites_pipeline_state);- command_encoder.set_vertex_buffer(- SpriteInputIndex::Vertices as u64,- Some(&self.unit_vertices),- 0,- );- command_encoder.set_vertex_buffer(- SpriteInputIndex::Sprites as u64,- Some(&instance_bindings.monochrome_sprites.buffer),- instance_bindings.monochrome_sprites.offset as u64,- );- command_encoder.set_vertex_bytes(- SpriteInputIndex::ViewportSize as u64,- mem::size_of_val(&viewport_size) as u64,- &viewport_size as *const Size<DevicePixels> as *const _,- );- command_encoder.set_vertex_bytes(- SpriteInputIndex::AtlasTextureSize as u64,- mem::size_of_val(&texture_size) as u64,- &texture_size as *const Size<DevicePixels> as *const _,- );- command_encoder.set_fragment_buffer(- SpriteInputIndex::Sprites as u64,- Some(&instance_bindings.monochrome_sprites.buffer),- instance_bindings.monochrome_sprites.offset as u64,- );- command_encoder.set_fragment_texture(SpriteInputIndex::AtlasTexture as u64, Some(&texture));-- command_encoder.draw_primitives_instanced_base_instance(- metal::MTLPrimitiveType::Triangle,- 0,- 6,- sprites.len() as u64,- sprites.start as u64,- );+ command_encoder.setRenderPipelineState(&self.monochrome_sprites_pipeline_state);+ // SAFETY: The scene's sprite range, six unit vertices, and copied sizes match the shader layouts and slots.+ // Metal retains the buffers and texture, and writer.finish publishes the instance writes.+ unsafe {+ command_encoder.setVertexBuffer_offset_atIndex(+ Some(&self.unit_vertices),+ 0,+ SpriteInputIndex::Vertices as usize,+ );+ command_encoder.setVertexBuffer_offset_atIndex(+ Some(&instance_bindings.monochrome_sprites.buffer),+ instance_bindings.monochrome_sprites.offset,+ SpriteInputIndex::Sprites as usize,+ );+ command_encoder.setVertexBytes_length_atIndex(+ ptr::NonNull::from(&viewport_size).cast(),+ mem::size_of_val(&viewport_size),+ SpriteInputIndex::ViewportSize as usize,+ );+ command_encoder.setVertexBytes_length_atIndex(+ ptr::NonNull::from(&texture_size).cast(),+ mem::size_of_val(&texture_size),+ SpriteInputIndex::AtlasTextureSize as usize,+ );+ command_encoder.setFragmentBuffer_offset_atIndex(+ Some(&instance_bindings.monochrome_sprites.buffer),+ instance_bindings.monochrome_sprites.offset,+ SpriteInputIndex::Sprites as usize,+ );+ command_encoder.setFragmentTexture_atIndex(+ Some(&texture),+ SpriteInputIndex::AtlasTexture as usize,+ );+ command_encoder.drawPrimitives_vertexStart_vertexCount_instanceCount_baseInstance(+ MTLPrimitiveType::Triangle,+ 0,+ 6,+ sprites.len(),+ sprites.start,+ );+ }}fn draw_polychrome_sprites(@@ -1158,7 +1239,7 @@ impl MetalRenderer {sprites: Range<usize>,instance_bindings: &InstanceBindings,viewport_size: Size<DevicePixels>,- command_encoder: &metal::RenderCommandEncoderRef,+ command_encoder: &ProtocolObject<dyn MTLRenderCommandEncoder>,) {if sprites.is_empty() {return;@@ -1171,41 +1252,47 @@ impl MetalRenderer {DevicePixels(texture.width() as i32),DevicePixels(texture.height() as i32),);- command_encoder.set_render_pipeline_state(&self.polychrome_sprites_pipeline_state);- command_encoder.set_vertex_buffer(- SpriteInputIndex::Vertices as u64,- Some(&self.unit_vertices),- 0,- );- command_encoder.set_vertex_buffer(- SpriteInputIndex::Sprites as u64,- Some(&instance_bindings.polychrome_sprites.buffer),- instance_bindings.polychrome_sprites.offset as u64,- );- command_encoder.set_vertex_bytes(- SpriteInputIndex::ViewportSize as u64,- mem::size_of_val(&viewport_size) as u64,- &viewport_size as *const Size<DevicePixels> as *const _,- );- command_encoder.set_vertex_bytes(- SpriteInputIndex::AtlasTextureSize as u64,- mem::size_of_val(&texture_size) as u64,- &texture_size as *const Size<DevicePixels> as *const _,- );- command_encoder.set_fragment_buffer(- SpriteInputIndex::Sprites as u64,- Some(&instance_bindings.polychrome_sprites.buffer),- instance_bindings.polychrome_sprites.offset as u64,- );- command_encoder.set_fragment_texture(SpriteInputIndex::AtlasTexture as u64, Some(&texture));-- command_encoder.draw_primitives_instanced_base_instance(- metal::MTLPrimitiveType::Triangle,- 0,- 6,- sprites.len() as u64,- sprites.start as u64,- );+ command_encoder.setRenderPipelineState(&self.polychrome_sprites_pipeline_state);+ // SAFETY: The scene's sprite range, six unit vertices, and copied sizes match the shader layouts and slots.+ // Metal retains the buffers and texture, and writer.finish publishes the instance writes.+ unsafe {+ command_encoder.setVertexBuffer_offset_atIndex(+ Some(&self.unit_vertices),+ 0,+ SpriteInputIndex::Vertices as usize,+ );+ command_encoder.setVertexBuffer_offset_atIndex(+ Some(&instance_bindings.polychrome_sprites.buffer),+ instance_bindings.polychrome_sprites.offset,+ SpriteInputIndex::Sprites as usize,+ );+ command_encoder.setVertexBytes_length_atIndex(+ ptr::NonNull::from(&viewport_size).cast(),+ mem::size_of_val(&viewport_size),+ SpriteInputIndex::ViewportSize as usize,+ );+ command_encoder.setVertexBytes_length_atIndex(+ ptr::NonNull::from(&texture_size).cast(),+ mem::size_of_val(&texture_size),+ SpriteInputIndex::AtlasTextureSize as usize,+ );+ command_encoder.setFragmentBuffer_offset_atIndex(+ Some(&instance_bindings.polychrome_sprites.buffer),+ instance_bindings.polychrome_sprites.offset,+ SpriteInputIndex::Sprites as usize,+ );+ command_encoder.setFragmentTexture_atIndex(+ Some(&texture),+ SpriteInputIndex::AtlasTexture as usize,+ );+ command_encoder.drawPrimitives_vertexStart_vertexCount_instanceCount_baseInstance(+ MTLPrimitiveType::Triangle,+ 0,+ 6,+ sprites.len(),+ sprites.start,+ );+ }}fn draw_surfaces(@@ -1214,28 +1301,33 @@ impl MetalRenderer {first_surface: usize,instance_bindings: &InstanceBindings,viewport_size: Size<DevicePixels>,- command_encoder: &metal::RenderCommandEncoderRef,- ) {+ command_encoder: &ProtocolObject<dyn MTLRenderCommandEncoder>,+ surface_textures: &mut Vec<CFRetained<CVMetalTexture>>,+ ) -> Result<()> {if surfaces.is_empty() {- return;+ return Ok(());}- command_encoder.set_render_pipeline_state(&self.surfaces_pipeline_state);- command_encoder.set_vertex_buffer(- SurfaceInputIndex::Vertices as u64,- Some(&self.unit_vertices),- 0,- );- command_encoder.set_vertex_buffer(- SurfaceInputIndex::Surfaces as u64,- Some(&instance_bindings.surfaces.buffer),- instance_bindings.surfaces.offset as u64,- );- command_encoder.set_vertex_bytes(- SurfaceInputIndex::ViewportSize as u64,- mem::size_of_val(&viewport_size) as u64,- &viewport_size as *const Size<DevicePixels> as *const _,- );+ command_encoder.setRenderPipelineState(&self.surfaces_pipeline_state);+ // SAFETY: The unit vertices, SurfaceBounds instances, and copied viewport match the shader layouts and slots.+ // Metal retains the buffers, and writer.finish publishes CPU writes before submission.+ unsafe {+ command_encoder.setVertexBuffer_offset_atIndex(+ Some(&self.unit_vertices),+ 0,+ SurfaceInputIndex::Vertices as usize,+ );+ command_encoder.setVertexBuffer_offset_atIndex(+ Some(&instance_bindings.surfaces.buffer),+ instance_bindings.surfaces.offset,+ SurfaceInputIndex::Surfaces as usize,+ );+ command_encoder.setVertexBytes_length_atIndex(+ ptr::NonNull::from(&viewport_size).cast(),+ mem::size_of_val(&viewport_size),+ SurfaceInputIndex::ViewportSize as usize,+ );+ }for (index, surface) in surfaces.iter().enumerate() {let image_buffer = &surface.image_buffer;@@ -1244,88 +1336,106 @@ impl MetalRenderer {DevicePixels::from(CVPixelBufferGetHeight(image_buffer) as i32),);- assert_eq!(- CVPixelBufferGetPixelFormatType(image_buffer),- kCVPixelFormatType_420YpCbCr8BiPlanarFullRange+ let pixel_format = CVPixelBufferGetPixelFormatType(image_buffer);+ anyhow::ensure!(+ pixel_format == kCVPixelFormatType_420YpCbCr8BiPlanarFullRange,+ "unsupported surface pixel format: {pixel_format:#x}");- let plane_texture = |plane, format| unsafe {+ let plane_texture = |plane, format| -> Result<CFRetained<CVMetalTexture>> {+ let width = CVPixelBufferGetWidthOfPlane(image_buffer, plane);+ let height = CVPixelBufferGetHeightOfPlane(image_buffer, plane);let mut texture = ptr::null_mut();- let status = CVMetalTextureCache::create_texture_from_image(- None,- &self.core_video_texture_cache,- image_buffer,- None,- format,- CVPixelBufferGetWidthOfPlane(image_buffer, plane),- CVPixelBufferGetHeightOfPlane(image_buffer, plane),- plane,- ptr::NonNull::from(&mut texture),- );- assert_eq!(- status, kCVReturnSuccess,- "failed to create CoreVideo Metal texture"+ // SAFETY: The buffer has two planes matching these formats and dimensions, and the output pointer is writable.+ let status = unsafe {+ CVMetalTextureCache::create_texture_from_image(+ None,+ &self.core_video_texture_cache,+ image_buffer,+ None,+ format,+ width,+ height,+ plane,+ ptr::NonNull::from(&mut texture),+ )+ };+ anyhow::ensure!(+ status == kCVReturnSuccess,+ "creating CoreVideo Metal texture for plane {plane}: status {status}");- CFRetained::<CVMetalTexture>::from_raw(- ptr::NonNull::new(texture).expect("CoreVideo returned a null texture"),- )+ let texture =+ ptr::NonNull::new(texture).context("retrieving CoreVideo Metal texture")?;+ // SAFETY: The successful create call transfers ownership of this non-null texture.+ Ok(unsafe { CFRetained::from_raw(texture) })};- let y_texture = plane_texture(0, objc2_metal::MTLPixelFormat::R8Unorm);- let cb_cr_texture = plane_texture(1, objc2_metal::MTLPixelFormat::RG8Unorm);-- command_encoder.set_vertex_bytes(- SurfaceInputIndex::TextureSize as u64,- mem::size_of_val(&texture_size) as u64,- &texture_size as *const Size<DevicePixels> as *const _,- );- command_encoder.set_fragment_texture(SurfaceInputIndex::YTexture as u64, unsafe {- let texture = CVMetalTextureGetTexture(&y_texture)- .expect("CoreVideo returned no Metal texture");- Some(metal::TextureRef::from_ptr(- objc2::rc::Retained::as_ptr(&texture) as *mut _,- ))- });- command_encoder.set_fragment_texture(SurfaceInputIndex::CbCrTexture as u64, unsafe {- let texture = CVMetalTextureGetTexture(&cb_cr_texture)- .expect("CoreVideo returned no Metal texture");- Some(metal::TextureRef::from_ptr(- objc2::rc::Retained::as_ptr(&texture) as *mut _,- ))- });+ let y_texture = plane_texture(0, MTLPixelFormat::R8Unorm)?;+ let cb_cr_texture = plane_texture(1, MTLPixelFormat::RG8Unorm)?;+ let y_metal_texture =+ CVMetalTextureGetTexture(&y_texture).context("retrieving luma Metal texture")?;+ let cb_cr_metal_texture = CVMetalTextureGetTexture(&cb_cr_texture)+ .context("retrieving chroma Metal texture")?;++ // SAFETY: The size is copied from a live value, and both planes match their shader texture slots.+ // The frame completion handler retains the CoreVideo wrappers until GPU reads finish.+ unsafe {+ command_encoder.setVertexBytes_length_atIndex(+ ptr::NonNull::from(&texture_size).cast(),+ mem::size_of_val(&texture_size),+ SurfaceInputIndex::TextureSize as usize,+ );+ command_encoder.setFragmentTexture_atIndex(+ Some(&y_metal_texture),+ SurfaceInputIndex::YTexture as usize,+ );+ command_encoder.setFragmentTexture_atIndex(+ Some(&cb_cr_metal_texture),+ SurfaceInputIndex::CbCrTexture as usize,+ );+ }+ surface_textures.extend([y_texture, cb_cr_texture]);- command_encoder.draw_primitives_instanced_base_instance(- metal::MTLPrimitiveType::Triangle,- 0,- 6,- 1,- (first_surface + index) as u64,- );+ // SAFETY: Six unit vertices draw one instance within the uploaded scene's surface range.+ unsafe {+ command_encoder.drawPrimitives_vertexStart_vertexCount_instanceCount_baseInstance(+ MTLPrimitiveType::Triangle,+ 0,+ 6,+ 1,+ first_surface + index,+ );+ }}+ Ok(())}}-fn new_command_encoder_for_texture<'a>(- command_buffer: &'a metal::CommandBufferRef,- texture: &'a metal::TextureRef,+fn new_command_encoder_for_texture(+ command_buffer: &ProtocolObject<dyn MTLCommandBuffer>,+ texture: &ProtocolObject<dyn MTLTexture>,viewport_size: Size<DevicePixels>,- clear_color: Option<metal::MTLClearColor>,-) -> &'a metal::RenderCommandEncoderRef {- let render_pass_descriptor = metal::RenderPassDescriptor::new();- let color_attachment = render_pass_descriptor- .color_attachments()- .object_at(0)- .unwrap();- color_attachment.set_texture(Some(texture));- color_attachment.set_store_action(metal::MTLStoreAction::Store);+ clear_color: Option<MTLClearColor>,+) -> Result<Retained<ProtocolObject<dyn MTLRenderCommandEncoder>>> {+ let render_pass_descriptor = MTLRenderPassDescriptor::new();+ // SAFETY: Index zero is within the render pass's color attachment array.+ let color_attachment = unsafe {+ render_pass_descriptor+ .colorAttachments()+ .objectAtIndexedSubscript(0)+ };+ color_attachment.setTexture(Some(texture));+ color_attachment.setStoreAction(MTLStoreAction::Store);if let Some(clear_color) = clear_color {- color_attachment.set_load_action(metal::MTLLoadAction::Clear);- color_attachment.set_clear_color(clear_color);+ color_attachment.setLoadAction(MTLLoadAction::Clear);+ color_attachment.setClearColor(clear_color);} else {- color_attachment.set_load_action(metal::MTLLoadAction::Load);+ color_attachment.setLoadAction(MTLLoadAction::Load);}- let command_encoder = command_buffer.new_render_command_encoder(render_pass_descriptor);- command_encoder.set_viewport(metal::MTLViewport {+ let command_encoder = command_buffer+ .renderCommandEncoderWithDescriptor(&render_pass_descriptor)+ .context("creating render command encoder")?;+ command_encoder.setViewport(MTLViewport {originX: 0.0,originY: 0.0,width: i32::from(viewport_size.width) as f64,@@ -1333,149 +1443,154 @@ fn new_command_encoder_for_texture<'a>(znear: 0.0,zfar: 1.0,});- command_encoder+ Ok(command_encoder)}#[cfg(any(test, feature = "bench-support", feature = "test-support"))]-fn read_texture_to_image(texture: &metal::TextureRef) -> Result<RgbaImage> {+fn read_texture_to_image(texture: &ProtocolObject<dyn MTLTexture>) -> Result<RgbaImage> {let width = texture.width() as u32;let height = texture.height() as u32;let bytes_per_row = width as usize * 4;let mut pixels = vec![0u8; height as usize * bytes_per_row];- let region = metal::MTLRegion {- origin: metal::MTLOrigin { x: 0, y: 0, z: 0 },- size: metal::MTLSize {- width: width as u64,- height: height as u64,+ let region = MTLRegion {+ origin: MTLOrigin { x: 0, y: 0, z: 0 },+ size: MTLSize {+ width: width as usize,+ height: height as usize,depth: 1,},};- texture.get_bytes(- pixels.as_mut_ptr() as *mut std::ffi::c_void,- bytes_per_row as u64,- region,- 0,- );+ unsafe {+ texture.getBytes_bytesPerRow_fromRegion_mipmapLevel(+ ptr::NonNull::from(pixels.as_mut_slice()).cast(),+ bytes_per_row,+ region,+ 0,+ );+ }// Convert BGRA to RGBA (swap B and R channels)for chunk in pixels.chunks_exact_mut(4) {chunk.swap(0, 2);}- RgbaImage::from_raw(width, height, pixels).context("failed to create RgbaImage from pixel data")+ RgbaImage::from_raw(width, height, pixels).context("creating RGBA image from pixel data")}fn build_pipeline_state(- device: &metal::DeviceRef,- library: &metal::LibraryRef,+ device: &ProtocolObject<dyn MTLDevice>,+ library: &ProtocolObject<dyn MTLLibrary>,label: &str,vertex_fn_name: &str,fragment_fn_name: &str,- pixel_format: metal::MTLPixelFormat,-) -> metal::RenderPipelineState {+ pixel_format: MTLPixelFormat,+) -> Result<Retained<ProtocolObject<dyn MTLRenderPipelineState>>> {let vertex_fn = library- .get_function(vertex_fn_name, None)- .expect("error locating vertex function");+ .newFunctionWithName(&NSString::from_str(vertex_fn_name))+ .with_context(|| format!("locating vertex function {vertex_fn_name}"))?;let fragment_fn = library- .get_function(fragment_fn_name, None)- .expect("error locating fragment function");-- let descriptor = metal::RenderPipelineDescriptor::new();- descriptor.set_label(label);- descriptor.set_vertex_function(Some(vertex_fn.as_ref()));- descriptor.set_fragment_function(Some(fragment_fn.as_ref()));- let color_attachment = descriptor.color_attachments().object_at(0).unwrap();- color_attachment.set_pixel_format(pixel_format);- color_attachment.set_blending_enabled(true);- color_attachment.set_rgb_blend_operation(metal::MTLBlendOperation::Add);- color_attachment.set_alpha_blend_operation(metal::MTLBlendOperation::Add);- color_attachment.set_source_rgb_blend_factor(metal::MTLBlendFactor::SourceAlpha);- color_attachment.set_source_alpha_blend_factor(metal::MTLBlendFactor::One);- color_attachment.set_destination_rgb_blend_factor(metal::MTLBlendFactor::OneMinusSourceAlpha);- color_attachment.set_destination_alpha_blend_factor(metal::MTLBlendFactor::OneMinusSourceAlpha);+ .newFunctionWithName(&NSString::from_str(fragment_fn_name))+ .with_context(|| format!("locating fragment function {fragment_fn_name}"))?;++ let descriptor = MTLRenderPipelineDescriptor::new();+ descriptor.setLabel(Some(&NSString::from_str(label)));+ descriptor.setVertexFunction(Some(vertex_fn.as_ref()));+ descriptor.setFragmentFunction(Some(fragment_fn.as_ref()));+ // SAFETY: Index zero is within the pipeline's color attachment array.+ let color_attachment = unsafe { descriptor.colorAttachments().objectAtIndexedSubscript(0) };+ color_attachment.setPixelFormat(pixel_format);+ color_attachment.setBlendingEnabled(true);+ color_attachment.setRgbBlendOperation(MTLBlendOperation::Add);+ color_attachment.setAlphaBlendOperation(MTLBlendOperation::Add);+ color_attachment.setSourceRGBBlendFactor(MTLBlendFactor::SourceAlpha);+ color_attachment.setSourceAlphaBlendFactor(MTLBlendFactor::One);+ color_attachment.setDestinationRGBBlendFactor(MTLBlendFactor::OneMinusSourceAlpha);+ color_attachment.setDestinationAlphaBlendFactor(MTLBlendFactor::OneMinusSourceAlpha);device- .new_render_pipeline_state(&descriptor)- .expect("could not create render pipeline state")+ .newRenderPipelineStateWithDescriptor_error(&descriptor)+ .with_context(|| format!("creating {label} render pipeline"))}fn build_path_sprite_pipeline_state(- device: &metal::DeviceRef,- library: &metal::LibraryRef,+ device: &ProtocolObject<dyn MTLDevice>,+ library: &ProtocolObject<dyn MTLLibrary>,label: &str,vertex_fn_name: &str,fragment_fn_name: &str,- pixel_format: metal::MTLPixelFormat,-) -> metal::RenderPipelineState {+ pixel_format: MTLPixelFormat,+) -> Result<Retained<ProtocolObject<dyn MTLRenderPipelineState>>> {let vertex_fn = library- .get_function(vertex_fn_name, None)- .expect("error locating vertex function");+ .newFunctionWithName(&NSString::from_str(vertex_fn_name))+ .with_context(|| format!("locating vertex function {vertex_fn_name}"))?;let fragment_fn = library- .get_function(fragment_fn_name, None)- .expect("error locating fragment function");-- let descriptor = metal::RenderPipelineDescriptor::new();- descriptor.set_label(label);- descriptor.set_vertex_function(Some(vertex_fn.as_ref()));- descriptor.set_fragment_function(Some(fragment_fn.as_ref()));- let color_attachment = descriptor.color_attachments().object_at(0).unwrap();- color_attachment.set_pixel_format(pixel_format);- color_attachment.set_blending_enabled(true);- color_attachment.set_rgb_blend_operation(metal::MTLBlendOperation::Add);- color_attachment.set_alpha_blend_operation(metal::MTLBlendOperation::Add);- color_attachment.set_source_rgb_blend_factor(metal::MTLBlendFactor::One);- color_attachment.set_source_alpha_blend_factor(metal::MTLBlendFactor::One);- color_attachment.set_destination_rgb_blend_factor(metal::MTLBlendFactor::OneMinusSourceAlpha);- color_attachment.set_destination_alpha_blend_factor(metal::MTLBlendFactor::OneMinusSourceAlpha);+ .newFunctionWithName(&NSString::from_str(fragment_fn_name))+ .with_context(|| format!("locating fragment function {fragment_fn_name}"))?;++ let descriptor = MTLRenderPipelineDescriptor::new();+ descriptor.setLabel(Some(&NSString::from_str(label)));+ descriptor.setVertexFunction(Some(vertex_fn.as_ref()));+ descriptor.setFragmentFunction(Some(fragment_fn.as_ref()));+ // SAFETY: Index zero is within the pipeline's color attachment array.+ let color_attachment = unsafe { descriptor.colorAttachments().objectAtIndexedSubscript(0) };+ color_attachment.setPixelFormat(pixel_format);+ color_attachment.setBlendingEnabled(true);+ color_attachment.setRgbBlendOperation(MTLBlendOperation::Add);+ color_attachment.setAlphaBlendOperation(MTLBlendOperation::Add);+ color_attachment.setSourceRGBBlendFactor(MTLBlendFactor::One);+ color_attachment.setSourceAlphaBlendFactor(MTLBlendFactor::One);+ color_attachment.setDestinationRGBBlendFactor(MTLBlendFactor::OneMinusSourceAlpha);+ color_attachment.setDestinationAlphaBlendFactor(MTLBlendFactor::OneMinusSourceAlpha);device- .new_render_pipeline_state(&descriptor)- .expect("could not create render pipeline state")+ .newRenderPipelineStateWithDescriptor_error(&descriptor)+ .with_context(|| format!("creating {label} render pipeline"))}fn build_path_rasterization_pipeline_state(- device: &metal::DeviceRef,- library: &metal::LibraryRef,+ device: &ProtocolObject<dyn MTLDevice>,+ library: &ProtocolObject<dyn MTLLibrary>,label: &str,vertex_fn_name: &str,fragment_fn_name: &str,- pixel_format: metal::MTLPixelFormat,+ pixel_format: MTLPixelFormat,path_sample_count: u32,-) -> metal::RenderPipelineState {+) -> Result<Retained<ProtocolObject<dyn MTLRenderPipelineState>>> {let vertex_fn = library- .get_function(vertex_fn_name, None)- .expect("error locating vertex function");+ .newFunctionWithName(&NSString::from_str(vertex_fn_name))+ .with_context(|| format!("locating vertex function {vertex_fn_name}"))?;let fragment_fn = library- .get_function(fragment_fn_name, None)- .expect("error locating fragment function");+ .newFunctionWithName(&NSString::from_str(fragment_fn_name))+ .with_context(|| format!("locating fragment function {fragment_fn_name}"))?;- let descriptor = metal::RenderPipelineDescriptor::new();- descriptor.set_label(label);- descriptor.set_vertex_function(Some(vertex_fn.as_ref()));- descriptor.set_fragment_function(Some(fragment_fn.as_ref()));+ let descriptor = MTLRenderPipelineDescriptor::new();+ descriptor.setLabel(Some(&NSString::from_str(label)));+ descriptor.setVertexFunction(Some(vertex_fn.as_ref()));+ descriptor.setFragmentFunction(Some(fragment_fn.as_ref()));if path_sample_count > 1 {- descriptor.set_raster_sample_count(path_sample_count as _);- descriptor.set_alpha_to_coverage_enabled(false);+ descriptor.setRasterSampleCount(path_sample_count as _);+ descriptor.setAlphaToCoverageEnabled(false);}- let color_attachment = descriptor.color_attachments().object_at(0).unwrap();- color_attachment.set_pixel_format(pixel_format);- color_attachment.set_blending_enabled(true);- color_attachment.set_rgb_blend_operation(metal::MTLBlendOperation::Add);- color_attachment.set_alpha_blend_operation(metal::MTLBlendOperation::Add);- color_attachment.set_source_rgb_blend_factor(metal::MTLBlendFactor::One);- color_attachment.set_source_alpha_blend_factor(metal::MTLBlendFactor::One);- color_attachment.set_destination_rgb_blend_factor(metal::MTLBlendFactor::OneMinusSourceAlpha);- color_attachment.set_destination_alpha_blend_factor(metal::MTLBlendFactor::OneMinusSourceAlpha);+ // SAFETY: Index zero is within the pipeline's color attachment array.+ let color_attachment = unsafe { descriptor.colorAttachments().objectAtIndexedSubscript(0) };+ color_attachment.setPixelFormat(pixel_format);+ color_attachment.setBlendingEnabled(true);+ color_attachment.setRgbBlendOperation(MTLBlendOperation::Add);+ color_attachment.setAlphaBlendOperation(MTLBlendOperation::Add);+ color_attachment.setSourceRGBBlendFactor(MTLBlendFactor::One);+ color_attachment.setSourceAlphaBlendFactor(MTLBlendFactor::One);+ color_attachment.setDestinationRGBBlendFactor(MTLBlendFactor::OneMinusSourceAlpha);+ color_attachment.setDestinationAlphaBlendFactor(MTLBlendFactor::OneMinusSourceAlpha);device- .new_render_pipeline_state(&descriptor)- .expect("could not create render pipeline state")+ .newRenderPipelineStateWithDescriptor_error(&descriptor)+ .with_context(|| format!("creating {label} render pipeline"))}#[derive(Clone)]struct InstanceBinding {- buffer: metal::Buffer,+ buffer: Retained<ProtocolObject<dyn MTLBuffer>>,offset: usize,}@@ -1503,7 +1618,7 @@ fn write_instances(scene: &Scene, writer: &mut InstanceBufferWriter) -> Result<I}struct InstanceBufferWriter {- device: metal::Device,+ device: Retained<ProtocolObject<dyn MTLDevice>>,pool: Arc<Mutex<InstanceBufferPool>>,unified_memory: bool,filled: Vec<(InstanceBuffer, usize)>,@@ -1513,19 +1628,19 @@ struct InstanceBufferWriter {impl InstanceBufferWriter {fn new(- device: &metal::Device,+ device: &ProtocolObject<dyn MTLDevice>,pool: &Arc<Mutex<InstanceBufferPool>>,unified_memory: bool,- ) -> Self {- let current = pool.lock().acquire(device, unified_memory);- Self {- device: device.clone(),+ ) -> Result<Self> {+ let current = pool.lock().acquire(device, unified_memory)?;+ Ok(Self {+ device: device.retain(),pool: pool.clone(),unified_memory,filled: Vec::new(),current,offset: 0,- }+ })}fn allocate<T>(&mut self, count: usize) -> Result<(InstanceBinding, &mut [MaybeUninit<T>])> {@@ -1541,10 +1656,15 @@ impl InstanceBufferWriter {buffer: self.current.metal_buffer.clone(),offset,};- // Safety: the reservation lies within a buffer this frame owns- // exclusively, and never overlaps one handed out earlier.+ // SAFETY: The aligned reservation lies within this frame's exclusively owned buffer and does not overlap prior writes.let values = unsafe {- let start = (self.current.metal_buffer.contents() as *mut u8).add(offset);+ let start = self+ .current+ .metal_buffer+ .contents()+ .as_ptr()+ .cast::<u8>()+ .add(offset);slice::from_raw_parts_mut(start.cast::<MaybeUninit<T>>(), count)};Ok((binding, values))@@ -1552,6 +1672,7 @@ impl InstanceBufferWriter {fn write<T>(&mut self, values: &[T]) -> Result<InstanceBinding> {let (binding, destination) = self.allocate::<T>(values.len())?;+ // SAFETY: The disjoint source and destination hold the same number of T values, and the destination stays MaybeUninit.unsafe {ptr::copy_nonoverlapping(values.as_ptr(),@@ -1590,7 +1711,7 @@ impl InstanceBufferWriter {log::info!("increased instance buffer size to {buffer_size}");pool.reset(buffer_size);}- let buffer = pool.acquire(&self.device, self.unified_memory);+ let buffer = pool.acquire(&self.device, self.unified_memory)?;drop(pool);let filled = mem::replace(&mut self.current, buffer);@@ -1613,15 +1734,15 @@ impl InstanceBufferWriter {if *written == 0 {continue;}- buffer.metal_buffer.did_modify_range(NSRange {+ buffer.metal_buffer.didModifyRange(NSRange {location: 0,- length: *written as NSUInteger,+ length: *written,});}if offset > 0 {- current.metal_buffer.did_modify_range(NSRange {+ current.metal_buffer.didModifyRange(NSRange {location: 0,- length: offset as NSUInteger,+ length: offset,});}}@@ -1699,10 +1820,10 @@ pub struct MetalHeadlessRenderer {#[cfg(any(test, feature = "bench-support", feature = "test-support"))]impl MetalHeadlessRenderer {- pub fn new() -> Self {+ pub fn new() -> Result<Self> {let instance_buffer_pool = Arc::new(Mutex::new(InstanceBufferPool::default()));- let renderer = MetalRenderer::new_headless(instance_buffer_pool);- Self { renderer }+ let renderer = MetalRenderer::new_headless(instance_buffer_pool)?;+ Ok(Self { renderer })}}@@ -1734,11 +1855,13 @@ mod tests {CVPixelBufferGetBytesPerRowOfPlane, CVPixelBufferLockBaseAddress, CVPixelBufferLockFlags,CVPixelBufferUnlockBaseAddress, kCVPixelBufferIOSurfacePropertiesKey,};+ use objc2_metal::MTLCommandBufferStatus;#[test]fn render_core_video_surface() {+ let surface_properties_key = unsafe { kCVPixelBufferIOSurfacePropertiesKey };let attributes = CFDictionary::from_slices(- &[unsafe { kCVPixelBufferIOSurfacePropertiesKey }],+ &[surface_properties_key],&[&*CFDictionary::<CFType, CFType>::empty()],);let mut image_buffer = ptr::null_mut();@@ -1755,8 +1878,8 @@ mod tests {},kCVReturnSuccess);- let image_buffer =- unsafe { CFRetained::from_raw(ptr::NonNull::new(image_buffer).unwrap()) };+ let image_buffer = ptr::NonNull::new(image_buffer).unwrap();+ let image_buffer = unsafe { CFRetained::from_raw(image_buffer) };unsafe {assert_eq!(CVPixelBufferLockBaseAddress(&image_buffer, CVPixelBufferLockFlags::empty()),@@ -1788,7 +1911,9 @@ mod tests {drop(image_buffer);scene.finish();- let mut renderer = MetalRenderer::new_headless(Arc::new(Mutex::new(Default::default())));+ let mut renderer =+ MetalRenderer::new_headless(Arc::new(Mutex::new(InstanceBufferPool::default())))+ .unwrap();let image = renderer.render_scene_to_image(&scene, size(DevicePixels(16), DevicePixels(16))).unwrap();@@ -1798,5 +1923,41 @@ mod tests {assert!(blue.abs_diff(128) <= 2);assert_eq!(*alpha, 255);}++ let descriptor = MTLTextureDescriptor::new();+ unsafe {+ descriptor.setWidth(16);+ descriptor.setHeight(16);+ }+ descriptor.setPixelFormat(MTLPixelFormat::BGRA8Unorm);+ descriptor.setUsage(MTLTextureUsage::RenderTarget);+ let uses_shared_storage = cfg!(target_os = "ios") || renderer.is_apple_gpu;+ descriptor.setStorageMode(if uses_shared_storage {+ MTLStorageMode::Shared+ } else {+ MTLStorageMode::Managed+ });+ let target_texture = renderer+ .device+ .newTextureWithDescriptor(&descriptor)+ .unwrap();+ let command_buffer = renderer+ .render_frame(+ &scene,+ &target_texture,+ size(DevicePixels(16), DevicePixels(16)),+ )+ .unwrap();+ if !uses_shared_storage {+ let blit = command_buffer.blitCommandEncoder().unwrap();+ blit.synchronizeResource(ProtocolObject::from_ref(&*target_texture));+ blit.endEncoding();+ }+ drop(scene);+ drop(renderer);+ command_buffer.commit();+ command_buffer.waitUntilCompleted();+ assert_eq!(command_buffer.status(), MTLCommandBufferStatus::Completed);+ assert_eq!(read_texture_to_image(&target_texture).unwrap(), image);}}diff --git a/crates/gpui_ios/src/ios/window.rs b/crates/gpui_ios/src/ios/window.rsindex e1556654f97..3e506946019 100644--- a/crates/gpui_ios/src/ios/window.rs+++ b/crates/gpui_ios/src/ios/window.rs@@ -326,6 +326,16 @@ impl IosWindow {let layer = view.layer();layer.setContentsScale(scale);+ let mut renderer = MetalRenderer::from_layer(+ MetalContext::default(),+ layer+ .downcast_ref::<CAMetalLayer>()+ .ok_or_else(|| anyhow::anyhow!("UIKit view must have a CAMetalLayer"))?,+ false,+ )?;+ let pixel_w = (screen_bounds_cg.size.width * scale) as i32;+ let pixel_h = (screen_bounds_cg.size.height * scale) as i32;+ renderer.update_drawable_size(size(DevicePixels(pixel_w), DevicePixels(pixel_h)));// Auto-resize the Metal view when the parent view changes size// (e.g. rotation). UIViewAutoresizingFlexibleWidth | UIViewAutoresizingFlexibleHeight@@ -406,17 +416,6 @@ impl IosWindow {text_input_view.setUserInteractionEnabled(true);view.addSubview(&text_input_view);- let pixel_w = (screen_bounds_cg.size.width * scale) as i32;- let pixel_h = (screen_bounds_cg.size.height * scale) as i32;- let mut renderer = MetalRenderer::from_layer(- MetalContext::default(),- layer- .downcast_ref::<CAMetalLayer>()- .ok_or_else(|| anyhow::anyhow!("UIKit view must have a CAMetalLayer"))?,- false,- );- renderer.update_drawable_size(size(DevicePixels(pixel_w), DevicePixels(pixel_h)));-let state = IosWindowState {platform: Rc::downgrade(platform),keyboard_observers: RefCell::default(),diff --git a/crates/gpui_macos/src/platform.rs b/crates/gpui_macos/src/platform.rsindex 8fd20666b09..798262d47e3 100644--- a/crates/gpui_macos/src/platform.rs+++ b/crates/gpui_macos/src/platform.rs@@ -770,7 +770,7 @@ impl Platform for MacPlatform {background_executor,renderer_context,self.1,- )))+ )?))}fn window_appearance(&self) -> WindowAppearance {diff --git a/crates/gpui_macos/src/window.rs b/crates/gpui_macos/src/window.rsindex f2208d35ecd..0ef42cb538a 100644--- a/crates/gpui_macos/src/window.rs+++ b/crates/gpui_macos/src/window.rs@@ -4,7 +4,6 @@ use crate::{kTISPropertyInputSourceIsASCIICapable, kTISPropertyInputSourceType, kTISTypeKeyboardInputMode,ns_string, renderer,};-#[cfg(any(test, feature = "test-support"))]use anyhow::Result;use block2::RcBlock;use dispatch2::DispatchQueue;@@ -959,8 +958,9 @@ impl MacWindow {background_executor: BackgroundExecutor,renderer_context: renderer::Context,marker: MainThreadMarker,- ) -> Self {+ ) -> Result<Self> {autoreleasepool(|_| unsafe {+ let renderer = renderer::new_renderer(renderer_context, false, use_display_p3)?;let allows_automatic_window_tabbing = tabbing_identifier.is_some();if allows_automatic_window_tabbing {let () = msg_send![class!(NSWindow), setAllowsAutomaticWindowTabbing: Bool::YES];@@ -1072,14 +1072,7 @@ impl MacWindow {cursor_style: CursorStyle::Arrow,cursor_visible,frame_source: None,- renderer: renderer::new_renderer(- renderer_context,- native_window as *mut _,- native_view as *mut _,- bounds.size.map(|pixels| pixels.as_f32()),- false,- use_display_p3,- ),+ renderer,request_frame_callback: None,event_callback: None,activate_callback: None,@@ -1285,7 +1278,7 @@ impl MacWindow {window_state.sheet_parent = sheet_parent;}- window+ Ok(window)})}diff --git a/crates/gpui_platform/Cargo.toml b/crates/gpui_platform/Cargo.tomlindex ace83f52cde..6245202a714 100644--- a/crates/gpui_platform/Cargo.toml+++ b/crates/gpui_platform/Cargo.toml@@ -26,6 +26,11 @@ runtime_shaders = ["gpui_macos/runtime_shaders", "gpui_ios/runtime_shaders"]wayland = ["gpui_linux/wayland"]x11 = ["gpui_linux/x11"]+[[bench]]+name = "atlas_upload"+harness = false+required-features = ["bench-support"]+[[bench]]name = "focus_cleanup"path = "../gpui/benches/focus_cleanup.rs"diff --git a/crates/gpui_platform/benches/atlas_upload.rs b/crates/gpui_platform/benches/atlas_upload.rsnew file mode 100644index 00000000000..8ede1a5bd5c--- /dev/null+++ b/crates/gpui_platform/benches/atlas_upload.rs@@ -0,0 +1,264 @@+use std::{borrow::Cow, hint::black_box, sync::Arc, time::Duration};++use anyhow::{Context as _, Result};+use bench_metrics::MetricReport;+use criterion::{BatchSize, BenchmarkId, Criterion, Throughput};+use gpui::{+ AtlasKey, AtlasTextureId, AtlasTextureKind, AtlasTile, BenchMeasurement, Bounds, ContentMask,+ Corners, DevicePixels, Hsla, ImageId, MonochromeSprite, PaddedBool32, PlatformAtlas,+ PlatformHeadlessRenderer, Point, PolychromeSprite, RenderImageParams, RenderSvgParams,+ ScaledPixels, Scene, SharedString, Size, TransformationMatrix, size,+};++struct Entry {+ key: AtlasKey,+ bytes: Vec<u8>,+}++struct Fixture {+ renderer: Box<dyn PlatformHeadlessRenderer>,+ atlas: Arc<dyn PlatformAtlas>,+ dimensions: Size<DevicePixels>,+ seed: Entry,+ entries: Vec<Entry>,+}++struct Batch<'a> {+ fixture: &'a Fixture,+ texture_id: AtlasTextureId,+ misses: bool,+ builder_calls: usize,+ tiles: Vec<AtlasTile>,+}++fn atlas_upload(criterion: &mut Criterion<BenchMeasurement>) {+ assert!(cfg!(target_os = "macos"), "this benchmark requires Metal");+ assert!(!cfg!(debug_assertions), "use --profile release-fast");+ let mut group = criterion.benchmark_group("atlas_upload");+ for (kind, format) in [+ (AtlasTextureKind::Monochrome, "a8"),+ (AtlasTextureKind::Polychrome, "bgra8"),+ ] {+ for (width, height, count) in [(1, 1, 128), (3, 2, 128), (16, 16, 128), (256, 256, 8)] {+ let dimensions = size(DevicePixels(width), DevicePixels(height));+ let mut fixture = Fixture::new(kind, dimensions, count).expect("create Metal fixture");+ fixture.validate_pixels().expect("validate atlas pixels");+ group.throughput(Throughput::Elements(count as u64));+ for (misses, mode) in [(true, "miss"), (false, "hit")] {+ let report = MetricReport::new();+ let id = BenchmarkId::new(+ format!("{mode}_{format}"),+ format!("{width}x{height}_{count}"),+ );+ group.bench_function(id, |bencher| {+ let mut iterations = 0;+ report.discard_pending();+ bencher.iter_batched_ref(+ || {+ iterations += 1;+ fixture.prepare(misses).expect("prepare atlas batch")+ },+ |batch| batch.run().expect("insert atlas batch"),+ BatchSize::PerIteration,+ );+ report.record_sample(iterations * count as u64);+ });+ eprintln!("{mode}_{format}/{width}x{height}: secondary metrics per atlas lookup");+ report.print(" ");+ }+ }+ }+ group.finish();+}++impl Fixture {+ fn new(kind: AtlasTextureKind, dimensions: Size<DevicePixels>, count: usize) -> Result<Self> {+ let renderer = gpui_platform::current_headless_renderer()?.context("Metal unavailable")?;+ let atlas = renderer.sprite_atlas();+ Ok(Self {+ renderer,+ atlas,+ dimensions,+ seed: make_entry(kind, dimensions, count),+ entries: (0..count)+ .map(|index| make_entry(kind, dimensions, index))+ .collect(),+ })+ }++ fn insert(&self, entry: &Entry, builder_calls: &mut usize) -> Result<AtlasTile> {+ self.atlas+ .get_or_insert_with(black_box(entry.key.clone()), &mut || {+ *builder_calls += 1;+ Ok(Some((+ black_box(self.dimensions),+ Cow::Borrowed(black_box(&entry.bytes)),+ )))+ })?+ .context("missing atlas tile")+ }++ fn prepare(&self, misses: bool) -> Result<Batch<'_>> {+ for entry in &self.entries {+ self.atlas.remove(&entry.key);+ }+ self.atlas.remove(&self.seed.key);+ let mut builder_calls = 0;+ let seed = self.insert(&self.seed, &mut builder_calls)?;+ assert_eq!(builder_calls, 1);+ if !misses {+ for entry in &self.entries {+ let tile = self.insert(entry, &mut builder_calls)?;+ assert_eq!(tile.texture_id, seed.texture_id);+ }+ assert_eq!(builder_calls, self.entries.len() + 1);+ }+ Ok(Batch {+ fixture: self,+ texture_id: seed.texture_id,+ misses,+ builder_calls: 0,+ tiles: Vec::with_capacity(self.entries.len()),+ })+ }++ fn validate_pixels(&mut self) -> Result<()> {+ let tiles = {+ let mut batch = self.prepare(true)?;+ batch.run()?;+ batch.tiles.clone()+ };+ for (entry, tile) in self.entries.iter().zip(tiles) {+ let scene = tile_scene(tile);+ let image = self+ .renderer+ .render_scene_to_image(&scene, self.dimensions)?;+ let expected = match tile.texture_id.kind {+ AtlasTextureKind::Monochrome => entry+ .bytes+ .iter()+ .flat_map(|&alpha| [alpha, alpha, alpha, 255])+ .collect::<Vec<_>>(),+ AtlasTextureKind::Polychrome => entry+ .bytes+ .chunks_exact(4)+ .flat_map(|pixel| [pixel[2], pixel[1], pixel[0], 255])+ .collect(),+ AtlasTextureKind::Subpixel => unreachable!(),+ };+ assert_eq!(image.as_raw(), &expected);+ }+ let mut batch = self.prepare(false)?;+ batch.run()?;+ Ok(())+ }+}++impl Batch<'_> {+ fn run(&mut self) -> Result<()> {+ for entry in &self.fixture.entries {+ self.tiles+ .push(self.fixture.insert(entry, &mut self.builder_calls)?);+ }+ black_box(&self.tiles);+ Ok(())+ }+}++impl Drop for Batch<'_> {+ fn drop(&mut self) {+ if std::thread::panicking() {+ return;+ }+ let count = self.fixture.entries.len();+ assert_eq!(self.tiles.len(), count);+ assert_eq!(self.builder_calls, if self.misses { count } else { 0 });+ for tile in &self.tiles {+ assert_eq!(tile.texture_id, self.texture_id);+ assert_eq!(tile.bounds.size, self.fixture.dimensions);+ }+ }+}++fn make_entry(kind: AtlasTextureKind, dimensions: Size<DevicePixels>, index: usize) -> Entry {+ let key = match kind {+ AtlasTextureKind::Monochrome => AtlasKey::Svg(RenderSvgParams {+ path: SharedString::from(format!("atlas-upload-{index}")),+ size: dimensions,+ }),+ AtlasTextureKind::Polychrome => AtlasKey::Image(RenderImageParams {+ image_id: ImageId(index),+ frame_index: 0,+ }),+ AtlasTextureKind::Subpixel => unreachable!(),+ };+ let mut bytes = Vec::new();+ for row in 0..dimensions.height.0 {+ for column in 0..dimensions.width.0 {+ let value = (index as u8)+ .wrapping_mul(73)+ .wrapping_add((row as u8).wrapping_mul(31))+ .wrapping_add((column as u8).wrapping_mul(17));+ match kind {+ AtlasTextureKind::Monochrome => bytes.push(value),+ AtlasTextureKind::Polychrome => {+ bytes.extend([value, value.wrapping_add(53), value.wrapping_add(107), 255])+ }+ AtlasTextureKind::Subpixel => unreachable!(),+ }+ }+ }+ Entry { key, bytes }+}++fn tile_scene(tile: AtlasTile) -> Scene {+ let bounds = Bounds {+ origin: Point::default(),+ size: size(+ ScaledPixels(tile.bounds.size.width.0 as f32),+ ScaledPixels(tile.bounds.size.height.0 as f32),+ ),+ };+ let content_mask = ContentMask { bounds };+ let mut scene = Scene::default();+ match tile.texture_id.kind {+ AtlasTextureKind::Monochrome => scene.insert_primitive(MonochromeSprite {+ order: 0,+ pad: 0,+ tile,+ bounds,+ content_mask,+ color: Hsla {+ h: 0.0,+ s: 0.0,+ l: 1.0,+ a: 1.0,+ },+ transformation: TransformationMatrix::default(),+ }),+ AtlasTextureKind::Polychrome => scene.insert_primitive(PolychromeSprite {+ order: 0,+ pad: 0,+ tile,+ grayscale: PaddedBool32::from(false),+ opacity: 1.0,+ bounds,+ content_mask,+ corner_radii: Corners::default(),+ }),+ AtlasTextureKind::Subpixel => unreachable!(),+ }+ scene.finish();+ scene+}++gpui::bench_group! {+ name = benches;+ config = Criterion::default()+ .sample_size(30)+ .warm_up_time(Duration::from_secs(1))+ .measurement_time(Duration::from_secs(2))+ .without_plots();+ targets = atlas_upload+}+gpui::bench_main!(benches);diff --git a/crates/gpui_platform/src/gpui_platform.rs b/crates/gpui_platform/src/gpui_platform.rsindex c55da39b25f..5f328d1bcdd 100644--- a/crates/gpui_platform/src/gpui_platform.rs+++ b/crates/gpui_platform/src/gpui_platform.rs@@ -118,7 +118,7 @@ pub fn current_headless_renderer() -> anyhow::Result<Option<Box<dyn gpui::Platfo#[cfg(target_os = "macos")]{Ok(Some(Box::new(- gpui_macos::metal_renderer::MetalHeadlessRenderer::new(),+ gpui_macos::metal_renderer::MetalHeadlessRenderer::new()?,)))}diff --git a/tooling/xtask/src/workspace.rs b/tooling/xtask/src/workspace.rsindex 46d8da1f04c..7f87ddea582 100644--- a/tooling/xtask/src/workspace.rs+++ b/tooling/xtask/src/workspace.rs@@ -16,18 +16,18 @@ mod tests {};use anyhow::{Context as _, Result};- use cargo_metadata::{DependencyKind, Metadata, MetadataCommand};+ use cargo_metadata::{CargoOpt, DependencyKind, Metadata, MetadataCommand};use super::load_workspace;- /// Direct dependencies forbidden in workspace packages, paired with the reason shown on failure.- const FORBIDDEN_DIRECT_DEPENDENCIES: &[(&str, &str)] = &[+ const FORBIDDEN_OBJC_DEPENDENCIES: &[(&str, &str)] = &[("block", "use `block2` instead"),("cocoa","use `objc2-app-kit` and `objc2-foundation` instead",),("cocoa-foundation", "use `objc2-foundation` instead"),+ ("metal", "use `objc2-metal` and `objc2-quartz-core` instead"),("objc", "use `objc2` instead"),("objc-foundation", "use `objc2-foundation` instead"),("objc_id", "use `objc2::rc::Retained` instead"),@@ -53,21 +53,24 @@ mod tests {];#[test]- fn no_forbidden_direct_dependencies() -> Result<()> {- let workspace = load_workspace()?;- let violations = forbidden_direct_dependency_violations(&workspace)?;+ fn no_forbidden_objc_dependencies() -> Result<()> {+ let workspace = MetadataCommand::new()+ .features(CargoOpt::AllFeatures)+ .exec()+ .context("loading cargo metadata with all workspace features")?;+ let violations = forbidden_objc_dependency_violations(&workspace)?;assert_eq!(violations,Vec::<String>::new(),- "forbidden direct dependencies:\n{}",+ "forbidden Objective-C dependencies:\n{}",violations.join("\n"),);Ok(())}#[test]- fn forbidden_direct_dependencies_cover_manifest_declarations() -> Result<()> {+ fn forbidden_objc_dependencies_cover_manifests_and_transitive_packages() -> Result<()> {let fixture = tempfile::tempdir()?;for name in ["block",@@ -80,16 +83,21 @@ mod tests {"objc2","objc2-app-kit","objc2-foundation",+ "objc2-metal",+ "objc2-quartz-core","metal",+ "intermediate","workspace",] {let directory = fixture.path().join(name);fs::create_dir(&directory)?;fs::write(directory.join("lib.rs"), "")?;- let dependencies = if name == "metal" {- "[dependencies]\nobjc = { path = '../objc' }\n"- } else {- ""+ let dependencies = match name {+ "metal" => "[dependencies]\nobjc = { path = '../objc' }\n",+ "intermediate" => {+ "[dependencies]\nmetal = { path = '../metal', optional = true }\n"+ }+ _ => "",};fs::write(directory.join("Cargo.toml"),@@ -110,7 +118,8 @@ block2 = { path = "../block2" }objc2 = { path = "../objc2" }objc2-app-kit = { path = "../objc2-app-kit" }objc2-foundation = { path = "../objc2-foundation" }-metal = { path = "../metal" }+objc2-metal = { path = "../objc2-metal" }+objc2-quartz-core = { path = "../objc2-quartz-core" }"#,);let forbidden = r#"@@ -122,6 +131,9 @@ path = "../cocoa"[dependencies.cocoa-foundation]path = "../cocoa-foundation"optional = true+[dependencies.legacy_metal]+package = "metal"+path = "../metal"[target.'cfg(any())'.dependencies]objc = { path = "../objc" }[dev-dependencies]@@ -132,6 +144,7 @@ legacy_id = { workspace = true, optional = true }legacy_id = { package = "objc_id", path = "../objc_id" }objc = "0.1.0"unused_cocoa = { package = "cocoa", version = "0.1.0" }+unused_metal = { package = "metal", version = "0.1.0" }unused_objc2 = { package = "objc2", version = "0.1.0" }"#;fs::write(&manifest, format!("{allowed}{forbidden}"))?;@@ -139,7 +152,7 @@ unused_objc2 = { package = "objc2", version = "0.1.0" }command.manifest_path(&manifest).other_options(vec!["--offline".to_owned()]);- let mut violations = forbidden_direct_dependency_violations(&command.exec()?)?;+ let mut violations = forbidden_objc_dependency_violations(&command.exec()?)?;violations.sort();assert_eq!(violations,@@ -147,18 +160,42 @@ unused_objc2 = { package = "objc2", version = "0.1.0" }"Cargo.toml [workspace.dependencies]: `legacy_id` uses `objc_id`; use `objc2::rc::Retained` instead","Cargo.toml [workspace.dependencies]: `objc` uses `objc`; use `objc2` instead","Cargo.toml [workspace.dependencies]: `unused_cocoa` uses `cocoa`; use `objc2-app-kit` and `objc2-foundation` instead",+ "Cargo.toml [workspace.dependencies]: `unused_metal` uses `metal`; use `objc2-metal` and `objc2-quartz-core` instead","workspace directly depends on `block`; use `block2` instead","workspace directly depends on `cocoa-foundation`; use `objc2-foundation` instead","workspace directly depends on `cocoa`; use `objc2-app-kit` and `objc2-foundation` instead",+ "workspace directly depends on `metal`; use `objc2-metal` and `objc2-quartz-core` instead","workspace directly depends on `objc-foundation`; use `objc2-foundation` instead","workspace directly depends on `objc_id`; use `objc2::rc::Retained` instead","workspace directly depends on `objc`; use `objc2` instead",],"including renamed optional inactive-target build dependency",);+ fs::write(+ &manifest,+ format!(+ "{allowed}\n[target.'cfg(any())'.dependencies]\n\+ intermediate = {{ path = '../intermediate', optional = true }}\n\+ [features]\nlegacy = ['dep:intermediate', 'intermediate/metal']\n"+ ),+ )?;+ assert_eq!(+ forbidden_objc_dependency_violations(&command.exec()?)?,+ Vec::<String>::new(),+ );+ command.features(CargoOpt::AllFeatures);+ let mut violations = forbidden_objc_dependency_violations(&command.exec()?)?;+ violations.sort();+ assert_eq!(+ violations,+ [+ "dependency graph contains `metal`; use `objc2-metal` and `objc2-quartz-core` instead",+ "dependency graph contains `objc`; use `objc2` instead",+ ],+ );fs::write(&manifest, allowed)?;assert_eq!(- forbidden_direct_dependency_violations(&command.exec()?)?,+ forbidden_objc_dependency_violations(&command.exec()?)?,Vec::<String>::new(),);Ok(())@@ -240,11 +277,12 @@ unused_objc2 = { package = "objc2", version = "0.1.0" });}- fn forbidden_direct_dependency_violations(workspace: &Metadata) -> Result<Vec<String>> {+ fn forbidden_objc_dependency_violations(workspace: &Metadata) -> Result<Vec<String>> {let mut violations = Vec::new();+ let mut reported_dependencies = BTreeSet::new();for package in workspace.workspace_packages() {for dependency in &package.dependencies {- let Some((_, reason)) = FORBIDDEN_DIRECT_DEPENDENCIES+ let Some((_, reason)) = FORBIDDEN_OBJC_DEPENDENCIES.iter().find(|(name, _)| *name == dependency.name)else {@@ -254,6 +292,21 @@ unused_objc2 = { package = "objc2", version = "0.1.0" }"{} directly depends on `{}`; {reason}",package.name, dependency.name));+ reported_dependencies.insert(dependency.name.as_str());+ }+ }+ for package in &workspace.packages {+ let Some((_, reason)) = FORBIDDEN_OBJC_DEPENDENCIES+ .iter()+ .find(|(name, _)| *name == package.name.as_str())+ else {+ continue;+ };+ if reported_dependencies.insert(package.name.as_str()) {+ violations.push(format!(+ "dependency graph contains `{}`; {reason}",+ package.name,+ ));}}@@ -271,7 +324,7 @@ unused_objc2 = { package = "objc2", version = "0.1.0" }.get("package").and_then(toml::Value::as_str).unwrap_or(alias);- let Some((_, reason)) = FORBIDDEN_DIRECT_DEPENDENCIES+ let Some((_, reason)) = FORBIDDEN_OBJC_DEPENDENCIES.iter().find(|(forbidden, _)| *forbidden == name)else {