Merge pull request #1 from nestrilabs/fix-gpui-issue

feat: Expose wgpu to the client

Author: wanjohiryan

crates/gpui/src/scene.rs

@@ -9,10 +9,12 @@ use crate::{
     Point, Radians, ScaledPixels, Size, bounds_tree::BoundsTree, point,
 };
 use std::{
+    any::Any,
     fmt::Debug,
     iter::Peekable,
     ops::{Add, Range, Sub},
     slice,
+    sync::Arc,
 };
 
 #[allow(non_camel_case_types, unused)]
@@ -36,6 +38,7 @@ pub struct Scene {
     pub subpixel_sprites: Vec<SubpixelSprite>,
     pub polychrome_sprites: Vec<PolychromeSprite>,
     pub surfaces: Vec<PaintSurface>,
+    pub custom_render_passes: Vec<CustomRenderPassPrimitive>,
 }
 
 #[expect(missing_docs)]
@@ -52,6 +55,7 @@ impl Scene {
         self.subpixel_sprites.clear();
         self.polychrome_sprites.clear();
         self.surfaces.clear();
+        self.custom_render_passes.clear();
     }
 
     pub fn len(&self) -> usize {
@@ -119,6 +123,10 @@ impl Scene {
                 surface.order = order;
                 self.surfaces.push(surface.clone());
             }
+            Primitive::CustomRenderPass(custom) => {
+                custom.order = order;
+                self.custom_render_passes.push(custom.clone());
+            }
         }
         self.paint_operations
             .push(PaintOperation::Primitive(primitive));
@@ -146,6 +154,7 @@ impl Scene {
         self.polychrome_sprites
             .sort_by_key(|sprite| (sprite.order, sprite.tile.tile_id));
         self.surfaces.sort_by_key(|surface| surface.order);
+        self.custom_render_passes.sort_by_key(|custom| custom.order);
     }
 
     #[cfg_attr(
@@ -173,6 +182,8 @@ impl Scene {
             polychrome_sprites_iter: self.polychrome_sprites.iter().peekable(),
             surfaces_start: 0,
             surfaces_iter: self.surfaces.iter().peekable(),
+            custom_render_passes_start: 0,
+            custom_render_passes_iter: self.custom_render_passes.iter().peekable(),
         }
     }
 }
@@ -195,6 +206,7 @@ pub(crate) enum PrimitiveKind {
     SubpixelSprite,
     PolychromeSprite,
     Surface,
+    CustomRenderPass,
 }
 
 pub(crate) enum PaintOperation {
@@ -214,6 +226,7 @@ pub enum Primitive {
     SubpixelSprite(SubpixelSprite),
     PolychromeSprite(PolychromeSprite),
     Surface(PaintSurface),
+    CustomRenderPass(CustomRenderPassPrimitive),
 }
 
 #[expect(missing_docs)]
@@ -228,6 +241,7 @@ impl Primitive {
             Primitive::SubpixelSprite(sprite) => &sprite.bounds,
             Primitive::PolychromeSprite(sprite) => &sprite.bounds,
             Primitive::Surface(surface) => &surface.bounds,
+            Primitive::CustomRenderPass(custom) => &custom.bounds,
         }
     }
 
@@ -241,6 +255,7 @@ impl Primitive {
             Primitive::SubpixelSprite(sprite) => &sprite.content_mask,
             Primitive::PolychromeSprite(sprite) => &sprite.content_mask,
             Primitive::Surface(surface) => &surface.content_mask,
+            Primitive::CustomRenderPass(custom) => &custom.content_mask,
         }
     }
 }
@@ -269,6 +284,8 @@ struct BatchIterator<'a> {
     polychrome_sprites_iter: Peekable<slice::Iter<'a, PolychromeSprite>>,
     surfaces_start: usize,
     surfaces_iter: Peekable<slice::Iter<'a, PaintSurface>>,
+    custom_render_passes_start: usize,
+    custom_render_passes_iter: Peekable<slice::Iter<'a, CustomRenderPassPrimitive>>,
 }
 
 impl<'a> Iterator for BatchIterator<'a> {
@@ -302,6 +319,10 @@ impl<'a> Iterator for BatchIterator<'a> {
                 self.surfaces_iter.peek().map(|s| s.order),
                 PrimitiveKind::Surface,
             ),
+            (
+                self.custom_render_passes_iter.peek().map(|c| c.order),
+                PrimitiveKind::CustomRenderPass,
+            ),
         ];
         orders_and_kinds.sort_by_key(|(order, kind)| (order.unwrap_or(u32::MAX), *kind));
 
@@ -447,6 +468,20 @@ impl<'a> Iterator for BatchIterator<'a> {
                 self.surfaces_start = surfaces_end;
                 Some(PrimitiveBatch::Surfaces(surfaces_start..surfaces_end))
             }
+            PrimitiveKind::CustomRenderPass => {
+                let custom_render_passes_start = self.custom_render_passes_start;
+                let mut custom_render_passes_end = custom_render_passes_start + 1;
+                self.custom_render_passes_iter.next();
+                while self
+                    .custom_render_passes_iter
+                    .next_if(|custom| (custom.order, batch_kind) < max_order_and_kind)
+                    .is_some()
+                {
+                    custom_render_passes_end += 1;
+                }
+                self.custom_render_passes_start = custom_render_passes_end;
+                Some(PrimitiveBatch::CustomRenderPasses(custom_render_passes_start..custom_render_passes_end))
+            }
         }
     }
 }
@@ -479,6 +514,7 @@ pub enum PrimitiveBatch {
         range: Range<usize>,
     },
     Surfaces(Range<usize>),
+    CustomRenderPasses(Range<usize>),
 }
 
 #[derive(Default, Debug, Copy, Clone)]
@@ -726,6 +762,37 @@ impl From<PaintSurface> for Primitive {
     }
 }
 
+/// A trait implemented by renderer-specific context types passed to custom render callbacks.
+/// The callback can downcast to the concrete type using `Any` methods.
+pub trait AnyRenderContext: std::any::Any {
+    /// Returns a reference to the underlying `Any` for downcasting.
+    fn as_any(&self) -> &dyn std::any::Any;
+    /// Returns a mutable reference to the underlying `Any` for downcasting.
+    fn as_any_mut(&mut self) -> &mut dyn std::any::Any;
+}
+
+/// A primitive that invokes a custom render callback during the wgpu render pass.
+/// The callback receives a type-erased context which the renderer populates with
+/// platform-specific GPU resources. This keeps gpui independent of wgpu while
+/// allowing full GPU access to consumers.
+///
+/// The callback should downcast the context to the concrete type provided by the
+/// renderer (e.g., `CustomRenderPassContext` in `gpui_wgpu`).
+#[derive(Clone)]
+#[expect(missing_docs)]
+pub struct CustomRenderPassPrimitive {
+    pub order: DrawOrder,
+    pub bounds: Bounds<ScaledPixels>,
+    pub content_mask: ContentMask<ScaledPixels>,
+    pub callback: Arc<dyn Fn(&mut dyn AnyRenderContext) + Send + Sync>,
+}
+
+impl From<CustomRenderPassPrimitive> for Primitive {
+    fn from(custom: CustomRenderPassPrimitive) -> Self {
+        Primitive::CustomRenderPass(custom)
+    }
+}
+
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
 #[expect(missing_docs)]
 pub struct PathId(pub usize);

crates/gpui/src/window.rs

@@ -3,22 +3,21 @@ use crate::Inspector;
 use crate::{
     Action, AnyDrag, AnyElement, AnyImageCache, AnyTooltip, AnyView, App, AppContext, Arena, Asset,
     AsyncWindowContext, AvailableSpace, Background, BorderStyle, Bounds, BoxShadow, Capslock,
-    Context, Corners, CursorHideMode, CursorStyle, Decorations, DevicePixels,
-    DispatchActionListener, DispatchNodeId, DispatchTree, DisplayId, Edges, Effect, Entity,
-    EntityId, EventEmitter, FileDropEvent, FontId, Global, GlobalElementId, GlyphId, GpuSpecs,
-    Hsla, InputHandler, IsZero, KeyBinding, KeyContext, KeyDownEvent, KeyEvent, Keystroke,
-    KeystrokeEvent, LayoutId, LineLayoutIndex, Modifiers, ModifiersChangedEvent, MonochromeSprite,
-    MouseButton, MouseEvent, MouseMoveEvent, MouseUpEvent, Path, Pixels, PlatformAtlas,
-    PlatformDisplay, PlatformInput, PlatformInputHandler, PlatformWindow, Point, PolychromeSprite,
-    Priority, PromptButton, PromptLevel, Quad, Render, RenderGlyphParams, RenderImage,
-    RenderImageParams, RenderSvgParams, Replay, ResizeEdge, SMOOTH_SVG_SCALE_FACTOR,
-    SUBPIXEL_VARIANTS_X, SUBPIXEL_VARIANTS_Y, ScaledPixels, Scene, Shadow, SharedString, Size,
-    StrikethroughStyle, Style, SubpixelSprite, SubscriberSet, Subscription, SystemWindowTab,
-    SystemWindowTabController, TabStopMap, TaffyLayoutEngine, Task, TextRenderingMode, TextStyle,
-    TextStyleRefinement, ThermalState, TransformationMatrix, Underline, UnderlineStyle,
-    WindowAppearance, WindowBackgroundAppearance, WindowBounds, WindowControls, WindowDecorations,
-    WindowOptions, WindowParams, WindowTextSystem, point, prelude::*, px, rems, size,
-    transparent_black,
+    Context, Corners, CursorStyle, CustomRenderPassPrimitive, Decorations, DevicePixels, DispatchActionListener,
+    DispatchNodeId, DispatchTree, DisplayId, Edges, Effect, Entity, EntityId, EventEmitter,
+    FileDropEvent, FontId, Global, GlobalElementId, GlyphId, GpuSpecs, Hsla, InputHandler, IsZero,
+    KeyBinding, KeyContext, KeyDownEvent, KeyEvent, Keystroke, KeystrokeEvent, LayoutId,
+    LineLayoutIndex, Modifiers, ModifiersChangedEvent, MonochromeSprite, MouseButton, MouseEvent,
+    MouseMoveEvent, MouseUpEvent, Path, Pixels, PlatformAtlas, PlatformDisplay, PlatformInput,
+    PlatformInputHandler, PlatformWindow, Point, PolychromeSprite, Priority, PromptButton,
+    PromptLevel, Quad, Render, RenderGlyphParams, RenderImage, RenderImageParams, RenderSvgParams,
+    Replay, ResizeEdge, SMOOTH_SVG_SCALE_FACTOR, SUBPIXEL_VARIANTS_X, SUBPIXEL_VARIANTS_Y,
+    ScaledPixels, Scene, Shadow, SharedString, Size, StrikethroughStyle, Style, SubpixelSprite,
+    SubscriberSet, Subscription, SystemWindowTab, SystemWindowTabController, TabStopMap,
+    TaffyLayoutEngine, Task, TextRenderingMode, TextStyle, TextStyleRefinement, ThermalState,
+    TransformationMatrix, Underline, UnderlineStyle, WindowAppearance, WindowBackgroundAppearance,
+    WindowBounds, WindowControls, WindowDecorations, WindowOptions, WindowParams, WindowTextSystem,
+    point, prelude::*, px, rems, size, transparent_black,
 };
 use anyhow::{Context as _, Result, anyhow};
 use collections::{FxHashMap, FxHashSet};
@@ -3858,6 +3857,30 @@ impl Window {
         });
     }
 
+    /// Schedule a custom render pass to be executed during the wgpu rendering phase.
+    ///
+    /// The callback receives a type-erased context (`&mut dyn Any`) which the wgpu renderer
+    /// populates with GPU resources. On Linux/wgpu, this is a `CustomRenderPassContext`
+    /// containing `&wgpu::Device`, `&wgpu::Queue`, `&wgpu::TextureView`, and `wgpu::TextureFormat`.
+    ///
+    /// This method should only be called as part of the paint phase of element drawing.
+    pub fn paint_custom_render_pass(
+        &mut self,
+        bounds: Bounds<Pixels>,
+        callback: Arc<dyn Fn(&mut dyn crate::AnyRenderContext) + Send + Sync>,
+    ) {
+        self.invalidator.debug_assert_paint();
+
+        let bounds = self.snap_bounds(bounds);
+        let content_mask = self.snapped_content_mask();
+        self.next_frame.scene.insert_primitive(CustomRenderPassPrimitive {
+            order: 0,
+            bounds,
+            content_mask,
+            callback,
+        });
+    }
+
     /// Removes an image from the sprite atlas.
     pub fn drop_image(&mut self, data: Arc<RenderImage>) -> Result<()> {
         for frame_index in 0..data.frame_count() {

crates/gpui_wgpu/src/wgpu_renderer.rs

@@ -1,7 +1,7 @@
 use crate::{CompositorGpuHint, WgpuAtlas, WgpuContext};
 use bytemuck::{Pod, Zeroable};
 use gpui::{
-    AtlasTextureId, Background, Bounds, DevicePixels, GpuSpecs, MonochromeSprite, Path, Point,
+    AnyRenderContext, AtlasTextureId, Background, Bounds, DevicePixels, GpuSpecs, MonochromeSprite, Path, Point,
     PolychromeSprite, PrimitiveBatch, Quad, ScaledPixels, Scene, Shadow, Size, SubpixelSprite,
     Underline, get_gamma_correction_ratios,
 };
@@ -69,6 +69,27 @@ struct PathRasterizationVertex {
     bounds: Bounds<ScaledPixels>,
 }
 
+/// Context passed to custom render pass callbacks. Contains the GPU resources
+/// needed to render directly to the window surface. All fields are owned
+/// (reference-counted) so the context is `'static`.
+pub struct CustomRenderPassContext {
+    pub device: Arc<wgpu::Device>,
+    pub queue: Arc<wgpu::Queue>,
+    pub view: wgpu::TextureView,
+    pub format: wgpu::TextureFormat,
+    pub bounds: Bounds<ScaledPixels>,
+}
+
+impl AnyRenderContext for CustomRenderPassContext {
+    fn as_any(&self) -> &dyn std::any::Any {
+        self
+    }
+
+    fn as_any_mut(&mut self) -> &mut dyn std::any::Any {
+        self
+    }
+}
+
 pub struct WgpuSurfaceConfig {
     pub size: Size<DevicePixels>,
     pub transparent: bool,
@@ -1305,6 +1326,47 @@ impl WgpuRenderer {
                             // Not implemented for Linux/wgpu
                             true
                         }
+                        PrimitiveBatch::CustomRenderPasses(range) => {
+                            let custom_passes = &scene.custom_render_passes[range];
+                            if custom_passes.is_empty() {
+                                continue;
+                            }
+
+                            drop(pass);
+
+                            let resources = self.resources();
+                            let device = Arc::clone(&resources.device);
+                            let queue = Arc::clone(&resources.queue);
+                            let view = frame_view.clone();
+                            let format = self.surface_config.format;
+
+                            for custom in custom_passes {
+                                let mut ctx = CustomRenderPassContext {
+                                    device: Arc::clone(&device),
+                                    queue: Arc::clone(&queue),
+                                    view: view.clone(),
+                                    format,
+                                    bounds: custom.bounds,
+                                };
+                                (custom.callback)(&mut ctx);
+                            }
+
+                            pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+                                label: Some("main_pass_after_custom"),
+                                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
+                                    view: &frame_view,
+                                    resolve_target: None,
+                                    ops: wgpu::Operations {
+                                        load: wgpu::LoadOp::Load,
+                                        store: wgpu::StoreOp::Store,
+                                    },
+                                    depth_slice: None,
+                                })],
+                                depth_stencil_attachment: None,
+                                ..Default::default()
+                            });
+                            true
+                        }
                     };
                     if !ok {
                         overflow = true;