gltf_kun 0.4.0

Graph-based glTF processing library.
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

use petgraph::graph::NodeIndex;
use serde::{Deserialize, Serialize};

use crate::graph::{ByteNode, Graph, Weight};

#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub enum PhysicsShapeWeight {
    #[serde(rename = "box")]
    Box(BoxShape),
    #[serde(rename = "sphere")]
    Sphere(SphereShape),
    #[serde(rename = "capsule")]
    Capsule(CapsuleShape),
    #[serde(rename = "cylinder")]
    Cylinder(CylinderShape),
    #[serde(rename = "convex")]
    Convex,
    #[serde(rename = "trimesh")]
    Trimesh,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct BoxShape {
    #[serde(default, skip_serializing_if = "is_default_size")]
    pub size: Size,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct SphereShape {
    #[serde(default, skip_serializing_if = "is_default_radius")]
    pub radius: Radius,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct CapsuleShape {
    #[serde(default, skip_serializing_if = "is_default_radius")]
    pub radius: Radius,
    #[serde(default, skip_serializing_if = "is_default_height")]
    pub height: Height,
}

#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct CylinderShape {
    #[serde(default, skip_serializing_if = "is_default_radius")]
    pub radius: Radius,
    #[serde(default, skip_serializing_if = "is_default_height")]
    pub height: Height,
}

#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct Size(pub [f32; 3]);

impl Default for Size {
    fn default() -> Self {
        Self([1.0, 1.0, 1.0])
    }
}

#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct Radius(pub f32);

impl Default for Radius {
    fn default() -> Self {
        Self(0.5)
    }
}

#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct Height(pub f32);

impl Default for Height {
    fn default() -> Self {
        Self(2.0)
    }
}

impl From<&Vec<u8>> for PhysicsShapeWeight {
    fn from(bytes: &Vec<u8>) -> Self {
        serde_json::from_slice(bytes).expect("Failed to deserialize physics shape weight")
    }
}

impl From<&PhysicsShapeWeight> for Vec<u8> {
    fn from(value: &PhysicsShapeWeight) -> Self {
        serde_json::to_vec(value).expect("Failed to serialize physics shape weight")
    }
}

#[derive(Copy, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub struct PhysicsShape(pub NodeIndex);

impl From<NodeIndex> for PhysicsShape {
    fn from(index: NodeIndex) -> Self {
        Self(index)
    }
}

impl From<PhysicsShape> for NodeIndex {
    fn from(physics_shape: PhysicsShape) -> Self {
        physics_shape.0
    }
}

impl ByteNode<PhysicsShapeWeight> for PhysicsShape {}

impl PhysicsShape {
    pub fn new(graph: &mut Graph, weight: &PhysicsShapeWeight) -> Self {
        let index = graph.add_node(Weight::Bytes(weight.into()));
        Self(index)
    }
}

fn is_default_size(size: &Size) -> bool {
    *size == Size::default()
}

fn is_default_radius(radius: &Radius) -> bool {
    *radius == Radius::default()
}

fn is_default_height(height: &Height) -> bool {
    *height == Height::default()
}