Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
use crate::metal_atlas::MetalAtlas;
use anyhow::{Context as _, Result};
use block2::RcBlock;
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::{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, mem, mem::MaybeUninit, ops::Range, ptr, slice, sync::Arc};
// Exported to metal
pub(crate) type PointF = gpui::Point<f32>;
#[cfg(not(feature = "runtime_shaders"))]
const SHADERS_METALLIB: &[u8] = include_bytes!(concat!(env!("OUT_DIR"), "/shaders.metallib"));
#[cfg(feature = "runtime_shaders")]
const SHADERS_SOURCE_FILE: &str = include_str!(concat!(env!("OUT_DIR"), "/stitched_shaders.metal"));
// Use 4x MSAA, all devices support it.
// https://developer.apple.com/documentation/metal/mtldevice/1433355-supportstexturesamplecount
const PATH_SAMPLE_COUNT: u32 = 4;
/// Metal requires the offset a buffer is bound at to be 256-byte aligned.
const INSTANCE_BUFFER_ALIGNMENT: usize = 256;
const MAX_INSTANCE_BUFFER_SIZE: usize = 256 * 1024 * 1024;
pub type Context = Arc<Mutex<InstanceBufferPool>>;
pub type Renderer = MetalRenderer;
pub fn new_renderer(
context: self::Context,
transparent: bool,
use_display_p3: bool,
) -> Result<Renderer> {
MetalRenderer::new(context, transparent, use_display_p3)
}
pub struct InstanceBufferPool {
buffer_size: usize,
buffers: Vec<InstanceBuffer>,
}
impl Default for InstanceBufferPool {
fn default() -> Self {
Self {
buffer_size: 2 * 1024 * 1024,
buffers: Vec::new(),
}
}
}
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();
}
fn acquire(
&mut self,
device: &ProtocolObject<dyn MTLDevice>,
unified_memory: bool,
) -> 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,
})
}
fn release(&mut self, buffer: InstanceBuffer) {
if buffer.size == self.buffer_size {
self.buffers.push(buffer)
}
}
}
enum DisplayLinkMode {
Detached,
Attached {
drawable: Option<Retained<ProtocolObject<dyn CAMetalDrawable>>>,
},
}
pub struct MetalRenderer {
device: Retained<ProtocolObject<dyn MTLDevice>>,
layer: Option<Retained<CAMetalLayer>>,
is_apple_gpu: bool,
is_unified_memory: bool,
presents_with_transaction: bool,
display_link_mode: DisplayLinkMode,
/// For headless rendering, tracks whether output should be opaque
opaque: bool,
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<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<Retained<ProtocolObject<dyn MTLTexture>>>,
}
#[repr(C)]
pub struct PathRasterizationVertex {
pub xy_position: Point<ScaledPixels>,
pub st_position: Point<f32>,
pub color: Background,
pub bounds: Bounds<ScaledPixels>,
}
impl MetalRenderer {
/// Creates a new MetalRenderer with a CAMetalLayer for window-based rendering.
pub fn new(
instance_buffer_pool: Arc<Mutex<InstanceBufferPool>>,
transparent: bool,
use_display_p3: bool,
) -> 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)
}
/// Creates a renderer for a CAMetalLayer owned by a platform view, such as
/// the backing layer UIKit creates for a view whose `layerClass` is
/// `CAMetalLayer`. The renderer retains the layer.
pub fn from_layer(
instance_buffer_pool: Arc<Mutex<InstanceBufferPool>>,
layer: &CAMetalLayer,
transparent: bool,
) -> 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: &CAMetalLayer,
device: &ProtocolObject<dyn MTLDevice>,
transparent: bool,
use_display_p3: bool,
) {
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::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.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.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")]
layer.setAutoresizingMask(
objc2_quartz_core::CAAutoresizingMask::LayerWidthSizable
| objc2_quartz_core::CAAutoresizingMask::LayerHeightSizable,
);
}
/// Creates a new headless MetalRenderer for offscreen rendering without a window.
///
/// 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>>) -> Result<Self> {
let device = Self::create_device()?;
Self::new_internal(device, None, true, instance_buffer_pool)
}
#[cfg(target_os = "macos")]
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(device) = MTLCopyAllDevices()
.iter()
.min_by_key(|device| (device.isRemovable(), !device.isLowPower()))
{
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.
log::error!(
"Unable to enumerate Metal devices; attempting to use system default device"
);
Self::system_default_device()
}
}
#[cfg(target_os = "ios")]
fn create_device() -> Result<Retained<ProtocolObject<dyn MTLDevice>>> {
Self::system_default_device()
}
fn system_default_device() -> Result<Retained<ProtocolObject<dyn MTLDevice>>> {
MTLCreateSystemDefaultDevice().context("accessing a compatible Metal device")
}
fn new_internal(
device: Retained<ProtocolObject<dyn MTLDevice>>,
layer: Option<Retained<CAMetalLayer>>,
opaque: bool,
instance_buffer_pool: Arc<Mutex<InstanceBufferPool>>,
) -> Result<Self> {
#[cfg(feature = "runtime_shaders")]
let library = device
.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
.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;
output <<= 32;
output |= point.x.to_bits() as u64;
output
}
// Shared memory can be used only if CPU and GPU share the same memory space.
// 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.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.supportsFamily(MTLGPUFamily::Apple1);
let unit_vertices = [
to_float2_bits(point(0., 0.)),
to_float2_bits(point(1., 0.)),
to_float2_bits(point(0., 1.)),
to_float2_bits(point(0., 1.)),
to_float2_bits(point(1., 0.)),
to_float2_bits(point(1., 1.)),
];
// 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,
&library,
"paths_rasterization",
"path_rasterization_vertex",
"path_rasterization_fragment",
MTLPixelFormat::BGRA8Unorm,
PATH_SAMPLE_COUNT,
)?;
let path_sprites_pipeline_state = build_path_sprite_pipeline_state(
&device,
&library,
"path_sprites",
"path_sprite_vertex",
"path_sprite_fragment",
MTLPixelFormat::BGRA8Unorm,
)?;
let shadows_pipeline_state = build_pipeline_state(
&device,
&library,
"shadows",
"shadow_vertex",
"shadow_fragment",
MTLPixelFormat::BGRA8Unorm,
)?;
let quads_pipeline_state = build_pipeline_state(
&device,
&library,
"quads",
"quad_vertex",
"quad_fragment",
MTLPixelFormat::BGRA8Unorm,
)?;
let underlines_pipeline_state = build_pipeline_state(
&device,
&library,
"underlines",
"underline_vertex",
"underline_fragment",
MTLPixelFormat::BGRA8Unorm,
)?;
let monochrome_sprites_pipeline_state = build_pipeline_state(
&device,
&library,
"monochrome_sprites",
"monochrome_sprite_vertex",
"monochrome_sprite_fragment",
MTLPixelFormat::BGRA8Unorm,
)?;
let polychrome_sprites_pipeline_state = build_pipeline_state(
&device,
&library,
"polychrome_sprites",
"polychrome_sprite_vertex",
"polychrome_sprite_fragment",
MTLPixelFormat::BGRA8Unorm,
)?;
let surfaces_pipeline_state = build_pipeline_state(
&device,
&library,
"surfaces",
"surface_vertex",
"surface_fragment",
MTLPixelFormat::BGRA8Unorm,
)?;
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));
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) };
Ok(Self {
device,
layer,
presents_with_transaction: false,
display_link_mode: DisplayLinkMode::Detached,
is_apple_gpu,
is_unified_memory,
opaque,
command_queue,
paths_rasterization_pipeline_state,
path_sprites_pipeline_state,
shadows_pipeline_state,
quads_pipeline_state,
underlines_pipeline_state,
monochrome_sprites_pipeline_state,
polychrome_sprites_pipeline_state,
surfaces_pipeline_state,
unit_vertices,
instance_buffer_pool,
sprite_atlas,
core_video_texture_cache,
path_intermediate_texture: None,
path_intermediate_msaa_texture: None,
path_sample_count: PATH_SAMPLE_COUNT,
#[cfg(any(test, feature = "bench-support", feature = "test-support"))]
headless_render_target: None,
})
}
pub fn layer(&self) -> Option<&CAMetalLayer> {
self.layer.as_deref()
}
pub fn layer_ptr(&self) -> *mut CAMetalLayer {
self.layer
.as_ref()
.map(|layer| Retained::as_ptr(layer).cast_mut())
.unwrap_or(ptr::null_mut())
}
pub fn sprite_atlas(&self) -> &Arc<MetalAtlas> {
&self.sprite_atlas
}
/// Draw the next frame into `drawable` instead of asking the layer for one.
///
/// A `CAMetalDisplayLink` hands out each frame's drawable early enough for
/// the frame to reach the display on time; `nextDrawable` would instead
/// wait for the compositor to release one. Pass `None` once the frame is
/// done, so a drawable the frame did not use goes back to the layer.
///
/// Returns the drawable this replaces: after a frame, `Some` means the
/// frame neither drew nor presented.
///
/// This is a setter rather than a guard scoped to one frame because the
/// window releases its lock on the renderer while GPUI draws.
pub fn set_frame_drawable(
&mut self,
drawable: Option<Retained<ProtocolObject<dyn CAMetalDrawable>>>,
) -> Option<Retained<ProtocolObject<dyn CAMetalDrawable>>> {
match &mut self.display_link_mode {
DisplayLinkMode::Attached { drawable: current } => mem::replace(current, drawable),
DisplayLinkMode::Detached => {
// Only a live link hands out drawables, and a link is detached
// only after it has been invalidated.
debug_assert!(
drawable.is_none(),
"received a display link drawable while detached"
);
None
}
}
}
/// Record whether a `CAMetalDisplayLink` drives the layer. While one
/// does, frames are drawn only into the drawables it hands out.
pub fn set_display_link_attached(&mut self, attached: bool) {
self.display_link_mode = if attached {
DisplayLinkMode::Attached { drawable: None }
} else {
DisplayLinkMode::Detached
};
}
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.setPresentsWithTransaction(presents_with_transaction);
}
}
pub fn update_drawable_size(&mut self, size: Size<DevicePixels>) {
if let Some(layer) = &self.layer {
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:#}");
}
}
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
if size.width.0 <= 0 || size.height.0 <= 0 {
self.path_intermediate_texture = None;
self.path_intermediate_msaa_texture = None;
return Ok(());
}
if self
.path_intermediate_texture
.as_ref()
.is_some_and(|texture| {
texture.width() == size.width.0 as usize
&& texture.height() == size.height.0 as usize
})
{
return Ok(());
}
self.path_intermediate_texture = None;
self.path_intermediate_msaa_texture = None;
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")?;
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 {
MTLStorageMode::Memoryless
} else {
MTLStorageMode::Private
};
let msaa_descriptor = texture_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 {
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.setOpaque(!transparent);
}
}
pub fn destroy(&self) {
// nothing to do
}
pub fn draw(&mut self, scene: &Scene) {
let layer = match &self.layer {
Some(l) => l.clone(),
None => {
log::error!(
"draw() called on headless renderer - use render_scene_to_image() instead"
);
return;
}
};
let drawable = match &mut self.display_link_mode {
DisplayLinkMode::Attached { drawable } => {
let Some(drawable) = drawable.take() else {
log::error!("skipped a frame drawn outside its display link's update");
return;
};
drawable
}
DisplayLinkMode::Detached => {
let Some(drawable) = layer.nextDrawable() else {
log::error!(
"failed to retrieve next drawable, drawable size: {:?}",
layer.drawableSize()
);
return;
};
drawable
}
};
// A display link's drawable was sized when the link handed it out,
// which can be before a resize the layer has since taken.
let texture = drawable.texture();
let viewport_size: Size<DevicePixels> = size(
(texture.width() as i32).into(),
(texture.height() as i32).into(),
);
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:#}");
return;
}
};
if self.presents_with_transaction {
command_buffer.commit();
command_buffer.waitUntilScheduled();
drawable.present();
} else {
command_buffer.presentDrawable(ProtocolObject::from_ref(&*drawable));
command_buffer.commit();
}
}
fn render_frame(
&mut self,
scene: &Scene,
texture: &ProtocolObject<dyn MTLTexture>,
viewport_size: Size<DevicePixels>,
) -> 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!(
"writing instance data: {} paths, {} shadows, {} quads, {} underlines, {} mono, {} poly, {} surfaces",
scene.paths.len(),
scene.shadows.len(),
scene.quads.len(),
scene.underlines.len(),
scene.monochrome_sprites.len(),
scene.polychrome_sprites.len(),
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 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.addCompletedHandler(RcBlock::as_ptr(&block));
}
Ok(command_buffer)
}
/// Renders the scene to a texture and returns the pixel data as an RGBA image.
/// This does not present the frame to screen - useful for visual testing
/// where we want to capture what would be rendered without displaying it.
///
/// Note: This requires a layer-backed renderer. For headless rendering,
/// use `render_scene_to_image()` instead.
#[cfg(any(test, feature = "test-support"))]
pub fn render_to_image(&mut self, scene: &Scene) -> Result<RgbaImage> {
let layer = self
.layer
.clone()
.ok_or_else(|| anyhow::anyhow!("render_to_image requires a layer-backed renderer"))?;
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(),
);
// CAMetalDisplayLink owns the drawable, so render into a texture we own.
self.render_offscreen(scene, viewport_size)
}
/// Renders a scene to an image without requiring a window or CAMetalLayer.
///
/// This is the primary method for headless rendering. It creates an offscreen
/// texture, renders the scene to it, and returns the pixel data as an RGBA image.
#[cfg(any(test, feature = "bench-support", feature = "test-support"))]
pub fn render_scene_to_image(
&mut self,
scene: &Scene,
size: Size<DevicePixels>,
) -> Result<RgbaImage> {
if size.width.0 <= 0 || size.height.0 <= 0 {
anyhow::bail!("Invalid size for render_scene_to_image: {:?}", size);
}
// Headless callers do not have a Cocoa event-loop pool to release
// autoreleased command buffers and render-pass descriptors.
objc2::rc::autoreleasepool(|_| {
self.update_path_intermediate_textures(size)?;
self.render_offscreen(scene, size)
})
}
/// Renders a scene into a new offscreen texture of `size` and reads it
/// back, without presenting anything.
#[cfg(any(test, feature = "bench-support", feature = "test-support"))]
fn render_offscreen(&mut self, scene: &Scene, size: Size<DevicePixels>) -> Result<RgbaImage> {
if size.width.0 <= 0 || size.height.0 <= 0 {
anyhow::bail!("Invalid size for render_offscreen: {:?}", size);
}
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.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.setStorageMode(if uses_shared_storage {
MTLStorageMode::Shared
} else {
MTLStorageMode::Managed
});
let target_texture = self
.device
.newTextureWithDescriptor(&texture_descriptor)
.context("allocating offscreen render target")?;
let command_buffer = self.render_frame(scene, &target_texture, size)?;
// Managed textures require an explicit blit synchronize before the CPU
// can read back the rendered data. Without this, get_bytes returns
// stale zeros.
if !uses_shared_storage {
let blit = command_buffer
.blitCommandEncoder()
.context("creating blit command encoder")?;
blit.synchronizeResource(ProtocolObject::from_ref(&*target_texture));
blit.endEncoding();
}
command_buffer.commit();
command_buffer.waitUntilCompleted();
read_texture_to_image(&target_texture)
}
/// Renders a scene to a reused offscreen texture without reading pixels
/// back or blocking on GPU completion.
///
/// This mirrors the CPU cost of presenting a frame to a window (scene
/// encoding, instance buffer writes, command submission) and is used by
/// headless benchmark rendering, where the produced pixels are never
/// inspected.
#[cfg(any(test, feature = "bench-support", feature = "test-support"))]
pub fn render_scene(&mut self, scene: &Scene, size: Size<DevicePixels>) -> Result<()> {
if size.width.0 <= 0 || size.height.0 <= 0 {
anyhow::bail!("Invalid size for render_scene: {:?}", size);
}
objc2::rc::autoreleasepool(|_| {
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 usize
|| texture.height() != size.height.0 as usize
});
if needs_new_target {
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")?,
);
}
let target_texture = self
.headless_render_target
.clone()
.context("retrieving headless render target")?;
let command_buffer = self.render_frame(scene, &target_texture, size)?;
// Commit without waiting, mirroring presentation to a real window where
// the CPU doesn't block on the GPU.
command_buffer.commit();
Ok(())
})
}
fn draw_primitives_to_texture(
&mut self,
scene: &Scene,
instance_bindings: &InstanceBindings,
writer: &mut InstanceBufferWriter,
texture: &ProtocolObject<dyn MTLTexture>,
viewport_size: Size<DevicePixels>,
surface_textures: &mut Vec<CFRetained<CVMetalTexture>>,
) -> Result<Retained<ProtocolObject<dyn MTLCommandBuffer>>> {
let command_queue = self.command_queue.clone();
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,
texture,
viewport_size,
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)
}
PrimitiveBatch::Quads(range) => {
self.draw_quads(range, instance_bindings, viewport_size, &command_encoder)
}
PrimitiveBatch::Paths(range) => {
let paths = &scene.paths[range];
command_encoder.endEncoding();
let did_draw = self.draw_paths_to_intermediate(
paths,
writer,
viewport_size,
&command_buffer,
)?;
command_encoder = new_command_encoder_for_texture(
&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.endEncoding();
return Err(error);
}
}
}
PrimitiveBatch::Underlines(range) => {
self.draw_underlines(range, instance_bindings, viewport_size, &command_encoder)
}
PrimitiveBatch::MonochromeSprites { texture_id, range } => self
.draw_monochrome_sprites(
texture_id,
range,
instance_bindings,
viewport_size,
&command_encoder,
),
PrimitiveBatch::PolychromeSprites { texture_id, range } => self
.draw_polychrome_sprites(
texture_id,
range,
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.endEncoding();
Ok(command_buffer)
}
fn draw_paths_to_intermediate(
&self,
paths: &[Path<ScaledPixels>],
writer: &mut InstanceBufferWriter,
viewport_size: Size<DevicePixels>,
command_buffer: &ProtocolObject<dyn MTLCommandBuffer>,
) -> Result<bool> {
if paths.is_empty() {
return Ok(false);
}
let intermediate_texture = self
.path_intermediate_texture
.as_ref()
.context("missing path intermediate texture")?;
let mut vertices = Vec::new();
for path in paths {
vertices.extend(path.vertices.iter().map(|v| PathRasterizationVertex {
xy_position: v.xy_position,
st_position: v.st_position,
color: path.color,
bounds: path.bounds.intersect(&path.content_mask.bounds),
}));
}
let vertex_instance_bindings = writer.write(&vertices)?;
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.setTexture(Some(msaa_texture));
color_attachment.setResolveTexture(Some(intermediate_texture));
color_attachment.setStoreAction(MTLStoreAction::MultisampleResolve);
} else {
color_attachment.setTexture(Some(intermediate_texture));
color_attachment.setStoreAction(MTLStoreAction::Store);
}
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.endEncoding();
Ok(true)
}
fn draw_shadows(
&self,
shadows: Range<usize>,
instance_bindings: &InstanceBindings,
viewport_size: Size<DevicePixels>,
command_encoder: &ProtocolObject<dyn MTLRenderCommandEncoder>,
) {
if shadows.is_empty() {
return;
}
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(
&self,
quads: Range<usize>,
instance_bindings: &InstanceBindings,
viewport_size: Size<DevicePixels>,
command_encoder: &ProtocolObject<dyn MTLRenderCommandEncoder>,
) {
if quads.is_empty() {
return;
}
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(
&self,
paths: &[Path<ScaledPixels>],
writer: &mut InstanceBufferWriter,
viewport_size: Size<DevicePixels>,
command_encoder: &ProtocolObject<dyn MTLRenderCommandEncoder>,
) -> Result<()> {
let (Some(first_path), Some(last_path)) = (paths.first(), paths.last()) else {
return Ok(());
};
let intermediate_texture = self
.path_intermediate_texture
.as_ref()
.context("missing path 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.
//
// If all paths have the same draw order, then their bounds are all
// disjoint, so we can copy each path's bounds individually. If this
// batch combines different draw orders, we perform a single copy
// for a minimal spanning rect.
let sprites;
if last_path.order == first_path.order {
sprites = paths
.iter()
.map(|path| PathSprite {
bounds: path.clipped_bounds(),
})
.collect();
} else {
let mut bounds = first_path.clipped_bounds();
for path in paths.iter().skip(1) {
bounds = bounds.union(&path.clipped_bounds());
}
sprites = vec![PathSprite { bounds }];
}
let sprite_instance_bindings = writer.write(&sprites)?;
// 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(())
}
fn draw_underlines(
&self,
underlines: Range<usize>,
instance_bindings: &InstanceBindings,
viewport_size: Size<DevicePixels>,
command_encoder: &ProtocolObject<dyn MTLRenderCommandEncoder>,
) {
if underlines.is_empty() {
return;
}
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(
&self,
texture_id: AtlasTextureId,
sprites: Range<usize>,
instance_bindings: &InstanceBindings,
viewport_size: Size<DevicePixels>,
command_encoder: &ProtocolObject<dyn MTLRenderCommandEncoder>,
) {
if sprites.is_empty() {
return;
}
let Some(texture) = self.sprite_atlas.metal_texture(texture_id) else {
return;
};
let texture_size = size(
DevicePixels(texture.width() as i32),
DevicePixels(texture.height() as i32),
);
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(
&self,
texture_id: AtlasTextureId,
sprites: Range<usize>,
instance_bindings: &InstanceBindings,
viewport_size: Size<DevicePixels>,
command_encoder: &ProtocolObject<dyn MTLRenderCommandEncoder>,
) {
if sprites.is_empty() {
return;
}
let Some(texture) = self.sprite_atlas.metal_texture(texture_id) else {
return;
};
let texture_size = size(
DevicePixels(texture.width() as i32),
DevicePixels(texture.height() as i32),
);
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(
&mut self,
surfaces: &[PaintSurface],
first_surface: usize,
instance_bindings: &InstanceBindings,
viewport_size: Size<DevicePixels>,
command_encoder: &ProtocolObject<dyn MTLRenderCommandEncoder>,
surface_textures: &mut Vec<CFRetained<CVMetalTexture>>,
) -> Result<()> {
if surfaces.is_empty() {
return Ok(());
}
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;
let texture_size = size(
DevicePixels::from(CVPixelBufferGetWidth(image_buffer) as i32),
DevicePixels::from(CVPixelBufferGetHeight(image_buffer) as i32),
);
let pixel_format = CVPixelBufferGetPixelFormatType(image_buffer);
anyhow::ensure!(
pixel_format == kCVPixelFormatType_420YpCbCr8BiPlanarFullRange,
"unsupported surface pixel format: {pixel_format:#x}"
);
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();
// 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}"
);
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, 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]);
// 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(
command_buffer: &ProtocolObject<dyn MTLCommandBuffer>,
texture: &ProtocolObject<dyn MTLTexture>,
viewport_size: Size<DevicePixels>,
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.setLoadAction(MTLLoadAction::Clear);
color_attachment.setClearColor(clear_color);
} else {
color_attachment.setLoadAction(MTLLoadAction::Load);
}
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,
height: i32::from(viewport_size.height) as f64,
znear: 0.0,
zfar: 1.0,
});
Ok(command_encoder)
}
#[cfg(any(test, feature = "bench-support", feature = "test-support"))]
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 = MTLRegion {
origin: MTLOrigin { x: 0, y: 0, z: 0 },
size: MTLSize {
width: width as usize,
height: height as usize,
depth: 1,
},
};
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("creating RGBA image from pixel data")
}
fn build_pipeline_state(
device: &ProtocolObject<dyn MTLDevice>,
library: &ProtocolObject<dyn MTLLibrary>,
label: &str,
vertex_fn_name: &str,
fragment_fn_name: &str,
pixel_format: MTLPixelFormat,
) -> Result<Retained<ProtocolObject<dyn MTLRenderPipelineState>>> {
let vertex_fn = library
.newFunctionWithName(&NSString::from_str(vertex_fn_name))
.with_context(|| format!("locating vertex function {vertex_fn_name}"))?;
let fragment_fn = library
.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
.newRenderPipelineStateWithDescriptor_error(&descriptor)
.with_context(|| format!("creating {label} render pipeline"))
}
fn build_path_sprite_pipeline_state(
device: &ProtocolObject<dyn MTLDevice>,
library: &ProtocolObject<dyn MTLLibrary>,
label: &str,
vertex_fn_name: &str,
fragment_fn_name: &str,
pixel_format: MTLPixelFormat,
) -> Result<Retained<ProtocolObject<dyn MTLRenderPipelineState>>> {
let vertex_fn = library
.newFunctionWithName(&NSString::from_str(vertex_fn_name))
.with_context(|| format!("locating vertex function {vertex_fn_name}"))?;
let fragment_fn = library
.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
.newRenderPipelineStateWithDescriptor_error(&descriptor)
.with_context(|| format!("creating {label} render pipeline"))
}
fn build_path_rasterization_pipeline_state(
device: &ProtocolObject<dyn MTLDevice>,
library: &ProtocolObject<dyn MTLLibrary>,
label: &str,
vertex_fn_name: &str,
fragment_fn_name: &str,
pixel_format: MTLPixelFormat,
path_sample_count: u32,
) -> Result<Retained<ProtocolObject<dyn MTLRenderPipelineState>>> {
let vertex_fn = library
.newFunctionWithName(&NSString::from_str(vertex_fn_name))
.with_context(|| format!("locating vertex function {vertex_fn_name}"))?;
let fragment_fn = library
.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()));
if path_sample_count > 1 {
descriptor.setRasterSampleCount(path_sample_count as _);
descriptor.setAlphaToCoverageEnabled(false);
}
// 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
.newRenderPipelineStateWithDescriptor_error(&descriptor)
.with_context(|| format!("creating {label} render pipeline"))
}
#[derive(Clone)]
struct InstanceBinding {
buffer: Retained<ProtocolObject<dyn MTLBuffer>>,
offset: usize,
}
struct InstanceBindings {
quads: InstanceBinding,
shadows: InstanceBinding,
underlines: InstanceBinding,
monochrome_sprites: InstanceBinding,
polychrome_sprites: InstanceBinding,
surfaces: InstanceBinding,
}
fn write_instances(scene: &Scene, writer: &mut InstanceBufferWriter) -> Result<InstanceBindings> {
Ok(InstanceBindings {
quads: writer.write(&scene.quads)?,
shadows: writer.write(&scene.shadows)?,
underlines: writer.write(&scene.underlines)?,
monochrome_sprites: writer.write(&scene.monochrome_sprites)?,
polychrome_sprites: writer.write(&scene.polychrome_sprites)?,
surfaces: writer.write_iter(scene.surfaces.iter().map(|surface| SurfaceBounds {
bounds: surface.bounds,
content_mask: surface.content_mask,
}))?,
})
}
struct InstanceBufferWriter {
device: Retained<ProtocolObject<dyn MTLDevice>>,
pool: Arc<Mutex<InstanceBufferPool>>,
unified_memory: bool,
filled: Vec<(InstanceBuffer, usize)>,
current: InstanceBuffer,
offset: usize,
}
impl InstanceBufferWriter {
fn new(
device: &ProtocolObject<dyn MTLDevice>,
pool: &Arc<Mutex<InstanceBufferPool>>,
unified_memory: bool,
) -> 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>])> {
let size = mem::size_of::<T>() * count;
let mut offset = self.offset.next_multiple_of(INSTANCE_BUFFER_ALIGNMENT);
if offset + size > self.current.size {
self.grow(size)?;
offset = 0;
}
self.offset = offset + size;
let binding = InstanceBinding {
buffer: self.current.metal_buffer.clone(),
offset,
};
// 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_ptr()
.cast::<u8>()
.add(offset);
slice::from_raw_parts_mut(start.cast::<MaybeUninit<T>>(), count)
};
Ok((binding, values))
}
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(),
destination.as_mut_ptr().cast::<T>(),
values.len(),
);
}
Ok(binding)
}
fn write_iter<T>(
&mut self,
values: impl ExactSizeIterator<Item = T>,
) -> Result<InstanceBinding> {
let (binding, destination) = self.allocate::<T>(values.len())?;
for (slot, value) in destination.iter_mut().zip(values) {
slot.write(value);
}
Ok(binding)
}
fn grow(&mut self, required: usize) -> Result<()> {
let mut pool = self.pool.lock();
let buffer_size = (pool.buffer_size * 2)
.max(required.next_power_of_two())
.min(MAX_INSTANCE_BUFFER_SIZE);
anyhow::ensure!(
buffer_size >= required,
"instance buffer needs {required} bytes, above the maximum of {MAX_INSTANCE_BUFFER_SIZE}"
);
anyhow::ensure!(
buffer_size > self.current.size,
"frame instance data exceeds the {MAX_INSTANCE_BUFFER_SIZE}-byte maximum"
);
if buffer_size != pool.buffer_size {
log::info!("increased instance buffer size to {buffer_size}");
pool.reset(buffer_size);
}
let buffer = pool.acquire(&self.device, self.unified_memory)?;
drop(pool);
let filled = mem::replace(&mut self.current, buffer);
self.filled.push((filled, self.offset));
self.offset = 0;
Ok(())
}
fn finish(self) -> InstanceBuffer {
let Self {
unified_memory,
filled,
current,
offset,
..
} = self;
if !unified_memory {
for (buffer, written) in &filled {
if *written == 0 {
continue;
}
buffer.metal_buffer.didModifyRange(NSRange {
location: 0,
length: *written,
});
}
if offset > 0 {
current.metal_buffer.didModifyRange(NSRange {
location: 0,
length: offset,
});
}
}
// Metal retains encoded resources until the command buffer completes.
// Only the final, largest buffer is worth keeping in the pool.
drop(filled);
current
}
}
#[repr(C)]
enum ShadowInputIndex {
Vertices = 0,
Shadows = 1,
ViewportSize = 2,
}
#[repr(C)]
enum QuadInputIndex {
Vertices = 0,
Quads = 1,
ViewportSize = 2,
}
#[repr(C)]
enum UnderlineInputIndex {
Vertices = 0,
Underlines = 1,
ViewportSize = 2,
}
#[repr(C)]
enum SpriteInputIndex {
Vertices = 0,
Sprites = 1,
ViewportSize = 2,
AtlasTextureSize = 3,
AtlasTexture = 4,
}
#[repr(C)]
enum SurfaceInputIndex {
Vertices = 0,
Surfaces = 1,
ViewportSize = 2,
TextureSize = 3,
YTexture = 4,
CbCrTexture = 5,
}
#[repr(C)]
enum PathRasterizationInputIndex {
Vertices = 0,
ViewportSize = 1,
}
#[derive(Clone, Debug, Eq, PartialEq)]
#[repr(C)]
pub struct PathSprite {
pub bounds: Bounds<ScaledPixels>,
}
#[derive(Clone, Debug, Eq, PartialEq)]
#[repr(C)]
pub struct SurfaceBounds {
pub bounds: Bounds<ScaledPixels>,
pub content_mask: ContentMask<ScaledPixels>,
}
#[cfg(any(test, feature = "bench-support", feature = "test-support"))]
pub struct MetalHeadlessRenderer {
renderer: MetalRenderer,
}
#[cfg(any(test, feature = "bench-support", feature = "test-support"))]
impl MetalHeadlessRenderer {
pub fn new() -> Result<Self> {
let instance_buffer_pool = Arc::new(Mutex::new(InstanceBufferPool::default()));
let renderer = MetalRenderer::new_headless(instance_buffer_pool)?;
Ok(Self { renderer })
}
}
#[cfg(any(test, feature = "bench-support", feature = "test-support"))]
impl gpui::PlatformHeadlessRenderer for MetalHeadlessRenderer {
fn render_scene_to_image(
&mut self,
scene: &Scene,
size: Size<DevicePixels>,
) -> anyhow::Result<image::RgbaImage> {
self.renderer.render_scene_to_image(scene, size)
}
fn render_scene(&mut self, scene: &Scene, size: Size<DevicePixels>) -> anyhow::Result<()> {
self.renderer.render_scene(scene, size)
}
fn sprite_atlas(&self) -> Arc<dyn gpui::PlatformAtlas> {
self.renderer.sprite_atlas().clone()
}
}
#[cfg(test)]
mod tests {
use super::*;
use objc2_core_foundation::{CFDictionary, CFType};
use objc2_core_video::{
CVPixelBufferCreate, CVPixelBufferGetBaseAddressOfPlane,
CVPixelBufferGetBytesPerRowOfPlane, CVPixelBufferLockBaseAddress, CVPixelBufferLockFlags,
CVPixelBufferUnlockBaseAddress, kCVPixelBufferIOSurfacePropertiesKey,
};
use objc2_metal::MTLCommandBufferStatus;
#[test]
fn path_intermediate_textures_are_reused_until_resize() -> Result<()> {
let mut renderer = MetalRenderer::new_headless(Default::default())?;
let initial_size = size(DevicePixels(64), DevicePixels(64));
renderer.update_path_intermediate_textures(initial_size)?;
let initial_texture = renderer
.path_intermediate_texture
.clone()
.context("missing path intermediate texture")?;
let initial_msaa_texture = renderer.path_intermediate_msaa_texture.clone();
renderer.update_path_intermediate_textures(initial_size)?;
assert!(ptr::eq(
&*initial_texture,
renderer
.path_intermediate_texture
.as_deref()
.context("missing reused texture")?,
));
assert_eq!(
initial_msaa_texture.as_ref().map(Retained::as_ptr),
renderer
.path_intermediate_msaa_texture
.as_ref()
.map(Retained::as_ptr),
);
renderer.update_path_intermediate_textures(size(DevicePixels(128), DevicePixels(64)))?;
let resized_texture = renderer
.path_intermediate_texture
.as_deref()
.context("missing resized texture")?;
assert_eq!(
(resized_texture.width(), resized_texture.height()),
(128, 64)
);
assert!(!ptr::eq(&*initial_texture, resized_texture));
if let Some(texture) = &renderer.path_intermediate_msaa_texture {
assert_eq!((texture.width(), texture.height()), (128, 64));
}
for (width, height) in [(0, 64), (64, 0), (-1, 64), (64, -1)] {
renderer.update_path_intermediate_textures(size(
DevicePixels(width),
DevicePixels(height),
))?;
assert!(renderer.path_intermediate_texture.is_none());
assert!(renderer.path_intermediate_msaa_texture.is_none());
renderer.update_path_intermediate_textures(initial_size)?;
assert!(renderer.path_intermediate_texture.is_some());
}
Ok(())
}
#[test]
fn render_to_image_rejects_zero_sized_layer() -> Result<()> {
let mut renderer = MetalRenderer::new(Default::default(), false, false)?;
for (width, height) in [(0, 0), (0, 64), (64, 0)] {
renderer.update_drawable_size(size(DevicePixels(width), DevicePixels(height)));
assert!(renderer.render_to_image(&Scene::default()).is_err());
}
Ok(())
}
#[test]
fn display_link_mode_consumes_and_clears_drawables() -> Result<()> {
let mut renderer = MetalRenderer::new(Default::default(), false, false)?;
renderer.update_drawable_size(size(DevicePixels(64), DevicePixels(64)));
let drawable = renderer
.layer()
.and_then(|layer| layer.nextDrawable())
.context("window renderer must supply a drawable")?;
renderer.set_display_link_attached(true);
assert!(matches!(
renderer.display_link_mode,
DisplayLinkMode::Attached { drawable: None }
));
assert!(
renderer
.set_frame_drawable(Some(drawable.clone()))
.is_none()
);
assert!(matches!(
renderer.display_link_mode,
DisplayLinkMode::Attached { drawable: Some(_) }
));
renderer.draw(&Scene::default());
assert!(matches!(
renderer.display_link_mode,
DisplayLinkMode::Attached { drawable: None }
));
// A frame that drew consumed its drawable; one that didn't hands it back.
assert!(
renderer
.set_frame_drawable(Some(drawable.clone()))
.is_none()
);
assert!(renderer.set_frame_drawable(None).is_some());
renderer.set_frame_drawable(Some(drawable));
renderer.set_display_link_attached(false);
assert!(matches!(
renderer.display_link_mode,
DisplayLinkMode::Detached
));
Ok(())
}
#[test]
fn render_core_video_surface() {
let surface_properties_key = unsafe { kCVPixelBufferIOSurfacePropertiesKey };
let attributes = CFDictionary::from_slices(
&[surface_properties_key],
&[&*CFDictionary::<CFType, CFType>::empty()],
);
let mut image_buffer = ptr::null_mut();
assert_eq!(
unsafe {
CVPixelBufferCreate(
None,
16,
16,
kCVPixelFormatType_420YpCbCr8BiPlanarFullRange,
Some(attributes.as_opaque()),
ptr::NonNull::from(&mut image_buffer),
)
},
kCVReturnSuccess
);
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()),
kCVReturnSuccess
);
for plane in 0..2 {
let bytes = CVPixelBufferGetBaseAddressOfPlane(&image_buffer, plane).cast::<u8>();
let length = CVPixelBufferGetBytesPerRowOfPlane(&image_buffer, plane)
* CVPixelBufferGetHeightOfPlane(&image_buffer, plane);
slice::from_raw_parts_mut(bytes, length).fill(128);
}
assert_eq!(
CVPixelBufferUnlockBaseAddress(&image_buffer, CVPixelBufferLockFlags::empty()),
kCVReturnSuccess
);
}
let bounds = Bounds {
origin: Point::default(),
size: size(ScaledPixels(16.0), ScaledPixels(16.0)),
};
let mut scene = Scene::default();
scene.insert_primitive(PaintSurface {
order: 0,
bounds,
content_mask: ContentMask { bounds },
image_buffer: image_buffer.clone(),
});
drop(image_buffer);
scene.finish();
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();
for image::Rgba([red, green, blue, alpha]) in image.pixels() {
assert!(red.abs_diff(128) <= 2);
assert!(green.abs_diff(128) <= 2);
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);
}
}