Skip to content

armgit / zed

Public Imported from GitHub
0

Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.

Remove `block` dependency from the tree (#65942)

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