Struct ProofEngine 

pub struct ProofEngine {
    pub config: EngineConfig,
    pub scene: SceneGraph,
    pub camera: ProofCamera,
    pub input: InputState,
    pub ui: UiLayer,
    pub fx: ScreenFx,
    pub audio: Option<AudioEngine>,
    /* private fields */
}

The main engine struct. Create once, run forever.

Fields

config: EngineConfig

scene: SceneGraph

camera: ProofCamera

input: InputState

ui: UiLayer

Screen-space UI, in pixel coordinates. Cleared at the start of every frame by run_ui, so games redraw it immediate-mode style.

fx: ScreenFx

Transient screen effects: shockwaves, flashes, light shafts. Fire and forget; ticked and uploaded by run_ui every frame.

audio: Option<AudioEngine>

Optional audio engine — None if no output device is available.

Implementations

impl ProofEngine

pub fn run_game<G: ProofGame>(game: G)

Run the engine with a ProofGame implementation.

This is the preferred entry point for games that implement ProofGame. It calls on_start(), runs the game loop calling update() each frame, then calls on_stop() on clean exit.

use proof_engine::prelude::*;
use proof_engine::integration::ProofGame;

struct MyGame;
impl ProofGame for MyGame {
    fn title(&self) -> &str { "My Game" }
    fn update(&mut self, _engine: &mut ProofEngine, _dt: f32) {}
}

ProofEngine::run_game(MyGame);

impl ProofEngine

pub fn dispatch(&mut self, event: GameEvent)

Dispatch a GameEvent to the appropriate engine subsystem.

This is the primary integration point — chaos-rpg-core can queue events each frame and the engine handles the visual/audio response.

impl ProofEngine

pub fn new(config: EngineConfig) -> Self

pub fn init_gpu_density(&mut self, particles: u32)

Turn on GPU density entities with a per-entity particle budget.

The budget is capped at MAX_PARTICLES_PER_ENTITY: past that there are more particles than pixels and the picture stops improving while the frame time keeps climbing. Asking for more is fine; you get the cap and a log line.

pub fn queue_gpu_density_entity(&mut self, entity: GpuDensityEntityData)

Draw a density entity this frame. Call every frame it should show.

pub fn emit_audio(&self, event: AudioEvent)

Send an audio event. No-op if audio is unavailable.

pub fn run<F>(&mut self, update: F)

where F: FnMut(&mut ProofEngine, f32),

Run the engine. Calls update every frame with elapsed seconds. Blocks until the window is closed.

pub fn run_with_overlay<F>(&mut self, update: F)

where F: FnMut(&mut ProofEngine, f32, &Context),

Run the engine with an overlay callback. The overlay callback receives the glow GL context reference and is called AFTER scene rendering but BEFORE buffer swap — perfect for egui.

pub fn run_ui<F>(&mut self, update: F)

where F: FnMut(&mut ProofEngine, f32),

Run a UI-driven game.

Unlike [run], update is called before the scene is drawn, and the screen-space ui layer is painted afterwards. That ordering matters for a game: what you push this frame is what appears this frame, rather than showing up one frame late.

The UI layer is cleared before each update, so games redraw it in full every frame instead of tracking what to erase.

pub fn add_field(&mut self, field: ForceField) -> FieldId

Add a force field to the scene.

pub fn remove_field(&mut self, id: FieldId)

Remove a force field.

pub fn spawn_glyph(&mut self, glyph: Glyph) -> GlyphId

Spawn a glyph into the scene.

pub fn spawn_entity(&mut self, entity: AmorphousEntity) -> EntityId

Spawn an amorphous entity, creating its formation glyphs.

pub fn emit_particles(&mut self, emitter: EmitterPreset, origin: Vec3)

Emit a burst of particles at a position.

pub fn add_trauma(&mut self, amount: f32)

Apply trauma (screen shake). 0.0 = none, 1.0 = maximum.

impl ProofEngine

Request quit on next frame.

pub fn request_quit(&mut self)

pub fn gl(&self) -> Option<&Context>

Get a reference to the glow GL context (for egui integration). Returns None if the pipeline hasn’t been initialized yet.

pub fn window(&self) -> Option<&Window>

Get the window reference (for egui-winit event processing).

pub fn window_size(&self) -> (u32, u32)

Get the current window size in pixels.

pub fn render_size(&self) -> (u32, u32)

The framebuffer size, in the same units the viewport uses.

Screen-space UI must lay out against this, not the window size: on a scaled display the two differ and the UI ends up magnified.

pub fn save_frame(&self, path: &str) -> Result<()>

Write the frame currently on screen to an uncompressed 24-bit BMP.

The point of this is being able to see what the engine actually drew. Asking the window manager for a picture of a hardware-accelerated window is unreliable — it hands back whatever it last cached, which can be a stale frame or a blank one — so the only trustworthy answer comes from reading the framebuffer back off the GPU.

BMP because it needs no compression and therefore no dependency; the row order matches OpenGL’s, so no flip is needed either.