Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
Tweak renderer resource management (#62069)
John Turbe8c6f9fb356
diff --git a/crates/gpui/src/window.rs b/crates/gpui/src/window.rsindex 3e8563c01b9..1b5011e076b 100644--- a/crates/gpui/src/window.rs+++ b/crates/gpui/src/window.rs@@ -3967,6 +3967,45 @@ impl Window {}}+ fn largest_border_interior(quad: &Quad) -> Bounds<ScaledPixels> {+ let radii = &quad.corner_radii;+ let widths = &quad.border_widths;+ let edge_radii = Edges {+ top: radii.top_left.max(radii.top_right),+ right: radii.top_right.max(radii.bottom_right),+ bottom: radii.bottom_left.max(radii.bottom_right),+ left: radii.top_left.max(radii.bottom_left),+ };++ let antialias_inset = point(ScaledPixels(1.0), ScaledPixels(1.0));+ let inset_bounds = |top_left_inset, bottom_right_inset| {+ Bounds::from_corners(+ quad.bounds.origin + top_left_inset + antialias_inset,+ quad.bounds.bottom_right() - bottom_right_inset - antialias_inset,+ )+ };++ // Rounded corners need only be excluded on one axis. Either candidate+ // is empty of border pixels, so use the larger interior.+ let horizontal_band = inset_bounds(+ point(widths.left, widths.top.max(edge_radii.top)),+ point(widths.right, widths.bottom.max(edge_radii.bottom)),+ );+ let vertical_band = inset_bounds(+ point(widths.left.max(edge_radii.left), widths.top),+ point(widths.right.max(edge_radii.right), widths.bottom),+ );++ let area = |bounds: &Bounds<ScaledPixels>| {+ bounds.size.width.0.max(0.) * bounds.size.height.0.max(0.)+ };+ if area(&horizontal_band) >= area(&vertical_band) {+ horizontal_band+ } else {+ vertical_band+ }+ }+/// Paint one or more quads into the scene for the next frame at the current stacking context./// Quads are colored rectangular regions with an optional background, border, and corner radius./// see [`fill`], [`outline`], and [`quad`] to construct this type.@@ -3998,29 +4037,10 @@ impl Window {return;}- // We're drawing a quad with a border but no fill color. Painting this quad would run the quad shader for every- // transparent interior pixel, which is especially costly when the quad is large.- // Instead, split it into four non-overlapping strips that cover the regions where borders are painted:- // the side strips own the straight left and right edges, while the top and bottom strips own the horizontal- // edges and the rounded corners.- let radii = &quad.corner_radii;- let widths = &quad.border_widths;-- let antialias_slack = point(ScaledPixels(1.0), ScaledPixels(1.0));- let top_left_inset = point(- widths.left,- widths.top.max(radii.top_left).max(radii.top_right),- ) + antialias_slack;- let bottom_right_inset = point(- widths.right,- widths.bottom.max(radii.bottom_left).max(radii.bottom_right),- ) + antialias_slack;-+ // Splitting a border-only quad around its empty interior avoids shading+ // every transparent pixel inside large outlines.let outer_bounds = quad.bounds;- let inner_bounds = Bounds::from_corners(- outer_bounds.origin + top_left_inset,- outer_bounds.bottom_right() - bottom_right_inset,- );+ let inner_bounds = Self::largest_border_interior(&quad);if inner_bounds.is_empty() {self.next_frame.scene.insert_primitive(quad);diff --git a/crates/gpui_macos/src/metal_renderer.rs b/crates/gpui_macos/src/metal_renderer.rsindex 5a72e23e140..4f6b0fee78a 100644--- a/crates/gpui_macos/src/metal_renderer.rs+++ b/crates/gpui_macos/src/metal_renderer.rs@@ -1,5 +1,5 @@use crate::metal_atlas::MetalAtlas;-use anyhow::Result;+use anyhow::{Context as _, Result};use block::ConcreteBlock;use cocoa::{base::{NO, YES},@@ -7,9 +7,8 @@ use cocoa::{quartzcore::AutoresizingMask,};use gpui::{- AtlasTextureId, Background, Bounds, ContentMask, DevicePixels, MonochromeSprite, PaintSurface,- Path, Point, PolychromeSprite, PrimitiveBatch, Quad, ScaledPixels, Scene, Shadow, Size,- Surface, Underline, point, size,+ AtlasTextureId, Background, Bounds, ContentMask, DevicePixels, PaintSurface, Path, Point,+ PrimitiveBatch, ScaledPixels, Scene, Size, point, size,};#[cfg(any(test, feature = "test-support"))]use image::RgbaImage;@@ -22,12 +21,11 @@ use core_video::{use foreign_types::{ForeignType, ForeignTypeRef};use metal::{CAMetalLayer, CommandQueue, MTLGPUFamily, MTLPixelFormat, MTLResourceOptions, NSRange,- RenderPassColorAttachmentDescriptorRef,};use objc::{self, msg_send, sel, sel_impl};use parking_lot::Mutex;-use std::{cell::Cell, ffi::c_void, mem, ptr, sync::Arc};+use std::{cell::Cell, ffi::c_void, mem, mem::MaybeUninit, ops::Range, ptr, slice, sync::Arc};// Exported to metalpub(crate) type PointF = gpui::Point<f32>;@@ -39,6 +37,9 @@ const SHADERS_SOURCE_FILE: &str = include_str!(concat!(env!("OUT_DIR"), "/stitch// Use 4x MSAA, all devices support it.// https://developer.apple.com/documentation/metal/mtldevice/1433355-supportstexturesamplecountconst 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(crate) type Context = Arc<Mutex<InstanceBufferPool>>;pub(crate) type Renderer = MetalRenderer;@@ -468,58 +469,68 @@ impl MetalRenderer {return;};- loop {- let mut instance_buffer = self- .instance_buffer_pool- .lock()- .acquire(&self.device, self.is_unified_memory);-- let command_buffer =- self.draw_primitives(scene, &mut instance_buffer, drawable, viewport_size);-- match command_buffer {- Ok(command_buffer) => {- let instance_buffer_pool = self.instance_buffer_pool.clone();- let instance_buffer = Cell::new(Some(instance_buffer));- let block = ConcreteBlock::new(move |_| {- if let Some(instance_buffer) = instance_buffer.take() {- instance_buffer_pool.lock().release(instance_buffer);- }- });- let block = block.copy();- command_buffer.add_completed_handler(&block);-- if self.presents_with_transaction {- command_buffer.commit();- command_buffer.wait_until_scheduled();- drawable.present();- } else {- command_buffer.present_drawable(drawable);- command_buffer.commit();- }- return;- }- Err(err) => {- log::error!(- "failed to render: {}. retrying with larger instance buffer size",- err- );- let mut instance_buffer_pool = self.instance_buffer_pool.lock();- let buffer_size = instance_buffer_pool.buffer_size;- if buffer_size >= 256 * 1024 * 1024 {- log::error!("instance buffer size grew too large: {}", buffer_size);- break;- }- instance_buffer_pool.reset(buffer_size * 2);- log::info!(- "increased instance buffer size to {}",- instance_buffer_pool.buffer_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:#}");+ return;}+ };++ if self.presents_with_transaction {+ command_buffer.commit();+ command_buffer.wait_until_scheduled();+ drawable.present();+ } else {+ command_buffer.present_drawable(drawable);+ command_buffer.commit();}}+ fn render_frame(+ &mut self,+ scene: &Scene,+ texture: &metal::TextureRef,+ viewport_size: Size<DevicePixels>,+ ) -> Result<metal::CommandBuffer> {+ 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",+ scene.paths.len(),+ scene.shadows.len(),+ scene.quads.len(),+ scene.underlines.len(),+ scene.monochrome_sprites.len(),+ scene.polychrome_sprites.len(),+ scene.surfaces.len(),+ )+ })?;+ let command_buffer = self.draw_primitives_to_texture(+ scene,+ &instance_bindings,+ &mut writer,+ texture,+ viewport_size,+ )?;++ let instance_buffer_pool = self.instance_buffer_pool.clone();+ let instance_buffer = Cell::new(Some(writer.finish()));+ let block = ConcreteBlock::new(move |_| {+ if let Some(instance_buffer) = instance_buffer.take() {+ instance_buffer_pool.lock().release(instance_buffer);+ }+ });+ let block = block.copy();+ command_buffer.add_completed_handler(&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.@@ -541,83 +552,13 @@ impl MetalRenderer {.next_drawable().ok_or_else(|| anyhow::anyhow!("Failed to get drawable for render_to_image"))?;- loop {- let mut instance_buffer = self- .instance_buffer_pool- .lock()- .acquire(&self.device, self.is_unified_memory);-- let command_buffer =- self.draw_primitives(scene, &mut instance_buffer, drawable, viewport_size);-- match command_buffer {- Ok(command_buffer) => {- let instance_buffer_pool = self.instance_buffer_pool.clone();- let instance_buffer = Cell::new(Some(instance_buffer));- let block = ConcreteBlock::new(move |_| {- if let Some(instance_buffer) = instance_buffer.take() {- instance_buffer_pool.lock().release(instance_buffer);- }- });- let block = block.copy();- command_buffer.add_completed_handler(&block);-- // Commit and wait for completion without presenting- command_buffer.commit();- command_buffer.wait_until_completed();-- // Read pixels from the texture- let texture = drawable.texture();- let width = texture.width() as u32;- let height = texture.height() as u32;- let bytes_per_row = width as usize * 4;- let buffer_size = height as usize * bytes_per_row;-- let mut pixels = vec![0u8; buffer_size];-- let region = metal::MTLRegion {- origin: metal::MTLOrigin { x: 0, y: 0, z: 0 },- size: metal::MTLSize {- width: width as u64,- height: height as u64,- depth: 1,- },- };-- texture.get_bytes(- pixels.as_mut_ptr() as *mut std::ffi::c_void,- bytes_per_row as u64,- region,- 0,- );+ let command_buffer = self.render_frame(scene, drawable.texture(), viewport_size)?;- // Convert BGRA to RGBA (swap B and R channels)- for chunk in pixels.chunks_exact_mut(4) {- chunk.swap(0, 2);- }+ // Commit and wait for completion without presenting+ command_buffer.commit();+ command_buffer.wait_until_completed();- return RgbaImage::from_raw(width, height, pixels).ok_or_else(|| {- anyhow::anyhow!("Failed to create RgbaImage from pixel data")- });- }- Err(err) => {- log::error!(- "failed to render: {}. retrying with larger instance buffer size",- err- );- let mut instance_buffer_pool = self.instance_buffer_pool.lock();- let buffer_size = instance_buffer_pool.buffer_size;- if buffer_size >= 256 * 1024 * 1024 {- anyhow::bail!("instance buffer size grew too large: {}", buffer_size);- }- instance_buffer_pool.reset(buffer_size * 2);- log::info!(- "increased instance buffer size to {}",- instance_buffer_pool.buffer_size- );- }- }- }+ read_texture_to_image(drawable.texture())}/// Renders a scene to an image without requiring a window or CAMetalLayer.@@ -647,92 +588,22 @@ impl MetalRenderer {texture_descriptor.set_storage_mode(metal::MTLStorageMode::Managed);let target_texture = self.device.new_texture(&texture_descriptor);- loop {- let mut instance_buffer = self- .instance_buffer_pool- .lock()- .acquire(&self.device, self.is_unified_memory);-- let command_buffer =- self.draw_primitives_to_texture(scene, &mut instance_buffer, &target_texture, size);-- match command_buffer {- Ok(command_buffer) => {- let instance_buffer_pool = self.instance_buffer_pool.clone();- let instance_buffer = Cell::new(Some(instance_buffer));- let block = ConcreteBlock::new(move |_| {- if let Some(instance_buffer) = instance_buffer.take() {- instance_buffer_pool.lock().release(instance_buffer);- }- });- let block = block.copy();- command_buffer.add_completed_handler(&block);-- // On discrete GPUs (non-unified memory), Managed textures- // require an explicit blit synchronize before the CPU can- // read back the rendered data. Without this, get_bytes- // returns stale zeros.- if !self.is_unified_memory {- let blit = command_buffer.new_blit_command_encoder();- blit.synchronize_resource(&target_texture);- blit.end_encoding();- }+ let command_buffer = self.render_frame(scene, &target_texture, size)?;- // Commit and wait for completion- command_buffer.commit();- command_buffer.wait_until_completed();-- // Read pixels from the texture- let width = size.width.0 as u32;- let height = size.height.0 as u32;- let bytes_per_row = width as usize * 4;- let buffer_size = height as usize * bytes_per_row;-- let mut pixels = vec![0u8; buffer_size];-- let region = metal::MTLRegion {- origin: metal::MTLOrigin { x: 0, y: 0, z: 0 },- size: metal::MTLSize {- width: width as u64,- height: height as u64,- depth: 1,- },- };-- target_texture.get_bytes(- pixels.as_mut_ptr() as *mut std::ffi::c_void,- bytes_per_row as u64,- region,- 0,- );+ // On discrete GPUs (non-unified memory), Managed textures require an+ // explicit blit synchronize before the CPU can read back the rendered+ // data. Without this, get_bytes returns stale zeros.+ if !self.is_unified_memory {+ let blit = command_buffer.new_blit_command_encoder();+ blit.synchronize_resource(&target_texture);+ blit.end_encoding();+ }- // Convert BGRA to RGBA (swap B and R channels)- for chunk in pixels.chunks_exact_mut(4) {- chunk.swap(0, 2);- }+ // Commit and wait for completion+ command_buffer.commit();+ command_buffer.wait_until_completed();- return RgbaImage::from_raw(width, height, pixels).ok_or_else(|| {- anyhow::anyhow!("Failed to create RgbaImage from pixel data")- });- }- Err(err) => {- log::error!(- "failed to render: {}. retrying with larger instance buffer size",- err- );- let mut instance_buffer_pool = self.instance_buffer_pool.lock();- let buffer_size = instance_buffer_pool.buffer_size;- if buffer_size >= 256 * 1024 * 1024 {- anyhow::bail!("instance buffer size grew too large: {}", buffer_size);- }- instance_buffer_pool.reset(buffer_size * 2);- log::info!(- "increased instance buffer size to {}",- instance_buffer_pool.buffer_size- );- }- }- }+ read_texture_to_image(&target_texture)}/// Renders a scene to a reused offscreen texture without reading pixels@@ -769,209 +640,131 @@ impl MetalRenderer {.clone().expect("just ensured the render target exists");- loop {- let mut instance_buffer = self- .instance_buffer_pool- .lock()- .acquire(&self.device, self.is_unified_memory);-- let command_buffer =- self.draw_primitives_to_texture(scene, &mut instance_buffer, &target_texture, size);-- match command_buffer {- Ok(command_buffer) => {- let instance_buffer_pool = self.instance_buffer_pool.clone();- let instance_buffer = Cell::new(Some(instance_buffer));- let block = ConcreteBlock::new(move |_| {- if let Some(instance_buffer) = instance_buffer.take() {- instance_buffer_pool.lock().release(instance_buffer);- }- });- let block = block.copy();- command_buffer.add_completed_handler(&block);-- // Commit without waiting, mirroring presentation to a real- // window where the CPU doesn't block on the GPU.- command_buffer.commit();- return Ok(());- }- Err(err) => {- log::error!(- "failed to render: {}. retrying with larger instance buffer size",- err- );- let mut instance_buffer_pool = self.instance_buffer_pool.lock();- let buffer_size = instance_buffer_pool.buffer_size;- if buffer_size >= 256 * 1024 * 1024 {- anyhow::bail!("instance buffer size grew too large: {}", buffer_size);- }- instance_buffer_pool.reset(buffer_size * 2);- log::info!(- "increased instance buffer size to {}",- instance_buffer_pool.buffer_size- );- }- }- }- }+ let command_buffer = self.render_frame(scene, &target_texture, size)?;- fn draw_primitives(- &mut self,- scene: &Scene,- instance_buffer: &mut InstanceBuffer,- drawable: &metal::MetalDrawableRef,- viewport_size: Size<DevicePixels>,- ) -> Result<metal::CommandBuffer> {- self.draw_primitives_to_texture(scene, instance_buffer, drawable.texture(), viewport_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_buffer: &mut InstanceBuffer,+ instance_bindings: &InstanceBindings,+ writer: &mut InstanceBufferWriter,texture: &metal::TextureRef,viewport_size: Size<DevicePixels>,) -> Result<metal::CommandBuffer> {let command_queue = self.command_queue.clone();let command_buffer = command_queue.new_command_buffer();let alpha = if self.opaque { 1. } else { 0. };- let mut instance_offset = 0;let mut command_encoder = new_command_encoder_for_texture(command_buffer,texture,viewport_size,- |color_attachment| {- color_attachment.set_load_action(metal::MTLLoadAction::Clear);- color_attachment.set_clear_color(metal::MTLClearColor::new(0., 0., 0., alpha));- },+ Some(metal::MTLClearColor::new(0., 0., 0., alpha)),);for batch in scene.batches() {- let ok = match batch {- PrimitiveBatch::Shadows(range) => self.draw_shadows(- &scene.shadows[range],- instance_buffer,- &mut instance_offset,- viewport_size,- command_encoder,- ),- PrimitiveBatch::Quads(range) => self.draw_quads(- &scene.quads[range],- instance_buffer,- &mut instance_offset,- viewport_size,- command_encoder,- ),+ 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.end_encoding();let did_draw = self.draw_paths_to_intermediate(paths,- instance_buffer,- &mut instance_offset,+ writer,viewport_size,command_buffer,- );+ )?;command_encoder = new_command_encoder_for_texture(command_buffer,texture,viewport_size,- |color_attachment| {- color_attachment.set_load_action(metal::MTLLoadAction::Load);- },+ None,);if did_draw {- self.draw_paths_from_intermediate(+ if let Err(error) = self.draw_paths_from_intermediate(paths,- instance_buffer,- &mut instance_offset,+ writer,viewport_size,command_encoder,- )- } else {- false+ ) {+ command_encoder.end_encoding();+ return Err(error);+ }}}- PrimitiveBatch::Underlines(range) => self.draw_underlines(- &scene.underlines[range],- instance_buffer,- &mut instance_offset,- viewport_size,- command_encoder,- ),+ PrimitiveBatch::Underlines(range) => {+ self.draw_underlines(range, instance_bindings, viewport_size, command_encoder)+ }PrimitiveBatch::MonochromeSprites { texture_id, range } => self.draw_monochrome_sprites(texture_id,- &scene.monochrome_sprites[range],- instance_buffer,- &mut instance_offset,+ range,+ instance_bindings,viewport_size,command_encoder,),PrimitiveBatch::PolychromeSprites { texture_id, range } => self.draw_polychrome_sprites(texture_id,- &scene.polychrome_sprites[range],- instance_buffer,- &mut instance_offset,+ range,+ instance_bindings,viewport_size,command_encoder,),PrimitiveBatch::Surfaces(range) => self.draw_surfaces(- &scene.surfaces[range],- instance_buffer,- &mut instance_offset,+ &scene.surfaces[range.clone()],+ range.start,+ instance_bindings,viewport_size,command_encoder,),PrimitiveBatch::SubpixelSprites { .. } => unreachable!(),- };- if !ok {- command_encoder.end_encoding();- anyhow::bail!(- "scene too large: {} 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(),- );}}command_encoder.end_encoding();- if !self.is_unified_memory {- // Sync the instance buffer to the GPU- instance_buffer.metal_buffer.did_modify_range(NSRange {- location: 0,- length: instance_offset as NSUInteger,- });- }-Ok(command_buffer.to_owned())}fn draw_paths_to_intermediate(&self,paths: &[Path<ScaledPixels>],- instance_buffer: &mut InstanceBuffer,- instance_offset: &mut usize,+ writer: &mut InstanceBufferWriter,viewport_size: Size<DevicePixels>,command_buffer: &metal::CommandBufferRef,- ) -> bool {+ ) -> Result<bool> {if paths.is_empty() {- return true;+ return Ok(false);}- let Some(intermediate_texture) = &self.path_intermediate_texture else {- return 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 = metal::RenderPassDescriptor::new();let color_attachment = render_pass_descriptor@@ -992,27 +785,10 @@ impl MetalRenderer {let command_encoder = command_buffer.new_render_command_encoder(render_pass_descriptor);command_encoder.set_render_pipeline_state(&self.paths_rasterization_pipeline_state);-- align_offset(instance_offset);- 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 vertices_bytes_len = mem::size_of_val(vertices.as_slice());- let next_offset = *instance_offset + vertices_bytes_len;- if next_offset > instance_buffer.size {- command_encoder.end_encoding();- return false;- }command_encoder.set_vertex_buffer(PathRasterizationInputIndex::Vertices as u64,- Some(&instance_buffer.metal_buffer),- *instance_offset as u64,+ Some(&vertex_instance_bindings.buffer),+ vertex_instance_bindings.offset as u64,);command_encoder.set_vertex_bytes(PathRasterizationInputIndex::ViewportSize as u64,@@ -1021,41 +797,29 @@ impl MetalRenderer {);command_encoder.set_fragment_buffer(PathRasterizationInputIndex::Vertices as u64,- Some(&instance_buffer.metal_buffer),- *instance_offset as u64,+ Some(&vertex_instance_bindings.buffer),+ vertex_instance_bindings.offset as u64,);- let buffer_contents =- unsafe { (instance_buffer.metal_buffer.contents() as *mut u8).add(*instance_offset) };- unsafe {- ptr::copy_nonoverlapping(- vertices.as_ptr() as *const u8,- buffer_contents,- vertices_bytes_len,- );- }command_encoder.draw_primitives(metal::MTLPrimitiveType::Triangle,0,vertices.len() as u64,);- *instance_offset = next_offset;command_encoder.end_encoding();- true+ Ok(true)}fn draw_shadows(&self,- shadows: &[Shadow],- instance_buffer: &mut InstanceBuffer,- instance_offset: &mut usize,+ shadows: Range<usize>,+ instance_bindings: &InstanceBindings,viewport_size: Size<DevicePixels>,command_encoder: &metal::RenderCommandEncoderRef,- ) -> bool {+ ) {if shadows.is_empty() {- return true;+ return;}- align_offset(instance_offset);command_encoder.set_render_pipeline_state(&self.shadows_pipeline_state);command_encoder.set_vertex_buffer(@@ -1065,60 +829,39 @@ impl MetalRenderer {);command_encoder.set_vertex_buffer(ShadowInputIndex::Shadows as u64,- Some(&instance_buffer.metal_buffer),- *instance_offset as u64,+ Some(&instance_bindings.shadows.buffer),+ instance_bindings.shadows.offset as u64,);command_encoder.set_fragment_buffer(ShadowInputIndex::Shadows as u64,- Some(&instance_buffer.metal_buffer),- *instance_offset 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 _,);- let shadow_bytes_len = mem::size_of_val(shadows);- let buffer_contents =- unsafe { (instance_buffer.metal_buffer.contents() as *mut u8).add(*instance_offset) };-- let next_offset = *instance_offset + shadow_bytes_len;- if next_offset > instance_buffer.size {- return false;- }-- unsafe {- ptr::copy_nonoverlapping(- shadows.as_ptr() as *const u8,- buffer_contents,- shadow_bytes_len,- );- }-- command_encoder.draw_primitives_instanced(+ command_encoder.draw_primitives_instanced_base_instance(metal::MTLPrimitiveType::Triangle,0,6,shadows.len() as u64,+ shadows.start as u64,);- *instance_offset = next_offset;- true}fn draw_quads(&self,- quads: &[Quad],- instance_buffer: &mut InstanceBuffer,- instance_offset: &mut usize,+ quads: Range<usize>,+ instance_bindings: &InstanceBindings,viewport_size: Size<DevicePixels>,command_encoder: &metal::RenderCommandEncoderRef,- ) -> bool {+ ) {if quads.is_empty() {- return true;+ return;}- align_offset(instance_offset);command_encoder.set_render_pipeline_state(&self.quads_pipeline_state);command_encoder.set_vertex_buffer(@@ -1128,59 +871,43 @@ impl MetalRenderer {);command_encoder.set_vertex_buffer(QuadInputIndex::Quads as u64,- Some(&instance_buffer.metal_buffer),- *instance_offset as u64,+ Some(&instance_bindings.quads.buffer),+ instance_bindings.quads.offset as u64,);command_encoder.set_fragment_buffer(QuadInputIndex::Quads as u64,- Some(&instance_buffer.metal_buffer),- *instance_offset 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 _,);- let quad_bytes_len = mem::size_of_val(quads);- let buffer_contents =- unsafe { (instance_buffer.metal_buffer.contents() as *mut u8).add(*instance_offset) };-- let next_offset = *instance_offset + quad_bytes_len;- if next_offset > instance_buffer.size {- return false;- }-- unsafe {- ptr::copy_nonoverlapping(quads.as_ptr() as *const u8, buffer_contents, quad_bytes_len);- }-- command_encoder.draw_primitives_instanced(+ command_encoder.draw_primitives_instanced_base_instance(metal::MTLPrimitiveType::Triangle,0,6,quads.len() as u64,+ quads.start as u64,);- *instance_offset = next_offset;- true}fn draw_paths_from_intermediate(&self,paths: &[Path<ScaledPixels>],- instance_buffer: &mut InstanceBuffer,- instance_offset: &mut usize,+ writer: &mut InstanceBufferWriter,viewport_size: Size<DevicePixels>,command_encoder: &metal::RenderCommandEncoderRef,- ) -> bool {+ ) -> Result<()> {let Some(first_path) = paths.first() else {- return true;- };-- let Some(ref intermediate_texture) = self.path_intermediate_texture else {- return false;+ return Ok(());};+ let intermediate_texture = self+ .path_intermediate_texture+ .as_ref()+ .context("missing path intermediate texture")?;command_encoder.set_render_pipeline_state(&self.path_sprites_pipeline_state);command_encoder.set_vertex_buffer(@@ -1222,52 +949,32 @@ impl MetalRenderer {sprites = vec![PathSprite { bounds }];}- align_offset(instance_offset);- let sprite_bytes_len = mem::size_of_val(sprites.as_slice());- let next_offset = *instance_offset + sprite_bytes_len;- if next_offset > instance_buffer.size {- return false;- }-+ let sprite_instance_bindings = writer.write(&sprites)?;command_encoder.set_vertex_buffer(SpriteInputIndex::Sprites as u64,- Some(&instance_buffer.metal_buffer),- *instance_offset as u64,+ Some(&sprite_instance_bindings.buffer),+ sprite_instance_bindings.offset as u64,);- let buffer_contents =- unsafe { (instance_buffer.metal_buffer.contents() as *mut u8).add(*instance_offset) };- unsafe {- ptr::copy_nonoverlapping(- sprites.as_ptr() as *const u8,- buffer_contents,- sprite_bytes_len,- );- }-command_encoder.draw_primitives_instanced(metal::MTLPrimitiveType::Triangle,0,6,sprites.len() as u64,);- *instance_offset = next_offset;-- true+ Ok(())}fn draw_underlines(&self,- underlines: &[Underline],- instance_buffer: &mut InstanceBuffer,- instance_offset: &mut usize,+ underlines: Range<usize>,+ instance_bindings: &InstanceBindings,viewport_size: Size<DevicePixels>,command_encoder: &metal::RenderCommandEncoderRef,- ) -> bool {+ ) {if underlines.is_empty() {- return true;+ return;}- align_offset(instance_offset);command_encoder.set_render_pipeline_state(&self.underlines_pipeline_state);command_encoder.set_vertex_buffer(@@ -1277,69 +984,39 @@ impl MetalRenderer {);command_encoder.set_vertex_buffer(UnderlineInputIndex::Underlines as u64,- Some(&instance_buffer.metal_buffer),- *instance_offset as u64,+ Some(&instance_bindings.underlines.buffer),+ instance_bindings.underlines.offset as u64,);command_encoder.set_fragment_buffer(UnderlineInputIndex::Underlines as u64,- Some(&instance_buffer.metal_buffer),- *instance_offset 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 _,);- let underline_bytes_len = mem::size_of_val(underlines);- let buffer_contents =- unsafe { (instance_buffer.metal_buffer.contents() as *mut u8).add(*instance_offset) };-- let next_offset = *instance_offset + underline_bytes_len;- if next_offset > instance_buffer.size {- return false;- }-- unsafe {- ptr::copy_nonoverlapping(- underlines.as_ptr() as *const u8,- buffer_contents,- underline_bytes_len,- );- }-- command_encoder.draw_primitives_instanced(+ command_encoder.draw_primitives_instanced_base_instance(metal::MTLPrimitiveType::Triangle,0,6,underlines.len() as u64,+ underlines.start as u64,);- *instance_offset = next_offset;- true}fn draw_monochrome_sprites(&self,texture_id: AtlasTextureId,- sprites: &[MonochromeSprite],- instance_buffer: &mut InstanceBuffer,- instance_offset: &mut usize,+ sprites: Range<usize>,+ instance_bindings: &InstanceBindings,viewport_size: Size<DevicePixels>,command_encoder: &metal::RenderCommandEncoderRef,- ) -> bool {+ ) {if sprites.is_empty() {- return true;- }- align_offset(instance_offset);-- let sprite_bytes_len = mem::size_of_val(sprites);- let buffer_contents =- unsafe { (instance_buffer.metal_buffer.contents() as *mut u8).add(*instance_offset) };-- let next_offset = *instance_offset + sprite_bytes_len;- if next_offset > instance_buffer.size {- return false;+ return;}let texture = self.sprite_atlas.metal_texture(texture_id);@@ -1355,8 +1032,8 @@ impl MetalRenderer {);command_encoder.set_vertex_buffer(SpriteInputIndex::Sprites as u64,- Some(&instance_buffer.metal_buffer),- *instance_offset as u64,+ Some(&instance_bindings.monochrome_sprites.buffer),+ instance_bindings.monochrome_sprites.offset as u64,);command_encoder.set_vertex_bytes(SpriteInputIndex::ViewportSize as u64,@@ -1370,42 +1047,31 @@ impl MetalRenderer {);command_encoder.set_fragment_buffer(SpriteInputIndex::Sprites as u64,- Some(&instance_buffer.metal_buffer),- *instance_offset 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));- unsafe {- ptr::copy_nonoverlapping(- sprites.as_ptr() as *const u8,- buffer_contents,- sprite_bytes_len,- );- }-- command_encoder.draw_primitives_instanced(+ command_encoder.draw_primitives_instanced_base_instance(metal::MTLPrimitiveType::Triangle,0,6,sprites.len() as u64,+ sprites.start as u64,);- *instance_offset = next_offset;- true}fn draw_polychrome_sprites(&self,texture_id: AtlasTextureId,- sprites: &[PolychromeSprite],- instance_buffer: &mut InstanceBuffer,- instance_offset: &mut usize,+ sprites: Range<usize>,+ instance_bindings: &InstanceBindings,viewport_size: Size<DevicePixels>,command_encoder: &metal::RenderCommandEncoderRef,- ) -> bool {+ ) {if sprites.is_empty() {- return true;+ return;}- align_offset(instance_offset);let texture = self.sprite_atlas.metal_texture(texture_id);let texture_size = size(@@ -1420,8 +1086,8 @@ impl MetalRenderer {);command_encoder.set_vertex_buffer(SpriteInputIndex::Sprites as u64,- Some(&instance_buffer.metal_buffer),- *instance_offset as u64,+ Some(&instance_bindings.polychrome_sprites.buffer),+ instance_bindings.polychrome_sprites.offset as u64,);command_encoder.set_vertex_bytes(SpriteInputIndex::ViewportSize as u64,@@ -1435,59 +1101,50 @@ impl MetalRenderer {);command_encoder.set_fragment_buffer(SpriteInputIndex::Sprites as u64,- Some(&instance_buffer.metal_buffer),- *instance_offset 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));- let sprite_bytes_len = mem::size_of_val(sprites);- let buffer_contents =- unsafe { (instance_buffer.metal_buffer.contents() as *mut u8).add(*instance_offset) };-- let next_offset = *instance_offset + sprite_bytes_len;- if next_offset > instance_buffer.size {- return false;- }-- unsafe {- ptr::copy_nonoverlapping(- sprites.as_ptr() as *const u8,- buffer_contents,- sprite_bytes_len,- );- }-- command_encoder.draw_primitives_instanced(+ command_encoder.draw_primitives_instanced_base_instance(metal::MTLPrimitiveType::Triangle,0,6,sprites.len() as u64,+ sprites.start as u64,);- *instance_offset = next_offset;- true}fn draw_surfaces(&mut self,surfaces: &[PaintSurface],- instance_buffer: &mut InstanceBuffer,- instance_offset: &mut usize,+ first_surface: usize,+ instance_bindings: &InstanceBindings,viewport_size: Size<DevicePixels>,command_encoder: &metal::RenderCommandEncoderRef,- ) -> bool {+ ) {+ if surfaces.is_empty() {+ return;+ }+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 _,);- for surface in surfaces {+ for (index, surface) in surfaces.iter().enumerate() {let texture_size = size(DevicePixels::from(surface.image_buffer.get_width() as i32),DevicePixels::from(surface.image_buffer.get_height() as i32),@@ -1521,17 +1178,6 @@ impl MetalRenderer {).unwrap();- align_offset(instance_offset);- let next_offset = *instance_offset + mem::size_of::<Surface>();- if next_offset > instance_buffer.size {- return false;- }-- command_encoder.set_vertex_buffer(- SurfaceInputIndex::Surfaces as u64,- Some(&instance_buffer.metal_buffer),- *instance_offset as u64,- );command_encoder.set_vertex_bytes(SurfaceInputIndex::TextureSize as u64,mem::size_of_val(&texture_size) as u64,@@ -1547,23 +1193,14 @@ impl MetalRenderer {Some(metal::TextureRef::from_ptr(texture as *mut _))});- unsafe {- let buffer_contents = (instance_buffer.metal_buffer.contents() as *mut u8)- .add(*instance_offset)- as *mut SurfaceBounds;- ptr::write(- buffer_contents,- SurfaceBounds {- bounds: surface.bounds,- content_mask: surface.content_mask,- },- );- }-- command_encoder.draw_primitives(metal::MTLPrimitiveType::Triangle, 0, 6);- *instance_offset = next_offset;+ command_encoder.draw_primitives_instanced_base_instance(+ metal::MTLPrimitiveType::Triangle,+ 0,+ 6,+ 1,+ (first_surface + index) as u64,+ );}- true}}@@ -1571,7 +1208,7 @@ fn new_command_encoder_for_texture<'a>(command_buffer: &'a metal::CommandBufferRef,texture: &'a metal::TextureRef,viewport_size: Size<DevicePixels>,- configure_color_attachment: impl Fn(&RenderPassColorAttachmentDescriptorRef),+ clear_color: Option<metal::MTLClearColor>,) -> &'a metal::RenderCommandEncoderRef {let render_pass_descriptor = metal::RenderPassDescriptor::new();let color_attachment = render_pass_descriptor@@ -1580,7 +1217,12 @@ fn new_command_encoder_for_texture<'a>(.unwrap();color_attachment.set_texture(Some(texture));color_attachment.set_store_action(metal::MTLStoreAction::Store);- configure_color_attachment(color_attachment);+ if let Some(clear_color) = clear_color {+ color_attachment.set_load_action(metal::MTLLoadAction::Clear);+ color_attachment.set_clear_color(clear_color);+ } else {+ color_attachment.set_load_action(metal::MTLLoadAction::Load);+ }let command_encoder = command_buffer.new_render_command_encoder(render_pass_descriptor);command_encoder.set_viewport(metal::MTLViewport {@@ -1594,6 +1236,36 @@ fn new_command_encoder_for_texture<'a>(command_encoder}+#[cfg(any(test, feature = "test-support"))]+fn read_texture_to_image(texture: &metal::TextureRef) -> 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,+ depth: 1,+ },+ };+ texture.get_bytes(+ pixels.as_mut_ptr() as *mut std::ffi::c_void,+ bytes_per_row as u64,+ 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")+}+fn build_pipeline_state(device: &metal::DeviceRef,library: &metal::LibraryRef,@@ -1701,9 +1373,164 @@ fn build_path_rasterization_pipeline_state(.expect("could not create render pipeline state")}-// Align to multiples of 256 make Metal happy.-fn align_offset(offset: &mut usize) {- *offset = (*offset).div_ceil(256) * 256;+#[derive(Clone)]+struct InstanceBinding {+ buffer: metal::Buffer,+ 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: metal::Device,+ pool: Arc<Mutex<InstanceBufferPool>>,+ unified_memory: bool,+ filled: Vec<(InstanceBuffer, usize)>,+ current: InstanceBuffer,+ offset: usize,+}++impl InstanceBufferWriter {+ fn new(+ device: &metal::Device,+ pool: &Arc<Mutex<InstanceBufferPool>>,+ unified_memory: bool,+ ) -> Self {+ let current = pool.lock().acquire(device, unified_memory);+ Self {+ device: device.clone(),+ 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 reservation lies within a buffer this frame owns+ // exclusively, and never overlaps one handed out earlier.+ let values = unsafe {+ let start = (self.current.metal_buffer.contents() as *mut 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())?;+ 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.did_modify_range(NSRange {+ location: 0,+ length: *written as NSUInteger,+ });+ }+ if offset > 0 {+ current.metal_buffer.did_modify_range(NSRange {+ location: 0,+ length: offset as NSUInteger,+ });+ }+ }++ // 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)]diff --git a/crates/gpui_wgpu/src/shaders.wgsl b/crates/gpui_wgpu/src/shaders.wgslindex 747a34d81e0..c009ed98074 100644--- a/crates/gpui_wgpu/src/shaders.wgsl+++ b/crates/gpui_wgpu/src/shaders.wgsl@@ -93,8 +93,8 @@ struct GammaParams {@group(0) @binding(0) var<uniform> globals: GlobalParams;@group(0) @binding(1) var<uniform> gamma_params: GammaParams;-@group(1) @binding(1) var t_sprite: texture_2d<f32>;-@group(1) @binding(2) var s_sprite: sampler;+@group(2) @binding(0) var t_sprite: texture_2d<f32>;+@group(2) @binding(1) var s_sprite: sampler;const M_PI_F: f32 = 3.1415926;const GRAYSCALE_FACTORS: vec3<f32> = vec3<f32>(0.2126, 0.7152, 0.0722);diff --git a/crates/gpui_wgpu/src/wgpu_renderer.rs b/crates/gpui_wgpu/src/wgpu_renderer.rsindex 587315debfa..e30ade6e398 100644--- a/crates/gpui_wgpu/src/wgpu_renderer.rs+++ b/crates/gpui_wgpu/src/wgpu_renderer.rs@@ -1,18 +1,21 @@use crate::{CompositorGpuHint, WgpuAtlas, WgpuContext};+use anyhow::{Context as _, Result};use bytemuck::{Pod, Zeroable};use gpui::{- AtlasTextureId, Background, Bounds, DevicePixels, GpuSpecs, MonochromeSprite, Path, Point,- PolychromeSprite, PrimitiveBatch, Quad, ScaledPixels, Scene, Shadow, Size, SubpixelSprite,- Underline, get_gamma_correction_ratios,+ AtlasTextureId, Background, Bounds, DevicePixels, GpuSpecs, Path, Point, PrimitiveBatch,+ ScaledPixels, Scene, Size, get_gamma_correction_ratios,};use log::warn;#[cfg(not(target_family = "wasm"))]use raw_window_handle::{HasDisplayHandle, HasWindowHandle};use std::cell::RefCell;use std::num::NonZeroU64;+use std::ops::Range;use std::rc::Rc;use std::sync::{Arc, Mutex};+const MAX_INSTANCE_BUFFER_SIZE: u64 = 256 * 1024 * 1024;+#[repr(C)]#[derive(Clone, Copy, Pod, Zeroable)]struct GlobalParams {@@ -94,10 +97,19 @@ struct WgpuPipelines {surfaces: wgpu::RenderPipeline,}+struct InstanceBindings {+ quads: wgpu::BindGroup,+ shadows: wgpu::BindGroup,+ underlines: wgpu::BindGroup,+ monochrome_sprites: wgpu::BindGroup,+ subpixel_sprites: wgpu::BindGroup,+ polychrome_sprites: wgpu::BindGroup,+}+struct WgpuBindGroupLayouts {globals: wgpu::BindGroupLayout,instances: wgpu::BindGroupLayout,- instances_with_texture: wgpu::BindGroupLayout,+ texture: wgpu::BindGroupLayout,surfaces: wgpu::BindGroupLayout,}@@ -381,9 +393,15 @@ impl WgpuRenderer {mapped_at_creation: false,});- let max_buffer_size = device.limits().max_buffer_size;+ // Every frame allocation is exposed as one storage-buffer binding, so+ // its backing buffer must satisfy both the allocation and binding limits.+ let max_buffer_size = device+ .limits()+ .max_buffer_size+ .min(device.limits().max_storage_buffer_binding_size)+ .min(MAX_INSTANCE_BUFFER_SIZE);let storage_buffer_alignment = device.limits().min_storage_buffer_offset_alignment as u64;- let initial_instance_buffer_capacity = 2 * 1024 * 1024;+ let initial_instance_buffer_capacity = (2 * 1024 * 1024).min(max_buffer_size);let instance_buffer = device.create_buffer(&wgpu::BufferDescriptor {label: Some("instance_buffer"),size: initial_instance_buffer_capacity,@@ -539,29 +557,27 @@ impl WgpuRenderer {entries: &[storage_buffer_entry(0)],});- let instances_with_texture =- device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {- label: Some("instances_with_texture_layout"),- entries: &[- storage_buffer_entry(0),- wgpu::BindGroupLayoutEntry {- binding: 1,- visibility: wgpu::ShaderStages::VERTEX_FRAGMENT,- ty: wgpu::BindingType::Texture {- sample_type: wgpu::TextureSampleType::Float { filterable: true },- view_dimension: wgpu::TextureViewDimension::D2,- multisampled: false,- },- count: None,- },- wgpu::BindGroupLayoutEntry {- binding: 2,- visibility: wgpu::ShaderStages::VERTEX_FRAGMENT,- ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),- count: None,+ let texture = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {+ label: Some("texture_layout"),+ entries: &[+ wgpu::BindGroupLayoutEntry {+ binding: 0,+ visibility: wgpu::ShaderStages::VERTEX_FRAGMENT,+ ty: wgpu::BindingType::Texture {+ sample_type: wgpu::TextureSampleType::Float { filterable: true },+ view_dimension: wgpu::TextureViewDimension::D2,+ multisampled: false,},- ],- });+ count: None,+ },+ wgpu::BindGroupLayoutEntry {+ binding: 1,+ visibility: wgpu::ShaderStages::VERTEX_FRAGMENT,+ ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),+ count: None,+ },+ ],+ });let surfaces = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {label: Some("surfaces_layout"),@@ -610,7 +626,7 @@ impl WgpuRenderer {WgpuBindGroupLayouts {globals,instances,- instances_with_texture,+ texture,surfaces,}}@@ -682,13 +698,16 @@ impl WgpuRenderer {fs_entry: &str,globals_layout: &wgpu::BindGroupLayout,data_layout: &wgpu::BindGroupLayout,+ texture_layout: Option<&wgpu::BindGroupLayout>,topology: wgpu::PrimitiveTopology,color_targets: &[Option<wgpu::ColorTargetState>],sample_count: u32,module: &wgpu::ShaderModule| {+ let mut bind_group_layouts = vec![Some(globals_layout), Some(data_layout)];+ bind_group_layouts.extend(texture_layout.map(Some));let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {label: Some(&format!("{name}_layout")),- bind_group_layouts: &[Some(globals_layout), Some(data_layout)],+ bind_group_layouts: &bind_group_layouts,immediate_size: 0,});@@ -733,6 +752,7 @@ impl WgpuRenderer {"fs_quad",&layouts.globals,&layouts.instances,+ None,wgpu::PrimitiveTopology::TriangleStrip,&[Some(color_target.clone())],1,@@ -745,6 +765,7 @@ impl WgpuRenderer {"fs_shadow",&layouts.globals,&layouts.instances,+ None,wgpu::PrimitiveTopology::TriangleStrip,&[Some(color_target.clone())],1,@@ -757,6 +778,7 @@ impl WgpuRenderer {"fs_path_rasterization",&layouts.globals,&layouts.instances,+ None,wgpu::PrimitiveTopology::TriangleList,&[Some(wgpu::ColorTargetState {format: surface_format,@@ -785,7 +807,8 @@ impl WgpuRenderer {"vs_path","fs_path",&layouts.globals,- &layouts.instances_with_texture,+ &layouts.instances,+ Some(&layouts.texture),wgpu::PrimitiveTopology::TriangleStrip,&[Some(wgpu::ColorTargetState {format: surface_format,@@ -802,6 +825,7 @@ impl WgpuRenderer {"fs_underline",&layouts.globals,&layouts.instances,+ None,wgpu::PrimitiveTopology::TriangleStrip,&[Some(color_target.clone())],1,@@ -813,7 +837,8 @@ impl WgpuRenderer {"vs_mono_sprite","fs_mono_sprite",&layouts.globals,- &layouts.instances_with_texture,+ &layouts.instances,+ Some(&layouts.texture),wgpu::PrimitiveTopology::TriangleStrip,&[Some(color_target.clone())],1,@@ -839,7 +864,8 @@ impl WgpuRenderer {"vs_subpixel_sprite","fs_subpixel_sprite",&layouts.globals,- &layouts.instances_with_texture,+ &layouts.instances,+ Some(&layouts.texture),wgpu::PrimitiveTopology::TriangleStrip,&[Some(wgpu::ColorTargetState {format: surface_format,@@ -858,7 +884,8 @@ impl WgpuRenderer {"vs_poly_sprite","fs_poly_sprite",&layouts.globals,- &layouts.instances_with_texture,+ &layouts.instances,+ Some(&layouts.texture),wgpu::PrimitiveTopology::TriangleStrip,&[Some(color_target.clone())],1,@@ -871,6 +898,7 @@ impl WgpuRenderer {"fs_surface",&layouts.globals,&layouts.surfaces,+ None,wgpu::PrimitiveTopology::TriangleStrip,&[Some(color_target)],1,@@ -1202,327 +1230,249 @@ impl WgpuRenderer {);}- loop {- let mut instance_offset: u64 = 0;- let mut overflow = false;+ if let Err(error) = self.record_frame(scene, &frame_view) {+ log::error!("{error:#}");+ self.resources().queue.submit(std::iter::empty());+ return false;+ }- let mut encoder =- self.resources()- .device- .create_command_encoder(&wgpu::CommandEncoderDescriptor {- label: Some("main_encoder"),- });+ frame.present();+ true+ }- {- let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {- label: Some("main_pass"),- color_attachments: &[Some(wgpu::RenderPassColorAttachment {- view: &frame_view,- resolve_target: None,- ops: wgpu::Operations {- load: wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT),- store: wgpu::StoreOp::Store,- },- depth_slice: None,- })],- depth_stencil_attachment: None,- ..Default::default()- });+ fn record_frame(&mut self, scene: &Scene, frame_view: &wgpu::TextureView) -> Result<()> {+ let mut instance_offset = 0;+ let instance_bindings = self+ .write_instances(scene, &mut instance_offset)+ .with_context(|| {+ format!(+ "scene too large: {} paths, {} shadows, {} quads, {} underlines, {} monochrome sprites, {} subpixel sprites, {} polychrome sprites",+ scene.paths.len(),+ scene.shadows.len(),+ scene.quads.len(),+ scene.underlines.len(),+ scene.monochrome_sprites.len(),+ scene.subpixel_sprites.len(),+ scene.polychrome_sprites.len(),+ )+ })?;- for batch in scene.batches() {- let ok = match batch {- PrimitiveBatch::Quads(range) => {- self.draw_quads(&scene.quads[range], &mut instance_offset, &mut pass)- }- PrimitiveBatch::Shadows(range) => self.draw_shadows(- &scene.shadows[range],- &mut instance_offset,- &mut pass,- ),- PrimitiveBatch::Paths(range) => {- let paths = &scene.paths[range];- if paths.is_empty() {- continue;- }+ let mut encoder =+ self.resources()+ .device+ .create_command_encoder(&wgpu::CommandEncoderDescriptor {+ label: Some("main_encoder"),+ });- drop(pass);+ {+ let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {+ label: Some("main_pass"),+ color_attachments: &[Some(wgpu::RenderPassColorAttachment {+ view: frame_view,+ resolve_target: None,+ ops: wgpu::Operations {+ load: wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT),+ store: wgpu::StoreOp::Store,+ },+ depth_slice: None,+ })],+ depth_stencil_attachment: None,+ ..Default::default()+ });- let did_draw = self.draw_paths_to_intermediate(- &mut encoder,- paths,- &mut instance_offset,- );-- pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {- label: Some("main_pass_continued"),- color_attachments: &[Some(wgpu::RenderPassColorAttachment {- view: &frame_view,- resolve_target: None,- ops: wgpu::Operations {- load: wgpu::LoadOp::Load,- store: wgpu::StoreOp::Store,- },- depth_slice: None,- })],- depth_stencil_attachment: None,- ..Default::default()- });-- if did_draw {- self.draw_paths_from_intermediate(- paths,- &mut instance_offset,- &mut pass,- )- } else {- false- }+ for batch in scene.batches() {+ match batch {+ PrimitiveBatch::Quads(range) => self.draw_instances(+ &instance_bindings.quads,+ &self.resources().pipelines.quads,+ instance_range(range),+ &mut pass,+ ),+ PrimitiveBatch::Shadows(range) => self.draw_instances(+ &instance_bindings.shadows,+ &self.resources().pipelines.shadows,+ instance_range(range),+ &mut pass,+ ),+ PrimitiveBatch::Paths(range) => {+ let paths = &scene.paths[range];+ if paths.is_empty() {+ continue;}- PrimitiveBatch::Underlines(range) => self.draw_underlines(- &scene.underlines[range],++ drop(pass);+ let rasterized = self.draw_paths_to_intermediate(+ &mut encoder,+ paths,&mut instance_offset,- &mut pass,- ),- PrimitiveBatch::MonochromeSprites { texture_id, range } => self- .draw_monochrome_sprites(- &scene.monochrome_sprites[range],- texture_id,- &mut instance_offset,- &mut pass,- ),- PrimitiveBatch::SubpixelSprites { texture_id, range } => self- .draw_subpixel_sprites(- &scene.subpixel_sprites[range],- texture_id,- &mut instance_offset,- &mut pass,- ),- PrimitiveBatch::PolychromeSprites { texture_id, range } => self- .draw_polychrome_sprites(- &scene.polychrome_sprites[range],- texture_id,+ )?;++ pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {+ label: Some("main_pass_continued"),+ color_attachments: &[Some(wgpu::RenderPassColorAttachment {+ view: frame_view,+ resolve_target: None,+ ops: wgpu::Operations {+ load: wgpu::LoadOp::Load,+ store: wgpu::StoreOp::Store,+ },+ depth_slice: None,+ })],+ depth_stencil_attachment: None,+ ..Default::default()+ });++ if rasterized {+ self.draw_paths_from_intermediate(+ paths,&mut instance_offset,&mut pass,- ),- PrimitiveBatch::Surfaces(_surfaces) => {- // Surfaces are macOS-only for video playback- // Not implemented for Linux/wgpu- true+ )?;}- };- if !ok {- overflow = true;- break;}+ PrimitiveBatch::Underlines(range) => self.draw_instances(+ &instance_bindings.underlines,+ &self.resources().pipelines.underlines,+ instance_range(range),+ &mut pass,+ ),+ PrimitiveBatch::MonochromeSprites { texture_id, range } => self.draw_sprites(+ &instance_bindings.monochrome_sprites,+ texture_id,+ &self.resources().pipelines.mono_sprites,+ instance_range(range),+ &mut pass,+ ),+ PrimitiveBatch::SubpixelSprites { texture_id, range } => {+ let resources = self.resources();+ self.draw_sprites(+ &instance_bindings.subpixel_sprites,+ texture_id,+ resources+ .pipelines+ .subpixel_sprites+ .as_ref()+ .unwrap_or(&resources.pipelines.mono_sprites),+ instance_range(range),+ &mut pass,+ );+ }+ PrimitiveBatch::PolychromeSprites { texture_id, range } => self.draw_sprites(+ &instance_bindings.polychrome_sprites,+ texture_id,+ &self.resources().pipelines.poly_sprites,+ instance_range(range),+ &mut pass,+ ),+ // Surfaces are macOS-only for video playback and are not+ // implemented by the WGPU renderer.+ PrimitiveBatch::Surfaces(_surfaces) => {}}}-- if overflow {- drop(encoder);- if self.instance_buffer_capacity >= self.max_buffer_size {- log::error!(- "instance buffer size grew too large: {}",- self.instance_buffer_capacity- );- frame.present();- return true;- }- self.grow_instance_buffer();- continue;- }-- self.resources()- .queue- .submit(std::iter::once(encoder.finish()));- frame.present();- return true;}- }-- fn draw_quads(- &self,- quads: &[Quad],- instance_offset: &mut u64,- pass: &mut wgpu::RenderPass<'_>,- ) -> bool {- let data = unsafe { Self::instance_bytes(quads) };- self.draw_instances(- data,- quads.len() as u32,- &self.resources().pipelines.quads,- instance_offset,- pass,- )- }- fn draw_shadows(- &self,- shadows: &[Shadow],- instance_offset: &mut u64,- pass: &mut wgpu::RenderPass<'_>,- ) -> bool {- let data = unsafe { Self::instance_bytes(shadows) };- self.draw_instances(- data,- shadows.len() as u32,- &self.resources().pipelines.shadows,- instance_offset,- pass,- )- }-- fn draw_underlines(- &self,- underlines: &[Underline],- instance_offset: &mut u64,- pass: &mut wgpu::RenderPass<'_>,- ) -> bool {- let data = unsafe { Self::instance_bytes(underlines) };- self.draw_instances(- data,- underlines.len() as u32,- &self.resources().pipelines.underlines,- instance_offset,- pass,- )+ self.resources()+ .queue+ .submit(std::iter::once(encoder.finish()));+ Ok(())}- fn draw_monochrome_sprites(- &self,- sprites: &[MonochromeSprite],- texture_id: AtlasTextureId,+ fn write_instances(+ &mut self,+ scene: &Scene,instance_offset: &mut u64,- pass: &mut wgpu::RenderPass<'_>,- ) -> bool {- let tex_info = self.atlas.get_texture_info(texture_id);- let data = unsafe { Self::instance_bytes(sprites) };- self.draw_instances_with_texture(- data,- sprites.len() as u32,- &tex_info.view,- &self.resources().pipelines.mono_sprites,- instance_offset,- pass,- )+ ) -> Result<InstanceBindings> {+ Ok(InstanceBindings {+ quads: self.write_instance_binding("quads_bind_group", instance_offset, unsafe {+ Self::instance_bytes(&scene.quads)+ })?,+ shadows: self.write_instance_binding(+ "shadows_bind_group",+ instance_offset,+ unsafe { Self::instance_bytes(&scene.shadows) },+ )?,+ underlines: self.write_instance_binding(+ "underlines_bind_group",+ instance_offset,+ unsafe { Self::instance_bytes(&scene.underlines) },+ )?,+ monochrome_sprites: self.write_instance_binding(+ "monochrome_sprites_bind_group",+ instance_offset,+ unsafe { Self::instance_bytes(&scene.monochrome_sprites) },+ )?,+ subpixel_sprites: self.write_instance_binding(+ "subpixel_sprites_bind_group",+ instance_offset,+ unsafe { Self::instance_bytes(&scene.subpixel_sprites) },+ )?,+ polychrome_sprites: self.write_instance_binding(+ "polychrome_sprites_bind_group",+ instance_offset,+ unsafe { Self::instance_bytes(&scene.polychrome_sprites) },+ )?,+ })}- fn draw_subpixel_sprites(+ fn create_texture_bind_group(&self,- sprites: &[SubpixelSprite],- texture_id: AtlasTextureId,- instance_offset: &mut u64,- pass: &mut wgpu::RenderPass<'_>,- ) -> bool {- let tex_info = self.atlas.get_texture_info(texture_id);- let data = unsafe { Self::instance_bytes(sprites) };+ label: &str,+ texture_view: &wgpu::TextureView,+ ) -> wgpu::BindGroup {let resources = self.resources();- let pipeline = resources- .pipelines- .subpixel_sprites- .as_ref()- .unwrap_or(&resources.pipelines.mono_sprites);- self.draw_instances_with_texture(- data,- sprites.len() as u32,- &tex_info.view,- pipeline,- instance_offset,- pass,- )- }-- fn draw_polychrome_sprites(- &self,- sprites: &[PolychromeSprite],- texture_id: AtlasTextureId,- instance_offset: &mut u64,- pass: &mut wgpu::RenderPass<'_>,- ) -> bool {- let tex_info = self.atlas.get_texture_info(texture_id);- let data = unsafe { Self::instance_bytes(sprites) };- self.draw_instances_with_texture(- data,- sprites.len() as u32,- &tex_info.view,- &self.resources().pipelines.poly_sprites,- instance_offset,- pass,- )+ resources+ .device+ .create_bind_group(&wgpu::BindGroupDescriptor {+ label: Some(label),+ layout: &resources.bind_group_layouts.texture,+ entries: &[+ wgpu::BindGroupEntry {+ binding: 0,+ resource: wgpu::BindingResource::TextureView(texture_view),+ },+ wgpu::BindGroupEntry {+ binding: 1,+ resource: wgpu::BindingResource::Sampler(&resources.atlas_sampler),+ },+ ],+ })}fn draw_instances(&self,- data: &[u8],- instance_count: u32,+ bind_group: &wgpu::BindGroup,pipeline: &wgpu::RenderPipeline,- instance_offset: &mut u64,+ instances: Range<u32>,pass: &mut wgpu::RenderPass<'_>,- ) -> bool {- if instance_count == 0 {- return true;+ ) {+ if instances.is_empty() {+ return;}- let Some((offset, size)) = self.write_to_instance_buffer(instance_offset, data) else {- return false;- };- let resources = self.resources();- let bind_group = resources- .device- .create_bind_group(&wgpu::BindGroupDescriptor {- label: None,- layout: &resources.bind_group_layouts.instances,- entries: &[wgpu::BindGroupEntry {- binding: 0,- resource: self.instance_binding(offset, size),- }],- });pass.set_pipeline(pipeline);- pass.set_bind_group(0, &resources.globals_bind_group, &[]);- pass.set_bind_group(1, &bind_group, &[]);- pass.draw(0..4, 0..instance_count);- true+ pass.set_bind_group(0, &self.resources().globals_bind_group, &[]);+ pass.set_bind_group(1, bind_group, &[]);+ pass.draw(0..4, instances);}- fn draw_instances_with_texture(+ fn draw_sprites(&self,- data: &[u8],- instance_count: u32,- texture_view: &wgpu::TextureView,+ sprite_instances: &wgpu::BindGroup,+ texture_id: AtlasTextureId,pipeline: &wgpu::RenderPipeline,- instance_offset: &mut u64,+ instances: Range<u32>,pass: &mut wgpu::RenderPass<'_>,- ) -> bool {- if instance_count == 0 {- return true;+ ) {+ if instances.is_empty() {+ return;}- let Some((offset, size)) = self.write_to_instance_buffer(instance_offset, data) else {- return false;- };- let resources = self.resources();- let bind_group = resources- .device- .create_bind_group(&wgpu::BindGroupDescriptor {- label: None,- layout: &resources.bind_group_layouts.instances_with_texture,- entries: &[- wgpu::BindGroupEntry {- binding: 0,- resource: self.instance_binding(offset, size),- },- wgpu::BindGroupEntry {- binding: 1,- resource: wgpu::BindingResource::TextureView(texture_view),- },- wgpu::BindGroupEntry {- binding: 2,- resource: wgpu::BindingResource::Sampler(&resources.atlas_sampler),- },- ],- });+ let texture_info = self.atlas.get_texture_info(texture_id);+ let texture =+ self.create_texture_bind_group("atlas_texture_bind_group", &texture_info.view);pass.set_pipeline(pipeline);- pass.set_bind_group(0, &resources.globals_bind_group, &[]);- pass.set_bind_group(1, &bind_group, &[]);- pass.draw(0..4, 0..instance_count);- true+ pass.set_bind_group(0, &self.resources().globals_bind_group, &[]);+ pass.set_bind_group(1, sprite_instances, &[]);+ pass.set_bind_group(2, &texture, &[]);+ pass.draw(0..4, instances);}unsafe fn instance_bytes<T>(instances: &[T]) -> &[u8] {@@ -1535,11 +1485,11 @@ impl WgpuRenderer {}fn draw_paths_from_intermediate(- &self,+ &mut self,paths: &[Path<ScaledPixels>],instance_offset: &mut u64,pass: &mut wgpu::RenderPass<'_>,- ) -> bool {+ ) -> Result<()> {let first_path = &paths[0];let sprites: Vec<PathSprite> = if paths.last().map(|p| &p.order) == Some(&first_path.order){@@ -1557,28 +1507,32 @@ impl WgpuRenderer {vec![PathSprite { bounds }]};- let resources = self.resources();- let Some(path_intermediate_view) = resources.path_intermediate_view.as_ref() else {- return true;+ let Some(path_intermediate_view) = self.resources().path_intermediate_view.clone() else {+ return Ok(());};-- let sprite_data = unsafe { Self::instance_bytes(&sprites) };- self.draw_instances_with_texture(- sprite_data,- sprites.len() as u32,- path_intermediate_view,- &resources.pipelines.paths,- instance_offset,- pass,- )+ let instances =+ self.write_instance_binding("path_sprites_bind_group", instance_offset, unsafe {+ Self::instance_bytes(&sprites)+ })?;+ let texture = self.create_texture_bind_group(+ "path_intermediate_texture_bind_group",+ &path_intermediate_view,+ );+ let resources = self.resources();+ pass.set_pipeline(&resources.pipelines.paths);+ pass.set_bind_group(0, &resources.globals_bind_group, &[]);+ pass.set_bind_group(1, &instances, &[]);+ pass.set_bind_group(2, &texture, &[]);+ pass.draw(0..4, 0..sprites.len() as u32);+ Ok(())}fn draw_paths_to_intermediate(- &self,+ &mut self,encoder: &mut wgpu::CommandEncoder,paths: &[Path<ScaledPixels>],instance_offset: &mut u64,- ) -> bool {+ ) -> Result<bool> {let mut vertices = Vec::new();for path in paths {let bounds = path.clipped_bounds();@@ -1591,30 +1545,18 @@ impl WgpuRenderer {}if vertices.is_empty() {- return true;+ return Ok(false);}- let vertex_data = unsafe { Self::instance_bytes(&vertices) };- let Some((vertex_offset, vertex_size)) =- self.write_to_instance_buffer(instance_offset, vertex_data)- else {- return false;- };+ let data_bind_group = self.write_instance_binding(+ "path_rasterization_bind_group",+ instance_offset,+ unsafe { Self::instance_bytes(&vertices) },+ )?;let resources = self.resources();- let data_bind_group = resources- .device- .create_bind_group(&wgpu::BindGroupDescriptor {- label: Some("path_rasterization_bind_group"),- layout: &resources.bind_group_layouts.instances,- entries: &[wgpu::BindGroupEntry {- binding: 0,- resource: self.instance_binding(vertex_offset, vertex_size),- }],- });-let Some(path_intermediate_view) = resources.path_intermediate_view.as_ref() else {- return true;+ return Ok(false);};let (target_view, resolve_target) = if let Some(ref msaa_view) = resources.path_msaa_view {@@ -1645,46 +1587,75 @@ impl WgpuRenderer {pass.draw(0..vertices.len() as u32, 0..1);}- true- }-- fn grow_instance_buffer(&mut self) {- let new_capacity = (self.instance_buffer_capacity * 2).min(self.max_buffer_size);- log::info!("increased instance buffer size to {}", new_capacity);- let resources = self.resources_mut();- resources.instance_buffer = resources.device.create_buffer(&wgpu::BufferDescriptor {- label: Some("instance_buffer"),- size: new_capacity,- usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST,- mapped_at_creation: false,- });- self.instance_buffer_capacity = new_capacity;+ Ok(true)}- fn write_to_instance_buffer(- &self,+ fn write_instance_binding(+ &mut self,+ label: &str,instance_offset: &mut u64,data: &[u8],- ) -> Option<(u64, NonZeroU64)> {- let offset = (*instance_offset).next_multiple_of(self.storage_buffer_alignment);+ ) -> Result<wgpu::BindGroup> {+ // wgpu rejects zero-sized bindings, so empty primitive arrays still+ // reserve the 16-byte minimum.let size = (data.len() as u64).max(16);+ let mut offset = (*instance_offset).next_multiple_of(self.storage_buffer_alignment.max(1));if offset + size > self.instance_buffer_capacity {- return None;+ self.grow_instance_buffer(size)?;+ offset = 0;}- let resources = self.resources();- resources- .queue- .write_buffer(&resources.instance_buffer, offset, data);*instance_offset = offset + size;- Some((offset, NonZeroU64::new(size).expect("size is at least 16")))++ let resources = self.resources();+ if !data.is_empty() {+ resources+ .queue+ .write_buffer(&resources.instance_buffer, offset, data);+ }+ let bind_group = resources+ .device+ .create_bind_group(&wgpu::BindGroupDescriptor {+ label: Some(label),+ layout: &resources.bind_group_layouts.instances,+ entries: &[wgpu::BindGroupEntry {+ binding: 0,+ resource: wgpu::BindingResource::Buffer(wgpu::BufferBinding {+ buffer: &resources.instance_buffer,+ offset,+ size: NonZeroU64::new(size),+ }),+ }],+ });+ Ok(bind_group)}- fn instance_binding(&self, offset: u64, size: NonZeroU64) -> wgpu::BindingResource<'_> {- wgpu::BindingResource::Buffer(wgpu::BufferBinding {- buffer: &self.resources().instance_buffer,- offset,- size: Some(size),- })+ fn grow_instance_buffer(&mut self, required: u64) -> Result<()> {+ let capacity = (self.instance_buffer_capacity * 2)+ .max(required.next_power_of_two())+ .min(self.max_buffer_size);+ anyhow::ensure!(+ capacity >= required,+ "instance buffer needs {required} bytes, above the device maximum of {}",+ self.max_buffer_size+ );+ anyhow::ensure!(+ capacity > self.instance_buffer_capacity,+ "frame instance data exceeds the {}-byte maximum",+ self.max_buffer_size+ );+ log::debug!(+ "instance buffer grown from {} to {capacity}",+ self.instance_buffer_capacity+ );+ let resources = self.resources_mut();+ resources.instance_buffer = resources.device.create_buffer(&wgpu::BufferDescriptor {+ label: Some("instance_buffer"),+ size: capacity,+ usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST,+ mapped_at_creation: false,+ });+ self.instance_buffer_capacity = capacity;+ Ok(())}/// Mark the surface as unconfigured so rendering is skipped until a new@@ -1851,6 +1822,10 @@ impl WgpuRenderer {}}+fn instance_range(range: Range<usize>) -> Range<u32> {+ range.start as u32..range.end as u32+}+#[cfg(not(target_family = "wasm"))]fn create_surface(instance: &wgpu::Instance,diff --git a/crates/gpui_windows/src/directx_renderer.rs b/crates/gpui_windows/src/directx_renderer.rsindex 8a350682e23..5719c12f2d5 100644--- a/crates/gpui_windows/src/directx_renderer.rs+++ b/crates/gpui_windows/src/directx_renderer.rs@@ -27,6 +27,7 @@ pub(crate) const DISABLE_DIRECT_COMPOSITION: &str = "GPUI_DISABLE_DIRECT_COMPOSIconst RENDER_TARGET_FORMAT: DXGI_FORMAT = DXGI_FORMAT_B8G8R8A8_UNORM;// This configuration is used for MSAA rendering on paths only, and it's guaranteed to be supported by DirectX 11.const PATH_MULTISAMPLE_COUNT: u32 = 4;+const MAX_INSTANCE_BUFFER_SIZE: usize = 256 * 1024 * 1024;pub(crate) struct FontInfo {pub gamma_ratios: [f32; 4],@@ -95,6 +96,7 @@ struct DirectXRenderPipelines {struct DirectXGlobalElements {global_params_buffer: Option<ID3D11Buffer>,+ batch_params_buffer: Option<ID3D11Buffer>,sampler: Option<ID3D11SamplerState>,}@@ -229,6 +231,12 @@ impl DirectXRenderer {device_context.OMSetRenderTargets(Some(slice::from_ref(&resources.render_target_view)), None);device_context.RSSetViewports(Some(slice::from_ref(&resources.viewport)));+ device_context+ .VSSetConstantBuffers(0, Some(slice::from_ref(&self.globals.global_params_buffer)));+ device_context+ .VSSetConstantBuffers(1, Some(slice::from_ref(&self.globals.batch_params_buffer)));+ device_context+ .PSSetConstantBuffers(0, Some(slice::from_ref(&self.globals.global_params_buffer)));}Ok(())}@@ -487,17 +495,11 @@ impl DirectXRenderer {}let devices = self.devices.as_ref().context("devices missing")?;self.pipelines.shadow_pipeline.draw_range(- &devices.device,&devices.device_context,- slice::from_ref(- &self- .resources- .as_ref()- .context("resources missing")?- .viewport,- ),- slice::from_ref(&self.globals.global_params_buffer),- 4,+ self.globals+ .batch_params_buffer+ .as_ref()+ .context("batch params buffer missing")?,start as u32,len as u32,)@@ -509,17 +511,11 @@ impl DirectXRenderer {}let devices = self.devices.as_ref().context("devices missing")?;self.pipelines.quad_pipeline.draw_range(- &devices.device,&devices.device_context,- slice::from_ref(- &self- .resources- .as_ref()- .context("resources missing")?- .viewport,- ),- slice::from_ref(&self.globals.global_params_buffer),- 4,+ self.globals+ .batch_params_buffer+ .as_ref()+ .context("batch params buffer missing")?,start as u32,len as u32,)@@ -565,8 +561,6 @@ impl DirectXRenderer {self.pipelines.path_rasterization_pipeline.draw(&devices.device_context,- slice::from_ref(&resources.viewport),- slice::from_ref(&self.globals.global_params_buffer),D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST,vertices.len() as u32,1,@@ -629,8 +623,6 @@ impl DirectXRenderer {self.pipelines.path_sprite_pipeline.draw_with_texture(&devices.device_context,slice::from_ref(&resources.path_intermediate_srv),- slice::from_ref(&resources.viewport),- slice::from_ref(&self.globals.global_params_buffer),slice::from_ref(&self.globals.sampler),sprites.len() as u32,)@@ -641,13 +633,12 @@ impl DirectXRenderer {return Ok(());}let devices = self.devices.as_ref().context("devices missing")?;- let resources = self.resources.as_ref().context("resources missing")?;self.pipelines.underline_pipeline.draw_range(- &devices.device,&devices.device_context,- slice::from_ref(&resources.viewport),- slice::from_ref(&self.globals.global_params_buffer),- 4,+ self.globals+ .batch_params_buffer+ .as_ref()+ .context("batch params buffer missing")?,start as u32,len as u32,)@@ -663,14 +654,14 @@ impl DirectXRenderer {return Ok(());}let devices = self.devices.as_ref().context("devices missing")?;- let resources = self.resources.as_ref().context("resources missing")?;let texture_view = self.atlas.get_texture_view(texture_id);self.pipelines.mono_sprites.draw_range_with_texture(- &devices.device,&devices.device_context,&texture_view,- slice::from_ref(&resources.viewport),- slice::from_ref(&self.globals.global_params_buffer),+ self.globals+ .batch_params_buffer+ .as_ref()+ .context("batch params buffer missing")?,slice::from_ref(&self.globals.sampler),start as u32,len as u32,@@ -687,14 +678,14 @@ impl DirectXRenderer {return Ok(());}let devices = self.devices.as_ref().context("devices missing")?;- let resources = self.resources.as_ref().context("resources missing")?;let texture_view = self.atlas.get_texture_view(texture_id);self.pipelines.subpixel_sprites.draw_range_with_texture(- &devices.device,&devices.device_context,&texture_view,- slice::from_ref(&resources.viewport),- slice::from_ref(&self.globals.global_params_buffer),+ self.globals+ .batch_params_buffer+ .as_ref()+ .context("batch params buffer missing")?,slice::from_ref(&self.globals.sampler),start as u32,len as u32,@@ -711,14 +702,14 @@ impl DirectXRenderer {return Ok(());}let devices = self.devices.as_ref().context("devices missing")?;- let resources = self.resources.as_ref().context("resources missing")?;let texture_view = self.atlas.get_texture_view(texture_id);self.pipelines.poly_sprites.draw_range_with_texture(- &devices.device,&devices.device_context,&texture_view,- slice::from_ref(&resources.viewport),- slice::from_ref(&self.globals.global_params_buffer),+ self.globals+ .batch_params_buffer+ .as_ref()+ .context("batch params buffer missing")?,slice::from_ref(&self.globals.sampler),start as u32,len as u32,@@ -948,18 +939,8 @@ impl DirectComposition {impl DirectXGlobalElements {pub fn new(device: &ID3D11Device) -> Result<Self> {- let global_params_buffer = unsafe {- let desc = D3D11_BUFFER_DESC {- ByteWidth: std::mem::size_of::<GlobalParams>() as u32,- Usage: D3D11_USAGE_DYNAMIC,- BindFlags: D3D11_BIND_CONSTANT_BUFFER.0 as u32,- CPUAccessFlags: D3D11_CPU_ACCESS_WRITE.0 as u32,- ..Default::default()- };- let mut buffer = None;- device.CreateBuffer(&desc, None, Some(&mut buffer))?;- buffer- };+ let global_params_buffer = create_constant_buffer::<GlobalParams>(device)?;+ let batch_params_buffer = create_constant_buffer::<BatchParams>(device)?;let sampler = unsafe {let desc = D3D11_SAMPLER_DESC {@@ -981,6 +962,7 @@ impl DirectXGlobalElements {Ok(Self {global_params_buffer,+ batch_params_buffer,sampler,})}@@ -997,6 +979,15 @@ struct GlobalParams {_pad: [u32; 3],}+#[derive(Clone, Copy, Debug, Default)]+#[repr(C, align(16))]+struct BatchParams {+ start_index: u32,+ _padding: [u32; 3],+}++const _: () = assert!(std::mem::size_of::<BatchParams>() == 16);+struct PipelineState<T> {label: &'static str,vertex: ID3D11VertexShader,@@ -1046,7 +1037,17 @@ impl<T> PipelineState<T> {data: &[T],) -> Result<()> {if self.buffer_size < data.len() {- let new_buffer_size = data.len().next_power_of_two();+ let element_size = std::mem::size_of::<T>();+ let required_size = std::mem::size_of_val(data);+ anyhow::ensure!(+ required_size <= MAX_INSTANCE_BUFFER_SIZE,+ "{} buffer needs {required_size} bytes, above the maximum of {MAX_INSTANCE_BUFFER_SIZE}",+ self.label+ );+ let new_buffer_size = data+ .len()+ .next_power_of_two()+ .min(MAX_INSTANCE_BUFFER_SIZE / element_size);log::debug!("Updating {} buffer size from {} to {}",self.label,@@ -1065,8 +1066,6 @@ impl<T> PipelineState<T> {fn draw(&self,device_context: &ID3D11DeviceContext,- viewport: &[D3D11_VIEWPORT],- global_params: &[Option<ID3D11Buffer>],topology: D3D_PRIMITIVE_TOPOLOGY,vertex_count: u32,instance_count: u32,@@ -1075,10 +1074,8 @@ impl<T> PipelineState<T> {device_context,slice::from_ref(&self.view),topology,- viewport,&self.vertex,&self.fragment,- global_params,&self.blend_state,);unsafe {@@ -1091,8 +1088,6 @@ impl<T> PipelineState<T> {&self,device_context: &ID3D11DeviceContext,texture: &[Option<ID3D11ShaderResourceView>],- viewport: &[D3D11_VIEWPORT],- global_params: &[Option<ID3D11Buffer>],sampler: &[Option<ID3D11SamplerState>],instance_count: u32,) -> Result<()> {@@ -1100,10 +1095,8 @@ impl<T> PipelineState<T> {device_context,slice::from_ref(&self.view),D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP,- viewport,&self.vertex,&self.fragment,- global_params,&self.blend_state,);unsafe {@@ -1118,51 +1111,52 @@ impl<T> PipelineState<T> {fn draw_range(&self,- device: &ID3D11Device,device_context: &ID3D11DeviceContext,- viewport: &[D3D11_VIEWPORT],- global_params: &[Option<ID3D11Buffer>],- vertex_count: u32,+ batch_params_buffer: &ID3D11Buffer,first_instance: u32,instance_count: u32,) -> Result<()> {- let view = create_buffer_view_range(device, &self.buffer, first_instance, instance_count)?;+ anyhow::ensure!(+ first_instance as usize + instance_count as usize <= self.buffer_size,+ "DirectX instance range exceeds the {} buffer",+ self.label+ );+ update_batch_start(device_context, batch_params_buffer, first_instance)?;set_pipeline_state(device_context,- slice::from_ref(&view),+ slice::from_ref(&self.view),D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP,- viewport,&self.vertex,&self.fragment,- global_params,&self.blend_state,);unsafe {- device_context.DrawInstanced(vertex_count, instance_count, 0, 0);+ device_context.DrawInstanced(4, instance_count, 0, 0);}Ok(())}fn draw_range_with_texture(&self,- device: &ID3D11Device,device_context: &ID3D11DeviceContext,texture: &[Option<ID3D11ShaderResourceView>],- viewport: &[D3D11_VIEWPORT],- global_params: &[Option<ID3D11Buffer>],+ batch_params_buffer: &ID3D11Buffer,sampler: &[Option<ID3D11SamplerState>],first_instance: u32,instance_count: u32,) -> Result<()> {- let view = create_buffer_view_range(device, &self.buffer, first_instance, instance_count)?;+ anyhow::ensure!(+ first_instance as usize + instance_count as usize <= self.buffer_size,+ "DirectX instance range exceeds the {} buffer",+ self.label+ );+ update_batch_start(device_context, batch_params_buffer, first_instance)?;set_pipeline_state(device_context,- slice::from_ref(&view),+ slice::from_ref(&self.view),D3D_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP,- viewport,&self.vertex,&self.fragment,- global_params,&self.blend_state,);unsafe {@@ -1282,7 +1276,14 @@ fn create_resources(create_path_intermediate_texture(&devices.device, width, height)?;let (path_intermediate_msaa_texture, path_intermediate_msaa_view) =create_path_intermediate_msaa_texture_and_view(&devices.device, width, height)?;- let viewport = set_viewport(&devices.device_context, width as f32, height as f32);+ let viewport = D3D11_VIEWPORT {+ TopLeftX: 0.0,+ TopLeftY: 0.0,+ Width: width as f32,+ Height: height as f32,+ MinDepth: 0.0,+ MaxDepth: 1.0,+ };Ok((render_target,render_target_view,@@ -1369,20 +1370,6 @@ fn create_path_intermediate_msaa_texture_and_view(Ok((msaa_texture, Some(msaa_view.unwrap())))}-#[inline]-fn set_viewport(device_context: &ID3D11DeviceContext, width: f32, height: f32) -> D3D11_VIEWPORT {- let viewport = [D3D11_VIEWPORT {- TopLeftX: 0.0,- TopLeftY: 0.0,- Width: width,- Height: height,- MinDepth: 0.0,- MaxDepth: 1.0,- }];- unsafe { device_context.RSSetViewports(Some(&viewport)) };- viewport[0]-}-#[inline]fn set_rasterizer_state(device: &ID3D11Device, device_context: &ID3D11DeviceContext) -> Result<()> {let desc = D3D11_RASTERIZER_DESC {@@ -1504,6 +1491,22 @@ fn create_fragment_shader(device: &ID3D11Device, bytes: &[u8]) -> Result<ID3D11P}}+#[inline]+fn create_constant_buffer<T>(device: &ID3D11Device) -> Result<Option<ID3D11Buffer>> {+ const { assert!(std::mem::size_of::<T>() != 0 && std::mem::size_of::<T>().is_multiple_of(16)) };+ let desc = D3D11_BUFFER_DESC {+ ByteWidth: std::mem::size_of::<T>() as u32,+ Usage: D3D11_USAGE_DYNAMIC,+ BindFlags: D3D11_BIND_CONSTANT_BUFFER.0 as u32,+ CPUAccessFlags: D3D11_CPU_ACCESS_WRITE.0 as u32,+ MiscFlags: 0,+ StructureByteStride: 0,+ };+ let mut buffer = None;+ unsafe { device.CreateBuffer(&desc, None, Some(&mut buffer)) }?;+ Ok(buffer)+}+#[inline]fn create_buffer(device: &ID3D11Device,@@ -1533,32 +1536,6 @@ fn create_buffer_view(Ok(view)}-#[inline]-fn create_buffer_view_range(- device: &ID3D11Device,- buffer: &ID3D11Buffer,- first_element: u32,- num_elements: u32,-) -> Result<Option<ID3D11ShaderResourceView>> {- let desc = D3D11_SHADER_RESOURCE_VIEW_DESC {- Format: DXGI_FORMAT_UNKNOWN,- ViewDimension: D3D11_SRV_DIMENSION_BUFFER,- Anonymous: D3D11_SHADER_RESOURCE_VIEW_DESC_0 {- Buffer: D3D11_BUFFER_SRV {- Anonymous1: D3D11_BUFFER_SRV_0 {- FirstElement: first_element,- },- Anonymous2: D3D11_BUFFER_SRV_1 {- NumElements: num_elements,- },- },- },- };- let mut view = None;- unsafe { device.CreateShaderResourceView(buffer, Some(&desc), Some(&mut view)) }?;- Ok(view)-}-#[inline]fn update_buffer<T>(device_context: &ID3D11DeviceContext,@@ -1574,26 +1551,37 @@ fn update_buffer<T>(Ok(())}+#[inline]+fn update_batch_start(+ device_context: &ID3D11DeviceContext,+ buffer: &ID3D11Buffer,+ first_instance: u32,+) -> Result<()> {+ update_buffer(+ device_context,+ buffer,+ &[BatchParams {+ start_index: first_instance,+ _padding: [0; 3],+ }],+ )+}+#[inline]fn set_pipeline_state(device_context: &ID3D11DeviceContext,buffer_view: &[Option<ID3D11ShaderResourceView>],topology: D3D_PRIMITIVE_TOPOLOGY,- viewport: &[D3D11_VIEWPORT],vertex_shader: &ID3D11VertexShader,fragment_shader: &ID3D11PixelShader,- global_params: &[Option<ID3D11Buffer>],blend_state: &ID3D11BlendState,) {unsafe {device_context.VSSetShaderResources(1, Some(buffer_view));device_context.PSSetShaderResources(1, Some(buffer_view));device_context.IASetPrimitiveTopology(topology);- device_context.RSSetViewports(Some(viewport));device_context.VSSetShader(vertex_shader, None);device_context.PSSetShader(fragment_shader, None);- device_context.VSSetConstantBuffers(0, Some(global_params));- device_context.PSSetConstantBuffers(0, Some(global_params));device_context.OMSetBlendState(blend_state, None, 0xFFFFFFFF);}}diff --git a/crates/gpui_windows/src/shaders.hlsl b/crates/gpui_windows/src/shaders.hlslindex 483f0399385..d20cb317dbf 100644--- a/crates/gpui_windows/src/shaders.hlsl+++ b/crates/gpui_windows/src/shaders.hlsl@@ -9,6 +9,11 @@ cbuffer GlobalParams: register(b0) {uint3 global_pad;};+cbuffer BatchParams: register(b1) {+ uint batch_start_index;+ uint3 batch_pad;+};+Texture2D<float4> t_sprite: register(t0);SamplerState s_sprite: register(s0);@@ -525,8 +530,9 @@ struct QuadFragmentInput {StructuredBuffer<Quad> quads: register(t1);-QuadVertexOutput quad_vertex(uint vertex_id: SV_VertexID, uint quad_id: SV_InstanceID) {+QuadVertexOutput quad_vertex(uint vertex_id: SV_VertexID, uint instance_id: SV_InstanceID) {float2 unit_vertex = float2(float(vertex_id & 1u), 0.5 * float(vertex_id & 2u));+ uint quad_id = batch_start_index + instance_id;Quad quad = quads[quad_id];float4 device_position = to_device_position(unit_vertex, quad.bounds);@@ -875,8 +881,9 @@ struct ShadowFragmentInput {StructuredBuffer<Shadow> shadows: register(t1);-ShadowVertexOutput shadow_vertex(uint vertex_id: SV_VertexID, uint shadow_id: SV_InstanceID) {+ShadowVertexOutput shadow_vertex(uint vertex_id: SV_VertexID, uint instance_id: SV_InstanceID) {float2 unit_vertex = float2(float(vertex_id & 1u), 0.5 * float(vertex_id & 2u));+ uint shadow_id = batch_start_index + instance_id;Shadow shadow = shadows[shadow_id];Bounds bounds;@@ -1080,8 +1087,9 @@ struct UnderlineFragmentInput {StructuredBuffer<Underline> underlines: register(t1);-UnderlineVertexOutput underline_vertex(uint vertex_id: SV_VertexID, uint underline_id: SV_InstanceID) {+UnderlineVertexOutput underline_vertex(uint vertex_id: SV_VertexID, uint instance_id: SV_InstanceID) {float2 unit_vertex = float2(float(vertex_id & 1u), 0.5 * float(vertex_id & 2u));+ uint underline_id = batch_start_index + instance_id;Underline underline = underlines[underline_id];float4 device_position = to_device_position(unit_vertex, underline.bounds);float4 clip_distance = distance_from_clip_rect(unit_vertex, underline.bounds,@@ -1155,8 +1163,9 @@ struct MonochromeSpriteFragmentInput {StructuredBuffer<MonochromeSprite> mono_sprites: register(t1);-MonochromeSpriteVertexOutput monochrome_sprite_vertex(uint vertex_id: SV_VertexID, uint sprite_id: SV_InstanceID) {+MonochromeSpriteVertexOutput monochrome_sprite_vertex(uint vertex_id: SV_VertexID, uint instance_id: SV_InstanceID) {float2 unit_vertex = float2(float(vertex_id & 1u), 0.5 * float(vertex_id & 2u));+ uint sprite_id = batch_start_index + instance_id;MonochromeSprite sprite = mono_sprites[sprite_id];float4 device_position =to_device_position_transformed(unit_vertex, sprite.bounds, sprite.transformation);@@ -1178,8 +1187,8 @@ float4 monochrome_sprite_fragment(MonochromeSpriteFragmentInput input): SV_Targereturn float4(input.color.rgb, input.color.a * alpha_corrected);}-MonochromeSpriteVertexOutput subpixel_sprite_vertex(uint vertex_id: SV_VertexID, uint sprite_id: SV_InstanceID) {- return monochrome_sprite_vertex(vertex_id, sprite_id);+MonochromeSpriteVertexOutput subpixel_sprite_vertex(uint vertex_id: SV_VertexID, uint instance_id: SV_InstanceID) {+ return monochrome_sprite_vertex(vertex_id, instance_id);}SubpixelSpriteFragmentOutput subpixel_sprite_fragment(MonochromeSpriteFragmentInput input) {@@ -1227,8 +1236,9 @@ struct PolychromeSpriteFragmentInput {StructuredBuffer<PolychromeSprite> poly_sprites: register(t1);-PolychromeSpriteVertexOutput polychrome_sprite_vertex(uint vertex_id: SV_VertexID, uint sprite_id: SV_InstanceID) {+PolychromeSpriteVertexOutput polychrome_sprite_vertex(uint vertex_id: SV_VertexID, uint instance_id: SV_InstanceID) {float2 unit_vertex = float2(float(vertex_id & 1u), 0.5 * float(vertex_id & 2u));+ uint sprite_id = batch_start_index + instance_id;PolychromeSprite sprite = poly_sprites[sprite_id];float4 device_position = to_device_position(unit_vertex, sprite.bounds);float4 clip_distance = distance_from_clip_rect(unit_vertex, sprite.bounds,