Real Render Worker Establishment
Intrepid/Prometeu/Runtime/pipeline/pr-master This commit looks good

This commit is contained in:
2026-06-20 17:05:25 +01:00
parent aa917cf44e
commit 21b5d59a7d
44 changed files with 350 additions and 3092 deletions
@@ -10,9 +10,9 @@ use pixels::{Pixels, PixelsBuilder, SurfaceTexture};
use prometeu_drivers::hardware::Hardware;
use prometeu_drivers::{AudioCommand, LocalFramebufferRenderBackend, MemoryBanks};
use prometeu_firmware::{BootTarget, Firmware, FirmwareState};
use prometeu_hal::RuntimePlatform;
use prometeu_hal::telemetry::CertificationConfig;
use prometeu_hal::{OwnedRgba8888Frame, RenderWorkerError, RenderWorkerFrameSink, RuntimePlatform};
use prometeu_system::RenderWorkerConfig;
use prometeu_system::{LatestRenderFrameStore, RenderWorkerConfig};
use std::sync::Arc;
use std::time::{Duration, Instant};
use winit::application::ApplicationHandler;
@@ -24,15 +24,6 @@ use winit::window::{Window, WindowAttributes, WindowId};
const IDLE_HOST_POLL_DT: Duration = Duration::from_millis(100);
#[derive(Debug, Clone, Copy)]
struct HostWorkerFrameSink;
impl RenderWorkerFrameSink for HostWorkerFrameSink {
fn publish(&self, _frame: OwnedRgba8888Frame) -> Result<(), RenderWorkerError> {
Ok(())
}
}
#[derive(Debug, Clone)]
struct PresentationState {
latest_published_frame: u64,
@@ -147,6 +138,8 @@ pub struct HostRunner {
audio: HostAudio,
/// Last known pause state to sync with audio.
last_paused_state: bool,
/// Worker-published frame store used as the single observable publication source.
render_frame_store: LatestRenderFrameStore,
/// Tracks whether a new logical frame or host-only surface invalidation requires presentation.
presentation: PresentationState,
}
@@ -177,10 +170,11 @@ impl HostRunner {
memory_banks,
hardware.assets.glyph_asset_slot_index(),
);
let render_frame_store = LatestRenderFrameStore::default();
firmware.os.vm().start_render_worker(
RenderWorkerConfig::default(),
worker_backend,
HostWorkerFrameSink,
render_frame_store.clone(),
);
Self {
@@ -199,6 +193,7 @@ impl HostRunner {
debugger: HostDebugger::new(),
audio: HostAudio::new(),
last_paused_state: false,
render_frame_store,
presentation: PresentationState::default(),
}
}
@@ -252,7 +247,9 @@ impl ApplicationHandler for HostRunner {
let window = event_loop.create_window(attrs).expect("failed to create window");
// 🔥 Leak: Window becomes &'static Window (bootstrap)
// `pixels` stores a surface tied to the window lifetime. The current
// winit runner owns one process-lifetime window, so we intentionally
// promote it to a static reference for the duration of the host process.
let window: &'static Window = Box::leak(Box::new(window));
self.window = Some(window);
@@ -261,7 +258,7 @@ impl ApplicationHandler for HostRunner {
let (display_w, display_h) = self.hardware.display_size();
let mut pixels = PixelsBuilder::new(display_w as u32, display_h as u32, surface_texture)
.present_mode(PresentMode::Fifo) // activate vsync
.present_mode(PresentMode::Fifo)
.build()
.expect("failed to create Pixels");
@@ -298,23 +295,24 @@ impl ApplicationHandler for HostRunner {
}
WindowEvent::RedrawRequested => {
// Get Pixels directly from the field (not via helper that gets the entire &mut self)
let pixels = self.pixels.as_mut().expect("pixels not initialized");
{
// Mutable borrow of the frame (lasts only within this block)
let frame = pixels.frame_mut();
if should_present_worker_frame(&self.firmware.state)
&& let Some(worker_frame) =
self.firmware.os.vm().repeat_latest_render_worker_frame()
&& let Some(worker_frame) = self.render_frame_store.latest_frame()
{
self.firmware
.os
.vm()
.record_repeated_render_worker_frame(worker_frame.frame_id);
draw_owned_rgba8888_frame_to_rgba8(&worker_frame, frame);
} else {
let src = self.hardware.gfx.front_buffer();
draw_rgba8888_to_rgba8(src, frame);
}
} // <- frame borrow ends here
}
if pixels.render().is_err() {
event_loop.exit();
@@ -378,7 +376,7 @@ impl ApplicationHandler for HostRunner {
self.last_frame_time = now;
self.accumulator += frame_delta;
// 🔥 Logic Update Loop: consumes time in exact 60Hz (16.66ms) slices.
// Consume time in exact 60Hz slices.
while self.accumulator >= self.frame_target_dt {
// Unless the debugger is waiting for a 'start' command, advance the system.
if !self.debugger.waiting_for_start {
@@ -405,7 +403,7 @@ impl ApplicationHandler for HostRunner {
}
if should_present_worker_frame(&self.firmware.state)
&& let Some(worker_frame) = self.firmware.os.vm().latest_render_worker_frame()
&& let Some(worker_frame) = self.render_frame_store.latest_frame()
{
self.presentation.note_published_frame(worker_frame.frame_id.get());
} else {
@@ -453,8 +451,10 @@ mod tests {
use prometeu_firmware::firmware::firmware_state::{
GameRunningStep, HubHomeStep, ShellRunningStep,
};
use prometeu_hal::app_mode::AppMode;
use prometeu_hal::debugger_protocol::DEVTOOLS_PROTOCOL_VERSION;
use prometeu_hal::telemetry::{CertificationConfig, TelemetryFrame};
use prometeu_hal::{FrameId, OwnedRgba8888Frame, RenderOwnership, RenderWorkerFrameSink};
use prometeu_system::task::TaskId;
use std::io::{Read, Write};
use std::net::TcpStream;
@@ -534,6 +534,30 @@ mod tests {
assert!(!should_present_worker_frame(&FirmwareState::HubHome(HubHomeStep)));
}
#[test]
fn host_presentation_observes_worker_publication_store() {
let store = LatestRenderFrameStore::default();
let frame = OwnedRgba8888Frame::packed(
FrameId::new(9),
RenderOwnership::new(1, AppMode::Game, 1),
1,
1,
vec![0xFF00FFFF],
)
.expect("test frame");
store.publish(frame).expect("store publish");
let mut presentation = PresentationState::default();
presentation.mark_presented();
let published = store.latest_frame().expect("published frame");
presentation.note_published_frame(published.frame_id.get());
assert!(presentation.should_request_redraw());
presentation.mark_presented();
assert_eq!(presentation.last_presented_frame, Some(9));
}
#[test]
fn host_debugger_maps_cert_events_from_host_owned_sources() {
let telemetry = TelemetryFrame {