pak 0.7.1

An easy-to-use data pak format for games.
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
129
130
131

use {
    super::{Quat, Vec3},
    gltf::animation::Interpolation as GltfInterpolation,
    serde::{Deserialize, Serialize},
};

/// Holds an `Animation` in a `.pak` file. For data transport only.
#[derive(Debug, Deserialize, PartialEq, Serialize)]
pub struct Animation {
    channels: Vec<Channel>,
}

impl Animation {
    pub(super) fn new(channels: Vec<Channel>) -> Self {
        Self { channels }
    }

    /// The channels (joints/bones) of movement used in this `Animation`.
    pub fn channels(&self) -> &[Channel] {
        &self.channels
    }
}

/// Describes the animation of one joint.
#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub struct Channel {
    inputs: Vec<u32>,
    interpolation: Interpolation,
    outputs: Outputs,
    target: String,
}

impl Channel {
    #[allow(unused)]
    pub(crate) fn new<T: AsRef<str>, I: IntoIterator<Item = u32>>(
        target: T,
        interpolation: GltfInterpolation,
        inputs: I,
        outputs: Outputs,
    ) -> Self {
        let inputs = inputs.into_iter().collect::<Vec<_>>();
        let target = target.as_ref().to_owned();

        assert!(!target.is_empty());
        assert_ne!(inputs.len(), 0);

        Self {
            inputs,
            interpolation: match interpolation {
                GltfInterpolation::CubicSpline => Interpolation::CubicSpline,
                GltfInterpolation::Linear => Interpolation::Linear,
                GltfInterpolation::Step => Interpolation::Step,
            },
            outputs,
            target,
        }
    }

    pub fn inputs(&self) -> &[u32] {
        &self.inputs
    }

    pub fn interpolation(&self) -> Interpolation {
        self.interpolation
    }

    pub fn outputs(&self) -> &Outputs {
        &self.outputs
    }

    /// The target joint/bone.
    pub fn target(&self) -> &str {
        &self.target
    }
}

// This is here because GLTF doesn't provide serialize! TODO: Fix!
/// Specifies an interpolation algorithm.
#[derive(Clone, Copy, Debug, Eq, PartialEq, Deserialize, Serialize)]
pub enum Interpolation {
    /// Linear interpolation.
    ///
    /// The animated values are linearly interpolated between keyframes.
    /// When targeting a rotation, spherical linear interpolation (slerp) should be
    /// used to interpolate quaternions. The number output of elements must equal
    /// the number of input elements.
    Linear = 1,

    /// Step interpolation.
    ///
    /// The animated values remain constant to the output of the first keyframe,
    /// until the next keyframe. The number of output elements must equal the number
    /// of input elements.
    Step,

    /// Cubic spline interpolation.
    ///
    /// The animation's interpolation is computed using a cubic spline with specified
    /// tangents. The number of output elements must equal three times the number of
    /// input elements. For each input element, the output stores three elements, an
    /// in-tangent, a spline vertex, and an out-tangent. There must be at least two
    /// keyframes when using this interpolation
    CubicSpline,
}

#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]
pub enum Outputs {
    Rotations(Vec<Quat>),
    Scales(Vec<Vec3>),
    Translations(Vec<Vec3>),
}

impl Outputs {
    /// Returns `true` if the vector contains no elements.
    pub fn is_empty(&self) -> bool {
        match self {
            Self::Rotations(rotations) => rotations.is_empty(),
            Self::Scales(scales) => scales.is_empty(),
            Self::Translations(translations) => translations.is_empty(),
        }
    }

    /// The count of outputs
    pub fn len(&self) -> usize {
        match self {
            Self::Rotations(rotations) => rotations.len(),
            Self::Scales(scales) => scales.len(),
            Self::Translations(translations) => translations.len(),
        }
    }
}