diff --git a/Cargo.lock b/Cargo.lock index 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.toml index 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.toml index 23142d504f5..488d1dcab15 100644 --- a/crates/gpui_apple/Cargo.toml +++ b/crates/gpui_apple/Cargo.toml @@ -31,10 +31,8 @@ core-foundation.workspace = true core-foundation-sys.workspace = true core-graphics.workspace = true core-text = { workspace = true, optional = true } -derive_more.workspace = true -dispatch2.workspace = true +dispatch2 = { workspace = true, features = ["block2"] } etagere.workspace = true -foreign-types.workspace = true futures.workspace = true # WARNING: If you change this, you must also publish a new version of zed-font-kit to crates.io font-kit = { workspace = true, optional = true, features = ["source"] } @@ -43,14 +41,34 @@ image.workspace = true libc.workspace = true log.workspace = true mach2.workspace = true -metal.workspace = true objc2.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 = true parking_lot.workspace = true pathfinder_geometry = { workspace = true, optional = true } diff --git a/crates/gpui_apple/src/metal_atlas.rs b/crates/gpui_apple/src/metal_atlas.rs index 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>); impl MetalAtlas { - pub(crate) fn new(device: Device, supports_shared_storage: bool) -> Self { + pub(crate) fn new( + device: Retained>, + 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 { + pub(crate) fn metal_texture( + &self, + id: AtlasTextureId, + ) -> Option>> { Some(self.0.lock().backend.texture(id)?.metal_texture.clone()) } } struct MetalAtlasTextures { - device: AssertSend, + device: Retained>, supports_shared_storage: bool, monochrome_textures: AtlasTextureList, polychrome_textures: AtlasTextureList, @@ -58,11 +67,12 @@ impl AtlasBackend for MetalAtlasTextures { size: Size, bytes: &[u8], ) -> Result { - 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, texture_kind: AtlasTextureKind, - ) -> Option { + ) -> Result { { 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, kind: AtlasTextureKind, - ) -> &mut MetalAtlasTexture { + ) -> Result<&mut MetalAtlasTexture> { const DEFAULT_ATLAS_SIZE: Size = 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: Retained>, live_atlas_keys: u32, } @@ -226,28 +237,46 @@ impl MetalAtlasTexture { Some(tile) } - fn upload(&self, bounds: Bounds, 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, 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, + bytes: &'a [u8], + bytes_per_row: usize, +} + +impl<'a> AtlasUpload<'a> { + fn new(kind: AtlasTextureKind, size: Size, bytes: &'a [u8]) -> Result { + 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) -> etagere::Size { etagere::Size::new(size.width.into(), size.height.into()) } @@ -270,39 +337,13 @@ fn point_from_etagere(value: etagere::Point) -> Point { } } -#[derive(Deref, DerefMut)] -struct AssertSend(T); - -unsafe impl Send for AssertSend {} - #[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 { - 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) -> 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::>(); + 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 { + 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) -> 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.rs index 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 metal pub(crate) type PointF = gpui::Point; @@ -43,20 +50,17 @@ const MAX_INSTANCE_BUFFER_SIZE: usize = 256 * 1024 * 1024; pub type Context = Arc>; 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, transparent: bool, use_display_p3: bool, -) -> Renderer { +) -> Result { MetalRenderer::new(context, transparent, use_display_p3) } pub struct InstanceBufferPool { buffer_size: usize, - buffers: Vec, + buffers: Vec, } 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>, 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, 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 { + 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, + device: Retained>, + layer: Option>, is_apple_gpu: bool, is_unified_memory: bool, presents_with_transaction: bool, /// For headless rendering, tracks whether output should be opaque opaque: 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>, + paths_rasterization_pipeline_state: Retained>, + path_sprites_pipeline_state: Retained>, + shadows_pipeline_state: Retained>, + quads_pipeline_state: Retained>, + underlines_pipeline_state: Retained>, + monochrome_sprites_pipeline_state: Retained>, + polychrome_sprites_pipeline_state: Retained>, + surfaces_pipeline_state: Retained>, + unit_vertices: Retained>, instance_buffer_pool: Arc>, sprite_atlas: Arc, core_video_texture_cache: CFRetained, - path_intermediate_texture: Option, - path_intermediate_msaa_texture: Option, + path_intermediate_texture: Option>>, + path_intermediate_msaa_texture: Option>>, 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, + headless_render_target: Option>>, } #[repr(C)] @@ -154,9 +162,9 @@ impl MetalRenderer { instance_buffer_pool: Arc>, transparent: bool, use_display_p3: bool, - ) -> Self { - let device = Self::create_device(); - let layer = metal::MetalLayer::new(); + ) -> Result { + 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>, - 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::()) - } - .to_owned(); + ) -> Result { + 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, 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 Graphics let 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::() - ]; - } + 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>) -> Self { - let device = Self::create_device(); + pub fn new_headless(instance_buffer_pool: Arc>) -> Result { + 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>> { // 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>> { 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>> { + MTLCreateSystemDefaultDevice().context("accessing a compatible Metal device") } fn new_internal( - device: metal::Device, - layer: Option, + device: Retained>, + layer: Option>, opaque: bool, instance_buffer_pool: Arc>, - ) -> Self { + ) -> Result { #[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::>(), - 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) { 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) { + fn update_path_intermediate_textures(&mut self, size: Size) -> 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 Silicon let 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 = 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, viewport_size: Size, - ) -> Result { + ) -> Result>> { + 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| { - 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>| { + 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 = 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 presenting command_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 completion command_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, viewport_size: Size, - ) -> Result { + surface_textures: &mut Vec>, + ) -> Result>> { 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], writer: &mut InstanceBufferWriter, viewport_size: Size, - command_buffer: &metal::CommandBufferRef, + command_buffer: &ProtocolObject, ) -> Result { 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 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, instance_bindings: &InstanceBindings, viewport_size: Size, - command_encoder: &metal::RenderCommandEncoderRef, + command_encoder: &ProtocolObject, ) { 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 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, instance_bindings: &InstanceBindings, viewport_size: Size, - command_encoder: &metal::RenderCommandEncoderRef, + command_encoder: &ProtocolObject, ) { 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 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], writer: &mut InstanceBufferWriter, viewport_size: Size, - command_encoder: &metal::RenderCommandEncoderRef, + command_encoder: &ProtocolObject, ) -> 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 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, instance_bindings: &InstanceBindings, viewport_size: Size, - command_encoder: &metal::RenderCommandEncoderRef, + command_encoder: &ProtocolObject, ) { 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 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, instance_bindings: &InstanceBindings, viewport_size: Size, - command_encoder: &metal::RenderCommandEncoderRef, + command_encoder: &ProtocolObject, ) { 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 as *const _, - ); - command_encoder.set_vertex_bytes( - SpriteInputIndex::AtlasTextureSize as u64, - mem::size_of_val(&texture_size) as u64, - &texture_size as *const Size 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, instance_bindings: &InstanceBindings, viewport_size: Size, - command_encoder: &metal::RenderCommandEncoderRef, + command_encoder: &ProtocolObject, ) { 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 as *const _, - ); - command_encoder.set_vertex_bytes( - SpriteInputIndex::AtlasTextureSize as u64, - mem::size_of_val(&texture_size) as u64, - &texture_size as *const Size 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, - command_encoder: &metal::RenderCommandEncoderRef, - ) { + command_encoder: &ProtocolObject, + surface_textures: &mut Vec>, + ) -> 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 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> { + 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), + // 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}" ); - assert_eq!( - status, kCVReturnSuccess, - "failed to create CoreVideo Metal texture" - ); - CFRetained::::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); + 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")?; - command_encoder.set_vertex_bytes( - SurfaceInputIndex::TextureSize as u64, - mem::size_of_val(&texture_size) as u64, - &texture_size as *const Size 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 _, - )) - }); + // 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, + texture: &ProtocolObject, viewport_size: Size, - clear_color: Option, -) -> &'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, +) -> Result>> { + 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 { +fn read_texture_to_image(texture: &ProtocolObject) -> Result { 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, + library: &ProtocolObject, label: &str, vertex_fn_name: &str, fragment_fn_name: &str, - pixel_format: metal::MTLPixelFormat, -) -> metal::RenderPipelineState { + pixel_format: MTLPixelFormat, +) -> Result>> { 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 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); + 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, + library: &ProtocolObject, label: &str, vertex_fn_name: &str, fragment_fn_name: &str, - pixel_format: metal::MTLPixelFormat, -) -> metal::RenderPipelineState { + pixel_format: MTLPixelFormat, +) -> Result>> { 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 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); + 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, + library: &ProtocolObject, label: &str, vertex_fn_name: &str, fragment_fn_name: &str, - pixel_format: metal::MTLPixelFormat, + pixel_format: MTLPixelFormat, path_sample_count: u32, -) -> metal::RenderPipelineState { +) -> Result>> { 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>, offset: usize, } @@ -1503,7 +1618,7 @@ fn write_instances(scene: &Scene, writer: &mut InstanceBufferWriter) -> Result>, pool: Arc>, unified_memory: bool, filled: Vec<(InstanceBuffer, usize)>, @@ -1513,19 +1628,19 @@ struct InstanceBufferWriter { impl InstanceBufferWriter { fn new( - device: &metal::Device, + device: &ProtocolObject, pool: &Arc>, unified_memory: bool, - ) -> Self { - let current = pool.lock().acquire(device, unified_memory); - Self { - device: device.clone(), + ) -> Result { + 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(&mut self, count: usize) -> Result<(InstanceBinding, &mut [MaybeUninit])> { @@ -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::() + .add(offset); slice::from_raw_parts_mut(start.cast::>(), count) }; Ok((binding, values)) @@ -1552,6 +1672,7 @@ impl InstanceBufferWriter { fn write(&mut self, values: &[T]) -> Result { let (binding, destination) = self.allocate::(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 { 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::::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.rs index 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::() + .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::() - .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.rs index 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.rs index 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 { 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.toml index 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.rs new file mode 100644 index 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, +} + +struct Fixture { + renderer: Box, + atlas: Arc, + dimensions: Size, + seed: Entry, + entries: Vec, +} + +struct Batch<'a> { + fixture: &'a Fixture, + texture_id: AtlasTextureId, + misses: bool, + builder_calls: usize, + tiles: Vec, +} + +fn atlas_upload(criterion: &mut Criterion) { + 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, count: usize) -> Result { + 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 { + 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> { + 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::>(), + 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, 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.rs index 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 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::::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::::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::::new(), ); Ok(()) @@ -240,11 +277,12 @@ unused_objc2 = { package = "objc2", version = "0.1.0" } ); } - fn forbidden_direct_dependency_violations(workspace: &Metadata) -> Result> { + fn forbidden_objc_dependency_violations(workspace: &Metadata) -> Result> { 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 {