spinal 0.0.1

A 2D animation engine for Spine.
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

use crate::color::Color;

#[derive(Debug)]
pub struct Animation {
    slots: Vec<SlotAnimation>,
    bones: Vec<BoneAnimation>,
    // ik: Vec<IkAnimation>,
    // transforms: Vec<TransformAnimation>,
    // paths: Vec<PathAnimation>,
    // skins: Vec<SkinAnimation>,
    // draw_orders: Vec<DrawOrderAnimation>,
    // events: Vec<EventAnimation>,
}

#[derive(Debug)]
pub struct SlotAnimation {
    slot: usize,
    timelines: Vec<AnimationTimeline>,
}

#[derive(Debug)]
pub struct AnimationTimeline {
    timeline_type: AnimationTimelineType,
    //
}

#[derive(Debug)]
pub enum AnimationTimelineType {
    Attachment(Vec<AttachmentKeyframe>),
    Color(Vec<ColorKeyframe>),
    TwoColor(Vec<TwoColorKeyframe>),
}

#[derive(Debug)]
pub struct AttachmentKeyframe {
    /// The time in seconds for the keyframe.
    time: f32,

    /// The name of the attachment to set on the slot, or `None` to clear the slot's attachment.
    attachment_string: Option<usize>,
}

// TODO: Make a special type for Vec<ColorKeyframe> where the last frame does not have a curve.
#[derive(Debug)]
pub struct ColorKeyframe {
    /// The time in seconds for the keyframe.
    time: f32,

    /// The slot color to set for the keyframe.
    color: Color,

    /// The keyframe's curve. The curve is omitted for the last keyframe.
    curve: Option<Curve>,
}

#[derive(Debug)]
pub struct TwoColorKeyframe {
    /// The time in seconds for the keyframe.
    time: f32,

    /// The light slot color to set for the keyframe.
    light: Color,

    /// The dark slot color to set for the keyframe.
    dark: Color,

    /// The keyframe's curve. The curve is omitted for the last keyframe.
    curve: Option<Curve>,
}

#[derive(Debug)]
pub struct BoneAnimation {
    bone: usize,
    timelines: Vec<AnimationTimeline>,
}

/// A curve defines the interpolation to use between a keyframe and the next keyframe:
/// linear, stepped, or a Bézier curve.
#[derive(Debug)]
pub struct Curve {
    /// The type of curve.
    curve_type: CurveType,

    /// The curve's parameters.
    parameters: Vec<f32>,
}

#[derive(Debug)]
pub enum CurveType {
    Linear,
    Stepped,
    Bezier(BezierCurve),
}

/// The Bézier curve has 4 values which define the control points: cx1, cy1, cx2, cy2.
/// The X axis is from 0 to 1 and represents the percent of time between the two keyframes.
/// The Y axis is from 0 to 1 and represents the percent of the difference between the keyframe's
/// values.
#[derive(Debug)]
pub struct BezierCurve {
    cx1: f32,
    cy1: f32,
    cx2: f32,
    cy2: f32,
}