Skip to main content

rusting_core/
components.rs

1use bevy_ecs::component::Component;
2use bevy_ecs::entity::Entity;
3use serde::{Deserialize, Serialize};
4use uuid::Uuid;
5
6/// Persistent scene identity. Unlike a Bevy [`Entity`], this survives saving,
7/// loading, and a new process.
8#[derive(Component, Clone, Copy, Debug, PartialEq, Eq, Hash)]
9pub struct SceneId(pub Uuid);
10
11impl SceneId {
12    #[must_use]
13    pub fn new() -> Self {
14        Self(Uuid::new_v4())
15    }
16}
17
18impl Default for SceneId {
19    fn default() -> Self {
20        Self::new()
21    }
22}
23
24/// World-space transform derived from [`crate::transform::Transform`] and hierarchy.
25#[derive(Component, Clone, Copy, Debug, PartialEq)]
26pub struct GlobalTransform {
27    pub matrix: [[f32; 4]; 4],
28}
29
30impl Default for GlobalTransform {
31    fn default() -> Self {
32        Self {
33            matrix: nalgebra::Matrix4::<f32>::identity().into(),
34        }
35    }
36}
37
38#[derive(Component, Clone, Copy, Debug, PartialEq, Eq)]
39pub struct Parent(pub Entity);
40
41#[derive(Component, Clone, Debug, Default, PartialEq, Eq)]
42pub struct Children(pub Vec<Entity>);
43
44#[derive(Clone, Copy, Debug, PartialEq)]
45pub enum Projection {
46    Perspective {
47        vertical_fov_radians: f32,
48        near: f32,
49        far: f32,
50    },
51    Orthographic {
52        vertical_size: f32,
53        near: f32,
54        far: f32,
55    },
56}
57
58impl Default for Projection {
59    fn default() -> Self {
60        Self::Perspective {
61            vertical_fov_radians: std::f32::consts::FRAC_PI_3,
62            near: 0.1,
63            far: 1_000.0,
64        }
65    }
66}
67
68#[derive(Component, Clone, Copy, Debug, Default, PartialEq)]
69pub struct Camera {
70    pub projection: Projection,
71    pub active: bool,
72    pub priority: i32,
73    /// Part of the window this camera draws into, as fractions
74    /// `[x, y, width, height]` from the top-left corner. `None` fills the
75    /// window.
76    pub viewport: Option<[f32; 4]>,
77}
78
79#[derive(Component, Clone, Debug, PartialEq, Eq)]
80pub struct Name(pub String);
81
82impl Name {
83    #[must_use]
84    pub fn as_str(&self) -> &str {
85        &self.0
86    }
87}
88
89impl std::ops::Deref for Name {
90    type Target = str;
91
92    fn deref(&self) -> &str {
93        &self.0
94    }
95}
96
97/// Reusable classes assigned to one scene object.
98///
99/// Names identify one object. Classes select any number of objects, and one
100/// object can belong to several classes at the same time.
101#[derive(
102    Component, Clone, Debug, Default, Deserialize, PartialEq, Eq, Serialize,
103)]
104pub struct ObjectClasses {
105    /// Class names such as `gravity`, `enemy`, or `falling_cubes`.
106    pub names: Vec<String>,
107}
108
109impl ObjectClasses {
110    /// Creates a clean class list without empty or repeated names.
111    #[must_use]
112    pub fn new(classes: impl IntoIterator<Item = impl Into<String>>) -> Self {
113        let mut result = Self::default();
114        for class in classes {
115            result.add(class);
116        }
117        result
118    }
119
120    /// Adds a class if this object does not already have it.
121    pub fn add(&mut self, class: impl Into<String>) -> bool {
122        let class = class.into();
123        let class = class.trim();
124        if class.is_empty() || self.contains(class) {
125            return false;
126        }
127        self.names.push(class.to_owned());
128        true
129    }
130
131    /// Removes a class from this object.
132    pub fn remove(&mut self, class: &str) -> bool {
133        let old_len = self.names.len();
134        self.names.retain(|current| current != class);
135        self.names.len() != old_len
136    }
137
138    /// Returns true when this object belongs to the requested class.
139    #[must_use]
140    pub fn contains(&self, class: &str) -> bool {
141        self.names.iter().any(|current| current == class)
142    }
143}
144
145#[derive(Component, Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
146pub struct DirectionalLight {
147    pub color: [f32; 3],
148    pub illuminance: f32,
149    pub shadows: bool,
150}
151
152impl DirectionalLight {
153    /// Illuminance that lights a white surface facing the light at 1 before
154    /// exposure, like a point light of 1000 up close or ambient intensity 1.
155    pub const LUX_PER_UNIT: f32 = 100_000.0;
156}
157
158impl Default for DirectionalLight {
159    fn default() -> Self {
160        Self {
161            color: [1.0; 3],
162            illuminance: 100_000.0,
163            shadows: true,
164        }
165    }
166}
167
168#[derive(Component, Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
169pub struct PointLight {
170    pub color: [f32; 3],
171    pub intensity: f32,
172    pub range: f32,
173    /// Casts shadows through six cube faces of the shadow map. Only when
174    /// no directional or spot light in the frame casts shadows.
175    #[serde(default)]
176    pub shadows: bool,
177    /// Radius in metres of the glowing sphere. A larger source gives
178    /// wider, softer highlights on shiny surfaces; 0 is a point.
179    #[serde(default)]
180    pub radius: f32,
181}
182
183#[derive(Component, Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
184pub struct SpotLight {
185    pub color: [f32; 3],
186    pub intensity: f32,
187    pub range: f32,
188    /// Fully illuminated cone angle in radians.
189    pub inner_angle: f32,
190    /// Outer cone angle in radians where illumination reaches zero.
191    pub outer_angle: f32,
192    /// Casts shadows through one shadow map. A frame has one shadowed
193    /// light: a directional light with shadows wins over spot lights.
194    #[serde(default)]
195    pub shadows: bool,
196    /// Radius in metres of the glowing sphere. A larger source gives
197    /// wider, softer highlights on shiny surfaces; 0 is a point.
198    #[serde(default)]
199    pub radius: f32,
200}
201
202impl Default for SpotLight {
203    fn default() -> Self {
204        Self {
205            color: [1.0; 3],
206            intensity: 1_000.0,
207            range: 10.0,
208            inner_angle: 20.0_f32.to_radians(),
209            outer_angle: 35.0_f32.to_radians(),
210            shadows: false,
211            radius: 0.0,
212        }
213    }
214}
215
216impl Default for PointLight {
217    fn default() -> Self {
218        Self {
219            color: [1.0; 3],
220            intensity: 1_000.0,
221            range: 10.0,
222            shadows: false,
223            radius: 0.0,
224        }
225    }
226}
227
228#[derive(Component, Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
229pub struct AmbientLight {
230    pub color: [f32; 3],
231    pub intensity: f32,
232}
233
234impl Default for AmbientLight {
235    fn default() -> Self {
236        Self {
237            color: [1.0; 3],
238            intensity: 0.1,
239        }
240    }
241}
242
243/// Hemisphere environment light: surfaces facing +Y see `sky_color`,
244/// surfaces facing -Y see `ground_color`, and the two blend in between.
245/// Adds to any [`AmbientLight`].
246#[derive(Component, Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
247pub struct SkyLight {
248    pub sky_color: [f32; 3],
249    pub ground_color: [f32; 3],
250    pub intensity: f32,
251}
252
253impl Default for SkyLight {
254    fn default() -> Self {
255        Self {
256            sky_color: [0.6, 0.75, 1.0],
257            ground_color: [0.3, 0.25, 0.2],
258            intensity: 0.3,
259        }
260    }
261}
262
263/// Curve that maps HDR scene color into the displayable 0..1 range.
264#[derive(
265    Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize,
266)]
267pub enum ToneMapper {
268    /// Clips at 1, like Godot's default. Leaves values below 1 unchanged.
269    #[default]
270    Linear,
271    /// `c / (1 + c)`: never clips, compresses highlights softly.
272    Reinhard,
273    /// Filmic ACES curve (Narkowicz fit): more contrast, saturated mids.
274    Aces,
275}
276
277/// Exposure and tone mapping applied to the lit scene before display, like
278/// the tonemap settings of Godot's `Environment`. The first one found in the
279/// world is used; without one the scene uses `Linear` at exposure 1.
280#[derive(Component, Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
281pub struct ToneMapping {
282    pub mapper: ToneMapper,
283    /// Scene color is multiplied by this before the curve.
284    pub exposure: f32,
285}
286
287impl Default for ToneMapping {
288    fn default() -> Self {
289        Self {
290            mapper: ToneMapper::Linear,
291            exposure: 1.0,
292        }
293    }
294}
295
296/// Render-only bounds used for visibility, separate from the physics
297/// `Collider`. Stored in the entity's local space; render extraction
298/// transforms them into world space every time the entity is extracted.
299#[derive(Component, Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
300pub enum RenderBounds {
301    Sphere { center: [f32; 3], radius: f32 },
302    Aabb { min: [f32; 3], max: [f32; 3] },
303}
304
305/// The built-in unit cube's box.
306impl Default for RenderBounds {
307    fn default() -> Self {
308        RenderBounds::Aabb {
309            min: [-0.5; 3],
310            max: [0.5; 3],
311        }
312    }
313}
314
315impl RenderBounds {
316    /// Returns the bounds of this volume after `matrix` (a column-major
317    /// `GlobalTransform` matrix). A sphere stays a sphere whose radius grows
318    /// by the largest axis scale; a box becomes the axis-aligned box around
319    /// its transformed corners, so both stay conservative under rotation and
320    /// non-uniform scale.
321    pub fn transformed(&self, matrix: &[[f32; 4]; 4]) -> RenderBounds {
322        let matrix = nalgebra::Matrix4::from(*matrix);
323        let linear = matrix.fixed_view::<3, 3>(0, 0);
324        let translation = matrix.fixed_view::<3, 1>(0, 3);
325        match *self {
326            RenderBounds::Sphere { center, radius } => {
327                let scale = (0..3)
328                    .map(|axis| linear.column(axis).norm())
329                    .fold(0.0_f32, f32::max);
330                let center =
331                    linear * nalgebra::Vector3::from(center) + translation;
332                RenderBounds::Sphere {
333                    center: center.into(),
334                    radius: radius * scale,
335                }
336            }
337            RenderBounds::Aabb { min, max } => {
338                // Arvo's method: each output axis takes the smaller and the
339                // larger product per input axis.
340                let mut world_min: [f32; 3] = translation.into();
341                let mut world_max = world_min;
342                for row in 0..3 {
343                    for column in 0..3 {
344                        let a = linear[(row, column)] * min[column];
345                        let b = linear[(row, column)] * max[column];
346                        world_min[row] += a.min(b);
347                        world_max[row] += a.max(b);
348                    }
349                }
350                RenderBounds::Aabb {
351                    min: world_min,
352                    max: world_max,
353                }
354            }
355        }
356    }
357}
358
359#[derive(Component, Clone, Copy, Debug, PartialEq, Eq)]
360pub struct Visibility {
361    pub visible: bool,
362}
363
364impl Default for Visibility {
365    fn default() -> Self {
366        Self { visible: true }
367    }
368}
369
370#[derive(
371    Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize,
372)]
373pub enum QualityProfile {
374    Auto,
375    Eco,
376    #[default]
377    Balanced,
378    High,
379}
380
381/// How the renderer skips objects outside the view.
382#[derive(
383    Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize,
384)]
385pub enum CullingMode {
386    /// The renderer picks: small scenes draw everything, the rest cull by
387    /// frustum on the CPU or GPU.
388    #[default]
389    Auto,
390    /// Draw every visible object.
391    Disabled,
392    /// Skip objects whose world bounds lie outside the camera frustum.
393    Frustum,
394    /// Frustum culling plus GPU occlusion culling against a depth pyramid
395    /// of the objects visible last frame. Needs the GPU culling path, so it
396    /// always runs there, whatever the scene size.
397    FrustumAndOcclusion,
398}
399
400/// Anti-aliasing. `Auto` follows the quality profile: off on `Eco`, the
401/// most multisamples the device offers (up to 4) otherwise. A count the
402/// device lacks falls back to the next lower one. `Fxaa` renders one sample
403/// and smooths edges found in the final image instead: cheaper than MSAA,
404/// also smooths edges inside textures and alpha-cut leaves, a little softer.
405/// `Taa` renders one sample from a slightly different spot each frame and
406/// blends the frames: the smoothest edges, with some blur on fast motion.
407#[derive(
408    Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize,
409)]
410pub enum Antialiasing {
411    #[default]
412    Auto,
413    Off,
414    Msaa2,
415    Msaa4,
416    Fxaa,
417    Taa,
418}
419
420/// Shadow map resolution and reach. `Auto` follows the quality profile.
421#[derive(
422    Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize,
423)]
424pub enum ShadowQuality {
425    #[default]
426    Auto,
427    /// 1024 px map, 30 m reach.
428    Low,
429    /// 2048 px map, 50 m reach.
430    Medium,
431    /// 4096 px map, 80 m reach.
432    High,
433}
434
435#[derive(bevy_ecs::prelude::Resource, Clone, Debug, PartialEq)]
436pub struct RenderSettings {
437    pub quality: QualityProfile,
438    pub vsync: bool,
439    pub limit_fps: bool,
440    pub max_fps: u32,
441    /// Fraction of the target size the 3D scene renders at, 0.25 to 2.0.
442    /// The frame is stretched over the target; UI stays at full resolution.
443    pub render_scale: f32,
444    /// Stretch a scaled frame with nearest-neighbour filtering, so a low
445    /// `render_scale` shows square pixels instead of blur.
446    pub pixelated: bool,
447    /// Above 0, a `render_scale` below 1 is stretched with an
448    /// edge-preserving filter and contrast-adaptive sharpening of this
449    /// strength (up to 1), like FSR 1, instead of a plain linear stretch.
450    pub upscale_sharpness: f32,
451    /// RGBA color used to clear the game render target before drawing.
452    pub background_color: [f32; 4],
453    pub culling: CullingMode,
454    pub antialiasing: Antialiasing,
455    pub shadows: ShadowQuality,
456    /// One shadow-map tap per pixel instead of 3x3 filtering: crisp,
457    /// stair-stepped shadow edges for a low-poly look.
458    pub hard_shadows: bool,
459    /// Screen-space reflections and refraction of the opaque scene. Off
460    /// skips the scene copy, mip chain and depth pyramid.
461    pub reflections: bool,
462}
463
464impl Default for RenderSettings {
465    fn default() -> Self {
466        Self {
467            quality: QualityProfile::Auto,
468            vsync: false,
469            limit_fps: false,
470            max_fps: 120,
471            render_scale: 1.0,
472            pixelated: false,
473            upscale_sharpness: 0.0,
474            background_color: [0.025, 0.04, 0.07, 1.0],
475            culling: CullingMode::Auto,
476            antialiasing: Antialiasing::Auto,
477            shadows: ShadowQuality::Auto,
478            hard_shadows: false,
479            reflections: true,
480        }
481    }
482}
483
484/// Freezes a dynamic body's motion along world axes, like Godot's axis
485/// locks. A 2D body in the XY plane locks linear z and angular x and y.
486#[derive(
487    Component,
488    Clone,
489    Copy,
490    Debug,
491    Default,
492    PartialEq,
493    Eq,
494    Serialize,
495    Deserialize,
496)]
497#[serde(default)]
498pub struct AxisLock {
499    /// No movement along world x, y, z.
500    pub linear: [bool; 3],
501    /// No turning around world x, y, z.
502    pub angular: [bool; 3],
503}
504
505impl AxisLock {
506    /// The XY-plane lock of a 2D body.
507    pub const PLANE_XY: Self = Self {
508        linear: [false, false, true],
509        angular: [true, true, false],
510    };
511
512    /// Bits 0 to 2 lock linear x, y, z and bits 3 to 5 angular x, y, z.
513    #[must_use]
514    pub fn mask(&self) -> u32 {
515        self.linear
516            .iter()
517            .chain(&self.angular)
518            .enumerate()
519            .map(|(bit, &locked)| u32::from(locked) << bit)
520            .sum()
521    }
522}
523
524#[derive(bevy_ecs::prelude::Resource, Clone, Debug, PartialEq)]
525pub struct PhysicsSettings {
526    pub gravity: [f32; 3],
527    pub enabled: bool,
528    /// Loose dynamic CPU bodies below this height are despawned and send
529    /// `FellOut`; `None` keeps them falling.
530    pub kill_y: Option<f32>,
531    /// CPU solver substeps per fixed step. More substeps hold long joint
532    /// chains and heavy-on-light stacks tighter, at that many times the
533    /// solver cost.
534    pub substeps: u32,
535    /// Axis locks every GPU body shares; [`AxisLock::PLANE_XY`] keeps a 2D
536    /// game's GPU bodies in its plane. CPU bodies take their own
537    /// `rusting.axis_lock` instead.
538    pub gpu_locks: AxisLock,
539}
540
541/// Reports which physics backends are connected to the ECS scene runner.
542/// The compatibility engine facade has its own legacy GPU path and does not
543/// use this resource.
544#[derive(
545    bevy_ecs::prelude::Resource, Clone, Copy, Debug, Default, PartialEq, Eq,
546)]
547pub struct PhysicsBackendStatus {
548    pub gameplay_available: bool,
549    pub gpu_dynamic_available: bool,
550}
551
552impl Default for PhysicsSettings {
553    fn default() -> Self {
554        Self {
555            gravity: [0.0, -9.81, 0.0],
556            enabled: true,
557            kill_y: None,
558            substeps: 1,
559            gpu_locks: AxisLock::default(),
560        }
561    }
562}
563
564/// Says where the newest runtime physics state of an entity lives.
565#[derive(
566    Clone, Copy, Debug, Default, Deserialize, PartialEq, Eq, Serialize,
567)]
568pub enum SimulationClass {
569    /// No simulation; the body is ignored by every solver.
570    None,
571    /// Never moves; a collider for both the CPU and the GPU solvers.
572    Static,
573    /// Simulated on the CPU, so gameplay reads current state directly.
574    #[default]
575    #[serde(alias = "Gameplay")]
576    Cpu,
577    /// Simulated on the GPU; the CPU sees events and selected readbacks.
578    #[serde(alias = "GpuDynamic")]
579    Gpu,
580}
581
582#[allow(non_upper_case_globals)]
583impl SimulationClass {
584    #[deprecated(note = "renamed to `SimulationClass::Cpu`")]
585    pub const Gameplay: Self = Self::Cpu;
586    #[deprecated(note = "renamed to `SimulationClass::Gpu`")]
587    pub const GpuDynamic: Self = Self::Gpu;
588}
589
590/// Built-in GPU compute profile, or a project-provided compute shader.
591#[derive(
592    Clone, Copy, Debug, Default, Deserialize, PartialEq, Eq, Serialize,
593)]
594pub enum PhysicsSolver {
595    #[default]
596    Full,
597    Simplified,
598    NoCollision,
599    Space,
600    Custom,
601}
602
603/// Semantic physics configuration authored by the editor.
604///
605/// Static and disabled bodies are deliberately excluded from dynamic compute
606/// dispatches. Custom shader paths are project-relative and validated by the
607/// editor before they are saved.
608#[derive(Component, Clone, Debug, Deserialize, PartialEq, Eq, Serialize)]
609pub struct PhysicsBody {
610    pub simulation: SimulationClass,
611    pub solver: PhysicsSolver,
612    pub custom_shader: Option<String>,
613}
614
615impl Default for PhysicsBody {
616    fn default() -> Self {
617        Self {
618            simulation: SimulationClass::Cpu,
619            solver: PhysicsSolver::Full,
620            custom_shader: None,
621        }
622    }
623}
624
625impl PhysicsBody {
626    #[must_use]
627    pub fn participates_in_dynamic_simulation(&self) -> bool {
628        matches!(self.simulation, SimulationClass::Cpu | SimulationClass::Gpu)
629    }
630
631    #[must_use]
632    pub fn uses_gpu(&self) -> bool {
633        self.simulation == SimulationClass::Gpu
634    }
635}
636
637#[derive(
638    Component,
639    Clone,
640    Copy,
641    Debug,
642    Default,
643    Deserialize,
644    PartialEq,
645    Eq,
646    Serialize,
647)]
648pub enum RigidBodyKind {
649    Fixed,
650    #[default]
651    Dynamic,
652    Kinematic,
653}
654
655#[derive(Component, Clone, Copy, Debug, Deserialize, PartialEq, Serialize)]
656pub struct RigidBody {
657    pub kind: RigidBodyKind,
658    pub mass: f32,
659    pub linear_velocity: [f32; 3],
660    pub angular_velocity: [f32; 3],
661    pub gravity_scale: f32,
662}
663
664impl Default for RigidBody {
665    fn default() -> Self {
666        Self {
667            kind: RigidBodyKind::Dynamic,
668            mass: 1.0,
669            linear_velocity: [0.0; 3],
670            angular_velocity: [0.0; 3],
671            gravity_scale: 1.0,
672        }
673    }
674}
675
676#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Serialize)]
677pub enum ColliderShape {
678    Box {
679        half_extents: [f32; 3],
680    },
681    Sphere {
682        radius: f32,
683    },
684    Capsule {
685        half_height: f32,
686        radius: f32,
687    },
688    /// The convex hull of the entity's `MeshRenderer` mesh, scaled by its
689    /// transform. Dynamic bodies may use it.
690    ConvexMesh,
691    /// The triangles of the entity's `MeshRenderer` mesh, scaled by its
692    /// transform. Static only: a body with it never moves.
693    TriangleMesh,
694    /// The entity's `rusting.heightfield` height grid, scaled by its
695    /// transform. Static only, like `TriangleMesh`.
696    Heightfield,
697    /// The convex hull of the entity's `rusting.polygon` outline, extruded
698    /// along Z. Dynamic bodies may use it; the 2D convex polygon.
699    Polygon,
700    /// The segments of the entity's `rusting.polygon` outline as thin
701    /// walls, extruded along Z. Static only; the 2D segment chain.
702    Chain,
703}
704
705#[derive(Component, Clone, Copy, Debug, Deserialize, PartialEq, Serialize)]
706pub struct Collider {
707    pub shape: ColliderShape,
708    pub friction: f32,
709    pub restitution: f32,
710    pub sensor: bool,
711}
712
713impl Default for Collider {
714    fn default() -> Self {
715        Self {
716            shape: ColliderShape::Box {
717                half_extents: [0.5; 3],
718            },
719            friction: 0.5,
720            restitution: 0.0,
721            sensor: false,
722        }
723    }
724}
725
726#[derive(
727    Component, Clone, Copy, Debug, Deserialize, PartialEq, Eq, Serialize,
728)]
729pub struct CollisionLayers {
730    pub memberships: u32,
731    pub filters: u32,
732}
733
734impl Default for CollisionLayers {
735    fn default() -> Self {
736        Self {
737            memberships: u32::MAX,
738            filters: u32::MAX,
739        }
740    }
741}
742
743#[cfg(test)]
744mod tests {
745    use super::*;
746    use bevy_ecs::{component::Component, resource::Resource};
747
748    fn assert_component<T: Component>() {}
749    fn assert_resource<T: Resource>() {}
750
751    #[test]
752    fn canonical_types_implement_bevy_ecs_traits() {
753        assert_component::<SceneId>();
754        assert_component::<GlobalTransform>();
755        assert_component::<Parent>();
756        assert_component::<Children>();
757        assert_component::<Camera>();
758        assert_component::<Name>();
759        assert_component::<ObjectClasses>();
760        assert_component::<DirectionalLight>();
761        assert_component::<PointLight>();
762        assert_component::<SpotLight>();
763        assert_component::<AmbientLight>();
764        assert_component::<SkyLight>();
765        assert_component::<ToneMapping>();
766        assert_component::<RenderBounds>();
767        assert_component::<Visibility>();
768        assert_component::<PhysicsBody>();
769        assert_component::<RigidBodyKind>();
770        assert_component::<RigidBody>();
771        assert_component::<Collider>();
772        assert_component::<CollisionLayers>();
773
774        assert_resource::<RenderSettings>();
775        assert_resource::<PhysicsSettings>();
776        assert_resource::<PhysicsBackendStatus>();
777    }
778
779    #[test]
780    fn defaults_are_ready_for_a_basic_scene() {
781        let identity: [[f32; 4]; 4] =
782            nalgebra::Matrix4::<f32>::identity().into();
783        assert_eq!(GlobalTransform::default().matrix, identity);
784        assert!(Visibility::default().visible);
785        assert_eq!(RigidBody::default().mass, 1.0);
786        assert_eq!(PhysicsSettings::default().gravity, [0.0, -9.81, 0.0]);
787        assert_eq!(CollisionLayers::default().memberships, u32::MAX);
788        assert_eq!(RenderSettings::default().quality, QualityProfile::Auto);
789    }
790
791    #[test]
792    fn render_bounds_stay_conservative_under_transforms() {
793        use nalgebra::{Matrix4, Rotation3, Vector3};
794        let matrix: [[f32; 4]; 4] =
795            (Matrix4::new_translation(&Vector3::new(10.0, 0.0, 0.0))
796                * Rotation3::from_axis_angle(
797                    &Vector3::z_axis(),
798                    std::f32::consts::FRAC_PI_4,
799                )
800                .to_homogeneous()
801                * Matrix4::new_nonuniform_scaling(&Vector3::new(
802                    2.0, 1.0, 3.0,
803                )))
804            .into();
805        let RenderBounds::Sphere { center, radius } = (RenderBounds::Sphere {
806            center: [1.0, 0.0, 0.0],
807            radius: 1.0,
808        })
809        .transformed(&matrix) else {
810            panic!("a sphere stays a sphere");
811        };
812        let half = std::f32::consts::FRAC_1_SQRT_2;
813        let expected = [10.0 + 2.0 * half, 2.0 * half, 0.0];
814        for (value, expected) in center.iter().zip(expected) {
815            assert!((value - expected).abs() < 1e-5, "{center:?}");
816        }
817        assert!((radius - 3.0).abs() < 1e-5, "largest axis scale");
818
819        let RenderBounds::Aabb { min, max } = (RenderBounds::Aabb {
820            min: [-1.0; 3],
821            max: [1.0; 3],
822        })
823        .transformed(&matrix) else {
824            panic!("a box stays a box");
825        };
826        // The 2x1 face rotated 45 degrees spans (2 + 1) / sqrt(2) on x and
827        // y; z only scales.
828        let reach = 3.0 * half;
829        let expected_min = [10.0 - reach, -reach, -3.0];
830        let expected_max = [10.0 + reach, reach, 3.0];
831        for axis in 0..3 {
832            assert!((min[axis] - expected_min[axis]).abs() < 1e-5, "{min:?}");
833            assert!((max[axis] - expected_max[axis]).abs() < 1e-5, "{max:?}");
834        }
835    }
836
837    #[test]
838    fn object_classes_clean_and_edit_names() {
839        let mut classes =
840            ObjectClasses::new([" gravity ", "", "gravity", "enemy"]);
841        assert_eq!(classes.names, ["gravity", "enemy"]);
842        assert!(classes.contains("gravity"));
843        assert!(!classes.add("enemy"));
844        assert!(classes.remove("enemy"));
845        assert!(!classes.contains("enemy"));
846    }
847
848    #[test]
849    fn physics_body_helpers_follow_simulation_class() {
850        let mut body = PhysicsBody::default();
851        assert!(body.participates_in_dynamic_simulation());
852        assert!(!body.uses_gpu());
853
854        body.simulation = SimulationClass::Gpu;
855        assert!(body.participates_in_dynamic_simulation());
856        assert!(body.uses_gpu());
857
858        body.simulation = SimulationClass::Static;
859        assert!(!body.participates_in_dynamic_simulation());
860        assert!(!body.uses_gpu());
861    }
862}