Skip to content

armgit / gecko

Public Imported from GitHub
0

A GameCube/Wii emulator and debugger written in Rust.

viewport and scissors

Laylebc36a54d200a
diff --git a/crates/backend-wgpu/src/render.rs b/crates/backend-wgpu/src/render.rs
index 3a9848b..a29cd87 100644
--- a/crates/backend-wgpu/src/render.rs
+++ b/crates/backend-wgpu/src/render.rs
@@ -33,7 +33,7 @@ impl GxRenderer {
}
self.upload_buffers(device, queue, &frame_uniform_bytes);
- self.execute_render_pass(device, queue, commands, target, &draw_call_indices);
+ self.execute_render_pass(device, queue, commands, target, target_width, target_height, &draw_call_indices);
}
fn prepare_resources(&mut self, device: &wgpu::Device, queue: &wgpu::Queue, commands: &DrawCommands, ram: &[u8]) {
@@ -181,6 +181,8 @@ impl GxRenderer {
queue: &wgpu::Queue,
commands: &DrawCommands,
target: &wgpu::TextureView,
+ target_width: u32,
+ target_height: u32,
draw_call_indices: &[usize],
) {
let fallback_sampler_key = (WrapMode::Clamp, WrapMode::Clamp, MagFilter::Linear, MinFilter::Linear);
@@ -297,6 +299,20 @@ impl GxRenderer {
let frame_offset = (index * frame_stride) as u32;
let draw_offset = (index as u64 * self.draw_uniform_stride) as u32;
rpass.set_bind_group(0, bind_group, &[frame_offset, draw_offset]);
+
+ // Apply per-draw viewport and scissor, clamped to render target bounds
+ let vp = &dc.viewport;
+ let vp_x = vp.x.max(0.0);
+ let vp_y = vp.y.max(0.0);
+ let vp_w = vp.w.max(1.0).min(target_width as f32 - vp_x);
+ let vp_h = vp.h.max(1.0).min(target_height as f32 - vp_y);
+ rpass.set_viewport(vp_x, vp_y, vp_w, vp_h, vp.min_depth, vp.max_depth);
+
+ let sc = &dc.scissor;
+ let sc_w = sc.w.max(1).min(target_width.saturating_sub(sc.x));
+ let sc_h = sc.h.max(1).min(target_height.saturating_sub(sc.y));
+ rpass.set_scissor_rect(sc.x, sc.y, sc_w, sc_h);
+
rpass.draw(first_vertex..first_vertex + vertex_count, 0..1);
}
}
diff --git a/crates/gecko/src/flipper/gx.rs b/crates/gecko/src/flipper/gx.rs
index 6aa4bc6..b42e3dd 100644
--- a/crates/gecko/src/flipper/gx.rs
+++ b/crates/gecko/src/flipper/gx.rs
@@ -41,6 +41,8 @@ pub struct GraphicsProcessor {
pub cur_zmode: ZMode,
pub cur_blend_mode: BlendMode,
pub cur_alpha_compare: AlphaCompare,
+ pub cur_viewport: draw::Viewport,
+ pub cur_scissor: draw::Scissor,
}
impl GraphicsProcessor {
@@ -68,6 +70,8 @@ impl GraphicsProcessor {
cur_zmode: Default::default(),
cur_blend_mode: BlendMode::from_raw(0).with_color_update(true).with_alpha_update(true),
cur_alpha_compare: Default::default(),
+ cur_viewport: Default::default(),
+ cur_scissor: Default::default(),
}
}
diff --git a/crates/gecko/src/flipper/gx/bp.rs b/crates/gecko/src/flipper/gx/bp.rs
index c598f26..0fdf298 100644
--- a/crates/gecko/src/flipper/gx/bp.rs
+++ b/crates/gecko/src/flipper/gx/bp.rs
@@ -1,7 +1,8 @@
use super::constants::{
BP_GEN_MODE, BP_PE_ALPHA_COMPARE, BP_PE_CMODE0, BP_PE_DONE, BP_PE_DONE_FINISH_BIT, BP_PE_TOKEN, BP_PE_TOKEN_INT,
- BP_PE_ZMODE, BP_RAS1_TREF_COUNT, BP_RAS1_TREF0, 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, BP_TX_SETMODE0_I0, BP_TX_SETMODE0_I4,
+ BP_PE_ZMODE, BP_RAS1_TREF_COUNT, BP_RAS1_TREF0, BP_SU_SCIS_BR, BP_SU_SCIS_OFFSET, BP_SU_SCIS_TL,
+ 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, BP_TX_SETMODE0_I0, BP_TX_SETMODE0_I4, EFB_HEIGHT, EFB_WIDTH,
};
use super::regs::{
AlphaCompare, BlendMode, GenMode, TevAlphaEnv, TevColorEnv, TevOrder, TevRegType, TevRegisterH, TevRegisterL,
@@ -86,6 +87,11 @@ impl GraphicsProcessor {
self.token_dirty = true;
self.raise_token_interrupt = true;
}
+
+ // Scissor registers (BP 0x20, 0x21, 0x59)
+ if idx == BP_SU_SCIS_TL || idx == BP_SU_SCIS_BR || idx == BP_SU_SCIS_OFFSET {
+ self.recompute_scissor();
+ }
}
fn snapshot_texture(&mut self, slot: usize, image3_val: u32) {
@@ -197,4 +203,26 @@ impl GraphicsProcessor {
}
}
}
+
+ fn recompute_scissor(&mut self) {
+ let tl = self.bp_regs[BP_SU_SCIS_TL];
+ let br = self.bp_regs[BP_SU_SCIS_BR];
+
+ let tl_y = (tl & 0x7FF) as i32 - 342;
+ let tl_x = ((tl >> 12) & 0x7FF) as i32 - 342;
+ let br_y = (br & 0x7FF) as i32 - 342 + 1; // BR is inclusive
+ let br_x = ((br >> 12) & 0x7FF) as i32 - 342 + 1;
+
+ let x = tl_x.max(0) as u32;
+ let y = tl_y.max(0) as u32;
+ let x2 = (br_x.max(0) as u32).min(EFB_WIDTH);
+ let y2 = (br_y.max(0) as u32).min(EFB_HEIGHT);
+
+ self.cur_scissor = draw::Scissor {
+ x,
+ y,
+ w: x2.saturating_sub(x),
+ h: y2.saturating_sub(y),
+ };
+ }
}
diff --git a/crates/gecko/src/flipper/gx/constants.rs b/crates/gecko/src/flipper/gx/constants.rs
index 249b62c..a3b5d00 100644
--- a/crates/gecko/src/flipper/gx/constants.rs
+++ b/crates/gecko/src/flipper/gx/constants.rs
@@ -114,3 +114,25 @@ pub const BP_TEV_REGISTERH_0: usize = 0xE1;
// BP TEV KSEL (Konst Selection) registers
pub const BP_TEV_KSEL_0: usize = 0xF6; // 0xF6-0xFD, 8 registers covering 16 stages
+
+// XF viewport registers
+pub const XF_VIEWPORT_SCALE_X: usize = 0x101A;
+pub const XF_VIEWPORT_SCALE_Y: usize = 0x101B;
+pub const XF_VIEWPORT_SCALE_Z: usize = 0x101C;
+pub const XF_VIEWPORT_OFFSET_X: usize = 0x101D;
+pub const XF_VIEWPORT_OFFSET_Y: usize = 0x101E;
+pub const XF_VIEWPORT_OFFSET_Z: usize = 0x101F;
+pub const XF_VIEWPORT_BASE: usize = 0x101A;
+pub const XF_VIEWPORT_END: usize = 0x101F;
+
+// BP scissor registers
+pub const BP_SU_SCIS_TL: usize = 0x20;
+pub const BP_SU_SCIS_BR: usize = 0x21;
+pub const BP_SU_SCIS_OFFSET: usize = 0x59;
+
+// EFB dimensions
+pub const EFB_WIDTH: u32 = 640;
+pub const EFB_HEIGHT: u32 = 480;
+
+// Depth max for 24-bit Z
+pub const DEPTH_24_BIT_MAX: f32 = 16777215.0; // (1 << 24) - 1
diff --git a/crates/gecko/src/flipper/gx/draw.rs b/crates/gecko/src/flipper/gx/draw.rs
index 31d0f06..85084c5 100644
--- a/crates/gecko/src/flipper/gx/draw.rs
+++ b/crates/gecko/src/flipper/gx/draw.rs
@@ -71,10 +71,54 @@ pub struct TextureDescriptor {
pub min_filter: MinFilter,
}
+#[derive(Debug, Clone, Copy)]
+pub struct Viewport {
+ pub x: f32,
+ pub y: f32,
+ pub w: f32,
+ pub h: f32,
+ pub min_depth: f32,
+ pub max_depth: f32,
+}
+
+impl Default for Viewport {
+ fn default() -> Self {
+ Viewport {
+ x: 0.0,
+ y: 0.0,
+ w: super::constants::EFB_WIDTH as f32,
+ h: super::constants::EFB_HEIGHT as f32,
+ min_depth: 0.0,
+ max_depth: 1.0,
+ }
+ }
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct Scissor {
+ pub x: u32,
+ pub y: u32,
+ pub w: u32,
+ pub h: u32,
+}
+
+impl Default for Scissor {
+ fn default() -> Self {
+ Scissor {
+ x: 0,
+ y: 0,
+ w: super::constants::EFB_WIDTH,
+ h: super::constants::EFB_HEIGHT,
+ }
+ }
+}
+
pub struct DrawCall {
pub primitive: Primitive,
pub vertices: Vec<Vertex>,
pub modelview: Matrix4,
+ pub viewport: Viewport,
+ pub scissor: Scissor,
// Textures bound at draw time
pub textures: [Option<TextureDescriptor>; 8],
diff --git a/crates/gecko/src/flipper/gx/texgen.rs b/crates/gecko/src/flipper/gx/texgen.rs
index 8d8b2bf..b2968bf 100644
--- a/crates/gecko/src/flipper/gx/texgen.rs
+++ b/crates/gecko/src/flipper/gx/texgen.rs
@@ -100,30 +100,30 @@ impl GraphicsProcessor {
match tg.projection() {
super::regs::TexGenProjection::St => {
// 2x4 matrix -> (s, t)
- let s = self.xf_f32(tex_mtx_base) * input[0]
- + self.xf_f32(tex_mtx_base + 1) * input[1]
- + self.xf_f32(tex_mtx_base + 2) * input[2]
- + self.xf_f32(tex_mtx_base + 3) * input[3];
- let t = self.xf_f32(tex_mtx_base + 4) * input[0]
- + self.xf_f32(tex_mtx_base + 5) * input[1]
- + self.xf_f32(tex_mtx_base + 6) * input[2]
- + self.xf_f32(tex_mtx_base + 7) * input[3];
+ let s = f32::from_bits(self.xf_mem[tex_mtx_base]) * input[0]
+ + f32::from_bits(self.xf_mem[tex_mtx_base + 1]) * input[1]
+ + f32::from_bits(self.xf_mem[tex_mtx_base + 2]) * input[2]
+ + f32::from_bits(self.xf_mem[tex_mtx_base + 3]) * input[3];
+ let t = f32::from_bits(self.xf_mem[tex_mtx_base + 4]) * input[0]
+ + f32::from_bits(self.xf_mem[tex_mtx_base + 5]) * input[1]
+ + f32::from_bits(self.xf_mem[tex_mtx_base + 6]) * input[2]
+ + f32::from_bits(self.xf_mem[tex_mtx_base + 7]) * input[3];
(s, t, 1.0)
}
super::regs::TexGenProjection::Stq => {
// 3x4 matrix -> (s, t, q)
- let s = self.xf_f32(tex_mtx_base) * input[0]
- + self.xf_f32(tex_mtx_base + 1) * input[1]
- + self.xf_f32(tex_mtx_base + 2) * input[2]
- + self.xf_f32(tex_mtx_base + 3) * input[3];
- let t = self.xf_f32(tex_mtx_base + 4) * input[0]
- + self.xf_f32(tex_mtx_base + 5) * input[1]
- + self.xf_f32(tex_mtx_base + 6) * input[2]
- + self.xf_f32(tex_mtx_base + 7) * input[3];
- let q = self.xf_f32(tex_mtx_base + 8) * input[0]
- + self.xf_f32(tex_mtx_base + 9) * input[1]
- + self.xf_f32(tex_mtx_base + 10) * input[2]
- + self.xf_f32(tex_mtx_base + 11) * input[3];
+ let s = f32::from_bits(self.xf_mem[tex_mtx_base]) * input[0]
+ + f32::from_bits(self.xf_mem[tex_mtx_base + 1]) * input[1]
+ + f32::from_bits(self.xf_mem[tex_mtx_base + 2]) * input[2]
+ + f32::from_bits(self.xf_mem[tex_mtx_base + 3]) * input[3];
+ let t = f32::from_bits(self.xf_mem[tex_mtx_base + 4]) * input[0]
+ + f32::from_bits(self.xf_mem[tex_mtx_base + 5]) * input[1]
+ + f32::from_bits(self.xf_mem[tex_mtx_base + 6]) * input[2]
+ + f32::from_bits(self.xf_mem[tex_mtx_base + 7]) * input[3];
+ let q = f32::from_bits(self.xf_mem[tex_mtx_base + 8]) * input[0]
+ + f32::from_bits(self.xf_mem[tex_mtx_base + 9]) * input[1]
+ + f32::from_bits(self.xf_mem[tex_mtx_base + 10]) * input[2]
+ + f32::from_bits(self.xf_mem[tex_mtx_base + 11]) * input[3];
(s, t, q)
}
}
@@ -144,18 +144,18 @@ impl GraphicsProcessor {
(s, t, q)
};
// Post-transform: 3x4 matrix multiply on (ns, nt, nq)
- let ps = self.xf_f32(post_base) * ns
- + self.xf_f32(post_base + 1) * nt
- + self.xf_f32(post_base + 2) * nq
- + self.xf_f32(post_base + 3);
- let pt = self.xf_f32(post_base + 4) * ns
- + self.xf_f32(post_base + 5) * nt
- + self.xf_f32(post_base + 6) * nq
- + self.xf_f32(post_base + 7);
- let pq = self.xf_f32(post_base + 8) * ns
- + self.xf_f32(post_base + 9) * nt
- + self.xf_f32(post_base + 10) * nq
- + self.xf_f32(post_base + 11);
+ let ps = f32::from_bits(self.xf_mem[post_base]) * ns
+ + f32::from_bits(self.xf_mem[post_base + 1]) * nt
+ + f32::from_bits(self.xf_mem[post_base + 2]) * nq
+ + f32::from_bits(self.xf_mem[post_base + 3]);
+ let pt = f32::from_bits(self.xf_mem[post_base + 4]) * ns
+ + f32::from_bits(self.xf_mem[post_base + 5]) * nt
+ + f32::from_bits(self.xf_mem[post_base + 6]) * nq
+ + f32::from_bits(self.xf_mem[post_base + 7]);
+ let pq = f32::from_bits(self.xf_mem[post_base + 8]) * ns
+ + f32::from_bits(self.xf_mem[post_base + 9]) * nt
+ + f32::from_bits(self.xf_mem[post_base + 10]) * nq
+ + f32::from_bits(self.xf_mem[post_base + 11]);
(ps, pt, pq)
}
}
diff --git a/crates/gecko/src/flipper/gx/vertex.rs b/crates/gecko/src/flipper/gx/vertex.rs
index f37b0af..d4e7187 100644
--- a/crates/gecko/src/flipper/gx/vertex.rs
+++ b/crates/gecko/src/flipper/gx/vertex.rs
@@ -84,6 +84,8 @@ impl GraphicsProcessor {
primitive,
vertices,
modelview,
+ viewport: self.cur_viewport,
+ scissor: self.cur_scissor,
textures: self.cur_textures,
tev_orders: self.resolve_tev_orders(),
tev_color_env: self.cur_tev_color_env,
@@ -261,7 +263,7 @@ impl GraphicsProcessor {
let pos_mtx_base = pos_mtx_idx as usize * XF_POS_MTX_STRIDE;
let nrm_mtx_idx = (pos_mtx_idx as usize) & 31;
let nrm_mtx_base = XF_NRM_MTX_BASE + nrm_mtx_idx * 3;
- let nrm_mtx: [f32; 9] = std::array::from_fn(|i| self.xf_f32(nrm_mtx_base + i));
+ let nrm_mtx: [f32; 9] = std::array::from_fn(|i| f32::from_bits(self.xf_mem[nrm_mtx_base + i]));
// Read position
let position = if vf.pos_attr == AttributeType::Direct {
@@ -385,27 +387,27 @@ impl GraphicsProcessor {
let default_mtx_base = pos_mtx_idx as usize * XF_POS_MTX_STRIDE;
draw::Matrix4([
[
- self.xf_f32(default_mtx_base),
- self.xf_f32(default_mtx_base + 4),
- self.xf_f32(default_mtx_base + 8),
+ f32::from_bits(self.xf_mem[default_mtx_base]),
+ f32::from_bits(self.xf_mem[default_mtx_base + 4]),
+ f32::from_bits(self.xf_mem[default_mtx_base + 8]),
0.0,
],
[
- self.xf_f32(default_mtx_base + 1),
- self.xf_f32(default_mtx_base + 5),
- self.xf_f32(default_mtx_base + 9),
+ f32::from_bits(self.xf_mem[default_mtx_base + 1]),
+ f32::from_bits(self.xf_mem[default_mtx_base + 5]),
+ f32::from_bits(self.xf_mem[default_mtx_base + 9]),
0.0,
],
[
- self.xf_f32(default_mtx_base + 2),
- self.xf_f32(default_mtx_base + 6),
- self.xf_f32(default_mtx_base + 10),
+ f32::from_bits(self.xf_mem[default_mtx_base + 2]),
+ f32::from_bits(self.xf_mem[default_mtx_base + 6]),
+ f32::from_bits(self.xf_mem[default_mtx_base + 10]),
0.0,
],
[
- self.xf_f32(default_mtx_base + 3),
- self.xf_f32(default_mtx_base + 7),
- self.xf_f32(default_mtx_base + 11),
+ f32::from_bits(self.xf_mem[default_mtx_base + 3]),
+ f32::from_bits(self.xf_mem[default_mtx_base + 7]),
+ f32::from_bits(self.xf_mem[default_mtx_base + 11]),
1.0,
],
])
@@ -419,7 +421,7 @@ impl GraphicsProcessor {
unpack_rgba(self.xf_mem[base])
} else {
// Float vec3, w = 0
- [self.xf_f32(base), self.xf_f32(base + 1), self.xf_f32(base + 2), 0.0]
+ [f32::from_bits(self.xf_mem[base]), f32::from_bits(self.xf_mem[base + 1]), f32::from_bits(self.xf_mem[base + 2]), 0.0]
}
})
}
diff --git a/crates/gecko/src/flipper/gx/xf.rs b/crates/gecko/src/flipper/gx/xf.rs
index 2c77d98..8ed588e 100644
--- a/crates/gecko/src/flipper/gx/xf.rs
+++ b/crates/gecko/src/flipper/gx/xf.rs
@@ -1,36 +1,63 @@
-use super::constants::{XF_PROJECTION_BASE, XF_PROJECTION_END};
+use super::constants::{
+ DEPTH_24_BIT_MAX, XF_PROJECTION_BASE, XF_PROJECTION_END, XF_VIEWPORT_BASE, XF_VIEWPORT_END, XF_VIEWPORT_OFFSET_X,
+ XF_VIEWPORT_OFFSET_Y, XF_VIEWPORT_OFFSET_Z, XF_VIEWPORT_SCALE_X, XF_VIEWPORT_SCALE_Y, XF_VIEWPORT_SCALE_Z,
+};
use super::math::Vec3;
use super::{GraphicsProcessor, draw};
impl GraphicsProcessor {
- pub fn xf_f32(&self, reg: usize) -> f32 {
- f32::from_bits(self.xf_mem[reg])
- }
-
pub fn xf_transform_3x4(&self, base: usize, v: [f32; 3]) -> Vec3 {
Vec3(
- self.xf_f32(base) * v[0]
- + self.xf_f32(base + 1) * v[1]
- + self.xf_f32(base + 2) * v[2]
- + self.xf_f32(base + 3),
- self.xf_f32(base + 4) * v[0]
- + self.xf_f32(base + 5) * v[1]
- + self.xf_f32(base + 6) * v[2]
- + self.xf_f32(base + 7),
- self.xf_f32(base + 8) * v[0]
- + self.xf_f32(base + 9) * v[1]
- + self.xf_f32(base + 10) * v[2]
- + self.xf_f32(base + 11),
+ f32::from_bits(self.xf_mem[base]) * v[0]
+ + f32::from_bits(self.xf_mem[base + 1]) * v[1]
+ + f32::from_bits(self.xf_mem[base + 2]) * v[2]
+ + f32::from_bits(self.xf_mem[base + 3]),
+ f32::from_bits(self.xf_mem[base + 4]) * v[0]
+ + f32::from_bits(self.xf_mem[base + 5]) * v[1]
+ + f32::from_bits(self.xf_mem[base + 6]) * v[2]
+ + f32::from_bits(self.xf_mem[base + 7]),
+ f32::from_bits(self.xf_mem[base + 8]) * v[0]
+ + f32::from_bits(self.xf_mem[base + 9]) * v[1]
+ + f32::from_bits(self.xf_mem[base + 10]) * v[2]
+ + f32::from_bits(self.xf_mem[base + 11]),
)
}
+ pub fn rebuild_viewport(&mut self) {
+ let scale_x = f32::from_bits(self.xf_mem[XF_VIEWPORT_SCALE_X]);
+ let scale_y = f32::from_bits(self.xf_mem[XF_VIEWPORT_SCALE_Y]);
+ let scale_z = f32::from_bits(self.xf_mem[XF_VIEWPORT_SCALE_Z]);
+ let offset_x = f32::from_bits(self.xf_mem[XF_VIEWPORT_OFFSET_X]);
+ let offset_y = f32::from_bits(self.xf_mem[XF_VIEWPORT_OFFSET_Y]);
+ let offset_z = f32::from_bits(self.xf_mem[XF_VIEWPORT_OFFSET_Z]);
+
+ // Decode: scale_x = wd*0.5, scale_y = (-ht)*0.5
+ // offset_x = (xOrig + wd*0.5) + 342, offset_y = (yOrig + ht*0.5) + 342
+ let w = scale_x * 2.0;
+ let h = scale_y * -2.0;
+ let x = offset_x - 342.0 - scale_x;
+ let y = offset_y - 342.0 + scale_y; // +scale_y because scale_y is negative
+
+ let far = offset_z / DEPTH_24_BIT_MAX;
+ let near = far - scale_z / DEPTH_24_BIT_MAX;
+
+ self.cur_viewport = draw::Viewport {
+ x,
+ y,
+ w,
+ h,
+ min_depth: near,
+ max_depth: far,
+ };
+ }
+
pub fn rebuild_projection(&mut self) {
- let pm1 = self.xf_f32(XF_PROJECTION_BASE);
- let pm2 = self.xf_f32(XF_PROJECTION_BASE + 1);
- let pm3 = self.xf_f32(XF_PROJECTION_BASE + 2);
- let pm4 = self.xf_f32(XF_PROJECTION_BASE + 3);
- let pm5 = self.xf_f32(XF_PROJECTION_BASE + 4);
- let pm6 = self.xf_f32(XF_PROJECTION_BASE + 5);
+ let pm1 = f32::from_bits(self.xf_mem[XF_PROJECTION_BASE + 0]);
+ let pm2 = f32::from_bits(self.xf_mem[XF_PROJECTION_BASE + 1]);
+ let pm3 = f32::from_bits(self.xf_mem[XF_PROJECTION_BASE + 2]);
+ let pm4 = f32::from_bits(self.xf_mem[XF_PROJECTION_BASE + 3]);
+ let pm5 = f32::from_bits(self.xf_mem[XF_PROJECTION_BASE + 4]);
+ let pm6 = f32::from_bits(self.xf_mem[XF_PROJECTION_BASE + 5]);
let proj_type = self.xf_mem[XF_PROJECTION_END];
self.draw_commands.projection = if proj_type == 0 {
@@ -90,5 +117,10 @@ impl GraphicsProcessor {
if addr <= XF_PROJECTION_END && end > XF_PROJECTION_BASE {
self.rebuild_projection();
}
+
+ // Rebuild viewport if the write touched its address range
+ if addr <= XF_VIEWPORT_END && end > XF_VIEWPORT_BASE {
+ self.rebuild_viewport();
+ }
}
}