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
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

use crate::color::Color;
use bevy_math::Vec2;
use std::path::PathBuf;
use strum::{EnumDiscriminants, FromRepr};

#[derive(Debug)]
pub struct Attachment {
    pub placeholder_name: String,
    pub attachment_name: String,
    pub data: AttachmentData,
}

// The discriminant stuff here is to generate another enum for the attachment type that can be used
// to map an integer back to the enum. It's called `AttachmentType` and has the same discriminant
// values but no data within them.
#[derive(Debug, EnumDiscriminants)]
#[strum_discriminants(name(AttachmentType))]
#[strum_discriminants(derive(FromRepr))]
#[strum_discriminants(vis(pub))]
pub enum AttachmentData {
    Region(RegionAttachment),
    BoundingBox(BoundingBoxAttachment),
    Mesh(MeshAttachment),
    LinkedMesh(LinkedMeshAttachment),
    Path(PathAttachment),
    Point(PointAttachment),
    Clipping(ClippingAttachment),
}

/// A textured rectangle.
#[derive(Debug)]
pub struct RegionAttachment {
    pub path: Option<PathBuf>,
    pub position: Vec2,
    pub scale: Vec2,
    pub rotation: f32,
    pub size: Vec2,
    pub color: Color,
    // TODO: Sequence?
}

/// A polygon used for hit detection, physics, etc.
#[derive(Debug)]
pub struct BoundingBoxAttachment {
    pub vertices: Vertices,

    /// The color of the bounding box in Spine. Assume 60F000FF RGBA if omitted. Nonessential.
    pub color: Color,
}

/// A textured mesh whose vertices may be influenced by multiple bones using weights.
#[derive(Debug)]
pub struct MeshAttachment {
    /// If not `None`, this value is used instead of the attachment name to look up the texture
    /// region.
    pub path_string: usize,

    /// The color to tint the attachment.
    pub color: Color,

    /// The texture coordinate for the vertex.
    pub uvs: Vec<Vec2>,

    /// The index of the vertex for each point.
    pub vertex_index: Vec<usize>,

    /// The mesh vertices.
    pub vertices: Vertices,

    /// The number of vertices that make up the polygon hull. The hull vertices are always first
    /// in the vertices list.
    pub hull_count: usize,

    /// The index of the edges between connected vertices. Nonessential.
    pub edges: Option<Vec<usize>>,

    /// The size of the image used by the mesh. Nonessential.
    pub size: Option<Vec2>,
}

/// A mesh which shares the UVs, vertices, and weights of another mesh.
#[derive(Debug)]
pub struct LinkedMeshAttachment {
    pub path: Option<String>,
    pub skin: Option<String>,
    pub parent: Option<String>,
    pub deform: bool,
    pub color: Color,
    pub size: Option<Vec2>,
}

/// A cubic spline, often used for moving bones along a path.
#[derive(Debug)]
pub struct PathAttachment {
    pub closed: bool,
    pub constant_speed: bool,
}

/// A single point and a rotation, often used for spawning projectiles or particles.
#[derive(Debug)]
pub struct PointAttachment {
    pub rotation: f32,
    pub position: Vec2,
    pub color: Option<Color>,
}

/// A polygon used to clip drawing of other attachments.
#[derive(Debug)]
pub struct ClippingAttachment {
    /// The index of the slot where clipping stops.
    pub end_slot_index: usize,

    /// The clipping polygon vertices.
    pub vertices: Vertices,

    /// The color of the clipping attachment in Spine. Assume CE3A3AFF RGBA if omitted.
    /// Nonessential.
    pub color: Option<Color>,
}

#[derive(Debug)]
pub enum Vertices {
    Positions { positions: Vec<Vec2> },
    BoneInfluenced { vertices: Vec<Vec<BoneInfluence>> },
}

#[derive(Debug)]
pub struct BoneInfluence {
    pub index: usize,
    pub position: Vec2,
    pub weight: f32,
}