Skip to content

armgit / gecko

Public Imported from GitHub
0

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.wgsl
index 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 parameters
alpha_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 {
@vertex
fn 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 uniforms
var 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 stages
let 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.rs
index 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.rs
index 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 state
let 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,
});