dreamwell-engine 1.0.0

Dreamwell pure-logic engine library — transforms, hierarchy, canon pipeline, spatial math, hashing, tile rules, validation, waymark schema, material/lighting descriptors. No SpacetimeDB dependency.
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

use serde::{Deserialize, Serialize};

/// Force field kind — type of spatial force applied to particles.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum ForceFieldKind {
    Gravity,
    Drag,
    Damping,
    Directional,
    Radial,
    Attractor,
    Repulsor,
    Vortex,
    Orbital,
    Turbulence,
    CurlNoise,
    Wind,
    Buoyancy,
    CustomVectorField,
}

/// Force binding — references a force field by kind with strength and radius.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ForceBinding {
    pub kind: ForceFieldKind,
    pub strength: f32,
    pub radius: f32,
}

/// Force field descriptor — full definition of a spatial force field.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ForceFieldDescriptor {
    pub kind: ForceFieldKind,
    pub position: [f32; 3],
    pub direction: [f32; 3],
    pub strength: f32,
    pub radius: f32,
    pub falloff: f32,
    pub noise_frequency: f32,
    pub noise_amplitude: f32,
}

impl Default for ForceFieldDescriptor {
    fn default() -> Self {
        Self {
            kind: ForceFieldKind::Gravity,
            position: [0.0, 0.0, 0.0],
            direction: [0.0, -1.0, 0.0],
            strength: 9.81,
            radius: f32::MAX,
            falloff: 0.0,
            noise_frequency: 0.0,
            noise_amplitude: 0.0,
        }
    }
}

impl ForceFieldKind {
    pub const ALL: &[ForceFieldKind] = &[
        Self::Gravity,
        Self::Drag,
        Self::Damping,
        Self::Directional,
        Self::Radial,
        Self::Attractor,
        Self::Repulsor,
        Self::Vortex,
        Self::Orbital,
        Self::Turbulence,
        Self::CurlNoise,
        Self::Wind,
        Self::Buoyancy,
        Self::CustomVectorField,
    ];

    pub fn name(&self) -> &'static str {
        match self {
            Self::Gravity => "Gravity",
            Self::Drag => "Drag",
            Self::Damping => "Damping",
            Self::Directional => "Directional",
            Self::Radial => "Radial",
            Self::Attractor => "Attractor",
            Self::Repulsor => "Repulsor",
            Self::Vortex => "Vortex",
            Self::Orbital => "Orbital",
            Self::Turbulence => "Turbulence",
            Self::CurlNoise => "Curl Noise",
            Self::Wind => "Wind",
            Self::Buoyancy => "Buoyancy",
            Self::CustomVectorField => "Custom Vector Field",
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn force_field_kind_all() {
        assert_eq!(ForceFieldKind::ALL.len(), 14);
    }

    #[test]
    fn force_field_descriptor_default() {
        let f = ForceFieldDescriptor::default();
        assert_eq!(f.kind, ForceFieldKind::Gravity);
        assert_eq!(f.direction, [0.0, -1.0, 0.0]);
    }

    #[test]
    fn force_field_serde() {
        let f = ForceFieldDescriptor {
            kind: ForceFieldKind::Vortex,
            position: [1.0, 2.0, 3.0],
            direction: [0.0, 1.0, 0.0],
            strength: 5.0,
            radius: 10.0,
            falloff: 1.0,
            noise_frequency: 0.0,
            noise_amplitude: 0.0,
        };
        let json = serde_json::to_string(&f).unwrap();
        let restored: ForceFieldDescriptor = serde_json::from_str(&json).unwrap();
        assert_eq!(restored.kind, ForceFieldKind::Vortex);
    }
}