spine2d 0.3.0

Pure Rust runtime for Spine 4.3 (unofficial)
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
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

use crate::runtime::{AnimationState, AnimationStateData};
use crate::{
    Animation, AttachmentData, AttachmentFrame, AttachmentTimeline, BlendMode, BoneData,
    RegionAttachmentData, Skeleton, SkeletonData, SkinData, SlotData,
};
use indexmap::IndexMap;
use std::collections::HashMap;
use std::sync::Arc;

fn build_data() -> Arc<SkeletonData> {
    let bones = vec![BoneData {
        name: "bone".to_string(),
        parent: None,
        length: 0.0,
        x: 0.0,
        y: 0.0,
        rotation: 0.0,
        scale_x: 1.0,
        scale_y: 1.0,
        shear_x: 0.0,
        shear_y: 0.0,
        inherit: Default::default(),
        skin_required: false,
        ..Default::default()
    }];

    let slots = vec![SlotData {
        name: "slot".to_string(),
        bone: 0,
        attachment: None,
        color: [1.0, 1.0, 1.0, 1.0],
        has_dark: false,
        dark_color: [0.0, 0.0, 0.0],
        blend: BlendMode::Normal,
        ..Default::default()
    }];

    let animation = crate::runtime::finalize_animation(Animation {
        name: "animation".to_string(),
        duration: 1.0,
        event_timeline: None,
        bone_timelines: Vec::new(),
        deform_timelines: Vec::new(),
        sequence_timelines: Vec::new(),
        slot_attachment_timelines: vec![AttachmentTimeline {
            slot_index: 0,
            frames: vec![
                AttachmentFrame {
                    time: 0.0,
                    name: Some("attachment1".to_string()),
                },
                AttachmentFrame {
                    time: 0.5,
                    name: Some("attachment2".to_string()),
                },
            ],
        }],
        slot_color_timelines: Vec::new(),
        slot_rgb_timelines: Vec::new(),
        slot_alpha_timelines: Vec::new(),
        slot_rgba2_timelines: Vec::new(),
        slot_rgb2_timelines: Vec::new(),
        ik_constraint_timelines: Vec::new(),
        transform_constraint_timelines: Vec::new(),
        path_constraint_timelines: Vec::new(),
        physics_constraint_timelines: Vec::new(),
        physics_reset_timelines: Vec::new(),
        slider_time_timelines: Vec::new(),
        slider_mix_timelines: Vec::new(),
        draw_order_timeline: None,
        draw_order_folder_timelines: Vec::new(),
        timeline_order: Vec::new(),
    });

    let mut animation_index = HashMap::new();
    animation_index.insert(animation.name.clone(), 0usize);

    let mut attachments = vec![IndexMap::new()];
    for name in ["attachment1", "attachment2"] {
        attachments[0].insert(
            name.to_string(),
            AttachmentData::Region(RegionAttachmentData {
                name: name.to_string(),
                path: format!("{name}.png"),
                sequence: None,
                color: [1.0, 1.0, 1.0, 1.0],
                x: 0.0,
                y: 0.0,
                rotation: 0.0,
                scale_x: 1.0,
                scale_y: 1.0,
                width: 1.0,
                height: 1.0,
            }),
        );
    }
    let mut skins = HashMap::new();
    skins.insert(
        "default".to_string(),
        SkinData {
            name: "default".to_string(),
            attachments,
            bones: Vec::new(),
            ik_constraints: Vec::new(),
            transform_constraints: Vec::new(),
            path_constraints: Vec::new(),
            physics_constraints: Vec::new(),
            slider_constraints: Vec::new(),
        },
    );

    Arc::new(SkeletonData {
        spine_version: None,
        reference_scale: 100.0,
        bones,
        slots,
        skins,
        events: HashMap::new(),
        animations: vec![animation],
        animation_index,
        ik_constraints: Vec::new(),
        transform_constraints: Vec::new(),
        path_constraints: Vec::new(),
        physics_constraints: Vec::new(),
        slider_constraints: Vec::new(),
    })
}

#[test]
fn attachment_timeline_libgdx_upstream_tests() {
    let data = build_data();
    let mut skeleton = Skeleton::new(data.clone());

    let state_data = AnimationStateData::new(data);
    let mut state = AnimationState::new(state_data);

    state.set_animation(0, "animation", true).unwrap();

    let mut test_step = |delta: f32, expected: &str| {
        state.update(delta);
        state.apply(&mut skeleton);
        assert_eq!(skeleton.slots[0].attachment.as_deref(), Some(expected));
    };

    test_step(0.0, "attachment1");
    test_step(0.0, "attachment1");
    test_step(0.25, "attachment1");
    test_step(0.0, "attachment1");
    test_step(0.25, "attachment2");
    test_step(0.25, "attachment2");
}