Skip to content

armgit / gecko

Public Imported from GitHub
0

A GameCube/Wii emulator and debugger written in Rust.

SETMODE implemented and refactored backend a bit

Layle6126d0ac454f
diff --git a/crates/backend-wgpu/src/helpers.rs b/crates/backend-wgpu/src/helpers.rs
new file mode 100644
index 0000000..3c7d352
--- /dev/null
+++ b/crates/backend-wgpu/src/helpers.rs
@@ -0,0 +1,90 @@
+use gekko::flipper::gx::regs::{BlendFactor, CompareFunc, MagFilter, MinFilter, TevRegisterH, TevRegisterL, WrapMode};
+
+pub fn map_wrap_mode(wrap: WrapMode) -> wgpu::AddressMode {
+ match wrap {
+ WrapMode::Clamp => wgpu::AddressMode::ClampToEdge,
+ WrapMode::Repeat => wgpu::AddressMode::Repeat,
+ WrapMode::Mirror => wgpu::AddressMode::MirrorRepeat,
+ }
+}
+
+pub fn map_mag_filter(filter: MagFilter) -> wgpu::FilterMode {
+ match filter {
+ MagFilter::Nearest => wgpu::FilterMode::Nearest,
+ MagFilter::Linear => wgpu::FilterMode::Linear,
+ }
+}
+
+pub fn map_min_filter(filter: MinFilter) -> wgpu::FilterMode {
+ match filter {
+ MinFilter::Nearest | MinFilter::NearestMipmapNearest | MinFilter::NearestMipmapLinear => wgpu::FilterMode::Nearest,
+ MinFilter::Linear | MinFilter::LinearMipmapNearest | MinFilter::LinearMipmapLinear => wgpu::FilterMode::Linear,
+ }
+}
+
+pub fn map_blend_factor(f: BlendFactor) -> wgpu::BlendFactor {
+ match f {
+ BlendFactor::Zero => wgpu::BlendFactor::Zero,
+ BlendFactor::One => wgpu::BlendFactor::One,
+ BlendFactor::SrcClr => wgpu::BlendFactor::Src,
+ BlendFactor::InvSrcClr => wgpu::BlendFactor::OneMinusSrc,
+ BlendFactor::SrcAlpha => wgpu::BlendFactor::SrcAlpha,
+ BlendFactor::InvSrcAlpha => wgpu::BlendFactor::OneMinusSrcAlpha,
+ BlendFactor::DstAlpha => wgpu::BlendFactor::DstAlpha,
+ BlendFactor::InvDstAlpha => wgpu::BlendFactor::OneMinusDstAlpha,
+ }
+}
+
+pub fn map_compare_func(f: CompareFunc) -> wgpu::CompareFunction {
+ match f {
+ CompareFunc::Never => wgpu::CompareFunction::Never,
+ CompareFunc::Less => wgpu::CompareFunction::Less,
+ CompareFunc::Equal => wgpu::CompareFunction::Equal,
+ CompareFunc::LessEqual => wgpu::CompareFunction::LessEqual,
+ CompareFunc::Greater => wgpu::CompareFunction::Greater,
+ CompareFunc::NotEqual => wgpu::CompareFunction::NotEqual,
+ CompareFunc::GreaterEqual => wgpu::CompareFunction::GreaterEqual,
+ CompareFunc::Always => wgpu::CompareFunction::Always,
+ }
+}
+
+pub fn s11_to_f32(val: u16) -> f32 {
+ let signed = if val & 0x400 != 0 {
+ val as i32 - 0x800
+ } else {
+ val as i32
+ };
+ signed as f32 / 255.0
+}
+
+pub fn decode_tev_color_regs(lo: &[TevRegisterL; 4], hi: &[TevRegisterH; 4]) -> [[f32; 4]; 4] {
+ let mut out = [[0.0f32; 4]; 4];
+ for i in 0..4 {
+ out[i] = [
+ s11_to_f32(lo[i].r()),
+ s11_to_f32(hi[i].g()),
+ s11_to_f32(hi[i].b()),
+ s11_to_f32(lo[i].a()),
+ ];
+ }
+ 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 bb831ba..772579d 100644
--- a/crates/backend-wgpu/src/lib.rs
+++ b/crates/backend-wgpu/src/lib.rs
@@ -1,7 +1,8 @@
+mod helpers;
mod texture;
use gekko::flipper::gx::draw::{DrawCall, DrawCommands, Primitive, TextureFormat};
-use gekko::flipper::gx::regs::{BlendFactor, CompareFunc, TevRegisterH, TevRegisterL};
+use gekko::flipper::gx::regs::{BlendFactor, CompareFunc, MagFilter, MinFilter, WrapMode};
use std::collections::HashMap;
#[repr(C)]
@@ -39,48 +40,6 @@ struct Uniforms {
_padding: [u32; 2], // 8B — pad to 16-byte alignment
}
-/// Sign-extend an 11-bit value stored in a u16 to f32, normalized by /255.
-fn s11_to_f32(val: u16) -> f32 {
- let signed = if val & 0x400 != 0 {
- val as i32 - 0x800
- } else {
- val as i32
- };
- signed as f32 / 255.0
-}
-
-fn decode_tev_color_regs(lo: &[TevRegisterL; 4], hi: &[TevRegisterH; 4]) -> [[f32; 4]; 4] {
- let mut out = [[0.0f32; 4]; 4];
- for i in 0..4 {
- out[i] = [
- s11_to_f32(lo[i].r()),
- s11_to_f32(hi[i].g()),
- s11_to_f32(hi[i].b()),
- s11_to_f32(lo[i].a()),
- ];
- }
- out
-}
-
-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
-}
-
const SHADER: &str = include_str!("gx.wgsl");
#[derive(Clone, Copy, Hash, PartialEq, Eq)]
@@ -110,32 +69,6 @@ impl PipelineKey {
}
}
-fn map_blend_factor(f: BlendFactor) -> wgpu::BlendFactor {
- match f {
- BlendFactor::Zero => wgpu::BlendFactor::Zero,
- BlendFactor::One => wgpu::BlendFactor::One,
- BlendFactor::SrcClr => wgpu::BlendFactor::Src,
- BlendFactor::InvSrcClr => wgpu::BlendFactor::OneMinusSrc,
- BlendFactor::SrcAlpha => wgpu::BlendFactor::SrcAlpha,
- BlendFactor::InvSrcAlpha => wgpu::BlendFactor::OneMinusSrcAlpha,
- BlendFactor::DstAlpha => wgpu::BlendFactor::DstAlpha,
- BlendFactor::InvDstAlpha => wgpu::BlendFactor::OneMinusDstAlpha,
- }
-}
-
-fn map_compare_func(f: CompareFunc) -> wgpu::CompareFunction {
- match f {
- CompareFunc::Never => wgpu::CompareFunction::Never,
- CompareFunc::Less => wgpu::CompareFunction::Less,
- CompareFunc::Equal => wgpu::CompareFunction::Equal,
- CompareFunc::LessEqual => wgpu::CompareFunction::LessEqual,
- CompareFunc::Greater => wgpu::CompareFunction::Greater,
- CompareFunc::NotEqual => wgpu::CompareFunction::NotEqual,
- CompareFunc::GreaterEqual => wgpu::CompareFunction::GreaterEqual,
- CompareFunc::Always => wgpu::CompareFunction::Always,
- }
-}
-
pub struct GxRenderer {
pipeline_cache: HashMap<PipelineKey, wgpu::RenderPipeline>,
shader: wgpu::ShaderModule,
@@ -150,7 +83,8 @@ pub struct GxRenderer {
depth_view: wgpu::TextureView,
depth_width: u32,
depth_height: u32,
- sampler: wgpu::Sampler,
+ /// Cache: (wrap_s, wrap_t, mag_filter, min_filter) -> wgpu Sampler
+ sampler_cache: HashMap<(WrapMode, WrapMode, MagFilter, MinFilter), wgpu::Sampler>,
/// Cache: (ram_addr, width, height, format) -> (wgpu Texture, TextureView)
texture_cache: HashMap<(usize, u32, u32, TextureFormat), (wgpu::Texture, wgpu::TextureView)>,
/// Fallback 1x1 white texture view used when no texture is bound
@@ -300,7 +234,10 @@ impl GxRenderer {
depth_view,
depth_width,
depth_height,
- sampler,
+ sampler_cache: HashMap::from([(
+ (WrapMode::Clamp, WrapMode::Clamp, MagFilter::Linear, MinFilter::Linear),
+ sampler,
+ )]),
texture_cache: HashMap::new(),
fallback_view,
}
@@ -354,13 +291,13 @@ impl GxRenderer {
};
Some(wgpu::BlendState {
color: wgpu::BlendComponent {
- src_factor: map_blend_factor(key.src_factor),
- dst_factor: map_blend_factor(key.dst_factor),
+ src_factor: helpers::map_blend_factor(key.src_factor),
+ dst_factor: helpers::map_blend_factor(key.dst_factor),
operation,
},
alpha: wgpu::BlendComponent {
- src_factor: map_blend_factor(key.src_factor),
- dst_factor: map_blend_factor(key.dst_factor),
+ src_factor: helpers::map_blend_factor(key.src_factor),
+ dst_factor: helpers::map_blend_factor(key.dst_factor),
operation,
},
})
@@ -372,7 +309,7 @@ impl GxRenderer {
Some(wgpu::DepthStencilState {
format: wgpu::TextureFormat::Depth24Plus,
depth_write_enabled: key.z_write,
- depth_compare: map_compare_func(key.z_func),
+ depth_compare: helpers::map_compare_func(key.z_func),
stencil: wgpu::StencilState::default(),
bias: wgpu::DepthBiasState::default(),
})
@@ -435,10 +372,10 @@ impl GxRenderer {
}
let alpha_cmp = commands.bp_alpha_compare;
- let tev_color_regs = decode_tev_color_regs(&commands.tev_color_regs_lo, &commands.tev_color_regs_hi);
+ 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 = unpack_tev_orders(&commands.tev_orders);
+ let tev_stage_orders = helpers::unpack_tev_orders(&commands.tev_orders);
let num_tev_stages = commands.num_tev_stages as u32;
// Get or create the pipeline for current blend/z state
@@ -449,12 +386,34 @@ impl GxRenderer {
}
// Upload texture slot 0 if present, using cache to avoid redundant uploads
- let tex_view = if let Some(desc) = &commands.textures[0] {
+ let sampler_key = if let Some(desc) = &commands.textures[0] {
let key = (desc.ram_addr, desc.width, desc.height, desc.format);
if !self.texture_cache.contains_key(&key) {
let (tex, view) = texture::upload_texture(device, queue, ram, desc);
self.texture_cache.insert(key, (tex, view));
}
+ (desc.wrap_s, desc.wrap_t, desc.mag_filter, desc.min_filter)
+ } else {
+ (WrapMode::Clamp, WrapMode::Clamp, MagFilter::Linear, MinFilter::Linear)
+ };
+
+ // Get or create sampler for these modes
+ if !self.sampler_cache.contains_key(&sampler_key) {
+ let s = device.create_sampler(&wgpu::SamplerDescriptor {
+ label: Some("gx_sampler"),
+ address_mode_u: helpers::map_wrap_mode(sampler_key.0),
+ address_mode_v: helpers::map_wrap_mode(sampler_key.1),
+ mag_filter: helpers::map_mag_filter(sampler_key.2),
+ min_filter: helpers::map_min_filter(sampler_key.3),
+ ..Default::default()
+ });
+ self.sampler_cache.insert(sampler_key, s);
+ }
+ let sampler = &self.sampler_cache[&sampler_key];
+
+ let tex_view = if commands.textures[0].is_some() {
+ let desc = commands.textures[0].as_ref().unwrap();
+ let key = (desc.ram_addr, desc.width, desc.height, desc.format);
&self.texture_cache[&key].1
} else {
&self.fallback_view
@@ -474,7 +433,7 @@ impl GxRenderer {
},
wgpu::BindGroupEntry {
binding: 2,
- resource: wgpu::BindingResource::Sampler(&self.sampler),
+ resource: wgpu::BindingResource::Sampler(sampler),
},
],
});
diff --git a/crates/gekko/src/flipper/gx.rs b/crates/gekko/src/flipper/gx.rs
index 00f0f89..85c9173 100644
--- a/crates/gekko/src/flipper/gx.rs
+++ b/crates/gekko/src/flipper/gx.rs
@@ -11,15 +11,15 @@ use crate::{
ARRAY_BASE_REG, ARRAY_CLR0, ARRAY_NRM, ARRAY_POS, ARRAY_STRIDE_REG, BP_GEN_MODE, BP_PE_ALPHA_COMPARE,
BP_PE_CMODE0, BP_PE_DONE, BP_PE_DONE_FINISH_BIT, BP_PE_ZMODE, BP_RAS1_TREF_COUNT, BP_RAS1_TREF0,
BP_REG_SIZE, BP_TEV_COLOR_ENV_0, BP_TEV_REGISTERL_0, BP_TX_SETIMAGE0_I0, BP_TX_SETIMAGE0_I4,
- BP_TX_SETIMAGE3_I0, BP_TX_SETIMAGE3_I4, CP_REG_SIZE, VATA_REG, VCD_HI_REG, VCD_LO_REG, XF_AMBIENT_COLOR0,
- XF_CHAN_CTRL0, XF_LIGHT_A0, XF_LIGHT_BASE, XF_LIGHT_COLOR, XF_LIGHT_K0, XF_LIGHT_NX, XF_LIGHT_PX,
- XF_LIGHT_STRIDE, XF_MATERIAL_COLOR0, XF_MATRIX_INDEX_A, XF_MEM_SIZE, XF_NRM_MTX_BASE, XF_POS_MTX_STRIDE,
- XF_PROJECTION_BASE, XF_PROJECTION_END,
+ BP_TX_SETIMAGE3_I0, BP_TX_SETIMAGE3_I4, BP_TX_SETMODE0_I0, BP_TX_SETMODE0_I4, CP_REG_SIZE, VATA_REG,
+ VCD_HI_REG, VCD_LO_REG, XF_AMBIENT_COLOR0, XF_CHAN_CTRL0, XF_LIGHT_A0, XF_LIGHT_BASE, XF_LIGHT_COLOR,
+ XF_LIGHT_K0, XF_LIGHT_NX, XF_LIGHT_PX, XF_LIGHT_STRIDE, XF_MATERIAL_COLOR0, XF_MATRIX_INDEX_A, XF_MEM_SIZE,
+ XF_NRM_MTX_BASE, XF_POS_MTX_STRIDE, XF_PROJECTION_BASE, XF_PROJECTION_END,
},
draw::DrawCommands,
regs::{
AlphaCompare, AttnFn, BlendMode, ChanCtrl, GenMode, MatrixIndex0, TevAlphaEnv, TevColorEnv, TevRegType,
- TevRegisterH, TevRegisterL, TxSetImage0, TxSetImage3, VatA, VcdHi, VcdLo, ZMode,
+ TevRegisterH, TevRegisterL, TxSetImage0, TxSetImage3, TxSetMode0, VatA, VcdHi, VcdLo, ZMode,
},
},
gekko::Gekko,
@@ -554,6 +554,13 @@ impl Gx {
let image0 = TxSetImage0::from_raw(self.bp_regs[image0_reg]);
let image3 = TxSetImage3::from_raw(val);
+ let mode0_reg = if slot < 4 {
+ BP_TX_SETMODE0_I0 + slot
+ } else {
+ BP_TX_SETMODE0_I4 + (slot - 4)
+ };
+ let mode0 = TxSetMode0::from_raw(self.bp_regs[mode0_reg]);
+
let width = image0.width();
let height = image0.height();
let ram_addr = image3.ram_addr();
@@ -564,6 +571,8 @@ impl Gx {
height,
format = format!("{:?}", image0.format()),
ram_addr = format!("{ram_addr:#010X}"),
+ wrap_s = format!("{:?}", mode0.wrap_s()),
+ wrap_t = format!("{:?}", mode0.wrap_t()),
"texture descriptor updated"
);
@@ -572,6 +581,10 @@ impl Gx {
width: width as u32,
height: height as u32,
format: image0.format(),
+ wrap_s: mode0.wrap_s(),
+ wrap_t: mode0.wrap_t(),
+ mag_filter: mode0.mag_filter(),
+ min_filter: mode0.min_filter(),
});
}
diff --git a/crates/gekko/src/flipper/gx/draw.rs b/crates/gekko/src/flipper/gx/draw.rs
index 8ad130f..0af8b2c 100644
--- a/crates/gekko/src/flipper/gx/draw.rs
+++ b/crates/gekko/src/flipper/gx/draw.rs
@@ -1,4 +1,7 @@
-use super::regs::{AlphaCompare, BlendMode, TevAlphaEnv, TevColorEnv, TevRegisterH, TevRegisterL, ZMode};
+use super::regs::{
+ AlphaCompare, BlendMode, MagFilter, MinFilter, TevAlphaEnv, TevColorEnv, TevRegisterH, TevRegisterL, WrapMode,
+ ZMode,
+};
use chapa::BitEnum;
#[derive(Debug)]
@@ -60,6 +63,10 @@ pub struct TextureDescriptor {
pub width: u32,
pub height: u32,
pub format: TextureFormat,
+ pub wrap_s: WrapMode,
+ pub wrap_t: WrapMode,
+ pub mag_filter: MagFilter,
+ pub min_filter: MinFilter,
}
pub struct DrawCall {
diff --git a/crates/gekko/src/flipper/gx/regs.rs b/crates/gekko/src/flipper/gx/regs.rs
index 24887d3..638f611 100644
--- a/crates/gekko/src/flipper/gx/regs.rs
+++ b/crates/gekko/src/flipper/gx/regs.rs
@@ -338,6 +338,45 @@ impl TxSetImage3 {
}
}
+#[derive(Debug, PartialEq, Eq, Hash, BitEnum)]
+pub enum WrapMode {
+ Clamp = 0,
+ Repeat = 1,
+ Mirror = 2,
+}
+
+#[derive(Debug, PartialEq, Eq, Hash, BitEnum)]
+pub enum MagFilter {
+ Nearest = 0,
+ Linear = 1,
+}
+
+#[derive(Debug, PartialEq, Eq, Hash, BitEnum)]
+pub enum MinFilter {
+ Nearest = 0,
+ NearestMipmapNearest = 1,
+ NearestMipmapLinear = 2,
+ Linear = 4,
+ LinearMipmapNearest = 5,
+ LinearMipmapLinear = 6,
+}
+
+#[chapa::bitfield(u32, order = lsb0)]
+#[derive(Debug, Clone, Copy)]
+pub struct TxSetMode0 {
+ #[bits(0..=1)]
+ pub wrap_s: WrapMode,
+
+ #[bits(2..=3)]
+ pub wrap_t: WrapMode,
+
+ #[bits(4..=4)]
+ pub mag_filter: MagFilter,
+
+ #[bits(5..=7)]
+ pub min_filter: MinFilter,
+}
+
// TEV color combiner input select (SELA-SELD)
#[derive(Debug, PartialEq, BitEnum)]
pub enum TevColorIn {