sokol_spine.h: change bone access functions to use instance + index

2 files changed, 119 insertions, 169 deletions

diff --git a/tests/functional/sokol_spine_test.c b/tests/functional/sokol_spine_test.c
index 19edd5e5..27b59ee3 100644
--- a/tests/functional/sokol_spine_test.c
+++ b/tests/functional/sokol_spine_test.c
@@ -60,12 +60,6 @@ static sspine_skeleton create_skeleton_json(sspine_atlas atlas) {
     return skeleton;
 }
 
-static sspine_instance create_instance() {
-    return sspine_make_instance(&(sspine_instance_desc){
-        .skeleton = create_skeleton_json(create_atlas()),
-    });
-}
-
 static sspine_skeleton create_skeleton_binary(sspine_atlas atlas) {
     sspine_range skeleton_binary_data = load_data("spineboy-pro.skel");
     sspine_skeleton skeleton = sspine_make_skeleton(&(sspine_skeleton_desc){
@@ -76,6 +70,16 @@ static sspine_skeleton create_skeleton_binary(sspine_atlas atlas) {
     return skeleton;
 }
 
+static sspine_skeleton create_skeleton(void) {
+    return create_skeleton_json(create_atlas());
+}
+
+static sspine_instance create_instance(void) {
+    return sspine_make_instance(&(sspine_instance_desc){
+        .skeleton = create_skeleton(),
+    });
+}
+
 UTEST(sokol_spine, default_init_shutdown) {
     // FIXME!
     T(true);
@@ -603,76 +607,40 @@ UTEST(sokol_spine, atlas_get_atlas_page_info_with_overrides) {
     shutdown();
 }
 
-UTEST(sokol_spine, find_bone) {
-    init();
-    sspine_instance instance = create_instance();
-    sspine_bone b0 = sspine_find_bone(instance, "crosshair");
-    T(b0.instance.id == instance.id);
-    T(b0.index == 2);
-    sspine_bone b1 = sspine_find_bone(instance, "blablub");
-    T(b1.instance.id == SSPINE_INVALID_ID);
-    T(b1.index == 0);
-    shutdown();
-}
-
-UTEST(sokol_spine, find_bone_destroyed_instance) {
+UTEST(sokol_spine, find_bone_index) {
     init();
-    sspine_instance instance = create_instance();
-    sspine_destroy_instance(instance);
-    sspine_bone b0 = sspine_find_bone(instance, "crosshair");
-    T(b0.instance.id == SSPINE_INVALID_ID);
-    T(b0.index == 0);
+    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);
     shutdown();
 }
 
-UTEST(sokol_spine, bone_valid) {
+UTEST(sokol_spine, find_bone_index_destroyed_skeleton) {
     init();
-    sspine_instance instance = create_instance();
-    sspine_bone b0 = sspine_find_bone(instance, "crosshair");
-    T(sspine_bone_valid(b0));
-    sspine_bone b1 = sspine_find_bone(instance, "blablub");
-    T(!sspine_bone_valid(b1));
-    sspine_destroy_instance(instance);
-    sspine_bone b2 = sspine_find_bone(instance, "crosshair");
-    T(!sspine_bone_valid(b2));
+    sspine_skeleton skeleton = create_skeleton();
+    sspine_destroy_skeleton(skeleton);
+    int b0 = sspine_find_bone_index(skeleton, "crosshair");
+    T(b0 == -1);
     shutdown();
 }
 
 UTEST(sokol_spine, num_bones) {
     init();
-    sspine_instance instance = create_instance();
-    T(sspine_num_bones(instance) == 67);
-    sspine_destroy_instance(instance);
-    T(sspine_num_bones(instance) == 0);
-    shutdown();
-}
-
-UTEST(sokol_spine, bone_at) {
-    init();
-    sspine_instance instance = create_instance();
-    sspine_bone b0 = sspine_bone_at(instance, 0);
-    T(b0.instance.id == instance.id);
-    T(b0.index == 0);
-    sspine_bone b1 = sspine_bone_at(instance, -1);
-    T(b1.instance.id == SSPINE_INVALID_ID);
-    T(b1.index == 0);
-    sspine_bone b2 = sspine_bone_at(instance, 23);
-    T(b2.instance.id == instance.id);
-    T(b2.index == 23);
-    sspine_bone b3 = sspine_bone_at(instance, 67);
-    T(b3.instance.id == SSPINE_INVALID_ID);
-    T(b3.index == 0);
-    sspine_bone b4 = sspine_bone_at(instance, 66);
-    T(b4.instance.id == instance.id);
-    T(b4.index == 66);
+    sspine_skeleton skeleton = create_skeleton();
+    T(sspine_num_bones(skeleton) == 67);
+    sspine_destroy_skeleton(skeleton);
+    T(sspine_num_bones(skeleton) == 0);
     shutdown();
 }
 
 UTEST(sokol_spine, get_bone_info) {
     init();
     sspine_instance instance = create_instance();
-    sspine_bone bone = sspine_find_bone(instance, "root");
-    const sspine_bone_info info = sspine_get_bone_info(bone);
+    sspine_skeleton skeleton = sspine_get_instance_skeleton(instance);
+    int bone_index = sspine_find_bone_index(skeleton, "root");
+    const sspine_bone_info info = sspine_get_bone_info(instance, bone_index);
     T(info.index == 0);
     T(strcmp(info.name, "root") == 0);
     T(info.length == 0.0f);
@@ -689,9 +657,10 @@ UTEST(sokol_spine, get_bone_info) {
 UTEST(sokol_spine, get_bone_info_destroyed_instance) {
     init();
     sspine_instance instance = create_instance();
-    sspine_bone bone = sspine_find_bone(instance, "root");
+    sspine_skeleton skeleton = sspine_get_instance_skeleton(instance);
+    int bone_index = sspine_find_bone_index(skeleton, "root");
     sspine_destroy_instance(instance);
-    const sspine_bone_info info = sspine_get_bone_info(bone);
+    const sspine_bone_info info = sspine_get_bone_info(instance, bone_index);
     T(info.name == 0);
     shutdown();
 }
@@ -699,14 +668,15 @@ UTEST(sokol_spine, get_bone_info_destroyed_instance) {
 UTEST(sokol_spine, set_get_bone_transform) {
     init();
     sspine_instance instance = create_instance();
-    sspine_bone bone = sspine_find_bone(instance, "root");
-    sspine_set_bone_transform(bone, &(sspine_bone_transform){
+    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){
         .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(bone);
+    const sspine_bone_transform tform = sspine_get_bone_transform(instance, bone_index);
     T(tform.position.x == 1.0f);
     T(tform.position.y == 2.0f);
     T(tform.rotation == 3.0f);
@@ -720,15 +690,16 @@ UTEST(sokol_spine, set_get_bone_transform) {
 UTEST(sokol_spine, set_get_bone_transform_destroyed_instance) {
     init();
     sspine_instance instance = create_instance();
-    sspine_bone bone = sspine_find_bone(instance, "root");
+    sspine_skeleton skeleton = sspine_get_instance_skeleton(instance);
+    int bone_index = sspine_find_bone_index(skeleton, "root");
     sspine_destroy_instance(instance);
-    sspine_set_bone_transform(bone, &(sspine_bone_transform){
+    sspine_set_bone_transform(instance, bone_index, &(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(bone);
+    const sspine_bone_transform tform = sspine_get_bone_transform(instance, bone_index);
     T(tform.position.x == 0.0f);
     T(tform.position.y == 0.0f);
     T(tform.rotation == 0.0f);
@@ -742,13 +713,14 @@ UTEST(sokol_spine, set_get_bone_transform_destroyed_instance) {
 UTEST(sokol_spine, set_get_bone_position) {
     init();
     sspine_instance instance = create_instance();
-    sspine_bone bone = sspine_find_bone(instance, "root");
-    sspine_set_bone_position(bone, (sspine_vec2){ 1.0f, 2.0f });
-    const sspine_vec2 p0 = sspine_get_bone_position(bone);
+    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);
     T(p0.x == 1.0f);
     T(p0.y == 2.0f);
     sspine_destroy_instance(instance);
-    const sspine_vec2 p1 = sspine_get_bone_position(bone);
+    const sspine_vec2 p1 = sspine_get_bone_position(instance, bone_index);
     T(p1.x == 0.0f);
     T(p1.y == 0.0f);
     shutdown();
@@ -757,24 +729,26 @@ UTEST(sokol_spine, set_get_bone_position) {
 UTEST(sokol_spine, set_get_bone_rotation) {
     init();
     sspine_instance instance = create_instance();
-    sspine_bone bone = sspine_find_bone(instance, "root");
-    sspine_set_bone_rotation(bone, 5.0f);
-    T(sspine_get_bone_rotation(bone) == 5.0f);
+    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_destroy_instance(instance);
-    T(sspine_get_bone_rotation(bone) == 0.0f);
+    T(sspine_get_bone_rotation(instance, bone_index) == 0.0f);
     shutdown();
 }
 
 UTEST(sokol_spine, set_get_bone_scale) {
     init();
     sspine_instance instance = create_instance();
-    sspine_bone bone = sspine_find_bone(instance, "root");
-    sspine_set_bone_scale(bone, (sspine_vec2){ 1.0f, 2.0f });
-    const sspine_vec2 s0 = sspine_get_bone_scale(bone);
+    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);
     T(s0.x == 1.0f);
     T(s0.y == 2.0f);
     sspine_destroy_instance(instance);
-    const sspine_vec2 s1 = sspine_get_bone_scale(bone);
+    const sspine_vec2 s1 = sspine_get_bone_scale(instance, bone_index);
     T(s1.x == 0.0f);
     T(s1.y == 0.0f);
     shutdown();
@@ -783,13 +757,14 @@ UTEST(sokol_spine, set_get_bone_scale) {
 UTEST(sokol_spine, set_get_bone_shear) {
     init();
     sspine_instance instance = create_instance();
-    sspine_bone bone = sspine_find_bone(instance, "root");
-    sspine_set_bone_shear(bone, (sspine_vec2){ 1.0f, 2.0f });
-    const sspine_vec2 s0 = sspine_get_bone_shear(bone);
+    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);
     T(s0.x == 1.0f);
     T(s0.y == 2.0f);
     sspine_destroy_instance(instance);
-    const sspine_vec2 s1 = sspine_get_bone_shear(bone);
+    const sspine_vec2 s1 = sspine_get_bone_shear(instance, bone_index);
     T(s1.x == 0.0f);
     T(s1.y == 0.0f);
     shutdown();
@@ -868,8 +843,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.instance.id == instance.id);
-    T(info.bone.index == 62);
+    T(info.bone_index == 62);
     T(info.color.r == 1.0f);
     T(info.color.g == 1.0f);
     T(info.color.b == 1.0f);
diff --git a/util/sokol_spine.h b/util/sokol_spine.h
index 7f7d22b2..903c6947 100644
--- a/util/sokol_spine.h
+++ b/util/sokol_spine.h
@@ -114,7 +114,6 @@ typedef struct sspine_skeleton { uint32_t id; } sspine_skeleton;
 typedef struct sspine_instance { uint32_t id; } sspine_instance;
 
 typedef struct sspine_atlas_page { sspine_atlas atlas; int index; } sspine_atlas_page;
-typedef struct sspine_bone { sspine_instance instance; int index; } sspine_bone;
 typedef struct sspine_slot { sspine_instance instance; int index; } sspine_slot;
 typedef struct sspine_anim { sspine_instance instance; int index; } sspine_anim;
 
@@ -219,7 +218,7 @@ typedef struct sspine_slot_info {
     const char* name;
     int index;
     const char* attachment_name;
-    sspine_bone bone;
+    int bone_index;
     sspine_color color;
 } sspine_slot_info;
 
@@ -329,21 +328,19 @@ SOKOL_SPINE_API_DECL sspine_atlas_page sspine_atlas_page_at(sspine_atlas atlas,
 SOKOL_SPINE_API_DECL sspine_atlas_page_info sspine_get_atlas_page_info(sspine_atlas_page page);
 
 // bone functions
-SOKOL_SPINE_API_DECL sspine_bone sspine_find_bone(sspine_instance instance, const char* name);
-SOKOL_SPINE_API_DECL bool sspine_bone_valid(sspine_bone bone);
-SOKOL_SPINE_API_DECL int sspine_num_bones(sspine_instance instance);
-SOKOL_SPINE_API_DECL sspine_bone sspine_bone_at(sspine_instance instance, int index);
-SOKOL_SPINE_API_DECL sspine_bone_info sspine_get_bone_info(sspine_bone bone);
-SOKOL_SPINE_API_DECL void sspine_set_bone_transform(sspine_bone bone, const sspine_bone_transform* transform);
-SOKOL_SPINE_API_DECL void sspine_set_bone_position(sspine_bone bone, sspine_vec2 position);
-SOKOL_SPINE_API_DECL void sspine_set_bone_rotation(sspine_bone bone, float rotation);
-SOKOL_SPINE_API_DECL void sspine_set_bone_scale(sspine_bone bone, sspine_vec2 scale);
-SOKOL_SPINE_API_DECL void sspine_set_bone_shear(sspine_bone bone, sspine_vec2 shear);
-SOKOL_SPINE_API_DECL sspine_bone_transform sspine_get_bone_transform(sspine_bone bone);
-SOKOL_SPINE_API_DECL sspine_vec2 sspine_get_bone_position(sspine_bone bone);
-SOKOL_SPINE_API_DECL float sspine_get_bone_rotation(sspine_bone bone);
-SOKOL_SPINE_API_DECL sspine_vec2 sspine_get_bone_scale(sspine_bone bone);
-SOKOL_SPINE_API_DECL sspine_vec2 sspine_get_bone_shear(sspine_bone bone);
+SOKOL_SPINE_API_DECL int sspine_find_bone_index(sspine_skeleton skeleton, const char* name);
+SOKOL_SPINE_API_DECL int sspine_num_bones(sspine_skeleton skeleton);
+SOKOL_SPINE_API_DECL sspine_bone_info sspine_get_bone_info(sspine_instance instance, 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);
 
 // slot functions
 SOKOL_SPINE_API_DECL sspine_slot sspine_find_slot(sspine_instance instance, const char* name);
@@ -2496,6 +2493,10 @@ static _sspine_alloc_indices_result_t _sspine_alloc_indices(_sspine_context_t* c
     return res;
 }
 
+static bool _sspine_skeleton_and_deps_valid(_sspine_skeleton_t* skeleton) {
+    return skeleton && _sspine_atlas_ref_valid(&skeleton->atlas);
+}
+
 static bool _sspine_instance_and_deps_valid(_sspine_instance_t* instance) {
     return instance && _sspine_atlas_ref_valid(&instance->atlas) && _sspine_skeleton_ref_valid(&instance->skel);
 }
@@ -2828,12 +2829,12 @@ static spAnimation* _sspine_lookup_anim(sspine_anim anim) {
     return 0;
 }
 
-static spBone* _sspine_lookup_bone(sspine_bone bone) {
-    _sspine_instance_t* instance = _sspine_lookup_instance(bone.instance.id);
+static spBone* _sspine_lookup_bone(uint32_t instance_id, int bone_index) {
+    _sspine_instance_t* instance = _sspine_lookup_instance(instance_id);
     if (_sspine_instance_and_deps_valid(instance)) {
         SOKOL_ASSERT(instance->sp_skel && instance->sp_skel->bones);
-        SOKOL_ASSERT((bone.index >= 0) && (bone.index <= instance->sp_skel->bonesCount));
-        return instance->sp_skel->bones[bone.index];
+        SOKOL_ASSERT((bone_index >= 0) && (bone_index <= instance->sp_skel->bonesCount));
+        return instance->sp_skel->bones[bone_index];
     }
     return 0;
 }
@@ -3425,63 +3426,38 @@ SOKOL_API_IMPL sspine_atlas_page_info sspine_get_atlas_page_info(sspine_atlas_pa
     return res;
 }
 
-SOKOL_API_IMPL sspine_bone sspine_find_bone(sspine_instance instance_id, const char* name) {
+SOKOL_API_IMPL int sspine_find_bone_index(sspine_skeleton skeleton_id, const char* name) {
     SOKOL_ASSERT(_SSPINE_INIT_COOKIE == _sspine.init_cookie);
     SOKOL_ASSERT(name);
-    _sspine_instance_t* instance = _sspine_lookup_instance(instance_id.id);
-    sspine_bone bone;
-    _sspine_clear(&bone, sizeof(bone));
-    if (_sspine_instance_and_deps_valid(instance)) {
-        SOKOL_ASSERT(instance->sp_skel);
-        spBone* sp_bone = spSkeleton_findBone(instance->sp_skel, name);
-        if (sp_bone) {
-            SOKOL_ASSERT(sp_bone->data);
-            bone.instance = instance_id;
-            bone.index = sp_bone->data->index;
+    _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 bone;
+    return -1;
 }
 
-SOKOL_API_IMPL bool sspine_bone_valid(sspine_bone bone) {
+SOKOL_API_IMPL int sspine_num_bones(sspine_skeleton skeleton_id) {
     SOKOL_ASSERT(_SSPINE_INIT_COOKIE == _sspine.init_cookie);
-    return 0 != _sspine_lookup_bone(bone);
-}
-
-
-SOKOL_API_IMPL int sspine_num_bones(sspine_instance instance_id) {
-    SOKOL_ASSERT(_SSPINE_INIT_COOKIE == _sspine.init_cookie);
-    _sspine_instance_t* instance = _sspine_lookup_instance(instance_id.id);
-    if (_sspine_instance_and_deps_valid(instance)) {
-        SOKOL_ASSERT(instance->sp_skel);
-        return instance->sp_skel->bonesCount;
+    _sspine_skeleton_t* skeleton = _sspine_lookup_skeleton(skeleton_id.id);
+    if (_sspine_skeleton_and_deps_valid(skeleton)) {
+        SOKOL_ASSERT(skeleton->sp_skel_data);
+        return skeleton->sp_skel_data->bonesCount;
     }
     return 0;
 }
 
-SOKOL_API_IMPL sspine_bone sspine_bone_at(sspine_instance instance_id, int index) {
-    SOKOL_ASSERT(_SSPINE_INIT_COOKIE == _sspine.init_cookie);
-    sspine_bone bone;
-    _sspine_clear(&bone, sizeof(bone));
-    _sspine_instance_t* instance = _sspine_lookup_instance(instance_id.id);
-    if (_sspine_instance_and_deps_valid(instance)) {
-        SOKOL_ASSERT(instance->sp_skel);
-        if ((index >= 0) && (index < instance->sp_skel->bonesCount)) {
-            bone.instance = instance_id;
-            bone.index = index;
-        }
-    }
-    return bone;
-}
-
-SOKOL_API_IMPL sspine_bone_info sspine_get_bone_info(sspine_bone bone) {
+SOKOL_API_IMPL sspine_bone_info sspine_get_bone_info(sspine_instance instance_id, int bone_index) {
     SOKOL_ASSERT(_SSPINE_INIT_COOKIE == _sspine.init_cookie);
     sspine_bone_info res;
     _sspine_clear(&res, sizeof(res));
-    spBone* sp_bone = _sspine_lookup_bone(bone);
+    spBone* sp_bone = _sspine_lookup_bone(instance_id.id, bone_index);
     if (sp_bone) {
         SOKOL_ASSERT(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.name = sp_bone->data->name;
         res.index = sp_bone->data->index;
@@ -3508,10 +3484,10 @@ SOKOL_API_IMPL sspine_bone_info sspine_get_bone_info(sspine_bone bone) {
     return res;
 }
 
-SOKOL_API_IMPL void sspine_set_bone_transform(sspine_bone bone, const sspine_bone_transform* transform) {
+SOKOL_API_IMPL void sspine_set_bone_transform(sspine_instance instance_id, int bone_index, const sspine_bone_transform* transform) {
     SOKOL_ASSERT(_SSPINE_INIT_COOKIE == _sspine.init_cookie);
     SOKOL_ASSERT(transform);
-    spBone* sp_bone = _sspine_lookup_bone(bone);
+    spBone* sp_bone = _sspine_lookup_bone(instance_id.id, bone_index);
     if (sp_bone) {
         sp_bone->x = transform->position.x;
         sp_bone->y = transform->position.y;
@@ -3523,46 +3499,46 @@ SOKOL_API_IMPL void sspine_set_bone_transform(sspine_bone bone, const sspine_bon
     }
 }
 
-SOKOL_API_IMPL void sspine_set_bone_position(sspine_bone bone, sspine_vec2 position) {
+SOKOL_API_IMPL void sspine_set_bone_position(sspine_instance instance_id, int bone_index, sspine_vec2 position) {
     SOKOL_ASSERT(_SSPINE_INIT_COOKIE == _sspine.init_cookie);
-    spBone* sp_bone = _sspine_lookup_bone(bone);
+    spBone* sp_bone = _sspine_lookup_bone(instance_id.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_bone bone, float rotation) {
+SOKOL_API_IMPL void sspine_set_bone_rotation(sspine_instance instance_id, int bone_index, float rotation) {
     SOKOL_ASSERT(_SSPINE_INIT_COOKIE == _sspine.init_cookie);
-    spBone* sp_bone = _sspine_lookup_bone(bone);
+    spBone* sp_bone = _sspine_lookup_bone(instance_id.id, bone_index);
     if (sp_bone) {
         sp_bone->rotation = rotation;
     }
 }
 
-SOKOL_API_IMPL void sspine_set_bone_scale(sspine_bone bone, sspine_vec2 scale) {
+SOKOL_API_IMPL void sspine_set_bone_scale(sspine_instance instance_id, int bone_index, sspine_vec2 scale) {
     SOKOL_ASSERT(_SSPINE_INIT_COOKIE == _sspine.init_cookie);
-    spBone* sp_bone = _sspine_lookup_bone(bone);
+    spBone* sp_bone = _sspine_lookup_bone(instance_id.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_bone bone, sspine_vec2 shear) {
+SOKOL_API_IMPL void sspine_set_bone_shear(sspine_instance instance_id, int bone_index, sspine_vec2 shear) {
     SOKOL_ASSERT(_SSPINE_INIT_COOKIE == _sspine.init_cookie);
-    spBone* sp_bone = _sspine_lookup_bone(bone);
+    spBone* sp_bone = _sspine_lookup_bone(instance_id.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_bone bone) {
+SOKOL_API_IMPL sspine_bone_transform sspine_get_bone_transform(sspine_instance instance_id, int bone_index) {
     SOKOL_ASSERT(_SSPINE_INIT_COOKIE == _sspine.init_cookie);
     sspine_bone_transform res;
     _sspine_clear(&res, sizeof(res));
-    spBone* sp_bone = _sspine_lookup_bone(bone);
+    spBone* sp_bone = _sspine_lookup_bone(instance_id.id, bone_index);
     if (sp_bone) {
         res.position.x = sp_bone->x;
         res.position.y = sp_bone->y;
@@ -3575,11 +3551,11 @@ SOKOL_API_IMPL sspine_bone_transform sspine_get_bone_transform(sspine_bone bone)
     return res;
 }
 
-SOKOL_API_IMPL sspine_vec2 sspine_get_bone_position(sspine_bone bone) {
+SOKOL_API_IMPL sspine_vec2 sspine_get_bone_position(sspine_instance instance_id, int bone_index) {
     SOKOL_ASSERT(_SSPINE_INIT_COOKIE == _sspine.init_cookie);
     sspine_vec2 res;
     _sspine_clear(&res, sizeof(res));
-    spBone* sp_bone = _sspine_lookup_bone(bone);
+    spBone* sp_bone = _sspine_lookup_bone(instance_id.id, bone_index);
     if (sp_bone) {
         res.x = sp_bone->x;
         res.y = sp_bone->y;
@@ -3587,9 +3563,9 @@ SOKOL_API_IMPL sspine_vec2 sspine_get_bone_position(sspine_bone bone) {
     return res;
 }
 
-SOKOL_API_IMPL float sspine_get_bone_rotation(sspine_bone bone) {
+SOKOL_API_IMPL float sspine_get_bone_rotation(sspine_instance instance_id, int bone_index) {
     SOKOL_ASSERT(_SSPINE_INIT_COOKIE == _sspine.init_cookie);
-    spBone* sp_bone = _sspine_lookup_bone(bone);
+    spBone* sp_bone = _sspine_lookup_bone(instance_id.id, bone_index);
     if (sp_bone) {
         return sp_bone->rotation;
     }
@@ -3598,11 +3574,11 @@ SOKOL_API_IMPL float sspine_get_bone_rotation(sspine_bone bone) {
     }
 }
 
-SOKOL_API_IMPL sspine_vec2 sspine_get_bone_scale(sspine_bone bone) {
+SOKOL_API_IMPL sspine_vec2 sspine_get_bone_scale(sspine_instance instance_id, int bone_index) {
     SOKOL_ASSERT(_SSPINE_INIT_COOKIE == _sspine.init_cookie);
     sspine_vec2 res;
     _sspine_clear(&res, sizeof(res));
-    spBone* sp_bone = _sspine_lookup_bone(bone);
+    spBone* sp_bone = _sspine_lookup_bone(instance_id.id, bone_index);
     if (sp_bone) {
         res.x = sp_bone->scaleX;
         res.y = sp_bone->scaleY;
@@ -3610,11 +3586,11 @@ SOKOL_API_IMPL sspine_vec2 sspine_get_bone_scale(sspine_bone bone) {
     return res;
 }
 
-SOKOL_API_IMPL sspine_vec2 sspine_get_bone_shear(sspine_bone bone) {
+SOKOL_API_IMPL sspine_vec2 sspine_get_bone_shear(sspine_instance instance_id, int bone_index) {
     SOKOL_ASSERT(_SSPINE_INIT_COOKIE == _sspine.init_cookie);
     sspine_vec2 res;
     _sspine_clear(&res, sizeof(res));
-    spBone* sp_bone = _sspine_lookup_bone(bone);
+    spBone* sp_bone = _sspine_lookup_bone(instance_id.id, bone_index);
     if (sp_bone) {
         res.x = sp_bone->shearX;
         res.y = sp_bone->shearY;
@@ -3683,7 +3659,7 @@ SOKOL_API_IMPL sspine_slot_info sspine_get_slot_info(sspine_slot slot) {
         res.name = sp_slot->data->name;
         res.index = sp_slot->data->index;
         res.attachment_name = sp_slot->data->attachmentName;
-        res.bone = sspine_bone_at(slot.instance, sp_slot->data->boneData->index);
+        res.bone_index = sp_slot->data->boneData->index;
         res.color.r = sp_slot->color.r;
         res.color.g = sp_slot->color.g;
         res.color.b = sp_slot->color.b;