Intrepid/prometeu-runtime
Intrepid/prometeu-runtime
3
0
Fork 0
Code Pull Requests 1 Activity

added small animations

Browse Source
This commit is contained in:
bQUARKz 2026-01-16 16:40:59 +00:00
parent 28ec041381
commit 314f193804
Signed by: bquarkz
SSH Key Fingerprint: SHA256:Z7dgqoglWwoK6j6u4QC87OveEq74WOhFN+gitsxtkf8
11 changed files with 278 additions and 123 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

95
crates/prometeu-core/src/firmware/firmware.rs
View File

@ -1,5 +1,5 @@
use crate::firmware::firmware_state::FirmwareState;
use crate::firmware::{firmware_step_crash_screen, firmware_step_hub_home, firmware_step_init_app, firmware_step_launch_hub, firmware_step_reset, firmware_step_run_app, firmware_step_splash_screen};
use crate::firmware::firmware_state::{FirmwareState, InitAppStep, ResetStep};
use crate::firmware::FirmwareRequest;
use crate::hardware::{HardwareBridge, InputSignals};
use crate::model::Cartridge;
use crate::prometeu_hub::PrometeuHub;
@ -9,6 +9,7 @@ pub struct Firmware {
pub os: PrometeuOS,
pub hub: PrometeuHub,
pub state: FirmwareState,
state_initialized: bool,
}
impl Firmware {
@ -16,30 +17,88 @@ impl Firmware {
Self {
os: PrometeuOS::new(),
hub: PrometeuHub::new(),
state: FirmwareState::Reset,
state: FirmwareState::Reset(ResetStep),
state_initialized: false,
}
}
pub fn step_frame(&mut self, signals: &InputSignals, hw: &mut dyn HardwareBridge) {
let os = &mut self.os;
let next_state = match &mut self.state {
FirmwareState::Reset => firmware_step_reset::step_reset(&mut self.os),
FirmwareState::SplashScreen(frame) => {
firmware_step_splash_screen::step_splash_screen(frame, os, signals, hw)
},
FirmwareState::LaunchHub => firmware_step_launch_hub::launch_hub(&mut self.os, &mut self.hub),
FirmwareState::HubHome => firmware_step_hub_home::step_hub_home(&mut self.hub, &mut self.os, hw),
FirmwareState::LoadApp(cartridge) => firmware_step_init_app::step_init_app(&mut self.os, signals, hw, cartridge),
FirmwareState::AppRunning => firmware_step_run_app::step_run_app(&mut self.os, signals, hw),
FirmwareState::AppCrashes(_error) => firmware_step_crash_screen::step_crash_screen(signals, hw),
};
if !self.state_initialized {
self.on_enter(signals, hw);
self.state_initialized = true;
}
if let Some(new_state) = next_state {
self.state = new_state;
if let Some(next_state) = self.on_update(signals, hw) {
self.change_state(next_state, signals, hw);
}
}
pub fn change_state(&mut self, new_state: FirmwareState, signals: &InputSignals, hw: &mut dyn HardwareBridge) {
self.on_exit(signals, hw);
self.state = new_state;
self.state_initialized = false;
// Entra no novo estado imediatamente
self.on_enter(signals, hw);
self.state_initialized = true;
}
fn on_enter(&mut self, signals: &InputSignals, hw: &mut dyn HardwareBridge) {
let mut req = FirmwareRequest {
os: &mut self.os,
hub: &mut self.hub,
signals,
hw,
};
match &mut self.state {
FirmwareState::Reset(s) => s.on_enter(&mut req),
FirmwareState::SplashScreen(s) => s.on_enter(&mut req),
FirmwareState::LaunchHub(s) => s.on_enter(&mut req),
FirmwareState::HubHome(s) => s.on_enter(&mut req),
FirmwareState::LoadApp(s) => s.on_enter(&mut req),
FirmwareState::AppRunning(s) => s.on_enter(&mut req),
FirmwareState::AppCrashes(s) => s.on_enter(&mut req),
}
}
fn on_update(&mut self, signals: &InputSignals, hw: &mut dyn HardwareBridge) -> Option<FirmwareState> {
let mut req = FirmwareRequest {
os: &mut self.os,
hub: &mut self.hub,
signals,
hw,
};
match &mut self.state {
FirmwareState::Reset(s) => s.on_update(&mut req),
FirmwareState::SplashScreen(s) => s.on_update(&mut req),
FirmwareState::LaunchHub(s) => s.on_update(&mut req),
FirmwareState::HubHome(s) => s.on_update(&mut req),
FirmwareState::LoadApp(s) => s.on_update(&mut req),
FirmwareState::AppRunning(s) => s.on_update(&mut req),
FirmwareState::AppCrashes(s) => s.on_update(&mut req),
}
}
fn on_exit(&mut self, signals: &InputSignals, hw: &mut dyn HardwareBridge) {
let mut req = FirmwareRequest {
os: &mut self.os,
hub: &mut self.hub,
signals,
hw,
};
match &mut self.state {
FirmwareState::Reset(s) => s.on_exit(&mut req),
FirmwareState::SplashScreen(s) => s.on_exit(&mut req),
FirmwareState::LaunchHub(s) => s.on_exit(&mut req),
FirmwareState::HubHome(s) => s.on_exit(&mut req),
FirmwareState::LoadApp(s) => s.on_exit(&mut req),
FirmwareState::AppRunning(s) => s.on_exit(&mut req),
FirmwareState::AppCrashes(s) => s.on_exit(&mut req),
}
}
pub fn load_cartridge(&mut self, cartridge: Cartridge) {
self.state = FirmwareState::LoadApp(cartridge); // change state
self.state = FirmwareState::LoadApp(InitAppStep { cartridge });
self.state_initialized = false;
}
}

22
crates/prometeu-core/src/firmware/firmware_state.rs
View File

@ -1,12 +1,18 @@
use crate::model::Cartridge;
pub use crate::firmware::firmware_step_reset::ResetStep;
pub use crate::firmware::firmware_step_splash_screen::SplashScreenStep;
pub use crate::firmware::firmware_step_launch_hub::LaunchHubStep;
pub use crate::firmware::firmware_step_hub_home::HubHomeStep;
pub use crate::firmware::firmware_step_init_app::InitAppStep;
pub use crate::firmware::firmware_step_run_app::RunAppStep;
pub use crate::firmware::firmware_step_crash_screen::AppCrashesStep;
#[derive(Debug, Clone)]
pub enum FirmwareState {
Reset,
SplashScreen(u32),
LaunchHub,
HubHome,
LoadApp(Cartridge),
AppRunning,
AppCrashes(String),
Reset(ResetStep),
SplashScreen(SplashScreenStep),
LaunchHub(LaunchHubStep),
HubHome(HubHomeStep),
AppRunning(RunAppStep),
LoadApp(InitAppStep),
AppCrashes(AppCrashesStep),
}

41
crates/prometeu-core/src/firmware/firmware_step_crash_screen.rs
View File

@ -1,21 +1,32 @@
use crate::firmware::firmware_state::FirmwareState;
use crate::hardware::{HardwareBridge, InputSignals};
use crate::firmware::firmware_state::{FirmwareState, LaunchHubStep};
use crate::firmware::FirmwareRequest;
use crate::model::Color;
pub fn step_crash_screen(signals: &InputSignals, hw: &mut dyn HardwareBridge) -> Option<FirmwareState> {
// Atualiza periféricos para input na tela de crash
hw.pad_mut().begin_frame(signals);
#[derive(Debug, Clone)]
pub struct AppCrashesStep {
pub error: String,
}
// Tela de erro: fundo vermelho, texto branco
hw.gfx_mut().clear(Color::RED);
// Por enquanto apenas logamos ou mostramos algo simples
// No futuro, usar draw_text
hw.gfx_mut().present();
impl AppCrashesStep {
pub fn on_enter(&mut self, _req: &mut FirmwareRequest) {}
// Se apertar START, volta pro Hub
if hw.pad().start.down {
return Some(FirmwareState::LaunchHub);
pub fn on_update(&mut self, req: &mut FirmwareRequest) -> Option<FirmwareState> {
// Atualiza periféricos para input na tela de crash
req.hw.pad_mut().begin_frame(req.signals);
// Tela de erro: fundo vermelho, texto branco
req.hw.gfx_mut().clear(Color::RED);
// Por enquanto apenas logamos ou mostramos algo simples
// No futuro, usar draw_text
req.hw.gfx_mut().present();
// Se apertar START, volta pro Hub
if req.hw.pad().start.down {
return Some(FirmwareState::LaunchHub(LaunchHubStep));
}
None
}
None
pub fn on_exit(&mut self, _req: &mut FirmwareRequest) {}
}

26
crates/prometeu-core/src/firmware/firmware_step_hub_home.rs
View File

@ -1,13 +1,21 @@
use crate::firmware::firmware_state::FirmwareState;
use crate::hardware::HardwareBridge;
use crate::firmware::FirmwareRequest;
use crate::model::Color;
use crate::prometeu_hub::PrometeuHub;
use crate::prometeu_os::PrometeuOS;
pub fn step_hub_home(hub: &mut PrometeuHub, os: &mut PrometeuOS, hw: &mut dyn HardwareBridge) -> Option<FirmwareState> {
hw.gfx_mut().clear(Color::INDIGO);
hub.gui_update(os);
hw.gfx_mut().present();
None
#[derive(Debug, Clone)]
pub struct HubHomeStep;
impl HubHomeStep {
pub fn on_enter(&mut self, _req: &mut FirmwareRequest) {}
pub fn on_update(&mut self, req: &mut FirmwareRequest) -> Option<FirmwareState> {
// req.hw.gfx_mut().clear(Color::BLACK);
req.hw.pad_mut().begin_frame(req.signals);
req.hub.gui_update(req.os, req.hw);
req.hw.gfx_mut().present();
None
}
pub fn on_exit(&mut self, _req: &mut FirmwareRequest) {}
}

24
crates/prometeu-core/src/firmware/firmware_step_init_app.rs
View File

@ -1,10 +1,20 @@
use crate::firmware::firmware_state::FirmwareState;
use crate::hardware::{HardwareBridge, InputSignals};
use crate::firmware::firmware_state::{FirmwareState, RunAppStep};
use crate::firmware::FirmwareRequest;
use crate::model::Cartridge;
use crate::prometeu_os::PrometeuOS;
pub fn step_init_app(os: &mut PrometeuOS, _signals: &InputSignals, _hw: &mut dyn HardwareBridge, cartridge: &Cartridge) -> Option<FirmwareState> {
os.initialize_vm(cartridge);
Some(FirmwareState::AppRunning)
#[derive(Debug, Clone)]
pub struct InitAppStep {
pub cartridge: Cartridge,
}
impl InitAppStep {
pub fn on_enter(&mut self, req: &mut FirmwareRequest) {
req.os.initialize_vm(&self.cartridge);
}
pub fn on_update(&mut self, _req: &mut FirmwareRequest) -> Option<FirmwareState> {
Some(FirmwareState::AppRunning(RunAppStep))
}
pub fn on_exit(&mut self, _req: &mut FirmwareRequest) {}
}

22
crates/prometeu-core/src/firmware/firmware_step_launch_hub.rs
View File

@ -1,9 +1,17 @@
use crate::firmware::firmware_state::FirmwareState;
use crate::prometeu_hub::PrometeuHub;
use crate::prometeu_os::PrometeuOS;
use crate::firmware::firmware_state::{FirmwareState, HubHomeStep};
use crate::firmware::FirmwareRequest;
pub fn launch_hub(_os: &mut PrometeuOS, hub: &mut PrometeuHub) -> Option<FirmwareState> {
hub.init();
Some(FirmwareState::HubHome)
#[derive(Debug, Clone)]
pub struct LaunchHubStep;
impl LaunchHubStep {
pub fn on_enter(&mut self, req: &mut FirmwareRequest) {
req.hub.init();
}
pub fn on_update(&mut self, _req: &mut FirmwareRequest) -> Option<FirmwareState> {
Some(FirmwareState::HubHome(HubHomeStep))
}
pub fn on_exit(&mut self, _req: &mut FirmwareRequest) {}
}

21
crates/prometeu-core/src/firmware/firmware_step_reset.rs
View File

@ -1,8 +1,17 @@
use crate::firmware::firmware_state::FirmwareState;
use crate::prometeu_os::PrometeuOS;
use crate::firmware::firmware_state::{FirmwareState, SplashScreenStep};
use crate::firmware::FirmwareRequest;
pub fn step_reset(os: &mut PrometeuOS) -> Option<FirmwareState> {
os.reset();
Some(FirmwareState::SplashScreen(0))
#[derive(Debug, Clone)]
pub struct ResetStep;
impl ResetStep {
pub fn on_enter(&mut self, req: &mut FirmwareRequest) {
req.os.reset();
}
pub fn on_update(&mut self, _req: &mut FirmwareRequest) -> Option<FirmwareState> {
Some(FirmwareState::SplashScreen(SplashScreenStep { frame: 0 }))
}
pub fn on_exit(&mut self, _req: &mut FirmwareRequest) {}
}

18
crates/prometeu-core/src/firmware/firmware_step_run_app.rs
View File

@ -1,7 +1,15 @@
use crate::firmware::firmware_state::FirmwareState;
use crate::hardware::{HardwareBridge, InputSignals};
use crate::prometeu_os::PrometeuOS;
use crate::firmware::firmware_state::{AppCrashesStep, FirmwareState};
use crate::firmware::FirmwareRequest;
pub fn step_run_app(os: &mut PrometeuOS, signals: &InputSignals, hw: &mut dyn HardwareBridge) -> Option<FirmwareState> {
os.step_frame(signals, hw).map(FirmwareState::AppCrashes)
#[derive(Debug, Clone)]
pub struct RunAppStep;
impl RunAppStep {
pub fn on_enter(&mut self, _req: &mut FirmwareRequest) {}
pub fn on_update(&mut self, req: &mut FirmwareRequest) -> Option<FirmwareState> {
req.os.step_frame(req.signals, req.hw).map(|err| FirmwareState::AppCrashes(AppCrashesStep { error: err }))
}
pub fn on_exit(&mut self, _req: &mut FirmwareRequest) {}
}

88
crates/prometeu-core/src/firmware/firmware_step_splash_screen.rs
View File

@ -1,51 +1,61 @@
use crate::firmware::firmware_state::FirmwareState;
use crate::hardware::{HardwareBridge, InputSignals, LoopMode};
use crate::firmware::firmware_state::{FirmwareState, LaunchHubStep};
use crate::firmware::FirmwareRequest;
use crate::hardware::LoopMode;
use crate::model::Color;
use crate::prometeu_os::PrometeuOS;
pub fn step_splash_screen(frame: &mut u32, os: &mut PrometeuOS, signals: &InputSignals, hw: &mut dyn HardwareBridge) -> Option<FirmwareState> {
const ANIMATION_DURATION: u32 = 60; // 1 segundo a 60fps
const TOTAL_DURATION: u32 = 240; // 4 segundos totais
#[derive(Debug, Clone)]
pub struct SplashScreenStep {
pub frame: u32,
}
// Atualiza periféricos para input
hw.pad_mut().begin_frame(signals);
// Tocar som no primeiro frame
if *frame == 0 {
if let Some(sample) = os.sample_square.clone() {
hw.audio_mut().play(sample, 0, 255, 127, 1.0, 0, LoopMode::Off);
impl SplashScreenStep {
pub fn on_enter(&mut self, req: &mut FirmwareRequest) {
// Tocar som no enter
if let Some(sample) = req.os.sample_square.clone() {
req.hw.audio_mut().play(sample, 0, 255, 127, 1.0, 0, LoopMode::Off);
}
}
// Limpar tela
hw.gfx_mut().clear(Color::BLACK);
pub fn on_update(&mut self, req: &mut FirmwareRequest) -> Option<FirmwareState> {
const ANIMATION_DURATION: u32 = 60; // 1 segundo a 60fps
const TOTAL_DURATION: u32 = 240; // 2 segundos totais (conforme requisito anterior)
// Desenhar quadrado aumentando
let (sw, sh) = hw.gfx().size();
let max_size = (sw.min(sh) as i32 / 2).max(1);
let current_size = if *frame < ANIMATION_DURATION {
(max_size * (*frame as i32 + 1)) / ANIMATION_DURATION as i32
} else {
max_size
};
// Atualiza periféricos para input
req.hw.pad_mut().begin_frame(req.signals);
let x = (sw as i32 - current_size) / 2;
let y = (sh as i32 - current_size) / 2;
hw.gfx_mut().fill_rect(x, y, current_size, current_size, Color::WHITE);
hw.gfx_mut().present();
// Limpar tela
req.hw.gfx_mut().clear(Color::BLACK);
// Lógica de transição
// Caso o botão start seja pressionado a qualquer momento depois da animação terminar
if *frame >= ANIMATION_DURATION && hw.pad().any() {
return Some(FirmwareState::LaunchHub);
// Desenhar quadrado aumentando
let (sw, sh) = req.hw.gfx().size();
let max_size = (sw.min(sh) as i32 / 2).max(1);
let current_size = if self.frame < ANIMATION_DURATION {
(max_size * (self.frame as i32 + 1)) / ANIMATION_DURATION as i32
} else {
max_size
};
let x = (sw as i32 - current_size) / 2;
let y = (sh as i32 - current_size) / 2;
req.hw.gfx_mut().fill_rect(x, y, current_size, current_size, Color::WHITE);
req.hw.gfx_mut().present();
// Lógica de transição
// Caso o botão start seja pressionado a qualquer momento depois da animação terminar
if self.frame >= ANIMATION_DURATION && req.hw.pad().any() {
return Some(FirmwareState::LaunchHub(LaunchHubStep));
}
if self.frame >= TOTAL_DURATION {
return Some(FirmwareState::LaunchHub(LaunchHubStep));
}
self.frame += 1;
None
}
if *frame >= TOTAL_DURATION {
return Some(FirmwareState::LaunchHub);
}
*frame += 1;
None
pub fn on_exit(&mut self, _req: &mut FirmwareRequest) {}
}

25
crates/prometeu-core/src/firmware/mod.rs
View File

@ -1,12 +1,23 @@
mod firmware;
pub mod firmware_state;
mod firmware_step_reset;
mod firmware_step_splash_screen;
mod firmware_step_launch_hub;
mod firmware_step_hub_home;
mod firmware_step_init_app;
mod firmware_step_run_app;
mod firmware_step_crash_screen;
pub(crate) mod firmware_step_reset;
pub(crate) mod firmware_step_splash_screen;
pub(crate) mod firmware_step_launch_hub;
pub(crate) mod firmware_step_hub_home;
pub(crate) mod firmware_step_init_app;
pub(crate) mod firmware_step_run_app;
pub(crate) mod firmware_step_crash_screen;
pub use firmware::Firmware;
use crate::hardware::{HardwareBridge, InputSignals};
use crate::prometeu_hub::PrometeuHub;
use crate::prometeu_os::PrometeuOS;
pub struct FirmwareRequest<'a> {
pub os: &'a mut PrometeuOS,
pub hub: &'a mut PrometeuHub,
pub signals: &'a InputSignals,
pub hw: &'a mut dyn HardwareBridge,
}

19
crates/prometeu-core/src/prometeu_hub/prometeu_hub.rs
View File

@ -19,12 +19,14 @@ impl WindowSystem {
/// PrometeuHub: Launcher e ambiente de UI do sistema.
pub struct PrometeuHub {
pub window_system: WindowSystem,
pub color: Color,
}
impl PrometeuHub {
pub fn new() -> Self {
Self {
window_system: WindowSystem::new(),
color: Color::BLACK,
}
}
@ -32,8 +34,21 @@ impl PrometeuHub {
// Inicializa o Window System e lista apps
}
pub fn gui_update(&mut self, _os: &mut PrometeuOS) {
// Atualiza a UI do Window System
pub fn gui_update(&mut self, os: &mut PrometeuOS, hw: &mut dyn HardwareBridge) {
if hw.pad().a.down {
self.color = Color::GREEN;
}
if hw.pad().b.down {
self.color = Color::INDIGO;
}
if hw.pad().x.down {
self.color = Color::YELLOW;
}
if hw.pad().y.down {
self.color = Color::RED;
}
hw.gfx_mut().clear(self.color);
}
pub fn render(&mut self, _os: &mut PrometeuOS, _hw: &mut dyn HardwareBridge) {