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
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149

use super::*;

/// A deterministic xorshift64* pseudo-random generator used by particle
/// emitters.
///
/// The engine intentionally avoids both the `rand` crate (dependency weight
/// for a wasm target) and `js_sys::Math::random` (non-deterministic, and
/// unusable outside a JS runtime, which would make host-side unit tests
/// impossible). A seeded generator keeps emitter behavior reproducible.
#[derive(Clone, Copy, Data, Debug, New, PartialEq, PartialOrd)]
pub struct ParticleRng {
    /// The current generator state. Never zero after construction.
    #[get(type(copy))]
    #[get_mut(pub(crate))]
    #[set(pub(crate))]
    pub state: u64,
}

/// The static configuration of a particle emitter, describing how new
/// particles are spawned and how they evolve over their lifetime.
///
/// Every field is publicly settable, so a caller composes a config by
/// starting from [`ParticleConfig::default`] and overriding the tunables it
/// cares about before handing it to [`ParticleEmitter::create`].
#[derive(Clone, Copy, Data, Debug, New, PartialEq, PartialOrd)]
pub struct ParticleConfig {
    /// The number of particles spawned per second while the emitter is active.
    #[get(pub(crate), type(copy))]
    #[get_mut(pub(crate))]
    pub emission_rate: f64,
    /// The maximum number of simultaneously live particles.
    #[get(pub(crate), type(copy))]
    pub max_particles: usize,
    /// The minimum particle lifetime in seconds.
    #[get(type(copy))]
    pub lifetime_min: f64,
    /// The maximum particle lifetime in seconds.
    #[get(type(copy))]
    #[get_mut(pub(crate))]
    pub lifetime_max: f64,
    /// The minimum initial particle speed in world units per second.
    #[get(pub(crate), type(copy))]
    #[get_mut(pub(crate))]
    pub speed_min: f64,
    /// The maximum initial particle speed in world units per second.
    #[get(pub(crate), type(copy))]
    #[get_mut(pub(crate))]
    pub speed_max: f64,
    /// The central emission direction in radians.
    #[get(pub(crate), type(copy))]
    #[new(skip)]
    #[set(pub(crate))]
    #[get_mut(pub(crate))]
    pub(crate) angle: f64,
    /// The total cone width around `angle` in radians within which
    /// particle directions are uniformly randomized.
    #[get(pub(crate), type(copy))]
    #[new(skip)]
    #[set(pub(crate))]
    #[get_mut(pub(crate))]
    pub(crate) spread: f64,
    /// The constant acceleration applied to every live particle.
    #[get(pub(crate), type(copy))]
    #[new(skip)]
    #[get_mut(pub(crate))]
    pub gravity: Vector2D,
    /// The particle color at birth.
    #[get(pub(crate), type(copy))]
    #[new(skip)]
    #[set(pub(crate))]
    #[get_mut(pub(crate))]
    pub(crate) color_start: Color,
    /// The particle color at death. Set its alpha to 0.0 for a fade-out.
    #[get(pub(crate), type(copy))]
    #[new(skip)]
    #[set(pub(crate))]
    #[get_mut(pub(crate))]
    pub(crate) color_end: Color,
    /// The particle radius at birth in world units.
    #[get(pub(crate), type(copy))]
    #[new(skip)]
    #[get_mut(pub(crate))]
    pub size_start: f64,
    /// The particle radius at death in world units.
    #[get(pub(crate), type(copy))]
    #[new(skip)]
    #[get_mut(pub(crate))]
    pub size_end: f64,
}

/// A single live particle.
#[derive(Clone, Copy, Data, Debug, New, PartialEq, PartialOrd)]
pub struct Particle {
    /// The current world-space position.
    #[get(type(copy))]
    #[get_mut(pub(crate))]
    pub position: Vector2D,
    #[get(type(clone))]
    #[get_mut(pub(crate))]
    pub velocity: Vector2D,
    /// The time this particle has been alive, in seconds.
    #[get(pub(crate), type(copy))]
    #[get_mut(pub(crate))]
    #[set(pub(crate))]
    pub(crate) age: f64,
    /// The total lifetime of this particle, in seconds.
    #[get(type(copy))]
    #[set(pub(crate))]
    #[get_mut(pub(crate))]
    pub lifetime: f64,
}

/// A point emitter that continuously (or in bursts) spawns particles,
/// integrates their motion, and records them into a `DrawList` as colored
/// circles whose color and size interpolate over each particle's lifetime.
#[derive(Clone, Data, Debug, New, PartialEq)]
pub struct ParticleEmitter {
    /// The world-space emission point.
    #[get(type(copy))]
    #[get_mut(pub(crate))]
    pub position: Vector2D,
    /// The emitter configuration.
    #[get(type(clone))]
    #[get_mut(pub(crate))]
    pub config: ParticleConfig,
    /// All currently live particles.
    #[get(type(clone))]
    #[get_mut(pub(crate))]
    #[set(pub(crate))]
    #[new(skip)]
    pub particles: Vec<Particle>,
    /// The fractional particle spawn budget carried between updates.
    #[get(type(copy))]
    #[get_mut(pub(crate))]
    #[set(pub(crate))]
    #[new(skip)]
    pub emit_accumulator: f64,
    /// Whether continuous emission is currently enabled.
    #[get(pub(crate), type(copy))]
    #[new(skip)]
    #[get_mut(pub(crate))]
    pub active: bool,
    /// The emitter's deterministic random generator.
    #[get(type(copy), pub(crate))]
    #[get_mut(pub(crate))]
    #[set(pub(crate))]
    #[new(skip)]
    pub(crate) rng: ParticleRng,
}