feat(graphics): migrate native target to 640x360
Intrepid/Prometeu/Runtime/pipeline/head This commit looks good

Centralize the fixed 640x360 RGBA8888/60 Hz contract in the existing HAL.
Preserve 8/16/32 tiles and composition, cover partial edges and mixed-size
camera movement, and adapt firmware, fixtures, hosts and native tests.

Share nearest-neighbor presentation geometry with pointer input. Measure
actual framebuffer publications and successful host presentations separately
from VM ticks, with bounded opt-in diagnostics and release harnesses.

Validated with the complete tooling verify gate, native rendering tests,
GPU readback, headless/process integration, formatting and strict clippy.
The existing synchronous session path is documented; no worker/session
architecture replacement or format compatibility layer is introduced.

Work: WRK-0016 / DEC-0001 / PLN-0001
Commit and push explicitly authorized by the user after completion.
This commit is contained in:
2026-11-20 10:34:45 +00:00
parent f1adf86dd5
commit a32f834b2b
36 changed files with 1345 additions and 165 deletions
@@ -385,6 +385,14 @@ impl<'a> VmFacade<'a> {
self.os.vm_runtime.record_repeated_render_worker_frame(frame_id);
}
pub fn record_presented_render_worker_frame(
&self,
ownership: RenderOwnership,
frame_id: FrameId,
) {
self.os.vm_runtime.record_presented_render_worker_frame(ownership, frame_id);
}
pub fn active_render_ownership(&self) -> RenderOwnership {
if let Some(task_id) = self.foreground_session_task_id()
&& let Some(session) = self.os.vm_sessions.for_task(task_id)
@@ -10,19 +10,41 @@ use prometeu_hal::{
const SHELL_A_BUTTON: Rect = Rect { x: 112, y: 172, w: 112, h: 32 };
const SHELL_B_BUTTON: Rect = Rect { x: 256, y: 172, w: 112, h: 32 };
const CLOSE_BUTTON: Rect = Rect { x: 420, y: 24, w: 16, h: 16 };
const VIEWPORT: Rect = Rect { x: 0, y: 0, w: 480, h: 270 };
const HOME_PANEL: Rect = Rect { x: 48, y: 58, w: 384, h: 154 };
const TITLE_PANEL: Rect = Rect { x: 72, y: 34, w: 336, h: 28 };
const CLOSE_BUTTON: Rect =
Rect { x: prometeu_hal::graphics_contract::WIDTH as i32 - 60, y: 24, w: 16, h: 16 };
const VIEWPORT: Rect = Rect {
x: 0,
y: 0,
w: prometeu_hal::graphics_contract::WIDTH as i32,
h: prometeu_hal::graphics_contract::HEIGHT as i32,
};
const HOME_PANEL: Rect = Rect {
x: 48,
y: 58,
w: prometeu_hal::graphics_contract::WIDTH as i32 - 96,
h: prometeu_hal::graphics_contract::HEIGHT as i32 - 116,
};
const TITLE_PANEL: Rect =
Rect { x: 72, y: 34, w: prometeu_hal::graphics_contract::WIDTH as i32 - 144, h: 28 };
const GAME_ROW_X: i32 = 72;
const GAME_ROW_Y: i32 = 90;
const GAME_ROW_W: i32 = 336;
const GAME_ROW_W: i32 = prometeu_hal::graphics_contract::WIDTH as i32 - 144;
const GAME_ROW_H: i32 = 22;
const GAME_ROW_GAP: i32 = 6;
const MAX_HOME_GAME_ROWS: usize = 3;
pub const HUB_SUSPENDED_GAME_KILL_CONTROL: Rect = Rect { x: 288, y: 230, w: 168, h: 24 };
pub const HUB_SUSPENDED_GAME_KILL_CONTROL: Rect = Rect {
x: prometeu_hal::graphics_contract::WIDTH as i32 - 192,
y: prometeu_hal::graphics_contract::HEIGHT as i32 - 40,
w: 168,
h: 24,
};
#[cfg(test)]
const SHELL_FRAME: Rect = Rect { x: 40, y: 20, w: 400, h: 220 };
const SHELL_FRAME: Rect = Rect {
x: 40,
y: 20,
w: prometeu_hal::graphics_contract::WIDTH as i32 - 80,
h: prometeu_hal::graphics_contract::HEIGHT as i32 - 50,
};
const COLOR_BG: Color = Color::rgb(12, 14, 22);
const COLOR_PANEL: Color = Color::rgb(25, 31, 48);
@@ -187,6 +187,16 @@ impl VirtualMachineRuntime {
self.render_worker_ownership.set(self.render_manager.active_ownership());
}
pub fn record_presented_render_worker_frame(
&self,
ownership: prometeu_hal::RenderOwnership,
frame_id: FrameId,
) {
if let Some(controller) = self.render_worker_controller.as_ref() {
controller.record_presented_frame(ownership, frame_id);
}
}
pub fn record_repeated_render_worker_frame(&self, frame_id: FrameId) {
if let Some(controller) = self.render_worker_controller.as_ref() {
controller.record_repeated_frame(frame_id);
@@ -25,6 +25,7 @@ impl Default for RenderWorkerConfig {
struct RenderWorkerState {
telemetry: RenderWorkerTelemetry,
last_error: Option<RenderWorkerError>,
last_presented: Option<(RenderOwnership, FrameId)>,
}
#[derive(Clone, Debug, Default)]
@@ -157,6 +158,7 @@ impl RenderWorkerController {
let mut telemetry = self.handoff.telemetry();
let state = self.state.lock().unwrap();
telemetry.published_frames = state.telemetry.published_frames;
telemetry.presented_frames = state.telemetry.presented_frames;
telemetry.render_failures = state.telemetry.render_failures;
telemetry.publish_failures = state.telemetry.publish_failures;
telemetry.present_failures = state.telemetry.present_failures;
@@ -179,6 +181,17 @@ impl RenderWorkerController {
self.ownership.snapshot()
}
/// Record only after a successful host presentation, never on publication.
pub fn record_presented_frame(&self, ownership: RenderOwnership, frame_id: FrameId) {
let mut state = self.state.lock().unwrap();
if state.last_presented == Some((ownership, frame_id)) {
state.telemetry.record_repeated_frame(frame_id.get());
} else {
state.telemetry.record_presented(frame_id.get());
}
state.last_presented = Some((ownership, frame_id));
}
pub fn record_repeated_frame(&self, frame_id: FrameId) {
let mut state = self.state.lock().unwrap();
state.telemetry.record_repeated_frame(frame_id.get());
@@ -203,13 +216,13 @@ fn run_worker_loop<B, S>(
B: RenderWorkerBackend,
S: RenderWorkerFrameSink,
{
loop {
let submission = match handoff.wait_take() {
RenderWorkerHandoffWait::Submission(submission) => submission,
RenderWorkerHandoffWait::Shutdown => return,
};
let report_path = std::env::var_os("PROMETEU_GRAPHICS_METRICS").map(std::path::PathBuf::from);
let mut measurements = Vec::new();
let mut measured_frames = 0usize;
while let RenderWorkerHandoffWait::Submission(submission) = handoff.wait_take() {
let frame_id = submission.frame_id;
let render_begin = report_path.as_ref().map(|_| std::time::Instant::now());
let render_result = catch_unwind(AssertUnwindSafe(|| backend.render(&submission)))
.map_err(|_| RenderWorkerError::WorkerPanic);
let frame = match render_result {
@@ -225,13 +238,45 @@ fn run_worker_loop<B, S>(
continue;
}
let render_us = render_begin.map(|start| start.elapsed().as_micros() as u64);
let publish_begin = report_path.as_ref().map(|_| std::time::Instant::now());
let publish_result = catch_unwind(AssertUnwindSafe(|| sink.publish(frame)))
.map_err(|_| RenderWorkerError::WorkerPanic);
if let (Some(render_us), Some(begin)) = (render_us, publish_begin) {
let sample = (frame_id.get(), render_us, begin.elapsed().as_micros() as u64);
if measurements.len() < 16384 {
measurements.push(sample);
} else {
measurements[measured_frames % 16384] = sample;
}
measured_frames += 1;
}
match publish_result {
Ok(Ok(())) => record_published(&state, frame_id),
Ok(Err(error)) | Err(error) => record_error(&state, error, frame_id),
}
}
if let Some(path) = report_path {
use std::io::Write;
let worker = state.lock().unwrap();
let handoff = handoff.telemetry();
let report = serde_json::json!({"schema":1,"source":"async_render_worker",
"produced_submissions":handoff.produced_submissions,"consumed_submissions":handoff.consumed_submissions,
"replaced_before_consume":handoff.replaced_before_consume,
"published_frames":worker.telemetry.published_frames,"first_presentations":worker.telemetry.presented_frames,
"repeated_presentations":worker.telemetry.repeated_frames,
"render_failures":worker.telemetry.render_failures,"publish_failures":worker.telemetry.publish_failures,
"measured_frames":measured_frames,"samples_frame_render_publish_us":measurements,
"physical_display_hz":null,
"limitations":"last 16384 successful-render samples; render includes owned-frame copy; sink publication is not scanout; opt-in clock and storage overhead"});
if let Ok(mut file) = std::fs::OpenOptions::new()
.create(true)
.append(true)
.open(path.with_extension("renderer.jsonl"))
{
let _ = writeln!(file, "{report}");
}
}
}
fn record_published(state: &Arc<Mutex<RenderWorkerState>>, frame_id: FrameId) {
@@ -346,6 +391,14 @@ mod tests {
SharedFakeBackend(backend),
);
let first_session = RenderOwnership::new(1, AppMode::Game, 7);
controller.record_presented_frame(first_session, FrameId::ZERO);
controller.record_presented_frame(first_session, FrameId::ZERO);
// Frame zero in a new epoch is a new image, not a repeat of the old session.
controller.record_presented_frame(RenderOwnership::new(2, AppMode::Game, 7), FrameId::ZERO);
assert_eq!(controller.telemetry().presented_frames, 2);
assert_eq!(controller.telemetry().repeated_frames, 1);
assert_eq!(controller.stop(), Ok(()));
assert_eq!(controller.last_error(), None);
}