use bevy_ecs::component::Component;
use bevy_ecs::entity::Entity;
use serde::{Deserialize, Serialize};
use uuid::Uuid;
#[derive(Component, Clone, Copy, Debug, PartialEq, Eq, Hash)]
pub struct SceneId(pub Uuid);
impl SceneId {
#[must_use]
pub fn new() -> Self {
Self(Uuid::new_v4())
}
}
impl Default for SceneId {
fn default() -> Self {
Self::new()
}
}
#[derive(Component, Clone, Copy, Debug, PartialEq)]
pub struct GlobalTransform {
pub matrix: [[f32; 4]; 4],
}
impl Default for GlobalTransform {
fn default() -> Self {
Self {
matrix: nalgebra::Matrix4::<f32>::identity().into(),
}
}
}
#[derive(Component, Clone, Copy, Debug, PartialEq, Eq)]
pub struct Parent(pub Entity);
#[derive(Component, Clone, Debug, Default, PartialEq, Eq)]
pub struct Children(pub Vec<Entity>);
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum Projection {
Perspective {
vertical_fov_radians: f32,
near: f32,
far: f32,
},
Orthographic {
vertical_size: f32,
near: f32,
far: f32,
},
}
impl Default for Projection {
fn default() -> Self {
Self::Perspective {
vertical_fov_radians: std::f32::consts::FRAC_PI_3,
near: 0.1,
far: 1_000.0,
}
}
}
#[derive(Component, Clone, Copy, Debug, Default, PartialEq)]
pub struct Camera {
pub projection: Projection,
pub active: bool,
pub priority: i32,
}
#[derive(Component, Clone, Debug, PartialEq, Eq)]
pub struct Name(pub String);
#[derive(
Component, Clone, Debug, Default, Deserialize, PartialEq, Eq, Serialize,
)]
pub struct ObjectClasses {
pub names: Vec<String>,
}
impl ObjectClasses {
#[must_use]
pub fn new(classes: impl IntoIterator<Item = impl Into<String>>) -> Self {
let mut result = Self::default();
for class in classes {
result.add(class);
}
result
}
pub fn add(&mut self, class: impl Into<String>) -> bool {
let class = class.into();
let class = class.trim();
if class.is_empty() || self.contains(class) {
return false;
}
self.names.push(class.to_owned());
true
}
pub fn remove(&mut self, class: &str) -> bool {
let old_len = self.names.len();
self.names.retain(|current| current != class);
self.names.len() != old_len
}
#[must_use]
pub fn contains(&self, class: &str) -> bool {
self.names.iter().any(|current| current == class)
}
}
#[derive(Component, Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
pub struct DirectionalLight {
pub color: [f32; 3],
pub illuminance: f32,
pub shadows: bool,
}
impl Default for DirectionalLight {
fn default() -> Self {
Self {
color: [1.0; 3],
illuminance: 100_000.0,
shadows: true,
}
}
}
#[derive(Component, Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
pub struct PointLight {
pub color: [f32; 3],
pub intensity: f32,
pub range: f32,
}
#[derive(Component, Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
pub struct SpotLight {
pub color: [f32; 3],
pub intensity: f32,
pub range: f32,
pub inner_angle: f32,
pub outer_angle: f32,
}
impl Default for SpotLight {
fn default() -> Self {
Self {
color: [1.0; 3],
intensity: 1_000.0,
range: 10.0,
inner_angle: 20.0_f32.to_radians(),
outer_angle: 35.0_f32.to_radians(),
}
}
}
impl Default for PointLight {
fn default() -> Self {
Self {
color: [1.0; 3],
intensity: 1_000.0,
range: 10.0,
}
}
}
#[derive(Component, Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
pub struct AmbientLight {
pub color: [f32; 3],
pub intensity: f32,
}
impl Default for AmbientLight {
fn default() -> Self {
Self {
color: [1.0; 3],
intensity: 0.1,
}
}
}
#[derive(Component, Clone, Copy, Debug, PartialEq, Eq)]
pub struct Visibility {
pub visible: bool,
}
impl Default for Visibility {
fn default() -> Self {
Self { visible: true }
}
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub enum QualityProfile {
Auto,
Eco,
#[default]
Balanced,
High,
}
#[derive(bevy_ecs::prelude::Resource, Clone, Debug, PartialEq)]
pub struct RenderSettings {
pub quality: QualityProfile,
pub vsync: bool,
pub limit_fps: bool,
pub max_fps: u32,
pub render_scale: f32,
pub background_color: [f32; 4],
}
impl Default for RenderSettings {
fn default() -> Self {
Self {
quality: QualityProfile::Auto,
vsync: false,
limit_fps: false,
max_fps: 120,
render_scale: 1.0,
background_color: [0.025, 0.04, 0.07, 1.0],
}
}
}
#[derive(bevy_ecs::prelude::Resource, Clone, Debug, PartialEq)]
pub struct PhysicsSettings {
pub gravity: [f32; 3],
pub enabled: bool,
}
#[derive(
bevy_ecs::prelude::Resource, Clone, Copy, Debug, Default, PartialEq, Eq,
)]
pub struct PhysicsBackendStatus {
pub gameplay_available: bool,
pub gpu_dynamic_available: bool,
}
impl Default for PhysicsSettings {
fn default() -> Self {
Self {
gravity: [0.0, -9.81, 0.0],
enabled: true,
}
}
}
#[derive(Component, Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct GpuEffectBody;
#[derive(
Clone, Copy, Debug, Default, Deserialize, PartialEq, Eq, Serialize,
)]
pub enum SimulationClass {
None,
Static,
#[default]
Gameplay,
GpuDynamic,
}
#[derive(
Clone, Copy, Debug, Default, Deserialize, PartialEq, Eq, Serialize,
)]
pub enum PhysicsSolver {
#[default]
Full,
Simplified,
NoCollision,
Space,
Custom,
}
#[derive(Component, Clone, Debug, Deserialize, PartialEq, Eq, Serialize)]
pub struct PhysicsBody {
pub simulation: SimulationClass,
pub solver: PhysicsSolver,
pub custom_shader: Option<String>,
}
impl Default for PhysicsBody {
fn default() -> Self {
Self {
simulation: SimulationClass::Gameplay,
solver: PhysicsSolver::Full,
custom_shader: None,
}
}
}
impl PhysicsBody {
#[must_use]
pub fn participates_in_dynamic_simulation(&self) -> bool {
matches!(
self.simulation,
SimulationClass::Gameplay | SimulationClass::GpuDynamic
)
}
#[must_use]
pub fn uses_gpu(&self) -> bool {
self.simulation == SimulationClass::GpuDynamic
}
}
#[derive(
Component,
Clone,
Copy,
Debug,
Default,
Deserialize,
PartialEq,
Eq,
Serialize,
)]
pub enum RigidBodyKind {
Fixed,
#[default]
Dynamic,
Kinematic,
}
#[derive(Component, Clone, Copy, Debug, Deserialize, PartialEq, Serialize)]
pub struct RigidBody {
pub kind: RigidBodyKind,
pub mass: f32,
pub linear_velocity: [f32; 3],
pub angular_velocity: [f32; 3],
pub gravity_scale: f32,
}
impl Default for RigidBody {
fn default() -> Self {
Self {
kind: RigidBodyKind::Dynamic,
mass: 1.0,
linear_velocity: [0.0; 3],
angular_velocity: [0.0; 3],
gravity_scale: 1.0,
}
}
}
#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Serialize)]
pub enum ColliderShape {
Box { half_extents: [f32; 3] },
Sphere { radius: f32 },
Capsule { half_height: f32, radius: f32 },
}
#[derive(Component, Clone, Copy, Debug, Deserialize, PartialEq, Serialize)]
pub struct Collider {
pub shape: ColliderShape,
pub friction: f32,
pub restitution: f32,
pub sensor: bool,
}
impl Default for Collider {
fn default() -> Self {
Self {
shape: ColliderShape::Box {
half_extents: [0.5; 3],
},
friction: 0.5,
restitution: 0.0,
sensor: false,
}
}
}
#[derive(
Component, Clone, Copy, Debug, Deserialize, PartialEq, Eq, Serialize,
)]
pub struct CollisionLayers {
pub memberships: u32,
pub filters: u32,
}
impl Default for CollisionLayers {
fn default() -> Self {
Self {
memberships: u32::MAX,
filters: u32::MAX,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
use bevy_ecs::{component::Component, resource::Resource};
fn assert_component<T: Component>() {}
fn assert_resource<T: Resource>() {}
#[test]
fn canonical_types_implement_bevy_ecs_traits() {
assert_component::<SceneId>();
assert_component::<GlobalTransform>();
assert_component::<Parent>();
assert_component::<Children>();
assert_component::<Camera>();
assert_component::<Name>();
assert_component::<ObjectClasses>();
assert_component::<DirectionalLight>();
assert_component::<PointLight>();
assert_component::<SpotLight>();
assert_component::<AmbientLight>();
assert_component::<Visibility>();
assert_component::<GpuEffectBody>();
assert_component::<PhysicsBody>();
assert_component::<RigidBodyKind>();
assert_component::<RigidBody>();
assert_component::<Collider>();
assert_component::<CollisionLayers>();
assert_resource::<RenderSettings>();
assert_resource::<PhysicsSettings>();
assert_resource::<PhysicsBackendStatus>();
}
#[test]
fn defaults_are_ready_for_a_basic_scene() {
let identity: [[f32; 4]; 4] =
nalgebra::Matrix4::<f32>::identity().into();
assert_eq!(GlobalTransform::default().matrix, identity);
assert!(Visibility::default().visible);
assert_eq!(RigidBody::default().mass, 1.0);
assert_eq!(PhysicsSettings::default().gravity, [0.0, -9.81, 0.0]);
assert_eq!(CollisionLayers::default().memberships, u32::MAX);
assert_eq!(RenderSettings::default().quality, QualityProfile::Auto);
}
#[test]
fn object_classes_clean_and_edit_names() {
let mut classes =
ObjectClasses::new([" gravity ", "", "gravity", "enemy"]);
assert_eq!(classes.names, ["gravity", "enemy"]);
assert!(classes.contains("gravity"));
assert!(!classes.add("enemy"));
assert!(classes.remove("enemy"));
assert!(!classes.contains("enemy"));
}
#[test]
fn physics_body_helpers_follow_simulation_class() {
let mut body = PhysicsBody::default();
assert!(body.participates_in_dynamic_simulation());
assert!(!body.uses_gpu());
body.simulation = SimulationClass::GpuDynamic;
assert!(body.participates_in_dynamic_simulation());
assert!(body.uses_gpu());
body.simulation = SimulationClass::Static;
assert!(!body.participates_in_dynamic_simulation());
assert!(!body.uses_gpu());
}
}