A GameCube/Wii emulator and debugger written in Rust.
split uniforms into per-frame and per-draw buffers, only mvp matrix changes between all draws in a frame
Layle3598640b9f5b
diff --git a/crates/backend-wgpu/src/gx.wgsl b/crates/backend-wgpu/src/gx.wgslindex 79c630d..59fa388 100644--- a/crates/backend-wgpu/src/gx.wgsl+++ b/crates/backend-wgpu/src/gx.wgsl@@ -1,17 +1,11 @@-struct Uniforms {- mvp: mat4x4<f32>,- // TEV color registers: TEVPREV, TEVREG0-2 as float RGBA+struct FrameUniforms {tev_color_reg0: vec4<f32>,tev_color_reg1: vec4<f32>,tev_color_reg2: vec4<f32>,tev_color_reg3: vec4<f32>,- // Raw bitfields packed as vec4<u32> (16 u32s = 4 vec4s)tev_color_env: array<vec4<u32>, 4>,tev_alpha_env: array<vec4<u32>, 4>,- tev_stage_orders: array<vec4<u32>, 4>,- // Number of active TEV stages (0-16)num_tev_stages: u32,- // Alpha compare parametersalpha_ref0: f32,alpha_ref1: f32,alpha_comp0: u32,@@ -19,13 +13,20 @@ struct Uniforms {alpha_op: u32,};+struct DrawUniforms {+ mvp: mat4x4<f32>,+};+@group(0) @binding(0)-var<uniform> uniforms: Uniforms;+var<uniform> frame: FrameUniforms;@group(0) @binding(1)-var tex: texture_2d<f32>;+var<uniform> draw: DrawUniforms;@group(0) @binding(2)+var tex: texture_2d<f32>;++@group(0) @binding(3)var tex_sampler: sampler;struct VsIn {@@ -43,7 +44,7 @@ struct VsOut {@vertexfn vs_main(in: VsIn) -> VsOut {var out: VsOut;- out.clip_pos = uniforms.mvp * vec4<f32>(in.position, 1.0);+ out.clip_pos = draw.mvp * vec4<f32>(in.position, 1.0);// Remap depth: GameCube/OpenGL uses [-1,1], wgpu uses [0,1]out.clip_pos.z = out.clip_pos.z * 0.5 + out.clip_pos.w * 0.5;out.color = in.color;@@ -194,16 +195,16 @@ fn alpha_combine(a: bool, b: bool, op: u32) -> bool {fn fs_main(in: VsOut) -> @location(0) vec4<f32> {// Initialize TEV registers from uniformsvar regs: array<vec4<f32>, 4>;- regs[0] = uniforms.tev_color_reg0;- regs[1] = uniforms.tev_color_reg1;- regs[2] = uniforms.tev_color_reg2;- regs[3] = uniforms.tev_color_reg3;+ regs[0] = frame.tev_color_reg0;+ regs[1] = frame.tev_color_reg1;+ regs[2] = frame.tev_color_reg2;+ regs[3] = frame.tev_color_reg3;// Inputs available to TEV stageslet ras_color = in.color;let tex_color = textureSample(tex, tex_sampler, in.tex0);- let num_stages = uniforms.num_tev_stages;+ let num_stages = frame.num_tev_stages;for (var stage = 0u; stage < 16u; stage++) {if stage >= num_stages {@@ -211,7 +212,7 @@ fn fs_main(in: VsOut) -> @location(0) vec4<f32> {}// Combine colors- let cenv = read_packed(uniforms.tev_color_env, stage);+ let cenv = read_packed(frame.tev_color_env, stage);// TevColorEnv bit layout (LSB0):// [3:0]=d [7:4]=c [11:8]=b [15:12]=a@@ -236,7 +237,7 @@ fn fs_main(in: VsOut) -> @location(0) vec4<f32> {regs[c_dest] = vec4(color_result, regs[c_dest].a);// Combine alpha- let aenv = read_packed(uniforms.tev_alpha_env, stage);+ let aenv = read_packed(frame.tev_alpha_env, stage);// TevAlphaEnv bit layout (LSB0):// [6:4]=d [9:7]=c [12:10]=b [15:13]=a@@ -265,9 +266,9 @@ fn fs_main(in: VsOut) -> @location(0) vec4<f32> {// Output is always TEVPREV (regs[0])let color = regs[0];- let c0 = alpha_compare(color.a, uniforms.alpha_ref0, uniforms.alpha_comp0);- let c1 = alpha_compare(color.a, uniforms.alpha_ref1, uniforms.alpha_comp1);- if !alpha_combine(c0, c1, uniforms.alpha_op) {+ 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) {discard;}diff --git a/crates/backend-wgpu/src/helpers.rs b/crates/backend-wgpu/src/helpers.rsindex 33b8d8c..38eecc3 100644--- a/crates/backend-wgpu/src/helpers.rs+++ b/crates/backend-wgpu/src/helpers.rs@@ -71,22 +71,3 @@ pub fn decode_tev_color_regs(lo: &[TevRegisterL; 4], hi: &[TevRegisterH; 4]) ->}out}--pub fn unpack_tev_orders(orders: &[u32; 8]) -> [u32; 16] {- let mut out = [0u32; 16];- for stage in 0..16u32 {- let reg_idx = (stage / 2) as usize;- if reg_idx < 8 {- let raw = orders[reg_idx];- if stage % 2 == 0 {- out[stage as usize] = raw & 0x3FF; // low 10 bits- } else {- out[stage as usize] = ((raw >> 12) & 0x7)- | (((raw >> 15) & 0x7) << 3)- | (((raw >> 18) & 0x1) << 6)- | (((raw >> 19) & 0x7) << 7);- }- }- }- out-}diff --git a/crates/backend-wgpu/src/lib.rs b/crates/backend-wgpu/src/lib.rsindex b87ed32..9aa40ad 100644--- a/crates/backend-wgpu/src/lib.rs+++ b/crates/backend-wgpu/src/lib.rs@@ -25,19 +25,23 @@ impl From<&gekko::flipper::gx::draw::Vertex> for GpuVertex {#[repr(C)]#[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]-struct Uniforms {- mvp: [[f32; 4]; 4], // 64B- tev_color_regs: [[f32; 4]; 4], // 64B — TEVPREV, TEVREG0-2 as float RGBA- tev_color_env: [u32; 16], // 64B — raw bitfields per stage- tev_alpha_env: [u32; 16], // 64B — raw bitfields per stage- tev_stage_orders: [u32; 16], // 64B — pre-unpacked per-stage order- num_tev_stages: u32, // 4B- alpha_ref0: f32, // 4B- alpha_ref1: f32, // 4B- alpha_comp0: u32, // 4B- alpha_comp1: u32, // 4B- alpha_op: u32, // 4B- _padding: [u32; 2], // 8B — pad to 16-byte alignment+struct FrameUniforms {+ tev_color_regs: [[f32; 4]; 4],+ tev_color_env: [u32; 16],+ tev_alpha_env: [u32; 16],+ num_tev_stages: u32,+ alpha_ref0: f32,+ alpha_ref1: f32,+ alpha_comp0: u32,+ alpha_comp1: u32,+ alpha_op: u32,+ _padding: [u32; 2],+}++#[repr(C)]+#[derive(Clone, Copy, bytemuck::Pod, bytemuck::Zeroable)]+struct DrawUniforms {+ mvp: [[f32; 4]; 4],}const SHADER: &str = include_str!("gx.wgsl");@@ -76,9 +80,10 @@ pub struct GxRenderer {surface_format: wgpu::TextureFormat,bind_group_layout: wgpu::BindGroupLayout,bind_group: wgpu::BindGroup,- uniform_buffer: wgpu::Buffer,- uniform_stride: u64,- uniform_capacity: usize,+ frame_uniform_buffer: wgpu::Buffer,+ draw_uniform_buffer: wgpu::Buffer,+ draw_uniform_stride: u64,+ draw_uniform_capacity: usize,vertex_buffer: wgpu::Buffer,vertex_capacity: usize,depth_texture: wgpu::Texture,@@ -105,8 +110,9 @@ impl GxRenderer {width: u32,height: u32,) -> Self {- let uniform_size = std::mem::size_of::<Uniforms>() as u64;- let uniform_stride = align_up(uniform_size, device.limits().min_uniform_buffer_offset_alignment as u64);+ let frame_uniform_size = std::mem::size_of::<FrameUniforms>() as u64;+ let draw_uniform_size = std::mem::size_of::<DrawUniforms>() as u64;+ let draw_uniform_stride = align_up(draw_uniform_size, device.limits().min_uniform_buffer_offset_alignment as u64);let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {label: Some("gx_shader"),@@ -121,13 +127,23 @@ impl GxRenderer {visibility: wgpu::ShaderStages::VERTEX | wgpu::ShaderStages::FRAGMENT,ty: wgpu::BindingType::Buffer {ty: wgpu::BufferBindingType::Uniform,- has_dynamic_offset: true,- min_binding_size: wgpu::BufferSize::new(uniform_size),+ has_dynamic_offset: false,+ min_binding_size: wgpu::BufferSize::new(frame_uniform_size),},count: None,},wgpu::BindGroupLayoutEntry {binding: 1,+ visibility: wgpu::ShaderStages::VERTEX,+ ty: wgpu::BindingType::Buffer {+ ty: wgpu::BufferBindingType::Uniform,+ has_dynamic_offset: true,+ min_binding_size: wgpu::BufferSize::new(draw_uniform_size),+ },+ count: None,+ },+ wgpu::BindGroupLayoutEntry {+ binding: 2,visibility: wgpu::ShaderStages::FRAGMENT,ty: wgpu::BindingType::Texture {sample_type: wgpu::TextureSampleType::Float { filterable: true },@@ -137,7 +153,7 @@ impl GxRenderer {count: None,},wgpu::BindGroupLayoutEntry {- binding: 2,+ binding: 3,visibility: wgpu::ShaderStages::FRAGMENT,ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),count: None,@@ -151,9 +167,16 @@ impl GxRenderer {immediate_size: 0,});- let uniform_buffer = device.create_buffer(&wgpu::BufferDescriptor {- label: Some("gx_uniforms"),- size: uniform_stride,+ let frame_uniform_buffer = device.create_buffer(&wgpu::BufferDescriptor {+ label: Some("gx_frame_uniforms"),+ size: frame_uniform_size,+ usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,+ mapped_at_creation: false,+ });++ let draw_uniform_buffer = device.create_buffer(&wgpu::BufferDescriptor {+ label: Some("gx_draw_uniforms"),+ size: draw_uniform_stride,usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,mapped_at_creation: false,});@@ -205,17 +228,25 @@ impl GxRenderer {wgpu::BindGroupEntry {binding: 0,resource: wgpu::BindingResource::Buffer(wgpu::BufferBinding {- buffer: &uniform_buffer,+ buffer: &frame_uniform_buffer,offset: 0,- size: wgpu::BufferSize::new(uniform_size),+ size: wgpu::BufferSize::new(frame_uniform_size),}),},wgpu::BindGroupEntry {binding: 1,- resource: wgpu::BindingResource::TextureView(&fallback_view),+ resource: wgpu::BindingResource::Buffer(wgpu::BufferBinding {+ buffer: &draw_uniform_buffer,+ offset: 0,+ size: wgpu::BufferSize::new(draw_uniform_size),+ }),},wgpu::BindGroupEntry {binding: 2,+ resource: wgpu::BindingResource::TextureView(&fallback_view),+ },+ wgpu::BindGroupEntry {+ binding: 3,resource: wgpu::BindingResource::Sampler(&sampler),},],@@ -240,9 +271,10 @@ impl GxRenderer {surface_format,bind_group_layout,bind_group,- uniform_buffer,- uniform_stride,- uniform_capacity: 1,+ frame_uniform_buffer,+ draw_uniform_buffer,+ draw_uniform_stride,+ draw_uniform_capacity: 1,vertex_buffer,vertex_capacity: initial_capacity,depth_texture,@@ -390,11 +422,18 @@ impl GxRenderer {}let alpha_cmp = commands.bp_alpha_compare;- let tev_color_regs = helpers::decode_tev_color_regs(&commands.tev_color_regs_lo, &commands.tev_color_regs_hi);- let tev_color_env = commands.tev_color_env.map(|e| e.raw());- let tev_alpha_env = commands.tev_alpha_env.map(|e| e.raw());- let tev_stage_orders = helpers::unpack_tev_orders(&commands.tev_orders);- let num_tev_stages = commands.num_tev_stages as u32;+ let frame_uniform = FrameUniforms {+ tev_color_regs: helpers::decode_tev_color_regs(&commands.tev_color_regs_lo, &commands.tev_color_regs_hi),+ tev_color_env: commands.tev_color_env.map(|e| e.raw()),+ tev_alpha_env: commands.tev_alpha_env.map(|e| e.raw()),+ num_tev_stages: commands.num_tev_stages as u32,+ alpha_ref0: alpha_cmp.ref0() as f32 / 255.0,+ alpha_ref1: alpha_cmp.ref1() as f32 / 255.0,+ alpha_comp0: alpha_cmp.comp0() as u32,+ alpha_comp1: alpha_cmp.comp1() as u32,+ alpha_op: alpha_cmp.op() as u32,+ _padding: [0; 2],+ };// Get or create the pipeline for current blend/z statelet pipeline_key = PipelineKey::from_draw_commands(commands);@@ -431,8 +470,8 @@ impl GxRenderer {self.scratch_draws.clear();self.scratch_uniform_bytes.clear();- let stride = self.uniform_stride as usize;- let uniform_size = std::mem::size_of::<Uniforms>();+ let stride = self.draw_uniform_stride as usize;+ let draw_size = std::mem::size_of::<DrawUniforms>();for dc in &commands.commands {let prev_len = self.scratch_vertices.len();@@ -443,23 +482,10 @@ impl GxRenderer {}let mvp = commands.projection * dc.modelview;- let uniform = Uniforms {- mvp: mvp.0,- tev_color_regs,- tev_color_env,- tev_alpha_env,- tev_stage_orders,- num_tev_stages,- alpha_ref0: alpha_cmp.ref0() as f32 / 255.0,- alpha_ref1: alpha_cmp.ref1() as f32 / 255.0,- alpha_comp0: alpha_cmp.comp0() as u32,- alpha_comp1: alpha_cmp.comp1() as u32,- alpha_op: alpha_cmp.op() as u32,- _padding: [0; 2],- };+ let draw_uniform = DrawUniforms { mvp: mvp.0 };let start = self.scratch_draws.len() * stride;self.scratch_uniform_bytes.resize(start + stride, 0);- self.scratch_uniform_bytes[start..start + uniform_size].copy_from_slice(bytemuck::bytes_of(&uniform));+ self.scratch_uniform_bytes[start..start + draw_size].copy_from_slice(bytemuck::bytes_of(&draw_uniform));self.scratch_draws.push((prev_len as u32, added as u32));}@@ -467,7 +493,7 @@ impl GxRenderer {return;}- self.ensure_uniform_capacity(device, self.scratch_draws.len());+ self.ensure_draw_capacity(device, self.scratch_draws.len());if self.scratch_vertices.len() > self.vertex_capacity {self.vertex_capacity = self.scratch_vertices.len().next_power_of_two();@@ -488,7 +514,8 @@ impl GxRenderer {&self.fallback_view};- queue.write_buffer(&self.uniform_buffer, 0, &self.scratch_uniform_bytes);+ queue.write_buffer(&self.frame_uniform_buffer, 0, bytemuck::bytes_of(&frame_uniform));+ queue.write_buffer(&self.draw_uniform_buffer, 0, &self.scratch_uniform_bytes);queue.write_buffer(&self.vertex_buffer, 0, bytemuck::cast_slice(&self.scratch_vertices));self.bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {@@ -498,17 +525,25 @@ impl GxRenderer {wgpu::BindGroupEntry {binding: 0,resource: wgpu::BindingResource::Buffer(wgpu::BufferBinding {- buffer: &self.uniform_buffer,+ buffer: &self.frame_uniform_buffer,offset: 0,- size: wgpu::BufferSize::new(std::mem::size_of::<Uniforms>() as u64),+ size: wgpu::BufferSize::new(std::mem::size_of::<FrameUniforms>() as u64),}),},wgpu::BindGroupEntry {binding: 1,- resource: wgpu::BindingResource::TextureView(tex_view),+ resource: wgpu::BindingResource::Buffer(wgpu::BufferBinding {+ buffer: &self.draw_uniform_buffer,+ offset: 0,+ size: wgpu::BufferSize::new(std::mem::size_of::<DrawUniforms>() as u64),+ }),},wgpu::BindGroupEntry {binding: 2,+ resource: wgpu::BindingResource::TextureView(tex_view),+ },+ wgpu::BindGroupEntry {+ binding: 3,resource: wgpu::BindingResource::Sampler(sampler),},],@@ -545,8 +580,8 @@ impl GxRenderer {rpass.set_vertex_buffer(0, self.vertex_buffer.slice(..));for (index, (first_vertex, vertex_count)) in self.scratch_draws.iter().copied().enumerate() {- let uniform_offset = (index as u64 * self.uniform_stride) as u32;- rpass.set_bind_group(0, &self.bind_group, &[uniform_offset]);+ let draw_offset = (index as u64 * self.draw_uniform_stride) as u32;+ rpass.set_bind_group(0, &self.bind_group, &[draw_offset]);rpass.draw(first_vertex..first_vertex + vertex_count, 0..1);}}@@ -554,15 +589,15 @@ impl GxRenderer {queue.submit([encoder.finish()]);}- fn ensure_uniform_capacity(&mut self, device: &wgpu::Device, count: usize) {- if count <= self.uniform_capacity {+ fn ensure_draw_capacity(&mut self, device: &wgpu::Device, count: usize) {+ if count <= self.draw_uniform_capacity {return;}- self.uniform_capacity = count.next_power_of_two();- self.uniform_buffer = device.create_buffer(&wgpu::BufferDescriptor {- label: Some("gx_uniforms"),- size: self.uniform_stride * self.uniform_capacity as u64,+ self.draw_uniform_capacity = count.next_power_of_two();+ self.draw_uniform_buffer = device.create_buffer(&wgpu::BufferDescriptor {+ label: Some("gx_draw_uniforms"),+ size: self.draw_uniform_stride * self.draw_uniform_capacity as u64,usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,mapped_at_creation: false,});