A GameCube/Wii emulator and debugger written in Rust.
draw coalesc, improved shader specialization, ubershader fallback, action batching, improved gx profiler
Layle30379d299279
diff --git a/crates/backend-wgpu/Cargo.toml b/crates/backend-wgpu/Cargo.tomlindex 598571a..6a88e9f 100644--- a/crates/backend-wgpu/Cargo.toml+++ b/crates/backend-wgpu/Cargo.toml@@ -8,6 +8,7 @@ renderdoc-capture = ["dep:renderdoc"]hotpath = ["dep:hotpath", "hotpath/hotpath", "hotpath/crossbeam"]# Write every compiled WGSL shader variant to cache/wgsl/ for debugging.dump-wgsl = []+gx-stats = ["gecko/gx-stats"][dependencies]wgpu = "29.0.3"diff --git a/crates/backend-wgpu/src/action.rs b/crates/backend-wgpu/src/action.rsindex bd4d761..8df9434 100644--- a/crates/backend-wgpu/src/action.rs+++ b/crates/backend-wgpu/src/action.rs@@ -1,5 +1,5 @@-use crate::pipeline::{FullPipelineKey, PipelineKey};-use crate::shader_specialization::{self, ShaderKey};+use crate::pipeline::{FullPipelineKey, PipelineKey, UberPipelineKey};+use crate::shader_specialization::{self, ShaderKey, ShaderSpecializationKey};use crate::{BindGroupCacheKey, DRAW_UNIFORMS_SIZE, DrawUniforms, FRAME_UNIFORMS_SIZE, FrameUniforms, GxRenderer, SamplerKey,helpers,@@ -9,6 +9,8 @@ use gecko::flipper::gx::regs::{CullMode, MagFilter, MinFilter, WrapMode};use gecko::flipper::gx::texture::CopyFormat;use gecko::host::{DrawData, GxAction};use glam::{Mat4, UVec4, Vec4};+#[cfg(feature = "gx-stats")]+use std::sync::atomic::Ordering;fn draw_active_slot_mask(draw: &DrawData) -> u8 {let mut mask: u8 = 0;@@ -246,7 +248,7 @@ impl GxRenderer {self.return_to_pool(tex, view);}self.bind_group_cache.clear();- self.pipeline_cache.clear();+ self.invalidate_pipeline_caches();}#[cfg(not(target_arch = "wasm32"))]GxAction::DumpTextures { dir } => {@@ -278,29 +280,57 @@ impl GxRenderer {let shader_key = ShaderKey::from_draw(draw, self.current_alpha_compare);if !self.shader_cache.contains_key(&shader_key) {+ #[cfg(feature = "gx-stats")]+ let shader_started = std::time::Instant::now();let wgsl = shader_specialization::compile_variant(shader_key);let module = device.create_shader_module(wgpu::ShaderModuleDescriptor {label: Some(&format!("gx_shader_{shader_key:?}")),source: wgpu::ShaderSource::Wgsl(wgsl.into()),});self.shader_cache.insert(shader_key, module);+ #[cfg(feature = "gx-stats")]+ {+ self.stats.shader_modules_created.fetch_add(1, Ordering::Relaxed);+ self.stats+ .shader_create_cpu_ns+ .fetch_add(shader_started.elapsed().as_nanos() as u64, Ordering::Relaxed);+ }tracing::info!(?shader_key, "compiled specialized shader variant");}let pipeline_key = self.current_pipeline_key(draw.ztex_op != 0);let full_key = FullPipelineKey {shader: shader_key,+ specialization: ShaderSpecializationKey::from_draw(draw, self.current_alpha_compare, shader_key),fixed: pipeline_key,};if !self.pipeline_cache.contains_key(&full_key) {- let module = &self.shader_cache[&shader_key];- let pipeline = self.create_pipeline(device, module, &full_key);- self.pipeline_cache.insert(full_key, pipeline);+ let uber_key = UberPipelineKey::from(full_key);+ if !self.uber_pipeline_cache.contains_key(&uber_key) {+ #[cfg(feature = "gx-stats")]+ let pipeline_started = std::time::Instant::now();+ let module = &self.shader_cache[&shader_key];+ let pipeline = crate::pipeline::create_uber_pipeline(+ device,+ &self.pipeline_layout,+ self.surface_format,+ module,+ &uber_key,+ );+ self.uber_pipeline_cache.insert(uber_key, pipeline);+ #[cfg(feature = "gx-stats")]+ {+ self.stats.pipelines_created.fetch_add(1, Ordering::Relaxed);+ self.stats+ .pipeline_create_cpu_ns+ .fetch_add(pipeline_started.elapsed().as_nanos() as u64, Ordering::Relaxed);+ }+ }+ self.request_specialized_pipeline(full_key);}let first_vertex = draw.base_vertex;- let first_index = self.scratch_indices.len() as u32;- let (vertex_count, index_count) = emit_draw_indices(draw, &mut self.scratch_indices);- if vertex_count == 0 {+ let vertex_count = draw.vertex_count;+ if !draw_emits_triangles(draw) {tracing::warn!("draw call produced zero vertices, skipping");return;}@@ -330,15 +360,18 @@ impl GxRenderer {}let draw_uniform = DrawUniforms { mvp, tex_dims };-- let start = self.scratch_draws.len() * draw_stride;- self.scratch_uniform_bytes.resize(start + draw_stride, 0);- self.scratch_uniform_bytes[start..start + draw_struct_size]- .copy_from_slice(bytemuck::bytes_of(&draw_uniform));+ let draw_uniform_bytes = bytemuck::bytes_of(&draw_uniform);+ let bg_key = trim_bg_key(self.current_bind_group_key(), active);+ // Matches the WESL `VsIn` layout gated by+ // `TEXCOORD_N_ENABLED`: 5 fixed attrs (68b) + N texcoord+ // attrs (12 bytes each).+ let stride = 68 + 12 * shader_key.active_texcoords as u32;// Build a fresh FrameUniforms slot only when the producer// signaled state changed since the last draw or this is the// first draw of the flush.+ let frame_bytes_len_before = self.frame_uniform_bytes.len();+ let mut frame_was_pushed = false;let frame_idx = if draw.frame_dirty || self.last_frame_uniform_index.is_none() {let alpha_cmp = self.current_alpha_compare;let frame_uniform = FrameUniforms {@@ -387,38 +420,82 @@ impl GxRenderer {.copy_from_slice(bytemuck::bytes_of(&frame_uniform));let idx = (fstart / frame_stride) as u32;self.last_frame_uniform_index = Some(idx);+ frame_was_pushed = true;idx} else {self.last_frame_uniform_index.unwrap()};- self.draw_pipeline_keys.push(full_key);- self.draw_bg_keys- .push(trim_bg_key(self.current_bind_group_key(), active));- self.draw_viewports.push(self.current_viewport);- self.draw_scissors.push(self.current_scissor);- self.draw_frame_indices.push(frame_idx);- #[cfg(feature = "renderdoc-capture")]- self.draw_primitives.push(draw.primitive);-- // Compute packed vertex stride/offset for this draw. Stride- // matches the WESL `VsIn` layout gated by- // `TEXCOORD_N_ENABLED`: 5 fixed attrs (68b) + N texcoord- // attrs (12 byteroos each).- let stride = 68 + 12 * shader_key.active_texcoords as u32;- let packed_byte_offset = self- .scratch_draws- .last()- .map(|d| d.packed_vertex_byte_offset + d.vertex_count * d.packed_vertex_stride)- .unwrap_or(0);- self.scratch_draws.push(crate::DrawRecord {- src_vertex_index: first_vertex,- vertex_count,- first_index,- index_count,- packed_vertex_byte_offset: packed_byte_offset,- packed_vertex_stride: stride,+ let previous_index = self.scratch_draws.len().checked_sub(1);+ let can_merge = previous_index.is_some_and(|previous| {+ let previous_draw = self.scratch_draws[previous];+ let previous_draw_start = previous * draw_stride;+ previous_draw.src_vertex_index + previous_draw.vertex_count == first_vertex+ && previous_draw.packed_vertex_stride == stride+ && self.draw_pipeline_keys[previous] == full_key+ && self.draw_bg_keys[previous] == bg_key+ && self.draw_viewports[previous] == self.current_viewport+ && self.draw_scissors[previous] == self.current_scissor+ && uniform_slots_equal(+ &self.frame_uniform_bytes,+ frame_stride,+ frame_struct_size,+ self.draw_frame_indices[previous],+ frame_idx,+ )+ && self.scratch_uniform_bytes[previous_draw_start..previous_draw_start + draw_struct_size]+ == *draw_uniform_bytes});++ if let Some(previous) = previous_index.filter(|_| can_merge) {+ let previous_frame_idx = self.draw_frame_indices[previous];+ if frame_was_pushed {+ self.frame_uniform_bytes.truncate(frame_bytes_len_before);+ self.last_frame_uniform_index = Some(previous_frame_idx);+ frame_was_pushed = false;+ }++ let vertex_bias = self.scratch_draws[previous].vertex_count;+ let (_, additional_indices) = emit_draw_indices(draw, &mut self.scratch_indices, vertex_bias);+ let merged = &mut self.scratch_draws[previous];+ merged.vertex_count += vertex_count;+ merged.index_count += additional_indices;+ #[cfg(feature = "renderdoc-capture")]+ {+ self.draw_primitives[previous] = Primitive::Triangles;+ }+ } else {+ let first_index = self.scratch_indices.len() as u32;+ let (_, index_count) = emit_draw_indices(draw, &mut self.scratch_indices, 0);++ let start = self.scratch_draws.len() * draw_stride;+ self.scratch_uniform_bytes.resize(start + draw_stride, 0);+ self.scratch_uniform_bytes[start..start + draw_struct_size].copy_from_slice(draw_uniform_bytes);++ self.draw_pipeline_keys.push(full_key);+ self.draw_bg_keys.push(bg_key);+ self.draw_viewports.push(self.current_viewport);+ self.draw_scissors.push(self.current_scissor);+ self.draw_frame_indices.push(frame_idx);+ #[cfg(feature = "renderdoc-capture")]+ self.draw_primitives.push(draw.primitive);++ let packed_byte_offset = self+ .scratch_draws+ .last()+ .map(|d| d.packed_vertex_byte_offset + d.vertex_count * d.packed_vertex_stride)+ .unwrap_or(0);+ self.scratch_draws.push(crate::DrawRecord {+ src_vertex_index: first_vertex,+ vertex_count,+ first_index,+ index_count,+ packed_vertex_byte_offset: packed_byte_offset,+ packed_vertex_stride: stride,+ });+ }++ debug_assert!(!frame_was_pushed || self.last_frame_uniform_index == Some(frame_idx));}GxAction::CopyXfb {@@ -541,10 +618,21 @@ impl GxRenderer {/// Flush accumulated draw calls into a render pass.pub fn flush_pending_draws(&mut self, device: &wgpu::Device, queue: &wgpu::Queue) {+ self.poll_compiled_pipelines();if self.scratch_draws.is_empty() {return;}+ debug_assert_eq!(self.scratch_draws.len(), self.draw_pipeline_keys.len());+ debug_assert_eq!(self.scratch_draws.len(), self.draw_bg_keys.len());+ debug_assert_eq!(self.scratch_draws.len(), self.draw_viewports.len());+ debug_assert_eq!(self.scratch_draws.len(), self.draw_scissors.len());+ debug_assert_eq!(self.scratch_draws.len(), self.draw_frame_indices.len());+ debug_assert_eq!(+ self.scratch_uniform_bytes.len(),+ self.scratch_draws.len() * self.draw_uniform_stride as usize+ );+if self.draw_bufs_write_pending {self.submit_pending(queue);}@@ -571,6 +659,27 @@ impl GxRenderer {}fn execute_action_render_pass(&mut self, device: &wgpu::Device) {+ #[cfg(feature = "gx-stats")]+ let encode_started = std::time::Instant::now();+ #[cfg(feature = "gx-stats")]+ let mut pipeline_changes = 0u64;+ #[cfg(feature = "gx-stats")]+ let mut viewport_changes = 0u64;+ #[cfg(feature = "gx-stats")]+ let mut scissor_changes = 0u64;+ #[cfg(feature = "gx-stats")]+ let mut bind_groups_created = 0u64;+ #[cfg(feature = "gx-stats")]+ let mut bind_group_key_changes = 0u64;+ #[cfg(feature = "gx-stats")]+ let mut frame_uniform_changes = 0u64;+ #[cfg(feature = "gx-stats")]+ let mut draw_uniform_changes = 0u64;+ #[cfg(feature = "gx-stats")]+ let mut vertex_stride_changes = 0u64;+ #[cfg(feature = "gx-stats")]+ let mut potential_merged_draws = 0u64;+let target_width = self.scaled(crate::EFB_WIDTH);let target_height = self.scaled(crate::EFB_HEIGHT);let scale = self.efb_scale as f32;@@ -651,6 +760,10 @@ impl GxRenderer {})};self.bind_group_cache.insert(self.draw_bg_keys[i].clone(), new_bg);+ #[cfg(feature = "gx-stats")]+ {+ bind_groups_created += 1;+ }}let mut encoder = self.take_or_create_encoder(device);@@ -735,6 +848,16 @@ impl GxRenderer {let mut last_vertex_slice: Option<(u64, u64)> = None;let mut last_viewport: Option<(f32, f32, f32, f32, f32, f32)> = None;let mut last_scissor: Option<(u32, u32, u32, u32)> = None;+ #[cfg(feature = "gx-stats")]+ let mut last_profile_index: Option<usize> = None;+ #[cfg(feature = "gx-stats")]+ let mut last_profile_pipeline_ptr: *const wgpu::RenderPipeline = std::ptr::null();+ #[cfg(feature = "gx-stats")]+ let mut last_profile_viewport: Option<(f32, f32, f32, f32, f32, f32)> = None;+ #[cfg(feature = "gx-stats")]+ let mut last_profile_scissor: Option<(u32, u32, u32, u32)> = None;+ #[cfg(feature = "gx-stats")]+ let mut last_profile_vertex_end: Option<u64> = None;for (index, draw) in self.scratch_draws.iter().copied().enumerate() {let crate::DrawRecord {@@ -764,11 +887,18 @@ impl GxRenderer {rpass.push_debug_group(&draw_label);}let full_key = &self.draw_pipeline_keys[index];- let pipeline = &self.pipeline_cache[full_key];+ let pipeline = self+ .pipeline_cache+ .get(full_key)+ .unwrap_or_else(|| &self.uber_pipeline_cache[&UberPipelineKey::from(*full_key)]);let pipeline_ptr = pipeline as *const wgpu::RenderPipeline;if pipeline_ptr != last_pipeline_ptr {rpass.set_pipeline(pipeline);last_pipeline_ptr = pipeline_ptr;+ #[cfg(feature = "gx-stats")]+ {+ pipeline_changes += 1;+ }}#[cfg(feature = "renderdoc-capture")]@@ -814,6 +944,10 @@ impl GxRenderer {if last_viewport != Some(vp_tuple) {rpass.set_viewport(vp_x, vp_y, vp_w, vp_h, min_d, max_d);last_viewport = Some(vp_tuple);+ #[cfg(feature = "gx-stats")]+ {+ viewport_changes += 1;+ }}} else {tracing::warn!(@@ -834,6 +968,70 @@ impl GxRenderer {if last_scissor != Some(sc_tuple) {rpass.set_scissor_rect(sc_x, sc_y, sc_w, sc_h);last_scissor = Some(sc_tuple);+ #[cfg(feature = "gx-stats")]+ {+ scissor_changes += 1;+ }+ }++ #[cfg(feature = "gx-stats")]+ {+ let draw_stride = self.draw_uniform_stride as usize;+ let draw_size = DRAW_UNIFORMS_SIZE.get() as usize;+ let frame_size = FRAME_UNIFORMS_SIZE.get() as usize;+ let draw_start = index * draw_stride;+ let frame_start = self.draw_frame_indices[index] as usize * frame_stride;++ let (pipeline_same, bind_group_same, frame_uniform_same, draw_uniform_same, stride_same) =+ if let Some(previous) = last_profile_index {+ let previous_draw_start = previous * draw_stride;+ let previous_frame_start = self.draw_frame_indices[previous] as usize * frame_stride;+ (+ pipeline_ptr == last_profile_pipeline_ptr,+ self.draw_bg_keys[index] == self.draw_bg_keys[previous],+ self.draw_frame_indices[index] == self.draw_frame_indices[previous]+ || self.frame_uniform_bytes[frame_start..frame_start + frame_size]+ == self.frame_uniform_bytes+ [previous_frame_start..previous_frame_start + frame_size],+ self.scratch_uniform_bytes[draw_start..draw_start + draw_size]+ == self.scratch_uniform_bytes[previous_draw_start..previous_draw_start + draw_size],+ packed_vertex_stride == self.scratch_draws[previous].packed_vertex_stride,+ )+ } else {+ (false, false, false, false, false)+ };++ if !bind_group_same {+ bind_group_key_changes += 1;+ }+ if !frame_uniform_same {+ frame_uniform_changes += 1;+ }+ if !draw_uniform_same {+ draw_uniform_changes += 1;+ }+ if !stride_same {+ vertex_stride_changes += 1;+ }++ let compatible = last_profile_index.is_some()+ && pipeline_same+ && bind_group_same+ && frame_uniform_same+ && draw_uniform_same+ && stride_same+ && last_profile_viewport == last_viewport+ && last_profile_scissor == Some(sc_tuple)+ && last_profile_vertex_end == Some(vertex_slice_start);+ if !compatible {+ potential_merged_draws += 1;+ }++ last_profile_index = Some(index);+ last_profile_pipeline_ptr = pipeline_ptr;+ last_profile_viewport = last_viewport;+ last_profile_scissor = Some(sc_tuple);+ last_profile_vertex_end = Some(vertex_slice_end);}#[cfg(feature = "renderdoc-capture")]@@ -861,6 +1059,43 @@ impl GxRenderer {self.current_encoder = Some(encoder);self.draw_bufs_write_pending = true;++ #[cfg(feature = "gx-stats")]+ {+ self.stats.draws_encoded.fetch_add(num_draws as u64, Ordering::Relaxed);+ self.stats.draw_render_passes.fetch_add(1, Ordering::Relaxed);+ self.stats+ .pipeline_changes+ .fetch_add(pipeline_changes, Ordering::Relaxed);+ self.stats+ .bind_group_sets+ .fetch_add(num_draws as u64, Ordering::Relaxed);+ self.stats+ .bind_groups_created+ .fetch_add(bind_groups_created, Ordering::Relaxed);+ self.stats+ .bind_group_key_changes+ .fetch_add(bind_group_key_changes, Ordering::Relaxed);+ self.stats+ .frame_uniform_changes+ .fetch_add(frame_uniform_changes, Ordering::Relaxed);+ self.stats+ .draw_uniform_changes+ .fetch_add(draw_uniform_changes, Ordering::Relaxed);+ self.stats+ .vertex_stride_changes+ .fetch_add(vertex_stride_changes, Ordering::Relaxed);+ self.stats+ .potential_merged_draws+ .fetch_add(potential_merged_draws, Ordering::Relaxed);+ self.stats+ .viewport_changes+ .fetch_add(viewport_changes, Ordering::Relaxed);+ self.stats.scissor_changes.fetch_add(scissor_changes, Ordering::Relaxed);+ self.stats+ .draw_pass_encode_ns+ .fetch_add(encode_started.elapsed().as_nanos() as u64, Ordering::Relaxed);+ }}fn ensure_sampler(&mut self, device: &wgpu::Device, key: &SamplerKey) {@@ -877,22 +1112,42 @@ impl GxRenderer {}}-/// Emit indices for a draw whose vertices already live in the renderer's-/// `scratch_vertices` at `[base_vertex .. base_vertex + n]`. Indices are-/// written into `indices_out` as offsets relative to `base_vertex`, since-/// `draw_indexed` is called with `base_vertex` as `first_vertex`. Returns-/// `(vertex_count, index_count)`.-fn emit_draw_indices(draw: &DrawData, indices_out: &mut Vec<u32>) -> (u32, u32) {+fn uniform_slots_equal(bytes: &[u8], stride: usize, size: usize, a: u32, b: u32) -> bool {+ if a == b {+ return true;+ }+ let a = a as usize * stride;+ let b = b as usize * stride;+ bytes[a..a + size] == bytes[b..b + size]+}++fn draw_emits_triangles(draw: &DrawData) -> bool {+ use gecko::flipper::gx::draw::Primitive;++ match draw.primitive {+ Primitive::Triangles | Primitive::TriangleStrip | Primitive::TriangleFan => draw.vertex_count >= 3,+ Primitive::Quads => draw.vertex_count >= 4,+ _ => {+ tracing::error!(?draw.primitive, "draw_emits_triangles: skipping unsupported primitive");+ false+ }+ }+}++fn emit_draw_indices(draw: &DrawData, indices_out: &mut Vec<u32>, vertex_bias: u32) -> (u32, u32) {use gecko::flipper::gx::draw::Primitive;let n = draw.vertex_count;match draw.primitive {- Primitive::Triangles => (n, 0),+ Primitive::Triangles => {+ indices_out.extend((0..n).map(|i| vertex_bias + i));+ (n, n)+ }Primitive::Quads => {let chunks = n / 4;for q in 0..chunks {- let base = q * 4;+ let base = vertex_bias + q * 4;indices_out.extend_from_slice(&[base, base + 1, base + 2, base, base + 2, base + 3]);}(n, chunks * 6)@@ -901,12 +1156,13 @@ fn emit_draw_indices(draw: &DrawData, indices_out: &mut Vec<u32>) -> (u32, u32)if n < 3 {return (0, 0);}+let tris = n - 2;for i in 0..tris {if i & 1 == 0 {- indices_out.extend_from_slice(&[i, i + 1, i + 2]);+ indices_out.extend_from_slice(&[vertex_bias + i, vertex_bias + i + 1, vertex_bias + i + 2]);} else {- indices_out.extend_from_slice(&[i + 1, i, i + 2]);+ indices_out.extend_from_slice(&[vertex_bias + i + 1, vertex_bias + i, vertex_bias + i + 2]);}}(n, tris * 3)@@ -915,9 +1171,10 @@ fn emit_draw_indices(draw: &DrawData, indices_out: &mut Vec<u32>) -> (u32, u32)if n < 3 {return (0, 0);}+let tris = n - 2;for i in 0..tris {- indices_out.extend_from_slice(&[0, i + 1, i + 2]);+ indices_out.extend_from_slice(&[vertex_bias, vertex_bias + i + 1, vertex_bias + i + 2]);}(n, tris * 3)}diff --git a/crates/backend-wgpu/src/lib.rs b/crates/backend-wgpu/src/lib.rsindex 2f3fc19..d4a3f8f 100644--- a/crates/backend-wgpu/src/lib.rs+++ b/crates/backend-wgpu/src/lib.rs@@ -19,13 +19,96 @@ use gecko::flipper::gx::regs::{AlphaCompare, BlendMode, CompareFunc, CullMode, Muse gecko::host::TextureKey;use glam::Mat4;-use pipeline::FullPipelineKey;+use pipeline::{FullPipelineKey, UberPipelineKey};use rustc_hash::FxHashMap;+#[cfg(not(target_arch = "wasm32"))]+use rustc_hash::FxHashSet;use shader_specialization::ShaderKey;use std::num::NonZeroU64;+#[cfg(feature = "gx-stats")]+use std::sync::{+ Arc,+ atomic::{AtomicU64, Ordering},+};pub(crate) type GpuVertex = gecko::host::DrawVertex;+#[cfg(feature = "gx-stats")]+#[derive(Default)]+pub(crate) struct RendererStats {+ pub(crate) actions_sent: AtomicU64,+ pub(crate) batches_sent: AtomicU64,+ pub(crate) channel_high_water: AtomicU64,+ pub(crate) queue_wait_ns: AtomicU64,+ pub(crate) efb_drain_wait_ns: AtomicU64,+ pub(crate) efb_drain_requests: AtomicU64,+ pub(crate) efb_drain_nonempty: AtomicU64,+ pub(crate) efb_writebacks: AtomicU64,+ pub(crate) efb_writeback_cpu_ns: AtomicU64,+ pub(crate) worker_batch_cpu_ns: AtomicU64,+ pub(crate) draws_encoded: AtomicU64,+ pub(crate) draw_render_passes: AtomicU64,+ pub(crate) pipeline_changes: AtomicU64,+ pub(crate) pipelines_created: AtomicU64,+ pub(crate) pipeline_create_cpu_ns: AtomicU64,+ pub(crate) shader_modules_created: AtomicU64,+ pub(crate) shader_create_cpu_ns: AtomicU64,+ pub(crate) bind_group_sets: AtomicU64,+ pub(crate) bind_groups_created: AtomicU64,+ pub(crate) bind_group_key_changes: AtomicU64,+ pub(crate) frame_uniform_changes: AtomicU64,+ pub(crate) draw_uniform_changes: AtomicU64,+ pub(crate) vertex_stride_changes: AtomicU64,+ pub(crate) potential_merged_draws: AtomicU64,+ pub(crate) viewport_changes: AtomicU64,+ pub(crate) scissor_changes: AtomicU64,+ pub(crate) draw_pass_encode_ns: AtomicU64,+ pub(crate) queue_submits: AtomicU64,+ pub(crate) command_buffers_submitted: AtomicU64,+ pub(crate) queue_submit_cpu_ns: AtomicU64,+}++#[cfg(feature = "gx-stats")]+impl RendererStats {+ pub(crate) fn snapshot(&self, channel_len: usize, channel_cap: usize) -> gecko::host::RenderStats {+ let load = |counter: &AtomicU64| counter.load(Ordering::Relaxed);+ gecko::host::RenderStats {+ actions_sent: load(&self.actions_sent),+ batches_sent: load(&self.batches_sent),+ channel_len,+ channel_cap,+ channel_high_water: load(&self.channel_high_water) as usize,+ queue_wait_ns: load(&self.queue_wait_ns),+ efb_drain_wait_ns: load(&self.efb_drain_wait_ns),+ efb_drain_requests: load(&self.efb_drain_requests),+ efb_drain_nonempty: load(&self.efb_drain_nonempty),+ efb_writebacks: load(&self.efb_writebacks),+ efb_writeback_cpu_ns: load(&self.efb_writeback_cpu_ns),+ worker_batch_cpu_ns: load(&self.worker_batch_cpu_ns),+ draws_encoded: load(&self.draws_encoded),+ draw_render_passes: load(&self.draw_render_passes),+ pipeline_changes: load(&self.pipeline_changes),+ pipelines_created: load(&self.pipelines_created),+ pipeline_create_cpu_ns: load(&self.pipeline_create_cpu_ns),+ shader_modules_created: load(&self.shader_modules_created),+ shader_create_cpu_ns: load(&self.shader_create_cpu_ns),+ bind_group_sets: load(&self.bind_group_sets),+ bind_groups_created: load(&self.bind_groups_created),+ bind_group_key_changes: load(&self.bind_group_key_changes),+ frame_uniform_changes: load(&self.frame_uniform_changes),+ draw_uniform_changes: load(&self.draw_uniform_changes),+ vertex_stride_changes: load(&self.vertex_stride_changes),+ potential_merged_draws: load(&self.potential_merged_draws),+ viewport_changes: load(&self.viewport_changes),+ scissor_changes: load(&self.scissor_changes),+ draw_pass_encode_ns: load(&self.draw_pass_encode_ns),+ queue_submits: load(&self.queue_submits),+ command_buffers_submitted: load(&self.command_buffers_submitted),+ queue_submit_cpu_ns: load(&self.queue_submit_cpu_ns),+ }+ }+}+pub(crate) fn align_up(value: u64, alignment: u64) -> u64 {(value + alignment - 1) & !(alignment - 1)}@@ -175,8 +258,17 @@ pub(crate) struct DrawBufferLayout {}pub struct GxRenderer {+ #[cfg(feature = "gx-stats")]+ pub(crate) stats: Arc<RendererStats>,pub(crate) pipeline_cache: FxHashMap<FullPipelineKey, wgpu::RenderPipeline>,+ pub(crate) uber_pipeline_cache: FxHashMap<UberPipelineKey, wgpu::RenderPipeline>,pub(crate) shader_cache: FxHashMap<ShaderKey, wgpu::ShaderModule>,+ #[cfg(not(target_arch = "wasm32"))]+ pub(crate) pipeline_compiler: pipeline::PipelineCompiler,+ #[cfg(not(target_arch = "wasm32"))]+ pub(crate) pending_pipeline_keys: FxHashSet<FullPipelineKey>,+ #[cfg(not(target_arch = "wasm32"))]+ pub(crate) pipeline_generation: u64,pub(crate) pipeline_layout: wgpu::PipelineLayout,pub(crate) surface_format: wgpu::TextureFormat,pub(crate) bind_group_layout: wgpu::BindGroupLayout,@@ -784,10 +876,24 @@ impl GxRenderer {let pipeline_cache: FxHashMap<pipeline::FullPipelineKey, wgpu::RenderPipeline> =FxHashMap::with_capacity_and_hasher(64, Default::default());+ let uber_pipeline_cache: FxHashMap<pipeline::UberPipelineKey, wgpu::RenderPipeline> =+ FxHashMap::with_capacity_and_hasher(64, Default::default());+ #[cfg(not(target_arch = "wasm32"))]+ let pipeline_compiler =+ pipeline::PipelineCompiler::new(device.clone(), pipeline_layout.clone(), surface_format);GxRenderer {+ #[cfg(feature = "gx-stats")]+ stats: Arc::new(RendererStats::default()),pipeline_cache,+ uber_pipeline_cache,shader_cache,+ #[cfg(not(target_arch = "wasm32"))]+ pipeline_compiler,+ #[cfg(not(target_arch = "wasm32"))]+ pending_pipeline_keys: FxHashSet::default(),+ #[cfg(not(target_arch = "wasm32"))]+ pipeline_generation: 0,pipeline_layout,surface_format,bind_group_layout,@@ -957,8 +1063,24 @@ impl GxRenderer {return;}+ #[cfg(feature = "gx-stats")]+ let command_buffer_count = self.pending_command_buffers.len() as u64;+ #[cfg(feature = "gx-stats")]+ let submit_started = std::time::Instant::now();+queue.submit(self.pending_command_buffers.drain(..));+ #[cfg(feature = "gx-stats")]+ {+ self.stats.queue_submits.fetch_add(1, Ordering::Relaxed);+ self.stats+ .command_buffers_submitted+ .fetch_add(command_buffer_count, Ordering::Relaxed);+ self.stats+ .queue_submit_cpu_ns+ .fetch_add(submit_started.elapsed().as_nanos() as u64, Ordering::Relaxed);+ }+self.draw_bufs_write_pending = false;self.xfb_copy_uniform_write_pending = false;self.efb_color_readback_uniform_write_pending = false;@@ -1107,6 +1229,44 @@ impl GxRenderer {Ok(keys.len())}+ #[cfg(not(target_arch = "wasm32"))]+ pub(crate) fn poll_compiled_pipelines(&mut self) {+ while let Some(result) = self.pipeline_compiler.try_recv() {+ if result.generation != self.pipeline_generation {+ continue;+ }+ self.pending_pipeline_keys.remove(&result.key);+ self.pipeline_cache.insert(result.key, result.pipeline);+ }+ }++ #[cfg(target_arch = "wasm32")]+ pub(crate) fn poll_compiled_pipelines(&mut self) {}++ #[cfg(not(target_arch = "wasm32"))]+ pub(crate) fn request_specialized_pipeline(&mut self, key: FullPipelineKey) {+ if self.pipeline_cache.contains_key(&key) || self.pending_pipeline_keys.contains(&key) {+ return;+ }+ let shader = self.shader_cache[&key.shader].clone();+ if self.pipeline_compiler.request(self.pipeline_generation, key, shader) {+ self.pending_pipeline_keys.insert(key);+ }+ }++ #[cfg(target_arch = "wasm32")]+ pub(crate) fn request_specialized_pipeline(&mut self, _key: FullPipelineKey) {}++ pub(crate) fn invalidate_pipeline_caches(&mut self) {+ self.pipeline_cache.clear();+ self.uber_pipeline_cache.clear();+ #[cfg(not(target_arch = "wasm32"))]+ {+ self.pipeline_generation = self.pipeline_generation.wrapping_add(1);+ self.pending_pipeline_keys.clear();+ }+ }+pub fn prewarm_pipeline_cache(&mut self, device: &wgpu::Device) {let path = std::path::Path::new(pipeline::PIPELINE_CACHE_PATH);let keys: Vec<pipeline::FullPipelineKey> = pipeline::load_cached_pipeline_keys(path)@@ -1141,7 +1301,16 @@ impl GxRenderer {.iter().map(|&k| {let module = &self_ref.shader_cache[&k.shader];- (k, self_ref.create_pipeline(device, module, &k))+ (+ k,+ pipeline::create_specialized_pipeline(+ device,+ &self_ref.pipeline_layout,+ self_ref.surface_format,+ module,+ &k,+ ),+ )}).collect::<Vec<_>>()})@@ -1156,7 +1325,16 @@ impl GxRenderer {.iter().map(|&k| {let module = &self.shader_cache[&k.shader];- (k, self.create_pipeline(device, module, &k))+ (+ k,+ pipeline::create_specialized_pipeline(+ device,+ &self.pipeline_layout,+ self.surface_format,+ module,+ &k,+ ),+ )}).collect();diff --git a/crates/backend-wgpu/src/pipeline.rs b/crates/backend-wgpu/src/pipeline.rsindex 2f1ab5a..bf1c7a5 100644--- a/crates/backend-wgpu/src/pipeline.rs+++ b/crates/backend-wgpu/src/pipeline.rs@@ -1,5 +1,7 @@-use crate::shader_specialization::{KEY_BYTES as SHADER_KEY_BYTES, ShaderKey};-use crate::{GxRenderer, helpers};+use crate::helpers;+use crate::shader_specialization::{+ KEY_BYTES as SHADER_KEY_BYTES, SPECIALIZATION_KEY_BYTES, ShaderKey, ShaderSpecializationKey,+};use chapa::BitField;use gecko::flipper::gx::regs::{BlendFactor, CompareFunc, CullMode, LogicOp};@@ -107,10 +109,26 @@ impl PipelineKey {#[derive(Clone, Copy, Hash, PartialEq, Eq)]pub(crate) struct FullPipelineKey {pub shader: ShaderKey,+ pub specialization: ShaderSpecializationKey,pub fixed: PipelineKey,}-pub(crate) const FULL_PIPELINE_KEY_BYTES: usize = SHADER_KEY_BYTES + PipelineKey::BYTES;+#[derive(Clone, Copy, Hash, PartialEq, Eq)]+pub(crate) struct UberPipelineKey {+ pub shader: ShaderKey,+ pub fixed: PipelineKey,+}++impl From<FullPipelineKey> for UberPipelineKey {+ fn from(key: FullPipelineKey) -> Self {+ Self {+ shader: key.shader,+ fixed: key.fixed,+ }+ }+}++pub(crate) const FULL_PIPELINE_KEY_BYTES: usize = SHADER_KEY_BYTES + SPECIALIZATION_KEY_BYTES + PipelineKey::BYTES;const PIPELINE_CACHE_MAGIC: [u8; 4] = *b"GPKC";const PIPELINE_CACHE_VERSION: u32 = crate::shader_specialization::CACHE_VERSION;pub(crate) const PIPELINE_CACHE_PATH: &str = "cache/pipeline_keys.bin";@@ -119,7 +137,9 @@ impl FullPipelineKey {fn to_bytes(self) -> [u8; FULL_PIPELINE_KEY_BYTES] {let mut out = [0u8; FULL_PIPELINE_KEY_BYTES];out[..SHADER_KEY_BYTES].copy_from_slice(&self.shader.to_bytes());- out[SHADER_KEY_BYTES..].copy_from_slice(&self.fixed.to_bytes());+ out[SHADER_KEY_BYTES..SHADER_KEY_BYTES + SPECIALIZATION_KEY_BYTES]+ .copy_from_slice(&self.specialization.to_bytes());+ out[SHADER_KEY_BYTES + SPECIALIZATION_KEY_BYTES..].copy_from_slice(&self.fixed.to_bytes());out}@@ -127,11 +147,15 @@ impl FullPipelineKey {let mut shader_bytes = [0u8; SHADER_KEY_BYTES];shader_bytes.copy_from_slice(&b[..SHADER_KEY_BYTES]);+ let mut specialization_bytes = [0u8; SPECIALIZATION_KEY_BYTES];+ specialization_bytes.copy_from_slice(&b[SHADER_KEY_BYTES..SHADER_KEY_BYTES + SPECIALIZATION_KEY_BYTES]);+let mut fixed_bytes = [0u8; PipelineKey::BYTES];- fixed_bytes.copy_from_slice(&b[SHADER_KEY_BYTES..]);+ fixed_bytes.copy_from_slice(&b[SHADER_KEY_BYTES + SPECIALIZATION_KEY_BYTES..]);Self {shader: ShaderKey::from_bytes(&shader_bytes),+ specialization: ShaderSpecializationKey::from_bytes(&specialization_bytes),fixed: PipelineKey::from_bytes(&fixed_bytes),}}@@ -186,155 +210,298 @@ pub(crate) fn save_pipeline_keys(path: &Path, keys: &[FullPipelineKey]) -> std::Ok(())}-impl GxRenderer {- pub(crate) fn create_pipeline(- &self,- device: &wgpu::Device,- shader: &wgpu::ShaderModule,- full_key: &FullPipelineKey,- ) -> wgpu::RenderPipeline {- let key = &full_key.fixed;- let active_texcoords = full_key.shader.active_texcoords.min(8) as usize;-- const BASE_ATTRS: [wgpu::VertexAttribute; 5] = [- wgpu::VertexAttribute {- format: wgpu::VertexFormat::Float32x3,- offset: 0,- shader_location: 0,- },- wgpu::VertexAttribute {- format: wgpu::VertexFormat::Float32x4,- offset: 12,- shader_location: 1,- },- wgpu::VertexAttribute {- format: wgpu::VertexFormat::Float32x4,- offset: 28,- shader_location: 2,- },- wgpu::VertexAttribute {- format: wgpu::VertexFormat::Float32x3,- offset: 44,- shader_location: 3,- },- wgpu::VertexAttribute {- format: wgpu::VertexFormat::Float32x3,- offset: 56,- shader_location: 4,- },- ];+pub(crate) fn create_specialized_pipeline(+ device: &wgpu::Device,+ pipeline_layout: &wgpu::PipelineLayout,+ surface_format: wgpu::TextureFormat,+ shader: &wgpu::ShaderModule,+ full_key: &FullPipelineKey,+) -> wgpu::RenderPipeline {+ let constants = full_key.specialization.pipeline_constants(full_key.shader);+ create_pipeline(+ device,+ pipeline_layout,+ surface_format,+ shader,+ full_key.shader,+ &full_key.fixed,+ &constants,+ "gx_pipeline_specialized",+ )+}- let mut attrs: Vec<wgpu::VertexAttribute> = Vec::with_capacity(5 + active_texcoords);- attrs.extend_from_slice(&BASE_ATTRS);+pub(crate) fn create_uber_pipeline(+ device: &wgpu::Device,+ pipeline_layout: &wgpu::PipelineLayout,+ surface_format: wgpu::TextureFormat,+ shader: &wgpu::ShaderModule,+ key: &UberPipelineKey,+) -> wgpu::RenderPipeline {+ create_pipeline(+ device,+ pipeline_layout,+ surface_format,+ shader,+ key.shader,+ &key.fixed,+ &[("gx_ubershader", 1.0)],+ "gx_pipeline_uber",+ )+}- for i in 0..active_texcoords {- attrs.push(wgpu::VertexAttribute {- format: wgpu::VertexFormat::Float32x3,- offset: 68 + (i as u64) * 12,- shader_location: 5 + i as u32,- });- }+#[allow(clippy::too_many_arguments)]+fn create_pipeline(+ device: &wgpu::Device,+ pipeline_layout: &wgpu::PipelineLayout,+ surface_format: wgpu::TextureFormat,+ shader: &wgpu::ShaderModule,+ shader_key: ShaderKey,+ key: &PipelineKey,+ constants: &[(&str, f64)],+ label: &str,+) -> wgpu::RenderPipeline {+ let active_texcoords = shader_key.active_texcoords.min(8) as usize;++ const BASE_ATTRS: [wgpu::VertexAttribute; 5] = [+ wgpu::VertexAttribute {+ format: wgpu::VertexFormat::Float32x3,+ offset: 0,+ shader_location: 0,+ },+ wgpu::VertexAttribute {+ format: wgpu::VertexFormat::Float32x4,+ offset: 12,+ shader_location: 1,+ },+ wgpu::VertexAttribute {+ format: wgpu::VertexFormat::Float32x4,+ offset: 28,+ shader_location: 2,+ },+ wgpu::VertexAttribute {+ format: wgpu::VertexFormat::Float32x3,+ offset: 44,+ shader_location: 3,+ },+ wgpu::VertexAttribute {+ format: wgpu::VertexFormat::Float32x3,+ offset: 56,+ shader_location: 4,+ },+ ];++ let mut attrs: Vec<wgpu::VertexAttribute> = Vec::with_capacity(5 + active_texcoords);+ attrs.extend_from_slice(&BASE_ATTRS);++ for i in 0..active_texcoords {+ attrs.push(wgpu::VertexAttribute {+ format: wgpu::VertexFormat::Float32x3,+ offset: 68 + (i as u64) * 12,+ shader_location: 5 + i as u32,+ });+ }- let vertex_layout = wgpu::VertexBufferLayout {- array_stride: 68 + (active_texcoords as u64) * 12,- step_mode: wgpu::VertexStepMode::Vertex,- attributes: &attrs,- };+ let vertex_layout = wgpu::VertexBufferLayout {+ array_stride: 68 + (active_texcoords as u64) * 12,+ step_mode: wgpu::VertexStepMode::Vertex,+ attributes: &attrs,+ };- let blend = if key.blend_enable {- // In subtract mode the hardware ignores the configured src/dst- // factors and computes `dst = dst - src` with ONE/ONE.- let (src_factor, dst_factor, operation) = if key.subtract {- (- wgpu::BlendFactor::One,- wgpu::BlendFactor::One,- wgpu::BlendOperation::ReverseSubtract,- )- } else {- (- helpers::map_src_blend_factor(key.src_factor),- helpers::map_dst_blend_factor(key.dst_factor),- wgpu::BlendOperation::Add,- )- };- Some(make_blend_state(src_factor, dst_factor, operation))- } else if key.logic_op_enable {- let (be, sub, sf, df) = logic_op_approximation(key.logic_op);- be.then(|| {- let operation = if sub {- wgpu::BlendOperation::ReverseSubtract- } else {- wgpu::BlendOperation::Add- };- make_blend_state(sf, df, operation)- })+ let blend = if key.blend_enable {+ // In subtract mode the hardware ignores the configured src/dst+ // factors and computes `dst = dst - src` with ONE/ONE.+ let (src_factor, dst_factor, operation) = if key.subtract {+ (+ wgpu::BlendFactor::One,+ wgpu::BlendFactor::One,+ wgpu::BlendOperation::ReverseSubtract,+ )} else {- None+ (+ helpers::map_src_blend_factor(key.src_factor),+ helpers::map_dst_blend_factor(key.dst_factor),+ wgpu::BlendOperation::Add,+ )};+ Some(make_blend_state(src_factor, dst_factor, operation))+ } else if key.logic_op_enable {+ let (be, sub, sf, df) = logic_op_approximation(key.logic_op);+ be.then(|| {+ let operation = if sub {+ wgpu::BlendOperation::ReverseSubtract+ } else {+ wgpu::BlendOperation::Add+ };+ make_blend_state(sf, df, operation)+ })+ } else {+ None+ };- let depth_stencil = if key.z_enable {- Some(wgpu::DepthStencilState {- format: wgpu::TextureFormat::Depth24Plus,- depth_write_enabled: Some(key.z_write),- depth_compare: Some(helpers::map_compare_func(key.z_func)),- stencil: wgpu::StencilState::default(),- bias: wgpu::DepthBiasState::default(),- })- } else {- Some(wgpu::DepthStencilState {- format: wgpu::TextureFormat::Depth24Plus,- depth_write_enabled: Some(false),- depth_compare: Some(wgpu::CompareFunction::Always),- stencil: wgpu::StencilState::default(),- bias: wgpu::DepthBiasState::default(),- })- };+ let depth_stencil = if key.z_enable {+ Some(wgpu::DepthStencilState {+ format: wgpu::TextureFormat::Depth24Plus,+ depth_write_enabled: Some(key.z_write),+ depth_compare: Some(helpers::map_compare_func(key.z_func)),+ stencil: wgpu::StencilState::default(),+ bias: wgpu::DepthBiasState::default(),+ })+ } else {+ Some(wgpu::DepthStencilState {+ format: wgpu::TextureFormat::Depth24Plus,+ depth_write_enabled: Some(false),+ depth_compare: Some(wgpu::CompareFunction::Always),+ stencil: wgpu::StencilState::default(),+ bias: wgpu::DepthBiasState::default(),+ })+ };- let mut write_mask = wgpu::ColorWrites::empty();- if key.color_update {- write_mask |= wgpu::ColorWrites::RED | wgpu::ColorWrites::GREEN | wgpu::ColorWrites::BLUE;- }- if key.alpha_update {- write_mask |= wgpu::ColorWrites::ALPHA;- }+ let mut write_mask = wgpu::ColorWrites::empty();+ if key.color_update {+ write_mask |= wgpu::ColorWrites::RED | wgpu::ColorWrites::GREEN | wgpu::ColorWrites::BLUE;+ }+ if key.alpha_update {+ write_mask |= wgpu::ColorWrites::ALPHA;+ }- device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {- label: Some("gx_pipeline"),- layout: Some(&self.pipeline_layout),- vertex: wgpu::VertexState {- module: shader,- entry_point: Some("vs_main"),- buffers: &[vertex_layout],- compilation_options: Default::default(),+ device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {+ label: Some(label),+ layout: Some(pipeline_layout),+ vertex: wgpu::VertexState {+ module: shader,+ entry_point: Some("vs_main"),+ buffers: &[vertex_layout],+ compilation_options: wgpu::PipelineCompilationOptions {+ constants,+ ..Default::default()},- fragment: Some(wgpu::FragmentState {- module: shader,- entry_point: Some(if key.ztex { "fs_main_ztex" } else { "fs_main" }),- targets: &[Some(wgpu::ColorTargetState {- format: self.surface_format,- blend,- write_mask,- })],- compilation_options: Default::default(),- }),- primitive: wgpu::PrimitiveState {- topology: wgpu::PrimitiveTopology::TriangleList,- front_face: wgpu::FrontFace::Cw,- cull_mode: match key.cull_mode {- CullMode::Back => Some(wgpu::Face::Back),- CullMode::Front => Some(wgpu::Face::Front),- CullMode::None | CullMode::All => None,- },+ },+ fragment: Some(wgpu::FragmentState {+ module: shader,+ entry_point: Some(if key.ztex { "fs_main_ztex" } else { "fs_main" }),+ targets: &[Some(wgpu::ColorTargetState {+ format: surface_format,+ blend,+ write_mask,+ })],+ compilation_options: wgpu::PipelineCompilationOptions {+ constants,..Default::default()},- depth_stencil,- multisample: wgpu::MultisampleState {- count: crate::EFB_SAMPLE_COUNT,- mask: !0,- alpha_to_coverage_enabled: false,+ }),+ primitive: wgpu::PrimitiveState {+ topology: wgpu::PrimitiveTopology::TriangleList,+ front_face: wgpu::FrontFace::Cw,+ cull_mode: match key.cull_mode {+ CullMode::Back => Some(wgpu::Face::Back),+ CullMode::Front => Some(wgpu::Face::Front),+ CullMode::None | CullMode::All => None,},- multiview_mask: None,- cache: None,- })+ ..Default::default()+ },+ depth_stencil,+ multisample: wgpu::MultisampleState {+ count: crate::EFB_SAMPLE_COUNT,+ mask: !0,+ alpha_to_coverage_enabled: false,+ },+ multiview_mask: None,+ cache: None,+ })+}++#[cfg(not(target_arch = "wasm32"))]+pub(crate) struct PipelineCompiler {+ request_tx: crossbeam_channel::Sender<PipelineCompileRequest>,+ result_rx: crossbeam_channel::Receiver<PipelineCompileResult>,+ shutdown_tx: crossbeam_channel::Sender<()>,+ thread: Option<std::thread::JoinHandle<()>>,+}++#[cfg(not(target_arch = "wasm32"))]+struct PipelineCompileRequest {+ generation: u64,+ key: FullPipelineKey,+ shader: wgpu::ShaderModule,+}++#[cfg(not(target_arch = "wasm32"))]+pub(crate) struct PipelineCompileResult {+ pub generation: u64,+ pub key: FullPipelineKey,+ pub pipeline: wgpu::RenderPipeline,+}++#[cfg(not(target_arch = "wasm32"))]+impl PipelineCompiler {+ const QUEUE_LIMIT: usize = 64;++ pub(crate) fn new(+ device: wgpu::Device,+ pipeline_layout: wgpu::PipelineLayout,+ surface_format: wgpu::TextureFormat,+ ) -> Self {+ let (request_tx, request_rx) = crossbeam_channel::bounded::<PipelineCompileRequest>(Self::QUEUE_LIMIT);+ let (result_tx, result_rx) = crossbeam_channel::unbounded::<PipelineCompileResult>();+ let (shutdown_tx, shutdown_rx) = crossbeam_channel::bounded::<()>(1);+ let thread = std::thread::Builder::new()+ .name("gx pipeline compiler".into())+ .spawn(move || {+ loop {+ crossbeam_channel::select_biased! {+ recv(shutdown_rx) -> _ => break,+ recv(request_rx) -> request => {+ let Ok(request) = request else { break };+ let pipeline = create_specialized_pipeline(+ &device,+ &pipeline_layout,+ surface_format,+ &request.shader,+ &request.key,+ );+ let result = PipelineCompileResult {+ generation: request.generation,+ key: request.key,+ pipeline,+ };+ if result_tx.send(result).is_err() {+ break;+ }+ }+ }+ }+ })+ .expect("failed to start GX pipeline compiler");++ Self {+ request_tx,+ result_rx,+ shutdown_tx,+ thread: Some(thread),+ }+ }++ pub(crate) fn request(&self, generation: u64, key: FullPipelineKey, shader: wgpu::ShaderModule) -> bool {+ self.request_tx+ .try_send(PipelineCompileRequest {+ generation,+ key,+ shader,+ })+ .is_ok()+ }++ pub(crate) fn try_recv(&self) -> Option<PipelineCompileResult> {+ self.result_rx.try_recv().ok()+ }+}++#[cfg(not(target_arch = "wasm32"))]+impl Drop for PipelineCompiler {+ fn drop(&mut self) {+ let _ = self.shutdown_tx.try_send(());+ if let Some(thread) = self.thread.take() {+ let _ = thread.join();+ }}}diff --git a/crates/backend-wgpu/src/shader_specialization.rs b/crates/backend-wgpu/src/shader_specialization.rsindex 57eb53e..1f7e6b5 100644--- a/crates/backend-wgpu/src/shader_specialization.rs+++ b/crates/backend-wgpu/src/shader_specialization.rs@@ -14,8 +14,9 @@ const LIGHTING_WESL: &str = include_str!("shaders/lighting.wesl");const MAIN_WESL: &str = include_str!("shaders/main.wesl");pub(crate) const KEY_BYTES: usize = 6;+pub(crate) const SPECIALIZATION_KEY_BYTES: usize = 82 * size_of::<u32>();const CACHE_MAGIC: [u8; 4] = *b"GSKC";-pub(crate) const CACHE_VERSION: u32 = 7;+pub(crate) const CACHE_VERSION: u32 = 8;pub(crate) const SHADER_CACHE_PATH: &str = "cache/shader_keys.bin";#[derive(Clone, Copy, Hash, PartialEq, Eq, Debug)]@@ -28,6 +29,283 @@ pub(crate) struct ShaderKey {pub active_texcoords: u8,}+#[derive(Clone, Copy, Hash, PartialEq, Eq, Debug, Default)]+pub(crate) struct ShaderSpecializationKey {+ pub tev_color_env: [u32; 16],+ pub tev_alpha_env: [u32; 16],+ pub tev_orders: [u32; 16],+ pub tev_ksel: [u32; 8],+ pub indirect_refs: u32,+ pub tev_indirect: [u32; 16],+ pub color_ctrl: [u32; 2],+ pub alpha_ctrl: [u32; 2],+ pub alpha_comp0: u32,+ pub alpha_comp1: u32,+ pub alpha_op: u32,+ pub ztex_type: u32,+ pub ztex_op: u32,+}++const TEV_COLOR_ENV_NAMES: [&str; 16] = [+ "gx_tev_color_env_0",+ "gx_tev_color_env_1",+ "gx_tev_color_env_2",+ "gx_tev_color_env_3",+ "gx_tev_color_env_4",+ "gx_tev_color_env_5",+ "gx_tev_color_env_6",+ "gx_tev_color_env_7",+ "gx_tev_color_env_8",+ "gx_tev_color_env_9",+ "gx_tev_color_env_10",+ "gx_tev_color_env_11",+ "gx_tev_color_env_12",+ "gx_tev_color_env_13",+ "gx_tev_color_env_14",+ "gx_tev_color_env_15",+];+const TEV_ALPHA_ENV_NAMES: [&str; 16] = [+ "gx_tev_alpha_env_0",+ "gx_tev_alpha_env_1",+ "gx_tev_alpha_env_2",+ "gx_tev_alpha_env_3",+ "gx_tev_alpha_env_4",+ "gx_tev_alpha_env_5",+ "gx_tev_alpha_env_6",+ "gx_tev_alpha_env_7",+ "gx_tev_alpha_env_8",+ "gx_tev_alpha_env_9",+ "gx_tev_alpha_env_10",+ "gx_tev_alpha_env_11",+ "gx_tev_alpha_env_12",+ "gx_tev_alpha_env_13",+ "gx_tev_alpha_env_14",+ "gx_tev_alpha_env_15",+];+const TEV_ORDER_NAMES: [&str; 16] = [+ "gx_tev_order_0",+ "gx_tev_order_1",+ "gx_tev_order_2",+ "gx_tev_order_3",+ "gx_tev_order_4",+ "gx_tev_order_5",+ "gx_tev_order_6",+ "gx_tev_order_7",+ "gx_tev_order_8",+ "gx_tev_order_9",+ "gx_tev_order_10",+ "gx_tev_order_11",+ "gx_tev_order_12",+ "gx_tev_order_13",+ "gx_tev_order_14",+ "gx_tev_order_15",+];+const TEV_KSEL_NAMES: [&str; 8] = [+ "gx_tev_ksel_0",+ "gx_tev_ksel_1",+ "gx_tev_ksel_2",+ "gx_tev_ksel_3",+ "gx_tev_ksel_4",+ "gx_tev_ksel_5",+ "gx_tev_ksel_6",+ "gx_tev_ksel_7",+];+const TEV_INDIRECT_NAMES: [&str; 16] = [+ "gx_tev_indirect_0",+ "gx_tev_indirect_1",+ "gx_tev_indirect_2",+ "gx_tev_indirect_3",+ "gx_tev_indirect_4",+ "gx_tev_indirect_5",+ "gx_tev_indirect_6",+ "gx_tev_indirect_7",+ "gx_tev_indirect_8",+ "gx_tev_indirect_9",+ "gx_tev_indirect_10",+ "gx_tev_indirect_11",+ "gx_tev_indirect_12",+ "gx_tev_indirect_13",+ "gx_tev_indirect_14",+ "gx_tev_indirect_15",+];++impl ShaderSpecializationKey {+ pub(crate) fn from_draw(draw: &DrawData, alpha_cmp: AlphaCompare, shader: ShaderKey) -> Self {+ let tev_stages = usize::from(shader.num_tev_stages.min(16));+ let indirect_stages = u32::from(shader.num_indirect_stages.min(4));++ let mut key = Self {+ tev_ksel: draw.tev_ksel.map(|value| value & 0x0f),+ indirect_refs: draw.indirect_refs & ((1u32 << (indirect_stages * 6)) - 1),+ color_ctrl: draw.color_ctrl.map(|ctrl| ctrl.raw() & 0x7fff),+ alpha_ctrl: draw.alpha_ctrl.map(|ctrl| ctrl.raw() & 0x7fff),+ ztex_type: u32::from(draw.ztex_type & 3),+ ztex_op: u32::from(draw.ztex_op & 3),+ ..Self::default()+ };++ fn masked_copy(dst: &mut [u32], src: &[u32], mask: u32) {+ for (d, &s) in dst.iter_mut().zip(src) {+ *d = s & mask;+ }+ }++ masked_copy(&mut key.tev_color_env[..tev_stages], &draw.tev_color_env, 0x00ff_ffff);+ masked_copy(&mut key.tev_alpha_env[..tev_stages], &draw.tev_alpha_env, 0x00ff_ffff);+ masked_copy(&mut key.tev_orders[..tev_stages], &draw.tev_orders, 0x03ff);++ if indirect_stages != 0 {+ masked_copy(&mut key.tev_indirect[..tev_stages], &draw.tev_indirect, 0x001f_ffff);+ }++ if shader.alpha_test_enabled {+ key.alpha_comp0 = alpha_cmp.comp0() as u32;+ key.alpha_comp1 = alpha_cmp.comp1() as u32;+ key.alpha_op = alpha_cmp.op() as u32;+ }++ if draw.ztex_op == 0 {+ key.ztex_type = 0;+ }++ key+ }++ pub(crate) fn pipeline_constants(&self, shader: ShaderKey) -> Vec<(&'static str, f64)> {+ let tev_stages = usize::from(shader.num_tev_stages.min(16));++ let mut constants = Vec::with_capacity(83);+ constants.push(("gx_ubershader", 0.0));+ constants.extend(+ TEV_COLOR_ENV_NAMES+ .iter()+ .take(tev_stages)+ .zip(self.tev_color_env)+ .map(|(&name, value)| (name, f64::from(value))),+ );+ constants.extend(+ TEV_ALPHA_ENV_NAMES+ .iter()+ .take(tev_stages)+ .zip(self.tev_alpha_env)+ .map(|(&name, value)| (name, f64::from(value))),+ );+ constants.extend(+ TEV_ORDER_NAMES+ .iter()+ .take(tev_stages)+ .zip(self.tev_orders)+ .map(|(&name, value)| (name, f64::from(value))),+ );+ constants.extend(+ TEV_KSEL_NAMES+ .iter()+ .zip(self.tev_ksel)+ .map(|(&name, value)| (name, f64::from(value))),+ );+ constants.push(("gx_indirect_refs", f64::from(self.indirect_refs)));+ constants.extend(+ TEV_INDIRECT_NAMES+ .iter()+ .take(tev_stages)+ .zip(self.tev_indirect)+ .map(|(&name, value)| (name, f64::from(value))),+ );+ constants.extend([+ ("gx_color_ctrl_0", f64::from(self.color_ctrl[0])),+ ("gx_color_ctrl_1", f64::from(self.color_ctrl[1])),+ ("gx_alpha_ctrl_0", f64::from(self.alpha_ctrl[0])),+ ("gx_alpha_ctrl_1", f64::from(self.alpha_ctrl[1])),+ ("gx_ztex_type", f64::from(self.ztex_type)),+ ("gx_ztex_op", f64::from(self.ztex_op)),+ ]);++ if shader.alpha_test_enabled {+ constants.extend([+ ("gx_alpha_comp_0", f64::from(self.alpha_comp0)),+ ("gx_alpha_comp_1", f64::from(self.alpha_comp1)),+ ("gx_alpha_op", f64::from(self.alpha_op)),+ ]);+ }++ constants+ }++ pub(crate) fn to_bytes(self) -> [u8; SPECIALIZATION_KEY_BYTES] {+ let mut out = [0u8; SPECIALIZATION_KEY_BYTES];+ let mut offset = 0;+ let mut write = |value: u32| {+ out[offset..offset + 4].copy_from_slice(&value.to_le_bytes());+ offset += 4;+ };+ for values in [+ self.tev_color_env,+ self.tev_alpha_env,+ self.tev_orders,+ self.tev_indirect,+ ] {+ values.into_iter().for_each(&mut write);+ }+ self.tev_ksel.into_iter().for_each(&mut write);+ write(self.indirect_refs);+ self.color_ctrl.into_iter().for_each(&mut write);+ self.alpha_ctrl.into_iter().for_each(&mut write);+ [+ self.alpha_comp0,+ self.alpha_comp1,+ self.alpha_op,+ self.ztex_type,+ self.ztex_op,+ ]+ .into_iter()+ .for_each(&mut write);+ debug_assert_eq!(offset, SPECIALIZATION_KEY_BYTES);+ out+ }++ pub(crate) fn from_bytes(bytes: &[u8; SPECIALIZATION_KEY_BYTES]) -> Self {+ let mut offset = 0;++ let mut read = || {+ let value = u32::from_le_bytes(bytes[offset..offset + 4].try_into().unwrap());+ offset += 4;+ value+ };++ let tev_color_env = std::array::from_fn(|_| read());+ let tev_alpha_env = std::array::from_fn(|_| read());+ let tev_orders = std::array::from_fn(|_| read());+ let tev_indirect = std::array::from_fn(|_| read());+ let tev_ksel = std::array::from_fn(|_| read());+ let indirect_refs = read();+ let color_ctrl = std::array::from_fn(|_| read());+ let alpha_ctrl = std::array::from_fn(|_| read());+ let alpha_comp0 = read();+ let alpha_comp1 = read();+ let alpha_op = read();+ let ztex_type = read();+ let ztex_op = read();++ debug_assert_eq!(offset, SPECIALIZATION_KEY_BYTES);++ Self {+ tev_color_env,+ tev_alpha_env,+ tev_orders,+ tev_ksel,+ indirect_refs,+ tev_indirect,+ color_ctrl,+ alpha_ctrl,+ alpha_comp0,+ alpha_comp1,+ alpha_op,+ ztex_type,+ ztex_op,+ }+ }+}+impl ShaderKey {pub(crate) fn from_draw(draw: &DrawData, alpha_cmp: AlphaCompare) -> Self {let num_tev_stages = draw.num_tev_stages.clamp(1, 16);diff --git a/crates/backend-wgpu/src/shaders/main.wesl b/crates/backend-wgpu/src/shaders/main.weslindex 763ed33..34044bb 100644--- a/crates/backend-wgpu/src/shaders/main.wesl+++ b/crates/backend-wgpu/src/shaders/main.wesl@@ -5,18 +5,129 @@ import super::tev_combiners::{tev_combine_color, tev_combine_alpha};import super::alpha_test::{alpha_compare, alpha_combine};import super::lighting::{compute_lighting_c0, compute_lighting_c1};+override gx_ubershader: bool = false;+override gx_tev_color_env_0: u32 = 0u;+override gx_tev_color_env_1: u32 = 0u;+override gx_tev_color_env_2: u32 = 0u;+override gx_tev_color_env_3: u32 = 0u;+override gx_tev_color_env_4: u32 = 0u;+override gx_tev_color_env_5: u32 = 0u;+override gx_tev_color_env_6: u32 = 0u;+override gx_tev_color_env_7: u32 = 0u;+override gx_tev_color_env_8: u32 = 0u;+override gx_tev_color_env_9: u32 = 0u;+override gx_tev_color_env_10: u32 = 0u;+override gx_tev_color_env_11: u32 = 0u;+override gx_tev_color_env_12: u32 = 0u;+override gx_tev_color_env_13: u32 = 0u;+override gx_tev_color_env_14: u32 = 0u;+override gx_tev_color_env_15: u32 = 0u;++override gx_tev_alpha_env_0: u32 = 0u;+override gx_tev_alpha_env_1: u32 = 0u;+override gx_tev_alpha_env_2: u32 = 0u;+override gx_tev_alpha_env_3: u32 = 0u;+override gx_tev_alpha_env_4: u32 = 0u;+override gx_tev_alpha_env_5: u32 = 0u;+override gx_tev_alpha_env_6: u32 = 0u;+override gx_tev_alpha_env_7: u32 = 0u;+override gx_tev_alpha_env_8: u32 = 0u;+override gx_tev_alpha_env_9: u32 = 0u;+override gx_tev_alpha_env_10: u32 = 0u;+override gx_tev_alpha_env_11: u32 = 0u;+override gx_tev_alpha_env_12: u32 = 0u;+override gx_tev_alpha_env_13: u32 = 0u;+override gx_tev_alpha_env_14: u32 = 0u;+override gx_tev_alpha_env_15: u32 = 0u;++override gx_tev_order_0: u32 = 0u;+override gx_tev_order_1: u32 = 0u;+override gx_tev_order_2: u32 = 0u;+override gx_tev_order_3: u32 = 0u;+override gx_tev_order_4: u32 = 0u;+override gx_tev_order_5: u32 = 0u;+override gx_tev_order_6: u32 = 0u;+override gx_tev_order_7: u32 = 0u;+override gx_tev_order_8: u32 = 0u;+override gx_tev_order_9: u32 = 0u;+override gx_tev_order_10: u32 = 0u;+override gx_tev_order_11: u32 = 0u;+override gx_tev_order_12: u32 = 0u;+override gx_tev_order_13: u32 = 0u;+override gx_tev_order_14: u32 = 0u;+override gx_tev_order_15: u32 = 0u;++override gx_tev_indirect_0: u32 = 0u;+override gx_tev_indirect_1: u32 = 0u;+override gx_tev_indirect_2: u32 = 0u;+override gx_tev_indirect_3: u32 = 0u;+override gx_tev_indirect_4: u32 = 0u;+override gx_tev_indirect_5: u32 = 0u;+override gx_tev_indirect_6: u32 = 0u;+override gx_tev_indirect_7: u32 = 0u;+override gx_tev_indirect_8: u32 = 0u;+override gx_tev_indirect_9: u32 = 0u;+override gx_tev_indirect_10: u32 = 0u;+override gx_tev_indirect_11: u32 = 0u;+override gx_tev_indirect_12: u32 = 0u;+override gx_tev_indirect_13: u32 = 0u;+override gx_tev_indirect_14: u32 = 0u;+override gx_tev_indirect_15: u32 = 0u;++override gx_tev_ksel_0: u32 = 0u;+override gx_tev_ksel_1: u32 = 0u;+override gx_tev_ksel_2: u32 = 0u;+override gx_tev_ksel_3: u32 = 0u;+override gx_tev_ksel_4: u32 = 0u;+override gx_tev_ksel_5: u32 = 0u;+override gx_tev_ksel_6: u32 = 0u;+override gx_tev_ksel_7: u32 = 0u;+override gx_indirect_refs: u32 = 0u;++override gx_color_ctrl_0: u32 = 0u;+override gx_color_ctrl_1: u32 = 0u;+override gx_alpha_ctrl_0: u32 = 0u;+override gx_alpha_ctrl_1: u32 = 0u;+override gx_alpha_comp_0: u32 = 7u;+override gx_alpha_comp_1: u32 = 7u;+override gx_alpha_op: u32 = 0u;+override gx_ztex_type: u32 = 0u;+override gx_ztex_op: u32 = 0u;++fn shader_state(specialized: u32, dynamic: u32) -> u32 {+ return select(specialized, dynamic, gx_ubershader);+}++fn dynamic_tev_color_env(stage: u32) -> u32 {+ return frame.tev_color_env[stage / 4u][stage % 4u];+}++fn dynamic_tev_alpha_env(stage: u32) -> u32 {+ return frame.tev_alpha_env[stage / 4u][stage % 4u];+}++fn dynamic_tev_order(stage: u32) -> u32 {+ return frame.tev_orders[stage / 4u][stage % 4u];+}++fn dynamic_tev_indirect(stage: u32) -> u32 {+ return frame.tev_indirect[stage / 4u][stage % 4u];+}+@vertexfn vs_main(in: VsIn) -> VsOut {var out: VsOut;out.clip_pos = draw.mvp * vec4<f32>(in.pos_view, 1.0);out.clip_pos.z = out.clip_pos.z + out.clip_pos.w;out.color = compute_lighting_c0(- frame.color_ctrl0, frame.alpha_ctrl0,+ shader_state(gx_color_ctrl_0, frame.color_ctrl0),+ shader_state(gx_alpha_ctrl_0, frame.alpha_ctrl0),frame.ambient_color0, frame.material_color0,in.color, in.normal, in.pos_view,);out.color1 = compute_lighting_c1(- frame.color_ctrl1, frame.alpha_ctrl1,+ shader_state(gx_color_ctrl_1, frame.color_ctrl1),+ shader_state(gx_alpha_ctrl_1, frame.alpha_ctrl1),frame.ambient_color1, frame.material_color1,in.color1, in.normal, in.pos_view,);@@ -44,20 +155,32 @@ struct TevState {last_raw_tex: vec4<f32>,}+fn specialized_tev_ksel(idx: u32) -> u32 {+ var specialized: u32;+ switch idx {+ case 0u: { specialized = gx_tev_ksel_0; }+ case 1u: { specialized = gx_tev_ksel_1; }+ case 2u: { specialized = gx_tev_ksel_2; }+ case 3u: { specialized = gx_tev_ksel_3; }+ case 4u: { specialized = gx_tev_ksel_4; }+ case 5u: { specialized = gx_tev_ksel_5; }+ case 6u: { specialized = gx_tev_ksel_6; }+ default: { specialized = gx_tev_ksel_7; }+ }+ return shader_state(specialized, frame.tev_ksel[idx / 4u][idx % 4u]);+}+fn run_stage(stage: u32,+ order: u32,+ cenv: u32,+ aenv: u32,+ ind_cmd: u32,in: VsOut,color0: vec4<f32>,presampled: IndirectSamples,state: ptr<function, TevState>,) {- let row = stage / 4u;- let col = stage % 4u;- let order = frame.tev_orders[row][col];- let cenv = frame.tev_color_env[row][col];- let aenv = frame.tev_alpha_env[row][col];- let ind_cmd = frame.tev_indirect[row][col];-let texmap_idx = order & 7u;let texcoord_idx = (order >> 3u) & 7u;let tex_enabled = ((order >> 6u) & 1u) != 0u;@@ -89,8 +212,18 @@ fn run_stage(tex_color = vec4<f32>(1.0, 1.0, 1.0, 1.0);}- ras_color = swizzle_tev_color(extract_bits(aenv, 0u, 2u), ras_color);- tex_color = swizzle_tev_color(extract_bits(aenv, 2u, 2u), tex_color);+ let ras_swap = extract_bits(aenv, 0u, 2u) * 2u;+ let tex_swap = extract_bits(aenv, 2u, 2u) * 2u;+ ras_color = swizzle_tev_color(+ specialized_tev_ksel(ras_swap),+ specialized_tev_ksel(ras_swap + 1u),+ ras_color,+ );+ tex_color = swizzle_tev_color(+ specialized_tev_ksel(tex_swap),+ specialized_tev_ksel(tex_swap + 1u),+ tex_color,+ );let c_d = extract_bits(cenv, 0u, 4u);let c_c = extract_bits(cenv, 4u, 4u);@@ -151,31 +284,31 @@ fn run_tev(in: VsOut) -> TevResult {state.last_raw_tex = vec4<f32>(0.0, 0.0, 0.0, 0.0);let color0 = in.color;- let presampled = sample_indirect_textures(in);-- @if(TEV_STAGE_1_ENABLED) { run_stage( 0u, in, color0, presampled, &state); }- @if(TEV_STAGE_2_ENABLED) { run_stage( 1u, in, color0, presampled, &state); }- @if(TEV_STAGE_3_ENABLED) { run_stage( 2u, in, color0, presampled, &state); }- @if(TEV_STAGE_4_ENABLED) { run_stage( 3u, in, color0, presampled, &state); }- @if(TEV_STAGE_5_ENABLED) { run_stage( 4u, in, color0, presampled, &state); }- @if(TEV_STAGE_6_ENABLED) { run_stage( 5u, in, color0, presampled, &state); }- @if(TEV_STAGE_7_ENABLED) { run_stage( 6u, in, color0, presampled, &state); }- @if(TEV_STAGE_8_ENABLED) { run_stage( 7u, in, color0, presampled, &state); }- @if(TEV_STAGE_9_ENABLED) { run_stage( 8u, in, color0, presampled, &state); }- @if(TEV_STAGE_10_ENABLED) { run_stage( 9u, in, color0, presampled, &state); }- @if(TEV_STAGE_11_ENABLED) { run_stage(10u, in, color0, presampled, &state); }- @if(TEV_STAGE_12_ENABLED) { run_stage(11u, in, color0, presampled, &state); }- @if(TEV_STAGE_13_ENABLED) { run_stage(12u, in, color0, presampled, &state); }- @if(TEV_STAGE_14_ENABLED) { run_stage(13u, in, color0, presampled, &state); }- @if(TEV_STAGE_15_ENABLED) { run_stage(14u, in, color0, presampled, &state); }- @if(TEV_STAGE_16_ENABLED) { run_stage(15u, in, color0, presampled, &state); }+ let presampled = sample_indirect_textures(in, shader_state(gx_indirect_refs, frame.indirect_refs));++ @if(TEV_STAGE_1_ENABLED) { run_stage( 0u, shader_state(gx_tev_order_0, dynamic_tev_order( 0u)), shader_state(gx_tev_color_env_0, dynamic_tev_color_env( 0u)), shader_state(gx_tev_alpha_env_0, dynamic_tev_alpha_env( 0u)), shader_state(gx_tev_indirect_0, dynamic_tev_indirect( 0u)), in, color0, presampled, &state); }+ @if(TEV_STAGE_2_ENABLED) { run_stage( 1u, shader_state(gx_tev_order_1, dynamic_tev_order( 1u)), shader_state(gx_tev_color_env_1, dynamic_tev_color_env( 1u)), shader_state(gx_tev_alpha_env_1, dynamic_tev_alpha_env( 1u)), shader_state(gx_tev_indirect_1, dynamic_tev_indirect( 1u)), in, color0, presampled, &state); }+ @if(TEV_STAGE_3_ENABLED) { run_stage( 2u, shader_state(gx_tev_order_2, dynamic_tev_order( 2u)), shader_state(gx_tev_color_env_2, dynamic_tev_color_env( 2u)), shader_state(gx_tev_alpha_env_2, dynamic_tev_alpha_env( 2u)), shader_state(gx_tev_indirect_2, dynamic_tev_indirect( 2u)), in, color0, presampled, &state); }+ @if(TEV_STAGE_4_ENABLED) { run_stage( 3u, shader_state(gx_tev_order_3, dynamic_tev_order( 3u)), shader_state(gx_tev_color_env_3, dynamic_tev_color_env( 3u)), shader_state(gx_tev_alpha_env_3, dynamic_tev_alpha_env( 3u)), shader_state(gx_tev_indirect_3, dynamic_tev_indirect( 3u)), in, color0, presampled, &state); }+ @if(TEV_STAGE_5_ENABLED) { run_stage( 4u, shader_state(gx_tev_order_4, dynamic_tev_order( 4u)), shader_state(gx_tev_color_env_4, dynamic_tev_color_env( 4u)), shader_state(gx_tev_alpha_env_4, dynamic_tev_alpha_env( 4u)), shader_state(gx_tev_indirect_4, dynamic_tev_indirect( 4u)), in, color0, presampled, &state); }+ @if(TEV_STAGE_6_ENABLED) { run_stage( 5u, shader_state(gx_tev_order_5, dynamic_tev_order( 5u)), shader_state(gx_tev_color_env_5, dynamic_tev_color_env( 5u)), shader_state(gx_tev_alpha_env_5, dynamic_tev_alpha_env( 5u)), shader_state(gx_tev_indirect_5, dynamic_tev_indirect( 5u)), in, color0, presampled, &state); }+ @if(TEV_STAGE_7_ENABLED) { run_stage( 6u, shader_state(gx_tev_order_6, dynamic_tev_order( 6u)), shader_state(gx_tev_color_env_6, dynamic_tev_color_env( 6u)), shader_state(gx_tev_alpha_env_6, dynamic_tev_alpha_env( 6u)), shader_state(gx_tev_indirect_6, dynamic_tev_indirect( 6u)), in, color0, presampled, &state); }+ @if(TEV_STAGE_8_ENABLED) { run_stage( 7u, shader_state(gx_tev_order_7, dynamic_tev_order( 7u)), shader_state(gx_tev_color_env_7, dynamic_tev_color_env( 7u)), shader_state(gx_tev_alpha_env_7, dynamic_tev_alpha_env( 7u)), shader_state(gx_tev_indirect_7, dynamic_tev_indirect( 7u)), in, color0, presampled, &state); }+ @if(TEV_STAGE_9_ENABLED) { run_stage( 8u, shader_state(gx_tev_order_8, dynamic_tev_order( 8u)), shader_state(gx_tev_color_env_8, dynamic_tev_color_env( 8u)), shader_state(gx_tev_alpha_env_8, dynamic_tev_alpha_env( 8u)), shader_state(gx_tev_indirect_8, dynamic_tev_indirect( 8u)), in, color0, presampled, &state); }+ @if(TEV_STAGE_10_ENABLED) { run_stage( 9u, shader_state(gx_tev_order_9, dynamic_tev_order( 9u)), shader_state(gx_tev_color_env_9, dynamic_tev_color_env( 9u)), shader_state(gx_tev_alpha_env_9, dynamic_tev_alpha_env( 9u)), shader_state(gx_tev_indirect_9, dynamic_tev_indirect( 9u)), in, color0, presampled, &state); }+ @if(TEV_STAGE_11_ENABLED) { run_stage(10u, shader_state(gx_tev_order_10, dynamic_tev_order(10u)), shader_state(gx_tev_color_env_10, dynamic_tev_color_env(10u)), shader_state(gx_tev_alpha_env_10, dynamic_tev_alpha_env(10u)), shader_state(gx_tev_indirect_10, dynamic_tev_indirect(10u)), in, color0, presampled, &state); }+ @if(TEV_STAGE_12_ENABLED) { run_stage(11u, shader_state(gx_tev_order_11, dynamic_tev_order(11u)), shader_state(gx_tev_color_env_11, dynamic_tev_color_env(11u)), shader_state(gx_tev_alpha_env_11, dynamic_tev_alpha_env(11u)), shader_state(gx_tev_indirect_11, dynamic_tev_indirect(11u)), in, color0, presampled, &state); }+ @if(TEV_STAGE_13_ENABLED) { run_stage(12u, shader_state(gx_tev_order_12, dynamic_tev_order(12u)), shader_state(gx_tev_color_env_12, dynamic_tev_color_env(12u)), shader_state(gx_tev_alpha_env_12, dynamic_tev_alpha_env(12u)), shader_state(gx_tev_indirect_12, dynamic_tev_indirect(12u)), in, color0, presampled, &state); }+ @if(TEV_STAGE_14_ENABLED) { run_stage(13u, shader_state(gx_tev_order_13, dynamic_tev_order(13u)), shader_state(gx_tev_color_env_13, dynamic_tev_color_env(13u)), shader_state(gx_tev_alpha_env_13, dynamic_tev_alpha_env(13u)), shader_state(gx_tev_indirect_13, dynamic_tev_indirect(13u)), in, color0, presampled, &state); }+ @if(TEV_STAGE_15_ENABLED) { run_stage(14u, shader_state(gx_tev_order_14, dynamic_tev_order(14u)), shader_state(gx_tev_color_env_14, dynamic_tev_color_env(14u)), shader_state(gx_tev_alpha_env_14, dynamic_tev_alpha_env(14u)), shader_state(gx_tev_indirect_14, dynamic_tev_indirect(14u)), in, color0, presampled, &state); }+ @if(TEV_STAGE_16_ENABLED) { run_stage(15u, shader_state(gx_tev_order_15, dynamic_tev_order(15u)), shader_state(gx_tev_color_env_15, dynamic_tev_color_env(15u)), shader_state(gx_tev_alpha_env_15, dynamic_tev_alpha_env(15u)), shader_state(gx_tev_indirect_15, dynamic_tev_indirect(15u)), in, color0, presampled, &state); }let color = vec4<f32>(state.regs[state.last_color_dest].rgb, state.regs[state.last_alpha_dest].a);@if(ALPHA_TEST_ENABLED) {- let c0 = alpha_compare(color.a, frame.alpha_ref0, frame.alpha_comp0);- let c1 = alpha_compare(color.a, frame.alpha_ref1, frame.alpha_comp1);- if !alpha_combine(c0, c1, frame.alpha_op) {+ let c0 = alpha_compare(color.a, frame.alpha_ref0, shader_state(gx_alpha_comp_0, frame.alpha_comp0));+ let c1 = alpha_compare(color.a, frame.alpha_ref1, shader_state(gx_alpha_comp_1, frame.alpha_comp1));+ if !alpha_combine(c0, c1, shader_state(gx_alpha_op, frame.alpha_op)) {discard;}}@@ -201,12 +334,12 @@ fn fs_main_ztex(in: VsOut) -> FsOutZtex {let r = run_tev(in);let texel = vec4<u32>(round(r.raw_tex * 255.0));var z: u32 = frame.ztex_bias;- switch frame.ztex_type {+ switch shader_state(gx_ztex_type, frame.ztex_type) {case 0u: { z += texel.a; }case 1u: { z += (texel.a << 8u) | texel.r; }default: { z += (texel.r << 16u) | (texel.g << 8u) | texel.b; }}- if frame.ztex_op == 1u {+ if shader_state(gx_ztex_op, frame.ztex_op) == 1u {z += u32(round(in.clip_pos.z * 16777215.0));}z = z & 0x00FFFFFFu;diff --git a/crates/backend-wgpu/src/shaders/tev_helpers.wesl b/crates/backend-wgpu/src/shaders/tev_helpers.weslindex f61e8d5..f2b2805 100644--- a/crates/backend-wgpu/src/shaders/tev_helpers.wesl+++ b/crates/backend-wgpu/src/shaders/tev_helpers.wesl@@ -1,11 +1,4 @@-import super::common::{VsOut, frame, tex0, tex1, tex2, tex3, tex4, tex5, tex6, tex7, samp0, samp1, samp2, samp3, samp4, samp5, samp6, samp7};--// Index into a packed array<vec4<u32>, 4> by flat index-fn read_packed(arr: array<vec4<u32>, 4>, idx: u32) -> u32 {- let vi = idx / 4u;- let ci = idx % 4u;- return arr[vi][ci];-}+import super::common::{VsOut, tex0, tex1, tex2, tex3, tex4, tex5, tex6, tex7, samp0, samp1, samp2, samp3, samp4, samp5, samp6, samp7};fn extract_bits(val: u32, lo: u32, width: u32) -> u32 {return (val >> lo) & ((1u << width) - 1u);@@ -20,9 +13,7 @@ fn select_color_channel(color: vec4<f32>, channel: u32) -> f32 {}}-fn swizzle_tev_color(swap_table: u32, color: vec4<f32>) -> vec4<f32> {- let rg = read_packed(frame.tev_ksel, swap_table * 2u);- let ba = read_packed(frame.tev_ksel, swap_table * 2u + 1u);+fn swizzle_tev_color(rg: u32, ba: u32, color: vec4<f32>) -> vec4<f32> {let r = extract_bits(rg, 0u, 2u);let g = extract_bits(rg, 2u, 2u);let b = extract_bits(ba, 0u, 2u);diff --git a/crates/backend-wgpu/src/shaders/tev_indirect.wesl b/crates/backend-wgpu/src/shaders/tev_indirect.weslindex d527f1d..2836b4a 100644--- a/crates/backend-wgpu/src/shaders/tev_indirect.wesl+++ b/crates/backend-wgpu/src/shaders/tev_indirect.wesl@@ -1,5 +1,5 @@-import super::common::{VsOut, FrameUniforms, frame, draw};-import super::tev_helpers::{select_texcoord, stq_to_uv, sample_texmap, read_packed};+import super::common::{VsOut, frame, draw};+import super::tev_helpers::{select_texcoord, stq_to_uv, sample_texmap};fn texmap_size(texmap: u32) -> vec2<f32> {let pair = draw.tex_dims[texmap / 2u];@@ -65,10 +65,10 @@ struct IndirectSamples {samples: array<vec3<f32>, 4>,}-fn sample_indirect_one(i: u32, in: VsOut, result: ptr<function, IndirectSamples>) {+fn sample_indirect_one(i: u32, in: VsOut, indirect_refs: u32, result: ptr<function, IndirectSamples>) {let shift = i * 6u;- let texmap = (frame.indirect_refs >> shift) & 7u;- let texcoord = (frame.indirect_refs >> (shift + 3u)) & 7u;+ let texmap = (indirect_refs >> shift) & 7u;+ let texcoord = (indirect_refs >> (shift + 3u)) & 7u;let scale_pair = frame.indirect_scales[i / 2u];let scale_s: u32 = select(scale_pair.x, scale_pair.z, (i & 1u) == 1u);let scale_t: u32 = select(scale_pair.y, scale_pair.w, (i & 1u) == 1u);@@ -83,17 +83,17 @@ fn sample_indirect_one(i: u32, in: VsOut, result: ptr<function, IndirectSamples>(*result).samples[i] = sample.abg;}-fn sample_indirect_textures(in: VsOut) -> IndirectSamples {+fn sample_indirect_textures(in: VsOut, indirect_refs: u32) -> IndirectSamples {var result: IndirectSamples;result.samples[0] = vec3<f32>(0.0);result.samples[1] = vec3<f32>(0.0);result.samples[2] = vec3<f32>(0.0);result.samples[3] = vec3<f32>(0.0);- @if(IND_STAGE_0_ENABLED) { sample_indirect_one(0u, in, &result); }- @if(IND_STAGE_1_ENABLED) { sample_indirect_one(1u, in, &result); }- @if(IND_STAGE_2_ENABLED) { sample_indirect_one(2u, in, &result); }- @if(IND_STAGE_3_ENABLED) { sample_indirect_one(3u, in, &result); }+ @if(IND_STAGE_0_ENABLED) { sample_indirect_one(0u, in, indirect_refs, &result); }+ @if(IND_STAGE_1_ENABLED) { sample_indirect_one(1u, in, indirect_refs, &result); }+ @if(IND_STAGE_2_ENABLED) { sample_indirect_one(2u, in, indirect_refs, &result); }+ @if(IND_STAGE_3_ENABLED) { sample_indirect_one(3u, in, indirect_refs, &result); }return result;}diff --git a/crates/backend-wgpu/src/sink.rs b/crates/backend-wgpu/src/sink.rsindex a649d0f..a323f60 100644--- a/crates/backend-wgpu/src/sink.rs+++ b/crates/backend-wgpu/src/sink.rs@@ -4,6 +4,8 @@ use gecko::host::GxAction;use crate::GxRenderer;#[cfg(not(target_arch = "wasm32"))]use gecko::host::{DrawData, DrawVertex, RenderSink};+#[cfg(all(not(target_arch = "wasm32"), feature = "gx-stats"))]+use std::sync::atomic::Ordering;#[cfg(not(target_arch = "wasm32"))]use std::sync::{Arc, Mutex, OnceLock};#[cfg(not(target_arch = "wasm32"))]@@ -15,7 +17,10 @@ use std::time::Instant;pub type FrameReadyCallback = Box<dyn Fn(Instant) + Send + Sync>;#[cfg(not(target_arch = "wasm32"))]-const WORK_QUEUE_LIMIT: usize = 4096;+// Keep only a few GX batches in flight. This used to count individual actions,+// so leaving it at 4096 after batching would allow thousands of whole frames to+// accumulate behind the render worker.+const WORK_QUEUE_LIMIT: usize = 8;/// Holds the XFB output texture that the render worker updates and the/// windowing thread reads for blitting and screenshots.@@ -55,9 +60,12 @@ impl TargetAspect {pub struct ThreadedSink {work_tx: crossbeam_channel::Sender<WorkerCommand>,recycled_draw_data_rx: crossbeam_channel::Receiver<Box<DrawData>>,+ recycled_batches_rx: crossbeam_channel::Receiver<ActionBatch>,+ #[cfg(feature = "gx-stats")]+ stats: Arc<crate::RendererStats>,worker_thread: Option<JoinHandle<()>>,+ pending_actions: Vec<GxAction>,scratch: Vec<DrawVertex>,- scratch_sent_len: usize,}#[cfg(not(target_arch = "wasm32"))]@@ -68,14 +76,16 @@ struct RenderWorker {shared: Arc<Shared>,frame_ready_cb: Arc<OnceLock<FrameReadyCallback>>,recycled_draw_data_tx: crossbeam_channel::Sender<Box<DrawData>>,+ recycled_batches_tx: crossbeam_channel::Sender<ActionBatch>,#[cfg(feature = "renderdoc-capture")]renderdoc: Arc<Mutex<crate::renderdoc_capture::RenderDocCapture>>,}#[cfg(not(target_arch = "wasm32"))]-struct ActionMessage {- action: GxAction,+struct ActionBatch {+ actions: Vec<GxAction>,vertices: Vec<DrawVertex>,+ resets_scratch: bool,}#[cfg(not(target_arch = "wasm32"))]@@ -84,12 +94,13 @@ struct EfbDrainRequest {mem1_len: usize,mem2_addr: usize,mem2_len: usize,- done_tx: crossbeam_channel::Sender<()>,+ batch: ActionBatch,+ done_tx: crossbeam_channel::Sender<ActionBatch>,}#[cfg(not(target_arch = "wasm32"))]enum WorkerCommand {- Action(ActionMessage),+ Actions(ActionBatch),DrainEfbCopies(EfbDrainRequest),Shutdown,}@@ -99,13 +110,14 @@ impl RenderWorker {fn run(mut self, work_rx: crossbeam_channel::Receiver<WorkerCommand>) {while let Ok(command) = work_rx.recv() {match command {- WorkerCommand::Action(message) => self.exec(message),+ WorkerCommand::Actions(batch) => self.exec_batch(batch),WorkerCommand::DrainEfbCopies(request) => self.drain_efb_copies(request),WorkerCommand::Shutdown => break,}}self.gx.submit_pending(&self.queue);+ self.gx.poll_compiled_pipelines();#[cfg(feature = "renderdoc-capture")]if let Ok(mut rd) = self.renderdoc.lock() {rd.end_emulated_frame();@@ -120,15 +132,10 @@ impl RenderWorker {}}- fn exec(&mut self, message: ActionMessage) {- if !message.vertices.is_empty() {- self.gx.scratch_vertices.extend_from_slice(&message.vertices);- }-- let resets_scratch = action_resets_vertex_scratch(&message.action);- self.gx.process_action(&self.device, &self.queue, &message.action);+ fn exec_action(&mut self, action: GxAction) {+ self.gx.process_action(&self.device, &self.queue, &action);- match message.action {+ match action {GxAction::PresentXfb { .. } | GxAction::PresentRawXfb { .. } => {#[cfg(feature = "renderdoc-capture")]if let Ok(mut rd) = self.renderdoc.lock() {@@ -146,13 +153,50 @@ impl RenderWorker {}_ => {}}+ }- if resets_scratch {- self.gx.scratch_vertices.clear();+ fn exec_batch_returning_vertices(&mut self, batch: &mut ActionBatch) {+ let worker_scratch = self.gx.replace_vertex_scratch(std::mem::take(&mut batch.vertices));+ for action in batch.actions.drain(..) {+ self.exec_action(action);+ }+ batch.vertices = self.gx.replace_vertex_scratch(worker_scratch);+ }++ fn exec_batch(&mut self, mut batch: ActionBatch) {+ #[cfg(feature = "gx-stats")]+ let batch_started = std::time::Instant::now();++ if batch.resets_scratch {+ self.exec_batch_returning_vertices(&mut batch);+ batch.vertices.clear();++ debug_assert!(batch.actions.is_empty());+ debug_assert!(batch.vertices.is_empty());++ let _ = self.recycled_batches_tx.send(batch);+ } else {+ let _old_scratch = self.gx.replace_vertex_scratch(batch.vertices);+ for action in batch.actions {+ self.exec_action(action);+ }}++ #[cfg(feature = "gx-stats")]+ self.gx+ .stats+ .worker_batch_cpu_ns+ .fetch_add(batch_started.elapsed().as_nanos() as u64, Ordering::Relaxed);}- fn drain_efb_copies(&mut self, request: EfbDrainRequest) {+ fn drain_efb_copies(&mut self, mut request: EfbDrainRequest) {+ #[cfg(feature = "gx-stats")]+ let batch_started = std::time::Instant::now();++ let expected_vertex_len = request.batch.vertices.len();+ self.exec_batch_returning_vertices(&mut request.batch);+ debug_assert_eq!(request.batch.vertices.len(), expected_vertex_len);+let mut ram = unsafe {// The emu thread blocks on `done_tx` and holds the only mutable// RamViewMut while this command runs. FIFO channel ordering also@@ -161,40 +205,91 @@ impl RenderWorker {let mem2 = std::slice::from_raw_parts_mut(request.mem2_addr as *mut u8, request.mem2_len);gecko::mmio::RamViewMut { mem1, mem2 }};+ #[cfg(feature = "gx-stats")]+ let writeback_count = self.gx.pending_writebacks.len() as u64;+ #[cfg(feature = "gx-stats")]+ let writeback_started = std::time::Instant::now();self.gx.drain_pending_writebacks(&self.device, &self.queue, &mut ram);- let _ = request.done_tx.send(());++ #[cfg(feature = "gx-stats")]+ {+ self.gx.stats.efb_drain_requests.fetch_add(1, Ordering::Relaxed);+ if writeback_count != 0 {+ self.gx.stats.efb_drain_nonempty.fetch_add(1, Ordering::Relaxed);+ self.gx+ .stats+ .efb_writebacks+ .fetch_add(writeback_count, Ordering::Relaxed);+ self.gx+ .stats+ .efb_writeback_cpu_ns+ .fetch_add(writeback_started.elapsed().as_nanos() as u64, Ordering::Relaxed);+ }+ self.gx+ .stats+ .worker_batch_cpu_ns+ .fetch_add(batch_started.elapsed().as_nanos() as u64, Ordering::Relaxed);+ }++ let _ = request.done_tx.send(request.batch);}}#[cfg(not(target_arch = "wasm32"))]impl ThreadedSink {- fn pending_vertices(&mut self) -> Vec<DrawVertex> {- if self.scratch.len() <= self.scratch_sent_len {- return Vec::new();+ fn reclaim_batch(&mut self) {+ if !self.pending_actions.is_empty() || !self.scratch.is_empty() {+ return;}- let vertices = self.scratch[self.scratch_sent_len..].to_vec();- self.scratch_sent_len = self.scratch.len();- vertices+ if let Ok(batch) = self.recycled_batches_rx.try_recv() {+ debug_assert!(batch.actions.is_empty());+ debug_assert!(batch.vertices.is_empty());+ self.pending_actions = batch.actions;+ self.scratch = batch.vertices;+ }+ }++ fn take_batch(&mut self, resets_scratch: bool) -> ActionBatch {+ ActionBatch {+ actions: std::mem::take(&mut self.pending_actions),+ vertices: std::mem::take(&mut self.scratch),+ resets_scratch,+ }+ }++ fn send_reset_batch(&mut self) {+ let batch = self.take_batch(true);+ #[cfg(feature = "gx-stats")]+ let send_started = std::time::Instant::now();+ self.work_tx+ .send(WorkerCommand::Actions(batch))+ .expect("render worker thread stopped");+ #[cfg(feature = "gx-stats")]+ {+ self.stats.batches_sent.fetch_add(1, Ordering::Relaxed);+ self.stats+ .channel_high_water+ .fetch_max(self.work_tx.len() as u64, Ordering::Relaxed);+ self.stats+ .queue_wait_ns+ .fetch_add(send_started.elapsed().as_nanos() as u64, Ordering::Relaxed);+ }+ self.reclaim_batch();}}#[cfg(not(target_arch = "wasm32"))]impl RenderSink for ThreadedSink {fn exec(&mut self, action: GxAction) {- let resets_scratch = action_resets_vertex_scratch(&action);- let message = ActionMessage {- action,- vertices: self.pending_vertices(),- };+ #[cfg(feature = "gx-stats")]+ self.stats.actions_sent.fetch_add(1, Ordering::Relaxed);- self.work_tx- .send(WorkerCommand::Action(message))- .expect("render worker thread stopped");+ let resets_scratch = action_resets_vertex_scratch(&action);+ self.pending_actions.push(action);if resets_scratch {- self.scratch.clear();- self.scratch_sent_len = 0;+ self.send_reset_batch();}}@@ -205,28 +300,64 @@ impl RenderSink for ThreadedSink {mem1_len: ram.mem1.len(),mem2_addr: ram.mem2.as_mut_ptr() as usize,mem2_len: ram.mem2.len(),+ batch: self.take_batch(false),done_tx,};+ #[cfg(feature = "gx-stats")]+ let drain_started = std::time::Instant::now();self.work_tx.send(WorkerCommand::DrainEfbCopies(request)).expect("render worker thread stopped");- done_rx.recv().expect("render worker thread stopped");+ let batch = done_rx.recv().expect("render worker thread stopped");+ #[cfg(feature = "gx-stats")]+ {+ self.stats.batches_sent.fetch_add(1, Ordering::Relaxed);+ self.stats+ .channel_high_water+ .fetch_max(self.work_tx.len() as u64, Ordering::Relaxed);+ self.stats+ .efb_drain_wait_ns+ .fetch_add(drain_started.elapsed().as_nanos() as u64, Ordering::Relaxed);+ }+ debug_assert!(batch.actions.is_empty());+ self.pending_actions = batch.actions;+ self.scratch = batch.vertices;}fn vertex_scratch(&mut self) -> &mut Vec<DrawVertex> {+ self.reclaim_batch();&mut self.scratch}fn take_draw_data(&mut self) -> Box<DrawData> {+ self.reclaim_batch();self.recycled_draw_data_rx.try_recv().unwrap_or_default()}++ fn render_stats(&self) -> gecko::host::RenderStats {+ #[cfg(feature = "gx-stats")]+ {+ return self+ .stats+ .snapshot(self.work_tx.len(), self.work_tx.capacity().unwrap_or(0));+ }++ #[cfg(not(feature = "gx-stats"))]+ gecko::host::RenderStats::default()+ }}#[cfg(not(target_arch = "wasm32"))]impl Drop for ThreadedSink {fn drop(&mut self) {if let Some(worker_thread) = self.worker_thread.take() {+ if !self.pending_actions.is_empty() || !self.scratch.is_empty() {+ let batch = self.take_batch(false);+ let _ = self.work_tx.send(WorkerCommand::Actions(batch));+ #[cfg(feature = "gx-stats")]+ self.stats.batches_sent.fetch_add(1, Ordering::Relaxed);+ }let _ = self.work_tx.send(WorkerCommand::Shutdown);if let Err(err) = worker_thread.join() {tracing::error!(?err, "render worker thread panicked");@@ -337,6 +468,8 @@ impl Renderer {) -> (Self, ThreadedSink) {let mut gx = GxRenderer::new(&device, &queue, surface_format, efb_scale);gx.prewarm_pipeline_cache(&device);+ #[cfg(feature = "gx-stats")]+ let stats = gx.stats.clone();// Initial shared output: the XFB texture (black until first PresentXfb).let shared = Arc::new(Shared {@@ -416,6 +549,7 @@ impl Renderer {let (work_tx, work_rx) = crossbeam_channel::bounded(WORK_QUEUE_LIMIT);let (recycled_draw_data_tx, recycled_draw_data_rx) = crossbeam_channel::unbounded();+ let (recycled_batches_tx, recycled_batches_rx) = crossbeam_channel::unbounded();let worker = RenderWorker {gx,device: device.clone(),@@ -423,6 +557,7 @@ impl Renderer {shared: shared.clone(),frame_ready_cb: frame_ready_cb.clone(),recycled_draw_data_tx,+ recycled_batches_tx,#[cfg(feature = "renderdoc-capture")]renderdoc: renderdoc.clone(),};@@ -434,9 +569,12 @@ impl Renderer {let sink = ThreadedSink {work_tx,recycled_draw_data_rx,+ recycled_batches_rx,+ #[cfg(feature = "gx-stats")]+ stats,worker_thread: Some(worker_thread),+ pending_actions: Vec::new(),scratch: Vec::new(),- scratch_sent_len: 0,};let renderer = Renderer {diff --git a/crates/gecko/src/flipper/gx/draw.rs b/crates/gecko/src/flipper/gx/draw.rsindex 325638e..4147b65 100644--- a/crates/gecko/src/flipper/gx/draw.rs+++ b/crates/gecko/src/flipper/gx/draw.rs@@ -116,7 +116,7 @@ pub struct TextureDescriptor {pub min_filter: MinFilter,}-#[derive(Debug, Clone, Copy)]+#[derive(Debug, Clone, Copy, PartialEq)]pub struct Viewport {pub x: f32,pub y: f32,@@ -139,7 +139,7 @@ impl Default for Viewport {}}-#[derive(Debug, Clone, Copy)]+#[derive(Debug, Clone, Copy, PartialEq, Eq)]pub struct Scissor {pub x: u32,pub y: u32,diff --git a/crates/gecko/src/host.rs b/crates/gecko/src/host.rsindex 90ce0de..245d47f 100644--- a/crates/gecko/src/host.rs+++ b/crates/gecko/src/host.rs@@ -227,6 +227,44 @@ pub struct LightData {pub direction: [f32; 4],}+/// Cumulative renderer-side profiling counters. Backends that do not expose+/// profiling data return the all-zero default through [`RenderSink`].+#[derive(Clone, Copy, Debug, Default)]+pub struct RenderStats {+ pub actions_sent: u64,+ pub batches_sent: u64,+ pub channel_len: usize,+ pub channel_cap: usize,+ pub channel_high_water: usize,+ pub queue_wait_ns: u64,+ pub efb_drain_wait_ns: u64,+ pub efb_drain_requests: u64,+ pub efb_drain_nonempty: u64,+ pub efb_writebacks: u64,+ pub efb_writeback_cpu_ns: u64,+ pub worker_batch_cpu_ns: u64,+ pub draws_encoded: u64,+ pub draw_render_passes: u64,+ pub pipeline_changes: u64,+ pub pipelines_created: u64,+ pub pipeline_create_cpu_ns: u64,+ pub shader_modules_created: u64,+ pub shader_create_cpu_ns: u64,+ pub bind_group_sets: u64,+ pub bind_groups_created: u64,+ pub bind_group_key_changes: u64,+ pub frame_uniform_changes: u64,+ pub draw_uniform_changes: u64,+ pub vertex_stride_changes: u64,+ pub potential_merged_draws: u64,+ pub viewport_changes: u64,+ pub scissor_changes: u64,+ pub draw_pass_encode_ns: u64,+ pub queue_submits: u64,+ pub command_buffers_submitted: u64,+ pub queue_submit_cpu_ns: u64,+}+/// One-way sink for GX actions. The emulator pushes actions here.pub trait RenderSink: Send {/// Submit a single action.@@ -254,6 +292,11 @@ pub trait RenderSink: Send {fn take_draw_data(&mut self) -> Box<DrawData> {Box::default()}++ /// Return a cheap, non-blocking snapshot of cumulative renderer metrics.+ fn render_stats(&self) -> RenderStats {+ RenderStats::default()+ }}/// Swallows every action. Used by headless runners (tinybench, tinytracer)diff --git a/crates/gecko/src/system.rs b/crates/gecko/src/system.rsindex 5239666..a5ac7ac 100644--- a/crates/gecko/src/system.rs+++ b/crates/gecko/src/system.rs@@ -37,6 +37,14 @@ pub enum ExecutionMode {Interpreter,}+#[cfg(feature = "gx-stats")]+#[derive(Clone, Default)]+struct GxStatsDumpState {+ vsync_count: u64,+ gx: crate::flipper::gx::GxStats,+ render: crate::host::RenderStats,+}+pub struct System<const SYSTEM: SystemId> {pub vsync_pending: bool,pub vi_present_seen_this_frame: bool,@@ -88,6 +96,9 @@ pub struct System<const SYSTEM: SystemId> {#[cfg(any(feature = "jit-stats", feature = "profile", feature = "gx-stats"))]pub vsync_count: u64,+ #[cfg(feature = "gx-stats")]+ gx_stats_dump_state: Option<GxStatsDumpState>,+#[cfg(feature = "profile")]pub pprof_config: Option<crate::profile::PprofConfig>,@@ -142,6 +153,9 @@ impl<const SYSTEM: SystemId> System<SYSTEM> {#[cfg(any(feature = "jit-stats", feature = "profile", feature = "gx-stats"))]vsync_count: 0,+ #[cfg(feature = "gx-stats")]+ gx_stats_dump_state: None,+#[cfg(feature = "profile")]pprof_config: None,@@ -377,7 +391,7 @@ impl<const SYSTEM: SystemId> System<SYSTEM> {}#[cfg(feature = "gx-stats")]- fn dump_gx_stats_if_due(&self) {+ fn dump_gx_stats_if_due(&mut self) {if !self.heatmap.enabled || self.heatmap.interval_frames == 0 {return;}@@ -389,20 +403,32 @@ impl<const SYSTEM: SystemId> System<SYSTEM> {use std::io::Write;let path = self.heatmap.out_dir.join("gx-stats.txt");- let s = &self.gx.stats;+ let s = self.gx.stats.clone();let avg_draw_ns = if s.draw_calls > 0 {s.create_draw_call_ns / s.draw_calls} else {0};- let actions_sent: u64 = 0;- let channel_len: usize = 0;- let channel_cap: usize = 0;+ let render = self.render_sink.render_stats();+ let presents = s.xfb_presents.max(1) as f64;+ let previous = self.gx_stats_dump_state.clone().unwrap_or_default();+ let delta = |current: u64, prior: u64| current.saturating_sub(prior);+ let interval_vsyncs = delta(self.vsync_count, previous.vsync_count);+ let interval_presents = delta(s.xfb_presents, previous.gx.xfb_presents);+ let interval_divisor = interval_presents.max(1) as f64;+ let interval_renderer_draws = delta(render.draws_encoded, previous.render.draws_encoded);+ let interval_potential_draws = delta(render.potential_merged_draws, previous.render.potential_merged_draws);+ let interval_reduction_pct = interval_renderer_draws.saturating_sub(interval_potential_draws) as f64+ / interval_renderer_draws.max(1) as f64+ * 100.0;+ let cumulative_reduction_pct = render.draws_encoded.saturating_sub(render.potential_merged_draws) as f64+ / render.draws_encoded.max(1) as f64+ * 100.0;let result = crate::profile::write_file_atomic(&path, |f| {writeln!(f,- "vsync_count={}\ndraw_calls={}\nvertices={}\nfifo_bytes={}\ntexture_loads={}\nxfb_presents={}\nbp_writes={}\nxf_writes={}\ncreate_draw_call_ns={}\navg_draw_call_ns={}\nrender_actions_sent={}\nrender_channel_len={}\nrender_channel_cap={}",+ "vsync_count={}\ndraw_calls={}\nvertices={}\nfifo_bytes={}\ntexture_loads={}\nxfb_presents={}\nbp_writes={}\nxf_writes={}\ncreate_draw_call_ns={}\navg_draw_call_ns={}\nrender_actions_sent={}\nrender_batches_sent={}\nrender_channel_len={}\nrender_channel_cap={}\nrender_channel_high_water={}\nrender_queue_wait_ns={}\nrender_efb_drain_wait_ns={}\nrender_efb_drain_requests={}\nrender_efb_drain_nonempty={}\nrender_efb_writebacks={}\nrender_efb_writeback_cpu_ns={}\nrender_worker_batch_cpu_ns={}\nrender_draws_encoded={}\nrender_draw_passes={}\nrender_pipeline_changes={}\nrender_pipelines_created={}\nrender_pipeline_create_cpu_ns={}\nrender_shader_modules_created={}\nrender_shader_create_cpu_ns={}\nrender_bind_group_sets={}\nrender_bind_groups_created={}\nrender_bind_group_key_changes={}\nrender_frame_uniform_changes={}\nrender_draw_uniform_changes={}\nrender_vertex_stride_changes={}\nrender_potential_merged_draws={}\nrender_viewport_changes={}\nrender_scissor_changes={}\nrender_draw_pass_encode_ns={}\nrender_queue_submits={}\nrender_command_buffers_submitted={}\nrender_queue_submit_cpu_ns={}",self.vsync_count,s.draw_calls,s.vertices,@@ -413,9 +439,118 @@ impl<const SYSTEM: SystemId> System<SYSTEM> {s.xf_writes,s.create_draw_call_ns,avg_draw_ns,- actions_sent,- channel_len,- channel_cap,+ render.actions_sent,+ render.batches_sent,+ render.channel_len,+ render.channel_cap,+ render.channel_high_water,+ render.queue_wait_ns,+ render.efb_drain_wait_ns,+ render.efb_drain_requests,+ render.efb_drain_nonempty,+ render.efb_writebacks,+ render.efb_writeback_cpu_ns,+ render.worker_batch_cpu_ns,+ render.draws_encoded,+ render.draw_render_passes,+ render.pipeline_changes,+ render.pipelines_created,+ render.pipeline_create_cpu_ns,+ render.shader_modules_created,+ render.shader_create_cpu_ns,+ render.bind_group_sets,+ render.bind_groups_created,+ render.bind_group_key_changes,+ render.frame_uniform_changes,+ render.draw_uniform_changes,+ render.vertex_stride_changes,+ render.potential_merged_draws,+ render.viewport_changes,+ render.scissor_changes,+ render.draw_pass_encode_ns,+ render.queue_submits,+ render.command_buffers_submitted,+ render.queue_submit_cpu_ns,+ )?;+ writeln!(+ f,+ "\n--- last dump interval ---\nvsyncs={}\nxfb_presents={}\ndraw_calls={}\nvertices={}\nrenderer_draws={}\nactions={}\nbatches={}\ndraws_per_present={:.2}\nvertices_per_present={:.2}\ndraw_passes_per_present={:.2}\npipeline_changes_per_present={:.2}\npipelines_created_per_present={:.2}\npipeline_create_cpu_us_per_present={:.2}\nshader_modules_created_per_present={:.2}\nshader_create_cpu_us_per_present={:.2}\nbind_group_sets_per_present={:.2}\nbind_groups_created_per_present={:.2}\nbind_group_key_changes_per_present={:.2}\nframe_uniform_changes_per_present={:.2}\ndraw_uniform_changes_per_present={:.2}\nvertex_stride_changes_per_present={:.2}\npotential_merged_draws_per_present={:.2}\npotential_draw_reduction_pct={:.2}\nviewport_changes_per_present={:.2}\nscissor_changes_per_present={:.2}\ndraw_pass_encode_cpu_us_per_present={:.2}\nworker_cpu_us_per_present={:.2}\nqueue_wait_us_per_present={:.2}\nefb_drain_wait_us_per_present={:.2}\nefb_drain_requests_per_present={:.2}\nefb_drain_nonempty_per_present={:.2}\nefb_writebacks_per_present={:.2}\nefb_writeback_cpu_us_per_present={:.2}\nqueue_submit_cpu_us_per_present={:.2}",+ interval_vsyncs,+ interval_presents,+ delta(s.draw_calls, previous.gx.draw_calls),+ delta(s.vertices, previous.gx.vertices),+ interval_renderer_draws,+ delta(render.actions_sent, previous.render.actions_sent),+ delta(render.batches_sent, previous.render.batches_sent),+ delta(render.draws_encoded, previous.render.draws_encoded) as f64 / interval_divisor,+ delta(s.vertices, previous.gx.vertices) as f64 / interval_divisor,+ delta(render.draw_render_passes, previous.render.draw_render_passes) as f64 / interval_divisor,+ delta(render.pipeline_changes, previous.render.pipeline_changes) as f64 / interval_divisor,+ delta(render.pipelines_created, previous.render.pipelines_created) as f64 / interval_divisor,+ delta(render.pipeline_create_cpu_ns, previous.render.pipeline_create_cpu_ns,) as f64+ / interval_divisor+ / 1_000.0,+ delta(render.shader_modules_created, previous.render.shader_modules_created,) as f64 / interval_divisor,+ delta(render.shader_create_cpu_ns, previous.render.shader_create_cpu_ns) as f64+ / interval_divisor+ / 1_000.0,+ delta(render.bind_group_sets, previous.render.bind_group_sets) as f64 / interval_divisor,+ delta(render.bind_groups_created, previous.render.bind_groups_created) as f64 / interval_divisor,+ delta(render.bind_group_key_changes, previous.render.bind_group_key_changes,) as f64 / interval_divisor,+ delta(render.frame_uniform_changes, previous.render.frame_uniform_changes,) as f64 / interval_divisor,+ delta(render.draw_uniform_changes, previous.render.draw_uniform_changes,) as f64 / interval_divisor,+ delta(render.vertex_stride_changes, previous.render.vertex_stride_changes,) as f64 / interval_divisor,+ interval_potential_draws as f64 / interval_divisor,+ interval_reduction_pct,+ delta(render.viewport_changes, previous.render.viewport_changes) as f64 / interval_divisor,+ delta(render.scissor_changes, previous.render.scissor_changes) as f64 / interval_divisor,+ delta(render.draw_pass_encode_ns, previous.render.draw_pass_encode_ns) as f64+ / interval_divisor+ / 1_000.0,+ delta(render.worker_batch_cpu_ns, previous.render.worker_batch_cpu_ns) as f64+ / interval_divisor+ / 1_000.0,+ delta(render.queue_wait_ns, previous.render.queue_wait_ns) as f64 / interval_divisor / 1_000.0,+ delta(render.efb_drain_wait_ns, previous.render.efb_drain_wait_ns) as f64 / interval_divisor / 1_000.0,+ delta(render.efb_drain_requests, previous.render.efb_drain_requests) as f64 / interval_divisor,+ delta(render.efb_drain_nonempty, previous.render.efb_drain_nonempty) as f64 / interval_divisor,+ delta(render.efb_writebacks, previous.render.efb_writebacks) as f64 / interval_divisor,+ delta(render.efb_writeback_cpu_ns, previous.render.efb_writeback_cpu_ns) as f64+ / interval_divisor+ / 1_000.0,+ delta(render.queue_submit_cpu_ns, previous.render.queue_submit_cpu_ns) as f64+ / interval_divisor+ / 1_000.0,+ )?;+ writeln!(+ f,+ "\n--- renderer averages per XFB present ---\ndraws={:.2}\ndraw_passes={:.2}\npipeline_changes={:.2}\npipelines_created={:.2}\npipeline_create_cpu_us={:.2}\nshader_modules_created={:.2}\nshader_create_cpu_us={:.2}\nbind_group_sets={:.2}\nbind_groups_created={:.2}\nbind_group_key_changes={:.2}\nframe_uniform_changes={:.2}\ndraw_uniform_changes={:.2}\nvertex_stride_changes={:.2}\npotential_merged_draws={:.2}\npotential_draw_reduction_pct={:.2}\nviewport_changes={:.2}\nscissor_changes={:.2}\ndraw_pass_encode_cpu_us={:.2}\nworker_cpu_us={:.2}\nqueue_wait_us={:.2}\nefb_drain_wait_us={:.2}\nefb_drain_requests={:.2}\nefb_drain_nonempty={:.2}\nefb_writebacks={:.2}\nefb_writeback_cpu_us={:.2}\nqueue_submit_cpu_us={:.2}",+ render.draws_encoded as f64 / presents,+ render.draw_render_passes as f64 / presents,+ render.pipeline_changes as f64 / presents,+ render.pipelines_created as f64 / presents,+ render.pipeline_create_cpu_ns as f64 / presents / 1_000.0,+ render.shader_modules_created as f64 / presents,+ render.shader_create_cpu_ns as f64 / presents / 1_000.0,+ render.bind_group_sets as f64 / presents,+ render.bind_groups_created as f64 / presents,+ render.bind_group_key_changes as f64 / presents,+ render.frame_uniform_changes as f64 / presents,+ render.draw_uniform_changes as f64 / presents,+ render.vertex_stride_changes as f64 / presents,+ render.potential_merged_draws as f64 / presents,+ cumulative_reduction_pct,+ render.viewport_changes as f64 / presents,+ render.scissor_changes as f64 / presents,+ render.draw_pass_encode_ns as f64 / presents / 1_000.0,+ render.worker_batch_cpu_ns as f64 / presents / 1_000.0,+ render.queue_wait_ns as f64 / presents / 1_000.0,+ render.efb_drain_wait_ns as f64 / presents / 1_000.0,+ render.efb_drain_requests as f64 / presents,+ render.efb_drain_nonempty as f64 / presents,+ render.efb_writebacks as f64 / presents,+ render.efb_writeback_cpu_ns as f64 / presents / 1_000.0,+ render.queue_submit_cpu_ns as f64 / presents / 1_000.0,)?;writeln!(f, "\n--- draws by primitive ---")?;@@ -440,7 +575,13 @@ impl<const SYSTEM: SystemId> System<SYSTEM> {});if let Err(err) = result {- tracing::warn!(?err, "gx-stats sidecar write failed");+ tracing::warn!(?err, "gx-stats write failed");+ } else {+ self.gx_stats_dump_state = Some(GxStatsDumpState {+ vsync_count: self.vsync_count,+ gx: s,+ render,+ });}}@@ -468,11 +609,11 @@ impl<const SYSTEM: SystemId> System<SYSTEM> {}#[cfg(feature = "jit")]- self.dump_idle_skip_sidecar();+ self.dump_idle_skip();}#[cfg(all(feature = "jit-stats", feature = "jit"))]- fn dump_idle_skip_sidecar(&self) {+ fn dump_idle_skip(&self) {use std::io::Write;use std::sync::atomic::Ordering;@@ -561,7 +702,7 @@ impl<const SYSTEM: SystemId> System<SYSTEM> {Ok(())});if let Err(err) = result {- tracing::warn!(?err, "idle-skip sidecar write failed");+ tracing::warn!(?err, "idle-skip write failed");}}diff --git a/crates/tinyapp/Cargo.toml b/crates/tinyapp/Cargo.tomlindex 28e382c..e57feba 100644--- a/crates/tinyapp/Cargo.toml+++ b/crates/tinyapp/Cargo.toml@@ -11,7 +11,7 @@ renderdoc-capture = ["backend-wgpu/renderdoc-capture"]audio-wav-dump = ["gecko/audio-wav-dump"]fps-counter = ["gecko/fps-counter"]jit-stats = ["gecko/jit-stats"]-gx-stats = ["gecko/gx-stats"]+gx-stats = ["gecko/gx-stats", "backend-wgpu/gx-stats"]profile = ["gecko/profile"]hotpath = ["dep:hotpath", "gecko/hotpath", "backend-wgpu/hotpath"]hotpath-alloc = ["hotpath", "hotpath/hotpath-alloc"]diff --git a/crates/tinyapp/src/main.rs b/crates/tinyapp/src/main.rsindex 45a0a9c..b27b594 100644--- a/crates/tinyapp/src/main.rs+++ b/crates/tinyapp/src/main.rs@@ -121,23 +121,23 @@ struct Args {#[arg(long)]no_cap: bool,- /// Enable per-block JIT heatmap CSV dumps (requires --features jit-stats)- #[cfg(feature = "jit-stats")]+ /// Enable periodic profiling dumps.+ #[cfg(any(feature = "jit-stats", feature = "gx-stats"))]#[arg(long)]heatmap: bool,/// Frames between heatmap CSV writes- #[cfg(feature = "jit-stats")]+ #[cfg(any(feature = "jit-stats", feature = "gx-stats"))]#[arg(long, default_value_t = 60)]heatmap_interval_frames: u32,/// Output directory for heatmap CSV files- #[cfg(feature = "jit-stats")]+ #[cfg(any(feature = "jit-stats", feature = "gx-stats"))]#[arg(long, default_value = "./profile-dumps")]heatmap_out: String,/// Top-K rows per heatmap CSV- #[cfg(feature = "jit-stats")]+ #[cfg(any(feature = "jit-stats", feature = "gx-stats"))]#[arg(long, default_value_t = 64)]heatmap_top_k: usize,@@ -322,7 +322,7 @@ fn configure<const SYSTEM: SystemId>(emulator: &mut System<SYSTEM>, args: &Args)emulator.apply_host_input(&HostInput::neutral_for(SYSTEM));- #[cfg(feature = "jit-stats")]+ #[cfg(any(feature = "jit-stats", feature = "gx-stats"))]{emulator.heatmap = gecko::profile::HeatmapConfig {enabled: args.heatmap,