Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
gpui: Webgl backend (#62165)
Cameron Mcloughlin4601ead4164a
diff --git a/Cargo.lock b/Cargo.lockindex e81a871f483..1c50600e16d 100644--- a/Cargo.lock+++ b/Cargo.lock@@ -8099,6 +8099,7 @@ dependencies = ["itertools 0.14.0","js-sys","log",+ "naga","parking_lot","pollster 0.4.0","profiling",@@ -21357,6 +21358,7 @@ dependencies = ["thiserror 2.0.17","wgpu-core-deps-apple","wgpu-core-deps-emscripten",+ "wgpu-core-deps-wasm","wgpu-core-deps-windows-linux-android","wgpu-hal","wgpu-naga-bridge",@@ -21381,6 +21383,15 @@ dependencies = ["wgpu-hal",]+[[package]]+name = "wgpu-core-deps-wasm"+version = "29.0.4"+source = "registry+https://github.com/rust-lang/crates.io-index"+checksum = "af1fb1798be2a912497d4c224f72d39bb0cb34af50e8bcc29865bc339c943059"+dependencies = [+ "wgpu-hal",+]+[[package]]name = "wgpu-core-deps-windows-linux-android"version = "29.0.4"diff --git a/crates/gpui_platform/src/gpui_platform.rs b/crates/gpui_platform/src/gpui_platform.rsindex 09b66bb8fc5..91d336ad169 100644--- a/crates/gpui_platform/src/gpui_platform.rs+++ b/crates/gpui_platform/src/gpui_platform.rs@@ -13,9 +13,7 @@ pub fn background_executor() -> gpui::BackgroundExecutor {pub fn application() -> gpui::Application {#[cfg(target_family = "wasm")]{- let platform = Rc::new(gpui_web::WebPlatform::new(true));- let http_client = std::sync::Arc::new(platform.fetch_http_client());- gpui::Application::with_platform(platform).with_http_client(http_client)+ application_with_web_backend(gpui_web::WebBackendPreference::Auto)}#[cfg(not(target_family = "wasm"))]@@ -26,6 +24,19 @@ pub fn headless() -> gpui::Application {gpui::Application::with_platform(current_platform(true))}+#[cfg(target_family = "wasm")]+pub use gpui_web::WebBackendPreference;++#[cfg(target_family = "wasm")]+pub fn application_with_web_backend(backend_preference: WebBackendPreference) -> gpui::Application {+ let platform = Rc::new(gpui_web::WebPlatform::new_with_backend(+ true,+ backend_preference,+ ));+ let http_client = std::sync::Arc::new(platform.fetch_http_client());+ gpui::Application::with_platform(platform).with_http_client(http_client)+}+/// Unlike `application`, this function returns a single-threaded web application.#[cfg(target_family = "wasm")]pub fn single_threaded_web() -> gpui::Application {diff --git a/crates/gpui_web/Cargo.toml b/crates/gpui_web/Cargo.tomlindex 2ec64e69686..917bc14267d 100644--- a/crates/gpui_web/Cargo.toml+++ b/crates/gpui_web/Cargo.toml@@ -54,6 +54,7 @@ web-sys = { version = "0.3", features = ["IdleDeadline","IdleRequestOptions","KeyboardEvent",+ "Location","MediaQueryList","MediaQueryListEvent","MouseEvent",diff --git a/crates/gpui_web/examples/hello_web/Cargo.toml b/crates/gpui_web/examples/hello_web/Cargo.tomlindex 7f8c5cf1377..925f47c71e4 100644--- a/crates/gpui_web/examples/hello_web/Cargo.toml+++ b/crates/gpui_web/examples/hello_web/Cargo.toml@@ -13,4 +13,5 @@ path = "main.rs"[dependencies]gpui = { path = "../../../gpui" }gpui_platform = { path = "../../../gpui_platform" }+web-sys = { version = "0.3", features = ["Location", "Window"] }web-time = "1"diff --git a/crates/gpui_web/examples/hello_web/main.rs b/crates/gpui_web/examples/hello_web/main.rsindex a6ff103e647..605fdf090e6 100644--- a/crates/gpui_web/examples/hello_web/main.rs+++ b/crates/gpui_web/examples/hello_web/main.rs@@ -405,9 +405,30 @@ impl Render for HelloWeb {// Entry point// ---------------------------------------------------------------------------+fn requested_backend() -> gpui_platform::WebBackendPreference {+ let search = web_sys::window()+ .and_then(|window| window.location().search().ok())+ .unwrap_or_default();+ if search+ .trim_start_matches('?')+ .split('&')+ .any(|parameter| parameter == "backend=webgpu")+ {+ gpui_platform::WebBackendPreference::WebGpu+ } else if search+ .trim_start_matches('?')+ .split('&')+ .any(|parameter| parameter == "backend=webgl")+ {+ gpui_platform::WebBackendPreference::WebGl+ } else {+ gpui_platform::WebBackendPreference::Auto+ }+}+fn main() {gpui_platform::web_init();- gpui_platform::application().run(|cx: &mut App| {+ gpui_platform::application_with_web_backend(requested_backend()).run(|cx: &mut App| {let bounds = Bounds::centered(None, size(px(640.), px(560.)), cx);cx.open_window(WindowOptions {diff --git a/crates/gpui_web/src/gpui_web.rs b/crates/gpui_web/src/gpui_web.rsindex dd9c3948163..72c56f95d9e 100644--- a/crates/gpui_web/src/gpui_web.rs+++ b/crates/gpui_web/src/gpui_web.rs@@ -1,5 +1,10 @@#![cfg(target_family = "wasm")]+//! GPUI's browser platform uses one document-owned canvas and supports one top-level window.+//! Browser WebGPU is preferred by default, with an automatic WebGL2 fallback. Applications can+//! force either backend with [`WebBackendPreference`]. Opening a second top-level window, or+//! reopening one after it closes, returns [`WebWindowError`].+mod dispatcher;mod display;mod events;@@ -11,8 +16,9 @@ mod window;pub use dispatcher::WebDispatcher;pub use display::WebDisplay;+pub use gpui_wgpu::WebBackendPreference;pub use http_client::{FetchCredentials, FetchHttpClient};pub use keyboard::WebKeyboardLayout;pub use logging::init_logging;-pub use platform::WebPlatform;+pub use platform::{WebPlatform, WebWindowError};pub use window::WebWindow;diff --git a/crates/gpui_web/src/platform.rs b/crates/gpui_web/src/platform.rsindex 33af331e302..ecf2736ceee 100644--- a/crates/gpui_web/src/platform.rs+++ b/crates/gpui_web/src/platform.rs@@ -12,7 +12,7 @@ use gpui::{PlatformKeyboardLayout, PlatformKeyboardMapper, PlatformTextSystem, PlatformWindow, Task,ThermalState, WindowAppearance, WindowKind, WindowParams, popup::PopupNotSupportedError,};-use gpui_wgpu::WgpuContext;+use gpui_wgpu::{PreparedWebGraphics, WebBackendPreference, WgpuContext, wgpu};use std::{borrow::Cow,cell::{Cell, RefCell},@@ -39,15 +39,69 @@ pub struct WebPlatform {background_executor: BackgroundExecutor,foreground_executor: ForegroundExecutor,text_system: Arc<dyn PlatformTextSystem>,- active_window: RefCell<Option<AnyWindowHandle>>,+ active_window: Rc<RefCell<Option<AnyWindowHandle>>>,active_display: Rc<dyn PlatformDisplay>,callbacks: RefCell<WebPlatformCallbacks>,+ backend_preference: WebBackendPreference,wgpu_context: Rc<RefCell<Option<WgpuContext>>>,+ prepared_window: Rc<RefCell<Option<PreparedWebWindow>>>,+ window_lifecycle: Rc<Cell<WebWindowLifecycle>>,cursor_visible: Rc<Cell<bool>>,last_cursor_css: Rc<Cell<&'static str>>,_cursor_restore_listeners: Vec<EventListenerHandle>,}+struct PreparedWebWindow {+ canvas: web_sys::HtmlCanvasElement,+ surface: wgpu::Surface<'static>,+}++#[derive(Clone, Copy, Debug, Eq, PartialEq)]+pub(crate) enum WebWindowLifecycle {+ Available,+ Open,+ Closed,+ Unavailable,+}++#[derive(Debug)]+pub enum WebWindowError {+ AlreadyOpen,+ ReopeningUnsupported,+ UnsupportedWindowKind(&'static str),+ /// Graphics initialization has not completed yet; retrying after it+ /// finishes (e.g. from the `Platform::run` callback) can succeed.+ GraphicsInitializationPending,+ /// Graphics initialization or an earlier window creation failed;+ /// retrying cannot succeed.+ GraphicsUnavailable,+}++impl std::fmt::Display for WebWindowError {+ fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {+ match self {+ Self::AlreadyOpen => formatter.write_str(+ "GPUI web supports only one top-level window; a window is already open",+ ),+ Self::ReopeningUnsupported => formatter.write_str(+ "reopening the GPUI web top-level window after it closes is not supported",+ ),+ Self::UnsupportedWindowKind(kind) => write!(+ formatter,+ "GPUI web does not support {kind} as a separate top-level window; render it inside the normal window instead"+ ),+ Self::GraphicsInitializationPending => formatter.write_str(+ "browser graphics initialization has not completed yet; open windows from the callback passed to Platform::run",+ ),+ Self::GraphicsUnavailable => formatter.write_str(+ "browser graphics are unavailable because graphics initialization or an earlier window creation failed",+ ),+ }+ }+}++impl std::error::Error for WebWindowError {}+#[derive(Default)]struct WebPlatformCallbacks {open_urls: Option<Box<dyn FnMut(Vec<String>)>>,@@ -62,6 +116,13 @@ struct WebPlatformCallbacks {impl WebPlatform {pub fn new(allow_multi_threading: bool) -> Self {+ Self::new_with_backend(allow_multi_threading, WebBackendPreference::Auto)+ }++ pub fn new_with_backend(+ allow_multi_threading: bool,+ backend_preference: WebBackendPreference,+ ) -> Self {let browser_window =web_sys::window().expect("must be running in a browser window context");let dispatcher = Arc::new(WebDispatcher::new(@@ -98,10 +159,13 @@ impl WebPlatform {background_executor,foreground_executor,text_system,- active_window: RefCell::new(None),+ active_window: Rc::new(RefCell::new(None)),active_display,callbacks: RefCell::new(WebPlatformCallbacks::default()),+ backend_preference,wgpu_context: Rc::new(RefCell::new(None)),+ prepared_window: Rc::new(RefCell::new(None)),+ window_lifecycle: Rc::new(Cell::new(WebWindowLifecycle::Available)),cursor_visible,last_cursor_css,_cursor_restore_listeners: cursor_restore_listeners,@@ -122,6 +186,83 @@ impl WebPlatform {}}+async fn initialize_graphics(+ browser_window: &web_sys::Window,+ preference: WebBackendPreference,+) -> anyhow::Result<(+ web_sys::HtmlCanvasElement,+ WgpuContext,+ wgpu::Surface<'static>,+)> {+ match preference {+ WebBackendPreference::Auto => {+ let webgpu_canvas = WebWindow::prepare_canvas(browser_window)?;+ let webgpu_result = if wgpu::util::is_browser_webgpu_supported().await {+ WgpuContext::new_web(&webgpu_canvas, WebBackendPreference::WebGpu).await+ } else {+ Err(anyhow::anyhow!(+ "browser WebGPU probe did not return a usable adapter"+ ))+ };+ match webgpu_result {+ Ok(PreparedWebGraphics { context, surface }) => {+ return Ok((webgpu_canvas, context, surface));+ }+ Err(webgpu_error) => {+ let canvas: &web_sys::Element = webgpu_canvas.as_ref();+ canvas.remove();+ log::warn!(+ "WebGPU initialization failed; falling back to WebGL2: {webgpu_error:#}"+ );++ let webgl_canvas =+ WebWindow::prepare_canvas(browser_window).map_err(|error| {+ anyhow::anyhow!(+ "WebGPU initialization failed: {webgpu_error:#}. \+ Failed to prepare a replacement canvas for WebGL2: {error:#}"+ )+ })?;+ match WgpuContext::new_web(&webgl_canvas, WebBackendPreference::WebGl).await {+ Ok(PreparedWebGraphics { context, surface }) => {+ Ok((webgl_canvas, context, surface))+ }+ Err(webgl_error) => {+ let canvas: &web_sys::Element = webgl_canvas.as_ref();+ canvas.remove();+ Err(anyhow::anyhow!(+ "No browser graphics backend could be initialized. \+ Tried WebGPU, then WebGL2. \+ WebGPU failure: {webgpu_error:#}. \+ WebGL2 failure: {webgl_error:#}"+ ))+ }+ }+ }+ }+ }+ WebBackendPreference::WebGpu | WebBackendPreference::WebGl => {+ let backend_name = if preference == WebBackendPreference::WebGpu {+ "WebGPU"+ } else {+ "WebGL2"+ };+ let canvas = WebWindow::prepare_canvas(browser_window)?;+ match WgpuContext::new_web(&canvas, preference).await {+ Ok(PreparedWebGraphics { context, surface }) => Ok((canvas, context, surface)),+ Err(error) => {+ let canvas: &web_sys::Element = canvas.as_ref();+ canvas.remove();+ Err(anyhow::anyhow!(+ "No browser graphics backend could be initialized. \+ Only {backend_name} was tried because the application requested \+ it explicitly. {backend_name} failure: {error:#}"+ ))+ }+ }+ }+ }+}+impl Platform for WebPlatform {fn background_executor(&self) -> BackgroundExecutor {self.background_executor.clone()@@ -137,20 +278,25 @@ impl Platform for WebPlatform {fn run(&self, on_finish_launching: Box<dyn 'static + FnOnce()>) {let wgpu_context = self.wgpu_context.clone();+ let prepared_window = self.prepared_window.clone();+ let window_lifecycle = self.window_lifecycle.clone();let browser_window = self.browser_window.clone();+ let backend_preference = self.backend_preference;wasm_bindgen_futures::spawn_local(async move {- match WgpuContext::new_web().await {- Ok(context) => {- log::info!("WebGPU context initialized successfully");+ match initialize_graphics(&browser_window, backend_preference).await {+ Ok((canvas, context, surface)) => {+ log::info!(+ "Browser graphics initialized successfully with {:?}",+ context.backend()+ );*wgpu_context.borrow_mut() = Some(context);+ *prepared_window.borrow_mut() = Some(PreparedWebWindow { canvas, surface });on_finish_launching();}- Err(err) => {- // Without a GPU context nothing can ever render, so- // launching the app would only produce confusing- // downstream errors. Leave a message in the page instead.- log::error!("Failed to initialize WebGPU context: {err:#}");- show_webgpu_unavailable_message(&browser_window);+ Err(error) => {+ window_lifecycle.set(WebWindowLifecycle::Unavailable);+ log::error!("Failed to initialize browser graphics: {error:#}");+ show_graphics_unavailable_message(&browser_window, &error);}}});@@ -187,20 +333,66 @@ impl Platform for WebPlatform {handle: AnyWindowHandle,params: WindowParams,) -> anyhow::Result<Box<dyn PlatformWindow>> {- // Native popups are not implemented on the web yet. Rejecting lets callers fall back to- // gpui's in-window popovers.- if let WindowKind::AnchoredPopup(_) = params.kind {- return Err(PopupNotSupportedError.into());+ match ¶ms.kind {+ WindowKind::Normal => {}+ WindowKind::AnchoredPopup(_) => return Err(PopupNotSupportedError.into()),+ WindowKind::PopUp => {+ return Err(WebWindowError::UnsupportedWindowKind("popup windows").into());+ }+ WindowKind::Floating => {+ return Err(WebWindowError::UnsupportedWindowKind("floating windows").into());+ }+ WindowKind::Dialog => {+ return Err(WebWindowError::UnsupportedWindowKind("dialog windows").into());+ }}- let context_ref = self.wgpu_context.borrow();- let context = context_ref.as_ref().ok_or_else(|| {- anyhow::anyhow!("WebGPU context not initialized. Was Platform::run() called?")- })?;+ match self.window_lifecycle.get() {+ WebWindowLifecycle::Open => return Err(WebWindowError::AlreadyOpen.into()),+ WebWindowLifecycle::Closed => {+ return Err(WebWindowError::ReopeningUnsupported.into());+ }+ WebWindowLifecycle::Unavailable => {+ return Err(WebWindowError::GraphicsUnavailable.into());+ }+ WebWindowLifecycle::Available => {}+ }- let window = WebWindow::new(handle, params, context, self.browser_window.clone())?;- *self.active_window.borrow_mut() = Some(handle);- Ok(Box::new(window))+ let context_ref = self.wgpu_context.borrow();+ let context = context_ref+ .as_ref()+ .ok_or(WebWindowError::GraphicsInitializationPending)?;+ let prepared_window = self+ .prepared_window+ .borrow_mut()+ .take()+ .ok_or(WebWindowError::GraphicsInitializationPending)?;+ let canvas = prepared_window.canvas;+ let canvas_for_cleanup = canvas.clone();++ let window = WebWindow::new(+ handle,+ params,+ context,+ canvas,+ prepared_window.surface,+ self.browser_window.clone(),+ self.window_lifecycle.clone(),+ self.active_window.clone(),+ );+ match window {+ Ok(window) => {+ self.window_lifecycle.set(WebWindowLifecycle::Open);+ *self.active_window.borrow_mut() = Some(handle);+ Ok(Box::new(window))+ }+ Err(error) => {+ let canvas: &web_sys::Element = canvas_for_cleanup.as_ref();+ canvas.remove();+ self.window_lifecycle.set(WebWindowLifecycle::Unavailable);+ Err(error)+ }+ }}fn window_appearance(&self) -> WindowAppearance {@@ -438,7 +630,7 @@ fn cursor_restore_listeners(handles}-fn show_webgpu_unavailable_message(browser_window: &web_sys::Window) {+fn show_graphics_unavailable_message(browser_window: &web_sys::Window, error: &anyhow::Error) {let Some(document) = browser_window.document() else {return;};@@ -448,9 +640,9 @@ fn show_webgpu_unavailable_message(browser_window: &web_sys::Window) {let Ok(message) = document.create_element("p") else {return;};- message.set_text_content(Some(- "Failed to initialize WebGPU. This application requires a browser with WebGPU support.",- ));+ message.set_text_content(Some(&format!(+ "Failed to initialize browser graphics: {error}"+ )));body.append_child(&message).ok();}diff --git a/crates/gpui_web/src/window.rs b/crates/gpui_web/src/window.rsindex 3dbf013a6fd..484014681b7 100644--- a/crates/gpui_web/src/window.rs+++ b/crates/gpui_web/src/window.rs@@ -1,5 +1,6 @@use crate::display::WebDisplay;use crate::events::{ClickState, EventListenerHandle, WebEventListeners, is_mac_platform};+use crate::platform::WebWindowLifecycle;use std::sync::Arc;use std::{cell::Cell, cell::RefCell, rc::Rc};@@ -10,7 +11,7 @@ use gpui::{ResizeEdge, Scene, Size, WindowAppearance, WindowBackgroundAppearance, WindowBounds,WindowControlArea, WindowControls, WindowDecorations, WindowParams, px,};-use gpui_wgpu::{WgpuContext, WgpuRenderer, WgpuSurfaceConfig};+use gpui_wgpu::{WgpuContext, WgpuRenderer, WgpuSurfaceConfig, wgpu};use wasm_bindgen::prelude::*;#[derive(Default)]@@ -63,6 +64,8 @@ pub(crate) struct WebWindowInner {pub struct WebWindow {inner: Rc<WebWindowInner>,display: Rc<dyn PlatformDisplay>,+ lifecycle: Rc<Cell<WebWindowLifecycle>>,+ active_window: Rc<RefCell<Option<AnyWindowHandle>>>,_raf_closure: Closure<dyn FnMut()>,_resize_observer: Option<web_sys::ResizeObserver>,_resize_observer_closure: Closure<dyn FnMut(js_sys::Array)>,@@ -70,50 +73,69 @@ pub struct WebWindow {}impl WebWindow {- pub fn new(- _handle: AnyWindowHandle,- _params: WindowParams,- context: &WgpuContext,- browser_window: web_sys::Window,- ) -> anyhow::Result<Self> {+ pub(crate) fn prepare_canvas(+ browser_window: &web_sys::Window,+ ) -> anyhow::Result<web_sys::HtmlCanvasElement> {let document = browser_window.document().ok_or_else(|| anyhow::anyhow!("No `document` found on window"))?;-let canvas: web_sys::HtmlCanvasElement = document.create_element("canvas")- .map_err(|e| anyhow::anyhow!("Failed to create canvas element: {e:?}"))?+ .map_err(|error| anyhow::anyhow!("Failed to create canvas element: {error:?}"))?.dyn_into()- .map_err(|e| anyhow::anyhow!("Created element is not a canvas: {e:?}"))?;-- let dpr = browser_window.device_pixel_ratio() as f32;- let max_texture_dimension = context.device.limits().max_texture_dimension_2d;- let has_device_pixel_support = check_device_pixel_support();-+ .map_err(|error| anyhow::anyhow!("Created element is not a canvas: {error:?}"))?;canvas.set_tab_index(-1);let style = canvas.style();- style- .set_property("width", "100%")- .map_err(|e| anyhow::anyhow!("Failed to set canvas width style: {e:?}"))?;- style- .set_property("height", "100%")- .map_err(|e| anyhow::anyhow!("Failed to set canvas height style: {e:?}"))?;- style- .set_property("display", "block")- .map_err(|e| anyhow::anyhow!("Failed to set canvas display style: {e:?}"))?;- style- .set_property("outline", "none")- .map_err(|e| anyhow::anyhow!("Failed to set canvas outline style: {e:?}"))?;- style- .set_property("touch-action", "none")- .map_err(|e| anyhow::anyhow!("Failed to set touch-action style: {e:?}"))?;+ for (property, value) in [+ ("width", "100%"),+ ("height", "100%"),+ ("display", "block"),+ ("outline", "none"),+ ("touch-action", "none"),+ ] {+ style.set_property(property, value).map_err(|error| {+ anyhow::anyhow!("Failed to set canvas {property} style: {error:?}")+ })?;+ }let body = document.body().ok_or_else(|| anyhow::anyhow!("No `body` found on document"))?;body.append_child(&canvas)- .map_err(|e| anyhow::anyhow!("Failed to append canvas to body: {e:?}"))?;+ .map_err(|error| anyhow::anyhow!("Failed to append canvas to body: {error:?}"))?;+ Ok(canvas)+ }++ #[allow(clippy::too_many_arguments)]+ pub(crate) fn new(+ _handle: AnyWindowHandle,+ _params: WindowParams,+ context: &WgpuContext,+ canvas: web_sys::HtmlCanvasElement,+ surface: wgpu::Surface<'static>,+ browser_window: web_sys::Window,+ lifecycle: Rc<Cell<WebWindowLifecycle>>,+ active_window: Rc<RefCell<Option<AnyWindowHandle>>>,+ ) -> anyhow::Result<Self> {+ let document = browser_window+ .document()+ .ok_or_else(|| anyhow::anyhow!("No `document` found on window"))?;+ let body = document+ .body()+ .ok_or_else(|| anyhow::anyhow!("No `body` found on document"))?;+ let dpr = browser_window.device_pixel_ratio() as f32;+ let max_texture_dimension = context.device.limits().max_texture_dimension_2d;+ let has_device_pixel_support = check_device_pixel_support();+ let renderer_config = WgpuSurfaceConfig {+ size: Size {+ width: DevicePixels(0),+ height: DevicePixels(0),+ },+ transparent: false,+ preferred_present_mode: None,+ };+ let renderer = WgpuRenderer::new_from_surface(context, surface, renderer_config)?;let input_element: web_sys::HtmlInputElement = document.create_element("input")@@ -131,19 +153,6 @@ impl WebWindow {.map_err(|e| anyhow::anyhow!("Failed to append input to body: {e:?}"))?;input_element.focus().ok();- let device_size = Size {- width: DevicePixels(0),- height: DevicePixels(0),- };-- let renderer_config = WgpuSurfaceConfig {- size: device_size,- transparent: false,- preferred_present_mode: None,- };-- let renderer = WgpuRenderer::new_from_canvas(context, &canvas, renderer_config)?;-let display: Rc<dyn PlatformDisplay> = Rc::new(WebDisplay::new(browser_window.clone()));let initial_bounds = Bounds {@@ -203,6 +212,8 @@ impl WebWindow {Ok(Self {inner,display,+ lifecycle,+ active_window,_raf_closure: raf_closure,_resize_observer: resize_observer,_resize_observer_closure: resize_observer_closure,@@ -515,6 +526,8 @@ impl Drop for WebWindow {canvas.remove();let input_element: &web_sys::Element = self.inner.input_element.as_ref();input_element.remove();+ self.active_window.borrow_mut().take();+ self.lifecycle.set(WebWindowLifecycle::Closed);}}diff --git a/crates/gpui_wgpu/Cargo.toml b/crates/gpui_wgpu/Cargo.tomlindex 03aea7f7d25..280c64ddf8f 100644--- a/crates/gpui_wgpu/Cargo.toml+++ b/crates/gpui_wgpu/Cargo.toml@@ -46,9 +46,11 @@ wasm-bindgen.workspace = truewasm-bindgen-futures.workspace = trueweb-sys = { version = "0.3", features = ["HtmlCanvasElement"] }js-sys.workspace = true+wgpu = { workspace = true, features = ["webgl"] }[dev-dependencies]criterion.workspace = true+naga = { version = "29.0.4", features = ["wgsl-in"] }[[bench]]name = "layout_line"diff --git a/crates/gpui_wgpu/src/shaders.wgsl b/crates/gpui_wgpu/src/shaders.wgslindex c009ed98074..718cb7595d8 100644--- a/crates/gpui_wgpu/src/shaders.wgsl+++ b/crates/gpui_wgpu/src/shaders.wgsl@@ -526,7 +526,6 @@ struct Quad {corner_radii: Corners,border_widths: Edges,}-@group(1) @binding(0) var<storage, read> b_quads: array<Quad>;struct QuadVarying {@builtin(position) position: vec4<f32>,@@ -542,7 +541,7 @@ struct QuadVarying {@vertexfn vs_quad(@builtin(vertex_index) vertex_id: u32, @builtin(instance_index) instance_id: u32) -> QuadVarying {let unit_vertex = vec2<f32>(f32(vertex_id & 1u), 0.5 * f32(vertex_id & 2u));- let quad = b_quads[instance_id];+ let quad = load_quad(instance_id);var out = QuadVarying();out.position = to_device_position(unit_vertex, quad.bounds);@@ -569,7 +568,7 @@ fn fs_quad(input: QuadVarying) -> @location(0) vec4<f32> {return vec4<f32>(0.0);}- let quad = b_quads[input.quad_id];+ let quad = load_quad(input.quad_id);let background_color = gradient_color(quad.background, input.position.xy, quad.bounds,input.background_solid, input.background_color0, input.background_color1);@@ -964,7 +963,6 @@ struct Shadow {inset: u32,pad: u32, // align to 8 bytes}-@group(1) @binding(0) var<storage, read> b_shadows: array<Shadow>;struct ShadowVarying {@builtin(position) position: vec4<f32>,@@ -977,7 +975,7 @@ struct ShadowVarying {@vertexfn vs_shadow(@builtin(vertex_index) vertex_id: u32, @builtin(instance_index) instance_id: u32) -> ShadowVarying {let unit_vertex = vec2<f32>(f32(vertex_id & 1u), 0.5 * f32(vertex_id & 2u));- var shadow = b_shadows[instance_id];+ var shadow = load_shadow(instance_id);var geometry: Bounds;if (shadow.inset != 0u) {@@ -1005,7 +1003,7 @@ fn fs_shadow(input: ShadowVarying) -> @location(0) vec4<f32> {return vec4<f32>(0.0);}- let shadow = b_shadows[input.shadow_id];+ let shadow = load_shadow(input.shadow_id);let half_size = shadow.bounds.size / 2.0;let center = shadow.bounds.origin + half_size;let center_to_point = input.position.xy - center;@@ -1056,7 +1054,7 @@ struct PathRasterizationVertex {bounds: Bounds,}-@group(1) @binding(0) var<storage, read> b_path_vertices: array<PathRasterizationVertex>;+struct PathRasterizationVarying {@builtin(position) position: vec4<f32>,@@ -1068,7 +1066,7 @@ struct PathRasterizationVarying {@vertexfn vs_path_rasterization(@builtin(vertex_index) vertex_id: u32) -> PathRasterizationVarying {- let v = b_path_vertices[vertex_id];+ let v = load_path_vertex(vertex_id);var out = PathRasterizationVarying();out.position = to_device_position_impl(v.xy_position);@@ -1086,7 +1084,7 @@ fn fs_path_rasterization(input: PathRasterizationVarying) -> @location(0) vec4<freturn vec4<f32>(0.0);}- let v = b_path_vertices[input.vertex_id];+ let v = load_path_vertex(input.vertex_id);let background = v.color;let bounds = v.bounds;@@ -1116,7 +1114,7 @@ fn fs_path_rasterization(input: PathRasterizationVarying) -> @location(0) vec4<fstruct PathSprite {bounds: Bounds,}-@group(1) @binding(0) var<storage, read> b_path_sprites: array<PathSprite>;+struct PathVarying {@builtin(position) position: vec4<f32>,@@ -1126,7 +1124,7 @@ struct PathVarying {@vertexfn vs_path(@builtin(vertex_index) vertex_id: u32, @builtin(instance_index) instance_id: u32) -> PathVarying {let unit_vertex = vec2<f32>(f32(vertex_id & 1u), 0.5 * f32(vertex_id & 2u));- let sprite = b_path_sprites[instance_id];+ let sprite = load_path_sprite(instance_id);// Don't apply content mask because it was already accounted for when rasterizing the path.let device_position = to_device_position(unit_vertex, sprite.bounds);// For screen-space intermediate texture, convert screen position to texture coordinates@@ -1157,7 +1155,7 @@ struct Underline {thickness: f32,wavy: u32,}-@group(1) @binding(0) var<storage, read> b_underlines: array<Underline>;+struct UnderlineVarying {@builtin(position) position: vec4<f32>,@@ -1170,7 +1168,7 @@ struct UnderlineVarying {@vertexfn vs_underline(@builtin(vertex_index) vertex_id: u32, @builtin(instance_index) instance_id: u32) -> UnderlineVarying {let unit_vertex = vec2<f32>(f32(vertex_id & 1u), 0.5 * f32(vertex_id & 2u));- let underline = b_underlines[instance_id];+ let underline = load_underline(instance_id);var out = UnderlineVarying();out.position = to_device_position(unit_vertex, underline.bounds);@@ -1190,7 +1188,7 @@ fn fs_underline(input: UnderlineVarying) -> @location(0) vec4<f32> {return vec4<f32>(0.0);}- let underline = b_underlines[input.underline_id];+ let underline = load_underline(input.underline_id);if (underline.wavy == 0u){return blend_color(input.color, input.color.a);@@ -1223,7 +1221,7 @@ struct MonochromeSprite {tile: AtlasTile,transformation: TransformationMatrix,}-@group(1) @binding(0) var<storage, read> b_mono_sprites: array<MonochromeSprite>;+struct MonoSpriteVarying {@builtin(position) position: vec4<f32>,@@ -1235,7 +1233,7 @@ struct MonoSpriteVarying {@vertexfn vs_mono_sprite(@builtin(vertex_index) vertex_id: u32, @builtin(instance_index) instance_id: u32) -> MonoSpriteVarying {let unit_vertex = vec2<f32>(f32(vertex_id & 1u), 0.5 * f32(vertex_id & 2u));- let sprite = b_mono_sprites[instance_id];+ let sprite = load_mono_sprite(instance_id);var out = MonoSpriteVarying();out.position = to_device_position_transformed(unit_vertex, sprite.bounds, sprite.transformation);@@ -1271,7 +1269,7 @@ struct PolychromeSprite {corner_radii: Corners,tile: AtlasTile,}-@group(1) @binding(0) var<storage, read> b_poly_sprites: array<PolychromeSprite>;+struct PolySpriteVarying {@builtin(position) position: vec4<f32>,@@ -1283,7 +1281,7 @@ struct PolySpriteVarying {@vertexfn vs_poly_sprite(@builtin(vertex_index) vertex_id: u32, @builtin(instance_index) instance_id: u32) -> PolySpriteVarying {let unit_vertex = vec2<f32>(f32(vertex_id & 1u), 0.5 * f32(vertex_id & 2u));- let sprite = b_poly_sprites[instance_id];+ let sprite = load_poly_sprite(instance_id);var out = PolySpriteVarying();out.position = to_device_position(unit_vertex, sprite.bounds);@@ -1301,7 +1299,7 @@ fn fs_poly_sprite(input: PolySpriteVarying) -> @location(0) vec4<f32> {return vec4<f32>(0.0);}- let sprite = b_poly_sprites[input.sprite_id];+ let sprite = load_poly_sprite(input.sprite_id);let distance = quad_sdf(input.position.xy, sprite.bounds, sprite.corner_radii);var color = sample;diff --git a/crates/gpui_wgpu/src/shaders_storage.wgsl b/crates/gpui_wgpu/src/shaders_storage.wgslnew file mode 100644index 00000000000..55b80802e6c--- /dev/null+++ b/crates/gpui_wgpu/src/shaders_storage.wgsl@@ -0,0 +1,42 @@+// Storage-buffer instance transport. Concatenated after `shaders.wgsl` on backends+// with storage buffer support; `shaders_webgl.wgsl` is the WebGL2 counterpart that+// decodes the same records from a texture instead.+//+// All buffers share `@group(1) @binding(0)` because each pipeline binds only the+// buffer its own entry points read.++@group(1) @binding(0) var<storage, read> b_quads: array<Quad>;+@group(1) @binding(0) var<storage, read> b_shadows: array<Shadow>;+@group(1) @binding(0) var<storage, read> b_path_vertices: array<PathRasterizationVertex>;+@group(1) @binding(0) var<storage, read> b_path_sprites: array<PathSprite>;+@group(1) @binding(0) var<storage, read> b_underlines: array<Underline>;+@group(1) @binding(0) var<storage, read> b_mono_sprites: array<MonochromeSprite>;+@group(1) @binding(0) var<storage, read> b_poly_sprites: array<PolychromeSprite>;++fn load_quad(instance_id: u32) -> Quad {+ return b_quads[instance_id];+}++fn load_shadow(instance_id: u32) -> Shadow {+ return b_shadows[instance_id];+}++fn load_path_vertex(vertex_id: u32) -> PathRasterizationVertex {+ return b_path_vertices[vertex_id];+}++fn load_path_sprite(instance_id: u32) -> PathSprite {+ return b_path_sprites[instance_id];+}++fn load_underline(instance_id: u32) -> Underline {+ return b_underlines[instance_id];+}++fn load_mono_sprite(instance_id: u32) -> MonochromeSprite {+ return b_mono_sprites[instance_id];+}++fn load_poly_sprite(instance_id: u32) -> PolychromeSprite {+ return b_poly_sprites[instance_id];+}diff --git a/crates/gpui_wgpu/src/shaders_webgl.wgsl b/crates/gpui_wgpu/src/shaders_webgl.wgslnew file mode 100644index 00000000000..0c9c217a69d--- /dev/null+++ b/crates/gpui_wgpu/src/shaders_webgl.wgsl@@ -0,0 +1,221 @@+@group(1) @binding(0) var t_instances: texture_2d<u32>;++// Each texel of `t_instances` packs four 32-bit words of instance data. Records+// are read strictly front to back, so all readers share a cursor that keeps the+// most recently fetched texel and only touches the texture again when the next+// word crosses a texel boundary. This fetches each texel exactly once per+// record load instead of once per word. The `read_*` functions must therefore+// consume their words in struct declaration order; skipping or re-reading words+// would still return correct data (the cursor re-fetches whenever the texel+// index changes) but would forfeit the single-fetch-per-texel guarantee.+struct InstanceCursor {+ word_index: u32,+ texel_index: u32,+ texel: vec4<u32>,+ width: u32,+}++fn fetch_instance_texel(texel_index: u32, width: u32) -> vec4<u32> {+ let coordinate = vec2<i32>(+ i32(texel_index % width),+ i32(texel_index / width),+ );+ return textureLoad(t_instances, coordinate, 0);+}++fn instance_cursor(word_index: u32) -> InstanceCursor {+ let width = textureDimensions(t_instances).x;+ let texel_index = word_index / 4u;+ return InstanceCursor(+ word_index,+ texel_index,+ fetch_instance_texel(texel_index, width),+ width,+ );+}++fn read_word(cursor: ptr<function, InstanceCursor>) -> u32 {+ let word_index = (*cursor).word_index;+ let texel_index = word_index / 4u;+ if texel_index != (*cursor).texel_index {+ (*cursor).texel = fetch_instance_texel(texel_index, (*cursor).width);+ (*cursor).texel_index = texel_index;+ }+ (*cursor).word_index = word_index + 1u;+ return (*cursor).texel[word_index % 4u];+}++fn read_f32(cursor: ptr<function, InstanceCursor>) -> f32 {+ return bitcast<f32>(read_word(cursor));+}++fn read_i32(cursor: ptr<function, InstanceCursor>) -> i32 {+ return bitcast<i32>(read_word(cursor));+}++fn read_vec2_f32(cursor: ptr<function, InstanceCursor>) -> vec2<f32> {+ return vec2<f32>(read_f32(cursor), read_f32(cursor));+}++fn read_vec2_i32(cursor: ptr<function, InstanceCursor>) -> vec2<i32> {+ return vec2<i32>(read_i32(cursor), read_i32(cursor));+}++fn read_hsla(cursor: ptr<function, InstanceCursor>) -> Hsla {+ return Hsla(+ read_f32(cursor),+ read_f32(cursor),+ read_f32(cursor),+ read_f32(cursor),+ );+}++fn read_bounds(cursor: ptr<function, InstanceCursor>) -> Bounds {+ return Bounds(read_vec2_f32(cursor), read_vec2_f32(cursor));+}++fn read_corners(cursor: ptr<function, InstanceCursor>) -> Corners {+ return Corners(+ read_f32(cursor),+ read_f32(cursor),+ read_f32(cursor),+ read_f32(cursor),+ );+}++fn read_edges(cursor: ptr<function, InstanceCursor>) -> Edges {+ return Edges(+ read_f32(cursor),+ read_f32(cursor),+ read_f32(cursor),+ read_f32(cursor),+ );+}++fn read_color_stop(cursor: ptr<function, InstanceCursor>) -> LinearColorStop {+ return LinearColorStop(read_hsla(cursor), read_f32(cursor));+}++fn read_background(cursor: ptr<function, InstanceCursor>) -> Background {+ return Background(+ read_word(cursor),+ read_word(cursor),+ read_hsla(cursor),+ read_f32(cursor),+ array<LinearColorStop, 2>(+ read_color_stop(cursor),+ read_color_stop(cursor),+ ),+ read_word(cursor),+ );+}++fn read_atlas_tile(cursor: ptr<function, InstanceCursor>) -> AtlasTile {+ return AtlasTile(+ AtlasTextureId(+ read_word(cursor),+ read_word(cursor),+ ),+ read_word(cursor),+ read_word(cursor),+ AtlasBounds(+ read_vec2_i32(cursor),+ read_vec2_i32(cursor),+ ),+ );+}++fn read_transformation(cursor: ptr<function, InstanceCursor>) -> TransformationMatrix {+ return TransformationMatrix(+ mat2x2<f32>(+ read_vec2_f32(cursor),+ read_vec2_f32(cursor),+ ),+ read_vec2_f32(cursor),+ );+}++fn load_quad(instance_id: u32) -> Quad {+ var cursor = instance_cursor(instance_id * 40u);+ return Quad(+ read_word(&cursor),+ read_word(&cursor),+ read_bounds(&cursor),+ read_bounds(&cursor),+ read_background(&cursor),+ read_hsla(&cursor),+ read_corners(&cursor),+ read_edges(&cursor),+ );+}++fn load_shadow(instance_id: u32) -> Shadow {+ var cursor = instance_cursor(instance_id * 28u);+ return Shadow(+ read_word(&cursor),+ read_f32(&cursor),+ read_bounds(&cursor),+ read_corners(&cursor),+ read_bounds(&cursor),+ read_hsla(&cursor),+ read_bounds(&cursor),+ read_corners(&cursor),+ read_word(&cursor),+ read_word(&cursor),+ );+}++fn load_path_vertex(vertex_id: u32) -> PathRasterizationVertex {+ var cursor = instance_cursor(vertex_id * 26u);+ return PathRasterizationVertex(+ read_vec2_f32(&cursor),+ read_vec2_f32(&cursor),+ read_background(&cursor),+ read_bounds(&cursor),+ );+}++fn load_path_sprite(instance_id: u32) -> PathSprite {+ var cursor = instance_cursor(instance_id * 4u);+ return PathSprite(read_bounds(&cursor));+}++fn load_underline(instance_id: u32) -> Underline {+ var cursor = instance_cursor(instance_id * 16u);+ return Underline(+ read_word(&cursor),+ read_word(&cursor),+ read_bounds(&cursor),+ read_bounds(&cursor),+ read_hsla(&cursor),+ read_f32(&cursor),+ read_word(&cursor),+ );+}++fn load_mono_sprite(instance_id: u32) -> MonochromeSprite {+ var cursor = instance_cursor(instance_id * 28u);+ return MonochromeSprite(+ read_word(&cursor),+ read_word(&cursor),+ read_bounds(&cursor),+ read_bounds(&cursor),+ read_hsla(&cursor),+ read_atlas_tile(&cursor),+ read_transformation(&cursor),+ );+}++fn load_poly_sprite(instance_id: u32) -> PolychromeSprite {+ var cursor = instance_cursor(instance_id * 24u);+ return PolychromeSprite(+ read_word(&cursor),+ read_word(&cursor),+ read_word(&cursor),+ read_f32(&cursor),+ read_bounds(&cursor),+ read_bounds(&cursor),+ read_corners(&cursor),+ read_atlas_tile(&cursor),+ );+}diff --git a/crates/gpui_wgpu/src/wgpu_context.rs b/crates/gpui_wgpu/src/wgpu_context.rsindex 9dd55993934..7e744e80d6c 100644--- a/crates/gpui_wgpu/src/wgpu_context.rs+++ b/crates/gpui_wgpu/src/wgpu_context.rs@@ -11,11 +11,51 @@ pub struct WgpuContext {pub adapter: wgpu::Adapter,pub device: Arc<wgpu::Device>,pub queue: Arc<wgpu::Queue>,+ backend: WgpuBackend,dual_source_blending: bool,color_texture_format: wgpu::TextureFormat,device_lost: Arc<AtomicBool>,}+#[derive(Clone, Copy, Debug, Eq, PartialEq)]+pub enum WgpuBackend {+ BrowserWebGpu,+ Gl,+ Native(wgpu::Backend),+}++#[cfg(target_family = "wasm")]+#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]+pub enum WebBackendPreference {+ #[default]+ Auto,+ WebGpu,+ WebGl,+}++#[cfg(target_family = "wasm")]+pub struct PreparedWebGraphics {+ pub context: WgpuContext,+ pub surface: wgpu::Surface<'static>,+}++/// wgpu-core refuses to create a surface when neither the instance nor the surface+/// target carries a display handle, and `SurfaceTarget::Canvas` always passes `None`.+/// The WebGL2 backend never reads the handle (WebGPU bypasses wgpu-core entirely), so+/// a unit web display handle on the instance satisfies the check.+#[cfg(target_family = "wasm")]+#[derive(Debug)]+struct WebDisplaySource;++#[cfg(target_family = "wasm")]+impl raw_window_handle::HasDisplayHandle for WebDisplaySource {+ fn display_handle(+ &self,+ ) -> Result<raw_window_handle::DisplayHandle<'_>, raw_window_handle::HandleError> {+ Ok(raw_window_handle::DisplayHandle::web())+ }+}+#[derive(Clone, Copy)]pub struct CompositorGpuHint {pub vendor_id: u32,@@ -88,11 +128,13 @@ impl WgpuContext {adapter.get_info().backend);+ let backend = WgpuBackend::Native(adapter.get_info().backend);Ok(Self {instance,adapter,device: Arc::new(device),queue: Arc::new(queue),+ backend,dual_source_blending,color_texture_format,device_lost,@@ -100,43 +142,95 @@ impl WgpuContext {}#[cfg(target_family = "wasm")]- pub async fn new_web() -> anyhow::Result<Self> {- let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {- backends: wgpu::Backends::BROWSER_WEBGPU | wgpu::Backends::GL,+ pub async fn new_web(+ canvas: &web_sys::HtmlCanvasElement,+ preference: WebBackendPreference,+ ) -> anyhow::Result<PreparedWebGraphics> {+ Self::new_web_with_backend(canvas, preference).await+ }++ #[cfg(target_family = "wasm")]+ #[allow(clippy::arc_with_non_send_sync)]+ async fn new_web_with_backend(+ canvas: &web_sys::HtmlCanvasElement,+ preference: WebBackendPreference,+ ) -> anyhow::Result<PreparedWebGraphics> {+ let backends = match preference {+ WebBackendPreference::Auto => wgpu::Backends::BROWSER_WEBGPU | wgpu::Backends::GL,+ WebBackendPreference::WebGpu => wgpu::Backends::BROWSER_WEBGPU,+ WebBackendPreference::WebGl => wgpu::Backends::GL,+ };+ let descriptor = wgpu::InstanceDescriptor {+ backends,flags: wgpu::InstanceFlags::default(),backend_options: wgpu::BackendOptions::default(),memory_budget_thresholds: wgpu::MemoryBudgetThresholds::default(),- display: None,- });+ display: Some(Box::new(WebDisplaySource)),+ };+ let instance = if preference == WebBackendPreference::Auto {+ wgpu::util::new_instance_with_webgpu_detection(descriptor).await+ } else {+ wgpu::Instance::new(descriptor)+ };+ let surface = instance+ .create_surface(wgpu::SurfaceTarget::Canvas(canvas.clone()))+ .map_err(|error| {+ anyhow::anyhow!("Failed to create browser graphics surface: {error}")+ })?;let adapter = instance.request_adapter(&wgpu::RequestAdapterOptions {power_preference: wgpu::PowerPreference::HighPerformance,- compatible_surface: None,+ compatible_surface: Some(&surface),force_fallback_adapter: false,}).await- .map_err(|e| anyhow::anyhow!("Failed to request GPU adapter: {e}"))?;-- log::info!(- "Selected GPU adapter: {:?} ({:?})",- adapter.get_info().name,- adapter.get_info().backend- );+ .map_err(|error| {+ anyhow::anyhow!(+ "Failed to request a {preference:?} adapter compatible with the canvas: {error}"+ )+ })?;+ let adapter_info = adapter.get_info();+ let backend = match adapter_info.backend {+ wgpu::Backend::BrowserWebGpu => WgpuBackend::BrowserWebGpu,+ wgpu::Backend::Gl => WgpuBackend::Gl,+ backend => {+ anyhow::bail!(+ "Browser graphics initialization selected unexpected backend {backend:?}"+ )+ }+ };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);+ }+ }+ });+ log::info!(+ "Browser graphics initialized: requested={preference:?}, selected={backend:?}, \+ adapter={:?}, limits={:?}, dual_source_blending={dual_source_blending}",+ adapter_info.name,+ device.limits(),+ );- Ok(Self {+ let context = Self {instance,adapter,device: Arc::new(device),queue: Arc::new(queue),+ backend,dual_source_blending,color_texture_format,device_lost,- })+ };+ Ok(PreparedWebGraphics { context, surface })}async fn create_device(@@ -157,14 +251,26 @@ impl WgpuContext {}let color_atlas_texture_format = Self::select_color_texture_format(adapter)?;+ #[cfg(target_family = "wasm")]+ let required_limits = if adapter.get_info().backend == wgpu::Backend::Gl {+ wgpu::Limits::downlevel_webgl2_defaults()+ .using_resolution(adapter.limits())+ .using_alignment(adapter.limits())+ } else {+ wgpu::Limits::downlevel_defaults()+ .using_resolution(adapter.limits())+ .using_alignment(adapter.limits())+ };+ #[cfg(not(target_family = "wasm"))]+ let required_limits = wgpu::Limits::downlevel_defaults()+ .using_resolution(adapter.limits())+ .using_alignment(adapter.limits());let (device, queue) = adapter.request_device(&wgpu::DeviceDescriptor {label: Some("gpui_device"),required_features,- required_limits: wgpu::Limits::downlevel_defaults()- .using_resolution(adapter.limits())- .using_alignment(adapter.limits()),+ required_limits,memory_hints: wgpu::MemoryHints::MemoryUsage,trace: wgpu::Trace::Off,experimental_features: wgpu::ExperimentalFeatures::disabled(),@@ -396,11 +502,16 @@ impl WgpuContext {fn select_color_texture_format(adapter: &wgpu::Adapter) -> anyhow::Result<wgpu::TextureFormat> {let required_usages = wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST;let bgra_features = adapter.get_texture_format_features(wgpu::TextureFormat::Bgra8Unorm);+ let rgba_features = adapter.get_texture_format_features(wgpu::TextureFormat::Rgba8Unorm);+ #[cfg(target_family = "wasm")]+ if adapter.get_info().backend == wgpu::Backend::Gl+ && rgba_features.allowed_usages.contains(required_usages)+ {+ return Ok(wgpu::TextureFormat::Rgba8Unorm);+ }if bgra_features.allowed_usages.contains(required_usages) {return Ok(wgpu::TextureFormat::Bgra8Unorm);}-- let rgba_features = adapter.get_texture_format_features(wgpu::TextureFormat::Rgba8Unorm);if rgba_features.allowed_usages.contains(required_usages) {let info = adapter.get_info();log::warn!(@@ -426,6 +537,14 @@ impl WgpuContext {rgba_features.allowed_usages,))}+ pub fn backend(&self) -> WgpuBackend {+ self.backend+ }++ pub fn uses_webgl_instance_data(&self) -> bool {+ matches!(self.backend, WgpuBackend::Gl) && cfg!(target_family = "wasm")+ }+pub fn supports_dual_source_blending(&self) -> bool {self.dual_source_blending}diff --git a/crates/gpui_wgpu/src/wgpu_renderer.rs b/crates/gpui_wgpu/src/wgpu_renderer.rsindex e30ade6e398..b0cd40a767e 100644--- a/crates/gpui_wgpu/src/wgpu_renderer.rs+++ b/crates/gpui_wgpu/src/wgpu_renderer.rs@@ -16,6 +16,43 @@ use std::sync::{Arc, Mutex};const MAX_INSTANCE_BUFFER_SIZE: u64 = 256 * 1024 * 1024;+const INSTANCE_TEXTURE_TEXEL_SIZE: u64 = 16;++/// Shader variant for backends with storage buffer support: the shared shader+/// logic plus the storage-buffer instance transport.+const STORAGE_BUFFER_SHADERS: &str = concat!(+ include_str!("shaders.wgsl"),+ include_str!("shaders_storage.wgsl"),+);++/// Shader variant for WebGL2, which has no storage buffers: the shared shader+/// logic plus the texture-based instance transport.+const WEBGL_SHADERS: &str = concat!(+ include_str!("shaders.wgsl"),+ include_str!("shaders_webgl.wgsl"),+);++/// Subpixel text rendering requires dual-source blending, which WebGL2 lacks, so+/// this variant only ever runs with the storage-buffer transport. The `enable`+/// directive must precede all declarations.+const SUBPIXEL_SHADERS: &str = concat!(+ "enable dual_source_blending;\n",+ include_str!("shaders.wgsl"),+ include_str!("shaders_storage.wgsl"),+ include_str!("shaders_subpixel.wgsl"),+);++fn least_common_multiple(left: u64, right: u64) -> u64 {+ let mut first = left;+ let mut second = right;+ while second != 0 {+ let remainder = first % second;+ first = second;+ second = remainder;+ }+ left / first * right+}+#[repr(C)]#[derive(Clone, Copy, Pod, Zeroable)]struct GlobalParams {@@ -97,13 +134,24 @@ struct WgpuPipelines {surfaces: wgpu::RenderPipeline,}+/// One frame allocation of instance data, ready to bind.+struct InstanceBinding {+ bind_group: wgpu::BindGroup,+ /// Index of the allocation's first instance within the bound data. Always+ /// zero on the storage-buffer path, where the binding offset already+ /// positions the array; on the WebGL texture path the shader indexes the+ /// shared instance texture absolutely, so draws must offset their+ /// instance (or vertex) ranges by this value.+ first_instance: u32,+}+struct InstanceBindings {- quads: wgpu::BindGroup,- shadows: wgpu::BindGroup,- underlines: wgpu::BindGroup,- monochrome_sprites: wgpu::BindGroup,- subpixel_sprites: wgpu::BindGroup,- polychrome_sprites: wgpu::BindGroup,+ quads: InstanceBinding,+ shadows: InstanceBinding,+ underlines: InstanceBinding,+ monochrome_sprites: InstanceBinding,+ subpixel_sprites: InstanceBinding,+ polychrome_sprites: InstanceBinding,}struct WgpuBindGroupLayouts {@@ -116,6 +164,18 @@ struct WgpuBindGroupLayouts {/// Shared GPU context reference, used to coordinate device recovery across multiple windows.pub type GpuContext = Rc<RefCell<Option<WgpuContext>>>;+enum InstanceData {+ Storage(wgpu::Buffer),+ // WebGL2 has no storage buffers. A uint texture keeps the records available to both shader+ // stages while preserving integer and floating-point bit patterns exactly.+ Texture {+ texture: wgpu::Texture,+ view: wgpu::TextureView,+ width: u32,+ height: u32,+ },+}+/// GPU resources that must be dropped together during device recovery.struct WgpuResources {device: Arc<wgpu::Device>,@@ -127,7 +187,7 @@ struct WgpuResources {globals_buffer: wgpu::Buffer,globals_bind_group: wgpu::BindGroup,path_globals_bind_group: wgpu::BindGroup,- instance_buffer: wgpu::Buffer,+ instance_data: InstanceData,path_intermediate_texture: Option<wgpu::Texture>,path_intermediate_view: Option<wgpu::TextureView>,path_msaa_texture: Option<wgpu::Texture>,@@ -155,9 +215,10 @@ pub struct WgpuRenderer {atlas: Arc<WgpuAtlas>,path_globals_offset: u64,gamma_offset: u64,- instance_buffer_capacity: u64,- max_buffer_size: u64,- storage_buffer_alignment: u64,+ instance_data_capacity: u64,+ max_instance_data_size: u64,+ instance_data_alignment: u64,+ uses_webgl_instance_data: bool,rendering_params: RenderingParameters,is_bgr: bool,dual_source_blending: bool,@@ -263,9 +324,17 @@ impl WgpuRenderer {.instance.create_surface(wgpu::SurfaceTarget::Canvas(canvas.clone())).map_err(|e| anyhow::anyhow!("Failed to create surface: {e}"))?;+ Self::new_from_surface(context, surface, config)+ }+ #[cfg(target_family = "wasm")]+ #[allow(clippy::arc_with_non_send_sync)]+ pub fn new_from_surface(+ context: &WgpuContext,+ surface: wgpu::Surface<'static>,+ config: WgpuSurfaceConfig,+ ) -> anyhow::Result<Self> {let atlas = Arc::new(WgpuAtlas::from_context(context));-Self::new_internal(None, context, surface, config, None, atlas)}@@ -360,10 +429,11 @@ impl WgpuRenderer {surface.configure(&context.device, &surface_config);let queue = Arc::clone(&context.queue);- let dual_source_blending = context.supports_dual_source_blending();-let rendering_params = RenderingParameters::new(&context.adapter, surface_format);- let bind_group_layouts = Self::create_bind_group_layouts(&device);+ 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,@@ -371,6 +441,7 @@ impl WgpuRenderer {alpha_mode,rendering_params.path_sample_count,dual_source_blending,+ uses_webgl_instance_data,);let atlas_sampler = device.create_sampler(&wgpu::SamplerDescriptor {@@ -393,21 +464,47 @@ impl WgpuRenderer {mapped_at_creation: false,});- // Every frame allocation is exposed as one storage-buffer binding, so- // its backing buffer must satisfy both the allocation and binding limits.- let max_buffer_size = device- .limits()- .max_buffer_size- .min(device.limits().max_storage_buffer_binding_size)- .min(MAX_INSTANCE_BUFFER_SIZE);- let storage_buffer_alignment = device.limits().min_storage_buffer_offset_alignment as u64;- let initial_instance_buffer_capacity = (2 * 1024 * 1024).min(max_buffer_size);- let instance_buffer = device.create_buffer(&wgpu::BufferDescriptor {- label: Some("instance_buffer"),- size: initial_instance_buffer_capacity,- usage: wgpu::BufferUsages::STORAGE | 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"),@@ -474,7 +571,7 @@ impl WgpuRenderer {globals_buffer,globals_bind_group,path_globals_bind_group,- instance_buffer,+ 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,@@ -491,9 +588,10 @@ impl WgpuRenderer {atlas,path_globals_offset,gamma_offset,- instance_buffer_capacity: initial_instance_buffer_capacity,- max_buffer_size,- storage_buffer_alignment,+ instance_data_capacity,+ max_instance_data_size,+ instance_data_alignment,+ uses_webgl_instance_data,rendering_params,is_bgr: false,dual_source_blending,@@ -509,7 +607,10 @@ impl WgpuRenderer {})}- fn create_bind_group_layouts(device: &wgpu::Device) -> WgpuBindGroupLayouts {+ fn create_bind_group_layouts(+ device: &wgpu::Device,+ uses_webgl_instance_data: bool,+ ) -> WgpuBindGroupLayouts {let globals =device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {label: Some("globals_layout"),@@ -541,20 +642,28 @@ impl WgpuRenderer {],});- let storage_buffer_entry = |binding: u32| wgpu::BindGroupLayoutEntry {- binding,+ let instance_data_entry = wgpu::BindGroupLayoutEntry {+ binding: 0,visibility: wgpu::ShaderStages::VERTEX_FRAGMENT,- ty: wgpu::BindingType::Buffer {- ty: wgpu::BufferBindingType::Storage { read_only: true },- has_dynamic_offset: false,- min_binding_size: None,+ ty: if uses_webgl_instance_data {+ wgpu::BindingType::Texture {+ sample_type: wgpu::TextureSampleType::Uint,+ view_dimension: wgpu::TextureViewDimension::D2,+ multisampled: false,+ }+ } else {+ wgpu::BindingType::Buffer {+ ty: wgpu::BufferBindingType::Storage { read_only: true },+ has_dynamic_offset: false,+ min_binding_size: None,+ }},count: None,};let instances = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {label: Some("instances_layout"),- entries: &[storage_buffer_entry(0)],+ entries: &[instance_data_entry],});let texture = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {@@ -631,6 +740,44 @@ impl WgpuRenderer {}}+ fn create_instance_texture(+ device: &wgpu::Device,+ requested_capacity: u64,+ max_texture_dimension: u32,+ ) -> (InstanceData, u64) {+ let texel_count = requested_capacity.div_ceil(INSTANCE_TEXTURE_TEXEL_SIZE);+ let width = texel_count.min(u64::from(max_texture_dimension)).max(1) as u32;+ let height = texel_count+ .div_ceil(u64::from(width))+ .min(u64::from(max_texture_dimension))+ .max(1) as u32;+ let texture = device.create_texture(&wgpu::TextureDescriptor {+ label: Some("instance_texture"),+ size: wgpu::Extent3d {+ width,+ height,+ depth_or_array_layers: 1,+ },+ mip_level_count: 1,+ sample_count: 1,+ dimension: wgpu::TextureDimension::D2,+ format: wgpu::TextureFormat::Rgba32Uint,+ usage: wgpu::TextureUsages::TEXTURE_BINDING | wgpu::TextureUsages::COPY_DST,+ view_formats: &[],+ });+ let view = texture.create_view(&wgpu::TextureViewDescriptor::default());+ let capacity = u64::from(width) * u64::from(height) * INSTANCE_TEXTURE_TEXEL_SIZE;+ (+ InstanceData::Texture {+ texture,+ view,+ width,+ height,+ },+ capacity,+ )+ }+fn create_pipelines(device: &wgpu::Device,layouts: &WgpuBindGroupLayouts,@@ -638,6 +785,7 @@ impl WgpuRenderer {alpha_mode: wgpu::CompositeAlphaMode,path_sample_count: u32,dual_source_blending: bool,+ uses_webgl_instance_data: bool,) -> WgpuPipelines {// Diagnostic guard: verify the device actually has// DUAL_SOURCE_BLENDING. We have a crash report (ZED-5G1) where a@@ -659,22 +807,23 @@ impl WgpuRenderer {device.features(),);}- let dual_source_blending = dual_source_blending && device_has_feature;+ let dual_source_blending =+ dual_source_blending && device_has_feature && !uses_webgl_instance_data;- let base_shader_source = include_str!("shaders.wgsl");+ let shader_source = if uses_webgl_instance_data {+ WEBGL_SHADERS+ } else {+ STORAGE_BUFFER_SHADERS+ };let shader_module = device.create_shader_module(wgpu::ShaderModuleDescriptor {label: Some("gpui_shaders"),- source: wgpu::ShaderSource::Wgsl(std::borrow::Cow::Borrowed(base_shader_source)),+ source: wgpu::ShaderSource::Wgsl(shader_source.into()),});- let subpixel_shader_source = include_str!("shaders_subpixel.wgsl");let subpixel_shader_module = if dual_source_blending {- let combined = format!(- "enable dual_source_blending;\n{base_shader_source}\n{subpixel_shader_source}"- );Some(device.create_shader_module(wgpu::ShaderModuleDescriptor {label: Some("gpui_subpixel_shaders"),- source: wgpu::ShaderSource::Wgsl(std::borrow::Cow::Owned(combined)),+ source: wgpu::ShaderSource::Wgsl(SUBPIXEL_SHADERS.into()),}))} else {None@@ -1065,6 +1214,7 @@ impl WgpuRenderer {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;};@@ -1078,6 +1228,7 @@ impl WgpuRenderer {surface_config.alpha_mode,path_sample_count,dual_source_blending,+ uses_webgl_instance_data,);}}@@ -1112,6 +1263,17 @@ impl WgpuRenderer {}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;+ }+// 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@@ -1383,33 +1545,35 @@ impl WgpuRenderer {instance_offset: &mut u64,) -> Result<InstanceBindings> {Ok(InstanceBindings {- quads: self.write_instance_binding("quads_bind_group", instance_offset, unsafe {- Self::instance_bytes(&scene.quads)- })?,+ quads: self.write_instance_binding(+ "quads_bind_group",+ instance_offset,+ &scene.quads,+ )?,shadows: self.write_instance_binding("shadows_bind_group",instance_offset,- unsafe { Self::instance_bytes(&scene.shadows) },+ &scene.shadows,)?,underlines: self.write_instance_binding("underlines_bind_group",instance_offset,- unsafe { Self::instance_bytes(&scene.underlines) },+ &scene.underlines,)?,monochrome_sprites: self.write_instance_binding("monochrome_sprites_bind_group",instance_offset,- unsafe { Self::instance_bytes(&scene.monochrome_sprites) },+ &scene.monochrome_sprites,)?,subpixel_sprites: self.write_instance_binding("subpixel_sprites_bind_group",instance_offset,- unsafe { Self::instance_bytes(&scene.subpixel_sprites) },+ &scene.subpixel_sprites,)?,polychrome_sprites: self.write_instance_binding("polychrome_sprites_bind_group",instance_offset,- unsafe { Self::instance_bytes(&scene.polychrome_sprites) },+ &scene.polychrome_sprites,)?,})}@@ -1440,29 +1604,32 @@ impl WgpuRenderer {fn draw_instances(&self,- bind_group: &wgpu::BindGroup,+ instances: &InstanceBinding,pipeline: &wgpu::RenderPipeline,- instances: Range<u32>,+ range: Range<u32>,pass: &mut wgpu::RenderPass<'_>,) {- if instances.is_empty() {+ if range.is_empty() {return;}pass.set_pipeline(pipeline);pass.set_bind_group(0, &self.resources().globals_bind_group, &[]);- pass.set_bind_group(1, bind_group, &[]);- pass.draw(0..4, instances);+ pass.set_bind_group(1, &instances.bind_group, &[]);+ pass.draw(+ 0..4,+ instances.first_instance + range.start..instances.first_instance + range.end,+ );}fn draw_sprites(&self,- sprite_instances: &wgpu::BindGroup,+ sprite_instances: &InstanceBinding,texture_id: AtlasTextureId,pipeline: &wgpu::RenderPipeline,- instances: Range<u32>,+ range: Range<u32>,pass: &mut wgpu::RenderPass<'_>,) {- if instances.is_empty() {+ if range.is_empty() {return;}let texture_info = self.atlas.get_texture_info(texture_id);@@ -1470,9 +1637,13 @@ impl WgpuRenderer {self.create_texture_bind_group("atlas_texture_bind_group", &texture_info.view);pass.set_pipeline(pipeline);pass.set_bind_group(0, &self.resources().globals_bind_group, &[]);- pass.set_bind_group(1, sprite_instances, &[]);+ pass.set_bind_group(1, &sprite_instances.bind_group, &[]);pass.set_bind_group(2, &texture, &[]);- pass.draw(0..4, instances);+ pass.draw(+ 0..4,+ sprite_instances.first_instance + range.start+ ..sprite_instances.first_instance + range.end,+ );}unsafe fn instance_bytes<T>(instances: &[T]) -> &[u8] {@@ -1511,9 +1682,7 @@ impl WgpuRenderer {return Ok(());};let instances =- self.write_instance_binding("path_sprites_bind_group", instance_offset, unsafe {- Self::instance_bytes(&sprites)- })?;+ self.write_instance_binding("path_sprites_bind_group", instance_offset, &sprites)?;let texture = self.create_texture_bind_group("path_intermediate_texture_bind_group",&path_intermediate_view,@@ -1521,9 +1690,12 @@ impl WgpuRenderer {let resources = self.resources();pass.set_pipeline(&resources.pipelines.paths);pass.set_bind_group(0, &resources.globals_bind_group, &[]);- pass.set_bind_group(1, &instances, &[]);+ pass.set_bind_group(1, &instances.bind_group, &[]);pass.set_bind_group(2, &texture, &[]);- pass.draw(0..4, 0..sprites.len() as u32);+ pass.draw(+ 0..4,+ instances.first_instance..instances.first_instance + sprites.len() as u32,+ );Ok(())}@@ -1548,10 +1720,10 @@ impl WgpuRenderer {return Ok(false);}- let data_bind_group = self.write_instance_binding(+ let vertex_binding = self.write_instance_binding("path_rasterization_bind_group",instance_offset,- unsafe { Self::instance_bytes(&vertices) },+ &vertices,)?;let resources = self.resources();@@ -1583,34 +1755,65 @@ impl WgpuRenderer {pass.set_pipeline(&resources.pipelines.path_rasterization);pass.set_bind_group(0, &resources.path_globals_bind_group, &[]);- pass.set_bind_group(1, &data_bind_group, &[]);- pass.draw(0..vertices.len() as u32, 0..1);+ pass.set_bind_group(1, &vertex_binding.bind_group, &[]);+ // The path rasterization shader loads records by vertex index+ // rather than instance index, so the allocation's base shifts the+ // vertex range here.+ pass.draw(+ vertex_binding.first_instance+ ..vertex_binding.first_instance + vertices.len() as u32,+ 0..1,+ );}Ok(true)}- fn write_instance_binding(+ fn write_instance_binding<T>(&mut self,label: &str,instance_offset: &mut u64,- data: &[u8],- ) -> Result<wgpu::BindGroup> {+ instances: &[T],+ ) -> Result<InstanceBinding> {+ let data = unsafe { Self::instance_bytes(instances) };// wgpu rejects zero-sized bindings, so empty primitive arrays still// reserve the 16-byte minimum.let size = (data.len() as u64).max(16);- let mut offset = (*instance_offset).next_multiple_of(self.storage_buffer_alignment.max(1));- if offset + size > self.instance_buffer_capacity {- self.grow_instance_buffer(size)?;+ let stride = (std::mem::size_of::<T>() as u64).max(1);+ let (alignment, allocation_size) = if self.uses_webgl_instance_data {+ // The texture transport has no binding offset: the shader indexes+ // the instance texture absolutely, so each allocation must start on+ // a whole instance (a stride multiple) and a whole texel, and must+ // end on a texel boundary so the zero padding of its final partial+ // texel cannot overlap the next allocation.+ (+ least_common_multiple(self.instance_data_alignment, stride),+ size.next_multiple_of(INSTANCE_TEXTURE_TEXEL_SIZE),+ )+ } else {+ (self.instance_data_alignment.max(1), size)+ };+ let mut offset = (*instance_offset).next_multiple_of(alignment);+ if offset + allocation_size > self.instance_data_capacity {+ self.grow_instance_data(allocation_size)?;offset = 0;}- *instance_offset = offset + size;+ *instance_offset = offset + allocation_size;++ let first_instance = if self.uses_webgl_instance_data {+ u32::try_from(offset / stride).context("instance index exceeds u32 range")?+ } else {+ 0+ };let resources = self.resources();if !data.is_empty() {- resources- .queue- .write_buffer(&resources.instance_buffer, offset, data);+ match &resources.instance_data {+ InstanceData::Storage(buffer) => resources.queue.write_buffer(buffer, offset, data),+ InstanceData::Texture { .. } => {+ Self::write_instance_texture(resources, offset, data)+ }+ }}let bind_group = resources.device@@ -1619,42 +1822,150 @@ impl WgpuRenderer {layout: &resources.bind_group_layouts.instances,entries: &[wgpu::BindGroupEntry {binding: 0,- resource: wgpu::BindingResource::Buffer(wgpu::BufferBinding {- buffer: &resources.instance_buffer,- offset,- size: NonZeroU64::new(size),- }),+ resource: match &resources.instance_data {+ InstanceData::Storage(buffer) => {+ wgpu::BindingResource::Buffer(wgpu::BufferBinding {+ buffer,+ offset,+ size: NonZeroU64::new(size),+ })+ }+ InstanceData::Texture { view, .. } => {+ wgpu::BindingResource::TextureView(view)+ }+ },}],});- Ok(bind_group)+ Ok(InstanceBinding {+ bind_group,+ first_instance,+ })+ }++ fn write_instance_texture(resources: &WgpuResources, offset: u64, data: &[u8]) {+ let InstanceData::Texture {+ texture,+ width,+ height,+ ..+ } = &resources.instance_data+ else {+ return;+ };+ let mut byte_offset = 0usize;+ let mut texel_offset = offset / INSTANCE_TEXTURE_TEXEL_SIZE;+ while byte_offset < data.len() {+ let x = (texel_offset % u64::from(*width)) as u32;+ let y = (texel_offset / u64::from(*width)) as u32;+ if y >= *height {+ // The capacity check in write_instance_binding should make this+ // unreachable. Truncating silently would leave stale bytes in the+ // texture and draw garbage for the remaining instances.+ debug_assert!(+ false,+ "instance texture write out of bounds: row {y} >= height {}",+ *height+ );+ log::error!(+ "instance texture write out of bounds; dropping {} bytes of instance data",+ data.len() - byte_offset+ );+ return;+ }+ let available_texels = u64::from(*width - x);+ let remaining_bytes = data.len() - byte_offset;+ let complete_texels = remaining_bytes as u64 / INSTANCE_TEXTURE_TEXEL_SIZE;+ let texels = complete_texels.min(available_texels);+ if texels > 0 {+ let byte_count = (texels * INSTANCE_TEXTURE_TEXEL_SIZE) as usize;+ resources.queue.write_texture(+ wgpu::TexelCopyTextureInfo {+ texture,+ mip_level: 0,+ origin: wgpu::Origin3d { x, y, z: 0 },+ aspect: wgpu::TextureAspect::All,+ },+ &data[byte_offset..byte_offset + byte_count],+ wgpu::TexelCopyBufferLayout {+ offset: 0,+ bytes_per_row: Some(byte_count as u32),+ rows_per_image: None,+ },+ wgpu::Extent3d {+ width: texels as u32,+ height: 1,+ depth_or_array_layers: 1,+ },+ );+ byte_offset += byte_count;+ texel_offset += texels;+ continue;+ }++ let mut final_texel = [0; INSTANCE_TEXTURE_TEXEL_SIZE as usize];+ final_texel[..remaining_bytes].copy_from_slice(&data[byte_offset..]);+ resources.queue.write_texture(+ wgpu::TexelCopyTextureInfo {+ texture,+ mip_level: 0,+ origin: wgpu::Origin3d { x, y, z: 0 },+ aspect: wgpu::TextureAspect::All,+ },+ &final_texel,+ wgpu::TexelCopyBufferLayout {+ offset: 0,+ bytes_per_row: Some(INSTANCE_TEXTURE_TEXEL_SIZE as u32),+ rows_per_image: None,+ },+ wgpu::Extent3d {+ width: 1,+ height: 1,+ depth_or_array_layers: 1,+ },+ );+ break;+ }}- fn grow_instance_buffer(&mut self, required: u64) -> Result<()> {- let capacity = (self.instance_buffer_capacity * 2)+ fn grow_instance_data(&mut self, required: u64) -> Result<()> {+ let capacity = (self.instance_data_capacity * 2).max(required.next_power_of_two())- .min(self.max_buffer_size);+ .min(self.max_instance_data_size);anyhow::ensure!(capacity >= required,- "instance buffer needs {required} bytes, above the device maximum of {}",- self.max_buffer_size+ "instance data needs {required} bytes, above the maximum of {}",+ self.max_instance_data_size);anyhow::ensure!(- capacity > self.instance_buffer_capacity,+ capacity > self.instance_data_capacity,"frame instance data exceeds the {}-byte maximum",- self.max_buffer_size+ self.max_instance_data_size);log::debug!(- "instance buffer grown from {} to {capacity}",- self.instance_buffer_capacity+ "instance data grown from {} to {capacity}",+ self.instance_data_capacity);+ // Bind groups created earlier in the frame keep the previous buffer or+ // texture alive, so allocations written before the grow remain valid;+ // only subsequent writes land in the new allocation.+ let uses_webgl_instance_data = self.uses_webgl_instance_data;let resources = self.resources_mut();- resources.instance_buffer = resources.device.create_buffer(&wgpu::BufferDescriptor {- label: Some("instance_buffer"),- size: capacity,- usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST,- mapped_at_creation: false,- });- self.instance_buffer_capacity = capacity;+ if uses_webgl_instance_data {+ let max_texture_dimension = resources.device.limits().max_texture_dimension_2d;+ let (instance_data, actual_capacity) =+ Self::create_instance_texture(&resources.device, capacity, max_texture_dimension);+ resources.instance_data = instance_data;+ self.instance_data_capacity = actual_capacity;+ } else {+ resources.instance_data =+ InstanceData::Storage(resources.device.create_buffer(&wgpu::BufferDescriptor {+ label: Some("instance_buffer"),+ size: capacity,+ usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_DST,+ mapped_at_creation: false,+ }));+ self.instance_data_capacity = capacity;+ }Ok(())}@@ -1886,3 +2197,47 @@ impl RenderingParameters {}}}++#[cfg(test)]+mod tests {+ use super::*;+ use gpui::{MonochromeSprite, PolychromeSprite, Quad, Shadow, SubpixelSprite, Underline};++ #[test]+ fn webgl_shader_is_valid_wgsl_without_storage_buffers() {+ assert!(!WEBGL_SHADERS.contains("var<storage"));+ validate_wgsl(WEBGL_SHADERS, naga::valid::Capabilities::empty());+ }++ #[test]+ fn storage_buffer_shader_is_valid_wgsl() {+ validate_wgsl(STORAGE_BUFFER_SHADERS, naga::valid::Capabilities::empty());+ }++ #[test]+ fn subpixel_shader_is_valid_wgsl() {+ validate_wgsl(+ SUBPIXEL_SHADERS,+ naga::valid::Capabilities::DUAL_SOURCE_BLENDING,+ );+ }++ fn validate_wgsl(source: &str, capabilities: naga::valid::Capabilities) {+ let module = naga::front::wgsl::parse_str(source).expect("shader should parse");+ naga::valid::Validator::new(naga::valid::ValidationFlags::all(), capabilities)+ .validate(&module)+ .expect("shader should validate");+ }++ #[test]+ fn webgl_record_sizes_match_shader_word_strides() {+ assert_eq!(std::mem::size_of::<Quad>(), 40 * 4);+ assert_eq!(std::mem::size_of::<Shadow>(), 28 * 4);+ assert_eq!(std::mem::size_of::<PathRasterizationVertex>(), 26 * 4);+ assert_eq!(std::mem::size_of::<PathSprite>(), 4 * 4);+ assert_eq!(std::mem::size_of::<Underline>(), 16 * 4);+ assert_eq!(std::mem::size_of::<MonochromeSprite>(), 28 * 4);+ assert_eq!(std::mem::size_of::<SubpixelSprite>(), 28 * 4);+ assert_eq!(std::mem::size_of::<PolychromeSprite>(), 24 * 4);+ }+}