Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
gpui_wgpu: Add Linux headless rendering (#64718)
Anthony Eide91b82c10681
diff --git a/Cargo.lock b/Cargo.lockindex edff55c3997..4eb6561afa1 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -7706,12 +7706,14 @@ dependencies = [name = "gpui_platform"version = "0.1.0"dependencies = [+ "anyhow","console_error_panic_hook","criterion","gpui","gpui_linux","gpui_macos","gpui_web",+ "gpui_wgpu","gpui_windows",]@@ -7782,6 +7784,7 @@ dependencies = ["etagere","gpui","gpui_util",+ "image","itertools 0.14.0","log","naga",diff --git a/crates/gpui/src/app/bench_context.rs b/crates/gpui/src/app/bench_context.rsindex a8b269b3f45..c9e5484d298 100644--- a/crates/gpui/src/app/bench_context.rs+++ b/crates/gpui/src/app/bench_context.rs@@ -44,7 +44,9 @@ use crate::{/// a headless renderer (Metal), so GPU submission is excluded from benchmark/// measurements on other platforms.pub fn bench_platform(- headless_renderer_factory: Option<Box<dyn Fn() -> Option<Box<dyn PlatformHeadlessRenderer>>>>,+ headless_renderer_factory: Option<+ Box<dyn Fn() -> anyhow::Result<Option<Box<dyn PlatformHeadlessRenderer>>>>,+ >,text_system: Arc<dyn PlatformTextSystem>,) -> Rc<dyn Platform> {thread_local! {diff --git a/crates/gpui/src/app/headless_app_context.rs b/crates/gpui/src/app/headless_app_context.rsindex b21e64fa369..6ac4bfe9f85 100644--- a/crates/gpui/src/app/headless_app_context.rs+++ b/crates/gpui/src/app/headless_app_context.rs@@ -49,7 +49,7 @@ pub struct HeadlessAppContext {impl HeadlessAppContext {/// Creates a new headless app context with the given text system.pub fn new(platform_text_system: Arc<dyn PlatformTextSystem>) -> Self {- Self::with_platform(platform_text_system, Arc::new(()), || None)+ Self::with_platform(platform_text_system, Arc::new(()), || Ok(None))}/// Creates a new headless app context with a custom text system and asset source.@@ -57,7 +57,7 @@ impl HeadlessAppContext {platform_text_system: Arc<dyn PlatformTextSystem>,asset_source: Arc<dyn AssetSource>,) -> Self {- Self::with_platform(platform_text_system, asset_source, || None)+ Self::with_platform(platform_text_system, asset_source, || Ok(None))}/// Creates a new headless app context with the given text system, asset source,@@ -65,7 +65,7 @@ impl HeadlessAppContext {pub fn with_platform(platform_text_system: Arc<dyn PlatformTextSystem>,asset_source: Arc<dyn AssetSource>,- renderer_factory: impl Fn() -> Option<Box<dyn PlatformHeadlessRenderer>> + 'static,+ renderer_factory: impl Fn() -> Result<Option<Box<dyn PlatformHeadlessRenderer>>> + 'static,) -> Self {let seed = std::env::var("SEED").ok()@@ -77,7 +77,7 @@ impl HeadlessAppContext {let background_executor = BackgroundExecutor::new(arc_dispatcher.clone());let foreground_executor = ForegroundExecutor::new(arc_dispatcher);- let renderer_factory: Box<dyn Fn() -> Option<Box<dyn PlatformHeadlessRenderer>>> =+ let renderer_factory: Box<dyn Fn() -> Result<Option<Box<dyn PlatformHeadlessRenderer>>>> =Box::new(renderer_factory);let platform = TestPlatform::with_platform(background_executor.clone(),diff --git a/crates/gpui/src/platform/test/platform.rs b/crates/gpui/src/platform/test/platform.rsindex 77a644114f0..4bf08387848 100644--- a/crates/gpui/src/platform/test/platform.rs+++ b/crates/gpui/src/platform/test/platform.rs@@ -50,7 +50,8 @@ pub(crate) struct TestPlatform {idle_sleep_prevention_count: Arc<AtomicUsize>,idle_sleep_prevention_delay: Cell<Duration>,idle_sleep_prevention_fails: Cell<bool>,- headless_renderer_factory: Option<Box<dyn Fn() -> Option<Box<dyn PlatformHeadlessRenderer>>>>,+ headless_renderer_factory:+ Option<Box<dyn Fn() -> anyhow::Result<Option<Box<dyn PlatformHeadlessRenderer>>>>>,weak: Weak<Self>,menus: RefCell<Vec<OwnedMenu>>,}@@ -144,7 +145,7 @@ impl TestPlatform {foreground_executor: ForegroundExecutor,text_system: Arc<dyn PlatformTextSystem>,headless_renderer_factory: Option<- Box<dyn Fn() -> Option<Box<dyn PlatformHeadlessRenderer>>>,+ Box<dyn Fn() -> anyhow::Result<Option<Box<dyn PlatformHeadlessRenderer>>>>,>,) -> Rc<Self> {Rc::new_cyclic(|weak| TestPlatform {@@ -494,7 +495,10 @@ impl Platform for TestPlatform {handle: AnyWindowHandle,params: WindowParams,) -> anyhow::Result<Box<dyn crate::PlatformWindow>> {- let renderer = self.headless_renderer_factory.as_ref().and_then(|f| f());+ let renderer = match self.headless_renderer_factory.as_ref() {+ Some(factory) => factory()?,+ None => None,+ };let window = TestWindow::new(handle,params,diff --git a/crates/gpui_linux/src/linux/wayland/window.rs b/crates/gpui_linux/src/linux/wayland/window.rsindex a66547aa0c7..3f2671d5f59 100644--- a/crates/gpui_linux/src/linux/wayland/window.rs+++ b/crates/gpui_linux/src/linux/wayland/window.rs@@ -2134,7 +2134,7 @@ impl PlatformWindow for WaylandWindow {}fn gpu_specs(&self) -> Option<GpuSpecs> {- self.borrow().renderer.gpu_specs().into()+ self.borrow().renderer.gpu_specs()}fn play_system_bell(&self) {diff --git a/crates/gpui_linux/src/linux/x11/window.rs b/crates/gpui_linux/src/linux/x11/window.rsindex 3d33ab0c114..efeb606b202 100644--- a/crates/gpui_linux/src/linux/x11/window.rs+++ b/crates/gpui_linux/src/linux/x11/window.rs@@ -1965,7 +1965,7 @@ impl PlatformWindow for X11Window {}fn gpu_specs(&self) -> Option<GpuSpecs> {- self.0.state.borrow().renderer.gpu_specs().into()+ self.0.state.borrow().renderer.gpu_specs()}fn play_system_bell(&self) {diff --git a/crates/gpui_platform/Cargo.toml b/crates/gpui_platform/Cargo.tomlindex 61be065c9d2..ce2e057c4ae 100644--- a/crates/gpui_platform/Cargo.toml+++ b/crates/gpui_platform/Cargo.toml@@ -14,10 +14,10 @@ doctest = false[features]default = []-bench-support = ["gpui/bench-support", "gpui_macos/bench-support"]+bench-support = ["gpui/bench-support", "gpui_macos/bench-support", "gpui_wgpu/bench-support"]font-kit = ["gpui_macos/font-kit"]inspector = ["gpui/inspector"]-test-support = ["gpui/test-support", "gpui_macos/test-support", "gpui_windows/test-support"]+test-support = ["gpui/test-support", "gpui_macos/test-support", "gpui_windows/test-support", "gpui_wgpu/test-support"]screen-capture = ["gpui/screen-capture", "gpui_macos/screen-capture", "gpui_windows/screen-capture", "gpui_linux/screen-capture"]runtime_shaders = ["gpui_macos/runtime_shaders"]wayland = ["gpui_linux/wayland"]@@ -29,6 +29,7 @@ harness = falserequired-features = ["bench-support"][dependencies]+anyhow.workspace = truegpui.workspace = true[dev-dependencies]@@ -44,6 +45,9 @@ gpui = { workspace = true, features = ["windows-manifest"] }[target.'cfg(any(target_os = "linux", target_os = "freebsd"))'.dependencies]gpui_linux.workspace = true+[target.'cfg(target_os = "linux")'.dependencies]+gpui_wgpu = { workspace = true, optional = true }+[target.'cfg(target_family = "wasm")'.dependencies]gpui_web.workspace = trueconsole_error_panic_hook.workspace = truediff --git a/crates/gpui_platform/src/gpui_platform.rs b/crates/gpui_platform/src/gpui_platform.rsindex b95e6098368..5e165d5c402 100644--- a/crates/gpui_platform/src/gpui_platform.rs+++ b/crates/gpui_platform/src/gpui_platform.rs@@ -82,17 +82,24 @@ pub fn current_platform(headless: bool) -> Rc<dyn Platform> {/// Returns a new [`HeadlessRenderer`] for the current platform, if available.#[cfg(any(feature = "bench-support", feature = "test-support"))]-pub fn current_headless_renderer() -> Option<Box<dyn gpui::PlatformHeadlessRenderer>> {+pub fn current_headless_renderer() -> anyhow::Result<Option<Box<dyn gpui::PlatformHeadlessRenderer>>>+{#[cfg(target_os = "macos")]{- Some(Box::new(+ Ok(Some(Box::new(gpui_macos::metal_renderer::MetalHeadlessRenderer::new(),- ))+ )))}- #[cfg(not(target_os = "macos"))]+ #[cfg(target_os = "linux")]{- None+ gpui_wgpu::WgpuHeadlessRenderer::new()+ .map(|renderer| Some(Box::new(renderer) as Box<dyn gpui::PlatformHeadlessRenderer>))+ }++ #[cfg(not(any(target_os = "macos", target_os = "linux")))]+ {+ Ok(None)}}diff --git a/crates/gpui_web/src/window.rs b/crates/gpui_web/src/window.rsindex bf00bd2d4ba..d503148fed5 100644--- a/crates/gpui_web/src/window.rs+++ b/crates/gpui_web/src/window.rs@@ -1003,7 +1003,7 @@ impl PlatformWindow for WebWindow {}fn gpu_specs(&self) -> Option<GpuSpecs> {- Some(self.inner.state.borrow().renderer.gpu_specs())+ self.inner.state.borrow().renderer.gpu_specs()}fn update_ime_position(&self, _bounds: Bounds<Pixels>) {}diff --git a/crates/gpui_wgpu/Cargo.toml b/crates/gpui_wgpu/Cargo.tomlindex 18d6737c3d8..a49cf7f3ae1 100644--- a/crates/gpui_wgpu/Cargo.toml+++ b/crates/gpui_wgpu/Cargo.toml@@ -14,7 +14,9 @@ doctest = false[features]default = []+bench-support = ["gpui/bench-support", "dep:image"]font-kit = ["dep:font-kit"]+test-support = ["gpui/test-support", "dep:image"][dependencies]gpui.workspace = true@@ -24,6 +26,7 @@ collections.workspace = truecosmic-text = "0.19.0"etagere.workspace = trueitertools.workspace = true+image = { workspace = true, optional = true }log.workspace = trueparking_lot.workspace = trueprofiling.workspace = true@@ -45,7 +48,8 @@ wgpu = { workspace = true, features = ["webgl"] }[dev-dependencies]criterion.workspace = true-gpui = { workspace = true, features = ["test-support"] }+gpui = { workspace = true, features = ["bench-support"] }+image.workspace = truenaga = { version = "29.0.4", features = ["wgsl-in"] }[[bench]]diff --git a/crates/gpui_wgpu/src/cosmic_text_system.rs b/crates/gpui_wgpu/src/cosmic_text_system.rsindex 5135632401a..0e4e3b11f23 100644--- a/crates/gpui_wgpu/src/cosmic_text_system.rs+++ b/crates/gpui_wgpu/src/cosmic_text_system.rs@@ -1200,6 +1200,7 @@ fn check_is_known_emoji_font(postscript_name: &str) -> bool {#[cfg(test)]mod tests {use super::*;+ #[cfg(feature = "test-support")]use std::{cell::RefCell, rc::Rc};#[test]@@ -1314,6 +1315,7 @@ mod tests {Ok(())}+ #[cfg(feature = "test-support")]#[test]fn reports_graphemes_that_exhaust_font_fallback() -> Result<()> {let platform_text_system = Arc::new(text_system()?);diff --git a/crates/gpui_wgpu/src/gpui_wgpu.rs b/crates/gpui_wgpu/src/gpui_wgpu.rsindex 452c3c03f51..29a79afc6e3 100644--- a/crates/gpui_wgpu/src/gpui_wgpu.rs+++ b/crates/gpui_wgpu/src/gpui_wgpu.rs@@ -7,4 +7,9 @@ pub use cosmic_text_system::*;pub use wgpu;pub use wgpu_atlas::*;pub use wgpu_context::*;+#[cfg(all(+ not(target_family = "wasm"),+ any(test, feature = "bench-support", feature = "test-support")+))]+pub use wgpu_renderer::WgpuHeadlessRenderer;pub use wgpu_renderer::{GpuContext, WgpuRenderer, WgpuSurfaceConfig};diff --git a/crates/gpui_wgpu/src/wgpu_context.rs b/crates/gpui_wgpu/src/wgpu_context.rsindex 7e744e80d6c..4a6e9cbe0e4 100644--- a/crates/gpui_wgpu/src/wgpu_context.rs+++ b/crates/gpui_wgpu/src/wgpu_context.rs@@ -2,6 +2,7 @@use anyhow::Context as _;#[cfg(not(target_family = "wasm"))]use gpui_util::ResultExt;+use parking_lot::Mutex;use std::sync::Arc;use std::sync::atomic::{AtomicBool, Ordering};use wgpu::TextureFormat;@@ -14,7 +15,63 @@ pub struct WgpuContext {backend: WgpuBackend,dual_source_blending: bool,color_texture_format: wgpu::TextureFormat,- device_lost: Arc<AtomicBool>,+ errors: Arc<DeviceErrorState>,+}++/// Errors reported by wgpu's device-wide callbacks.+///+/// A device has exactly one lost callback and one uncaptured-error callback, so this+/// state is installed once per device and shared by every renderer using it. Renderers+/// keep their own handle so they can keep observing a loss after the context that+/// produced it has been dropped for recovery.+#[derive(Default)]+pub struct DeviceErrorState {+ lost: AtomicBool,+ last_error: Mutex<(u64, Option<String>)>,+}++impl DeviceErrorState {+ fn install(device: &wgpu::Device) -> Arc<Self> {+ let errors = Arc::new(Self::default());+ device.set_device_lost_callback({+ let errors = Arc::clone(&errors);+ move |reason, message| {+ log::error!("wgpu device lost: reason={reason:?}, message={message}");+ if reason != wgpu::DeviceLostReason::Destroyed {+ errors.lost.store(true, Ordering::Relaxed);+ }+ }+ });+ device.on_uncaptured_error(Arc::new({+ let errors = Arc::clone(&errors);+ move |error| errors.record(error.to_string())+ }));+ errors+ }++ /// Returns true if the GPU device was lost (e.g., due to driver crash, suspend/resume).+ pub fn device_lost(&self) -> bool {+ self.lost.load(Ordering::Relaxed)+ }++ fn record(&self, error: String) {+ let mut last_error = self.last_error.lock();+ last_error.0 = last_error.0.wrapping_add(1);+ last_error.1 = Some(error);+ }++ /// Returns the latest error once per observer, without consuming shared state.+ /// Start each observer at zero, including after switching devices, so errors+ /// raised during construction are observed. Multiple errors between observations+ /// coalesce into the latest error; this is not an error queue.+ pub fn observe_error(&self, generation: &mut u64) -> Option<String> {+ let last_error = self.last_error.lock();+ if *generation == last_error.0 {+ return None;+ }+ *generation = last_error.0;+ last_error.1.clone()+ }}#[derive(Clone, Copy, Debug, Eq, PartialEq)]@@ -88,17 +145,7 @@ impl WgpuContext {compositor_gpu: Option<CompositorGpuHint>,reject_software: bool,) -> anyhow::Result<Self> {- let device_id_filter = match std::env::var("ZED_DEVICE_ID") {- Ok(val) => parse_pci_id(&val)- .context("Failed to parse device ID from `ZED_DEVICE_ID` environment variable")- .log_err(),- Err(std::env::VarError::NotPresent) => None,- err => {- err.context("Failed to read value of `ZED_DEVICE_ID` environment variable")- .log_err();- None- }- };+ let device_id_filter = Self::device_id_filter();// Select an adapter by actually testing surface configuration with the real device.// This is the only reliable way to determine compatibility on hybrid GPU systems.@@ -111,25 +158,124 @@ impl WgpuContext {reject_software,))?;- let device_lost = Arc::new(AtomicBool::new(false));- device.set_device_lost_callback({- let device_lost = Arc::clone(&device_lost);- move |reason, message| {- log::error!("wgpu device lost: reason={reason:?}, message={message}");- if reason != wgpu::DeviceLostReason::Destroyed {- device_lost.store(true, Ordering::Relaxed);+ Ok(Self::from_native_adapter_and_device(+ instance,+ adapter,+ device,+ queue,+ dual_source_blending,+ color_texture_format,+ ))+ }++ #[cfg(all(+ not(target_family = "wasm"),+ any(test, feature = "bench-support", feature = "test-support")+ ))]+ pub(crate) fn new_headless() -> anyhow::Result<(Self, wgpu::TextureFormat)> {+ let instance = Self::instance(None);+ let device_id_filter = Self::device_id_filter();+ let (adapter, device, queue, dual_source_blending, color_texture_format, target_format) =+ gpui::block_on(async {+ let mut adapters = instance.enumerate_adapters(wgpu::Backends::all()).await;+ Self::sort_adapters(&mut adapters, device_id_filter, None);++ for adapter in adapters {+ let adapter_info = adapter.get_info();+ let Some(target_format) = Self::headless_target_format(&adapter) else {+ log::warn!(+ "Adapter {:?} has no supported headless render target format",+ adapter_info.name+ );+ continue;+ };++ match Self::create_device(&adapter).await {+ Ok((device, queue, dual_source_blending, color_texture_format)) => {+ #[cfg(feature = "bench-support")]+ if adapter_info.device_type == wgpu::DeviceType::Cpu {+ log::error!(+ "Headless renderer selected software adapter {:?}; \+ benchmark results measure CPU software rendering, not hardware GPU rendering",+ adapter_info.name+ );+ }+ return Ok((+ adapter,+ device,+ queue,+ dual_source_blending,+ color_texture_format,+ target_format,+ ));+ }+ Err(error) => {+ log::warn!(+ "Failed to create a headless device for adapter {:?}: {error:#}",+ adapter_info.name+ );+ }+ }}- }- });++ anyhow::bail!("No usable headless GPU adapter found")+ })?;++ Ok((+ Self::from_native_adapter_and_device(+ instance,+ adapter,+ device,+ queue,+ dual_source_blending,+ color_texture_format,+ ),+ target_format,+ ))+ }++ #[cfg(all(+ not(target_family = "wasm"),+ any(test, feature = "bench-support", feature = "test-support")+ ))]+ /// Both candidates are 8-bit RGBA-ordered or BGRA-ordered formats: headless readback+ /// copies rows as 4 bytes per pixel and only swizzles, so no other formats may be added+ /// here without updating it.+ fn headless_target_format(adapter: &wgpu::Adapter) -> Option<wgpu::TextureFormat> {+ let required_usages =+ wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC;+ [+ wgpu::TextureFormat::Rgba8Unorm,+ wgpu::TextureFormat::Bgra8Unorm,+ ]+ .into_iter()+ .find(|format| {+ adapter+ .get_texture_format_features(*format)+ .allowed_usages+ .contains(required_usages)+ })+ }++ #[cfg(not(target_family = "wasm"))]+ fn from_native_adapter_and_device(+ instance: wgpu::Instance,+ adapter: wgpu::Adapter,+ device: wgpu::Device,+ queue: wgpu::Queue,+ dual_source_blending: bool,+ color_texture_format: TextureFormat,+ ) -> Self {+ let errors = DeviceErrorState::install(&device);log::info!("Selected GPU adapter: {:?} ({:?})",adapter.get_info().name,adapter.get_info().backend);-let backend = WgpuBackend::Native(adapter.get_info().backend);- Ok(Self {++ Self {instance,adapter,device: Arc::new(device),@@ -137,8 +283,24 @@ impl WgpuContext {backend,dual_source_blending,color_texture_format,- device_lost,- })+ errors,+ }+ }++ #[cfg(not(target_family = "wasm"))]+ fn device_id_filter() -> Option<u32> {+ match std::env::var("ZED_DEVICE_ID") {+ Ok(value) => parse_pci_id(&value)+ .context("Failed to parse device ID from `ZED_DEVICE_ID` environment variable")+ .log_err(),+ Err(std::env::VarError::NotPresent) => None,+ error => {+ error+ .context("Failed to read value of `ZED_DEVICE_ID` environment variable")+ .log_err();+ None+ }+ }}#[cfg(target_family = "wasm")]@@ -201,18 +363,9 @@ impl WgpuContext {}};- let device_lost = Arc::new(AtomicBool::new(false));let (device, queue, dual_source_blending, color_texture_format) =Self::create_device(&adapter).await?;- device.set_device_lost_callback({- let device_lost = Arc::clone(&device_lost);- move |reason, message| {- log::error!("wgpu device lost: reason={reason:?}, message={message}");- if reason != wgpu::DeviceLostReason::Destroyed {- device_lost.store(true, Ordering::Relaxed);- }- }- });+ let errors = DeviceErrorState::install(&device);log::info!("Browser graphics initialized: requested={preference:?}, selected={backend:?}, \adapter={:?}, limits={:?}, dual_source_blending={dual_source_blending}",@@ -228,7 +381,7 @@ impl WgpuContext {backend,dual_source_blending,color_texture_format,- device_lost,+ errors,};Ok(PreparedWebGraphics { context, surface })}@@ -287,13 +440,13 @@ impl WgpuContext {}#[cfg(not(target_family = "wasm"))]- pub fn instance(display: Box<dyn wgpu::wgt::WgpuHasDisplayHandle>) -> wgpu::Instance {+ pub fn instance(display: Option<Box<dyn wgpu::wgt::WgpuHasDisplayHandle>>) -> wgpu::Instance {wgpu::Instance::new(wgpu::InstanceDescriptor {backends: wgpu::Backends::VULKAN | wgpu::Backends::GL,flags: wgpu::InstanceFlags::default(),backend_options: wgpu::BackendOptions::default(),memory_budget_thresholds: wgpu::MemoryBudgetThresholds::default(),- display: Some(display),+ display,})}@@ -341,60 +494,7 @@ impl WgpuContext {log::info!("ZED_DEVICE_ID filter: {:#06x}", device_id);}- // Sort adapters into a single priority order. Tiers (from highest to lowest):- //- // 1. ZED_DEVICE_ID match — explicit user override- // 2. Compositor GPU match — the GPU the display server is rendering on- // 3. Device type (Discrete > Integrated > Other > Virtual > Cpu).- // "Other" ranks above "Virtual" because OpenGL seems to count as "Other".- // 4. Backend — prefer Vulkan/Metal/Dx12 over GL/etc.- adapters.sort_by_key(|adapter| {- let info = adapter.get_info();-- // Backends like OpenGL report device=0 for all adapters, so- // device-based matching is only meaningful when non-zero.- let device_known = info.device != 0;-- let user_override: u8 = match device_id_filter {- Some(id) if device_known && info.device == id => 0,- _ => 1,- };-- let compositor_match: u8 = match compositor_gpu {- Some(hint)- if device_known- && info.vendor == hint.vendor_id- && info.device == hint.device_id =>- {- 0- }- _ => 1,- };-- let type_priority: u8 = if info.device_type == wgpu::DeviceType::Cpu {- 4- } else {- match info.device_type {- wgpu::DeviceType::DiscreteGpu => 0,- wgpu::DeviceType::IntegratedGpu => 1,- wgpu::DeviceType::Other => 2,- wgpu::DeviceType::VirtualGpu => 3,- wgpu::DeviceType::Cpu => 4,- }- };-- let backend_priority: u8 = match info.backend {- wgpu::Backend::Vulkan | wgpu::Backend::Metal | wgpu::Backend::Dx12 => 0,- _ => 1,- };-- (- user_override,- compositor_match,- type_priority,- backend_priority,- )- });+ Self::sort_adapters(&mut adapters, device_id_filter, compositor_gpu);// Log all available adapters (in sorted order)log::info!("Found {} GPU adapter(s):", adapters.len());@@ -454,6 +554,59 @@ impl WgpuContext {anyhow::bail!("No GPU adapter found that can configure the display surface")}+ /// Sort adapters into a single priority order. Tiers (from highest to lowest):+ ///+ /// 1. ZED_DEVICE_ID match — explicit user override+ /// 2. Compositor GPU match — the GPU the display server is rendering on+ /// 3. Device type (Discrete > Integrated > Other > Virtual > Cpu).+ /// "Other" ranks above "Virtual" because OpenGL seems to count as "Other".+ /// 4. Backend — prefer Vulkan/Metal/Dx12 over GL/etc.+ #[cfg(not(target_family = "wasm"))]+ fn sort_adapters(+ adapters: &mut [wgpu::Adapter],+ device_id_filter: Option<u32>,+ compositor_gpu: Option<&CompositorGpuHint>,+ ) {+ adapters.sort_by_key(|adapter| {+ let info = adapter.get_info();+ // Backends like OpenGL report device=0 for all adapters, so+ // device-based matching is only meaningful when non-zero.+ let device_known = info.device != 0;+ let user_override: u8 = match device_id_filter {+ Some(id) if device_known && info.device == id => 0,+ _ => 1,+ };+ let compositor_match: u8 = match compositor_gpu {+ Some(hint)+ if device_known+ && info.vendor == hint.vendor_id+ && info.device == hint.device_id =>+ {+ 0+ }+ _ => 1,+ };+ let type_priority: u8 = match info.device_type {+ wgpu::DeviceType::DiscreteGpu => 0,+ wgpu::DeviceType::IntegratedGpu => 1,+ wgpu::DeviceType::Other => 2,+ wgpu::DeviceType::VirtualGpu => 3,+ wgpu::DeviceType::Cpu => 4,+ };+ let backend_priority: u8 = match info.backend {+ wgpu::Backend::Vulkan | wgpu::Backend::Metal | wgpu::Backend::Dx12 => 0,+ _ => 1,+ };++ (+ user_override,+ compositor_match,+ type_priority,+ backend_priority,+ )+ });+ }+/// Try to use an adapter with a surface by creating a device and testing configuration./// Returns the device and queue if successful, allowing them to be reused.#[cfg(not(target_family = "wasm"))]@@ -556,12 +709,12 @@ impl WgpuContext {/// Returns true if the GPU device was lost (e.g., due to driver crash, suspend/resume)./// When this returns true, the context should be recreated.pub fn device_lost(&self) -> bool {- self.device_lost.load(Ordering::Relaxed)+ self.errors.device_lost()}- /// Returns a clone of the device_lost flag for sharing with renderers.- pub(crate) fn device_lost_flag(&self) -> Arc<AtomicBool> {- Arc::clone(&self.device_lost)+ /// The device-wide error state, shared with renderers on this device.+ pub fn errors(&self) -> &Arc<DeviceErrorState> {+ &self.errors}}@@ -584,7 +737,48 @@ fn parse_pci_id(id: &str) -> anyhow::Result<u32> {#[cfg(test)]mod tests {- use super::parse_pci_id;+ use super::{DeviceErrorState, parse_pci_id};++ #[test]+ fn device_errors_are_observed_independently() {+ let errors = DeviceErrorState::default();+ let mut first = 0;+ let mut second = 0;+ assert_eq!(errors.observe_error(&mut first), None);+ errors.record("first".into());+ assert_eq!(errors.observe_error(&mut first).as_deref(), Some("first"));+ assert_eq!(errors.observe_error(&mut first), None);+ assert_eq!(errors.observe_error(&mut second).as_deref(), Some("first"));+ assert_eq!(errors.observe_error(&mut second), None);++ errors.record("second".into());+ assert_eq!(errors.observe_error(&mut second).as_deref(), Some("second"));+ assert_eq!(errors.observe_error(&mut first).as_deref(), Some("second"));+ assert_eq!(errors.observe_error(&mut first), None);+ assert_eq!(errors.observe_error(&mut second), None);+ }++ #[test]+ fn device_errors_coalesce_and_new_observers_see_latest() {+ let errors = DeviceErrorState::default();+ errors.record("older".into());+ errors.record("latest".into());+ let mut generation = 0;+ assert_eq!(+ errors.observe_error(&mut generation).as_deref(),+ Some("latest")+ );+ assert_eq!(errors.observe_error(&mut generation), None);++ let replacement = DeviceErrorState::default();+ replacement.record("replacement".into());+ generation = 0;+ assert_eq!(+ replacement.observe_error(&mut generation).as_deref(),+ Some("replacement")+ );+ assert_eq!(replacement.observe_error(&mut generation), None);+ }#[test]fn test_parse_device_id() {diff --git a/crates/gpui_wgpu/src/wgpu_renderer.rs b/crates/gpui_wgpu/src/wgpu_renderer.rsindex 06efecd3247..0f120bbad0e 100644--- a/crates/gpui_wgpu/src/wgpu_renderer.rs+++ b/crates/gpui_wgpu/src/wgpu_renderer.rs@@ -1,4 +1,4 @@-use crate::{CompositorGpuHint, WgpuAtlas, WgpuContext};+use crate::{CompositorGpuHint, DeviceErrorState, WgpuAtlas, WgpuContext};use anyhow::{Context as _, Result};use bytemuck::{Pod, Zeroable};use collections::FxHashMap;@@ -14,7 +14,7 @@ use std::cell::RefCell;use std::num::NonZeroU64;use std::ops::Range;use std::rc::Rc;-use std::sync::{Arc, Mutex};+use std::sync::Arc;const MAX_INSTANCE_BUFFER_SIZE: u64 = 256 * 1024 * 1024;@@ -182,7 +182,6 @@ enum InstanceData {struct WgpuResources {device: Arc<wgpu::Device>,queue: Arc<wgpu::Queue>,- surface: wgpu::Surface<'static>,pipelines: WgpuPipelines,bind_group_layouts: WgpuBindGroupLayouts,atlas_sampler: wgpu::Sampler,@@ -211,15 +210,8 @@ impl WgpuResources {}}-pub struct WgpuRenderer {- /// Shared GPU context for device recovery coordination (unused on WASM).- #[allow(dead_code)]- context: Option<GpuContext>,- /// Compositor GPU hint for adapter selection (unused on WASM).- #[allow(dead_code)]- compositor_gpu: Option<CompositorGpuHint>,- resources: Option<WgpuResources>,- surface_config: wgpu::SurfaceConfiguration,+struct WgpuRendererCore {+ resources: WgpuResources,atlas: Arc<WgpuAtlas>,path_globals_offset: u64,gamma_offset: u64,@@ -231,27 +223,60 @@ pub struct WgpuRenderer {is_bgr: bool,dual_source_blending: bool,adapter_info: wgpu::AdapterInfo,+ target_format: wgpu::TextureFormat,+ max_texture_size: u32,+}++/// GPU resources of a windowed renderer. A surface is only ever configured against the+/// device that owns `core`, so it cannot outlive it: there is no surface-only state.+enum RendererState {+ /// Frames can be drawn.+ Ready {+ surface: wgpu::Surface<'static>,+ core: WgpuRendererCore,+ },+ /// The native surface is gone (Android `TerminateWindow`, browser context loss) but+ /// the device, pipelines, and atlas remain so `replace_surface` can resume without+ /// re-uploading cached textures.+ Unconfigured { core: WgpuRendererCore },+ /// Released by `destroy`, or dropped for a device recovery that has not succeeded yet.+ Released,+}++pub struct WgpuRenderer {+ /// Shared GPU context for device recovery coordination (unused on WASM).+ #[allow(dead_code)]+ context: Option<GpuContext>,+ /// Compositor GPU hint for adapter selection (unused on WASM).+ #[allow(dead_code)]+ compositor_gpu: Option<CompositorGpuHint>,+ state: RendererState,+ surface_config: wgpu::SurfaceConfiguration,+ atlas: Arc<WgpuAtlas>,transparent_alpha_mode: wgpu::CompositeAlphaMode,opaque_alpha_mode: wgpu::CompositeAlphaMode,max_texture_size: u32,- last_error: Arc<Mutex<Option<String>>>,+ is_bgr: bool,failed_frame_count: u32,- device_lost: std::sync::Arc<std::sync::atomic::AtomicBool>,- surface_configured: bool,+ device_errors: Arc<DeviceErrorState>,+ observed_error_generation: u64,+ last_surface_error: Option<String>,needs_redraw: bool,}impl WgpuRenderer {- fn resources(&self) -> &WgpuResources {- self.resources- .as_ref()- .expect("GPU resources not available")+ fn core(&self) -> Option<&WgpuRendererCore> {+ match &self.state {+ RendererState::Ready { core, .. } | RendererState::Unconfigured { core } => Some(core),+ RendererState::Released => None,+ }}- fn resources_mut(&mut self) -> &mut WgpuResources {- self.resources- .as_mut()- .expect("GPU resources not available")+ fn core_mut(&mut self) -> Option<&mut WgpuRendererCore> {+ match &mut self.state {+ RendererState::Ready { core, .. } | RendererState::Unconfigured { core } => Some(core),+ RendererState::Released => None,+ }}/// Creates a new WgpuRenderer from raw window handles.@@ -290,7 +315,7 @@ impl WgpuRenderer {.borrow().as_ref().map(|ctx| ctx.instance.clone())- .unwrap_or_else(|| WgpuContext::instance(Box::new(window.clone())));+ .unwrap_or_else(|| WgpuContext::instance(Some(Box::new(window.clone()))));// Safety: The caller guarantees that the window handle is valid for the// lifetime of this renderer. In practice, the RawWindow struct is created@@ -436,186 +461,28 @@ impl WgpuRenderer {// that this adapter can successfully configure this surface.surface.configure(&context.device, &surface_config);- let queue = Arc::clone(&context.queue);- let rendering_params = RenderingParameters::new(&context.adapter, surface_format);- let uses_webgl_instance_data = context.uses_webgl_instance_data();- let dual_source_blending =- context.supports_dual_source_blending() && !uses_webgl_instance_data;- let bind_group_layouts = Self::create_bind_group_layouts(&device, uses_webgl_instance_data);- let pipelines = Self::create_pipelines(- &device,- &bind_group_layouts,- surface_format,- alpha_mode,- rendering_params.path_sample_count,- dual_source_blending,- uses_webgl_instance_data,- );-- let atlas_sampler = device.create_sampler(&wgpu::SamplerDescriptor {- label: Some("atlas_sampler"),- mag_filter: wgpu::FilterMode::Linear,- min_filter: wgpu::FilterMode::Linear,- ..Default::default()- });-- let uniform_alignment = device.limits().min_uniform_buffer_offset_alignment as u64;- let globals_size = std::mem::size_of::<GlobalParams>() as u64;- let gamma_size = std::mem::size_of::<GammaParams>() as u64;- let path_globals_offset = globals_size.next_multiple_of(uniform_alignment);- let gamma_offset = (path_globals_offset + globals_size).next_multiple_of(uniform_alignment);-- let globals_buffer = device.create_buffer(&wgpu::BufferDescriptor {- label: Some("globals_buffer"),- size: gamma_offset + gamma_size,- usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,- mapped_at_creation: false,- });-- let (- instance_data,- instance_data_capacity,- max_instance_data_size,- instance_data_alignment,- ) = if uses_webgl_instance_data {- let max_texture_dimension = device.limits().max_texture_dimension_2d;- let max_instance_data_size = (u64::from(max_texture_dimension).pow(2)- * INSTANCE_TEXTURE_TEXEL_SIZE)- .min(MAX_INSTANCE_BUFFER_SIZE);- let initial_capacity = (2 * 1024 * 1024).min(max_instance_data_size);- let (instance_data, capacity) =- Self::create_instance_texture(&device, initial_capacity, max_texture_dimension);- (- instance_data,- capacity,- max_instance_data_size,- INSTANCE_TEXTURE_TEXEL_SIZE,- )- } else {- // 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 initial_capacity = (2 * 1024 * 1024).min(max_buffer_size);- let buffer = device.create_buffer(&wgpu::BufferDescriptor {- label: Some("instance_buffer"),- size: initial_capacity,- usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST,- mapped_at_creation: false,- });- (- InstanceData::Storage(buffer),- initial_capacity,- max_buffer_size,- device.limits().min_storage_buffer_offset_alignment as u64,- )- };-- let globals_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {- label: Some("globals_bind_group"),- layout: &bind_group_layouts.globals,- entries: &[- wgpu::BindGroupEntry {- binding: 0,- resource: wgpu::BindingResource::Buffer(wgpu::BufferBinding {- buffer: &globals_buffer,- offset: 0,- size: Some(NonZeroU64::new(globals_size).unwrap()),- }),- },- wgpu::BindGroupEntry {- binding: 1,- resource: wgpu::BindingResource::Buffer(wgpu::BufferBinding {- buffer: &globals_buffer,- offset: gamma_offset,- size: Some(NonZeroU64::new(gamma_size).unwrap()),- }),- },- ],- });-- let path_globals_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {- label: Some("path_globals_bind_group"),- layout: &bind_group_layouts.globals,- entries: &[- wgpu::BindGroupEntry {- binding: 0,- resource: wgpu::BindingResource::Buffer(wgpu::BufferBinding {- buffer: &globals_buffer,- offset: path_globals_offset,- size: Some(NonZeroU64::new(globals_size).unwrap()),- }),- },- wgpu::BindGroupEntry {- binding: 1,- resource: wgpu::BindingResource::Buffer(wgpu::BufferBinding {- buffer: &globals_buffer,- offset: gamma_offset,- size: Some(NonZeroU64::new(gamma_size).unwrap()),- }),- },- ],- });-- let adapter_info = context.adapter.get_info();-- let last_error: Arc<Mutex<Option<String>>> = Arc::new(Mutex::new(None));- let last_error_clone = Arc::clone(&last_error);- device.on_uncaptured_error(Arc::new(move |error| {- let mut guard = last_error_clone.lock().unwrap();- *guard = Some(error.to_string());- }));-- let resources = WgpuResources {- device,- queue,- surface,- pipelines,- bind_group_layouts,- atlas_sampler,- atlas_texture_bind_groups: FxHashMap::default(),- globals_buffer,- globals_bind_group,- path_globals_bind_group,- instance_data,- // Defer intermediate texture creation to first draw call via ensure_intermediate_textures().- // This avoids panics when the device/surface is in an invalid state during initialization.- path_intermediate_texture: None,- path_intermediate_view: None,- path_msaa_texture: None,- path_msaa_view: None,- };+ let core = WgpuRendererCore::new(context, atlas.clone(), surface_format, alpha_mode);Ok(Self {context: gpu_context,compositor_gpu,- resources: Some(resources),+ state: RendererState::Ready { surface, core },surface_config,atlas,- path_globals_offset,- gamma_offset,- instance_data_capacity,- max_instance_data_size,- instance_data_alignment,- uses_webgl_instance_data,- rendering_params,- is_bgr: false,- dual_source_blending,- adapter_info,transparent_alpha_mode,opaque_alpha_mode,max_texture_size,- last_error,+ is_bgr: false,failed_frame_count: 0,- device_lost: context.device_lost_flag(),- surface_configured: true,+ device_errors: Arc::clone(context.errors()),+ observed_error_generation: 0,+ last_surface_error: None,needs_redraw: false,})}+}+impl WgpuRendererCore {fn create_bind_group_layouts(device: &wgpu::Device,uses_webgl_instance_data: bool,@@ -1127,88 +994,67 @@ impl WgpuRenderer {let view = texture.create_view(&wgpu::TextureViewDescriptor::default());Some((texture, view))}+}+impl WgpuRenderer {+ /// Records the new drawable size and reconfigures the surface when one is present.+ /// The size is kept even without GPU resources so that recovery restores it.pub fn update_drawable_size(&mut self, size: Size<DevicePixels>) {let width = size.width.0 as u32;let height = size.height.0 as u32;- if width != self.surface_config.width || height != self.surface_config.height {- let clamped_width = width.min(self.max_texture_size);- let clamped_height = height.min(self.max_texture_size);-- if clamped_width != width || clamped_height != height {- warn!(- "Requested surface size ({}, {}) exceeds maximum texture dimension {}. \- Clamping to ({}, {}). Window content may not fill the entire window.",- width, height, self.max_texture_size, clamped_width, clamped_height- );- }-- self.surface_config.width = clamped_width.max(1);- self.surface_config.height = clamped_height.max(1);- let surface_config = self.surface_config.clone();-- let Some(resources) = self.resources.as_mut() else {- return;- };-- // Wait for any in-flight GPU work to complete before destroying textures- if let Err(e) = resources.device.poll(wgpu::PollType::Wait {- submission_index: None,- timeout: None,- }) {- warn!("Failed to poll device during resize: {e:?}");- }-- // Destroy old textures before allocating new ones to avoid GPU memory spikes- if let Some(ref texture) = resources.path_intermediate_texture {- texture.destroy();- }- if let Some(ref texture) = resources.path_msaa_texture {- texture.destroy();- }-- resources- .surface- .configure(&resources.device, &surface_config);+ if width == self.surface_config.width && height == self.surface_config.height {+ return;+ }- // Invalidate intermediate textures - they will be lazily recreated- // in draw() after we confirm the surface is healthy. This avoids- // panics when the device/surface is in an invalid state during resize.- resources.invalidate_intermediate_textures();+ let clamped_width = width.min(self.max_texture_size);+ let clamped_height = height.min(self.max_texture_size);+ if clamped_width != width || clamped_height != height {+ warn!(+ "Requested surface size ({}, {}) exceeds maximum texture dimension {}. \+ Clamping to ({}, {}). Window content may not fill the entire window.",+ width, height, self.max_texture_size, clamped_width, clamped_height+ );}- }+ self.surface_config.width = clamped_width.max(1);+ self.surface_config.height = clamped_height.max(1);- fn ensure_intermediate_textures(&mut self) {- if self.resources().path_intermediate_texture.is_some() {+ let Some(core) = self.core_mut() else {return;+ };+ let resources = &mut core.resources;++ // Wait for any in-flight GPU work to complete before destroying textures+ if let Err(e) = resources.device.poll(wgpu::PollType::Wait {+ submission_index: None,+ timeout: None,+ }) {+ warn!("Failed to poll device during resize: {e:?}");}- let format = self.surface_config.format;- let width = self.surface_config.width;- let height = self.surface_config.height;- let path_sample_count = self.rendering_params.path_sample_count;- let resources = self.resources_mut();+ // Destroy old textures before allocating new ones to avoid GPU memory spikes+ if let Some(ref texture) = resources.path_intermediate_texture {+ texture.destroy();+ }+ if let Some(ref texture) = resources.path_msaa_texture {+ texture.destroy();+ }- let (t, v) = Self::create_path_intermediate(&resources.device, format, width, height);- resources.path_intermediate_texture = Some(t);- resources.path_intermediate_view = Some(v);+ // Invalidate intermediate textures - they will be lazily recreated+ // in draw() after we confirm the surface is healthy. This avoids+ // panics when the device/surface is in an invalid state during resize.+ resources.invalidate_intermediate_textures();- let (path_msaa_texture, path_msaa_view) = Self::create_msaa_if_needed(- &resources.device,- format,- width,- height,- path_sample_count,- )- .map(|(t, v)| (Some(t), Some(v)))- .unwrap_or((None, None));- resources.path_msaa_texture = path_msaa_texture;- resources.path_msaa_view = path_msaa_view;+ if let RendererState::Ready { surface, core } = &self.state {+ surface.configure(&core.resources.device, &self.surface_config);+ }}pub fn set_subpixel_layout(&mut self, is_bgr: bool) {self.is_bgr = is_bgr;+ if let Some(core) = self.core_mut() {+ core.is_bgr = is_bgr;+ }}pub fn update_transparency(&mut self, transparent: bool) {@@ -1217,28 +1063,28 @@ impl WgpuRenderer {} else {self.opaque_alpha_mode};+ if new_alpha_mode == self.surface_config.alpha_mode {+ return;+ }+ self.surface_config.alpha_mode = new_alpha_mode;+ let format = self.surface_config.format;- if new_alpha_mode != self.surface_config.alpha_mode {- self.surface_config.alpha_mode = new_alpha_mode;- let surface_config = self.surface_config.clone();- let path_sample_count = self.rendering_params.path_sample_count;- let dual_source_blending = self.dual_source_blending;- let uses_webgl_instance_data = self.uses_webgl_instance_data;- let Some(resources) = self.resources.as_mut() else {- return;- };- resources- .surface- .configure(&resources.device, &surface_config);- resources.pipelines = Self::create_pipelines(- &resources.device,- &resources.bind_group_layouts,- surface_config.format,- surface_config.alpha_mode,- path_sample_count,- dual_source_blending,- uses_webgl_instance_data,- );+ let Some(core) = self.core_mut() else {+ return;+ };+ let resources = &mut core.resources;+ resources.pipelines = WgpuRendererCore::create_pipelines(+ &resources.device,+ &resources.bind_group_layouts,+ format,+ new_alpha_mode,+ core.rendering_params.path_sample_count,+ core.dual_source_blending,+ core.uses_webgl_instance_data,+ );++ if let RendererState::Ready { surface, core } = &self.state {+ surface.configure(&core.resources.device, &self.surface_config);}}@@ -1250,109 +1096,345 @@ impl WgpuRenderer {}}- pub fn sprite_atlas(&self) -> &Arc<WgpuAtlas> {- &self.atlas+ pub fn sprite_atlas(&self) -> &Arc<WgpuAtlas> {+ &self.atlas+ }++ pub fn supports_dual_source_blending(&self) -> bool {+ self.core().is_some_and(|core| core.dual_source_blending)+ }++ /// Returns `None` once GPU resources have been released by `destroy` or a pending+ /// device recovery.+ pub fn gpu_specs(&self) -> Option<GpuSpecs> {+ let adapter_info = &self.core()?.adapter_info;+ Some(GpuSpecs {+ is_software_emulated: adapter_info.device_type == wgpu::DeviceType::Cpu,+ device_name: adapter_info.name.clone(),+ driver_name: adapter_info.driver.clone(),+ driver_info: adapter_info.driver_info.clone(),+ })+ }++ pub fn max_texture_size(&self) -> u32 {+ self.max_texture_size+ }++ pub fn draw(&mut self, scene: &Scene) -> bool {+ #[cfg(target_family = "wasm")]+ if self.device_lost() {+ if matches!(self.state, RendererState::Ready { .. }) {+ log::error!(+ "Browser graphics context was lost; rendering has stopped. Reload the page to recover."+ );+ self.unconfigure_surface();+ }+ return false;+ }++ // Bail out early if the surface has been unconfigured (e.g. during+ // Android background/rotation transitions). Attempting to acquire+ // a texture from an unconfigured surface can block indefinitely on+ // some drivers (Adreno).+ let RendererState::Ready { surface, core } = &mut self.state else {+ return false;+ };++ if let Some(error) = self.last_surface_error.take().or_else(|| {+ self.device_errors+ .observe_error(&mut self.observed_error_generation)+ }) {+ self.failed_frame_count += 1;+ log::error!(+ "GPU error during frame (failure {} of 10): {error}",+ self.failed_frame_count+ );++ // TBD. Does retrying more actually help?+ if self.failed_frame_count > 10 {+ panic!("Too many consecutive GPU errors. Last error: {error}");+ } else if self.failed_frame_count > 5 {+ core.resources.invalidate_intermediate_textures();+ self.atlas.clear();+ self.needs_redraw = true;+ self.failed_frame_count = 0;+ return false;+ }+ } else {+ self.failed_frame_count = 0;+ }++ let frame = match surface.get_current_texture() {+ wgpu::CurrentSurfaceTexture::Success(frame) => frame,+ wgpu::CurrentSurfaceTexture::Suboptimal(frame) => {+ // Textures must be destroyed before the surface can be reconfigured.+ drop(frame);+ surface.configure(&core.resources.device, &self.surface_config);+ return false;+ }+ wgpu::CurrentSurfaceTexture::Lost | wgpu::CurrentSurfaceTexture::Outdated => {+ surface.configure(&core.resources.device, &self.surface_config);+ return false;+ }+ wgpu::CurrentSurfaceTexture::Timeout | wgpu::CurrentSurfaceTexture::Occluded => {+ return false;+ }+ wgpu::CurrentSurfaceTexture::Validation => {+ self.last_surface_error = Some("Surface texture validation error".to_string());+ return false;+ }+ };++ // The acquired texture is the authority on frame dimensions; the surface+ // configuration is only a request.+ let size = Size {+ width: DevicePixels(frame.texture.width() as i32),+ height: DevicePixels(frame.texture.height() as i32),+ };+ let frame_view = frame+ .texture+ .create_view(&wgpu::TextureViewDescriptor::default());+ let premultiplied_alpha =+ self.surface_config.alpha_mode == wgpu::CompositeAlphaMode::PreMultiplied;+ if let Err(error) = core.render_frame(+ scene,+ &frame_view,+ size,+ premultiplied_alpha,+ wgpu::Color::TRANSPARENT,+ ) {+ log::error!("{error:#}");+ return false;+ }++ frame.present();+ true+ }+}++impl WgpuRendererCore {+ fn new(+ context: &WgpuContext,+ atlas: Arc<WgpuAtlas>,+ target_format: wgpu::TextureFormat,+ alpha_mode: wgpu::CompositeAlphaMode,+ ) -> Self {+ let device = Arc::clone(&context.device);+ let queue = Arc::clone(&context.queue);+ let rendering_params = RenderingParameters::new(&context.adapter, target_format);+ let uses_webgl_instance_data = context.uses_webgl_instance_data();+ let dual_source_blending =+ context.supports_dual_source_blending() && !uses_webgl_instance_data;+ let bind_group_layouts = Self::create_bind_group_layouts(&device, uses_webgl_instance_data);+ let pipelines = Self::create_pipelines(+ &device,+ &bind_group_layouts,+ target_format,+ alpha_mode,+ rendering_params.path_sample_count,+ dual_source_blending,+ uses_webgl_instance_data,+ );+ let atlas_sampler = device.create_sampler(&wgpu::SamplerDescriptor {+ label: Some("atlas_sampler"),+ mag_filter: wgpu::FilterMode::Linear,+ min_filter: wgpu::FilterMode::Linear,+ ..Default::default()+ });+ let uniform_alignment = device.limits().min_uniform_buffer_offset_alignment as u64;+ let globals_size = std::mem::size_of::<GlobalParams>() as u64;+ let gamma_size = std::mem::size_of::<GammaParams>() as u64;+ let path_globals_offset = globals_size.next_multiple_of(uniform_alignment);+ let gamma_offset = (path_globals_offset + globals_size).next_multiple_of(uniform_alignment);+ let globals_buffer = device.create_buffer(&wgpu::BufferDescriptor {+ label: Some("globals_buffer"),+ size: gamma_offset + gamma_size,+ usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,+ mapped_at_creation: false,+ });+ let (+ instance_data,+ instance_data_capacity,+ max_instance_data_size,+ instance_data_alignment,+ ) = if uses_webgl_instance_data {+ let max_texture_dimension = device.limits().max_texture_dimension_2d;+ let max_instance_data_size = (u64::from(max_texture_dimension).pow(2)+ * INSTANCE_TEXTURE_TEXEL_SIZE)+ .min(MAX_INSTANCE_BUFFER_SIZE);+ let initial_capacity = (2 * 1024 * 1024).min(max_instance_data_size);+ let (instance_data, capacity) =+ Self::create_instance_texture(&device, initial_capacity, max_texture_dimension);+ (+ instance_data,+ capacity,+ max_instance_data_size,+ INSTANCE_TEXTURE_TEXEL_SIZE,+ )+ } else {+ let max_buffer_size = device+ .limits()+ .max_buffer_size+ .min(device.limits().max_storage_buffer_binding_size)+ .min(MAX_INSTANCE_BUFFER_SIZE);+ let initial_capacity = (2 * 1024 * 1024).min(max_buffer_size);+ let buffer = device.create_buffer(&wgpu::BufferDescriptor {+ label: Some("instance_buffer"),+ size: initial_capacity,+ usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST,+ mapped_at_creation: false,+ });+ (+ InstanceData::Storage(buffer),+ initial_capacity,+ max_buffer_size,+ device.limits().min_storage_buffer_offset_alignment as u64,+ )+ };+ let globals_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {+ label: Some("globals_bind_group"),+ layout: &bind_group_layouts.globals,+ entries: &[+ wgpu::BindGroupEntry {+ binding: 0,+ resource: wgpu::BindingResource::Buffer(wgpu::BufferBinding {+ buffer: &globals_buffer,+ offset: 0,+ size: NonZeroU64::new(globals_size),+ }),+ },+ wgpu::BindGroupEntry {+ binding: 1,+ resource: wgpu::BindingResource::Buffer(wgpu::BufferBinding {+ buffer: &globals_buffer,+ offset: gamma_offset,+ size: NonZeroU64::new(gamma_size),+ }),+ },+ ],+ });+ let path_globals_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {+ label: Some("path_globals_bind_group"),+ layout: &bind_group_layouts.globals,+ entries: &[+ wgpu::BindGroupEntry {+ binding: 0,+ resource: wgpu::BindingResource::Buffer(wgpu::BufferBinding {+ buffer: &globals_buffer,+ offset: path_globals_offset,+ size: NonZeroU64::new(globals_size),+ }),+ },+ wgpu::BindGroupEntry {+ binding: 1,+ resource: wgpu::BindingResource::Buffer(wgpu::BufferBinding {+ buffer: &globals_buffer,+ offset: gamma_offset,+ size: NonZeroU64::new(gamma_size),+ }),+ },+ ],+ });+ let max_texture_size = device.limits().max_texture_dimension_2d;++ Self {+ resources: WgpuResources {+ device,+ queue,+ pipelines,+ bind_group_layouts,+ atlas_sampler,+ atlas_texture_bind_groups: FxHashMap::default(),+ globals_buffer,+ globals_bind_group,+ path_globals_bind_group,+ instance_data,+ path_intermediate_texture: None,+ path_intermediate_view: None,+ path_msaa_texture: None,+ path_msaa_view: None,+ },+ atlas,+ path_globals_offset,+ gamma_offset,+ instance_data_capacity,+ max_instance_data_size,+ instance_data_alignment,+ uses_webgl_instance_data,+ rendering_params,+ is_bgr: false,+ dual_source_blending,+ adapter_info: context.adapter.get_info(),+ target_format,+ max_texture_size,+ }+ }++ fn resources(&self) -> &WgpuResources {+ &self.resources}- pub fn supports_dual_source_blending(&self) -> bool {- self.dual_source_blending+ fn resources_mut(&mut self) -> &mut WgpuResources {+ &mut self.resources}- pub fn gpu_specs(&self) -> GpuSpecs {- GpuSpecs {- is_software_emulated: self.adapter_info.device_type == wgpu::DeviceType::Cpu,- device_name: self.adapter_info.name.clone(),- driver_name: self.adapter_info.driver.clone(),- driver_info: self.adapter_info.driver_info.clone(),+ /// Path rendering goes through an intermediate texture that must match the frame+ /// target's dimensions, so the textures are keyed by size and rebuilt on mismatch.+ fn ensure_intermediate_textures(&mut self, size: Size<DevicePixels>) {+ let width = size.width.0 as u32;+ let height = size.height.0 as u32;+ if self+ .resources+ .path_intermediate_texture+ .as_ref()+ .is_some_and(|texture| texture.width() == width && texture.height() == height)+ {+ return;}- }-- pub fn max_texture_size(&self) -> u32 {- self.max_texture_size- }- pub fn draw(&mut self, scene: &Scene) -> bool {- #[cfg(target_family = "wasm")]- if self.device_lost() {- if self.surface_configured {- log::error!(- "Browser graphics context was lost; rendering has stopped. Reload the page to recover."- );- self.surface_configured = false;- }- return false;- }+ let format = self.target_format;+ let path_sample_count = self.rendering_params.path_sample_count;+ let resources = &mut self.resources;- // Bail out early if the surface has been unconfigured (e.g. during- // Android background/rotation transitions). Attempting to acquire- // a texture from an unconfigured surface can block indefinitely on- // some drivers (Adreno).- if !self.surface_configured {- return false;- }+ let (texture, view) =+ Self::create_path_intermediate(&resources.device, format, width, height);+ resources.path_intermediate_texture = Some(texture);+ resources.path_intermediate_view = Some(view);- let last_error = self.last_error.lock().unwrap().take();- if let Some(error) = last_error {- self.failed_frame_count += 1;- log::error!(- "GPU error during frame (failure {} of 10): {error}",- self.failed_frame_count- );+ let (path_msaa_texture, path_msaa_view) = Self::create_msaa_if_needed(+ &resources.device,+ format,+ width,+ height,+ path_sample_count,+ )+ .map(|(texture, view)| (Some(texture), Some(view)))+ .unwrap_or((None, None));+ resources.path_msaa_texture = path_msaa_texture;+ resources.path_msaa_view = path_msaa_view;+ }- // TBD. Does retrying more actually help?- if self.failed_frame_count > 10 {- panic!("Too many consecutive GPU errors. Last error: {error}");- } else if self.failed_frame_count > 5 {- if let Some(res) = self.resources.as_mut() {- res.invalidate_intermediate_textures();- }- self.atlas.clear();- self.needs_redraw = true;- self.failed_frame_count = 0;- return false;- }- } else {- self.failed_frame_count = 0;- }+ fn render_frame(+ &mut self,+ scene: &Scene,+ target_view: &wgpu::TextureView,+ size: Size<DevicePixels>,+ premultiplied_alpha: bool,+ clear_color: wgpu::Color,+ ) -> Result<wgpu::SubmissionIndex> {+ anyhow::ensure!(+ size.width.0 > 0 && size.height.0 > 0,+ "invalid render target size: {size:?}"+ );+ anyhow::ensure!(+ size.width.0 as u32 <= self.max_texture_size+ && size.height.0 as u32 <= self.max_texture_size,+ "render target size {size:?} exceeds maximum texture dimension {}",+ self.max_texture_size+ );self.atlas.before_frame();-- let frame = match self.resources().surface.get_current_texture() {- wgpu::CurrentSurfaceTexture::Success(frame) => frame,- wgpu::CurrentSurfaceTexture::Suboptimal(frame) => {- // Textures must be destroyed before the surface can be reconfigured.- drop(frame);- let surface_config = self.surface_config.clone();- let resources = self.resources_mut();- resources- .surface- .configure(&resources.device, &surface_config);- return false;- }- wgpu::CurrentSurfaceTexture::Lost | wgpu::CurrentSurfaceTexture::Outdated => {- let surface_config = self.surface_config.clone();- let resources = self.resources_mut();- resources- .surface- .configure(&resources.device, &surface_config);- return false;- }- wgpu::CurrentSurfaceTexture::Timeout | wgpu::CurrentSurfaceTexture::Occluded => {- return false;- }- wgpu::CurrentSurfaceTexture::Validation => {- *self.last_error.lock().unwrap() =- Some("Surface texture validation error".to_string());- return false;- }- };-- // Now that we know the surface is healthy, ensure intermediate textures exist- self.ensure_intermediate_textures();-- let frame_view = frame- .texture- .create_view(&wgpu::TextureViewDescriptor::default());+ self.ensure_intermediate_textures(size);let gamma_params = GammaParams {gamma_ratios: self.rendering_params.gamma_ratios,@@ -1361,57 +1443,44 @@ impl WgpuRenderer {is_bgr: self.is_bgr as u32,_pad: 0,};-let globals = GlobalParams {- viewport_size: [- self.surface_config.width as f32,- self.surface_config.height as f32,- ],- premultiplied_alpha: if self.surface_config.alpha_mode- == wgpu::CompositeAlphaMode::PreMultiplied- {- 1- } else {- 0- },+ viewport_size: [size.width.0 as f32, size.height.0 as f32],+ premultiplied_alpha: premultiplied_alpha as u32,pad: 0,};-let path_globals = GlobalParams {premultiplied_alpha: 0,..globals};+ self.resources.queue.write_buffer(+ &self.resources.globals_buffer,+ 0,+ bytemuck::bytes_of(&globals),+ );+ self.resources.queue.write_buffer(+ &self.resources.globals_buffer,+ self.path_globals_offset,+ bytemuck::bytes_of(&path_globals),+ );+ self.resources.queue.write_buffer(+ &self.resources.globals_buffer,+ self.gamma_offset,+ bytemuck::bytes_of(&gamma_params),+ );- {- let resources = self.resources();- resources.queue.write_buffer(- &resources.globals_buffer,- 0,- bytemuck::bytes_of(&globals),- );- resources.queue.write_buffer(- &resources.globals_buffer,- self.path_globals_offset,- bytemuck::bytes_of(&path_globals),- );- resources.queue.write_buffer(- &resources.globals_buffer,- self.gamma_offset,- bytemuck::bytes_of(&gamma_params),- );- }-- if let Err(error) = self.record_frame(scene, &frame_view) {- log::error!("{error:#}");- self.resources().queue.submit(std::iter::empty());- return false;- }-- frame.present();- true+ self.record_frame(scene, target_view, clear_color)+ .inspect_err(|_| {+ // Queue writes are staged before encoding; flush them even if the frame fails.+ self.resources.queue.submit(std::iter::empty());+ })}- fn record_frame(&mut self, scene: &Scene, frame_view: &wgpu::TextureView) -> Result<()> {+ fn record_frame(+ &mut self,+ scene: &Scene,+ frame_view: &wgpu::TextureView,+ clear_color: wgpu::Color,+ ) -> Result<wgpu::SubmissionIndex> {let mut instance_offset = 0;let instance_bindings = self.write_instances(scene, &mut instance_offset)@@ -1443,7 +1512,7 @@ impl WgpuRenderer {view: frame_view,resolve_target: None,ops: wgpu::Operations {- load: wgpu::LoadOp::Clear(wgpu::Color::TRANSPARENT),+ load: wgpu::LoadOp::Clear(clear_color),store: wgpu::StoreOp::Store,},depth_slice: None,@@ -1547,10 +1616,11 @@ impl WgpuRenderer {}}- self.resources()+ let submission = self+ .resources().queue.submit(std::iter::once(encoder.finish()));- Ok(())+ Ok(submission)}fn write_instances(@@ -2032,7 +2102,9 @@ impl WgpuRenderer {}Ok(())}+}+impl WgpuRenderer {/// Mark the surface as unconfigured so rendering is skipped until a new/// surface is provided via [`replace_surface`](Self::replace_surface).///@@ -2041,10 +2113,16 @@ impl WgpuRenderer {/// (e.g. Android `TerminateWindow`) but you intend to re-create the/// surface later without losing cached atlas textures.pub fn unconfigure_surface(&mut self) {- self.surface_configured = false;+ self.state = match std::mem::replace(&mut self.state, RendererState::Released) {+ RendererState::Ready { core, surface } => {+ drop(surface);+ RendererState::Unconfigured { core }+ }+ state @ (RendererState::Unconfigured { .. } | RendererState::Released) => state,+ };// Drop intermediate textures since they reference the old surface size.- if let Some(res) = self.resources.as_mut() {- res.invalidate_intermediate_textures();+ if let Some(core) = self.core_mut() {+ core.resources.invalidate_intermediate_textures();}}@@ -2085,19 +2163,22 @@ impl WgpuRenderer {self.surface_config.present_mode = mode;}- {- let res = self- .resources- .as_mut()- .expect("GPU resources not available");- surface.configure(&res.device, &self.surface_config);- res.surface = surface;-- // Invalidate intermediate textures — they'll be recreated lazily.- res.invalidate_intermediate_textures();- }-- self.surface_configured = true;+ let mut core = match std::mem::replace(&mut self.state, RendererState::Released) {+ RendererState::Ready {+ core,+ surface: old_surface,+ } => {+ drop(old_surface);+ core+ }+ RendererState::Unconfigured { core } => core,+ RendererState::Released => {+ anyhow::bail!("Cannot replace the surface: GPU resources have been released")+ }+ };+ surface.configure(&core.resources.device, &self.surface_config);+ core.resources.invalidate_intermediate_textures();+ self.state = RendererState::Ready { surface, core };Ok(())}@@ -2105,12 +2186,12 @@ impl WgpuRenderer {pub fn destroy(&mut self) {// Release surface-bound GPU resources eagerly so the underlying native// window can be destroyed before the renderer itself is dropped.- self.resources.take();+ self.state = RendererState::Released;}/// Returns true if the GPU device was lost and recovery is needed.pub fn device_lost(&self) -> bool {- self.device_lost.load(std::sync::atomic::Ordering::SeqCst)+ self.device_errors.device_lost()}/// Returns true if a redraw is needed because GPU state was cleared.@@ -2147,7 +2228,7 @@ impl WgpuRenderer {log::warn!("GPU device lost, recreating context...");// Drop old resources to release Arc<Device>/Arc<Queue> and GPU resources- self.resources = None;+ self.state = RendererState::Released;*gpu_context.borrow_mut() = None;// Wait briefly for the GPU driver to stabilize, then try to@@ -2156,7 +2237,7 @@ impl WgpuRenderer {// may need more time to come back (e.g. after suspend/resume).std::thread::sleep(std::time::Duration::from_millis(350));- let instance = WgpuContext::instance(Box::new(window.clone()));+ let instance = WgpuContext::instance(Some(Box::new(window.clone())));let surface = create_surface(&instance, window_handle.as_raw())?;let new_context =WgpuContext::new_rejecting_software(instance, &surface, self.compositor_gpu)?;@@ -2180,9 +2261,10 @@ impl WgpuRenderer {let ctx_ref = gpu_context.borrow();let context = ctx_ref.as_ref().expect("context should exist");- self.resources = None;+ self.state = RendererState::Released;self.atlas.handle_device_lost(context);+ let is_bgr = self.is_bgr;*self = Self::new_internal(Some(gpu_context.clone()),context,@@ -2191,12 +2273,275 @@ impl WgpuRenderer {self.compositor_gpu,self.atlas.clone(),)?;+ self.set_subpixel_layout(is_bgr);log::info!("GPU recovery complete");Ok(())}}+#[cfg(all(+ not(target_family = "wasm"),+ any(test, feature = "bench-support", feature = "test-support")+))]+struct HeadlessRenderTarget {+ texture: wgpu::Texture,+ view: wgpu::TextureView,+}++#[cfg(all(+ not(target_family = "wasm"),+ any(test, feature = "bench-support", feature = "test-support")+))]+impl HeadlessRenderTarget {+ fn size(&self) -> Size<DevicePixels> {+ Size {+ width: DevicePixels(self.texture.width() as i32),+ height: DevicePixels(self.texture.height() as i32),+ }+ }+}++#[cfg(all(+ not(target_family = "wasm"),+ any(test, feature = "bench-support", feature = "test-support")+))]+pub struct WgpuHeadlessRenderer {+ context: WgpuContext,+ core: WgpuRendererCore,+ render_target: Option<HeadlessRenderTarget>,+ observed_error_generation: u64,+}++#[cfg(all(+ not(target_family = "wasm"),+ any(test, feature = "bench-support", feature = "test-support")+))]+impl WgpuHeadlessRenderer {+ pub fn new() -> anyhow::Result<Self> {+ let (context, target_format) = WgpuContext::new_headless()?;+ let atlas = Arc::new(WgpuAtlas::from_context(&context));+ let core = WgpuRendererCore::new(+ &context,+ atlas,+ target_format,+ wgpu::CompositeAlphaMode::Opaque,+ );++ Ok(Self {+ context,+ core,+ render_target: None,+ observed_error_generation: 0,+ })+ }++ fn ensure_render_target(&mut self, size: Size<DevicePixels>) -> anyhow::Result<()> {+ anyhow::ensure!(+ size.width.0 > 0 && size.height.0 > 0,+ "invalid headless render target size: {size:?}"+ );+ anyhow::ensure!(+ size.width.0 as u32 <= self.core.max_texture_size+ && size.height.0 as u32 <= self.core.max_texture_size,+ "headless render target size {size:?} exceeds maximum texture dimension {}",+ self.core.max_texture_size+ );+ if self+ .render_target+ .as_ref()+ .is_some_and(|target| target.size() == size)+ {+ return Ok(());+ }++ let texture = self+ .core+ .resources+ .device+ .create_texture(&wgpu::TextureDescriptor {+ label: Some("headless_render_target"),+ size: wgpu::Extent3d {+ width: size.width.0 as u32,+ height: size.height.0 as u32,+ depth_or_array_layers: 1,+ },+ mip_level_count: 1,+ sample_count: 1,+ dimension: wgpu::TextureDimension::D2,+ format: self.core.target_format,+ usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC,+ view_formats: &[],+ });+ let view = texture.create_view(&wgpu::TextureViewDescriptor::default());+ self.render_target = Some(HeadlessRenderTarget { texture, view });+ Ok(())+ }++ fn check_gpu_errors(&mut self) -> anyhow::Result<()> {+ anyhow::ensure!(+ !self.context.device_lost(),+ "GPU device was lost during headless rendering"+ );+ if let Some(error) = self+ .context+ .errors()+ .observe_error(&mut self.observed_error_generation)+ {+ anyhow::bail!("GPU error during headless rendering: {error}");+ }+ Ok(())+ }++ fn render(&mut self, scene: &Scene, size: Size<DevicePixels>) -> anyhow::Result<()> {+ self.check_gpu_errors()?;+ self.ensure_render_target(size)?;+ let view = self+ .render_target+ .as_ref()+ .ok_or_else(|| anyhow::anyhow!("Headless render target was not created"))?+ .view+ .clone();+ self.core+ .render_frame(scene, &view, size, false, wgpu::Color::BLACK)?;+ Ok(())+ }++ /// Copies the current render target back to the CPU. Dimensions come from the+ /// target texture itself, so the copy can never disagree with what was rendered.+ fn read_image(&mut self) -> anyhow::Result<image::RgbaImage> {+ let target = self+ .render_target+ .as_ref()+ .ok_or_else(|| anyhow::anyhow!("Headless render target was not created"))?;+ let width = target.texture.width();+ let height = target.texture.height();+ let bytes_per_row = width+ .checked_mul(4)+ .ok_or_else(|| anyhow::anyhow!("Headless render target row size overflowed"))?;+ let padded_bytes_per_row = bytes_per_row+ .checked_next_multiple_of(wgpu::COPY_BYTES_PER_ROW_ALIGNMENT)+ .ok_or_else(|| anyhow::anyhow!("Headless padded row size overflowed"))?;+ let buffer_size = u64::from(padded_bytes_per_row)+ .checked_mul(u64::from(height))+ .ok_or_else(|| anyhow::anyhow!("Headless readback buffer size overflowed"))?;+ anyhow::ensure!(+ buffer_size <= self.core.resources.device.limits().max_buffer_size,+ "Headless readback buffer size {buffer_size} exceeds maximum buffer size {}",+ self.core.resources.device.limits().max_buffer_size+ );+ let readback_buffer = self+ .core+ .resources+ .device+ .create_buffer(&wgpu::BufferDescriptor {+ label: Some("headless_readback_buffer"),+ size: buffer_size,+ usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ,+ mapped_at_creation: false,+ });+ let mut encoder =+ self.core+ .resources+ .device+ .create_command_encoder(&wgpu::CommandEncoderDescriptor {+ label: Some("headless_readback_encoder"),+ });+ encoder.copy_texture_to_buffer(+ wgpu::TexelCopyTextureInfo {+ texture: &target.texture,+ mip_level: 0,+ origin: wgpu::Origin3d::ZERO,+ aspect: wgpu::TextureAspect::All,+ },+ wgpu::TexelCopyBufferInfo {+ buffer: &readback_buffer,+ layout: wgpu::TexelCopyBufferLayout {+ offset: 0,+ bytes_per_row: Some(padded_bytes_per_row),+ rows_per_image: Some(height),+ },+ },+ wgpu::Extent3d {+ width,+ height,+ depth_or_array_layers: 1,+ },+ );+ let submission = self+ .core+ .resources+ .queue+ .submit(std::iter::once(encoder.finish()));+ let (sender, receiver) = std::sync::mpsc::channel();+ readback_buffer+ .slice(..)+ .map_async(wgpu::MapMode::Read, move |result| {+ if sender.send(result).is_err() {+ log::error!("Headless readback receiver was dropped before mapping completed");+ }+ });+ self.core+ .resources+ .device+ .poll(wgpu::PollType::Wait {+ submission_index: Some(submission),+ timeout: Some(std::time::Duration::from_secs(30)),+ })+ .map_err(|error| anyhow::anyhow!("Failed to wait for headless rendering: {error}"))?;+ receiver+ .recv_timeout(std::time::Duration::from_secs(30))+ .map_err(|error| anyhow::anyhow!("Failed to receive headless mapping result: {error}"))?+ .map_err(|error| anyhow::anyhow!("Failed to map headless readback buffer: {error}"))?;+ self.check_gpu_errors()?;++ let mapped_data = readback_buffer.slice(..).get_mapped_range();+ let pixel_capacity = usize::try_from(u64::from(bytes_per_row) * u64::from(height))+ .map_err(|_| anyhow::anyhow!("Headless image size exceeds addressable memory"))?;+ let mut pixels = Vec::with_capacity(pixel_capacity);+ for row in mapped_data+ .chunks_exact(padded_bytes_per_row as usize)+ .take(height as usize)+ {+ pixels.extend_from_slice(&row[..bytes_per_row as usize]);+ }+ drop(mapped_data);+ readback_buffer.unmap();++ if self.core.target_format == wgpu::TextureFormat::Bgra8Unorm {+ for pixel in pixels.chunks_exact_mut(4) {+ pixel.swap(0, 2);+ }+ }++ image::RgbaImage::from_raw(width, height, pixels)+ .ok_or_else(|| anyhow::anyhow!("Failed to create image from headless pixel data"))+ }+}++#[cfg(all(+ not(target_family = "wasm"),+ any(test, feature = "bench-support", feature = "test-support")+))]+impl gpui::PlatformHeadlessRenderer for WgpuHeadlessRenderer {+ fn render_scene_to_image(+ &mut self,+ scene: &Scene,+ size: Size<DevicePixels>,+ ) -> anyhow::Result<image::RgbaImage> {+ self.render(scene, size)?;+ self.read_image()+ }++ fn render_scene(&mut self, scene: &Scene, size: Size<DevicePixels>) -> anyhow::Result<()> {+ self.render(scene, size)+ }++ fn sprite_atlas(&self) -> Arc<dyn gpui::PlatformAtlas> {+ self.core.atlas.clone()+ }+}+fn instance_range(range: Range<usize>) -> Range<u32> {range.start as u32..range.end as u32}@@ -2267,9 +2612,161 @@ mod tests {use super::*;use gpui::{BorderStyle, ColorSpace, ContentMask, Corners, Edges, Hsla, MonochromeSprite,- PolychromeSprite, Quad, Shadow, SubpixelSprite, Underline, linear_color_stop,+ PolychromeSprite, Quad, Shadow, Size, SubpixelSprite, Underline, linear_color_stop,linear_gradient,};+ #[cfg(target_os = "linux")]+ use gpui::{DevicePixels, PlatformHeadlessRenderer, Scene};++ #[cfg(target_os = "linux")]+ fn device_size(width: i32, height: i32) -> Size<DevicePixels> {+ Size {+ width: DevicePixels(width),+ height: DevicePixels(height),+ }+ }++ #[cfg(target_os = "linux")]+ fn solid_quad(x: f32, y: f32, width: f32, height: f32, color: Hsla) -> Quad {+ let bounds = Bounds {+ origin: Point {+ x: x.into(),+ y: y.into(),+ },+ size: Size {+ width: width.into(),+ height: height.into(),+ },+ };+ Quad {+ order: 0,+ border_style: BorderStyle::Solid,+ bounds,+ content_mask: ContentMask { bounds },+ background: color.into(),+ border_color: color,+ corner_radii: Corners::default(),+ border_widths: Edges::default(),+ }+ }++ /// Channels are compared with a small tolerance so the assertions hold across+ /// drivers without pinning exact rasterizer output.+ #[cfg(target_os = "linux")]+ fn assert_pixel(image: &image::RgbaImage, x: u32, y: u32, expected: [u8; 4]) {+ let actual = image.get_pixel(x, y).0;+ assert!(+ actual+ .iter()+ .zip(expected)+ .all(|(actual, expected)| actual.abs_diff(expected) <= 3),+ "pixel ({x}, {y}) was {actual:?}, expected {expected:?}"+ );+ }++ #[cfg(target_os = "linux")]+ const RED: [u8; 4] = [255, 0, 0, 255];+ #[cfg(target_os = "linux")]+ const BLUE: [u8; 4] = [0, 0, 255, 255];+ #[cfg(target_os = "linux")]+ const BLACK: [u8; 4] = [0, 0, 0, 255];++ #[cfg(target_os = "linux")]+ #[test]+ fn headless_renderer_draws_quads_with_distinct_colors() -> anyhow::Result<()> {+ let mut renderer = WgpuHeadlessRenderer::new()?;+ let mut scene = Scene::default();+ scene.insert_primitive(solid_quad(0.0, 0.0, 32.0, 32.0, gpui::red()));+ scene.insert_primitive(solid_quad(32.0, 0.0, 32.0, 32.0, gpui::blue()));+ scene.finish();++ let image = renderer.render_scene_to_image(&scene, device_size(64, 32))?;+ assert_eq!(image.dimensions(), (64, 32));+ assert_pixel(&image, 8, 16, RED);+ assert_pixel(&image, 24, 16, RED);+ assert_pixel(&image, 40, 16, BLUE);+ assert_pixel(&image, 56, 16, BLUE);+ Ok(())+ }++ #[cfg(target_os = "linux")]+ #[test]+ fn headless_renderer_captures_each_requested_size() -> anyhow::Result<()> {+ let mut renderer = WgpuHeadlessRenderer::new()?;+ let mut scene = Scene::default();+ scene.insert_primitive(solid_quad(2.0, 2.0, 4.0, 3.0, gpui::red()));+ scene.finish();++ // 13 px rows are 52 bytes, forcing readback to strip copy-row padding.+ let image = renderer.render_scene_to_image(&scene, device_size(13, 7))?;+ assert_eq!(image.dimensions(), (13, 7));+ assert_pixel(&image, 0, 0, BLACK);+ assert_pixel(&image, 3, 3, RED);+ assert_pixel(&image, 12, 6, BLACK);++ let image = renderer.render_scene_to_image(&scene, device_size(17, 9))?;+ assert_eq!(image.dimensions(), (17, 9));+ assert_pixel(&image, 3, 3, RED);+ assert_pixel(&image, 16, 8, BLACK);++ let image = renderer.render_scene_to_image(&Scene::default(), device_size(13, 7))?;+ assert_eq!(image.dimensions(), (13, 7));+ assert!(image.pixels().all(|pixel| pixel.0 == BLACK));+ Ok(())+ }++ #[cfg(target_os = "linux")]+ #[test]+ fn headless_renderer_reuses_target_for_same_size() -> anyhow::Result<()> {+ let mut renderer = WgpuHeadlessRenderer::new()?;+ let target_texture = |renderer: &WgpuHeadlessRenderer| {+ renderer+ .render_target+ .as_ref()+ .map(|target| target.texture.clone())+ };++ renderer.render_scene(&Scene::default(), device_size(16, 16))?;+ let first = target_texture(&renderer);+ assert!(first.is_some());++ renderer.render_scene(&Scene::default(), device_size(16, 16))?;+ assert_eq!(target_texture(&renderer), first);++ renderer.render_scene(&Scene::default(), device_size(16, 17))?;+ assert_ne!(target_texture(&renderer), first);+ Ok(())+ }++ #[cfg(target_os = "linux")]+ #[test]+ fn headless_renderer_rejects_invalid_sizes() -> anyhow::Result<()> {+ let mut renderer = WgpuHeadlessRenderer::new()?;+ let too_large = renderer.core.max_texture_size as i32 + 1;++ for size in [+ device_size(0, 8),+ device_size(8, 0),+ device_size(-1, 8),+ device_size(too_large, 8),+ ] {+ assert!(+ renderer.render_scene(&Scene::default(), size).is_err(),+ "{size:?} should be rejected"+ );+ assert!(+ renderer+ .render_scene_to_image(&Scene::default(), size)+ .is_err(),+ "{size:?} should be rejected"+ );+ }++ // Rejection must leave the renderer usable.+ let image = renderer.render_scene_to_image(&Scene::default(), device_size(4, 4))?;+ assert_eq!(image.dimensions(), (4, 4));+ Ok(())+ }#[test]fn webgl_shader_is_valid_wgsl_without_storage_buffers() {@@ -2378,7 +2875,7 @@ mod tests {},};- let bytes = unsafe { WgpuRenderer::instance_bytes(std::slice::from_ref(&quad)) };+ let bytes = unsafe { WgpuRendererCore::instance_bytes(std::slice::from_ref(&quad)) };let words: &[u32] = bytemuck::cast_slice(bytes);assert_eq!(words,