Add design persistence, world rendering, metrics overlay and logs

M3: STL/OBJ import with mesh validation, mass/COM/inertia, material database, RON scene with content-addressed blobs and v0->v1 migration. M4: deterministic heightmap terrain, trimesh colliders, wgpu renderer with instancing and depth, winit app with 1 kHz physics, fly camera, on-screen metrics overlay and per-frame CSV/dev logs. Docs: UI, logging, network and headless CLI plans.
This commit is contained in:
Loki 2026-11-16 23:34:05 +01:00
parent 878d144b77
commit 190ef9cc4b
111 changed files with 14801 additions and 63 deletions

View file

@ -0,0 +1,320 @@
//! The application handler: window installation, resize, redraw and logging.
use std::sync::Arc;
use std::time::Duration;
use fabrilis_render::Overlay;
use winit::application::ApplicationHandler;
use winit::dpi::PhysicalSize;
use winit::event::{ElementState, KeyEvent, MouseButton, WindowEvent};
use winit::event_loop::{ActiveEventLoop, ControlFlow, EventLoop};
use winit::keyboard::{KeyCode, PhysicalKey};
use winit::window::{Window, WindowId};
use super::camera::Controls;
use super::config::Config;
use super::devlog::{self, DevLog, Level};
use super::gpu::WindowRenderer;
use super::metrics::{CsvLog, FrameWork, Metrics, Row, Stopwatch, spike_reason, unix_now};
use super::scene::View;
use super::sim::Simulation;
use super::{AppError, aspect, log_startup};
/// Runs the window loop until the user closes the window or presses Escape.
pub(super) fn run() -> Result<(), AppError> {
let config = super::parse_config();
let csv = super::open_csv(&config)?;
let level = if config.dev {
Level::Debug
} else {
Level::Info
};
let dev = match &config.log {
Some(path) => Some(
DevLog::open(path, level, config.append)
.map_err(|error| AppError::Log(format!("{}: {error}", path.display())))?,
),
None => None,
};
let event_loop = EventLoop::new().map_err(|error| AppError::EventLoop(error.to_string()))?;
event_loop.set_control_flow(ControlFlow::Poll);
let mut application = Fabrilis::new(config, csv, dev);
let result = event_loop.run_app(&mut application);
if let Err(error) = &result {
application.report("event loop", &error.to_string());
}
application.finish();
result.map_err(|error| AppError::EventLoop(error.to_string()))
}
/// The window state plus the diagnostics that observe it.
struct Fabrilis {
config: Config,
csv: Option<CsvLog>,
dev: Option<DevLog>,
frame: u64,
window: Option<Arc<Window>>,
renderer: Option<WindowRenderer>,
view: Option<View>,
simulation: Option<Simulation>,
controls: Controls,
metrics: Metrics,
overlay: Overlay,
}
impl Fabrilis {
fn new(config: Config, csv: Option<CsvLog>, dev: Option<DevLog>) -> Self {
Self {
config,
csv,
dev,
frame: 0,
window: None,
renderer: None,
view: None,
simulation: None,
controls: Controls::default(),
metrics: Metrics::default(),
overlay: Overlay::new(),
}
}
fn install(&mut self, event_loop: &ActiveEventLoop) -> Result<(), AppError> {
let attributes = Window::default_attributes()
.with_title("Fabrilis — RTF ...")
.with_inner_size(PhysicalSize::new(1280, 720));
let window = Arc::new(
event_loop
.create_window(attributes)
.map_err(|error| AppError::Window(error.to_string()))?,
);
let mut view = super::scene::build(aspect(window.inner_size()))?;
let simulation = Simulation::new(&view.terrain, &view.heightmap, &mut view.scene)?;
let renderer = WindowRenderer::new(window.clone())?;
log_startup(self.dev.as_mut(), &self.config, &view, &renderer, &window);
self.window = Some(window);
self.renderer = Some(renderer);
self.view = Some(view);
self.simulation = Some(simulation);
Ok(())
}
fn resize(&mut self, size: PhysicalSize<u32>) {
let result = match &mut self.renderer {
Some(renderer) => renderer.resize(size.width, size.height),
None => return,
};
if let Err(error) = result {
eprintln!("fabrilis: resize failed: {error}");
self.report("resize", &error.to_string());
return;
}
if let Some(view) = &mut self.view {
view.camera.set_aspect(aspect(size));
}
if let Some(window) = &self.window {
window.request_redraw();
}
}
fn redraw(&mut self) {
let Some(view) = self.view.as_mut() else {
return;
};
let Some(simulation) = self.simulation.as_mut() else {
return;
};
let unix_s = if self.csv.is_some() {
Some(unix_now())
} else {
None
};
let frame_time = self.metrics.frame_time();
let physics_start = Stopwatch::start();
let frame = simulation.advance(&mut view.scene);
let physics = physics_start.elapsed();
let slowest_step_ms = simulation.slowest_step().as_secs_f32() * 1000.0;
let sim_seconds = simulation.sim_seconds();
let motion = self.controls.motion(frame.elapsed_seconds);
view.camera.apply(motion);
if let (Some(rtf), Some(window)) = (frame.rtf, &self.window) {
window.set_title(&format!("Fabrilis — RTF {rtf:.2}"));
}
self.metrics.set_rtf(frame.rtf);
let camera = view.camera.view();
let size = self
.renderer
.as_ref()
.map_or((0, 0), |renderer| renderer.size());
self.overlay.clear();
if size.0 > 0 && size.1 > 0 {
self.metrics.draw_panel(&mut self.overlay);
}
let Some(renderer) = self.renderer.as_mut() else {
return;
};
let render_start = Stopwatch::start();
let draw = renderer.draw(&view.scene, &camera, &self.overlay);
let render = render_start.elapsed();
if let Err(error) = draw {
eprintln!("fabrilis: draw failed: {error}");
write_dev(&mut self.dev, Level::Error, "render", &error.to_string());
}
let recorded = self.metrics.record(
frame_time,
FrameWork {
physics,
render,
steps: frame.steps,
},
);
if !recorded {
return;
}
self.frame = self.frame.saturating_add(1);
self.log_frame(frame_time, slowest_step_ms, sim_seconds, unix_s);
}
/// Writes the CSV row and the dev-log summary and spike lines for one frame.
///
/// Both observers run after the frame was drawn and only read the metrics
/// that the overlay already computed.
fn log_frame(
&mut self,
frame_time: Duration,
slowest_step_ms: f32,
sim_seconds: f64,
unix_s: Option<f64>,
) {
let stats = self.metrics.stats();
let frame_ms = frame_time.as_secs_f32() * 1000.0;
let spike = spike_reason(frame_ms, slowest_step_ms);
if let Some(unix_s) = unix_s {
let row = Row {
unix_s,
t_s: sim_seconds,
frame: self.frame,
stats: &stats,
spike: spike.is_some(),
};
if let Some(csv) = self.csv.as_mut()
&& let Err(error) = csv.record(&row)
{
eprintln!("fabrilis: metrics log write failed: {error}");
write_dev(&mut self.dev, Level::Error, "metrics", &error.to_string());
}
}
if let Some(dev) = self.dev.as_mut() {
if dev.summary_due() {
write_line(dev, Level::Info, "metrics", &devlog::summary(&stats));
}
if let Some(trigger) = spike {
let line = devlog::spike(self.frame, frame_ms, slowest_step_ms, trigger);
write_line(dev, Level::Warn, "spike", &line);
}
}
}
/// Logs a failure with its context before the loop gives up on the step.
fn report(&mut self, context: &str, detail: &str) {
write_dev(
&mut self.dev,
Level::Error,
"app",
&format!("{context}: {detail}"),
);
}
/// Flushes the CSV and closes the dev session.
fn finish(&mut self) {
if let Some(csv) = self.csv.as_mut()
&& let Err(error) = csv.flush()
{
eprintln!("fabrilis: metrics log flush failed: {error}");
}
write_dev(&mut self.dev, Level::Info, "app", "session end");
}
fn is_escape(event: &KeyEvent) -> bool {
event.state == ElementState::Pressed
&& event.physical_key == PhysicalKey::Code(KeyCode::Escape)
}
fn key(&mut self, event: &KeyEvent) {
if let PhysicalKey::Code(code) = event.physical_key {
self.controls
.key(code, event.state == ElementState::Pressed);
}
}
}
/// Writes one dev-log line and reports a write failure on stderr.
fn write_line(dev: &mut DevLog, level: Level, target: &str, message: &str) {
if let Err(error) = dev.write(level, target, message) {
eprintln!("fabrilis: dev log write failed: {error}");
}
}
/// Writes one dev-log line when the log is enabled.
fn write_dev(dev: &mut Option<DevLog>, level: Level, target: &str, message: &str) {
if let Some(dev) = dev {
write_line(dev, level, target, message);
}
}
impl ApplicationHandler for Fabrilis {
fn resumed(&mut self, event_loop: &ActiveEventLoop) {
if self.window.is_some() {
return;
}
if let Err(error) = self.install(event_loop) {
eprintln!("fabrilis: startup failed: {error}");
self.report("startup", &error.to_string());
event_loop.exit();
return;
}
if let Some(window) = &self.window {
window.request_redraw();
}
}
fn window_event(
&mut self,
event_loop: &ActiveEventLoop,
_window_id: WindowId,
event: WindowEvent,
) {
match event {
WindowEvent::CloseRequested => event_loop.exit(),
WindowEvent::KeyboardInput { event, .. } if Self::is_escape(&event) => {
event_loop.exit();
}
WindowEvent::KeyboardInput { event, .. } => self.key(&event),
WindowEvent::MouseInput {
state,
button: MouseButton::Left,
..
} => self.controls.mouse(state),
WindowEvent::CursorMoved { position, .. } => {
self.controls.cursor_moved(position.x, position.y);
}
WindowEvent::Focused(false) => self.controls.release_all(),
WindowEvent::Resized(size) => self.resize(size),
WindowEvent::ScaleFactorChanged { .. } => {
let size = self
.window
.as_ref()
.map_or(PhysicalSize::new(0, 0), |window| window.inner_size());
self.resize(size);
}
WindowEvent::RedrawRequested => self.redraw(),
_ => {}
}
}
fn about_to_wait(&mut self, _event_loop: &ActiveEventLoop) {
if let Some(window) = &self.window {
window.request_redraw();
}
}
}