Skip to content

A modern terminal with a built-in multiplexer: close it and your sessions keep running. Run shells and tons of AI agents across your machines, then pick them up from desktop, browser, TUI and more. Written in Rust with no UI framework: interface drawn straight on the GPU. No Electron, GPUI or webview.

gui: reuse one persistent uniform buffer for the window and a slot pool for cards

RoversXf7a70adc125f
diff --git a/wezterm-gui/src/termwindow/render/draw.rs b/wezterm-gui/src/termwindow/render/draw.rs
index 7d13df04..2aa79af9 100644
--- a/wezterm-gui/src/termwindow/render/draw.rs
+++ b/wezterm-gui/src/termwindow/render/draw.rs
@@ -269,6 +269,26 @@ pub(crate) fn draw_webgpu_layers(
)
.to_arrays_transposed();
+ // Every non-card pass in this frame uses the same uniform value, so one
+ // persistent slot serves the layer passes and the composite passes alike.
+ let window_uniforms = webgpu.window_uniform(ShaderUniform {
+ foreground_text_hsb,
+ milliseconds,
+ viewport_and_corner: [
+ dimensions.pixel_width as f32,
+ dimensions.pixel_height as f32,
+ corner_radius,
+ 0.0,
+ ],
+ window_border: [
+ window_border.color[0],
+ window_border.color[1],
+ window_border.color[2],
+ window_border.width,
+ ],
+ projection,
+ });
+
// ---- Card texture work -------------------------------------------------
// One combined vertex upload covers every card render pass and every
// composite quad; each draw slices it with `base_vertex`. The uploads
@@ -303,7 +323,7 @@ pub(crate) fn draw_webgpu_layers(
// Render each dirty card's quads into its texture. These passes are
// encoded before the main pass, so the composites below sample the
// fresh picture.
- for pending in cards.pending.iter() {
+ for (card_slot, pending) in cards.pending.iter().enumerate() {
let (base, quads) = (pending.first_vertex, pending.quad_count);
if quads == 0 {
continue;
@@ -329,7 +349,7 @@ pub(crate) fn draw_webgpu_layers(
1.0,
)
.to_arrays();
- let card_uniforms = webgpu.create_uniform(ShaderUniform {
+ let card_uniforms = webgpu.card_uniform(card_slot, ShaderUniform {
foreground_text_hsb,
milliseconds,
viewport_and_corner: [
@@ -377,7 +397,6 @@ pub(crate) fn draw_webgpu_layers(
for idx in 0..3 {
let vb = &layer.vb.borrow()[idx];
let (vertex_count, index_count) = vb.vertex_index_count();
- let uniforms;
if vertex_count > 0 {
let vertices = vb.current_vb_mut();
let mut render_pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
@@ -400,26 +419,8 @@ pub(crate) fn draw_webgpu_layers(
});
cleared = true;
- uniforms = webgpu.create_uniform(ShaderUniform {
- foreground_text_hsb,
- milliseconds,
- viewport_and_corner: [
- dimensions.pixel_width as f32,
- dimensions.pixel_height as f32,
- corner_radius,
- 0.0,
- ],
- window_border: [
- window_border.color[0],
- window_border.color[1],
- window_border.color[2],
- window_border.width,
- ],
- projection,
- });
-
render_pass.set_pipeline(&webgpu.render_pipeline);
- render_pass.set_bind_group(0, &uniforms, &[]);
+ render_pass.set_bind_group(0, &window_uniforms, &[]);
render_pass.set_bind_group(1, &texture_linear_bind_group, &[]);
render_pass.set_bind_group(2, &texture_nearest_bind_group, &[]);
// Upload only the quads this frame actually wrote into the
@@ -450,23 +451,6 @@ pub(crate) fn draw_webgpu_layers(
let scratch = card_scratch
.as_ref()
.expect("composite draws imply the scratch exists");
- let comp_uniforms = webgpu.create_uniform(ShaderUniform {
- foreground_text_hsb,
- milliseconds,
- viewport_and_corner: [
- dimensions.pixel_width as f32,
- dimensions.pixel_height as f32,
- corner_radius,
- 0.0,
- ],
- window_border: [
- window_border.color[0],
- window_border.color[1],
- window_border.color[2],
- window_border.width,
- ],
- projection,
- });
let mut pass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
label: Some("Card Composite Pass"),
color_attachments: &[Some(wgpu::RenderPassColorAttachment {
@@ -487,7 +471,7 @@ pub(crate) fn draw_webgpu_layers(
});
cleared = true;
pass.set_pipeline(&webgpu.render_pipeline);
- pass.set_bind_group(0, &comp_uniforms, &[]);
+ pass.set_bind_group(0, &window_uniforms, &[]);
pass.set_vertex_buffer(0, scratch.vb.slice(..));
pass.set_index_buffer(scratch.index.slice(..), wgpu::IndexFormat::Uint32);
for (zindex, base, composite) in &composite_draws {
diff --git a/wezterm-gui/src/termwindow/webgpu.rs b/wezterm-gui/src/termwindow/webgpu.rs
index c4a56ba7..da06ac7c 100644
--- a/wezterm-gui/src/termwindow/webgpu.rs
+++ b/wezterm-gui/src/termwindow/webgpu.rs
@@ -3,7 +3,6 @@ use anyhow::anyhow;
use config::{ConfigHandle, GpuInfo, WebGpuPowerPreference};
use std::cell::RefCell;
use std::sync::Arc;
-use wgpu::util::DeviceExt;
use window::bitmaps::Texture2d;
use window::raw_window_handle::{
DisplayHandle, HandleError, HasDisplayHandle, HasWindowHandle, RawDisplayHandle,
@@ -33,6 +32,20 @@ pub struct ShaderUniform {
// sampler2D atlas_linear_sampler;
}
+/// A persistent uniform buffer plus its bind group. The buffer is written
+/// at most once per frame, so a slot can be reused every frame without
+/// re-creating either object.
+struct UniformSlot {
+ buffer: wgpu::Buffer,
+ bind_group: wgpu::BindGroup,
+}
+
+#[derive(Default)]
+struct FrameUniforms {
+ window: Option<UniformSlot>,
+ cards: Vec<UniformSlot>,
+}
+
pub struct WebGpuState {
pub adapter_info: wgpu::AdapterInfo,
pub downlevel_caps: wgpu::DownlevelCapabilities,
@@ -46,6 +59,7 @@ pub struct WebGpuState {
pub texture_bind_group_layout: wgpu::BindGroupLayout,
pub texture_nearest_sampler: wgpu::Sampler,
pub texture_linear_sampler: wgpu::Sampler,
+ frame_uniforms: RefCell<FrameUniforms>,
pub handle: RawHandlePair,
}
@@ -645,25 +659,58 @@ impl WebGpuState {
texture_bind_group_layout,
texture_nearest_sampler,
texture_linear_sampler,
+ frame_uniforms: RefCell::new(FrameUniforms::default()),
})
}
- pub fn create_uniform(&self, uniform: ShaderUniform) -> wgpu::BindGroup {
- let buffer = self
- .device
- .create_buffer_init(&wgpu::util::BufferInitDescriptor {
- label: Some("ShaderUniform Buffer"),
- contents: bytemuck::cast_slice(&[uniform]),
- usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
- });
- self.device.create_bind_group(&wgpu::BindGroupDescriptor {
+ fn make_uniform_slot(&self) -> UniformSlot {
+ crate::perf::log_counter("uniform_slot_creates", 1);
+ let buffer = self.device.create_buffer(&wgpu::BufferDescriptor {
+ label: Some("ShaderUniform Buffer"),
+ size: std::mem::size_of::<ShaderUniform>() as u64,
+ usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
+ mapped_at_creation: false,
+ });
+ let bind_group = self.device.create_bind_group(&wgpu::BindGroupDescriptor {
layout: &self.shader_uniform_bind_group_layout,
entries: &[wgpu::BindGroupEntry {
binding: 0,
resource: buffer.as_entire_binding(),
}],
label: Some("ShaderUniform Bind Group"),
- })
+ });
+ UniformSlot { buffer, bind_group }
+ }
+
+ /// The whole-window uniform value; every non-card pass in a frame uses
+ /// the same value, so they all share this one slot.
+ pub fn window_uniform(&self, uniform: ShaderUniform) -> wgpu::BindGroup {
+ let mut frame = self.frame_uniforms.borrow_mut();
+ let slot = match &frame.window {
+ Some(slot) => slot,
+ None => {
+ frame.window = Some(self.make_uniform_slot());
+ frame.window.as_ref().unwrap()
+ }
+ };
+ self.queue
+ .write_buffer(&slot.buffer, 0, bytemuck::bytes_of(&uniform));
+ slot.bind_group.clone()
+ }
+
+ /// Per-card uniform slots. Each slot's buffer may only be written once
+ /// per frame (queued writes all land at the head of the submit), which
+ /// holds because each pending card gets its own slot index.
+ pub fn card_uniform(&self, slot: usize, uniform: ShaderUniform) -> wgpu::BindGroup {
+ let mut frame = self.frame_uniforms.borrow_mut();
+ while frame.cards.len() <= slot {
+ let new_slot = self.make_uniform_slot();
+ frame.cards.push(new_slot);
+ }
+ let slot = &frame.cards[slot];
+ self.queue
+ .write_buffer(&slot.buffer, 0, bytemuck::bytes_of(&uniform));
+ slot.bind_group.clone()
}
#[allow(unused_mut)]