Skip to content

armgit / zed

Public Imported from GitHub
0

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

gpui_wgpu: Add Linux headless rendering (#64718)

Anthony Eide91b82c10681
diff --git a/Cargo.lock b/Cargo.lock
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.toml
index 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 = false
required-features = ["bench-support"]
[dependencies]
+anyhow.workspace = true
gpui.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 = true
console_error_panic_hook.workspace = true
diff --git a/crates/gpui_platform/src/gpui_platform.rs b/crates/gpui_platform/src/gpui_platform.rs
index 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.rs
index 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.toml
index 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 = true
cosmic-text = "0.19.0"
etagere.workspace = true
itertools.workspace = true
+image = { workspace = true, optional = true }
log.workspace = true
parking_lot.workspace = true
profiling.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 = true
naga = { 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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,