From e3f2ac268683541074d9fcc75caae9b5cbae85ba Mon Sep 17 00:00:00 2001 From: Samueltgg12 Date: Wed, 18 Nov 2026 08:20:22 -0300 Subject: [PATCH 1/2] Reduce display buffer memory usage --- CHANGELOG.md | 2 + HACKING.md | 7 ++ clanker/INDEX.md | 1 + .../perf/display-buffers-grow-on-demand.md | 17 ++++ iris-gui/src/framebuffer.rs | 5 +- src/compositor.rs | 28 ++++++- src/debug_overlay.rs | 9 ++- src/dev/gr2/gr2disp.rs | 1 + src/dev/kona/back/display/mod.rs | 1 + src/dev/mgras/disp.rs | 4 + src/dev/ng1/rex3_frame.rs | 2 + src/dev/o2gfx.rs | 8 +- src/dev/odyssey/display.rs | 2 + src/dev/odyssey/reader.rs | 2 +- src/disp.rs | 78 +++++++++++++++++-- src/display/mod.rs | 3 + src/ui.rs | 6 ++ 17 files changed, 162 insertions(+), 14 deletions(-) create mode 100644 clanker/perf/display-buffers-grow-on-demand.md diff --git a/CHANGELOG.md b/CHANGELOG.md index 20cb3208c..8c7a53ef3 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -15,6 +15,8 @@ hashes are given where a change is easiest to understand by reading the commit. ### Display +- Display buffers now start smaller and grow only for taller video modes; Newport-only + planes and debug overlays are allocated on demand. All machines use less host RAM. - Maximum IMPACT: every other screen row stayed black (PROM menus and monitor, issue 777) in builds since 2026-11-17; both raster engines draw again. - IMPACT (Indigo2 and Octane): texture colour tables diff --git a/HACKING.md b/HACKING.md index ec18598a5..a68c91377 100644 --- a/HACKING.md +++ b/HACKING.md @@ -1295,6 +1295,13 @@ separate CPU cache before using the ordinary renderer. `wait_fresh_frame` says whether the board composed a new frame in time, so a caller can tell a fresh screenshot from a repeat of the last one. +The shared frame and readback buffers start at 1024 rows and grow to the +highest active mode, up to `FB_MAX_H`. Newport's auxiliary and DID planes are +allocated only by a Newport display-state refresh. Software compositors and +debug overlays likewise allocate for their active frame height instead of +reserving 2048 rows up front. A producer that writes `fb_rgb`, or a renderer +that fills `rgba`, must first ensure the corresponding row count. + Nothing downstream looks inside the drawing code. The VNC server (`src/vnc/`) finds damage by comparing frames in 64x64 tiles, so every board is served the same way and drawing paths carry no bookkeeping. diff --git a/clanker/INDEX.md b/clanker/INDEX.md index 12e8b1db1..23f6a2de3 100644 --- a/clanker/INDEX.md +++ b/clanker/INDEX.md @@ -418,6 +418,7 @@ Host performance: idle parking, thread parking, GFIFO, benchmarks. | Note | Kind | Title | |---|---|---| | [decode-cache-conflicts-vary-by-boot.md](perf/decode-cache-conflicts-vary-by-boot.md) | measure | The shadow cache's 64-page decode cache conflicts differently on every boot: up to 25% interpreter variance per boot, gone with 256 pages; compare builds over several boots | +| [display-buffers-grow-on-demand.md](perf/display-buffers-grow-on-demand.md) | rule | Display frame, readback, software-compositor and debug-overlay buffers grow to the active height; Newport-only planes are allocated on demand, and every direct writer must ensure its rows first | | [bench-first-numbers.md](perf/bench-first-numbers.md) | history | First benchmark matrix — 2026-08-21 | | [guest-compiler-changes-the-benchmark.md](perf/guest-compiler-changes-the-benchmark.md) | measure | The guest compiler is part of the benchmark: GCC 14.2 against 16.2.1 changes Dhrystone and rotate90 by 37% in guest instructions, and the pin that fixes it | | [gfifo-backend-experiment.md](perf/gfifo-backend-experiment.md) | history | GFIFO backend: swappable ring for benchmarking — 2026-09-14 | diff --git a/clanker/perf/display-buffers-grow-on-demand.md b/clanker/perf/display-buffers-grow-on-demand.md new file mode 100644 index 000000000..b83813dd2 --- /dev/null +++ b/clanker/perf/display-buffers-grow-on-demand.md @@ -0,0 +1,17 @@ +# Display buffers grow on demand + +`Rex3Screen` used to reserve four 2048-row planes per head: RGB, auxiliary, +DID and composed readback (about 52 MiB). Newport's physical planes are only +1024 rows, and most other boards never use Newport's auxiliary or DID planes. +The software compositor and debug overlay also reserved 2048-row buffers. + +The shared RGB/readback buffers now start at 1024 rows. Newport allocates its +auxiliary and DID planes on its first display-state refresh. IMPACT, VPro, +InfiniteReality and O2 grow the composed frame buffer before writing taller +modes. Readback and presentation paths grow `rgba` before writing it. The +software compositor, iris-gui GL capture buffer and debug overlay allocate to +the active height. + +Buffers only grow, so a mode change does not repeatedly reallocate them. Any +new direct writer must call `ensure_fb_rows` or `ensure_rgba_rows` first; do +not reintroduce a fixed 2048-row allocation to avoid that call. diff --git a/iris-gui/src/framebuffer.rs b/iris-gui/src/framebuffer.rs index 3309c29d2..239f46dbf 100644 --- a/iris-gui/src/framebuffer.rs +++ b/iris-gui/src/framebuffer.rs @@ -323,14 +323,14 @@ impl Renderer for GlCaptureRenderer { return; } - let needed = FB_STRIDE * iris::disp::FB_MAX_H; + let needed = FB_STRIDE * height; if self.rgba.len() < needed { self.rgba.resize(needed, 0); } if screen.prebuilt { // GR2 hands over a finished frame (stride 2048, RGBA bytes): // no GPU round trip needed. - self.rgba.copy_from_slice(&screen.fb_rgb[..needed]); + self.rgba[..needed].copy_from_slice(&screen.fb_rgb[..needed]); } else { let src = screen.compositor_source_from(live_fb_rgb, live_fb_aux); let gl = &self.headless.gl; @@ -427,6 +427,7 @@ fn mirror_band( dirty_y: u32, dirty_h: u32, ) { + screen.ensure_rgba_rows(height); let first = dirty_y as usize; let last = (first + dirty_h as usize).min(height); for y in first..last { diff --git a/src/compositor.rs b/src/compositor.rs index 1c2c66e59..8f474b576 100644 --- a/src/compositor.rs +++ b/src/compositor.rs @@ -99,7 +99,7 @@ pub trait Compositor: Send { /// Pure-CPU compositor. Runs the per-pixel loop into a `Vec`, uploads to /// a GL texture via `glTexSubImage2D`, and returns that texture. pub struct SwCompositor { - /// CPU pixel buffer: stride 2048, `FB_MAX_H` rows. + /// CPU pixel buffer: stride 2048, grown to the tallest frame composed. buf: Vec, /// GL texture that holds the last uploaded frame. tex: Option, @@ -115,7 +115,7 @@ pub struct SwCompositor { impl SwCompositor { pub fn new() -> Self { Self { - buf: vec![0u32; crate::disp::FB_STRIDE * crate::disp::FB_MAX_H], + buf: Vec::new(), tex: None, picture_current: false, current_size: (0, 0), @@ -157,6 +157,10 @@ impl SwCompositor { let width = src.width; let height = src.height; + let needed = crate::disp::FB_STRIDE * height.min(crate::disp::FB_MAX_H); + if self.buf.len() < needed { + self.buf.resize(needed, 0); + } if let Some(frame) = src.prebuilt { for y in 0..height { @@ -393,4 +397,24 @@ mod tests { // Another size: the texture holds a picture of another size. assert!(!holds_current_picture(&src, true, (1280, 768))); } + + #[test] + fn the_pixel_buffer_tracks_the_tallest_active_frame() { + let tall = vec![0xff12_3456; crate::disp::FB_STRIDE * 1200]; + let mut comp = SwCompositor::new(); + comp.compose_pixels(&CompositorSource { + prebuilt: Some(&tall), + ..source(1600, 1200, false) + }); + assert_eq!(comp.pixels().len(), crate::disp::FB_STRIDE * 1200); + assert_eq!(comp.pixels()[1199 * crate::disp::FB_STRIDE], 0xff12_3456); + + let small = vec![0xff65_4321; crate::disp::FB_STRIDE * 768]; + comp.compose_pixels(&CompositorSource { + prebuilt: Some(&small), + ..source(1280, 768, false) + }); + assert_eq!(comp.pixels().len(), crate::disp::FB_STRIDE * 1200); + assert_eq!(comp.pixels()[0], 0xff65_4321); + } } diff --git a/src/debug_overlay.rs b/src/debug_overlay.rs index 3549a31bd..1ad276969 100644 --- a/src/debug_overlay.rs +++ b/src/debug_overlay.rs @@ -34,7 +34,8 @@ pub struct SeenMode { /// Debug overlay: renders CMAP swatches, DID/XMAP mode info, and draw-record /// annotations into a GL texture that is alpha-blended over the compositor output. pub struct DebugOverlay { - /// CPU pixel buffer for the overlay (transparent=0 where inactive), stride 2048. + /// CPU pixel buffer for the overlay (transparent=0 where inactive), stride + /// 2048. Empty until an overlay is drawn, then grown to the tallest frame. buf: Vec, /// GL texture backing the overlay. tex: Option, @@ -58,7 +59,7 @@ pub struct DebugOverlay { impl DebugOverlay { pub fn new() -> Self { Self { - buf: vec![0u32; crate::disp::FB_STRIDE * crate::disp::FB_MAX_H], + buf: Vec::new(), tex: None, font: crate::vga_font::SCREEN_8X16.to_vec(), show_cmap: false, @@ -118,6 +119,10 @@ impl DebugOverlay { pub fn render_pixels(&mut self, src: &OverlaySource<'_>) -> &[u32] { let width = src.width; let height = src.height; + let needed = crate::disp::FB_STRIDE * height.min(crate::disp::FB_MAX_H); + if self.buf.len() < needed { + self.buf.resize(needed, 0); + } let display_ctrl = src.vc2_regs[VC2_REG_DISPLAY_CONTROL as usize]; let cursor_en = (display_ctrl & VC2_CTRL_CURSOR_EN) != 0; diff --git a/src/dev/gr2/gr2disp.rs b/src/dev/gr2/gr2disp.rs index bd4f3af8d..153f8937f 100644 --- a/src/dev/gr2/gr2disp.rs +++ b/src/dev/gr2/gr2disp.rs @@ -49,6 +49,7 @@ impl Head for Gr2 { /// There is nothing smaller to take than the composed frame. fn capture(&self, screen: &mut Rex3Screen, _want: Want) -> bool { let r = self.regs(); + screen.ensure_fb_rows(FB_H); gr2comp::compose(self.vram(), &r.vc1, &r.xmap, &r.dac, &mut screen.fb_rgb); self.presentation_frames.fetch_add(1, std::sync::atomic::Ordering::Relaxed); self.presentation_host_read_pixels diff --git a/src/dev/kona/back/display/mod.rs b/src/dev/kona/back/display/mod.rs index 971b56864..8ab06441d 100644 --- a/src/dev/kona/back/display/mod.rs +++ b/src/dev/kona/back/display/mod.rs @@ -282,6 +282,7 @@ impl Compositor { let (w, h) = (self.store.width() as usize, self.store.height() as usize); let tables = self.tables.lock().snapshot(); compose(&self.store, self.word, &map, &tables, &mut self.frame, w); + screen.ensure_fb_rows(h); let stride = crate::disp::FB_STRIDE; let width = w.min(stride); let height = h.min(screen.fb_rgb.len() / stride); diff --git a/src/dev/mgras/disp.rs b/src/dev/mgras/disp.rs index 210b199be..a4dc10252 100644 --- a/src/dev/mgras/disp.rs +++ b/src/dev/mgras/disp.rs @@ -392,6 +392,8 @@ impl crate::display::Head for Mgras { return false; } if matches!(scan.taken, Taken::None) { + let (_, rows) = frame::display_size(&self.front_view().dcb); + screen.ensure_fb_rows(rows); scan.taken = match self.compose_gpu_into(rss, &mut screen.fb_rgb) { Some((w, h)) => Taken::Read(w, h), None if self.gpu_failed() => { @@ -458,6 +460,8 @@ impl crate::display::Head for Mgras { // SAFETY: a read-only view of the framebuffer, read while // the engines draw, as the board's scan-out reads it. let rss = unsafe { &*self.rss.get() }; + let (_, rows) = frame::display_size(&self.front_view().dcb); + screen.ensure_fb_rows(rows); (screen.width, screen.height) = frame::compose_direct(rss, &self.front_view().dcb, &mut screen.fb_rgb); Composed::Frame } diff --git a/src/dev/ng1/rex3_frame.rs b/src/dev/ng1/rex3_frame.rs index 80547f6ad..3b7645fb0 100644 --- a/src/dev/ng1/rex3_frame.rs +++ b/src/dev/ng1/rex3_frame.rs @@ -602,6 +602,7 @@ impl ResidentCompatibilityDisplay { if matches!(fault, Some(CaptureFault::AfterStaging)) { return Err(ResidentError::Failed("injected composed capture failure after staging".into())); } + screen.ensure_rgba_rows(height); for y in 0..height { let row = y * FB_STRIDE; screen.rgba[row..row + width] @@ -734,6 +735,7 @@ impl ResidentDirectDisplay { let after = self.scanout.traffic().composed_readbacks; rex.resident_frame.capture_delta(ResidentDisplayMode::DirectWgpu, before, after)?; result?; + screen.ensure_rgba_rows(height); for y in 0..height { let row = y * FB_STRIDE; for (dst, &src) in screen.rgba[row..row + width] diff --git a/src/dev/o2gfx.rs b/src/dev/o2gfx.rs index bfb3dfaaf..92affb80a 100644 --- a/src/dev/o2gfx.rs +++ b/src/dev/o2gfx.rs @@ -646,7 +646,7 @@ impl Gbe { /// /// Returns the size and whether any of `out` was written, or None when /// the display is off or does not fit. - pub fn render_direct(&self, ram: &mut crate::dev::crime_mem::RamWindow, out: &mut [u32], stride: usize, memo: &mut ScanMemo) -> Option<(u32, u32, bool)> { + pub fn render_direct(&self, ram: &mut crate::dev::crime_mem::RamWindow, out: &mut Vec, stride: usize, memo: &mut ScanMemo) -> Option<(u32, u32, bool)> { // The registers the scan reads, copied under the lock: the guest // polls the beam through the same lock while the frame is made. let (ctl, wids, crs) = { @@ -664,9 +664,13 @@ impl Gbe { }; let [hcmap, vcmap, ctrlstat, dotclock, vt_xy, vt_flags, tile, frm_pixel, frm, ovr, ovr_tile, did, crs_ctl, crs_pos] = ctl; let (w, h) = (((hcmap >> 12) & 0xfff) as usize, ((vcmap >> 12) & 0xfff) as usize); - if (ctrlstat >> 28) & 3 != 3 || dotclock & DOTCLOCK_RUN == 0 || vt_xy & VT_FREEZE != 0 || w == 0 || h == 0 || vt_flags & 0xa == 0xa || w > stride || h * stride > out.len() { + if (ctrlstat >> 28) & 3 != 3 || dotclock & DOTCLOCK_RUN == 0 || vt_xy & VT_FREEZE != 0 || w == 0 || h == 0 || vt_flags & 0xa == 0xa || w > stride || h > crate::disp::FB_MAX_H { return None; } + let needed = h * stride; + if out.len() < needed { + out.resize(needed, 0); + } ram.begin(); let ram = &*ram; // Everything but the cursor's place, which only the bands under diff --git a/src/dev/odyssey/display.rs b/src/dev/odyssey/display.rs index ef24fde10..82b402da5 100644 --- a/src/dev/odyssey/display.rs +++ b/src/dev/odyssey/display.rs @@ -97,6 +97,8 @@ impl Display { self.verify.lock().before(screen); } reader.force = verify; + reader.sync(shared); + screen.ensure_fb_rows(reader.frame_height as usize); let composed = reader.update_to(Some((&mut screen.fb_rgb, FB_STRIDE))); if shared.gpu_fault.lock().is_some() { return Composed::NotReady; diff --git a/src/dev/odyssey/reader.rs b/src/dev/odyssey/reader.rs index 07087d85d..fe230037c 100644 --- a/src/dev/odyssey/reader.rs +++ b/src/dev/odyssey/reader.rs @@ -606,7 +606,7 @@ impl ScanoutReader { } /// Take a new mode and retrace restart the front end published. - fn sync(&mut self, shared: &DisplayShared) { + pub fn sync(&mut self, shared: &DisplayShared) { let cell = &shared.mode; let (gen, restart) = (cell.gen.load(Acquire), cell.restart.load(Acquire)); let mode = ScanoutMode { diff --git a/src/disp.rs b/src/disp.rs index 5db545ba4..f2109e773 100644 --- a/src/disp.rs +++ b/src/disp.rs @@ -26,6 +26,10 @@ pub const FB_STRIDE: usize = 2048; /// board can hand over (Newport and GR2 use the first 1024; IMPACT's /// 1600x1200 modes need more). pub const FB_MAX_H: usize = 2048; +/// Rows in Newport's physical framebuffer planes. This is also the initial +/// height of the shared frame/readback buffers; taller boards grow them on +/// demand. +const BASE_FB_ROWS: usize = 1024; /// Independent revisions of the cached Newport display state. The source /// identifies the screen that issued them, so replacing a screen cannot make @@ -83,7 +87,9 @@ pub struct Rex3Screen { pub width: usize, pub height: usize, - // Framebuffer snapshots (copied from Rex3::fb_rgb / fb_aux each frame) + // Framebuffer snapshots (copied from Rex3::fb_rgb / fb_aux each frame). + // The shared RGB plane starts at 1024 rows and grows for taller boards; + // the Newport-only auxiliary plane is allocated on its first refresh. pub fb_rgb: Vec, pub fb_aux: Vec, #[cfg(feature = "rex-dirty-upload")] @@ -155,8 +161,11 @@ impl Rex3Screen { Self { width: 0, height: 0, - fb_rgb: vec![0u32; FB_STRIDE * FB_MAX_H], - fb_aux: vec![0u32; FB_STRIDE * FB_MAX_H], + fb_rgb: vec![0u32; FB_STRIDE * BASE_FB_ROWS], + // Newport's auxiliary plane and decoded window IDs are allocated + // only when Newport display state is refreshed. Other boards + // compose straight into fb_rgb and never use either plane. + fb_aux: Vec::new(), #[cfg(feature = "rex-dirty-upload")] fb_rgb_damage: Vec::new(), #[cfg(feature = "rex-dirty-upload")] @@ -165,8 +174,8 @@ impl Rex3Screen { fb_rgb_tiles: 0, #[cfg(feature = "rex-dirty-upload")] fb_aux_tiles: 0, - did: vec![0u8; FB_STRIDE * FB_MAX_H], - rgba: vec![0u32; FB_STRIDE * FB_MAX_H], + did: Vec::new(), + rgba: vec![0u32; FB_STRIDE * BASE_FB_ROWS], vc2_ram: vec![0u16; 32768], vc2_regs: [0u16; 32], cmap: [0u32; 8192], @@ -192,6 +201,39 @@ impl Rex3Screen { } } + /// Ensure the composed-frame buffer has `rows` rows. Buffers only grow: + /// a later, smaller mode reuses the allocation instead of reallocating. + pub fn ensure_fb_rows(&mut self, rows: usize) { + let words = FB_STRIDE * rows.min(FB_MAX_H); + if self.fb_rgb.len() < words { + self.fb_rgb.resize(words, 0); + } + } + + /// Ensure the CPU readback buffer has `rows` rows. Readback is uncommon + /// (screenshots, VNC and CI), so taller modes do not grow it here. + pub fn ensure_rgba_rows(&mut self, rows: usize) { + let words = FB_STRIDE * rows.min(FB_MAX_H); + if self.rgba.len() < words { + self.rgba.resize(words, 0); + } + } + + /// Newport's planes have a fixed 2048x1024 physical size, independent of + /// the visible mode. Allocate them together on the first Newport refresh. + fn ensure_newport_planes(&mut self) { + let words = FB_STRIDE * BASE_FB_ROWS; + if self.fb_rgb.len() < words { + self.fb_rgb.resize(words, 0); + } + if self.fb_aux.len() < words { + self.fb_aux.resize(words, 0); + } + if self.did.len() < words { + self.did.resize(words, 0); + } + } + fn decode_did_into( vc2_regs: &[u16; 32], vc2_ram: &[u16], @@ -329,6 +371,7 @@ impl Rex3Screen { bt445: &Mutex, diag: &AtomicU64, ) -> bool { + self.ensure_newport_planes(); #[cfg(feature = "rex-dirty-upload")] { fb_damage.rectangles_into(DamagePlane::Rgb, &mut self.fb_rgb_damage); @@ -484,6 +527,7 @@ impl Rex3Screen { } if decode_did { + self.ensure_newport_planes(); diag.fetch_or(Rex3::DIAG_LOOP_DECODE_DID, Ordering::Relaxed); let did_changed = self.decode_did(); #[cfg(feature = "wgpu")] @@ -626,6 +670,30 @@ impl Rex3Screen { } } +#[cfg(test)] +mod buffer_tests { + use super::*; + + #[test] + fn display_buffers_start_small_and_only_grow() { + let mut screen = Rex3Screen::new(); + let base = FB_STRIDE * BASE_FB_ROWS; + assert_eq!((screen.fb_rgb.len(), screen.rgba.len()), (base, base)); + assert!(screen.fb_aux.is_empty() && screen.did.is_empty()); + + screen.ensure_fb_rows(1200); + screen.ensure_rgba_rows(1200); + assert_eq!((screen.fb_rgb.len(), screen.rgba.len()), (FB_STRIDE * 1200, FB_STRIDE * 1200)); + screen.ensure_fb_rows(768); + screen.ensure_rgba_rows(768); + assert_eq!((screen.fb_rgb.len(), screen.rgba.len()), (FB_STRIDE * 1200, FB_STRIDE * 1200)); + assert!(screen.fb_aux.is_empty() && screen.did.is_empty()); + + screen.ensure_newport_planes(); + assert_eq!((screen.fb_aux.len(), screen.did.len()), (base, base)); + } +} + /// What a VC2 or VC3 timing generator's tables add up to. #[derive(Clone, Copy, Debug, PartialEq, Eq)] pub struct Vc2Totals { diff --git a/src/display/mod.rs b/src/display/mod.rs index 5d74a6b49..5a0186dc4 100644 --- a/src/display/mod.rs +++ b/src/display/mod.rs @@ -980,6 +980,9 @@ impl Slot { // A finished frame is copied for its readers here; display state // (Newport) is read back by the renderer that composes it. let fill = readback && !self.rgba_current && self.cpu_frame; + if fill { + screen.ensure_rgba_rows(size.1); + } if !(new_frame || fill || heartbeat) { // A head that asks every frame and had nothing new. return; diff --git a/src/ui.rs b/src/ui.rs index ce5741afa..bfd00eb07 100644 --- a/src/ui.rs +++ b/src/ui.rs @@ -563,6 +563,9 @@ impl Renderer for GlRenderer { let width = screen.width; let height = screen.height; if width == 0 || height == 0 { return; } + if need_readback { + screen.ensure_rgba_rows(height); + } // Apply any pending `disp compositor` swap now, on the thread that owns // the GL context. Done before the frame's `state` borrow so the old @@ -861,6 +864,9 @@ impl Renderer for WgpuRenderer { if width == 0 || height == 0 { return; } + if need_readback { + screen.ensure_rgba_rows(height); + } if let Some((w, h)) = self.window_size.lock().take() { self.presenter.resize(w, h); } From 9e7d14ed12978278b9673033417b634f7d649447 Mon Sep 17 00:00:00 2001 From: Samueltgg12 Date: Fri, 20 Nov 2026 05:13:47 -0300 Subject: [PATCH 2/2] CHANGELOG Fixed --- CHANGELOG.md | 3 --- 1 file changed, 3 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 5fd2570ad..e71613dfc 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -44,10 +44,8 @@ hashes are given where a change is easiest to understand by reading the commit. ### Display -<<<<<<< HEAD - Display buffers now start smaller and grow only for taller video modes; Newport-only planes and debug overlays are allocated on demand. All machines use less host RAM. -======= - VPro (Octane, Fuel, Tezro): 16-bit colour-index images put by the X server now appear, on the CPU raster and the GPU raster unit; LightWave Modeler's viewports showed no grid, labels or model. @@ -55,7 +53,6 @@ hashes are given where a change is easiest to understand by reading the commit. out pale and scrambled) and its tabs are grey again, not red and green. - VPro: the check mark of a checked menu toggle (IRIS GL pop-up menus, such as powerflip's) draws as a check mark, not a black bar twice the box's width. ->>>>>>> 3994fae97bdda1abadc8be4ffc839488f6bfa562 - Maximum IMPACT: every other screen row stayed black (PROM menus and monitor, issue 777) in builds since 2026-11-17; both raster engines draw again. - IMPACT (Indigo2 and Octane): texture colour tables