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

use serde::{Deserialize, Serialize};

/// Collision detection mode.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum CollisionMode {
    None,
    Plane,
    TerrainHeightfield,
    DepthBuffer,
    SignedDistanceField,
    ProxyCollider,
    VoxelGrid,
}

/// Collision response behavior.
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum CollisionResponse {
    Bounce,
    Slide,
    Stick,
    Die,
    Split,
    Shatter,
    Embed,
    Sleep,
    Promote,
    TriggerSubEmitter,
}

/// Collision policy for a particle system.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CollisionPolicy {
    pub mode: CollisionMode,
    pub response: CollisionResponse,
    pub restitution: f32,
    pub friction: f32,
    pub radius: f32,
    pub max_collisions: u32,
    pub material_response_table: Option<String>,
}

impl Default for CollisionPolicy {
    fn default() -> Self {
        Self {
            mode: CollisionMode::None,
            response: CollisionResponse::Bounce,
            restitution: 0.5,
            friction: 0.3,
            radius: 0.05,
            max_collisions: 4,
            material_response_table: None,
        }
    }
}

impl CollisionMode {
    pub const ALL: &[CollisionMode] = &[
        Self::None,
        Self::Plane,
        Self::TerrainHeightfield,
        Self::DepthBuffer,
        Self::SignedDistanceField,
        Self::ProxyCollider,
        Self::VoxelGrid,
    ];
}

impl CollisionResponse {
    pub const ALL: &[CollisionResponse] = &[
        Self::Bounce,
        Self::Slide,
        Self::Stick,
        Self::Die,
        Self::Split,
        Self::Shatter,
        Self::Embed,
        Self::Sleep,
        Self::Promote,
        Self::TriggerSubEmitter,
    ];
}

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

    #[test]
    fn collision_mode_all() {
        assert_eq!(CollisionMode::ALL.len(), 7);
    }

    #[test]
    fn collision_response_all() {
        assert_eq!(CollisionResponse::ALL.len(), 10);
    }

    #[test]
    fn collision_policy_default() {
        let p = CollisionPolicy::default();
        assert_eq!(p.mode, CollisionMode::None);
        assert_eq!(p.response, CollisionResponse::Bounce);
    }

    #[test]
    fn collision_policy_serde() {
        let p = CollisionPolicy {
            mode: CollisionMode::SignedDistanceField,
            response: CollisionResponse::Slide,
            restitution: 0.18,
            friction: 0.82,
            radius: 0.06,
            max_collisions: 12,
            material_response_table: Some("mat/stone".into()),
        };
        let json = serde_json::to_string(&p).unwrap();
        let restored: CollisionPolicy = serde_json::from_str(&json).unwrap();
        assert_eq!(restored.mode, CollisionMode::SignedDistanceField);
        assert_eq!(restored.max_collisions, 12);
    }
}