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
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245

use super::*;

/// A zero-sized namespace struct providing static math utility methods.
///
/// This struct follows the same pattern as `App`, serving as a namespace for
/// free-standing mathematical functions such as `clamp`, `lerp`, angle conversions,
/// and interpolation helpers.
#[derive(Clone, Copy, Data, Debug, Default, Eq, Hash, New, Ord, PartialEq, PartialOrd)]
pub struct Numeric;

/// A 2D vector with `x` and `y` components represented as `f64`.
#[derive(Clone, Copy, Data, Debug, Default, New, PartialEq, PartialOrd)]
pub struct Vector2D {
    /// The horizontal component of the vector.
    #[get(type(copy))]
    #[get_mut(pub(crate))]
    pub x: f64,
    /// The vertical component of the vector.
    #[get(type(copy))]
    #[get_mut(pub(crate))]
    pub y: f64,
}

/// An axis-aligned rectangle defined by its top-left corner and dimensions.
#[derive(Clone, Copy, Data, Debug, Default, New, PartialEq, PartialOrd)]
pub struct Rect {
    /// The x coordinate of the top-left corner.
    #[get(type(copy))]
    #[get_mut(pub(crate))]
    pub x: f64,
    /// The y coordinate of the top-left corner.
    #[get(type(copy))]
    #[get_mut(pub(crate))]
    pub y: f64,
    /// The width of the rectangle.
    #[get(type(copy))]
    #[get_mut(pub(crate))]
    pub width: f64,
    /// The height of the rectangle.
    #[get(type(copy))]
    #[get_mut(pub(crate))]
    pub height: f64,
}

/// A circle defined by its center point and radius.
#[derive(Clone, Copy, Data, Debug, Default, New, PartialEq, PartialOrd)]
pub struct Circle {
    /// The center point of the circle.
    #[get(type(copy))]
    #[get_mut(pub(crate))]
    #[set(pub(crate))]
    pub center: Vector2D,
    /// The radius of the circle.
    #[get(type(copy))]
    #[get_mut(pub(crate))]
    #[set(pub(crate))]
    pub radius: f64,
}

/// A 2D transform composed of position, rotation (in radians), and scale.
#[derive(Clone, Copy, Data, Debug, New, PartialEq, PartialOrd)]
pub struct Transform2D {
    /// The position offset of the transform.
    #[get(type(copy))]
    #[get_mut(pub(crate))]
    pub position: Vector2D,
    /// The rotation angle in radians.
    #[get(pub(crate), type(copy))]
    #[get_mut(pub(crate))]
    #[set(pub(crate))]
    pub(crate) rotation: f64,
    /// The scale factors for each axis.
    #[get(pub(crate), type(copy))]
    #[get_mut(pub(crate))]
    #[set(pub(crate))]
    pub(crate) scale: Vector2D,
}

/// A color represented by red, green, blue, and alpha channels in the range 0.0 to 1.0.
#[derive(Clone, Copy, Data, Debug, New, PartialEq, PartialOrd)]
pub struct Color {
    /// The red channel value in the range 0.0 to 1.0.
    #[get(type(copy))]
    #[get_mut(pub(crate))]
    #[set(pub(crate))]
    pub red: f64,
    /// The green channel value in the range 0.0 to 1.0.
    #[get(type(copy))]
    #[get_mut(pub(crate))]
    #[set(pub(crate))]
    pub green: f64,
    /// The blue channel value in the range 0.0 to 1.0.
    #[get(type(copy))]
    #[get_mut(pub(crate))]
    #[set(pub(crate))]
    pub blue: f64,
    /// The alpha (opacity) channel value in the range 0.0 to 1.0.
    #[get(type(copy))]
    pub alpha: f64,
}

/// A 3D vector with `x`, `y`, and `z` components represented as `f64`.
#[derive(Clone, Copy, Data, Debug, Default, New, PartialEq, PartialOrd)]
pub struct Vector3D {
    /// The horizontal component of the vector.
    #[get(type(copy))]
    #[get_mut(pub(crate))]
    pub x: f64,
    /// The vertical component of the vector.
    #[get(type(copy))]
    #[get_mut(pub(crate))]
    pub y: f64,
    /// The depth component of the vector.
    #[get(type(copy))]
    #[get_mut(pub(crate))]
    pub z: f64,
}

/// A quaternion representing a 3D rotation with `x`, `y`, `z`, and `w` components.
#[derive(Clone, Copy, Data, Debug, New, PartialEq, PartialOrd)]
pub struct Quaternion {
    /// The x component of the quaternion.
    #[get(type(copy))]
    #[get_mut(pub(crate))]
    pub x: f64,
    /// The y component of the quaternion.
    #[get(type(copy))]
    #[get_mut(pub(crate))]
    pub y: f64,
    /// The z component of the quaternion.
    #[get(type(copy))]
    #[get_mut(pub(crate))]
    pub z: f64,
    /// The w (scalar) component of the quaternion.
    #[get(type(copy))]
    #[get_mut(pub(crate))]
    #[set(pub(crate))]
    pub w: f64,
}

/// A 4x4 matrix stored in column-major order, used for 3D transformations.
#[derive(Clone, Copy, Data, Debug, New, PartialEq, PartialOrd)]
pub struct Matrix4x4 {
    /// The 16 elements of the matrix in column-major order.
    ///
    /// `get_elements` is public: `example/src/page/game_3d` reads the matrix
    /// from outside this crate. `get_mut` / `set` stay crate-internal.
    #[get_mut(pub(crate))]
    #[get(type(copy))]
    #[set(pub(crate))]
    pub elements: [f64; 16],
}

/// A 3D transform composed of position, rotation (as a quaternion), and scale.
#[derive(Clone, Copy, Data, Debug, New, PartialEq, PartialOrd)]
pub struct Transform3D {
    /// The position offset of the transform.
    #[get(type(copy))]
    #[get_mut(pub(crate))]
    pub position: Vector3D,
    /// The rotation as a quaternion.
    #[get(pub(crate), type(copy))]
    #[get_mut(pub(crate))]
    #[set(pub(crate))]
    pub(crate) rotation: Quaternion,
    /// The scale factors for each axis.
    #[get(pub(crate), type(copy))]
    #[get_mut(pub(crate))]
    #[set(pub(crate))]
    pub(crate) scale: Vector3D,
}

/// A 3D axis-aligned bounding box defined by its minimum and maximum corners.
#[derive(Clone, Copy, Data, Debug, Default, New, PartialEq, PartialOrd)]
pub struct AABB3D {
    /// The minimum corner (smallest x, y, z).
    #[get(type(copy))]
    #[get_mut(pub(crate))]
    #[set(pub(crate))]
    pub min: Vector3D,
    /// The maximum corner (largest x, y, z).
    #[get(type(copy))]
    #[get_mut(pub(crate))]
    #[set(pub(crate))]
    pub max: Vector3D,
}

/// A 3D sphere defined by its center point and radius.
#[derive(Clone, Copy, Data, Debug, Default, New, PartialEq, PartialOrd)]
pub struct Sphere {
    /// The center point of the sphere.
    #[get(type(copy))]
    #[get_mut(pub(crate))]
    #[set(pub(crate))]
    pub center: Vector3D,
    /// The radius of the sphere.
    #[get(type(copy))]
    #[get_mut(pub(crate))]
    #[set(pub(crate))]
    pub radius: f64,
}

/// A 3D plane defined by a normal vector and a distance from the origin.
#[derive(Clone, Copy, Data, Debug, Default, New, PartialEq, PartialOrd)]
pub struct Plane {
    /// The normal vector of the plane (should be normalized).
    #[get(type(copy), pub(crate))]
    #[get_mut(pub(crate))]
    #[set(pub(crate))]
    pub(crate) normal: Vector3D,
    /// The signed distance from the origin along the normal.
    #[get(type(copy), pub(crate))]
    #[get_mut(pub(crate))]
    #[set(pub(crate))]
    pub(crate) distance: f64,
}

/// A 3D ray defined by an origin point and a direction vector.
#[derive(Clone, Copy, Data, Debug, Default, New, PartialEq, PartialOrd)]
pub struct Ray3D {
    /// The origin point of the ray.
    #[get(type(copy))]
    #[get_mut(pub(crate))]
    #[set(pub(crate))]
    pub origin: Vector3D,
    /// The direction vector of the ray (should be normalized).
    #[get(type(copy))]
    #[get_mut(pub(crate))]
    pub direction: Vector3D,
}

/// A 2D ray defined by an origin point and a direction vector, used for
/// raycasting against 2D shapes (`Rect`, `Circle`).
#[derive(Clone, Copy, Data, Debug, Default, New, PartialEq, PartialOrd)]
pub struct Ray2D {
    /// The origin point of the ray.
    #[get(type(copy))]
    #[get_mut(pub(crate))]
    #[set(pub(crate))]
    pub origin: Vector2D,
    /// The direction vector of the ray (should be normalized).
    #[get(type(copy))]
    #[get_mut(pub(crate))]
    pub direction: Vector2D,
}