Struct EngineCore 

pub struct EngineCore<A: EngineApp> { /* private fields */ }

The core engine state, independent of any windowing backend.

Created by the windowing driver (e.g. WinitAppRunner), then driven frame-by-frame via EngineCore::tick.

Implementations

impl<A: EngineApp> EngineCore<A>

pub fn new() -> Self

Creates a new, uninitialized engine core.

pub fn bootstrap(&mut self, app: A, runtime: Runtime)

Bootstraps the engine: creates DCC, telemetry, scheduler, registers agents, calls app.setup(), and initializes agents.

This method takes ownership of the runtime populated by the windowing driver’s bootstrap closure. It wraps the runtime in an Arc once all built-in entries have been inserted.

pub fn feed_input(&mut self, event: InputEvent)

Queues an input event to be processed on the next tick.

pub fn tick(&mut self)

Executes one frame: app update, ECS maintenance, scheduler.

This method is called by the windowing driver (e.g. winit) each time a redraw is requested.

pub fn tick_with_runtime(&mut self, frame_runtime_arc: Arc<Runtime>)

Executes one frame with a custom per-frame Runtime overlay.

Used by the winit runner to inject a FrameContext into the per-frame Resources for cross-agent synchronization.

This is a convenience wrapper that calls the staged methods in order without invoking any EngineApp lifecycle hooks. Drivers that need to interleave hooks (e.g., the editor’s overlay/shell) should call the staged methods directly via the winit runner.

pub fn run_maintenance(&mut self)

Stage 6 — runs the end-of-tick Maintenance-phase DataSystems against the scheduler’s per-frame [OutputDeck].

The engine is subsystem-agnostic here: it threads the deck through the substrate dispatcher and lets each DataSystem drain whatever typed slot belongs to its domain (audio writeback, physics writeback, future subsystems …). No subsystem-specific code lives in this method.

pub fn drain_inputs(&mut self) -> Vec<InputEvent>

Stage 1 — drain queued input events. Also marks simulation started (emits the "simulation" phase change on the first call), ticks the telemetry service, and feeds the events into the engine-wide [khora_core::platform::InputMap] so app code can query actions (is_pressed, just_pressed) from the same frame’s inputs.

pub fn run_app_update(&mut self, inputs: &[InputEvent])

Stage 2 — run app.update, ECS maintenance, mesh sync, and scene/UI extractions. Called between drain_inputs and begin_render_frame.

pub fn begin_render_frame(&mut self, frame_runtime_arc: &Arc<Runtime>) -> bool

Stage 3 — acquire the swapchain via RenderSystem::begin_frame and populate the per-frame [FrameContext] with ColorTarget, DepthTarget, and ClearColor.

Returns true when a renderer is present and begin_frame succeeded (driver should later call present_frame). Returns false only when no renderer is registered or the swapchain could not be acquired.

pub fn run_scheduler(&mut self, frame_runtime_arc: &Arc<Runtime>)

Stage 4 — dispatch the scheduler so all registered agents execute their phases for this frame.

pub fn submit_passes(&mut self, presents: bool)

Stage 5a — submit recorded passes from the [FrameGraph] to the GPU. When presents is false (render-to-viewport mode), the frame graph is discarded instead.

pub fn present_frame(&mut self, presents: bool)

Stage 5b — call RenderSystem::end_frame to present the swapchain. No-op when presents is false.

pub fn end_render_frame(&mut self, presents: bool)

Convenience: runs both submit_passes and present_frame in order. Used by the default tick path; drivers that need to interleave hooks should call the staged methods directly.

pub fn app_mut(&mut self) -> Option<&mut A>

Mutable accessor for the application instance. Used by the winit runner to invoke EngineApp lifecycle hooks between staged frame methods.

pub fn with_app_and_world<F>(&mut self, f: F)

where F: FnOnce(&mut A, &mut GameWorld),

Invokes a closure with mutable access to BOTH the application and the game world simultaneously. Used by the winit runner to call lifecycle hooks that need to read/write components (e.g., gizmo collection) without re-borrowing EngineCore twice.

The closure is skipped silently if either is uninitialized.

pub fn set_runtime(&mut self, runtime: Arc<Runtime>)

Stores the runtime Arc. Used by the winit runner after bootstrap.

pub fn runtime(&self) -> &Arc<Runtime>

Returns a reference to the engine-level runtime.

pub fn game_world_mut(&mut self) -> Option<&mut GameWorld>

Returns a mutable reference to the game world, if initialized.

pub fn dcc(&self) -> Option<&DccService>

Returns the DCC service, if initialized.

pub fn set_engine_hint(&self, hint: EngineHint)

Applies a developer EngineHint biasing GORNA arbitration (Cap a per-frame budget, Prioritize an agent) without changing game semantics. No-op if the DCC isn’t running. Thread-safe; takes effect on the next arbitration tick.

pub fn clear_agent_hints(&self, agent_id: AgentId)

Clears all developer hints for an agent, restoring engine defaults.

pub fn engine_hints(&self) -> HashMap<AgentId, AgentHints>

Read-only snapshot of the accumulated per-agent hints (glass-box), or an empty map if the DCC isn’t running.

pub fn shutdown(&mut self)

Shuts down the engine, calling app.on_shutdown().

Note: renderer shutdown is the responsibility of the application, since the renderer was created and registered by the app’s bootstrap closure.

Trait Implementations

impl<A: EngineApp> Default for EngineCore<A>

fn default() -> Self

Returns the “default value” for a type.