sokol_spine.h: replace raw bone indices with sspine_bone handles

2 files changed, 134 insertions, 133 deletions

diff --git a/tests/functional/sokol_spine_test.c b/tests/functional/sokol_spine_test.c
index 35744372..782488aa 100644
--- a/tests/functional/sokol_spine_test.c
+++ b/tests/functional/sokol_spine_test.c
@@ -626,34 +626,34 @@ UTEST(sokol_spine, atlas_get_atlas_page_info_with_overrides) {
     shutdown();
 }
 
-UTEST(sokol_spine, find_bone_index) {
+UTEST(sokol_spine, bone_by_name) {
     init();
     sspine_skeleton skeleton = create_skeleton();
-    int b0 = sspine_find_bone_index(skeleton, "crosshair");
-    T(b0 == 2);
-    int b1 = sspine_find_bone_index(skeleton, "blablub");
-    T(b1 == -1);
+    sspine_bone b0 = sspine_bone_by_name(skeleton, "crosshair");
+    T((b0.skeleton_id == skeleton.id) && (b0.index == 2));
+    sspine_bone b1 = sspine_bone_by_name(skeleton, "blablub");
+    T((b1.skeleton_id == 0) && (b1.index == 0));
     shutdown();
 }
 
-UTEST(sokol_spine, find_bone_index_destroyed_skeleton) {
+UTEST(sokol_spine, bone_by_name_destroyed_skeleton) {
     init();
     sspine_skeleton skeleton = create_skeleton();
     sspine_destroy_skeleton(skeleton);
-    int b0 = sspine_find_bone_index(skeleton, "crosshair");
-    T(b0 == -1);
+    sspine_bone b0 = sspine_bone_by_name(skeleton, "crosshair");
+    T((b0.skeleton_id == 0) && (b0.index == 0));
     shutdown();
 }
 
-UTEST(sokol_spine, bone_index_valid) {
+UTEST(sokol_spine, bone_valid) {
     init();
     sspine_skeleton skeleton = create_skeleton();
-    T(sspine_bone_index_valid(skeleton, 0));
-    T(sspine_bone_index_valid(skeleton, 66));
-    T(!sspine_bone_index_valid(skeleton, -1));
-    T(!sspine_bone_index_valid(skeleton, 67));
+    T(sspine_bone_valid(sspine_bone_by_index(skeleton, 0)));
+    T(sspine_bone_valid(sspine_bone_by_index(skeleton, 66)));
+    T(!sspine_bone_valid(sspine_bone_by_index(skeleton, -1)));
+    T(!sspine_bone_valid(sspine_bone_by_index(skeleton, 67)));
     sspine_destroy_skeleton(skeleton);
-    T(!sspine_bone_index_valid(skeleton, 0));
+    T(!sspine_bone_valid(sspine_bone_by_index(skeleton, 0)));
     shutdown();
 }
 
@@ -669,11 +669,10 @@ UTEST(sokol_spine, num_bones) {
 UTEST(sokol_spine, get_bone_info_root) {
     init();
     sspine_skeleton skeleton = create_skeleton();
-    int bone_index = sspine_find_bone_index(skeleton, "root");
-    const sspine_bone_info info = sspine_get_bone_info(skeleton, bone_index);
+    const sspine_bone_info info = sspine_get_bone_info(sspine_bone_by_name(skeleton, "root"));
     T(info.valid);
     T(info.index == 0);
-    T(info.parent_index == -1);
+    T((info.parent_bone.skeleton_id == 0) && (info.parent_bone.index == 0));
     T(strcmp(info.name, "root") == 0);
     T(info.length == 0.0f);
     T(info.pose.position.x == 0.0f);
@@ -686,23 +685,22 @@ UTEST(sokol_spine, get_bone_info_root) {
     shutdown();
 }
 
-UTEST(sokol_spine, get_bone_info_parent_index) {
+UTEST(sokol_spine, get_bone_info_parent_bone) {
     init();
     sspine_skeleton skeleton = create_skeleton();
-    int bone_index = sspine_find_bone_index(skeleton, "rear-shin");
-    const sspine_bone_info info = sspine_get_bone_info(skeleton, bone_index);
+    const sspine_bone_info info = sspine_get_bone_info(sspine_bone_by_name(skeleton, "rear-shin"));
     T(info.valid);
     T(info.index == 7);
-    T(info.parent_index == 6);
+    T((info.parent_bone.skeleton_id == skeleton.id) && (info.parent_bone.index == 6));
     shutdown();
 }
 
 UTEST(sokol_spine, get_bone_info_destroyed_skeleton) {
     init();
     sspine_skeleton skeleton = create_skeleton();
-    int bone_index = sspine_find_bone_index(skeleton, "root");
+    sspine_bone bone = sspine_bone_by_name(skeleton, "root");
     sspine_destroy_skeleton(skeleton);
-    const sspine_bone_info info = sspine_get_bone_info(skeleton, bone_index);
+    const sspine_bone_info info = sspine_get_bone_info(bone);
     T(!info.valid);
     T(info.name == 0);
     shutdown();
@@ -711,10 +709,10 @@ UTEST(sokol_spine, get_bone_info_destroyed_skeleton) {
 UTEST(sokol_spine, get_bone_info_invalid_index) {
     init();
     sspine_skeleton skeleton = create_skeleton();
-    const sspine_bone_info i0 = sspine_get_bone_info(skeleton, -1);
+    const sspine_bone_info i0 = sspine_get_bone_info(sspine_bone_by_index(skeleton, -1));
     T(!i0.valid);
     T(i0.name == 0);
-    const sspine_bone_info i1 = sspine_get_bone_info(skeleton, 1234);
+    const sspine_bone_info i1 = sspine_get_bone_info(sspine_bone_by_index(skeleton, 1234));
     T(!i1.valid);
     T(i1.name == 0);
     shutdown();
@@ -724,14 +722,14 @@ UTEST(sokol_spine, set_get_bone_transform) {
     init();
     sspine_instance instance = create_instance();
     sspine_skeleton skeleton = sspine_get_instance_skeleton(instance);
-    int bone_index = sspine_find_bone_index(skeleton, "root");
-    sspine_set_bone_transform(instance, bone_index, &(sspine_bone_transform){
+    sspine_bone bone = sspine_bone_by_name(skeleton, "root");
+    sspine_set_bone_transform(instance, bone, &(sspine_bone_transform){
         .position = { 1.0f, 2.0f },
         .rotation = 3.0f,
         .scale = { 4.0f, 5.0f },
         .shear = { 6.0f, 7.0f }
     });
-    const sspine_bone_transform tform = sspine_get_bone_transform(instance, bone_index);
+    const sspine_bone_transform tform = sspine_get_bone_transform(instance, bone);
     T(tform.position.x == 1.0f);
     T(tform.position.y == 2.0f);
     T(tform.rotation == 3.0f);
@@ -746,15 +744,15 @@ UTEST(sokol_spine, set_get_bone_transform_destroyed_instance) {
     init();
     sspine_instance instance = create_instance();
     sspine_skeleton skeleton = sspine_get_instance_skeleton(instance);
-    int bone_index = sspine_find_bone_index(skeleton, "root");
+    sspine_bone bone = sspine_bone_by_name(skeleton, "root");
     sspine_destroy_instance(instance);
-    sspine_set_bone_transform(instance, bone_index, &(sspine_bone_transform){
+    sspine_set_bone_transform(instance, bone, &(sspine_bone_transform){
         .position = { 1.0f, 2.0f },
         .rotation = 3.0f,
         .scale = { 4.0f, 5.0f },
         .shear = { 6.0f, 7.0f }
     });
-    const sspine_bone_transform tform = sspine_get_bone_transform(instance, bone_index);
+    const sspine_bone_transform tform = sspine_get_bone_transform(instance, bone);
     T(tform.position.x == 0.0f);
     T(tform.position.y == 0.0f);
     T(tform.rotation == 0.0f);
@@ -769,13 +767,13 @@ UTEST(sokol_spine, set_get_bone_position) {
     init();
     sspine_instance instance = create_instance();
     sspine_skeleton skeleton = sspine_get_instance_skeleton(instance);
-    int bone_index = sspine_find_bone_index(skeleton, "root");
-    sspine_set_bone_position(instance, bone_index, (sspine_vec2){ 1.0f, 2.0f });
-    const sspine_vec2 p0 = sspine_get_bone_position(instance, bone_index);
+    sspine_bone bone = sspine_bone_by_name(skeleton, "root");
+    sspine_set_bone_position(instance, bone, (sspine_vec2){ 1.0f, 2.0f });
+    const sspine_vec2 p0 = sspine_get_bone_position(instance, bone);
     T(p0.x == 1.0f);
     T(p0.y == 2.0f);
     sspine_destroy_instance(instance);
-    const sspine_vec2 p1 = sspine_get_bone_position(instance, bone_index);
+    const sspine_vec2 p1 = sspine_get_bone_position(instance, bone);
     T(p1.x == 0.0f);
     T(p1.y == 0.0f);
     shutdown();
@@ -785,11 +783,11 @@ UTEST(sokol_spine, set_get_bone_rotation) {
     init();
     sspine_instance instance = create_instance();
     sspine_skeleton skeleton = sspine_get_instance_skeleton(instance);
-    int bone_index = sspine_find_bone_index(skeleton, "root");
-    sspine_set_bone_rotation(instance, bone_index, 5.0f);
-    T(sspine_get_bone_rotation(instance, bone_index) == 5.0f);
+    sspine_bone bone = sspine_bone_by_name(skeleton, "root");
+    sspine_set_bone_rotation(instance, bone, 5.0f);
+    T(sspine_get_bone_rotation(instance, bone) == 5.0f);
     sspine_destroy_instance(instance);
-    T(sspine_get_bone_rotation(instance, bone_index) == 0.0f);
+    T(sspine_get_bone_rotation(instance, bone) == 0.0f);
     shutdown();
 }
 
@@ -797,13 +795,13 @@ UTEST(sokol_spine, set_get_bone_scale) {
     init();
     sspine_instance instance = create_instance();
     sspine_skeleton skeleton = sspine_get_instance_skeleton(instance);
-    int bone_index = sspine_find_bone_index(skeleton, "root");
-    sspine_set_bone_scale(instance, bone_index, (sspine_vec2){ 1.0f, 2.0f });
-    const sspine_vec2 s0 = sspine_get_bone_scale(instance, bone_index);
+    sspine_bone bone = sspine_bone_by_name(skeleton, "root");
+    sspine_set_bone_scale(instance, bone, (sspine_vec2){ 1.0f, 2.0f });
+    const sspine_vec2 s0 = sspine_get_bone_scale(instance, bone);
     T(s0.x == 1.0f);
     T(s0.y == 2.0f);
     sspine_destroy_instance(instance);
-    const sspine_vec2 s1 = sspine_get_bone_scale(instance, bone_index);
+    const sspine_vec2 s1 = sspine_get_bone_scale(instance, bone);
     T(s1.x == 0.0f);
     T(s1.y == 0.0f);
     shutdown();
@@ -813,13 +811,13 @@ UTEST(sokol_spine, set_get_bone_shear) {
     init();
     sspine_instance instance = create_instance();
     sspine_skeleton skeleton = sspine_get_instance_skeleton(instance);
-    int bone_index = sspine_find_bone_index(skeleton, "root");
-    sspine_set_bone_shear(instance, bone_index, (sspine_vec2){ 1.0f, 2.0f });
-    const sspine_vec2 s0 = sspine_get_bone_shear(instance, bone_index);
+    sspine_bone bone = sspine_bone_by_name(skeleton, "root");
+    sspine_set_bone_shear(instance, bone, (sspine_vec2){ 1.0f, 2.0f });
+    const sspine_vec2 s0 = sspine_get_bone_shear(instance, bone);
     T(s0.x == 1.0f);
     T(s0.y == 2.0f);
     sspine_destroy_instance(instance);
-    const sspine_vec2 s1 = sspine_get_bone_shear(instance, bone_index);
+    const sspine_vec2 s1 = sspine_get_bone_shear(instance, bone);
     T(s1.x == 0.0f);
     T(s1.y == 0.0f);
     shutdown();
@@ -874,7 +872,7 @@ UTEST(sokol_spine, get_slot_info) {
     T(info.index == 3);
     T(strcmp(info.name, "portal-streaks1") == 0);
     T(info.attachment_name == 0);
-    T(info.bone_index == 62);
+    T((info.bone.skeleton_id == skeleton.id) && (info.bone.index == 62));
     T(info.color.r == 1.0f);
     T(info.color.g == 1.0f);
     T(info.color.b == 1.0f);
@@ -1036,7 +1034,7 @@ UTEST(sokol_spine, get_iktarget_info) {
     T(info.valid);
     T(1 == info.index);
     T(0 == strcmp(info.name, "aim-torso-ik"));
-    T(2 == info.target_bone_index);
+    T((info.target_bone.skeleton_id == skeleton.id) && (info.target_bone.index == 2));
     shutdown();
 }
 
diff --git a/util/sokol_spine.h b/util/sokol_spine.h
index 2121b126..96b9a1a2 100644
--- a/util/sokol_spine.h
+++ b/util/sokol_spine.h
@@ -115,6 +115,7 @@ typedef struct sspine_skeleton { uint32_t id; } sspine_skeleton;
 typedef struct sspine_instance { uint32_t id; } sspine_instance;
 typedef struct sspine_skinset { uint32_t id; } sspine_skinset;
 typedef struct sspine_anim { uint32_t skeleton_id; int index; } sspine_anim;
+typedef struct sspine_bone { uint32_t skeleton_id; int index; } sspine_bone;
 
 typedef struct sspine_range { const void* ptr; size_t size; } sspine_range;
 typedef struct sspine_vec2 { float x, y; } sspine_vec2;
@@ -224,7 +225,7 @@ typedef struct sspine_bone_info {
     bool valid;
     const char* name;
     int index;
-    int parent_index;
+    sspine_bone parent_bone;
     float length;
     sspine_bone_transform pose;
     sspine_color color;
@@ -235,7 +236,7 @@ typedef struct sspine_slot_info {
     const char* name;
     int index;
     const char* attachment_name;
-    int bone_index;
+    sspine_bone bone;
     sspine_color color;
 } sspine_slot_info;
 
@@ -243,7 +244,7 @@ typedef struct sspine_iktarget_info {
     bool valid;
     const char* name;
     int index;
-    int target_bone_index;
+    sspine_bone target_bone;
 } sspine_iktarget_info;
 
 typedef struct sspine_skin_info {
@@ -397,23 +398,24 @@ SOKOL_SPINE_API_DECL int sspine_num_atlas_pages(sspine_atlas atlas);
 SOKOL_SPINE_API_DECL sspine_atlas_page_info sspine_get_atlas_page_info(sspine_atlas atlas, int page_index);
 
 // bone functions
-SOKOL_SPINE_API_DECL int sspine_find_bone_index(sspine_skeleton skeleton, const char* name);
-SOKOL_SPINE_API_DECL bool sspine_bone_index_valid(sspine_skeleton skeleton, int bone_index);
 SOKOL_SPINE_API_DECL int sspine_num_bones(sspine_skeleton skeleton);
-SOKOL_SPINE_API_DECL sspine_bone_info sspine_get_bone_info(sspine_skeleton skeleton, int bone_index);
-SOKOL_SPINE_API_DECL void sspine_set_bone_transform(sspine_instance instance, int bone_index, const sspine_bone_transform* transform);
-SOKOL_SPINE_API_DECL void sspine_set_bone_position(sspine_instance instance, int bone_index, sspine_vec2 position);
-SOKOL_SPINE_API_DECL void sspine_set_bone_rotation(sspine_instance instance, int bone_index, float rotation);
-SOKOL_SPINE_API_DECL void sspine_set_bone_scale(sspine_instance instance, int bone_index, sspine_vec2 scale);
-SOKOL_SPINE_API_DECL void sspine_set_bone_shear(sspine_instance instance, int bone_index, sspine_vec2 shear);
-SOKOL_SPINE_API_DECL sspine_bone_transform sspine_get_bone_transform(sspine_instance instance, int bone_index);
-SOKOL_SPINE_API_DECL sspine_vec2 sspine_get_bone_position(sspine_instance instance, int bone_index);
-SOKOL_SPINE_API_DECL float sspine_get_bone_rotation(sspine_instance instance, int bone_index);
-SOKOL_SPINE_API_DECL sspine_vec2 sspine_get_bone_scale(sspine_instance instance, int bone_index);
-SOKOL_SPINE_API_DECL sspine_vec2 sspine_get_bone_shear(sspine_instance instance, int bone_index);
-SOKOL_SPINE_API_DECL sspine_vec2 sspine_get_bone_world_position(sspine_instance instance, int bone_index);
-SOKOL_SPINE_API_DECL sspine_vec2 sspine_bone_local_to_world(sspine_instance instance, int bone_index, sspine_vec2 local_pos);
-SOKOL_SPINE_API_DECL sspine_vec2 sspine_bone_world_to_local(sspine_instance instance, int bone_index, sspine_vec2 world_pos);
+SOKOL_SPINE_API_DECL sspine_bone sspine_bone_by_name(sspine_skeleton skeleton, const char* name);
+SOKOL_SPINE_API_DECL sspine_bone sspine_bone_by_index(sspine_skeleton skeleton, int index);
+SOKOL_SPINE_API_DECL bool sspine_bone_valid(sspine_bone bone);
+SOKOL_SPINE_API_DECL sspine_bone_info sspine_get_bone_info(sspine_bone bone);
+SOKOL_SPINE_API_DECL void sspine_set_bone_transform(sspine_instance instance, sspine_bone bone, const sspine_bone_transform* transform);
+SOKOL_SPINE_API_DECL void sspine_set_bone_position(sspine_instance instance, sspine_bone bone, sspine_vec2 position);
+SOKOL_SPINE_API_DECL void sspine_set_bone_rotation(sspine_instance instance, sspine_bone bone, float rotation);
+SOKOL_SPINE_API_DECL void sspine_set_bone_scale(sspine_instance instance, sspine_bone bone, sspine_vec2 scale);
+SOKOL_SPINE_API_DECL void sspine_set_bone_shear(sspine_instance instance, sspine_bone bone, sspine_vec2 shear);
+SOKOL_SPINE_API_DECL sspine_bone_transform sspine_get_bone_transform(sspine_instance instance, sspine_bone bone);
+SOKOL_SPINE_API_DECL sspine_vec2 sspine_get_bone_position(sspine_instance instance, sspine_bone bone);
+SOKOL_SPINE_API_DECL float sspine_get_bone_rotation(sspine_instance instance, sspine_bone bone);
+SOKOL_SPINE_API_DECL sspine_vec2 sspine_get_bone_scale(sspine_instance instance, sspine_bone bone);
+SOKOL_SPINE_API_DECL sspine_vec2 sspine_get_bone_shear(sspine_instance instance, sspine_bone bone);
+SOKOL_SPINE_API_DECL sspine_vec2 sspine_get_bone_world_position(sspine_instance instance, sspine_bone bone);
+SOKOL_SPINE_API_DECL sspine_vec2 sspine_bone_local_to_world(sspine_instance instance, sspine_bone bone, sspine_vec2 local_pos);
+SOKOL_SPINE_API_DECL sspine_vec2 sspine_bone_world_to_local(sspine_instance instance, sspine_bone bone, sspine_vec2 world_pos);
 
 // slot functions
 SOKOL_SPINE_API_DECL int sspine_find_slot_index(sspine_skeleton skeleton, const char* name);
@@ -1900,6 +1902,14 @@ static sspine_anim _sspine_anim(uint32_t skeleton_id, int index) {
     return anim;
 }
 
+static sspine_bone _sspine_bone(uint32_t skeleton_id, int index) {
+    sspine_bone bone;
+    _sspine_clear(&bone, sizeof(bone));
+    bone.skeleton_id = skeleton_id;
+    bone.index = index;
+    return bone;
+}
+
 //=== HANDLE POOL FUNCTIONS ====================================================
 static void _sspine_init_pool(_sspine_pool_t* pool, int num) {
     SOKOL_ASSERT(pool && (num >= 1));
@@ -2780,9 +2790,9 @@ static spBoneData* _sspine_lookup_bone_data(uint32_t skeleton_id, int bone_index
     return 0;
 }
 
-static spBone* _sspine_lookup_bone(uint32_t instance_id, int bone_index) {
+static spBone* _sspine_lookup_bone(uint32_t instance_id, uint32_t skeleton_id, int bone_index) {
     _sspine_instance_t* instance = _sspine_lookup_instance(instance_id);
-    if (_sspine_instance_and_deps_valid(instance)) {
+    if (_sspine_instance_and_deps_valid(instance) && (instance->skel.id == skeleton_id)) {
         SOKOL_ASSERT(instance->sp_skel && instance->sp_skel->bones);
         if ((bone_index >= 0) && (bone_index <= instance->sp_skel->bonesCount)) {
             return instance->sp_skel->bones[bone_index];
@@ -3869,15 +3879,7 @@ SOKOL_API_IMPL sspine_anim sspine_anim_by_name(sspine_skeleton skeleton_id, cons
 }
 
 SOKOL_API_IMPL sspine_anim sspine_anim_by_index(sspine_skeleton skeleton_id, int index) {
-    SOKOL_ASSERT(_SSPINE_INIT_COOKIE == _sspine.init_cookie);
-    _sspine_skeleton_t* skeleton = _sspine_lookup_skeleton(skeleton_id.id);
-    if (_sspine_skeleton_and_deps_valid(skeleton)) {
-        SOKOL_ASSERT(skeleton->sp_skel_data);
-        if ((index >= 0) && (index < skeleton->sp_skel_data->animationsCount)) {
-            return _sspine_anim(skeleton_id.id, index);
-        }
-    }
-    return _sspine_anim(0, 0);
+    return _sspine_anim(skeleton_id.id, index);
 }
 
 SOKOL_API_IMPL bool sspine_anim_valid(sspine_anim anim) {
@@ -3894,7 +3896,7 @@ SOKOL_API_IMPL sspine_anim_info sspine_get_anim_info(sspine_anim anim) {
     SOKOL_ASSERT(_SSPINE_INIT_COOKIE == _sspine.init_cookie);
     sspine_anim_info res;
     _sspine_clear(&res, sizeof(res));
-    spAnimation* sp_anim = _sspine_lookup_skeleton_anim(anim.skeleton_id, anim.index);
+    const spAnimation* sp_anim = _sspine_lookup_skeleton_anim(anim.skeleton_id, anim.index);
     if (sp_anim) {
         res.valid = true;
         res.name = sp_anim->name;
@@ -4007,56 +4009,57 @@ SOKOL_API_IMPL sspine_atlas_page_info sspine_get_atlas_page_info(sspine_atlas at
     return res;
 }
 
-SOKOL_API_IMPL int sspine_find_bone_index(sspine_skeleton skeleton_id, const char* name) {
+SOKOL_API_IMPL int sspine_num_bones(sspine_skeleton skeleton_id) {
     SOKOL_ASSERT(_SSPINE_INIT_COOKIE == _sspine.init_cookie);
-    SOKOL_ASSERT(name);
     _sspine_skeleton_t* skeleton = _sspine_lookup_skeleton(skeleton_id.id);
     if (_sspine_skeleton_and_deps_valid(skeleton)) {
         SOKOL_ASSERT(skeleton->sp_skel_data);
-        spBoneData* sp_bone_data = spSkeletonData_findBone(skeleton->sp_skel_data, name);
-        if (sp_bone_data) {
-            return sp_bone_data->index;
-        }
+        return skeleton->sp_skel_data->bonesCount;
     }
-    return -1;
+    return 0;
 }
 
-SOKOL_API_IMPL bool sspine_bone_index_valid(sspine_skeleton skeleton_id, int bone_index) {
+SOKOL_API_IMPL sspine_bone sspine_bone_by_name(sspine_skeleton skeleton_id, const char* name) {
     SOKOL_ASSERT(_SSPINE_INIT_COOKIE == _sspine.init_cookie);
+    SOKOL_ASSERT(name);
     _sspine_skeleton_t* skeleton = _sspine_lookup_skeleton(skeleton_id.id);
     if (_sspine_skeleton_and_deps_valid(skeleton)) {
         SOKOL_ASSERT(skeleton->sp_skel_data);
-        return (bone_index >= 0) && (bone_index < skeleton->sp_skel_data->bonesCount);
+        spBoneData* sp_bone_data = spSkeletonData_findBone(skeleton->sp_skel_data, name);
+        if (sp_bone_data) {
+            return _sspine_bone(skeleton_id.id, sp_bone_data->index);
+        }
     }
-    return false;
+    return _sspine_bone(0, 0);
 }
 
-SOKOL_API_IMPL int sspine_num_bones(sspine_skeleton skeleton_id) {
+SOKOL_API_IMPL sspine_bone sspine_bone_by_index(sspine_skeleton skeleton_id, int index) {
+    return _sspine_bone(skeleton_id.id, index);
+}
+
+SOKOL_API_IMPL bool sspine_bone_valid(sspine_bone bone) {
     SOKOL_ASSERT(_SSPINE_INIT_COOKIE == _sspine.init_cookie);
-    _sspine_skeleton_t* skeleton = _sspine_lookup_skeleton(skeleton_id.id);
+    _sspine_skeleton_t* skeleton = _sspine_lookup_skeleton(bone.skeleton_id);
     if (_sspine_skeleton_and_deps_valid(skeleton)) {
         SOKOL_ASSERT(skeleton->sp_skel_data);
-        return skeleton->sp_skel_data->bonesCount;
+        return (bone.index >= 0) && (bone.index < skeleton->sp_skel_data->bonesCount);
     }
-    return 0;
+    return false;
 }
 
-SOKOL_API_IMPL sspine_bone_info sspine_get_bone_info(sspine_skeleton skeleton_id, int bone_index) {
+SOKOL_API_IMPL sspine_bone_info sspine_get_bone_info(sspine_bone bone) {
     SOKOL_ASSERT(_SSPINE_INIT_COOKIE == _sspine.init_cookie);
     sspine_bone_info res;
     _sspine_clear(&res, sizeof(res));
-    spBoneData* sp_bone_data = _sspine_lookup_bone_data(skeleton_id.id, bone_index);
+    const spBoneData* sp_bone_data = _sspine_lookup_bone_data(bone.skeleton_id, bone.index);
     if (sp_bone_data) {
-        SOKOL_ASSERT(sp_bone_data->index == bone_index);
+        SOKOL_ASSERT(sp_bone_data->index == bone.index);
         SOKOL_ASSERT(sp_bone_data->name);
         res.valid = true;
         res.name = sp_bone_data->name;
         res.index = sp_bone_data->index;
         if (sp_bone_data->parent) {
-            res.parent_index = sp_bone_data->parent->index;
-        }
-        else {
-            res.parent_index = -1;
+            res.parent_bone = _sspine_bone(bone.skeleton_id, sp_bone_data->parent->index);
         }
         res.length = sp_bone_data->length;
         res.pose.position.x = sp_bone_data->x;
@@ -4074,10 +4077,10 @@ SOKOL_API_IMPL sspine_bone_info sspine_get_bone_info(sspine_skeleton skeleton_id
     return res;
 }
 
-SOKOL_API_IMPL void sspine_set_bone_transform(sspine_instance instance_id, int bone_index, const sspine_bone_transform* transform) {
+SOKOL_API_IMPL void sspine_set_bone_transform(sspine_instance instance_id, sspine_bone bone, const sspine_bone_transform* transform) {
     SOKOL_ASSERT(_SSPINE_INIT_COOKIE == _sspine.init_cookie);
     SOKOL_ASSERT(transform);
-    spBone* sp_bone = _sspine_lookup_bone(instance_id.id, bone_index);
+    spBone* sp_bone = _sspine_lookup_bone(instance_id.id, bone.skeleton_id, bone.index);
     if (sp_bone) {
         sp_bone->x = transform->position.x;
         sp_bone->y = transform->position.y;
@@ -4089,46 +4092,46 @@ SOKOL_API_IMPL void sspine_set_bone_transform(sspine_instance instance_id, int b
     }
 }
 
-SOKOL_API_IMPL void sspine_set_bone_position(sspine_instance instance_id, int bone_index, sspine_vec2 position) {
+SOKOL_API_IMPL void sspine_set_bone_position(sspine_instance instance_id, sspine_bone bone, sspine_vec2 position) {
     SOKOL_ASSERT(_SSPINE_INIT_COOKIE == _sspine.init_cookie);
-    spBone* sp_bone = _sspine_lookup_bone(instance_id.id, bone_index);
+    spBone* sp_bone = _sspine_lookup_bone(instance_id.id, bone.skeleton_id, bone.index);
     if (sp_bone) {
         sp_bone->x = position.x;
         sp_bone->y = position.y;
     }
 }
 
-SOKOL_API_IMPL void sspine_set_bone_rotation(sspine_instance instance_id, int bone_index, float rotation) {
+SOKOL_API_IMPL void sspine_set_bone_rotation(sspine_instance instance_id, sspine_bone bone, float rotation) {
     SOKOL_ASSERT(_SSPINE_INIT_COOKIE == _sspine.init_cookie);
-    spBone* sp_bone = _sspine_lookup_bone(instance_id.id, bone_index);
+    spBone* sp_bone = _sspine_lookup_bone(instance_id.id, bone.skeleton_id, bone.index);
     if (sp_bone) {
         sp_bone->rotation = rotation;
     }
 }
 
-SOKOL_API_IMPL void sspine_set_bone_scale(sspine_instance instance_id, int bone_index, sspine_vec2 scale) {
+SOKOL_API_IMPL void sspine_set_bone_scale(sspine_instance instance_id, sspine_bone bone, sspine_vec2 scale) {
     SOKOL_ASSERT(_SSPINE_INIT_COOKIE == _sspine.init_cookie);
-    spBone* sp_bone = _sspine_lookup_bone(instance_id.id, bone_index);
+    spBone* sp_bone = _sspine_lookup_bone(instance_id.id, bone.skeleton_id, bone.index);
     if (sp_bone) {
         sp_bone->scaleX = scale.x;
         sp_bone->scaleY = scale.y;
     }
 }
 
-SOKOL_API_IMPL void sspine_set_bone_shear(sspine_instance instance_id, int bone_index, sspine_vec2 shear) {
+SOKOL_API_IMPL void sspine_set_bone_shear(sspine_instance instance_id, sspine_bone bone, sspine_vec2 shear) {
     SOKOL_ASSERT(_SSPINE_INIT_COOKIE == _sspine.init_cookie);
-    spBone* sp_bone = _sspine_lookup_bone(instance_id.id, bone_index);
+    spBone* sp_bone = _sspine_lookup_bone(instance_id.id, bone.skeleton_id, bone.index);
     if (sp_bone) {
         sp_bone->shearX = shear.x;
         sp_bone->shearY = shear.y;
     }
 }
 
-SOKOL_API_IMPL sspine_bone_transform sspine_get_bone_transform(sspine_instance instance_id, int bone_index) {
+SOKOL_API_IMPL sspine_bone_transform sspine_get_bone_transform(sspine_instance instance_id, sspine_bone bone) {
     SOKOL_ASSERT(_SSPINE_INIT_COOKIE == _sspine.init_cookie);
     sspine_bone_transform res;
     _sspine_clear(&res, sizeof(res));
-    spBone* sp_bone = _sspine_lookup_bone(instance_id.id, bone_index);
+    spBone* sp_bone = _sspine_lookup_bone(instance_id.id, bone.skeleton_id, bone.index);
     if (sp_bone) {
         res.position.x = sp_bone->x;
         res.position.y = sp_bone->y;
@@ -4141,11 +4144,11 @@ SOKOL_API_IMPL sspine_bone_transform sspine_get_bone_transform(sspine_instance i
     return res;
 }
 
-SOKOL_API_IMPL sspine_vec2 sspine_get_bone_position(sspine_instance instance_id, int bone_index) {
+SOKOL_API_IMPL sspine_vec2 sspine_get_bone_position(sspine_instance instance_id, sspine_bone bone) {
     SOKOL_ASSERT(_SSPINE_INIT_COOKIE == _sspine.init_cookie);
     sspine_vec2 res;
     _sspine_clear(&res, sizeof(res));
-    spBone* sp_bone = _sspine_lookup_bone(instance_id.id, bone_index);
+    spBone* sp_bone = _sspine_lookup_bone(instance_id.id, bone.skeleton_id, bone.index);
     if (sp_bone) {
         res.x = sp_bone->x;
         res.y = sp_bone->y;
@@ -4153,9 +4156,9 @@ SOKOL_API_IMPL sspine_vec2 sspine_get_bone_position(sspine_instance instance_id,
     return res;
 }
 
-SOKOL_API_IMPL float sspine_get_bone_rotation(sspine_instance instance_id, int bone_index) {
+SOKOL_API_IMPL float sspine_get_bone_rotation(sspine_instance instance_id, sspine_bone bone) {
     SOKOL_ASSERT(_SSPINE_INIT_COOKIE == _sspine.init_cookie);
-    spBone* sp_bone = _sspine_lookup_bone(instance_id.id, bone_index);
+    spBone* sp_bone = _sspine_lookup_bone(instance_id.id, bone.skeleton_id, bone.index);
     if (sp_bone) {
         return sp_bone->rotation;
     }
@@ -4164,11 +4167,11 @@ SOKOL_API_IMPL float sspine_get_bone_rotation(sspine_instance instance_id, int b
     }
 }
 
-SOKOL_API_IMPL sspine_vec2 sspine_get_bone_scale(sspine_instance instance_id, int bone_index) {
+SOKOL_API_IMPL sspine_vec2 sspine_get_bone_scale(sspine_instance instance_id, sspine_bone bone) {
     SOKOL_ASSERT(_SSPINE_INIT_COOKIE == _sspine.init_cookie);
     sspine_vec2 res;
     _sspine_clear(&res, sizeof(res));
-    spBone* sp_bone = _sspine_lookup_bone(instance_id.id, bone_index);
+    spBone* sp_bone = _sspine_lookup_bone(instance_id.id, bone.skeleton_id, bone.index);
     if (sp_bone) {
         res.x = sp_bone->scaleX;
         res.y = sp_bone->scaleY;
@@ -4176,11 +4179,11 @@ SOKOL_API_IMPL sspine_vec2 sspine_get_bone_scale(sspine_instance instance_id, in
     return res;
 }
 
-SOKOL_API_IMPL sspine_vec2 sspine_get_bone_shear(sspine_instance instance_id, int bone_index) {
+SOKOL_API_IMPL sspine_vec2 sspine_get_bone_shear(sspine_instance instance_id, sspine_bone bone) {
     SOKOL_ASSERT(_SSPINE_INIT_COOKIE == _sspine.init_cookie);
     sspine_vec2 res;
     _sspine_clear(&res, sizeof(res));
-    spBone* sp_bone = _sspine_lookup_bone(instance_id.id, bone_index);
+    spBone* sp_bone = _sspine_lookup_bone(instance_id.id, bone.skeleton_id, bone.index);
     if (sp_bone) {
         res.x = sp_bone->shearX;
         res.y = sp_bone->shearY;
@@ -4188,11 +4191,11 @@ SOKOL_API_IMPL sspine_vec2 sspine_get_bone_shear(sspine_instance instance_id, in
     return res;
 }
 
-SOKOL_API_IMPL sspine_vec2 sspine_get_bone_world_position(sspine_instance instance_id, int bone_index) {
+SOKOL_API_IMPL sspine_vec2 sspine_get_bone_world_position(sspine_instance instance_id, sspine_bone bone) {
     SOKOL_ASSERT(_SSPINE_INIT_COOKIE == _sspine.init_cookie);
     sspine_vec2 res;
     _sspine_clear(&res, sizeof(res));
-    spBone* sp_bone = _sspine_lookup_bone(instance_id.id, bone_index);
+    spBone* sp_bone = _sspine_lookup_bone(instance_id.id, bone.skeleton_id, bone.index);
     if (sp_bone) {
         res.x = sp_bone->worldX;
         res.y = sp_bone->worldY;
@@ -4200,22 +4203,22 @@ SOKOL_API_IMPL sspine_vec2 sspine_get_bone_world_position(sspine_instance instan
     return res;
 }
 
-SOKOL_API_IMPL sspine_vec2 sspine_bone_local_to_world(sspine_instance instance_id, int bone_index, sspine_vec2 local_pos) {
+SOKOL_API_IMPL sspine_vec2 sspine_bone_local_to_world(sspine_instance instance_id, sspine_bone bone, sspine_vec2 local_pos) {
     SOKOL_ASSERT(_SSPINE_INIT_COOKIE == _sspine.init_cookie);
     sspine_vec2 res;
     _sspine_clear(&res, sizeof(res));
-    spBone* sp_bone = _sspine_lookup_bone(instance_id.id, bone_index);
+    spBone* sp_bone = _sspine_lookup_bone(instance_id.id, bone.skeleton_id, bone.index);
     if (sp_bone) {
         spBone_localToWorld(sp_bone, local_pos.x, local_pos.y, &res.x, &res.y);
     }
     return res;
 }
 
-SOKOL_API_IMPL sspine_vec2 sspine_bone_world_to_local(sspine_instance instance_id, int bone_index, sspine_vec2 world_pos) {
+SOKOL_API_IMPL sspine_vec2 sspine_bone_world_to_local(sspine_instance instance_id, sspine_bone bone, sspine_vec2 world_pos) {
     SOKOL_ASSERT(_SSPINE_INIT_COOKIE == _sspine.init_cookie);
     sspine_vec2 res;
     _sspine_clear(&res, sizeof(res));
-    spBone* sp_bone = _sspine_lookup_bone(instance_id.id, bone_index);
+    spBone* sp_bone = _sspine_lookup_bone(instance_id.id, bone.skeleton_id, bone.index);
     if (sp_bone) {
         spBone_worldToLocal(sp_bone, world_pos.x, world_pos.y, &res.x, &res.y);
     }
@@ -4260,7 +4263,7 @@ SOKOL_API_IMPL sspine_slot_info sspine_get_slot_info(sspine_skeleton skeleton_id
     SOKOL_ASSERT(_SSPINE_INIT_COOKIE == _sspine.init_cookie);
     sspine_slot_info res;
     _sspine_clear(&res, sizeof(res));
-    spSlotData* sp_slot_data = _sspine_lookup_slot_data(skeleton_id.id, slot_index);
+    const spSlotData* sp_slot_data = _sspine_lookup_slot_data(skeleton_id.id, slot_index);
     if (sp_slot_data) {
         SOKOL_ASSERT(sp_slot_data->index == slot_index);
         SOKOL_ASSERT(sp_slot_data->name);
@@ -4269,7 +4272,7 @@ SOKOL_API_IMPL sspine_slot_info sspine_get_slot_info(sspine_skeleton skeleton_id
         res.name = sp_slot_data->name;
         res.index = sp_slot_data->index;
         res.attachment_name = sp_slot_data->attachmentName;
-        res.bone_index = sp_slot_data->boneData->index;
+        res.bone = _sspine_bone(skeleton_id.id, sp_slot_data->boneData->index);
         res.color.r = sp_slot_data->color.r;
         res.color.g = sp_slot_data->color.g;
         res.color.b = sp_slot_data->color.b;
@@ -4346,7 +4349,7 @@ SOKOL_API_IMPL sspine_event_info sspine_get_event_info(sspine_skeleton skeleton_
     SOKOL_ASSERT(_SSPINE_INIT_COOKIE == _sspine.init_cookie);
     sspine_event_info res;
     _sspine_clear(&res, sizeof(res));
-    spEventData* sp_event_data = _sspine_lookup_event_data(skeleton_id.id, event_index);
+    const spEventData* sp_event_data = _sspine_lookup_event_data(skeleton_id.id, event_index);
     if (sp_event_data) {
         res.valid = true;
         res.name = sp_event_data->name;
@@ -4404,12 +4407,12 @@ SOKOL_API_IMPL sspine_iktarget_info sspine_get_iktarget_info(sspine_skeleton ske
     SOKOL_ASSERT(_SSPINE_INIT_COOKIE == _sspine.init_cookie);
     sspine_iktarget_info res;
     _sspine_clear(&res, sizeof(res));
-    spIkConstraintData* ik_data = _sspine_lookup_ikconstraint_data(skeleton_id.id, iktarget_index);
+    const spIkConstraintData* ik_data = _sspine_lookup_ikconstraint_data(skeleton_id.id, iktarget_index);
     if (ik_data) {
         res.valid = true;
         res.name = ik_data->name;
         res.index = iktarget_index;
-        res.target_bone_index = ik_data->target->index;
+        res.target_bone = _sspine_bone(skeleton_id.id, ik_data->target->index);
     }
     return res;
 }
@@ -4469,7 +4472,7 @@ SOKOL_API_IMPL sspine_skin_info sspine_get_skin_info(sspine_skeleton skeleton_id
     SOKOL_ASSERT(_SSPINE_INIT_COOKIE == _sspine.init_cookie);
     sspine_skin_info res;
     _sspine_clear(&res, sizeof(res));
-    spSkin* skin = _sspine_lookup_skin(skeleton_id.id, skin_index);
+    const spSkin* skin = _sspine_lookup_skin(skeleton_id.id, skin_index);
     if (skin) {
         res.valid = true;
         res.index = skin_index;