euv-engine 0.31.1

A high-performance 2D game engine built on the euv framework, featuring ECS, fixed-timestep game loop, canvas rendering, physics, collision detection, sprite animation, and audio.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

use super::*;

/// A zero-sized namespace struct providing static engine entry points.
///
/// This struct follows the same pattern as `euv::App`, serving as the
/// single root namespace for all top-level engine operations: creating
/// engine handles, initializing rendering backends, and starting the
/// fixed-timestep game loop.
///
/// All engine usage flows through `Engine::xxx` static calls, mirroring
/// how `euv::App::use_signal` / `euv::App::mount` are the public entry
/// points of the core framework.
#[derive(Clone, Copy, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct Engine;

/// A handle to a running or initialized engine instance.
///
/// Holds the engine configuration, an optional Canvas 2D renderer, an
/// optional WebGPU renderer, and the optional scheduler handle once the
/// game loop has started. Use `Engine::new_handle` to construct one, then
/// call `init_canvas` or `init_webgpu` (matching the backend chosen in
/// `RenderConfig`) and finally `start` to begin the game loop.
#[derive(Clone, Data, New)]
pub struct EngineHandle {
    /// The engine configuration containing render and scheduler settings.
    #[get_mut(pub(crate))]
    #[set(pub(crate))]
    pub config: EngineConfig,
    /// The initialized Canvas 2D renderer, or `None` if the WebGPU backend is used or initialization has not yet happened.
    #[get(pub(crate), type(clone))]
    #[get_mut(pub(crate))]
    #[set(pub(crate))]
    pub(crate) canvas_renderer: Option<CanvasRenderer>,
    /// The initialized WebGPU renderer, or `None` if the Canvas 2D backend is used or initialization has not yet happened.
    #[get(pub(crate), type(clone))]
    #[get_mut(pub(crate))]
    #[set(pub(crate))]
    pub(crate) webgpu_renderer: Option<WebGpuRenderer>,
    /// The initialized WebGL 2 renderer, or `None` if another backend is used or initialization has not yet happened.
    #[get(pub(crate), type(clone))]
    #[get_mut(pub(crate))]
    #[set(pub(crate))]
    pub(crate) webgl_renderer: Option<WebGl2Backend>,
    /// The shared input state once `register_input` has attached the DOM
    /// event listeners, or `None` before registration (or if the canvas
    /// selector did not resolve at registration time).
    #[new(skip)]
    #[get_mut(pub(crate))]
    #[set(pub(crate))]
    pub input_cell: Option<InputStateCell>,
    /// The shared task registry holding every [`Updatable`] object the
    /// scheduler advances on each fixed step. Always present so callers can
    /// register tasks before `start` is called.
    #[new(skip)]
    #[get(pub(crate))]
    #[get_mut(pub(crate))]
    #[set(pub(crate))]
    pub(crate) tasks: TaskRegistryRc,
    /// The shared asset loader, present once `register_assets` has created
    /// it, or `None` when asset loading was never requested.
    #[new(skip)]
    #[get(pub(crate))]
    #[get_mut(pub(crate))]
    #[set(pub(crate))]
    pub(crate) asset_loader: Option<AssetLoader>,
    /// The running scheduler handle, or `None` before `start` is called.
    #[get(pub(crate))]
    #[get_mut(pub(crate))]
    #[set(pub(crate))]
    pub(crate) scheduler_handle: Option<SchedulerHandle>,
}