implements PLN-0141

This commit is contained in:
2026-07-03 23:15:11 +01:00
parent 1b29b2f985
commit 999136fef3
7 changed files with 193 additions and 29 deletions
@@ -1,11 +1,14 @@
use crate::firmware::boot_target::BootTarget;
use crate::firmware::firmware_state::{FirmwareState, LoadCartridgeStep, ResetStep};
use crate::firmware::firmware_state::{
FirmwareState, GameRunningStep, LoadCartridgeStep, ResetStep,
};
use crate::firmware::prometeu_context::PrometeuContext;
use prometeu_hal::app_mode::AppMode;
use prometeu_hal::cartridge::Cartridge;
use prometeu_hal::log::LogSource;
use prometeu_hal::telemetry::CertificationConfig;
use prometeu_hal::{InputSignals, RuntimePlatform};
use prometeu_system::{PrometeuHub, SystemOS};
use prometeu_system::{PrometeuHub, ResidentGameState, SystemOS};
use prometeu_vm::VirtualMachine;
/// PROMETEU Firmware.
@@ -36,6 +39,7 @@ pub struct Firmware {
pub boot_target: BootTarget,
/// State-machine lifecycle tracker.
state_initialized: bool,
game_input_barrier_frames: u8,
}
impl Firmware {
@@ -48,6 +52,7 @@ impl Firmware {
state: FirmwareState::Reset(ResetStep),
boot_target: BootTarget::Hub,
state_initialized: false,
game_input_barrier_frames: 0,
}
}
@@ -56,23 +61,31 @@ impl Firmware {
/// This method is called exactly once per Host frame (60Hz).
/// It updates peripheral signals and delegates the logic to the current state.
pub fn tick(&mut self, signals: &InputSignals, platform: &mut dyn RuntimePlatform) {
let barriered_signals = InputSignals::default();
let effective_signals = if self.game_input_barrier_frames > 0 {
self.game_input_barrier_frames -= 1;
&barriered_signals
} else {
signals
};
// 0. Process asset commits at the beginning of the frame boundary.
platform.assets_mut().apply_commits();
// 1. Update the peripheral state using the latest signals from the Host.
// This ensures input is consistent throughout the entire update.
platform.input_mut().pad_mut().begin_frame(signals);
platform.input_mut().touch_mut().begin_frame(signals);
platform.input_mut().pad_mut().begin_frame(effective_signals);
platform.input_mut().touch_mut().begin_frame(effective_signals);
// 2. State machine lifecycle management.
if !self.state_initialized {
self.on_enter(signals, platform);
self.on_enter(effective_signals, platform);
self.state_initialized = true;
}
// 3. Update the current state and check for transitions.
if let Some(next_state) = self.on_update(signals, platform) {
self.change_state(next_state, signals, platform);
if let Some(next_state) = self.on_update(effective_signals, platform) {
self.change_state(next_state, effective_signals, platform);
}
}
@@ -176,9 +189,39 @@ impl Firmware {
LogSource::Pos,
format!("Home/SystemOS request could not pause Game: {error:?}"),
);
} else {
self.game_input_barrier_frames = 1;
}
}
}
pub fn resume_resident_game_from_home(&mut self) -> bool {
let Some(task_id) = self.os.lifecycle().resident_game_task() else {
return false;
};
if self.os.lifecycle().resume_task(task_id).is_err() {
return false;
}
let app_id = self.os.vm().current_app_id();
self.os.vm().transition_render_owner(AppMode::Game, app_id);
self.state = FirmwareState::GameRunning(GameRunningStep::new(task_id));
self.state_initialized = false;
self.game_input_barrier_frames = 1;
true
}
pub fn game_lifecycle_audio_paused(&mut self) -> bool {
matches!(
self.os.lifecycle().resident_game().map(|game| game.state),
Some(
ResidentGameState::PauseRequested { .. }
| ResidentGameState::PausedSuspended
| ResidentGameState::ResumeRequested,
)
)
}
}
#[cfg(test)]
@@ -188,6 +231,7 @@ mod tests {
use prometeu_bytecode::assembler::assemble;
use prometeu_bytecode::model::{BytecodeModule, FunctionMeta, SyscallDecl};
use prometeu_drivers::TestPlatform;
use prometeu_hal::RuntimePlatform;
use prometeu_hal::app_mode::AppMode;
use prometeu_hal::cartridge::AssetsPayloadSource;
use prometeu_hal::color::Color;
@@ -757,9 +801,11 @@ mod tests {
other => panic!("expected GameRunning state, got {:?}", other),
};
let tick_index_before_home = firmware.os.vm().tick_index();
let render_ownership_before_home = firmware.os.vm().active_render_ownership();
firmware.request_home_from_host();
assert!(firmware.game_lifecycle_audio_paused());
assert_eq!(firmware.os.lifecycle().foreground_owner(), ForegroundOwner::Game(task_id));
assert_eq!(
firmware.os.lifecycle().resident_game().map(|game| game.state),
@@ -770,7 +816,9 @@ mod tests {
Some(GameLifecycleEventKind::Pause)
);
firmware.tick(&signals, &mut platform);
let held_signals =
InputSignals { up_signal: true, f_signal: true, x_pos: 72, y_pos: 90, ..signals };
firmware.tick(&held_signals, &mut platform);
assert!(matches!(firmware.state, FirmwareState::HubHome(_)));
assert_eq!(firmware.os.lifecycle().task_state(task_id), Some(TaskState::Suspended));
@@ -779,6 +827,53 @@ mod tests {
Ok(ProcessState::Suspended)
);
assert_eq!(firmware.os.vm().tick_index(), tick_index_before_home);
assert!(!platform.input().pad().any());
assert!(!platform.input().touch().f().down);
let render_ownership_after_home = firmware.os.vm().active_render_ownership();
assert_eq!(render_ownership_after_home.app_mode, AppMode::Shell);
assert_eq!(render_ownership_after_home.app_id, 0);
assert!(render_ownership_after_home.epoch > render_ownership_before_home.epoch);
}
#[test]
fn resident_game_resume_restores_render_owner_after_resume_event_and_barriers_input() {
let mut firmware = Firmware::new(None);
let mut platform = TestPlatform::new();
let signals = InputSignals::default();
firmware.load_cartridge(valid_cartridge(AppMode::Game));
firmware.tick(&signals, &mut platform);
let task_id = match &firmware.state {
FirmwareState::GameRunning(step) => step.task_id,
other => panic!("expected GameRunning state, got {:?}", other),
};
firmware.request_home_from_host();
firmware.tick(&signals, &mut platform);
let hub_ownership = firmware.os.vm().active_render_ownership();
assert!(firmware.resume_resident_game_from_home());
assert!(matches!(firmware.state, FirmwareState::GameRunning(_)));
assert!(!firmware.game_lifecycle_audio_paused());
assert_eq!(
firmware.os.lifecycle().pending_game_lifecycle_events().last().map(|event| event.kind),
Some(GameLifecycleEventKind::ResumeForeground)
);
let game_ownership = firmware.os.vm().active_render_ownership();
assert_eq!(game_ownership.app_mode, AppMode::Game);
assert_eq!(game_ownership.app_id, 9);
assert!(game_ownership.epoch > hub_ownership.epoch);
let held_signals =
InputSignals { up_signal: true, f_signal: true, x_pos: 72, y_pos: 90, ..signals };
firmware.tick(&held_signals, &mut platform);
assert_eq!(firmware.os.lifecycle().task_state(task_id), Some(TaskState::Foreground));
assert!(!platform.input().pad().any());
assert!(!platform.input().touch().f().down);
}
#[test]
@@ -1,5 +1,6 @@
use crate::firmware::firmware_state::{AppCrashesStep, FirmwareState, HubHomeStep};
use crate::firmware::prometeu_context::PrometeuContext;
use prometeu_hal::app_mode::AppMode;
use prometeu_hal::log::{LogLevel, LogSource};
use prometeu_system::CrashReport;
use prometeu_system::task::{TaskId, TaskState};
@@ -37,7 +38,10 @@ impl GameRunningStep {
}
match ctx.os.lifecycle().advance_game_pause_budget(self.task_id) {
Ok(true) => return Some(FirmwareState::HubHome(HubHomeStep)),
Ok(true) => {
ctx.os.vm().transition_render_owner(AppMode::Shell, 0);
return Some(FirmwareState::HubHome(HubHomeStep));
}
Ok(false) => {}
Err(_) => {
let report = CrashReport::VmPanic {
@@ -5,8 +5,8 @@ use prometeu_hal::app_mode::AppMode;
use prometeu_hal::cartridge::Cartridge;
use prometeu_hal::telemetry::{CertificationConfig, TelemetryFrame};
use prometeu_hal::{
FrameId, InputSignals, RenderWorkerBackend, RenderWorkerError, RenderWorkerFrameSink,
RuntimePlatform,
FrameId, InputSignals, RenderOwnership, RenderWorkerBackend, RenderWorkerError,
RenderWorkerFrameSink, RuntimePlatform,
};
use prometeu_vm::VirtualMachine;
use std::sync::atomic::Ordering;
@@ -120,6 +120,16 @@ impl<'a> VmFacade<'a> {
self.os.vm_runtime.record_repeated_render_worker_frame(frame_id);
}
pub fn active_render_ownership(&self) -> RenderOwnership {
self.os.vm_runtime.render_manager.active_ownership()
}
pub fn transition_render_owner(&mut self, app_mode: AppMode, app_id: u32) {
self.os.vm_runtime.render_manager.transition_render_owner(app_mode, app_id);
self.os.vm_runtime.sync_render_worker_ownership();
self.os.vm_runtime.render_manager.sync_telemetry(&self.os.vm_runtime.atomic_telemetry);
}
pub fn cert_config(&self) -> &CertificationConfig {
&self.os.vm_runtime.certifier.config
}