1use bevy_ecs::component::Component;
2use bevy_ecs::entity::Entity;
3use serde::{Deserialize, Serialize};
4use uuid::Uuid;
5
6#[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#[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 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#[derive(
102 Component, Clone, Debug, Default, Deserialize, PartialEq, Eq, Serialize,
103)]
104pub struct ObjectClasses {
105 pub names: Vec<String>,
107}
108
109impl ObjectClasses {
110 #[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 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 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 #[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 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 #[serde(default)]
176 pub shadows: bool,
177 #[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 pub inner_angle: f32,
190 pub outer_angle: f32,
192 #[serde(default)]
195 pub shadows: bool,
196 #[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#[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#[derive(
265 Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize,
266)]
267pub enum ToneMapper {
268 #[default]
270 Linear,
271 Reinhard,
273 Aces,
275}
276
277#[derive(Component, Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
281pub struct ToneMapping {
282 pub mapper: ToneMapper,
283 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#[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
305impl 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 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 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#[derive(
383 Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize,
384)]
385pub enum CullingMode {
386 #[default]
389 Auto,
390 Disabled,
392 Frustum,
394 FrustumAndOcclusion,
398}
399
400#[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#[derive(
422 Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize,
423)]
424pub enum ShadowQuality {
425 #[default]
426 Auto,
427 Low,
429 Medium,
431 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 pub render_scale: f32,
444 pub pixelated: bool,
447 pub upscale_sharpness: f32,
451 pub background_color: [f32; 4],
453 pub culling: CullingMode,
454 pub antialiasing: Antialiasing,
455 pub shadows: ShadowQuality,
456 pub hard_shadows: bool,
459 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#[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 pub linear: [bool; 3],
501 pub angular: [bool; 3],
503}
504
505impl AxisLock {
506 pub const PLANE_XY: Self = Self {
508 linear: [false, false, true],
509 angular: [true, true, false],
510 };
511
512 #[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 pub kill_y: Option<f32>,
531 pub substeps: u32,
535 pub gpu_locks: AxisLock,
539}
540
541#[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#[derive(
566 Clone, Copy, Debug, Default, Deserialize, PartialEq, Eq, Serialize,
567)]
568pub enum SimulationClass {
569 None,
571 Static,
573 #[default]
575 #[serde(alias = "Gameplay")]
576 Cpu,
577 #[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#[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#[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 ConvexMesh,
691 TriangleMesh,
694 Heightfield,
697 Polygon,
700 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 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}