Crate proof_engine

Expand description

§Proof Engine

A mathematical rendering engine for Rust. Every visual is the output of a mathematical function. Every animation is a continuous function over time. Every particle follows a real equation.

§Philosophy

Proof Engine does not render graphics. It renders mathematics.

A traditional renderer draws shapes and colors that represent game state. Proof Engine computes mathematical functions and the visual IS the output. A Lorenz attractor looks like a Lorenz attractor because particles are following the actual differential equations in real time.

§Quick Start

use proof_engine::prelude::*;

let config = EngineConfig::default();
let mut engine = ProofEngine::new(config);
engine.run(|engine, _dt| {
    // game logic
});

Re-exports§

pub use config::EngineConfig;
pub use math::MathFunction;
pub use math::ForceField;
pub use math::Falloff;
pub use math::AttractorType;
pub use glyph::Glyph;
pub use glyph::RenderLayer;
pub use glyph::BlendMode;
pub use entity::AmorphousEntity;
pub use particle::MathParticle;
pub use particle::ParticleInteraction;
pub use scene::SceneGraph;
pub use render::camera::ProofCamera;
pub use input::InputState;
pub use input::Key;
pub use render::pipeline::FrameStats;
pub use audio::AudioEvent;

Modules§

ai: AI module — Behavior Trees, Utility AI, Goal-Oriented Action Planning, Pathfinding, Navigation Meshes, Flow Fields, Steering Behaviors, and Blackboard.
anim: Animation State Machine for Proof Engine.
animation: Animation State Machine and Blend Trees.
asset: Asset Pipeline
audio: Mathematical audio — the same functions that drive visuals also drive sound.
behavior: AI Behavior subsystem — Behavior Trees, built-in nodes, and GOAP planner.
character
combat: Combat system — damage, status effects, hit detection, and DPS calculation.
compute: GPU Compute Pipeline
config: Engine configuration — hierarchical, hot-reloadable, command-line overridable.
crafting: Crafting & Economy System
debug: Debug overlay and performance profiling.
deferred: Deferred rendering subsystem for the Proof Engine.
dsp: Digital Signal Processing — module root
economy: Economy subsystem: market simulation, faction economies, and production chains.
ecs: Entity Component System (ECS)
editor: In-Engine Editor — master state, camera, undo/redo, grid, shortcuts.
effects: Screen effects coordinator — combines all post-processing passes into a single, driven, event-triggered system.
entity: Amorphous entity rendering.
game: Game Systems Module — top-level game state coordinator
glyph: Glyph — the fundamental rendering primitive.
input: Input handling — keyboard, mouse, scroll, and window events.
integration: ProofGame integration trait — the contract between proof-engine and chaos-rpg-core.
lighting: Advanced lighting subsystem for Proof Engine.
math: Mathematical primitives: functions, force fields, attractors.
netcode: Netcode Subsystem
network: Networking for Proof Engine: HTTP + WebSocket client, leaderboards, cloud saves.
networking: Networking module: HTTP client, WebSocket client, connection management.
particle: Mathematical particle system.
pathfinding
physics: Physics simulation — rigid bodies, constraints, collision, fluid dynamics.
prelude: Common imports for using Proof Engine.
procedural: Procedural content generation — dungeons, rooms, spawn tables, loot, names.
profiler: CPU/GPU performance profiler with hierarchical timing, counters, and flame graph capture.
render: Rendering pipeline — window, OpenGL context, glyph batching, post-processing.
rendergraph: Declarative render graph subsystem for the Proof Engine.
replay: Replay system: input recording, deterministic playback, scrubbing, ghost.
save: Save / Load System
scene: Scene graph — manages all active glyphs, entities, particles, and force fields. Full implementation with BVH spatial index, scene queries, serialization, transform hierarchy, layer management, event system, and portals.
scripting: Proof Engine scripting system — pure-Rust Lua-like language engine.
shader_graph: Shader Graph System
spatial: Spatial acceleration structures for fast proximity queries.
surfaces: Surface Rendering Subsystem
terrain: Terrain System
timeline: Cutscene and timeline system — scripted sequences of engine events.
tween: Tween / animation system.
ui: UI Widget System for Proof Engine.
vfx: Visual effects system: decals, trails, impact splats, ribbon renderers, screen-space effects, procedural destruction visuals, particle emitters, effect presets and force fields.
weather
world: Open-world management: zone streaming, portals, day/night cycle, weather simulation, and world-level event coordination.

Structs§

ProofEngine: The main engine struct. Create once, run forever.