Skip to content

armgit / gecko

Public Imported from GitHub
0

A GameCube/Wii emulator and debugger written in Rust.

MORE OPTIMIZATIOOOOOOOOOOOON

Laylec70013784b45
diff --git a/crates/backend-wgpu/src/lib.rs b/crates/backend-wgpu/src/lib.rs
index 6bb4a3d..dbd022f 100644
--- a/crates/backend-wgpu/src/lib.rs
+++ b/crates/backend-wgpu/src/lib.rs
@@ -11,6 +11,15 @@ use pipeline::PipelineKey;
use std::collections::HashMap;
use triangulate::{GpuVertex, align_up};
+type TexKey = (usize, u32, u32, TextureFormat);
+type SamplerKey = (WrapMode, WrapMode, MagFilter, MinFilter);
+
+#[derive(Clone, PartialEq, Eq, Hash)]
+pub(crate) struct BindGroupCacheKey {
+ tex_keys: [Option<TexKey>; 8],
+ sampler_keys: [Option<SamplerKey>; 8],
+}
+
#[derive(encase::ShaderType)]
pub(crate) struct FrameUniforms {
tev_color_regs: [glam::Vec4; 4],
@@ -64,6 +73,7 @@ pub struct GxRenderer {
pub(crate) scratch_vertices: Vec<GpuVertex>,
pub(crate) scratch_draws: Vec<(u32, u32)>,
pub(crate) scratch_uniform_bytes: Vec<u8>,
+ pub(crate) bind_group_cache: HashMap<BindGroupCacheKey, wgpu::BindGroup>,
}
impl GxRenderer {
@@ -93,7 +103,7 @@ impl GxRenderer {
visibility: wgpu::ShaderStages::VERTEX | wgpu::ShaderStages::FRAGMENT,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
- has_dynamic_offset: false,
+ has_dynamic_offset: true,
min_binding_size: Some(FrameUniforms::min_size()),
},
count: None,
@@ -230,6 +240,7 @@ impl GxRenderer {
scratch_vertices: Vec::new(),
scratch_draws: Vec::new(),
scratch_uniform_bytes: Vec::new(),
+ bind_group_cache: HashMap::new(),
}
}
diff --git a/crates/backend-wgpu/src/render.rs b/crates/backend-wgpu/src/render.rs
index 98fb91f..5192d71 100644
--- a/crates/backend-wgpu/src/render.rs
+++ b/crates/backend-wgpu/src/render.rs
@@ -1,3 +1,4 @@
+use crate::BindGroupCacheKey;
use crate::pipeline::PipelineKey;
use crate::triangulate::{self, GpuVertex, align_up};
use crate::{DrawUniforms, FrameUniforms, GxRenderer, helpers, texture};
@@ -166,6 +167,7 @@ impl GxRenderer {
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
+ self.bind_group_cache.clear();
}
queue.write_buffer(&self.frame_uniform_buffer, 0, frame_uniform_bytes);
@@ -174,7 +176,7 @@ impl GxRenderer {
}
fn execute_render_pass(
- &self,
+ &mut self,
device: &wgpu::Device,
queue: &wgpu::Queue,
commands: &DrawCommands,
@@ -187,6 +189,66 @@ impl GxRenderer {
device.limits().min_uniform_buffer_offset_alignment as u64,
) as usize;
+ // Pre-build bind groups for each unique texture/sampler configuration.
+ for &dc_idx in draw_call_indices {
+ let dc = &commands.commands[dc_idx];
+ let mut tex_keys: [Option<_>; 8] = [None; 8];
+ let mut sampler_keys: [Option<_>; 8] = [None; 8];
+
+ for slot in 0..8 {
+ if let Some(desc) = &dc.textures[slot] {
+ tex_keys[slot] = Some((desc.ram_addr, desc.width, desc.height, desc.format));
+ sampler_keys[slot] = Some((desc.wrap_s, desc.wrap_t, desc.mag_filter, desc.min_filter));
+ }
+ }
+
+ let bg_key = BindGroupCacheKey { tex_keys, sampler_keys };
+ self.bind_group_cache.entry(bg_key).or_insert_with(|| {
+ let mut tex_views: [&wgpu::TextureView; 8] = [&self.fallback_view; 8];
+ let mut tex_samplers: [&wgpu::Sampler; 8] = [&self.sampler_cache[&fallback_sampler_key]; 8];
+
+ for slot in 0..8 {
+ if let Some(tk) = &tex_keys[slot] {
+ tex_views[slot] = &self.texture_cache[tk].1;
+ tex_samplers[slot] = &self.sampler_cache[&sampler_keys[slot].unwrap()];
+ }
+ }
+
+ let entries: [wgpu::BindGroupEntry; 18] = std::array::from_fn(|i| match i {
+ 0 => wgpu::BindGroupEntry {
+ binding: 0,
+ resource: wgpu::BindingResource::Buffer(wgpu::BufferBinding {
+ buffer: &self.frame_uniform_buffer,
+ offset: 0,
+ size: Some(FrameUniforms::min_size()),
+ }),
+ },
+ 1 => wgpu::BindGroupEntry {
+ binding: 1,
+ resource: wgpu::BindingResource::Buffer(wgpu::BufferBinding {
+ buffer: &self.draw_uniform_buffer,
+ offset: 0,
+ size: Some(DrawUniforms::min_size()),
+ }),
+ },
+ 2..=9 => wgpu::BindGroupEntry {
+ binding: i as u32,
+ resource: wgpu::BindingResource::TextureView(tex_views[i - 2]),
+ },
+ _ => wgpu::BindGroupEntry {
+ binding: i as u32,
+ resource: wgpu::BindingResource::Sampler(tex_samplers[i - 10]),
+ },
+ });
+
+ device.create_bind_group(&wgpu::BindGroupDescriptor {
+ label: None,
+ layout: &self.bind_group_layout,
+ entries: &entries,
+ })
+ });
+ }
+
let mut encoder = device.create_command_encoder(&Default::default());
{
let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
@@ -220,57 +282,21 @@ impl GxRenderer {
let pipeline = &self.pipeline_cache[&pipeline_key];
rpass.set_pipeline(pipeline);
- let mut tex_views: [&wgpu::TextureView; 8] = [&self.fallback_view; 8];
- let mut tex_samplers: [&wgpu::Sampler; 8] = [&self.sampler_cache[&fallback_sampler_key]; 8];
+ let mut tex_keys: [Option<_>; 8] = [None; 8];
+ let mut sampler_keys: [Option<_>; 8] = [None; 8];
for slot in 0..8 {
if let Some(desc) = &dc.textures[slot] {
- let tex_key = (desc.ram_addr, desc.width, desc.height, desc.format);
- let sampler_key = (desc.wrap_s, desc.wrap_t, desc.mag_filter, desc.min_filter);
- tex_views[slot] = &self.texture_cache[&tex_key].1;
- tex_samplers[slot] = &self.sampler_cache[&sampler_key];
+ tex_keys[slot] = Some((desc.ram_addr, desc.width, desc.height, desc.format));
+ sampler_keys[slot] = Some((desc.wrap_s, desc.wrap_t, desc.mag_filter, desc.min_filter));
}
}
+
+ let bg_key = BindGroupCacheKey { tex_keys, sampler_keys };
+ let bind_group = &self.bind_group_cache[&bg_key];
- let frame_offset = (index as u64 * frame_stride as u64) as wgpu::BufferAddress;
+ let frame_offset = (index * frame_stride) as u32;
let draw_offset = (index as u64 * self.draw_uniform_stride) as u32;
-
- let mut entries = vec![
- wgpu::BindGroupEntry {
- binding: 0,
- resource: wgpu::BindingResource::Buffer(wgpu::BufferBinding {
- buffer: &self.frame_uniform_buffer,
- offset: frame_offset,
- size: Some(FrameUniforms::min_size()),
- }),
- },
- wgpu::BindGroupEntry {
- binding: 1,
- resource: wgpu::BindingResource::Buffer(wgpu::BufferBinding {
- buffer: &self.draw_uniform_buffer,
- offset: 0,
- size: Some(DrawUniforms::min_size()),
- }),
- },
- ];
- for i in 0..8u32 {
- entries.push(wgpu::BindGroupEntry {
- binding: 2 + i,
- resource: wgpu::BindingResource::TextureView(tex_views[i as usize]),
- });
- }
- for i in 0..8u32 {
- entries.push(wgpu::BindGroupEntry {
- binding: 10 + i,
- resource: wgpu::BindingResource::Sampler(tex_samplers[i as usize]),
- });
- }
- let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
- label: None,
- layout: &self.bind_group_layout,
- entries: &entries,
- });
-
- rpass.set_bind_group(0, &bind_group, &[draw_offset]);
+ rpass.set_bind_group(0, bind_group, &[frame_offset, draw_offset]);
rpass.draw(first_vertex..first_vertex + vertex_count, 0..1);
}
}
@@ -290,6 +316,7 @@ impl GxRenderer {
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
+ self.bind_group_cache.clear();
}
}
diff --git a/crates/debugger/src/render.rs b/crates/debugger/src/render.rs
index 02311d9..915fa51 100644
--- a/crates/debugger/src/render.rs
+++ b/crates/debugger/src/render.rs
@@ -440,7 +440,7 @@ impl RenderState {
// Clear after egui so the GX state window can inspect the draw calls from this frame.
if used_gx {
- emulator.gx.draw_commands.commands.clear();
+ emulator.gx.draw_commands.recycle();
}
}
diff --git a/crates/gecko/src/flipper/gx/draw.rs b/crates/gecko/src/flipper/gx/draw.rs
index b2f3f4b..b5f08f1 100644
--- a/crates/gecko/src/flipper/gx/draw.rs
+++ b/crates/gecko/src/flipper/gx/draw.rs
@@ -134,4 +134,24 @@ impl std::ops::Mul for Matrix4 {
pub struct DrawCommands {
pub projection: Matrix4,
pub commands: Vec<DrawCall>,
+ vertex_pool: Vec<Vec<Vertex>>,
+}
+
+impl DrawCommands {
+ pub fn recycle(&mut self) {
+ for dc in self.commands.drain(..) {
+ let mut buf = dc.vertices;
+ buf.clear();
+ self.vertex_pool.push(buf);
+ }
+ }
+
+ pub fn take_vertex_buf(&mut self, capacity: usize) -> Vec<Vertex> {
+ if let Some(mut buf) = self.vertex_pool.pop() {
+ buf.reserve(capacity.saturating_sub(buf.capacity()));
+ buf
+ } else {
+ Vec::with_capacity(capacity)
+ }
+ }
}
diff --git a/crates/gecko/src/flipper/gx/vertex.rs b/crates/gecko/src/flipper/gx/vertex.rs
index 6ed822b..954cfea 100644
--- a/crates/gecko/src/flipper/gx/vertex.rs
+++ b/crates/gecko/src/flipper/gx/vertex.rs
@@ -55,7 +55,7 @@ impl GraphicsProcessor {
let vertex_count = data.len() / vf.vertex_stride;
- let mut vertices: Vec<draw::Vertex> = Vec::with_capacity(vertex_count);
+ let mut vertices = self.draw_commands.take_vertex_buf(vertex_count);
let mut cur = Cursor::new(&data);
for i in 0..vertex_count {
diff --git a/crates/tinyapp/src/main.rs b/crates/tinyapp/src/main.rs
index 964f209..e85646c 100644
--- a/crates/tinyapp/src/main.rs
+++ b/crates/tinyapp/src/main.rs
@@ -308,7 +308,7 @@ impl State {
self.surface_config.width,
self.surface_config.height,
);
- emulator.gx.draw_commands.commands.clear();
+ emulator.gx.draw_commands.recycle();
}
fn render_xfb(&mut self, emulator: &GameCube, view: &wgpu::TextureView) {
diff --git a/crates/tinybench/src/main.rs b/crates/tinybench/src/main.rs
index a2e0e6c..e62c74f 100644
--- a/crates/tinybench/src/main.rs
+++ b/crates/tinybench/src/main.rs
@@ -74,7 +74,7 @@ fn run_bench(emulator: &mut GameCube, args: &Args) {
let frame_start = Instant::now();
emulator.run_until_vsync();
- emulator.gx.draw_commands.commands.clear();
+ emulator.gx.draw_commands.recycle();
let frame_time = frame_start.elapsed().as_secs_f64();
frame_count += 1;
diff --git a/crates/web/src/lib.rs b/crates/web/src/lib.rs
index 8bb0006..bd49f8d 100644
--- a/crates/web/src/lib.rs
+++ b/crates/web/src/lib.rs
@@ -318,7 +318,7 @@ impl State {
frame.present();
if used_gx {
- emulator.gx.draw_commands.commands.clear();
+ emulator.gx.draw_commands.recycle();
}
}