From ac7f0654a6eb146a697393f76ff3130c11eb187e Mon Sep 17 00:00:00 2001 From: Mario Zechner Date: Fri, 19 Apr 2024 14:43:00 +0200 Subject: [PATCH] [cpp][flutter] Added spine-lite-cpp, changed spine-flutter to use spine-lite-cpp. --- .gitignore | 1 + formatters/build.gradle | 4 +- spine-cpp/CMakeLists.txt | 3 + spine-cpp/spine-cpp-lite/spine-cpp-light.h | 996 ++++++++++++++++++ .../spine-cpp-lite/spine-cpp-lite.cpp | 19 +- spine-flutter/compile-wasm.sh | 2 +- spine-flutter/ios/Classes/spine_flutter.cpp | 2 +- .../lib/assets/libspine_flutter.wasm | Bin 416281 -> 416477 bytes spine-flutter/macos/Classes/spine_flutter.cpp | 2 +- spine-flutter/setup.sh | 1 + spine-flutter/src/CMakeLists.txt | 17 +- spine-flutter/src/spine_flutter.h | 996 ------------------ 12 files changed, 1020 insertions(+), 1023 deletions(-) create mode 100644 spine-cpp/spine-cpp-lite/spine-cpp-light.h rename spine-flutter/src/spine_flutter.cpp => spine-cpp/spine-cpp-lite/spine-cpp-lite.cpp (99%) delete mode 100644 spine-flutter/src/spine_flutter.h diff --git a/.gitignore b/.gitignore index e45273f58e..4dcf8f5658 100644 --- a/.gitignore +++ b/.gitignore @@ -200,3 +200,4 @@ spine-godot/godot-spine-csharp spine-ue/Plugins/Developer spine-haxe/export spine-godot/example-v4-csharp/.godot +spine-flutter/src/spine-cpp-lite diff --git a/formatters/build.gradle b/formatters/build.gradle index 3cf0946f79..ff7ff04fb3 100644 --- a/formatters/build.gradle +++ b/formatters/build.gradle @@ -30,9 +30,7 @@ spotless { 'spine-ue/**/*.cpp', 'spine-ue/**/*.h', 'spine-godot/spine_godot/*.cpp', - 'spine-godot/spine_godot/*.h', - 'spine-flutter/src/spine_flutter.cpp', - 'spine-flutter/src/spine_flutter.h' + 'spine-godot/spine_godot/*.h' clangFormat("13.0.1").pathToExe("$System.env.CLANGFORMAT").style('file') } diff --git a/spine-cpp/CMakeLists.txt b/spine-cpp/CMakeLists.txt index 96e5a7acb9..29645046d8 100644 --- a/spine-cpp/CMakeLists.txt +++ b/spine-cpp/CMakeLists.txt @@ -14,6 +14,9 @@ file(GLOB SOURCES "spine-cpp/src/**/*.cpp") add_library(spine-cpp STATIC ${SOURCES} ${INCLUDES}) target_include_directories(spine-cpp PUBLIC spine-cpp/include) +add_library(spine-cpp-lite STATIC ${SOURCES} ${INCLUDES} spine-cpp-lite/spine-cpp-lite.cpp) +target_include_directories(spine-cpp-lite PUBLIC spine-cpp/include) + # Install target install(TARGETS spine-cpp EXPORT spine-cpp_TARGETS DESTINATION dist/lib) install(FILES ${INCLUDES} DESTINATION dist/include) diff --git a/spine-cpp/spine-cpp-lite/spine-cpp-light.h b/spine-cpp/spine-cpp-lite/spine-cpp-light.h new file mode 100644 index 0000000000..f1590099c8 --- /dev/null +++ b/spine-cpp/spine-cpp-lite/spine-cpp-light.h @@ -0,0 +1,996 @@ +/****************************************************************************** + * Spine Runtimes License Agreement + * Last updated July 28, 2023. Replaces all prior versions. + * + * Copyright (c) 2013-2023, Esoteric Software LLC + * + * Integration of the Spine Runtimes into software or otherwise creating + * derivative works of the Spine Runtimes is permitted under the terms and + * conditions of Section 2 of the Spine Editor License Agreement: + * http://esotericsoftware.com/spine-editor-license + * + * Otherwise, it is permitted to integrate the Spine Runtimes into software or + * otherwise create derivative works of the Spine Runtimes (collectively, + * "Products"), provided that each user of the Products must obtain their own + * Spine Editor license and redistribution of the Products in any form must + * include this license and copyright notice. + * + * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY + * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY + * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, + * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE + * SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + *****************************************************************************/ + +#ifndef SPINE_FLUTTER +#define SPINE_FLUTTER + +#include + +#ifdef __cplusplus +#if _WIN32 +#define SPINE_FLUTTER_EXPORT extern "C" __declspec(dllexport) +#else +#ifdef __EMSCRIPTEN__ +#define SPINE_FLUTTER_EXPORT extern "C" __attribute__((used)) +#else +#define SPINE_CPP_LITE_EXPORT extern "C" +#endif +#endif +#else +#if _WIN32 +#define SPINE_FLUTTER_EXPORT __declspec(dllexport) +#else +#ifdef __EMSCRIPTEN__ +#define SPINE_FLUTTER_EXPORT __attribute__((used)) +#else +#define SPINE_FLUTTER_EXPORT +#endif +#endif +#endif + +#define SPINE_OPAQUE_TYPE(name) \ + typedef struct name##_wrapper { \ + } name##_wrapper; \ + typedef name##_wrapper *name; + +SPINE_OPAQUE_TYPE(spine_skeleton) +SPINE_OPAQUE_TYPE(spine_skeleton_data) +SPINE_OPAQUE_TYPE(spine_bone) +SPINE_OPAQUE_TYPE(spine_bone_data) +SPINE_OPAQUE_TYPE(spine_slot) +SPINE_OPAQUE_TYPE(spine_slot_data) +SPINE_OPAQUE_TYPE(spine_skin) +SPINE_OPAQUE_TYPE(spine_attachment) +SPINE_OPAQUE_TYPE(spine_region_attachment) +SPINE_OPAQUE_TYPE(spine_vertex_attachment) +SPINE_OPAQUE_TYPE(spine_mesh_attachment) +SPINE_OPAQUE_TYPE(spine_clipping_attachment) +SPINE_OPAQUE_TYPE(spine_bounding_box_attachment) +SPINE_OPAQUE_TYPE(spine_path_attachment) +SPINE_OPAQUE_TYPE(spine_point_attachment) +SPINE_OPAQUE_TYPE(spine_texture_region) +SPINE_OPAQUE_TYPE(spine_sequence) +SPINE_OPAQUE_TYPE(spine_constraint) +SPINE_OPAQUE_TYPE(spine_constraint_data) +SPINE_OPAQUE_TYPE(spine_ik_constraint) +SPINE_OPAQUE_TYPE(spine_ik_constraint_data) +SPINE_OPAQUE_TYPE(spine_transform_constraint) +SPINE_OPAQUE_TYPE(spine_transform_constraint_data) +SPINE_OPAQUE_TYPE(spine_path_constraint) +SPINE_OPAQUE_TYPE(spine_path_constraint_data) +SPINE_OPAQUE_TYPE(spine_physics_constraint) +SPINE_OPAQUE_TYPE(spine_physics_constraint_data) +SPINE_OPAQUE_TYPE(spine_animation_state) +SPINE_OPAQUE_TYPE(spine_animation_state_data) +SPINE_OPAQUE_TYPE(spine_animation_state_events) +SPINE_OPAQUE_TYPE(spine_event) +SPINE_OPAQUE_TYPE(spine_event_data) +SPINE_OPAQUE_TYPE(spine_track_entry) +SPINE_OPAQUE_TYPE(spine_animation) +SPINE_OPAQUE_TYPE(spine_atlas) +SPINE_OPAQUE_TYPE(spine_skeleton_data_result) +SPINE_OPAQUE_TYPE(spine_render_command) +SPINE_OPAQUE_TYPE(spine_bounds) +SPINE_OPAQUE_TYPE(spine_color) +SPINE_OPAQUE_TYPE(spine_vector) +SPINE_OPAQUE_TYPE(spine_skeleton_drawable) +SPINE_OPAQUE_TYPE(spine_skin_entry) +SPINE_OPAQUE_TYPE(spine_skin_entries) + +typedef char utf8; + +typedef enum spine_blend_mode { + SPINE_BLEND_MODE_NORMAL = 0, + SPINE_BLEND_MODE_ADDITIVE, + SPINE_BLEND_MODE_MULTIPLY, + SPINE_BLEND_MODE_SCREEN +} spine_blend_mode; + +typedef enum spine_mix_blend { + SPINE_MIX_BLEND_SETUP = 0, + SPINE_MIX_BLEND_FIRST, + SPINE_MIX_BLEND_REPLACE, + SPINE_MIX_BLEND_ADD +} spine_mix_blend; + +typedef enum spine_event_type { + SPINE_EVENT_TYPE_START = 0, + SPINE_EVENT_TYPE_INTERRUPT, + SPINE_EVENT_TYPE_END, + SPINE_EVENT_TYPE_COMPLETE, + SPINE_EVENT_TYPE_DISPOSE, + SPINE_EVENT_TYPE_EVENT +} spine_event_type; + +typedef enum spine_attachment_type { + SPINE_ATTACHMENT_REGION = 0, + SPINE_ATTACHMENT_MESH, + SPINE_ATTACHMENT_CLIPPING, + SPINE_ATTACHMENT_BOUNDING_BOX, + SPINE_ATTACHMENT_PATH, + SPINE_ATTACHMENT_POINT, +} spine_attachment_type; + +typedef enum spine_constraint_type { + SPINE_CONSTRAINT_IK, + SPINE_CONSTRAINT_TRANSFORM, + SPINE_CONSTRAINT_PATH +} spine_constraint_type; + +typedef enum spine_inherit { + SPINE_INHERIT_NORMAL = 0, + SPINE_INHERIT_ONLY_TRANSLATION, + SPINE_INHERIT_NO_ROTATION_OR_REFLECTION, + SPINE_INHERIT_NO_SCALE, + SPINE_INHERIT_NO_SCALE_OR_REFLECTION +} spine_inherit; + +typedef enum spine_position_mode { + SPINE_POSITION_MODE_FIXED = 0, + SPINE_POSITION_MODE_PERCENT +} spine_position_mode; + +typedef enum spine_spacing_mode { + SPINE_SPACING_MODE_LENGTH = 0, + SPINE_SPACING_MODE_FIXED, + SPINE_SPACING_MODE_PERCENT, + SPINE_SPACING_MODE_PROPORTIONAL +} spine_spacing_mode; + +typedef enum spine_rotate_mode { + SPINE_ROTATE_MODE_TANGENT = 0, + SPINE_ROTATE_MODE_CHAIN, + SPINE_ROTATE_MODE_CHAIN_SCALE +} spine_rotate_mode; + +typedef enum spine_physics { + SPINE_PHYSICS_NONE = 0, + SPINE_PHYSICS_RESET, + SPINE_PHYSICS_UPDATE, + SPINE_PHYSICS_POSE + +} spine_physics; + +SPINE_CPP_LITE_EXPORT int32_t spine_major_version(); +SPINE_CPP_LITE_EXPORT int32_t spine_minor_version(); +SPINE_CPP_LITE_EXPORT void spine_enable_debug_extension(int32_t enable); +SPINE_CPP_LITE_EXPORT void spine_report_leaks(); + +SPINE_CPP_LITE_EXPORT float spine_color_get_r(spine_color color); +SPINE_CPP_LITE_EXPORT float spine_color_get_g(spine_color color); +SPINE_CPP_LITE_EXPORT float spine_color_get_b(spine_color color); +SPINE_CPP_LITE_EXPORT float spine_color_get_a(spine_color color); + +SPINE_CPP_LITE_EXPORT float spine_bounds_get_x(spine_bounds bounds); +SPINE_CPP_LITE_EXPORT float spine_bounds_get_y(spine_bounds bounds); +SPINE_CPP_LITE_EXPORT float spine_bounds_get_width(spine_bounds bounds); +SPINE_CPP_LITE_EXPORT float spine_bounds_get_height(spine_bounds bounds); + +SPINE_CPP_LITE_EXPORT float spine_vector_get_x(spine_vector vector); +SPINE_CPP_LITE_EXPORT float spine_vector_get_y(spine_vector vector); + +SPINE_CPP_LITE_EXPORT spine_atlas spine_atlas_load(const utf8 *atlasData); +SPINE_CPP_LITE_EXPORT int32_t spine_atlas_get_num_image_paths(spine_atlas atlas); +SPINE_CPP_LITE_EXPORT utf8 *spine_atlas_get_image_path(spine_atlas atlas, int32_t index); +SPINE_CPP_LITE_EXPORT utf8 *spine_atlas_get_error(spine_atlas atlas); +SPINE_CPP_LITE_EXPORT void spine_atlas_dispose(spine_atlas atlas); + +SPINE_CPP_LITE_EXPORT spine_skeleton_data_result spine_skeleton_data_load_json(spine_atlas atlas, const utf8 *skeletonData); +SPINE_CPP_LITE_EXPORT spine_skeleton_data_result spine_skeleton_data_load_binary(spine_atlas atlas, const uint8_t *skeletonData, int32_t length); +SPINE_CPP_LITE_EXPORT utf8 *spine_skeleton_data_result_get_error(spine_skeleton_data_result result); +SPINE_CPP_LITE_EXPORT spine_skeleton_data spine_skeleton_data_result_get_data(spine_skeleton_data_result result); +SPINE_CPP_LITE_EXPORT void spine_skeleton_data_result_dispose(spine_skeleton_data_result result); +SPINE_CPP_LITE_EXPORT spine_bone_data spine_skeleton_data_find_bone(spine_skeleton_data data, const utf8 *name); +SPINE_CPP_LITE_EXPORT spine_slot_data spine_skeleton_data_find_slot(spine_skeleton_data data, const utf8 *name); +SPINE_CPP_LITE_EXPORT spine_skin spine_skeleton_data_find_skin(spine_skeleton_data data, const utf8 *name); +SPINE_CPP_LITE_EXPORT spine_event_data spine_skeleton_data_find_event(spine_skeleton_data data, const utf8 *name); +SPINE_CPP_LITE_EXPORT spine_animation spine_skeleton_data_find_animation(spine_skeleton_data data, const utf8 *name); +SPINE_CPP_LITE_EXPORT spine_ik_constraint_data spine_skeleton_data_find_ik_constraint(spine_skeleton_data data, const utf8 *name); +SPINE_CPP_LITE_EXPORT spine_transform_constraint_data spine_skeleton_data_find_transform_constraint(spine_skeleton_data data, const utf8 *name); +SPINE_CPP_LITE_EXPORT spine_path_constraint_data spine_skeleton_data_find_path_constraint(spine_skeleton_data data, const utf8 *name); +SPINE_CPP_LITE_EXPORT spine_physics_constraint_data spine_skeleton_data_find_physics_constraint(spine_skeleton_data data, const utf8 *name); +SPINE_CPP_LITE_EXPORT const utf8 *spine_skeleton_data_get_name(spine_skeleton_data data); +// OMITTED setName() +SPINE_CPP_LITE_EXPORT int32_t spine_skeleton_data_get_num_bones(spine_skeleton_data data); +SPINE_CPP_LITE_EXPORT spine_bone_data *spine_skeleton_data_get_bones(spine_skeleton_data data); +SPINE_CPP_LITE_EXPORT int32_t spine_skeleton_data_get_num_slots(spine_skeleton_data data); +SPINE_CPP_LITE_EXPORT spine_slot_data *spine_skeleton_data_get_slots(spine_skeleton_data data); +SPINE_CPP_LITE_EXPORT int32_t spine_skeleton_data_get_num_skins(spine_skeleton_data data); +SPINE_CPP_LITE_EXPORT spine_skin *spine_skeleton_data_get_skins(spine_skeleton_data data); +SPINE_CPP_LITE_EXPORT spine_skin spine_skeleton_data_get_default_skin(spine_skeleton_data data); +SPINE_CPP_LITE_EXPORT void spine_skeleton_data_set_default_skin(spine_skeleton_data data, spine_skin skin); +SPINE_CPP_LITE_EXPORT int32_t spine_skeleton_data_get_num_events(spine_skeleton_data data); +SPINE_CPP_LITE_EXPORT spine_event_data *spine_skeleton_data_get_events(spine_skeleton_data data); +SPINE_CPP_LITE_EXPORT int32_t spine_skeleton_data_get_num_animations(spine_skeleton_data data); +SPINE_CPP_LITE_EXPORT spine_animation *spine_skeleton_data_get_animations(spine_skeleton_data data); +SPINE_CPP_LITE_EXPORT int32_t spine_skeleton_data_get_num_ik_constraints(spine_skeleton_data data); +SPINE_CPP_LITE_EXPORT spine_ik_constraint_data *spine_skeleton_data_get_ik_constraints(spine_skeleton_data data); +SPINE_CPP_LITE_EXPORT int32_t spine_skeleton_data_get_num_transform_constraints(spine_skeleton_data data); +SPINE_CPP_LITE_EXPORT spine_transform_constraint_data *spine_skeleton_data_get_transform_constraints(spine_skeleton_data data); +SPINE_CPP_LITE_EXPORT int32_t spine_skeleton_data_get_num_path_constraints(spine_skeleton_data data); +SPINE_CPP_LITE_EXPORT spine_path_constraint_data *spine_skeleton_data_get_path_constraints(spine_skeleton_data data); +SPINE_CPP_LITE_EXPORT int32_t spine_skeleton_data_get_num_physics_constraints(spine_skeleton_data data); +SPINE_CPP_LITE_EXPORT spine_physics_constraint_data *spine_skeleton_data_get_physics_constraints(spine_skeleton_data data); +SPINE_CPP_LITE_EXPORT float spine_skeleton_data_get_x(spine_skeleton_data data); +SPINE_CPP_LITE_EXPORT void spine_skeleton_data_set_x(spine_skeleton_data data, float x); +SPINE_CPP_LITE_EXPORT float spine_skeleton_data_get_y(spine_skeleton_data data); +SPINE_CPP_LITE_EXPORT void spine_skeleton_data_set_y(spine_skeleton_data data, float y); +SPINE_CPP_LITE_EXPORT float spine_skeleton_data_get_width(spine_skeleton_data data); +SPINE_CPP_LITE_EXPORT void spine_skeleton_data_set_width(spine_skeleton_data data, float width); +SPINE_CPP_LITE_EXPORT float spine_skeleton_data_get_height(spine_skeleton_data data); +SPINE_CPP_LITE_EXPORT void spine_skeleton_data_set_height(spine_skeleton_data data, float height); +SPINE_CPP_LITE_EXPORT const utf8 *spine_skeleton_data_get_version(spine_skeleton_data data); +// OMITTED setVersion() +SPINE_CPP_LITE_EXPORT const utf8 *spine_skeleton_data_get_hash(spine_skeleton_data data); +// OMITTED setHash() +SPINE_CPP_LITE_EXPORT const utf8 *spine_skeleton_data_get_images_path(spine_skeleton_data data); +// OMITTED setImagesPath() +SPINE_CPP_LITE_EXPORT const utf8 *spine_skeleton_data_get_audio_path(spine_skeleton_data data); +// OMITTED setAudioPath() +SPINE_CPP_LITE_EXPORT float spine_skeleton_data_get_fps(spine_skeleton_data data); +// OMITTED setFps() +SPINE_CPP_LITE_EXPORT float spine_skeleton_data_get_reference_scale(spine_skeleton_data data); +SPINE_CPP_LITE_EXPORT void spine_skeleton_data_dispose(spine_skeleton_data data); + +SPINE_CPP_LITE_EXPORT spine_skeleton_drawable spine_skeleton_drawable_create(spine_skeleton_data skeletonData); +SPINE_CPP_LITE_EXPORT spine_render_command spine_skeleton_drawable_render(spine_skeleton_drawable drawable); +SPINE_CPP_LITE_EXPORT void spine_skeleton_drawable_dispose(spine_skeleton_drawable drawable); +SPINE_CPP_LITE_EXPORT spine_skeleton spine_skeleton_drawable_get_skeleton(spine_skeleton_drawable drawable); +SPINE_CPP_LITE_EXPORT spine_animation_state spine_skeleton_drawable_get_animation_state(spine_skeleton_drawable drawable); +SPINE_CPP_LITE_EXPORT spine_animation_state_data spine_skeleton_drawable_get_animation_state_data(spine_skeleton_drawable drawable); +SPINE_CPP_LITE_EXPORT spine_animation_state_events spine_skeleton_drawable_get_animation_state_events(spine_skeleton_drawable drawable); + +SPINE_CPP_LITE_EXPORT float *spine_render_command_get_positions(spine_render_command command); +SPINE_CPP_LITE_EXPORT float *spine_render_command_get_uvs(spine_render_command command); +SPINE_CPP_LITE_EXPORT int32_t *spine_render_command_get_colors(spine_render_command command); +SPINE_CPP_LITE_EXPORT int32_t spine_render_command_get_num_vertices(spine_render_command command); +SPINE_CPP_LITE_EXPORT uint16_t *spine_render_command_get_indices(spine_render_command command); +SPINE_CPP_LITE_EXPORT int32_t spine_render_command_get_num_indices(spine_render_command command); +SPINE_CPP_LITE_EXPORT int32_t spine_render_command_get_atlas_page(spine_render_command command); +SPINE_CPP_LITE_EXPORT spine_blend_mode spine_render_command_get_blend_mode(spine_render_command command); +SPINE_CPP_LITE_EXPORT spine_render_command spine_render_command_get_next(spine_render_command command); + +SPINE_CPP_LITE_EXPORT const utf8 *spine_animation_get_name(spine_animation animation); +// OMITTED getTimelines() +// OMITTED hasTimeline() +SPINE_CPP_LITE_EXPORT float spine_animation_get_duration(spine_animation animation); +// OMITTED setDuration() + +SPINE_CPP_LITE_EXPORT spine_skeleton_data spine_animation_state_data_get_skeleton_data(spine_animation_state_data stateData); +SPINE_CPP_LITE_EXPORT float spine_animation_state_data_get_default_mix(spine_animation_state_data stateData); +SPINE_CPP_LITE_EXPORT void spine_animation_state_data_set_default_mix(spine_animation_state_data stateData, float defaultMix); +SPINE_CPP_LITE_EXPORT void spine_animation_state_data_set_mix(spine_animation_state_data stateData, spine_animation from, spine_animation to, float duration); +SPINE_CPP_LITE_EXPORT float spine_animation_state_data_get_mix(spine_animation_state_data stateData, spine_animation from, spine_animation to); +SPINE_CPP_LITE_EXPORT void spine_animation_state_data_set_mix_by_name(spine_animation_state_data stateData, const utf8 *fromName, const utf8 *toName, float duration); +SPINE_CPP_LITE_EXPORT float spine_animation_state_data_get_mix_by_name(spine_animation_state_data stateData, const utf8 *fromName, const utf8 *toName); +SPINE_CPP_LITE_EXPORT void spine_animation_state_data_clear(spine_animation_state_data stateData); + +SPINE_CPP_LITE_EXPORT void spine_animation_state_update(spine_animation_state state, float delta); +SPINE_CPP_LITE_EXPORT void spine_animation_state_apply(spine_animation_state state, spine_skeleton skeleton); +SPINE_CPP_LITE_EXPORT void spine_animation_state_clear_tracks(spine_animation_state state); +SPINE_CPP_LITE_EXPORT void spine_animation_state_clear_track(spine_animation_state state, int32_t trackIndex); +SPINE_CPP_LITE_EXPORT int32_t spine_animation_state_get_num_tracks(spine_animation_state state); +SPINE_CPP_LITE_EXPORT spine_track_entry spine_animation_state_set_animation_by_name(spine_animation_state state, int32_t trackIndex, const utf8 *animationName, int32_t loop); +SPINE_CPP_LITE_EXPORT spine_track_entry spine_animation_state_set_animation(spine_animation_state state, int32_t trackIndex, spine_animation animation, int32_t loop); +SPINE_CPP_LITE_EXPORT spine_track_entry spine_animation_state_add_animation_by_name(spine_animation_state state, int32_t trackIndex, const utf8 *animationName, int32_t loop, float delay); +SPINE_CPP_LITE_EXPORT spine_track_entry spine_animation_state_add_animation(spine_animation_state state, int32_t trackIndex, spine_animation animation, int32_t loop, float delay); +SPINE_CPP_LITE_EXPORT spine_track_entry spine_animation_state_set_empty_animation(spine_animation_state state, int32_t trackIndex, float mixDuration); +SPINE_CPP_LITE_EXPORT spine_track_entry spine_animation_state_add_empty_animation(spine_animation_state state, int32_t trackIndex, float mixDuration, float delay); +SPINE_CPP_LITE_EXPORT void spine_animation_state_set_empty_animations(spine_animation_state state, float mixDuration); +SPINE_CPP_LITE_EXPORT spine_track_entry spine_animation_state_get_current(spine_animation_state state, int32_t trackIndex); +SPINE_CPP_LITE_EXPORT spine_animation_state_data spine_animation_state_get_data(spine_animation_state state); +SPINE_CPP_LITE_EXPORT float spine_animation_state_get_time_scale(spine_animation_state state); +SPINE_CPP_LITE_EXPORT void spine_animation_state_set_time_scale(spine_animation_state state, float timeScale); +// OMITTED setListener() +// OMITTED setListener() +// OMITTED disableQueue() +// OMITTED enableQueue() +// OMITTED setManualTrackEntryDisposal() +// OMITTED getManualTrackEntryDisposal() +SPINE_CPP_LITE_EXPORT void spine_animation_state_dispose_track_entry(spine_animation_state state, spine_track_entry entry); + +SPINE_CPP_LITE_EXPORT int32_t spine_animation_state_events_get_num_events(spine_animation_state_events events); +SPINE_CPP_LITE_EXPORT spine_event_type spine_animation_state_events_get_event_type(spine_animation_state_events events, int32_t index); +SPINE_CPP_LITE_EXPORT spine_track_entry spine_animation_state_events_get_track_entry(spine_animation_state_events events, int32_t index); +SPINE_CPP_LITE_EXPORT spine_event spine_animation_state_events_get_event(spine_animation_state_events events, int32_t index); +SPINE_CPP_LITE_EXPORT void spine_animation_state_events_reset(spine_animation_state_events events); + +SPINE_CPP_LITE_EXPORT int32_t spine_track_entry_get_track_index(spine_track_entry entry); +SPINE_CPP_LITE_EXPORT spine_animation spine_track_entry_get_animation(spine_track_entry entry); +SPINE_CPP_LITE_EXPORT spine_track_entry spine_track_entry_get_previous(spine_track_entry entry); +SPINE_CPP_LITE_EXPORT int32_t spine_track_entry_get_loop(spine_track_entry entry); +SPINE_CPP_LITE_EXPORT void spine_track_entry_set_loop(spine_track_entry entry, int32_t loop); +SPINE_CPP_LITE_EXPORT int32_t spine_track_entry_get_hold_previous(spine_track_entry entry); +SPINE_CPP_LITE_EXPORT void spine_track_entry_set_hold_previous(spine_track_entry entry, int32_t holdPrevious); +SPINE_CPP_LITE_EXPORT int32_t spine_track_entry_get_reverse(spine_track_entry entry); +SPINE_CPP_LITE_EXPORT void spine_track_entry_set_reverse(spine_track_entry entry, int32_t reverse); +SPINE_CPP_LITE_EXPORT int32_t spine_track_entry_get_shortest_rotation(spine_track_entry entry); +SPINE_CPP_LITE_EXPORT void spine_track_entry_set_shortest_rotation(spine_track_entry entry, int32_t shortestRotation); +SPINE_CPP_LITE_EXPORT float spine_track_entry_get_delay(spine_track_entry entry); +SPINE_CPP_LITE_EXPORT void spine_track_entry_set_delay(spine_track_entry entry, float delay); +SPINE_CPP_LITE_EXPORT float spine_track_entry_get_track_time(spine_track_entry entry); +SPINE_CPP_LITE_EXPORT void spine_track_entry_set_track_time(spine_track_entry entry, float trackTime); +SPINE_CPP_LITE_EXPORT float spine_track_entry_get_track_end(spine_track_entry entry); +SPINE_CPP_LITE_EXPORT void spine_track_entry_set_track_end(spine_track_entry entry, float trackEnd); +SPINE_CPP_LITE_EXPORT float spine_track_entry_get_animation_start(spine_track_entry entry); +SPINE_CPP_LITE_EXPORT void spine_track_entry_set_animation_start(spine_track_entry entry, float animationStart); +SPINE_CPP_LITE_EXPORT float spine_track_entry_get_animation_end(spine_track_entry entry); +SPINE_CPP_LITE_EXPORT void spine_track_entry_set_animation_end(spine_track_entry entry, float animationEnd); +SPINE_CPP_LITE_EXPORT float spine_track_entry_get_animation_last(spine_track_entry entry); +SPINE_CPP_LITE_EXPORT void spine_track_entry_set_animation_last(spine_track_entry entry, float animationLast); +SPINE_CPP_LITE_EXPORT float spine_track_entry_get_animation_time(spine_track_entry entry); +SPINE_CPP_LITE_EXPORT float spine_track_entry_get_time_scale(spine_track_entry entry); +SPINE_CPP_LITE_EXPORT void spine_track_entry_set_time_scale(spine_track_entry entry, float timeScale); +SPINE_CPP_LITE_EXPORT float spine_track_entry_get_alpha(spine_track_entry entry); +SPINE_CPP_LITE_EXPORT void spine_track_entry_set_alpha(spine_track_entry entry, float alpha); +SPINE_CPP_LITE_EXPORT float spine_track_entry_get_event_threshold(spine_track_entry entry); +SPINE_CPP_LITE_EXPORT void spine_track_entry_set_event_threshold(spine_track_entry entry, float eventThreshold); +SPINE_CPP_LITE_EXPORT float spine_track_entry_get_alpha_attachment_threshold(spine_track_entry entry); +SPINE_CPP_LITE_EXPORT void spine_track_entry_set_alpha_attachment_threshold(spine_track_entry entry, float attachmentThreshold); +SPINE_CPP_LITE_EXPORT float spine_track_entry_get_mix_attachment_threshold(spine_track_entry entry); +SPINE_CPP_LITE_EXPORT void spine_track_entry_set_mix_attachment_threshold(spine_track_entry entry, float attachmentThreshold); +SPINE_CPP_LITE_EXPORT float spine_track_entry_get_mix_draw_order_threshold(spine_track_entry entry); +SPINE_CPP_LITE_EXPORT void spine_track_entry_set_mix_draw_order_threshold(spine_track_entry entry, float drawOrderThreshold); +SPINE_CPP_LITE_EXPORT spine_track_entry spine_track_entry_get_next(spine_track_entry entry); +SPINE_CPP_LITE_EXPORT int32_t spine_track_entry_is_complete(spine_track_entry entry); +SPINE_CPP_LITE_EXPORT float spine_track_entry_get_mix_time(spine_track_entry entry); +SPINE_CPP_LITE_EXPORT void spine_track_entry_set_mix_time(spine_track_entry entry, float mixTime); +SPINE_CPP_LITE_EXPORT float spine_track_entry_get_mix_duration(spine_track_entry entry); +SPINE_CPP_LITE_EXPORT void spine_track_entry_set_mix_duration(spine_track_entry entry, float mixDuration); +SPINE_CPP_LITE_EXPORT spine_mix_blend spine_track_entry_get_mix_blend(spine_track_entry entry); +SPINE_CPP_LITE_EXPORT void spine_track_entry_set_mix_blend(spine_track_entry entry, spine_mix_blend mixBlend); +SPINE_CPP_LITE_EXPORT spine_track_entry spine_track_entry_get_mixing_from(spine_track_entry entry); +SPINE_CPP_LITE_EXPORT spine_track_entry spine_track_entry_get_mixing_to(spine_track_entry entry); +SPINE_CPP_LITE_EXPORT void spine_track_entry_reset_rotation_directions(spine_track_entry entry); +SPINE_CPP_LITE_EXPORT float spine_track_entry_get_track_complete(spine_track_entry entry); +// OMITTED setListener() +// OMITTED setListener() + +SPINE_CPP_LITE_EXPORT void spine_skeleton_update_cache(spine_skeleton skeleton); +// OMITTED printUpdateCache() +SPINE_CPP_LITE_EXPORT void spine_skeleton_update_world_transform(spine_skeleton skeleton, spine_physics physics); +SPINE_CPP_LITE_EXPORT void spine_skeleton_update_world_transform_bone(spine_skeleton skeleton, spine_physics physics, spine_bone parent); +SPINE_CPP_LITE_EXPORT void spine_skeleton_set_to_setup_pose(spine_skeleton skeleton); +SPINE_CPP_LITE_EXPORT void spine_skeleton_set_bones_to_setup_pose(spine_skeleton skeleton); +SPINE_CPP_LITE_EXPORT void spine_skeleton_set_slots_to_setup_pose(spine_skeleton skeleton); +SPINE_CPP_LITE_EXPORT spine_bone spine_skeleton_find_bone(spine_skeleton skeleton, const utf8 *boneName); +SPINE_CPP_LITE_EXPORT spine_slot spine_skeleton_find_slot(spine_skeleton skeleton, const utf8 *slotName); +SPINE_CPP_LITE_EXPORT void spine_skeleton_set_skin_by_name(spine_skeleton skeleton, const utf8 *skinName); +SPINE_CPP_LITE_EXPORT void spine_skeleton_set_skin(spine_skeleton skeleton, spine_skin skin); +SPINE_CPP_LITE_EXPORT spine_attachment spine_skeleton_get_attachment_by_name(spine_skeleton skeleton, const utf8 *slotName, const utf8 *attachmentName); +SPINE_CPP_LITE_EXPORT spine_attachment spine_skeleton_get_attachment(spine_skeleton skeleton, int32_t slotIndex, const utf8 *attachmentName); +SPINE_CPP_LITE_EXPORT void spine_skeleton_set_attachment(spine_skeleton skeleton, const utf8 *slotName, const utf8 *attachmentName); +SPINE_CPP_LITE_EXPORT spine_ik_constraint spine_skeleton_find_ik_constraint(spine_skeleton skeleton, const utf8 *constraintName); +SPINE_CPP_LITE_EXPORT spine_transform_constraint spine_skeleton_find_transform_constraint(spine_skeleton skeleton, const utf8 *constraintName); +SPINE_CPP_LITE_EXPORT spine_path_constraint spine_skeleton_find_path_constraint(spine_skeleton skeleton, const utf8 *constraintName); +SPINE_CPP_LITE_EXPORT spine_physics_constraint spine_skeleton_find_physics_constraint(spine_skeleton skeleton, const utf8 *constraintName); +SPINE_CPP_LITE_EXPORT spine_bounds spine_skeleton_get_bounds(spine_skeleton skeleton); +SPINE_CPP_LITE_EXPORT spine_bone spine_skeleton_get_root_bone(spine_skeleton skeleton); +SPINE_CPP_LITE_EXPORT spine_skeleton_data spine_skeleton_get_data(spine_skeleton skeleton); +SPINE_CPP_LITE_EXPORT int32_t spine_skeleton_get_num_bones(spine_skeleton skeleton); +SPINE_CPP_LITE_EXPORT spine_bone *spine_skeleton_get_bones(spine_skeleton skeleton); +// OMITTED getUpdateCacheList() +SPINE_CPP_LITE_EXPORT int32_t spine_skeleton_get_num_slots(spine_skeleton skeleton); +SPINE_CPP_LITE_EXPORT spine_slot *spine_skeleton_get_slots(spine_skeleton skeleton); +SPINE_CPP_LITE_EXPORT int32_t spine_skeleton_get_num_draw_order(spine_skeleton skeleton); +SPINE_CPP_LITE_EXPORT spine_slot *spine_skeleton_get_draw_order(spine_skeleton skeleton); +SPINE_CPP_LITE_EXPORT int32_t spine_skeleton_get_num_ik_constraints(spine_skeleton skeleton); +SPINE_CPP_LITE_EXPORT spine_ik_constraint *spine_skeleton_get_ik_constraints(spine_skeleton skeleton); +SPINE_CPP_LITE_EXPORT int32_t spine_skeleton_get_num_transform_constraints(spine_skeleton skeleton); +SPINE_CPP_LITE_EXPORT spine_transform_constraint *spine_skeleton_get_transform_constraints(spine_skeleton skeleton); +SPINE_CPP_LITE_EXPORT int32_t spine_skeleton_get_num_path_constraints(spine_skeleton skeleton); +SPINE_CPP_LITE_EXPORT spine_path_constraint *spine_skeleton_get_path_constraints(spine_skeleton skeleton); +SPINE_CPP_LITE_EXPORT int32_t spine_skeleton_get_num_physics_constraints(spine_skeleton skeleton); +SPINE_CPP_LITE_EXPORT spine_physics_constraint *spine_skeleton_get_physics_constraints(spine_skeleton skeleton); +SPINE_CPP_LITE_EXPORT spine_skin spine_skeleton_get_skin(spine_skeleton skeleton); +SPINE_CPP_LITE_EXPORT spine_color spine_skeleton_get_color(spine_skeleton skeleton); +SPINE_CPP_LITE_EXPORT void spine_skeleton_set_color(spine_skeleton skeleton, float r, float g, float b, float a); +SPINE_CPP_LITE_EXPORT void spine_skeleton_set_position(spine_skeleton skeleton, float x, float y); +SPINE_CPP_LITE_EXPORT float spine_skeleton_get_x(spine_skeleton skeleton); +SPINE_CPP_LITE_EXPORT void spine_skeleton_set_x(spine_skeleton skeleton, float x); +SPINE_CPP_LITE_EXPORT float spine_skeleton_get_y(spine_skeleton skeleton); +SPINE_CPP_LITE_EXPORT void spine_skeleton_set_y(spine_skeleton skeleton, float y); +SPINE_CPP_LITE_EXPORT float spine_skeleton_get_scale_x(spine_skeleton skeleton); +SPINE_CPP_LITE_EXPORT void spine_skeleton_set_scale_x(spine_skeleton skeleton, float scaleX); +SPINE_CPP_LITE_EXPORT float spine_skeleton_get_scale_y(spine_skeleton skeleton); +SPINE_CPP_LITE_EXPORT void spine_skeleton_set_scale_y(spine_skeleton skeleton, float scaleY); +SPINE_CPP_LITE_EXPORT float spine_skeleton_get_time(spine_skeleton skeleton); +SPINE_CPP_LITE_EXPORT void spine_skeleton_set_time(spine_skeleton skeleton, float time); +SPINE_CPP_LITE_EXPORT void spine_skeleton_update(spine_skeleton skeleton, float delta); + +SPINE_CPP_LITE_EXPORT const utf8 *spine_event_data_get_name(spine_event_data event); +SPINE_CPP_LITE_EXPORT int32_t spine_event_data_get_int_value(spine_event_data event); +SPINE_CPP_LITE_EXPORT void spine_event_data_set_int_value(spine_event_data event, int32_t value); +SPINE_CPP_LITE_EXPORT float spine_event_data_get_float_value(spine_event_data event); +SPINE_CPP_LITE_EXPORT void spine_event_data_set_float_value(spine_event_data event, float value); +SPINE_CPP_LITE_EXPORT const utf8 *spine_event_data_get_string_value(spine_event_data event); +SPINE_CPP_LITE_EXPORT void spine_event_data_set_string_value(spine_event_data event, const utf8 *value); +SPINE_CPP_LITE_EXPORT const utf8 *spine_event_data_get_audio_path(spine_event_data event); +// OMITTED setAudioPath() +SPINE_CPP_LITE_EXPORT float spine_event_data_get_volume(spine_event_data event); +SPINE_CPP_LITE_EXPORT void spine_event_data_set_volume(spine_event_data event, float volume); +SPINE_CPP_LITE_EXPORT float spine_event_data_get_balance(spine_event_data event); +SPINE_CPP_LITE_EXPORT void spine_event_data_set_balance(spine_event_data event, float balance); + +SPINE_CPP_LITE_EXPORT spine_event_data spine_event_get_data(spine_event event); +SPINE_CPP_LITE_EXPORT float spine_event_get_time(spine_event event); +SPINE_CPP_LITE_EXPORT int32_t spine_event_get_int_value(spine_event event); +SPINE_CPP_LITE_EXPORT void spine_event_set_int_value(spine_event event, int32_t value); +SPINE_CPP_LITE_EXPORT float spine_event_get_float_value(spine_event event); +SPINE_CPP_LITE_EXPORT void spine_event_set_float_value(spine_event event, float value); +SPINE_CPP_LITE_EXPORT const utf8 *spine_event_get_string_value(spine_event event); +SPINE_CPP_LITE_EXPORT void spine_event_set_string_value(spine_event event, const utf8 *value); +SPINE_CPP_LITE_EXPORT float spine_event_get_volume(spine_event event); +SPINE_CPP_LITE_EXPORT void spine_event_set_volume(spine_event event, float volume); +SPINE_CPP_LITE_EXPORT float spine_event_get_balance(spine_event event); +SPINE_CPP_LITE_EXPORT void spine_event_set_balance(spine_event event, float balance); + +SPINE_CPP_LITE_EXPORT int32_t spine_slot_data_get_index(spine_slot_data slot); +SPINE_CPP_LITE_EXPORT const utf8 *spine_slot_data_get_name(spine_slot_data slot); +SPINE_CPP_LITE_EXPORT spine_bone_data spine_slot_data_get_bone_data(spine_slot_data slot); +SPINE_CPP_LITE_EXPORT spine_color spine_slot_data_get_color(spine_slot_data slot); +SPINE_CPP_LITE_EXPORT void spine_slot_data_set_color(spine_slot_data slot, float r, float g, float b, float a); +SPINE_CPP_LITE_EXPORT spine_color spine_slot_data_get_dark_color(spine_slot_data slot); +SPINE_CPP_LITE_EXPORT void spine_slot_data_set_dark_color(spine_slot_data slot, float r, float g, float b, float a); +SPINE_CPP_LITE_EXPORT int32_t spine_slot_data_has_dark_color(spine_slot_data slot); +SPINE_CPP_LITE_EXPORT void spine_slot_data_set_has_dark_color(spine_slot_data slot, int32_t hasDarkColor); +SPINE_CPP_LITE_EXPORT const utf8 *spine_slot_data_get_attachment_name(spine_slot_data slot); +SPINE_CPP_LITE_EXPORT void spine_slot_data_set_attachment_name(spine_slot_data slot, const utf8 *attachmentName); +SPINE_CPP_LITE_EXPORT spine_blend_mode spine_slot_data_get_blend_mode(spine_slot_data slot); +SPINE_CPP_LITE_EXPORT void spine_slot_data_set_blend_mode(spine_slot_data slot, spine_blend_mode blendMode); +SPINE_CPP_LITE_EXPORT int32_t spine_slot_data_is_visible(spine_slot_data slot); +SPINE_CPP_LITE_EXPORT void spine_slot_data_set_visible(spine_slot_data slot, int32_t visible); +// OMITTED getPath()/setPath() + +SPINE_CPP_LITE_EXPORT void spine_slot_set_to_setup_pose(spine_slot slot); +SPINE_CPP_LITE_EXPORT spine_slot_data spine_slot_get_data(spine_slot slot); +SPINE_CPP_LITE_EXPORT spine_bone spine_slot_get_bone(spine_slot slot); +SPINE_CPP_LITE_EXPORT spine_skeleton spine_slot_get_skeleton(spine_slot slot); +SPINE_CPP_LITE_EXPORT spine_color spine_slot_get_color(spine_slot slot); +SPINE_CPP_LITE_EXPORT void spine_slot_set_color(spine_slot slot, float r, float g, float b, float a); +SPINE_CPP_LITE_EXPORT spine_color spine_slot_get_dark_color(spine_slot slot); +SPINE_CPP_LITE_EXPORT void spine_slot_set_dark_color(spine_slot slot, float r, float g, float b, float a); +SPINE_CPP_LITE_EXPORT int32_t spine_slot_has_dark_color(spine_slot slot); +SPINE_CPP_LITE_EXPORT spine_attachment spine_slot_get_attachment(spine_slot slot); +SPINE_CPP_LITE_EXPORT void spine_slot_set_attachment(spine_slot slot, spine_attachment attachment); +// OMITTED getDeform() +SPINE_CPP_LITE_EXPORT int32_t spine_slot_get_sequence_index(spine_slot slot); +SPINE_CPP_LITE_EXPORT void spine_slot_set_sequence_index(spine_slot slot, int32_t sequenceIndex); + +SPINE_CPP_LITE_EXPORT int32_t spine_bone_data_get_index(spine_bone_data data); +SPINE_CPP_LITE_EXPORT const utf8 *spine_bone_data_get_name(spine_bone_data data); +SPINE_CPP_LITE_EXPORT spine_bone_data spine_bone_data_get_parent(spine_bone_data data); +SPINE_CPP_LITE_EXPORT float spine_bone_data_get_length(spine_bone_data data); +SPINE_CPP_LITE_EXPORT void spine_bone_data_set_length(spine_bone_data data, float length); +SPINE_CPP_LITE_EXPORT float spine_bone_data_get_x(spine_bone_data data); +SPINE_CPP_LITE_EXPORT void spine_bone_data_set_x(spine_bone_data data, float x); +SPINE_CPP_LITE_EXPORT float spine_bone_data_get_y(spine_bone_data data); +SPINE_CPP_LITE_EXPORT void spine_bone_data_set_y(spine_bone_data data, float y); +SPINE_CPP_LITE_EXPORT float spine_bone_data_get_rotation(spine_bone_data data); +SPINE_CPP_LITE_EXPORT void spine_bone_data_set_rotation(spine_bone_data data, float rotation); +SPINE_CPP_LITE_EXPORT float spine_bone_data_get_scale_x(spine_bone_data data); +SPINE_CPP_LITE_EXPORT void spine_bone_data_set_scale_x(spine_bone_data data, float scaleX); +SPINE_CPP_LITE_EXPORT float spine_bone_data_get_scale_y(spine_bone_data data); +SPINE_CPP_LITE_EXPORT void spine_bone_data_set_scale_y(spine_bone_data data, float scaleY); +SPINE_CPP_LITE_EXPORT float spine_bone_data_get_shear_x(spine_bone_data data); +SPINE_CPP_LITE_EXPORT void spine_bone_data_set_shear_x(spine_bone_data data, float shearx); +SPINE_CPP_LITE_EXPORT float spine_bone_data_get_shear_y(spine_bone_data data); +SPINE_CPP_LITE_EXPORT void spine_bone_data_set_shear_y(spine_bone_data data, float shearY); +SPINE_CPP_LITE_EXPORT spine_inherit spine_bone_data_get_inherit(spine_bone_data data); +SPINE_CPP_LITE_EXPORT void spine_bone_data_set_inherit(spine_bone_data data, spine_inherit inherit); +SPINE_CPP_LITE_EXPORT int32_t spine_bone_data_is_skin_required(spine_bone_data data); +SPINE_CPP_LITE_EXPORT void spine_bone_data_set_is_skin_required(spine_bone_data data, int32_t isSkinRequired); +SPINE_CPP_LITE_EXPORT spine_color spine_bone_data_get_color(spine_bone_data data); +SPINE_CPP_LITE_EXPORT void spine_bone_data_set_color(spine_bone_data data, float r, float g, float b, float a); +SPINE_CPP_LITE_EXPORT int32_t spine_bone_data_is_visible(spine_bone_data data); +SPINE_CPP_LITE_EXPORT void spine_bone_data_set_visible(spine_bone_data data, int32_t isVisible); +// Omitted getIcon()/setIcon() + +SPINE_CPP_LITE_EXPORT void spine_bone_set_is_y_down(int32_t yDown); +SPINE_CPP_LITE_EXPORT int32_t spine_bone_get_is_y_down(); +SPINE_CPP_LITE_EXPORT void spine_bone_update(spine_bone bone); +SPINE_CPP_LITE_EXPORT void spine_bone_update_world_transform(spine_bone bone); +SPINE_CPP_LITE_EXPORT void spine_bone_update_world_transform_with(spine_bone bone, float x, float y, float rotation, float scaleX, float scaleY, float shearX, float shearY); +SPINE_CPP_LITE_EXPORT void spine_bone_update_applied_transform(spine_bone bone); +SPINE_CPP_LITE_EXPORT void spine_bone_set_to_setup_pose(spine_bone bone); +SPINE_CPP_LITE_EXPORT spine_vector spine_bone_world_to_local(spine_bone bone, float worldX, float worldY); +SPINE_CPP_LITE_EXPORT spine_vector spine_bone_world_to_parent(spine_bone bone, float worldX, float worldY); +SPINE_CPP_LITE_EXPORT spine_vector spine_bone_local_to_world(spine_bone bone, float localX, float localY); +SPINE_CPP_LITE_EXPORT spine_vector spine_bone_parent_to_world(spine_bone bone, float localX, float localY); +SPINE_CPP_LITE_EXPORT float spine_bone_world_to_local_rotation(spine_bone bone, float worldRotation); +SPINE_CPP_LITE_EXPORT float spine_bone_local_to_world_rotation(spine_bone bone, float localRotation); +SPINE_CPP_LITE_EXPORT void spine_bone_rotate_world(spine_bone bone, float degrees); +SPINE_CPP_LITE_EXPORT float spine_bone_get_world_to_local_rotation_x(spine_bone bone); +SPINE_CPP_LITE_EXPORT float spine_bone_get_world_to_local_rotation_y(spine_bone bone); +SPINE_CPP_LITE_EXPORT spine_bone_data spine_bone_get_data(spine_bone bone); +SPINE_CPP_LITE_EXPORT spine_skeleton spine_bone_get_skeleton(spine_bone bone); +SPINE_CPP_LITE_EXPORT spine_bone spine_bone_get_parent(spine_bone bone); +SPINE_CPP_LITE_EXPORT int32_t spine_bone_get_num_children(spine_bone bone); +SPINE_CPP_LITE_EXPORT spine_bone *spine_bone_get_children(spine_bone bone); +SPINE_CPP_LITE_EXPORT float spine_bone_get_x(spine_bone bone); +SPINE_CPP_LITE_EXPORT void spine_bone_set_x(spine_bone bone, float x); +SPINE_CPP_LITE_EXPORT float spine_bone_get_y(spine_bone bone); +SPINE_CPP_LITE_EXPORT void spine_bone_set_y(spine_bone bone, float y); +SPINE_CPP_LITE_EXPORT float spine_bone_get_rotation(spine_bone bone); +SPINE_CPP_LITE_EXPORT void spine_bone_set_rotation(spine_bone bone, float rotation); +SPINE_CPP_LITE_EXPORT float spine_bone_get_scale_x(spine_bone bone); +SPINE_CPP_LITE_EXPORT void spine_bone_set_scale_x(spine_bone bone, float scaleX); +SPINE_CPP_LITE_EXPORT float spine_bone_get_scale_y(spine_bone bone); +SPINE_CPP_LITE_EXPORT void spine_bone_set_scale_y(spine_bone bone, float scaleY); +SPINE_CPP_LITE_EXPORT float spine_bone_get_shear_x(spine_bone bone); +SPINE_CPP_LITE_EXPORT void spine_bone_set_shear_x(spine_bone bone, float shearX); +SPINE_CPP_LITE_EXPORT float spine_bone_get_shear_y(spine_bone bone); +SPINE_CPP_LITE_EXPORT void spine_bone_set_shear_y(spine_bone bone, float shearY); +SPINE_CPP_LITE_EXPORT float spine_bone_get_applied_rotation(spine_bone bone); +SPINE_CPP_LITE_EXPORT void spine_bone_set_applied_rotation(spine_bone bone, float rotation); +SPINE_CPP_LITE_EXPORT float spine_bone_get_a_x(spine_bone bone); +SPINE_CPP_LITE_EXPORT void spine_bone_set_a_x(spine_bone bone, float x); +SPINE_CPP_LITE_EXPORT float spine_bone_get_a_y(spine_bone bone); +SPINE_CPP_LITE_EXPORT void spine_bone_set_a_y(spine_bone bone, float y); +SPINE_CPP_LITE_EXPORT float spine_bone_get_a_scale_x(spine_bone bone); +SPINE_CPP_LITE_EXPORT void spine_bone_set_a_scale_x(spine_bone bone, float scaleX); +SPINE_CPP_LITE_EXPORT float spine_bone_get_a_scale_y(spine_bone bone); +SPINE_CPP_LITE_EXPORT void spine_bone_set_a_scale_y(spine_bone bone, float scaleY); +SPINE_CPP_LITE_EXPORT float spine_bone_get_a_shear_x(spine_bone bone); +SPINE_CPP_LITE_EXPORT void spine_bone_set_a_shear_x(spine_bone bone, float shearX); +SPINE_CPP_LITE_EXPORT float spine_bone_get_a_shear_y(spine_bone bone); +SPINE_CPP_LITE_EXPORT void spine_bone_set_a_shear_y(spine_bone bone, float shearY); +SPINE_CPP_LITE_EXPORT float spine_bone_get_a(spine_bone bone); +SPINE_CPP_LITE_EXPORT void spine_bone_set_a(spine_bone bone, float a); +SPINE_CPP_LITE_EXPORT float spine_bone_get_b(spine_bone bone); +SPINE_CPP_LITE_EXPORT void spine_bone_set_b(spine_bone bone, float b); +SPINE_CPP_LITE_EXPORT float spine_bone_get_c(spine_bone bone); +SPINE_CPP_LITE_EXPORT void spine_bone_set_c(spine_bone bone, float c); +SPINE_CPP_LITE_EXPORT float spine_bone_get_d(spine_bone bone); +SPINE_CPP_LITE_EXPORT void spine_bone_set_d(spine_bone bone, float d); +SPINE_CPP_LITE_EXPORT float spine_bone_get_world_x(spine_bone bone); +SPINE_CPP_LITE_EXPORT void spine_bone_set_world_x(spine_bone bone, float worldX); +SPINE_CPP_LITE_EXPORT float spine_bone_get_world_y(spine_bone bone); +SPINE_CPP_LITE_EXPORT void spine_bone_set_world_y(spine_bone bone, float worldY); +SPINE_CPP_LITE_EXPORT float spine_bone_get_world_rotation_x(spine_bone bone); +SPINE_CPP_LITE_EXPORT float spine_bone_get_world_rotation_y(spine_bone bone); +SPINE_CPP_LITE_EXPORT float spine_bone_get_world_scale_x(spine_bone bone); +SPINE_CPP_LITE_EXPORT float spine_bone_get_world_scale_y(spine_bone bone); +SPINE_CPP_LITE_EXPORT int32_t spine_bone_get_is_active(spine_bone bone); +SPINE_CPP_LITE_EXPORT void spine_bone_set_is_active(spine_bone bone, int32_t isActive); +SPINE_CPP_LITE_EXPORT spine_inherit spine_bone_get_inherit(spine_bone data); +SPINE_CPP_LITE_EXPORT void spine_bone_set_inherit(spine_bone data, spine_inherit inherit); + +SPINE_CPP_LITE_EXPORT const utf8 *spine_attachment_get_name(spine_attachment attachment); +SPINE_CPP_LITE_EXPORT spine_attachment_type spine_attachment_get_type(spine_attachment attachment); +SPINE_CPP_LITE_EXPORT spine_attachment spine_attachment_copy(spine_attachment attachment); +SPINE_CPP_LITE_EXPORT void spine_attachment_dispose(spine_attachment attachment); + +SPINE_CPP_LITE_EXPORT spine_vector spine_point_attachment_compute_world_position(spine_point_attachment attachment, spine_bone bone); +SPINE_CPP_LITE_EXPORT float spine_point_attachment_compute_world_rotation(spine_point_attachment attachment, spine_bone bone); +SPINE_CPP_LITE_EXPORT float spine_point_attachment_get_x(spine_point_attachment attachment); +SPINE_CPP_LITE_EXPORT void spine_point_attachment_set_x(spine_point_attachment attachment, float x); +SPINE_CPP_LITE_EXPORT float spine_point_attachment_get_y(spine_point_attachment attachment); +SPINE_CPP_LITE_EXPORT void spine_point_attachment_set_y(spine_point_attachment attachment, float y); +SPINE_CPP_LITE_EXPORT float spine_point_attachment_get_rotation(spine_point_attachment attachment); +SPINE_CPP_LITE_EXPORT void spine_point_attachment_set_rotation(spine_point_attachment attachment, float rotation); +SPINE_CPP_LITE_EXPORT spine_color spine_point_attachment_get_color(spine_point_attachment attachment); +SPINE_CPP_LITE_EXPORT void spine_point_attachment_set_color(spine_point_attachment attachment, float r, float g, float b, float a); + +SPINE_CPP_LITE_EXPORT void spine_region_attachment_update_region(spine_region_attachment attachment); +SPINE_CPP_LITE_EXPORT void spine_region_attachment_compute_world_vertices(spine_region_attachment attachment, spine_slot slot, float *worldVertices); +SPINE_CPP_LITE_EXPORT float spine_region_attachment_get_x(spine_region_attachment attachment); +SPINE_CPP_LITE_EXPORT void spine_region_attachment_set_x(spine_region_attachment attachment, float x); +SPINE_CPP_LITE_EXPORT float spine_region_attachment_get_y(spine_region_attachment attachment); +SPINE_CPP_LITE_EXPORT void spine_region_attachment_set_y(spine_region_attachment attachment, float y); +SPINE_CPP_LITE_EXPORT float spine_region_attachment_get_rotation(spine_region_attachment attachment); +SPINE_CPP_LITE_EXPORT void spine_region_attachment_set_rotation(spine_region_attachment attachment, float rotation); +SPINE_CPP_LITE_EXPORT float spine_region_attachment_get_scale_x(spine_region_attachment attachment); +SPINE_CPP_LITE_EXPORT void spine_region_attachment_set_scale_x(spine_region_attachment attachment, float scaleX); +SPINE_CPP_LITE_EXPORT float spine_region_attachment_get_scale_y(spine_region_attachment attachment); +SPINE_CPP_LITE_EXPORT void spine_region_attachment_set_scale_y(spine_region_attachment attachment, float scaleY); +SPINE_CPP_LITE_EXPORT float spine_region_attachment_get_width(spine_region_attachment attachment); +SPINE_CPP_LITE_EXPORT void spine_region_attachment_set_width(spine_region_attachment attachment, float width); +SPINE_CPP_LITE_EXPORT float spine_region_attachment_get_height(spine_region_attachment attachment); +SPINE_CPP_LITE_EXPORT void spine_region_attachment_set_height(spine_region_attachment attachment, float height); +SPINE_CPP_LITE_EXPORT spine_color spine_region_attachment_get_color(spine_region_attachment attachment); +SPINE_CPP_LITE_EXPORT void spine_region_attachment_set_color(spine_region_attachment attachment, float r, float g, float b, float a); +SPINE_CPP_LITE_EXPORT const utf8 *spine_region_attachment_get_path(spine_region_attachment attachment); +// OMITTED setPath() +SPINE_CPP_LITE_EXPORT spine_texture_region spine_region_attachment_get_region(spine_region_attachment attachment); +// OMITTED setRegion() +SPINE_CPP_LITE_EXPORT spine_sequence spine_region_attachment_get_sequence(spine_region_attachment attachment); +// OMITTED setSequence() +SPINE_CPP_LITE_EXPORT int32_t spine_region_attachment_get_num_offset(spine_region_attachment attachment); +SPINE_CPP_LITE_EXPORT float *spine_region_attachment_get_offset(spine_region_attachment attachment); +SPINE_CPP_LITE_EXPORT int32_t spine_region_attachment_get_num_uvs(spine_region_attachment attachment); +SPINE_CPP_LITE_EXPORT float *spine_region_attachment_get_uvs(spine_region_attachment attachment); + +SPINE_CPP_LITE_EXPORT int32_t spine_vertex_attachment_get_world_vertices_length(spine_vertex_attachment attachment); +SPINE_CPP_LITE_EXPORT void spine_vertex_attachment_compute_world_vertices(spine_vertex_attachment attachment, spine_slot slot, float *worldVertices); +// OMITTED getId() +SPINE_CPP_LITE_EXPORT int32_t spine_vertex_attachment_get_num_bones(spine_vertex_attachment attachment); +SPINE_CPP_LITE_EXPORT int32_t *spine_vertex_attachment_get_bones(spine_vertex_attachment attachment); +SPINE_CPP_LITE_EXPORT int32_t spine_vertex_attachment_get_num_vertices(spine_vertex_attachment attachment); +SPINE_CPP_LITE_EXPORT float *spine_vertex_attachment_get_vertices(spine_vertex_attachment attachment); +SPINE_CPP_LITE_EXPORT spine_attachment spine_vertex_attachment_get_timeline_attachment(spine_vertex_attachment timelineAttachment); +SPINE_CPP_LITE_EXPORT void spine_vertex_attachment_set_timeline_attachment(spine_vertex_attachment attachment, spine_attachment timelineAttachment); +// OMITTED copyTo() + +SPINE_CPP_LITE_EXPORT void spine_mesh_attachment_update_region(spine_mesh_attachment attachment); +SPINE_CPP_LITE_EXPORT int32_t spine_mesh_attachment_get_hull_length(spine_mesh_attachment attachment); +SPINE_CPP_LITE_EXPORT void spine_mesh_attachment_set_hull_length(spine_mesh_attachment attachment, int32_t hullLength); +SPINE_CPP_LITE_EXPORT int32_t spine_mesh_attachment_get_num_region_uvs(spine_mesh_attachment attachment); +SPINE_CPP_LITE_EXPORT float *spine_mesh_attachment_get_region_uvs(spine_mesh_attachment attachment); +SPINE_CPP_LITE_EXPORT int32_t spine_mesh_attachment_get_num_uvs(spine_mesh_attachment attachment); +SPINE_CPP_LITE_EXPORT float *spine_mesh_attachment_get_uvs(spine_mesh_attachment attachment); +SPINE_CPP_LITE_EXPORT int32_t spine_mesh_attachment_get_num_triangles(spine_mesh_attachment attachment); +SPINE_CPP_LITE_EXPORT uint16_t *spine_mesh_attachment_get_triangles(spine_mesh_attachment attachment); +SPINE_CPP_LITE_EXPORT spine_color spine_mesh_attachment_get_color(spine_mesh_attachment attachment); +SPINE_CPP_LITE_EXPORT void spine_mesh_attachment_set_color(spine_mesh_attachment attachment, float r, float g, float b, float a); +SPINE_CPP_LITE_EXPORT const utf8 *spine_mesh_attachment_get_path(spine_mesh_attachment attachment); +// OMITTED setPath() +SPINE_CPP_LITE_EXPORT spine_texture_region spine_mesh_attachment_get_region(spine_mesh_attachment attachment); +// OMITTED setRegion() +SPINE_CPP_LITE_EXPORT spine_sequence spine_mesh_attachment_get_sequence(spine_mesh_attachment attachment); +// OMITTED setSequence() +SPINE_CPP_LITE_EXPORT spine_mesh_attachment spine_mesh_attachment_get_parent_mesh(spine_mesh_attachment attachment); +SPINE_CPP_LITE_EXPORT void spine_mesh_attachment_set_parent_mesh(spine_mesh_attachment attachment, spine_mesh_attachment parentMesh); +SPINE_CPP_LITE_EXPORT int32_t spine_mesh_attachment_get_num_edges(spine_mesh_attachment attachment); +SPINE_CPP_LITE_EXPORT uint16_t *spine_mesh_attachment_get_edges(spine_mesh_attachment attachment); +SPINE_CPP_LITE_EXPORT float spine_mesh_attachment_get_width(spine_mesh_attachment attachment); +SPINE_CPP_LITE_EXPORT void spine_mesh_attachment_set_width(spine_mesh_attachment attachment, float width); +SPINE_CPP_LITE_EXPORT float spine_mesh_attachment_get_height(spine_mesh_attachment attachment); +SPINE_CPP_LITE_EXPORT void spine_mesh_attachment_set_height(spine_mesh_attachment attachment, float height); +// OMITTED newLinkedMesh() + +SPINE_CPP_LITE_EXPORT spine_slot_data spine_clipping_attachment_get_end_slot(spine_clipping_attachment attachment); +SPINE_CPP_LITE_EXPORT void spine_clipping_attachment_set_end_slot(spine_clipping_attachment attachment, spine_slot_data endSlot); +SPINE_CPP_LITE_EXPORT spine_color spine_clipping_attachment_get_color(spine_clipping_attachment attachment); +SPINE_CPP_LITE_EXPORT void spine_clipping_attachment_set_color(spine_clipping_attachment attachment, float r, float g, float b, float a); + +SPINE_CPP_LITE_EXPORT spine_color spine_bounding_box_attachment_get_color(spine_bounding_box_attachment attachment); +SPINE_CPP_LITE_EXPORT void spine_bounding_box_attachment_set_color(spine_bounding_box_attachment attachment, float r, float g, float b, float a); + +SPINE_CPP_LITE_EXPORT int32_t spine_path_attachment_get_num_lengths(spine_path_attachment attachment); +SPINE_CPP_LITE_EXPORT float *spine_path_attachment_get_lengths(spine_path_attachment attachment); +SPINE_CPP_LITE_EXPORT int32_t spine_path_attachment_get_is_closed(spine_path_attachment attachment); +SPINE_CPP_LITE_EXPORT void spine_path_attachment_set_is_closed(spine_path_attachment attachment, int32_t isClosed); +SPINE_CPP_LITE_EXPORT int32_t spine_path_attachment_get_is_constant_speed(spine_path_attachment attachment); +SPINE_CPP_LITE_EXPORT void spine_path_attachment_set_is_constant_speed(spine_path_attachment attachment, int32_t isConstantSpeed); +SPINE_CPP_LITE_EXPORT spine_color spine_path_attachment_get_color(spine_path_attachment attachment); +SPINE_CPP_LITE_EXPORT void spine_path_attachment_set_color(spine_path_attachment attachment, float r, float g, float b, float a); + +SPINE_CPP_LITE_EXPORT void spine_skin_set_attachment(spine_skin skin, int32_t slotIndex, const utf8 *name, spine_attachment attachment); +SPINE_CPP_LITE_EXPORT spine_attachment spine_skin_get_attachment(spine_skin skin, int32_t slotIndex, const utf8 *name); +SPINE_CPP_LITE_EXPORT void spine_skin_remove_attachment(spine_skin skin, int32_t slotIndex, const utf8 *name); +// OMITTED findNamesForSlot() +// OMITTED findAttachmentsForSlot() +// OMITTED getColor() +SPINE_CPP_LITE_EXPORT const utf8 *spine_skin_get_name(spine_skin skin); +SPINE_CPP_LITE_EXPORT void spine_skin_add_skin(spine_skin skin, spine_skin other); +SPINE_CPP_LITE_EXPORT void spine_skin_copy_skin(spine_skin skin, spine_skin other); +SPINE_CPP_LITE_EXPORT spine_skin_entries spine_skin_get_entries(spine_skin skin); +SPINE_CPP_LITE_EXPORT int32_t spine_skin_entries_get_num_entries(spine_skin_entries entries); +SPINE_CPP_LITE_EXPORT spine_skin_entry spine_skin_entries_get_entry(spine_skin_entries entries, int32_t index); +SPINE_CPP_LITE_EXPORT void spine_skin_entries_dispose(spine_skin_entries entries); +SPINE_CPP_LITE_EXPORT int32_t spine_skin_entry_get_slot_index(spine_skin_entry entry); +SPINE_CPP_LITE_EXPORT utf8 *spine_skin_entry_get_name(spine_skin_entry entry); +SPINE_CPP_LITE_EXPORT spine_attachment spine_skin_entry_get_attachment(spine_skin_entry entry); +SPINE_CPP_LITE_EXPORT int32_t spine_skin_get_num_bones(spine_skin skin); +SPINE_CPP_LITE_EXPORT spine_bone_data *spine_skin_get_bones(spine_skin skin); +SPINE_CPP_LITE_EXPORT int32_t spine_skin_get_num_constraints(spine_skin skin); +SPINE_CPP_LITE_EXPORT spine_constraint_data *spine_skin_get_constraints(spine_skin skin); +SPINE_CPP_LITE_EXPORT spine_skin spine_skin_create(const utf8 *name); +SPINE_CPP_LITE_EXPORT void spine_skin_dispose(spine_skin skin); + +SPINE_CPP_LITE_EXPORT spine_constraint_type spine_constraint_data_get_type(spine_constraint_data data); +SPINE_CPP_LITE_EXPORT const utf8 *spine_constraint_data_get_name(spine_constraint_data data); +SPINE_CPP_LITE_EXPORT uint64_t spine_constraint_data_get_order(spine_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_constraint_data_set_order(spine_constraint_data data, uint64_t order); +SPINE_CPP_LITE_EXPORT int32_t spine_constraint_data_get_is_skin_required(spine_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_constraint_data_set_is_skin_required(spine_constraint_data data, int32_t isSkinRequired); + +SPINE_CPP_LITE_EXPORT int32_t spine_ik_constraint_data_get_num_bones(spine_ik_constraint_data data); +SPINE_CPP_LITE_EXPORT spine_bone_data *spine_ik_constraint_data_get_bones(spine_ik_constraint_data data); +SPINE_CPP_LITE_EXPORT spine_bone_data spine_ik_constraint_data_get_target(spine_ik_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_ik_constraint_data_set_target(spine_ik_constraint_data data, spine_bone_data target); +SPINE_CPP_LITE_EXPORT int32_t spine_ik_constraint_data_get_bend_direction(spine_ik_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_ik_constraint_data_set_bend_direction(spine_ik_constraint_data data, int32_t bendDirection); +SPINE_CPP_LITE_EXPORT int32_t spine_ik_constraint_data_get_compress(spine_ik_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_ik_constraint_data_set_compress(spine_ik_constraint_data data, int32_t compress); +SPINE_CPP_LITE_EXPORT int32_t spine_ik_constraint_data_get_stretch(spine_ik_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_ik_constraint_data_set_stretch(spine_ik_constraint_data data, int32_t stretch); +SPINE_CPP_LITE_EXPORT int32_t spine_ik_constraint_data_get_uniform(spine_ik_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_ik_constraint_data_set_uniform(spine_ik_constraint_data data, int32_t uniform); +SPINE_CPP_LITE_EXPORT float spine_ik_constraint_data_get_mix(spine_ik_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_ik_constraint_data_set_mix(spine_ik_constraint_data data, float mix); +SPINE_CPP_LITE_EXPORT float spine_ik_constraint_data_get_softness(spine_ik_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_ik_constraint_data_set_softness(spine_ik_constraint_data data, float softness); + +SPINE_CPP_LITE_EXPORT void spine_ik_constraint_update(spine_ik_constraint constraint); +SPINE_CPP_LITE_EXPORT int32_t spine_ik_constraint_get_order(spine_ik_constraint constraint); +SPINE_CPP_LITE_EXPORT spine_ik_constraint_data spine_ik_constraint_get_data(spine_ik_constraint constraint); +SPINE_CPP_LITE_EXPORT int32_t spine_ik_constraint_get_num_bones(spine_ik_constraint constraint); +SPINE_CPP_LITE_EXPORT spine_bone *spine_ik_constraint_get_bones(spine_ik_constraint constraint); +SPINE_CPP_LITE_EXPORT spine_bone spine_ik_constraint_get_target(spine_ik_constraint constraint); +SPINE_CPP_LITE_EXPORT void spine_ik_constraint_set_target(spine_ik_constraint constraint, spine_bone target); +SPINE_CPP_LITE_EXPORT int32_t spine_ik_constraint_get_bend_direction(spine_ik_constraint constraint); +SPINE_CPP_LITE_EXPORT void spine_ik_constraint_set_bend_direction(spine_ik_constraint constraint, int32_t bendDirection); +SPINE_CPP_LITE_EXPORT int32_t spine_ik_constraint_get_compress(spine_ik_constraint constraint); +SPINE_CPP_LITE_EXPORT void spine_ik_constraint_set_compress(spine_ik_constraint constraint, int32_t compress); +SPINE_CPP_LITE_EXPORT int32_t spine_ik_constraint_get_stretch(spine_ik_constraint constraint); +SPINE_CPP_LITE_EXPORT void spine_ik_constraint_set_stretch(spine_ik_constraint constraint, int32_t stretch); +SPINE_CPP_LITE_EXPORT float spine_ik_constraint_get_mix(spine_ik_constraint constraint); +SPINE_CPP_LITE_EXPORT void spine_ik_constraint_set_mix(spine_ik_constraint constraint, float mix); +SPINE_CPP_LITE_EXPORT float spine_ik_constraint_get_softness(spine_ik_constraint constraint); +SPINE_CPP_LITE_EXPORT void spine_ik_constraint_set_softness(spine_ik_constraint constraint, float softness); +SPINE_CPP_LITE_EXPORT int32_t spine_ik_constraint_get_is_active(spine_ik_constraint constraint); +SPINE_CPP_LITE_EXPORT void spine_ik_constraint_set_is_active(spine_ik_constraint constraint, int32_t isActive); +// OMITTED setToSetupPose() + +SPINE_CPP_LITE_EXPORT int32_t spine_transform_constraint_data_get_num_bones(spine_transform_constraint_data data); +SPINE_CPP_LITE_EXPORT spine_bone_data *spine_transform_constraint_data_get_bones(spine_transform_constraint_data data); +SPINE_CPP_LITE_EXPORT spine_bone_data spine_transform_constraint_data_get_target(spine_transform_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_transform_constraint_data_set_target(spine_transform_constraint_data data, spine_bone_data target); +SPINE_CPP_LITE_EXPORT float spine_transform_constraint_data_get_mix_rotate(spine_transform_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_transform_constraint_data_set_mix_rotate(spine_transform_constraint_data data, float mixRotate); +SPINE_CPP_LITE_EXPORT float spine_transform_constraint_data_get_mix_x(spine_transform_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_transform_constraint_data_set_mix_x(spine_transform_constraint_data data, float mixX); +SPINE_CPP_LITE_EXPORT float spine_transform_constraint_data_get_mix_y(spine_transform_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_transform_constraint_data_set_mix_y(spine_transform_constraint_data data, float mixY); +SPINE_CPP_LITE_EXPORT float spine_transform_constraint_data_get_mix_scale_x(spine_transform_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_transform_constraint_data_set_mix_scale_x(spine_transform_constraint_data data, float mixScaleX); +SPINE_CPP_LITE_EXPORT float spine_transform_constraint_data_get_mix_scale_y(spine_transform_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_transform_constraint_data_set_mix_scale_y(spine_transform_constraint_data data, float mixScaleY); +SPINE_CPP_LITE_EXPORT float spine_transform_constraint_data_get_mix_shear_y(spine_transform_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_transform_constraint_data_set_mix_shear_y(spine_transform_constraint_data data, float mixShearY); +SPINE_CPP_LITE_EXPORT float spine_transform_constraint_data_get_offset_rotation(spine_transform_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_transform_constraint_data_set_offset_rotation(spine_transform_constraint_data data, float offsetRotation); +SPINE_CPP_LITE_EXPORT float spine_transform_constraint_data_get_offset_x(spine_transform_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_transform_constraint_data_set_offset_x(spine_transform_constraint_data data, float offsetX); +SPINE_CPP_LITE_EXPORT float spine_transform_constraint_data_get_offset_y(spine_transform_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_transform_constraint_data_set_offset_y(spine_transform_constraint_data data, float offsetY); +SPINE_CPP_LITE_EXPORT float spine_transform_constraint_data_get_offset_scale_x(spine_transform_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_transform_constraint_data_set_offset_scale_x(spine_transform_constraint_data data, float offsetScaleX); +SPINE_CPP_LITE_EXPORT float spine_transform_constraint_data_get_offset_scale_y(spine_transform_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_transform_constraint_data_set_offset_scale_y(spine_transform_constraint_data data, float offsetScaleY); +SPINE_CPP_LITE_EXPORT float spine_transform_constraint_data_get_offset_shear_y(spine_transform_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_transform_constraint_data_set_offset_shear_y(spine_transform_constraint_data data, float offsetShearY); +SPINE_CPP_LITE_EXPORT int32_t spine_transform_constraint_data_get_is_relative(spine_transform_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_transform_constraint_data_set_is_relative(spine_transform_constraint_data data, int32_t isRelative); +SPINE_CPP_LITE_EXPORT int32_t spine_transform_constraint_data_get_is_local(spine_transform_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_transform_constraint_data_set_is_local(spine_transform_constraint_data data, int32_t isLocal); + +SPINE_CPP_LITE_EXPORT void spine_transform_constraint_update(spine_transform_constraint constraint); +SPINE_CPP_LITE_EXPORT int32_t spine_transform_constraint_get_order(spine_transform_constraint constraint); +SPINE_CPP_LITE_EXPORT spine_transform_constraint_data spine_transform_constraint_get_data(spine_transform_constraint constraint); +SPINE_CPP_LITE_EXPORT int32_t spine_transform_constraint_get_num_bones(spine_transform_constraint constraint); +SPINE_CPP_LITE_EXPORT spine_bone *spine_transform_constraint_get_bones(spine_transform_constraint constraint); +SPINE_CPP_LITE_EXPORT spine_bone spine_transform_constraint_get_target(spine_transform_constraint constraint); +SPINE_CPP_LITE_EXPORT void spine_transform_constraint_set_target(spine_transform_constraint constraint, spine_bone target); +SPINE_CPP_LITE_EXPORT float spine_transform_constraint_get_mix_rotate(spine_transform_constraint constraint); +SPINE_CPP_LITE_EXPORT void spine_transform_constraint_set_mix_rotate(spine_transform_constraint constraint, float mixRotate); +SPINE_CPP_LITE_EXPORT float spine_transform_constraint_get_mix_x(spine_transform_constraint constraint); +SPINE_CPP_LITE_EXPORT void spine_transform_constraint_set_mix_x(spine_transform_constraint constraint, float mixX); +SPINE_CPP_LITE_EXPORT float spine_transform_constraint_get_mix_y(spine_transform_constraint constraint); +SPINE_CPP_LITE_EXPORT void spine_transform_constraint_set_mix_y(spine_transform_constraint constraint, float mixY); +SPINE_CPP_LITE_EXPORT float spine_transform_constraint_get_mix_scale_x(spine_transform_constraint constraint); +SPINE_CPP_LITE_EXPORT void spine_transform_constraint_set_mix_scale_x(spine_transform_constraint constraint, float mixScaleX); +SPINE_CPP_LITE_EXPORT float spine_transform_constraint_get_mix_scale_y(spine_transform_constraint constraint); +SPINE_CPP_LITE_EXPORT void spine_transform_constraint_set_mix_scale_y(spine_transform_constraint constraint, float mixScaleY); +SPINE_CPP_LITE_EXPORT float spine_transform_constraint_get_mix_shear_y(spine_transform_constraint constraint); +SPINE_CPP_LITE_EXPORT void spine_transform_constraint_set_mix_shear_y(spine_transform_constraint constraint, float mixShearY); +SPINE_CPP_LITE_EXPORT float spine_transform_constraint_get_is_active(spine_transform_constraint constraint); +SPINE_CPP_LITE_EXPORT void spine_transform_constraint_set_is_active(spine_transform_constraint constraint, int32_t isActive); +// OMITTED setToSetupPose() + +SPINE_CPP_LITE_EXPORT int32_t spine_path_constraint_data_get_num_bones(spine_path_constraint_data data); +SPINE_CPP_LITE_EXPORT spine_bone_data *spine_path_constraint_data_get_bones(spine_path_constraint_data data); +SPINE_CPP_LITE_EXPORT spine_slot_data spine_path_constraint_data_get_target(spine_path_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_path_constraint_data_set_target(spine_path_constraint_data data, spine_slot_data target); +SPINE_CPP_LITE_EXPORT spine_position_mode spine_path_constraint_data_get_position_mode(spine_path_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_path_constraint_data_set_position_mode(spine_path_constraint_data data, spine_position_mode positionMode); +SPINE_CPP_LITE_EXPORT spine_spacing_mode spine_path_constraint_data_get_spacing_mode(spine_path_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_path_constraint_data_set_spacing_mode(spine_path_constraint_data data, spine_spacing_mode spacingMode); +SPINE_CPP_LITE_EXPORT spine_rotate_mode spine_path_constraint_data_get_rotate_mode(spine_path_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_path_constraint_data_set_rotate_mode(spine_path_constraint_data data, spine_rotate_mode rotateMode); +SPINE_CPP_LITE_EXPORT float spine_path_constraint_data_get_offset_rotation(spine_path_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_path_constraint_data_set_offset_rotation(spine_path_constraint_data data, float offsetRotation); +SPINE_CPP_LITE_EXPORT float spine_path_constraint_data_get_position(spine_path_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_path_constraint_data_set_position(spine_path_constraint_data data, float position); +SPINE_CPP_LITE_EXPORT float spine_path_constraint_data_get_spacing(spine_path_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_path_constraint_data_set_spacing(spine_path_constraint_data data, float spacing); +SPINE_CPP_LITE_EXPORT float spine_path_constraint_data_get_mix_rotate(spine_path_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_path_constraint_data_set_mix_rotate(spine_path_constraint_data data, float mixRotate); +SPINE_CPP_LITE_EXPORT float spine_path_constraint_data_get_mix_x(spine_path_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_path_constraint_data_set_mix_x(spine_path_constraint_data data, float mixX); +SPINE_CPP_LITE_EXPORT float spine_path_constraint_data_get_mix_y(spine_path_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_path_constraint_data_set_mix_y(spine_path_constraint_data data, float mixY); + +SPINE_CPP_LITE_EXPORT void spine_path_constraint_update(spine_path_constraint constraint); +SPINE_CPP_LITE_EXPORT int32_t spine_path_constraint_get_order(spine_path_constraint constraint); +SPINE_CPP_LITE_EXPORT spine_path_constraint_data spine_path_constraint_get_data(spine_path_constraint constraint); +SPINE_CPP_LITE_EXPORT int32_t spine_path_constraint_get_num_bones(spine_path_constraint constraint); +SPINE_CPP_LITE_EXPORT spine_bone *spine_path_constraint_get_bones(spine_path_constraint constraint); +SPINE_CPP_LITE_EXPORT spine_slot spine_path_constraint_get_target(spine_path_constraint constraint); +SPINE_CPP_LITE_EXPORT void spine_path_constraint_set_target(spine_path_constraint constraint, spine_slot target); +SPINE_CPP_LITE_EXPORT float spine_path_constraint_get_position(spine_path_constraint constraint); +SPINE_CPP_LITE_EXPORT void spine_path_constraint_set_position(spine_path_constraint constraint, float position); +SPINE_CPP_LITE_EXPORT float spine_path_constraint_get_spacing(spine_path_constraint constraint); +SPINE_CPP_LITE_EXPORT void spine_path_constraint_set_spacing(spine_path_constraint constraint, float spacing); +SPINE_CPP_LITE_EXPORT float spine_path_constraint_get_mix_rotate(spine_path_constraint constraint); +SPINE_CPP_LITE_EXPORT void spine_path_constraint_set_mix_rotate(spine_path_constraint constraint, float mixRotate); +SPINE_CPP_LITE_EXPORT float spine_path_constraint_get_mix_x(spine_path_constraint constraint); +SPINE_CPP_LITE_EXPORT void spine_path_constraint_set_mix_x(spine_path_constraint constraint, float mixX); +SPINE_CPP_LITE_EXPORT float spine_path_constraint_get_mix_y(spine_path_constraint constraint); +SPINE_CPP_LITE_EXPORT void spine_path_constraint_set_mix_y(spine_path_constraint constraint, float mixY); +SPINE_CPP_LITE_EXPORT int32_t spine_path_constraint_get_is_active(spine_path_constraint constraint); +SPINE_CPP_LITE_EXPORT void spine_path_constraint_set_is_active(spine_path_constraint constraint, int32_t isActive); +// OMITTED setToSetupPose() + +SPINE_CPP_LITE_EXPORT void spine_physics_constraint_data_set_bone(spine_physics_constraint_data data, spine_bone_data bone); +SPINE_CPP_LITE_EXPORT spine_bone_data spine_physics_constraint_data_get_bone(spine_physics_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_physics_constraint_data_set_x(spine_physics_constraint_data data, float x); +SPINE_CPP_LITE_EXPORT float spine_physics_constraint_data_get_x(spine_physics_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_physics_constraint_data_set_y(spine_physics_constraint_data data, float y); +SPINE_CPP_LITE_EXPORT float spine_physics_constraint_data_get_y(spine_physics_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_physics_constraint_data_set_rotate(spine_physics_constraint_data data, float rotate); +SPINE_CPP_LITE_EXPORT float spine_physics_constraint_data_get_rotate(spine_physics_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_physics_constraint_data_set_scale_x(spine_physics_constraint_data data, float scaleX); +SPINE_CPP_LITE_EXPORT float spine_physics_constraint_data_get_scale_x(spine_physics_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_physics_constraint_data_set_shear_x(spine_physics_constraint_data data, float shearX); +SPINE_CPP_LITE_EXPORT float spine_physics_constraint_data_get_shear_x(spine_physics_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_physics_constraint_data_set_limit(spine_physics_constraint_data data, float limit); +SPINE_CPP_LITE_EXPORT float spine_physics_constraint_data_get_limit(spine_physics_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_physics_constraint_data_set_step(spine_physics_constraint_data data, float step); +SPINE_CPP_LITE_EXPORT float spine_physics_constraint_data_get_step(spine_physics_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_physics_constraint_data_set_inertia(spine_physics_constraint_data data, float inertia); +SPINE_CPP_LITE_EXPORT float spine_physics_constraint_data_get_inertia(spine_physics_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_physics_constraint_data_set_strength(spine_physics_constraint_data data, float strength); +SPINE_CPP_LITE_EXPORT float spine_physics_constraint_data_get_strength(spine_physics_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_physics_constraint_data_set_damping(spine_physics_constraint_data data, float damping); +SPINE_CPP_LITE_EXPORT float spine_physics_constraint_data_get_damping(spine_physics_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_physics_constraint_data_set_mass_inverse(spine_physics_constraint_data data, float massInverse); +SPINE_CPP_LITE_EXPORT float spine_physics_constraint_data_get_mass_inverse(spine_physics_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_physics_constraint_data_set_wind(spine_physics_constraint_data data, float wind); +SPINE_CPP_LITE_EXPORT float spine_physics_constraint_data_get_wind(spine_physics_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_physics_constraint_data_set_gravity(spine_physics_constraint_data data, float gravity); +SPINE_CPP_LITE_EXPORT float spine_physics_constraint_data_get_gravity(spine_physics_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_physics_constraint_data_set_mix(spine_physics_constraint_data data, float mix); +SPINE_CPP_LITE_EXPORT float spine_physics_constraint_data_get_mix(spine_physics_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_physics_constraint_data_set_inertia_global(spine_physics_constraint_data data, int32_t inertiaGlobal); +SPINE_CPP_LITE_EXPORT int32_t spine_physics_constraint_data_is_inertia_global(spine_physics_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_physics_constraint_data_set_strength_global(spine_physics_constraint_data data, int32_t strengthGlobal); +SPINE_CPP_LITE_EXPORT int32_t spine_physics_constraint_data_is_strength_global(spine_physics_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_physics_constraint_data_set_damping_global(spine_physics_constraint_data data, int32_t dampingGlobal); +SPINE_CPP_LITE_EXPORT int32_t spine_physics_constraint_data_is_damping_global(spine_physics_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_physics_constraint_data_set_mass_global(spine_physics_constraint_data data, int32_t massGlobal); +SPINE_CPP_LITE_EXPORT int32_t spine_physics_constraint_data_is_mass_global(spine_physics_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_physics_constraint_data_set_wind_global(spine_physics_constraint_data data, int32_t windGlobal); +SPINE_CPP_LITE_EXPORT int32_t spine_physics_constraint_data_is_wind_global(spine_physics_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_physics_constraint_data_set_gravity_global(spine_physics_constraint_data data, int32_t gravityGlobal); +SPINE_CPP_LITE_EXPORT int32_t spine_physics_constraint_data_is_gravity_global(spine_physics_constraint_data data); +SPINE_CPP_LITE_EXPORT void spine_physics_constraint_data_set_mix_global(spine_physics_constraint_data data, int32_t mixGlobal); +SPINE_CPP_LITE_EXPORT int32_t spine_physics_constraint_data_is_mix_global(spine_physics_constraint_data data); + +SPINE_CPP_LITE_EXPORT void spine_physics_constraint_set_bone(spine_physics_constraint constraint, spine_bone bone); +SPINE_CPP_LITE_EXPORT spine_bone spine_physics_constraint_get_bone(spine_physics_constraint constraint); +SPINE_CPP_LITE_EXPORT void spine_physics_constraint_set_inertia(spine_physics_constraint constraint, float value); +SPINE_CPP_LITE_EXPORT float spine_physics_constraint_get_inertia(spine_physics_constraint constraint); +SPINE_CPP_LITE_EXPORT void spine_physics_constraint_set_strength(spine_physics_constraint constraint, float value); +SPINE_CPP_LITE_EXPORT float spine_physics_constraint_get_strength(spine_physics_constraint constraint); +SPINE_CPP_LITE_EXPORT void spine_physics_constraint_set_damping(spine_physics_constraint constraint, float value); +SPINE_CPP_LITE_EXPORT float spine_physics_constraint_get_damping(spine_physics_constraint constraint); +SPINE_CPP_LITE_EXPORT void spine_physics_constraint_set_mass_inverse(spine_physics_constraint constraint, float value); +SPINE_CPP_LITE_EXPORT float spine_physics_constraint_get_mass_inverse(spine_physics_constraint constraint); +SPINE_CPP_LITE_EXPORT void spine_physics_constraint_set_wind(spine_physics_constraint constraint, float value); +SPINE_CPP_LITE_EXPORT float spine_physics_constraint_get_wind(spine_physics_constraint constraint); +SPINE_CPP_LITE_EXPORT void spine_physics_constraint_set_gravity(spine_physics_constraint constraint, float value); +SPINE_CPP_LITE_EXPORT float spine_physics_constraint_get_gravity(spine_physics_constraint constraint); +SPINE_CPP_LITE_EXPORT void spine_physics_constraint_set_mix(spine_physics_constraint constraint, float value); +SPINE_CPP_LITE_EXPORT float spine_physics_constraint_get_mix(spine_physics_constraint constraint); +SPINE_CPP_LITE_EXPORT void spine_physics_constraint_set_reset(spine_physics_constraint constraint, int32_t value); +SPINE_CPP_LITE_EXPORT int32_t spine_physics_constraint_get_reset(spine_physics_constraint constraint); +SPINE_CPP_LITE_EXPORT void spine_physics_constraint_set_ux(spine_physics_constraint constraint, float value); +SPINE_CPP_LITE_EXPORT float spine_physics_constraint_get_ux(spine_physics_constraint constraint); +SPINE_CPP_LITE_EXPORT void spine_physics_constraint_set_uy(spine_physics_constraint constraint, float value); +SPINE_CPP_LITE_EXPORT float spine_physics_constraint_get_uy(spine_physics_constraint constraint); +SPINE_CPP_LITE_EXPORT void spine_physics_constraint_set_cx(spine_physics_constraint constraint, float value); +SPINE_CPP_LITE_EXPORT float spine_physics_constraint_get_cx(spine_physics_constraint constraint); +SPINE_CPP_LITE_EXPORT void spine_physics_constraint_set_cy(spine_physics_constraint constraint, float value); +SPINE_CPP_LITE_EXPORT float spine_physics_constraint_get_cy(spine_physics_constraint constraint); +SPINE_CPP_LITE_EXPORT void spine_physics_constraint_set_tx(spine_physics_constraint constraint, float value); +SPINE_CPP_LITE_EXPORT float spine_physics_constraint_get_tx(spine_physics_constraint constraint); +SPINE_CPP_LITE_EXPORT void spine_physics_constraint_set_ty(spine_physics_constraint constraint, float value); +SPINE_CPP_LITE_EXPORT float spine_physics_constraint_get_ty(spine_physics_constraint constraint); +SPINE_CPP_LITE_EXPORT void spine_physics_constraint_set_x_offset(spine_physics_constraint constraint, float value); +SPINE_CPP_LITE_EXPORT float spine_physics_constraint_get_x_offset(spine_physics_constraint constraint); +SPINE_CPP_LITE_EXPORT void spine_physics_constraint_set_x_velocity(spine_physics_constraint constraint, float value); +SPINE_CPP_LITE_EXPORT float spine_physics_constraint_get_x_velocity(spine_physics_constraint constraint); +SPINE_CPP_LITE_EXPORT void spine_physics_constraint_set_y_offset(spine_physics_constraint constraint, float value); +SPINE_CPP_LITE_EXPORT float spine_physics_constraint_get_y_offset(spine_physics_constraint constraint); +SPINE_CPP_LITE_EXPORT void spine_physics_constraint_set_y_velocity(spine_physics_constraint constraint, float value); +SPINE_CPP_LITE_EXPORT float spine_physics_constraint_get_y_velocity(spine_physics_constraint constraint); +SPINE_CPP_LITE_EXPORT void spine_physics_constraint_set_rotate_offset(spine_physics_constraint constraint, float value); +SPINE_CPP_LITE_EXPORT float spine_physics_constraint_get_rotate_offset(spine_physics_constraint constraint); +SPINE_CPP_LITE_EXPORT void spine_physics_constraint_set_rotate_velocity(spine_physics_constraint constraint, float value); +SPINE_CPP_LITE_EXPORT float spine_physics_constraint_get_rotate_velocity(spine_physics_constraint constraint); +SPINE_CPP_LITE_EXPORT void spine_physics_constraint_set_scale_offset(spine_physics_constraint constraint, float value); +SPINE_CPP_LITE_EXPORT float spine_physics_constraint_get_scale_offset(spine_physics_constraint constraint); +SPINE_CPP_LITE_EXPORT void spine_physics_constraint_set_scale_velocity(spine_physics_constraint constraint, float value); +SPINE_CPP_LITE_EXPORT float spine_physics_constraint_get_scale_velocity(spine_physics_constraint constraint); +SPINE_CPP_LITE_EXPORT void spine_physics_constraint_set_active(spine_physics_constraint constraint, int32_t value); +SPINE_CPP_LITE_EXPORT int32_t spine_physics_constraint_is_active(spine_physics_constraint constraint); +SPINE_CPP_LITE_EXPORT void spine_physics_constraint_set_remaining(spine_physics_constraint constraint, float value); +SPINE_CPP_LITE_EXPORT float spine_physics_constraint_get_remaining(spine_physics_constraint constraint); +SPINE_CPP_LITE_EXPORT void spine_physics_constraint_set_last_time(spine_physics_constraint constraint, float value); +SPINE_CPP_LITE_EXPORT float spine_physics_constraint_get_last_time(spine_physics_constraint constraint); +SPINE_CPP_LITE_EXPORT void spine_physics_constraint_reset(spine_physics_constraint constraint); +// Omitted setToSetupPose() +SPINE_CPP_LITE_EXPORT void spine_physics_constraint_update(spine_physics_constraint data, spine_physics physics); +SPINE_CPP_LITE_EXPORT void spine_physics_constraint_translate(spine_physics_constraint data, float x, float y); +SPINE_CPP_LITE_EXPORT void spine_physics_constraint_rotate(spine_physics_constraint data, float x, float y, float degrees); + + +// OMITTED copy() +SPINE_CPP_LITE_EXPORT void spine_sequence_apply(spine_sequence sequence, spine_slot slot, spine_attachment attachment); +SPINE_CPP_LITE_EXPORT const utf8 *spine_sequence_get_path(spine_sequence sequence, const utf8 *basePath, int32_t index); +SPINE_CPP_LITE_EXPORT int32_t spine_sequence_get_id(spine_sequence sequence); +SPINE_CPP_LITE_EXPORT void spine_sequence_set_id(spine_sequence sequence, int32_t id); +SPINE_CPP_LITE_EXPORT int32_t spine_sequence_get_start(spine_sequence sequence); +SPINE_CPP_LITE_EXPORT void spine_sequence_set_start(spine_sequence sequence, int32_t start); +SPINE_CPP_LITE_EXPORT int32_t spine_sequence_get_digits(spine_sequence sequence); +SPINE_CPP_LITE_EXPORT void spine_sequence_set_digits(spine_sequence sequence, int32_t digits); +SPINE_CPP_LITE_EXPORT int32_t spine_sequence_get_setup_index(spine_sequence sequence); +SPINE_CPP_LITE_EXPORT void spine_sequence_set_setup_index(spine_sequence sequence, int32_t setupIndex); +SPINE_CPP_LITE_EXPORT int32_t spine_sequence_get_num_regions(spine_sequence sequence); +SPINE_CPP_LITE_EXPORT spine_texture_region *spine_sequence_get_regions(spine_sequence sequence); + +SPINE_CPP_LITE_EXPORT void *spine_texture_region_get_texture(spine_texture_region textureRegion); +SPINE_CPP_LITE_EXPORT void spine_texture_region_set_texture(spine_texture_region textureRegion, void *texture); +SPINE_CPP_LITE_EXPORT float spine_texture_region_get_u(spine_texture_region textureRegion); +SPINE_CPP_LITE_EXPORT void spine_texture_region_set_u(spine_texture_region textureRegion, float u); +SPINE_CPP_LITE_EXPORT float spine_texture_region_get_v(spine_texture_region textureRegion); +SPINE_CPP_LITE_EXPORT void spine_texture_region_set_v(spine_texture_region textureRegion, float v); +SPINE_CPP_LITE_EXPORT float spine_texture_region_get_u2(spine_texture_region textureRegion); +SPINE_CPP_LITE_EXPORT void spine_texture_region_set_u2(spine_texture_region textureRegion, float u2); +SPINE_CPP_LITE_EXPORT float spine_texture_region_get_v2(spine_texture_region textureRegion); +SPINE_CPP_LITE_EXPORT void spine_texture_region_set_v2(spine_texture_region textureRegion, float v2); +SPINE_CPP_LITE_EXPORT int32_t spine_texture_region_get_degrees(spine_texture_region textureRegion); +SPINE_CPP_LITE_EXPORT void spine_texture_region_set_degrees(spine_texture_region textureRegion, int32_t degrees); +SPINE_CPP_LITE_EXPORT float spine_texture_region_get_offset_x(spine_texture_region textureRegion); +SPINE_CPP_LITE_EXPORT void spine_texture_region_set_offset_x(spine_texture_region textureRegion, float offsetX); +SPINE_CPP_LITE_EXPORT float spine_texture_region_get_offset_y(spine_texture_region textureRegion); +SPINE_CPP_LITE_EXPORT void spine_texture_region_set_offset_y(spine_texture_region textureRegion, float offsetY); +SPINE_CPP_LITE_EXPORT int32_t spine_texture_region_get_width(spine_texture_region textureRegion); +SPINE_CPP_LITE_EXPORT void spine_texture_region_set_width(spine_texture_region textureRegion, int32_t width); +SPINE_CPP_LITE_EXPORT int32_t spine_texture_region_get_height(spine_texture_region textureRegion); +SPINE_CPP_LITE_EXPORT void spine_texture_region_set_height(spine_texture_region textureRegion, int32_t height); +SPINE_CPP_LITE_EXPORT int32_t spine_texture_region_get_original_width(spine_texture_region textureRegion); +SPINE_CPP_LITE_EXPORT void spine_texture_region_set_original_width(spine_texture_region textureRegion, int32_t originalWidth); +SPINE_CPP_LITE_EXPORT int32_t spine_texture_region_get_original_height(spine_texture_region textureRegion); +SPINE_CPP_LITE_EXPORT void spine_texture_region_set_original_height(spine_texture_region textureRegion, int32_t originalHeight); + +#endif diff --git a/spine-flutter/src/spine_flutter.cpp b/spine-cpp/spine-cpp-lite/spine-cpp-lite.cpp similarity index 99% rename from spine-flutter/src/spine_flutter.cpp rename to spine-cpp/spine-cpp-lite/spine-cpp-lite.cpp index 039eaf7bc3..0dec18cf0b 100644 --- a/spine-flutter/src/spine_flutter.cpp +++ b/spine-cpp/spine-cpp-lite/spine-cpp-lite.cpp @@ -27,7 +27,7 @@ * SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *****************************************************************************/ -#include "spine_flutter.h" +#include "spine-cpp-light.h" #include #include #include @@ -64,7 +64,7 @@ class BlockAllocator : public SpineObject { } ~BlockAllocator() { - for (int i = 0; i < blocks.size(); i++) { + for (int i = 0, n = (int) blocks.size(); i < n; i++) { SpineExtension::free(blocks[i].memory, __FILE__, __LINE__); } } @@ -82,7 +82,7 @@ class BlockAllocator : public SpineObject { void compress() { int totalSize = 0; - for (int i = 0; i < blocks.size(); i++) { + for (int i = 0, n = blocks.size(); i < n; i++) { totalSize += blocks[i].size; SpineExtension::free(blocks[i].memory, __FILE__, __LINE__); } @@ -115,6 +115,7 @@ struct EventListener : public AnimationStateListenerObject { void callback(AnimationState *state, EventType type, TrackEntry *entry, Event *event) { events.add(AnimationStateEvent(type, entry, event)); + SP_UNUSED(state); } }; @@ -715,8 +716,8 @@ static _spine_render_command *batch_commands(BlockAllocator &allocator, Vector<_ int i = 1; int numVertices = first->numVertices; int numIndices = first->numIndices; - while (i <= commands.size()) { - _spine_render_command *cmd = i < commands.size() ? commands[i] : nullptr; + while (i <= (int) commands.size()) { + _spine_render_command *cmd = i < (int) commands.size() ? commands[i] : nullptr; if (cmd != nullptr && cmd->atlasPage == first->atlasPage && cmd->blendMode == first->blendMode && cmd->colors[0] == first->colors[0] && @@ -731,7 +732,7 @@ static _spine_render_command *batch_commands(BlockAllocator &allocator, Vector<_ last->next = batched; last = batched; } - if (i == commands.size()) break; + if (i == (int) commands.size()) break; first = commands[i]; startIndex = i; numVertices = first->numVertices; @@ -1097,21 +1098,21 @@ spine_event_type spine_animation_state_events_get_event_type(spine_animation_sta if (events == nullptr) return SPINE_EVENT_TYPE_DISPOSE; if (index < 0) return SPINE_EVENT_TYPE_DISPOSE; EventListener *_events = (EventListener *) events; - if (index >= _events->events.size()) return SPINE_EVENT_TYPE_DISPOSE; + if (index >= (int) _events->events.size()) return SPINE_EVENT_TYPE_DISPOSE; return (spine_event_type) _events->events[index].type; } spine_track_entry spine_animation_state_events_get_track_entry(spine_animation_state_events events, int32_t index) { if (events == nullptr) return nullptr; EventListener *_events = (EventListener *) events; - if (index >= _events->events.size()) return nullptr; + if (index >= (int) _events->events.size()) return nullptr; return (spine_track_entry) _events->events[index].entry; } spine_event spine_animation_state_events_get_event(spine_animation_state_events events, int32_t index) { if (events == nullptr) return nullptr; EventListener *_events = (EventListener *) events; - if (index >= _events->events.size()) return nullptr; + if (index >= (int) _events->events.size()) return nullptr; return (spine_event) _events->events[index].event; } diff --git a/spine-flutter/compile-wasm.sh b/spine-flutter/compile-wasm.sh index 6d82597280..4839ede566 100755 --- a/spine-flutter/compile-wasm.sh +++ b/spine-flutter/compile-wasm.sh @@ -22,7 +22,7 @@ em++ \ --no-entry \ --extern-pre-js pre.js \ -s EXPORT_NAME=libspine_flutter \ - src/spine_flutter.cpp `find src/spine-cpp/src -type f` \ + src/spine-cpp-lite/spine-cpp-lite.cpp `find src/spine-cpp/src -type f` \ -o lib/assets/libspine_flutter.js ls -lah lib/assets rm pre.js diff --git a/spine-flutter/ios/Classes/spine_flutter.cpp b/spine-flutter/ios/Classes/spine_flutter.cpp index ac5716e5d8..d0997749f1 100644 --- a/spine-flutter/ios/Classes/spine_flutter.cpp +++ b/spine-flutter/ios/Classes/spine_flutter.cpp @@ -1,3 +1,3 @@ // Relative import to be able to reuse the C sources. // See the comment in ../{projectName}}.podspec for more information. -#include "../../src/spine_flutter.cpp" +#include "../../src/spine-cpp-lite/spine-cpp-lite.cpp" diff --git a/spine-flutter/lib/assets/libspine_flutter.wasm b/spine-flutter/lib/assets/libspine_flutter.wasm index d9007a674bbdcb3f6836b6b198cd0316de242d2d..835e9a6cb89e6256d7b655fff0242ea3e7257769 100755 GIT binary patch delta 59234 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 diff --git a/spine-flutter/macos/Classes/spine_flutter.cpp b/spine-flutter/macos/Classes/spine_flutter.cpp index ac5716e5d8..d0997749f1 100644 --- a/spine-flutter/macos/Classes/spine_flutter.cpp +++ b/spine-flutter/macos/Classes/spine_flutter.cpp @@ -1,3 +1,3 @@ // Relative import to be able to reuse the C sources. // See the comment in ../{projectName}}.podspec for more information. -#include "../../src/spine_flutter.cpp" +#include "../../src/spine-cpp-lite/spine-cpp-lite.cpp" diff --git a/spine-flutter/setup.sh b/spine-flutter/setup.sh index d3bc20e7c5..da475ae5db 100755 --- a/spine-flutter/setup.sh +++ b/spine-flutter/setup.sh @@ -7,4 +7,5 @@ pushd $dir > /dev/null cp -r ../spine-cpp/spine-cpp ios/Classes cp -r ../spine-cpp/spine-cpp macos/Classes cp -r ../spine-cpp/spine-cpp src +cp -r ../spine-cpp/spine-cpp-lite src popd \ No newline at end of file diff --git a/spine-flutter/src/CMakeLists.txt b/spine-flutter/src/CMakeLists.txt index 2ef603602c..2bbe65ba6f 100644 --- a/spine-flutter/src/CMakeLists.txt +++ b/spine-flutter/src/CMakeLists.txt @@ -6,23 +6,16 @@ cmake_minimum_required(VERSION 3.10) project(pine_flutter_library VERSION 0.0.1) file(GLOB SPINE_SOURCES "spine-cpp/src/**/*.cpp") +file(GLOB SPINE_LITE_SOURCES "spine-cpp-lite/*.cpp") add_library(spine_flutter SHARED - "spine_flutter.cpp" ${SPINE_SOURCES} + ${SPINE_LITE_SOURCES} ) set_target_properties(spine_flutter PROPERTIES - PUBLIC_HEADER spine_flutter.h + PUBLIC_HEADER spine-cpp-lite/spine_flutter.h OUTPUT_NAME "spine_flutter" ) -target_include_directories(spine_flutter PUBLIC spine-cpp/include) -target_compile_definitions(spine_flutter PUBLIC DART_SHARED_LIB) - -if(${SPINE_FLUTTER_TESTBED}) -set (CMAKE_CXX_STANDARD 11) -set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fsanitize=address -fsanitize=undefined") -set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fsanitize=address -fsanitize=undefined") -add_executable(spine_flutter_test main.cpp spine_flutter.cpp ${SPINE_SOURCES}) -include_directories(spine_flutter_test PUBLIC spine-cpp/include) -endif() \ No newline at end of file +target_include_directories(spine_flutter PUBLIC spine-cpp/include spine-cpp-lite) +target_compile_definitions(spine_flutter PUBLIC DART_SHARED_LIB) \ No newline at end of file diff --git a/spine-flutter/src/spine_flutter.h b/spine-flutter/src/spine_flutter.h deleted file mode 100644 index fdb993659a..0000000000 --- a/spine-flutter/src/spine_flutter.h +++ /dev/null @@ -1,996 +0,0 @@ -/****************************************************************************** - * Spine Runtimes License Agreement - * Last updated July 28, 2023. Replaces all prior versions. - * - * Copyright (c) 2013-2023, Esoteric Software LLC - * - * Integration of the Spine Runtimes into software or otherwise creating - * derivative works of the Spine Runtimes is permitted under the terms and - * conditions of Section 2 of the Spine Editor License Agreement: - * http://esotericsoftware.com/spine-editor-license - * - * Otherwise, it is permitted to integrate the Spine Runtimes into software or - * otherwise create derivative works of the Spine Runtimes (collectively, - * "Products"), provided that each user of the Products must obtain their own - * Spine Editor license and redistribution of the Products in any form must - * include this license and copyright notice. - * - * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY - * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE - * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY - * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES - * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, - * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND - * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT - * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THE - * SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - *****************************************************************************/ - -#ifndef SPINE_FLUTTER -#define SPINE_FLUTTER - -#include - -#ifdef __cplusplus -#if _WIN32 -#define SPINE_FLUTTER_EXPORT extern "C" __declspec(dllexport) -#else -#ifdef __EMSCRIPTEN__ -#define SPINE_FLUTTER_EXPORT extern "C" __attribute__((used)) -#else -#define SPINE_FLUTTER_EXPORT extern "C" -#endif -#endif -#else -#if _WIN32 -#define SPINE_FLUTTER_EXPORT __declspec(dllexport) -#else -#ifdef __EMSCRIPTEN__ -#define SPINE_FLUTTER_EXPORT __attribute__((used)) -#else -#define SPINE_FLUTTER_EXPORT -#endif -#endif -#endif - -#define SPINE_OPAQUE_TYPE(name) \ - typedef struct name##_wrapper { \ - } name##_wrapper; \ - typedef name##_wrapper *name; - -SPINE_OPAQUE_TYPE(spine_skeleton) -SPINE_OPAQUE_TYPE(spine_skeleton_data) -SPINE_OPAQUE_TYPE(spine_bone) -SPINE_OPAQUE_TYPE(spine_bone_data) -SPINE_OPAQUE_TYPE(spine_slot) -SPINE_OPAQUE_TYPE(spine_slot_data) -SPINE_OPAQUE_TYPE(spine_skin) -SPINE_OPAQUE_TYPE(spine_attachment) -SPINE_OPAQUE_TYPE(spine_region_attachment) -SPINE_OPAQUE_TYPE(spine_vertex_attachment) -SPINE_OPAQUE_TYPE(spine_mesh_attachment) -SPINE_OPAQUE_TYPE(spine_clipping_attachment) -SPINE_OPAQUE_TYPE(spine_bounding_box_attachment) -SPINE_OPAQUE_TYPE(spine_path_attachment) -SPINE_OPAQUE_TYPE(spine_point_attachment) -SPINE_OPAQUE_TYPE(spine_texture_region) -SPINE_OPAQUE_TYPE(spine_sequence) -SPINE_OPAQUE_TYPE(spine_constraint) -SPINE_OPAQUE_TYPE(spine_constraint_data) -SPINE_OPAQUE_TYPE(spine_ik_constraint) -SPINE_OPAQUE_TYPE(spine_ik_constraint_data) -SPINE_OPAQUE_TYPE(spine_transform_constraint) -SPINE_OPAQUE_TYPE(spine_transform_constraint_data) -SPINE_OPAQUE_TYPE(spine_path_constraint) -SPINE_OPAQUE_TYPE(spine_path_constraint_data) -SPINE_OPAQUE_TYPE(spine_physics_constraint) -SPINE_OPAQUE_TYPE(spine_physics_constraint_data) -SPINE_OPAQUE_TYPE(spine_animation_state) -SPINE_OPAQUE_TYPE(spine_animation_state_data) -SPINE_OPAQUE_TYPE(spine_animation_state_events) -SPINE_OPAQUE_TYPE(spine_event) -SPINE_OPAQUE_TYPE(spine_event_data) -SPINE_OPAQUE_TYPE(spine_track_entry) -SPINE_OPAQUE_TYPE(spine_animation) -SPINE_OPAQUE_TYPE(spine_atlas) -SPINE_OPAQUE_TYPE(spine_skeleton_data_result) -SPINE_OPAQUE_TYPE(spine_render_command) -SPINE_OPAQUE_TYPE(spine_bounds) -SPINE_OPAQUE_TYPE(spine_color) -SPINE_OPAQUE_TYPE(spine_vector) -SPINE_OPAQUE_TYPE(spine_skeleton_drawable) -SPINE_OPAQUE_TYPE(spine_skin_entry) -SPINE_OPAQUE_TYPE(spine_skin_entries) - -typedef char utf8; - -typedef enum spine_blend_mode { - SPINE_BLEND_MODE_NORMAL = 0, - SPINE_BLEND_MODE_ADDITIVE, - SPINE_BLEND_MODE_MULTIPLY, - SPINE_BLEND_MODE_SCREEN -} spine_blend_mode; - -typedef enum spine_mix_blend { - SPINE_MIX_BLEND_SETUP = 0, - SPINE_MIX_BLEND_FIRST, - SPINE_MIX_BLEND_REPLACE, - SPINE_MIX_BLEND_ADD -} spine_mix_blend; - -typedef enum spine_event_type { - SPINE_EVENT_TYPE_START = 0, - SPINE_EVENT_TYPE_INTERRUPT, - SPINE_EVENT_TYPE_END, - SPINE_EVENT_TYPE_COMPLETE, - SPINE_EVENT_TYPE_DISPOSE, - SPINE_EVENT_TYPE_EVENT -} spine_event_type; - -typedef enum spine_attachment_type { - SPINE_ATTACHMENT_REGION = 0, - SPINE_ATTACHMENT_MESH, - SPINE_ATTACHMENT_CLIPPING, - SPINE_ATTACHMENT_BOUNDING_BOX, - SPINE_ATTACHMENT_PATH, - SPINE_ATTACHMENT_POINT, -} spine_attachment_type; - -typedef enum spine_constraint_type { - SPINE_CONSTRAINT_IK, - SPINE_CONSTRAINT_TRANSFORM, - SPINE_CONSTRAINT_PATH -} spine_constraint_type; - -typedef enum spine_inherit { - SPINE_INHERIT_NORMAL = 0, - SPINE_INHERIT_ONLY_TRANSLATION, - SPINE_INHERIT_NO_ROTATION_OR_REFLECTION, - SPINE_INHERIT_NO_SCALE, - SPINE_INHERIT_NO_SCALE_OR_REFLECTION -} spine_inherit; - -typedef enum spine_position_mode { - SPINE_POSITION_MODE_FIXED = 0, - SPINE_POSITION_MODE_PERCENT -} spine_position_mode; - -typedef enum spine_spacing_mode { - SPINE_SPACING_MODE_LENGTH = 0, - SPINE_SPACING_MODE_FIXED, - SPINE_SPACING_MODE_PERCENT, - SPINE_SPACING_MODE_PROPORTIONAL -} spine_spacing_mode; - -typedef enum spine_rotate_mode { - SPINE_ROTATE_MODE_TANGENT = 0, - SPINE_ROTATE_MODE_CHAIN, - SPINE_ROTATE_MODE_CHAIN_SCALE -} spine_rotate_mode; - -typedef enum spine_physics { - SPINE_PHYSICS_NONE = 0, - SPINE_PHYSICS_RESET, - SPINE_PHYSICS_UPDATE, - SPINE_PHYSICS_POSE - -} spine_physics; - -SPINE_FLUTTER_EXPORT int32_t spine_major_version(); -SPINE_FLUTTER_EXPORT int32_t spine_minor_version(); -SPINE_FLUTTER_EXPORT void spine_enable_debug_extension(int32_t enable); -SPINE_FLUTTER_EXPORT void spine_report_leaks(); - -SPINE_FLUTTER_EXPORT float spine_color_get_r(spine_color color); -SPINE_FLUTTER_EXPORT float spine_color_get_g(spine_color color); -SPINE_FLUTTER_EXPORT float spine_color_get_b(spine_color color); -SPINE_FLUTTER_EXPORT float spine_color_get_a(spine_color color); - -SPINE_FLUTTER_EXPORT float spine_bounds_get_x(spine_bounds bounds); -SPINE_FLUTTER_EXPORT float spine_bounds_get_y(spine_bounds bounds); -SPINE_FLUTTER_EXPORT float spine_bounds_get_width(spine_bounds bounds); -SPINE_FLUTTER_EXPORT float spine_bounds_get_height(spine_bounds bounds); - -SPINE_FLUTTER_EXPORT float spine_vector_get_x(spine_vector vector); -SPINE_FLUTTER_EXPORT float spine_vector_get_y(spine_vector vector); - -SPINE_FLUTTER_EXPORT spine_atlas spine_atlas_load(const utf8 *atlasData); -SPINE_FLUTTER_EXPORT int32_t spine_atlas_get_num_image_paths(spine_atlas atlas); -SPINE_FLUTTER_EXPORT utf8 *spine_atlas_get_image_path(spine_atlas atlas, int32_t index); -SPINE_FLUTTER_EXPORT utf8 *spine_atlas_get_error(spine_atlas atlas); -SPINE_FLUTTER_EXPORT void spine_atlas_dispose(spine_atlas atlas); - -SPINE_FLUTTER_EXPORT spine_skeleton_data_result spine_skeleton_data_load_json(spine_atlas atlas, const utf8 *skeletonData); -SPINE_FLUTTER_EXPORT spine_skeleton_data_result spine_skeleton_data_load_binary(spine_atlas atlas, const uint8_t *skeletonData, int32_t length); -SPINE_FLUTTER_EXPORT utf8 *spine_skeleton_data_result_get_error(spine_skeleton_data_result result); -SPINE_FLUTTER_EXPORT spine_skeleton_data spine_skeleton_data_result_get_data(spine_skeleton_data_result result); -SPINE_FLUTTER_EXPORT void spine_skeleton_data_result_dispose(spine_skeleton_data_result result); -SPINE_FLUTTER_EXPORT spine_bone_data spine_skeleton_data_find_bone(spine_skeleton_data data, const utf8 *name); -SPINE_FLUTTER_EXPORT spine_slot_data spine_skeleton_data_find_slot(spine_skeleton_data data, const utf8 *name); -SPINE_FLUTTER_EXPORT spine_skin spine_skeleton_data_find_skin(spine_skeleton_data data, const utf8 *name); -SPINE_FLUTTER_EXPORT spine_event_data spine_skeleton_data_find_event(spine_skeleton_data data, const utf8 *name); -SPINE_FLUTTER_EXPORT spine_animation spine_skeleton_data_find_animation(spine_skeleton_data data, const utf8 *name); -SPINE_FLUTTER_EXPORT spine_ik_constraint_data spine_skeleton_data_find_ik_constraint(spine_skeleton_data data, const utf8 *name); -SPINE_FLUTTER_EXPORT spine_transform_constraint_data spine_skeleton_data_find_transform_constraint(spine_skeleton_data data, const utf8 *name); -SPINE_FLUTTER_EXPORT spine_path_constraint_data spine_skeleton_data_find_path_constraint(spine_skeleton_data data, const utf8 *name); -SPINE_FLUTTER_EXPORT spine_physics_constraint_data spine_skeleton_data_find_physics_constraint(spine_skeleton_data data, const utf8 *name); -SPINE_FLUTTER_EXPORT const utf8 *spine_skeleton_data_get_name(spine_skeleton_data data); -// OMITTED setName() -SPINE_FLUTTER_EXPORT int32_t spine_skeleton_data_get_num_bones(spine_skeleton_data data); -SPINE_FLUTTER_EXPORT spine_bone_data *spine_skeleton_data_get_bones(spine_skeleton_data data); -SPINE_FLUTTER_EXPORT int32_t spine_skeleton_data_get_num_slots(spine_skeleton_data data); -SPINE_FLUTTER_EXPORT spine_slot_data *spine_skeleton_data_get_slots(spine_skeleton_data data); -SPINE_FLUTTER_EXPORT int32_t spine_skeleton_data_get_num_skins(spine_skeleton_data data); -SPINE_FLUTTER_EXPORT spine_skin *spine_skeleton_data_get_skins(spine_skeleton_data data); -SPINE_FLUTTER_EXPORT spine_skin spine_skeleton_data_get_default_skin(spine_skeleton_data data); -SPINE_FLUTTER_EXPORT void spine_skeleton_data_set_default_skin(spine_skeleton_data data, spine_skin skin); -SPINE_FLUTTER_EXPORT int32_t spine_skeleton_data_get_num_events(spine_skeleton_data data); -SPINE_FLUTTER_EXPORT spine_event_data *spine_skeleton_data_get_events(spine_skeleton_data data); -SPINE_FLUTTER_EXPORT int32_t spine_skeleton_data_get_num_animations(spine_skeleton_data data); -SPINE_FLUTTER_EXPORT spine_animation *spine_skeleton_data_get_animations(spine_skeleton_data data); -SPINE_FLUTTER_EXPORT int32_t spine_skeleton_data_get_num_ik_constraints(spine_skeleton_data data); -SPINE_FLUTTER_EXPORT spine_ik_constraint_data *spine_skeleton_data_get_ik_constraints(spine_skeleton_data data); -SPINE_FLUTTER_EXPORT int32_t spine_skeleton_data_get_num_transform_constraints(spine_skeleton_data data); -SPINE_FLUTTER_EXPORT spine_transform_constraint_data *spine_skeleton_data_get_transform_constraints(spine_skeleton_data data); -SPINE_FLUTTER_EXPORT int32_t spine_skeleton_data_get_num_path_constraints(spine_skeleton_data data); -SPINE_FLUTTER_EXPORT spine_path_constraint_data *spine_skeleton_data_get_path_constraints(spine_skeleton_data data); -SPINE_FLUTTER_EXPORT int32_t spine_skeleton_data_get_num_physics_constraints(spine_skeleton_data data); -SPINE_FLUTTER_EXPORT spine_physics_constraint_data *spine_skeleton_data_get_physics_constraints(spine_skeleton_data data); -SPINE_FLUTTER_EXPORT float spine_skeleton_data_get_x(spine_skeleton_data data); -SPINE_FLUTTER_EXPORT void spine_skeleton_data_set_x(spine_skeleton_data data, float x); -SPINE_FLUTTER_EXPORT float spine_skeleton_data_get_y(spine_skeleton_data data); -SPINE_FLUTTER_EXPORT void spine_skeleton_data_set_y(spine_skeleton_data data, float y); -SPINE_FLUTTER_EXPORT float spine_skeleton_data_get_width(spine_skeleton_data data); -SPINE_FLUTTER_EXPORT void spine_skeleton_data_set_width(spine_skeleton_data data, float width); -SPINE_FLUTTER_EXPORT float spine_skeleton_data_get_height(spine_skeleton_data data); -SPINE_FLUTTER_EXPORT void spine_skeleton_data_set_height(spine_skeleton_data data, float height); -SPINE_FLUTTER_EXPORT const utf8 *spine_skeleton_data_get_version(spine_skeleton_data data); -// OMITTED setVersion() -SPINE_FLUTTER_EXPORT const utf8 *spine_skeleton_data_get_hash(spine_skeleton_data data); -// OMITTED setHash() -SPINE_FLUTTER_EXPORT const utf8 *spine_skeleton_data_get_images_path(spine_skeleton_data data); -// OMITTED setImagesPath() -SPINE_FLUTTER_EXPORT const utf8 *spine_skeleton_data_get_audio_path(spine_skeleton_data data); -// OMITTED setAudioPath() -SPINE_FLUTTER_EXPORT float spine_skeleton_data_get_fps(spine_skeleton_data data); -// OMITTED setFps() -SPINE_FLUTTER_EXPORT float spine_skeleton_data_get_reference_scale(spine_skeleton_data data); -SPINE_FLUTTER_EXPORT void spine_skeleton_data_dispose(spine_skeleton_data data); - -SPINE_FLUTTER_EXPORT spine_skeleton_drawable spine_skeleton_drawable_create(spine_skeleton_data skeletonData); -SPINE_FLUTTER_EXPORT spine_render_command spine_skeleton_drawable_render(spine_skeleton_drawable drawable); -SPINE_FLUTTER_EXPORT void spine_skeleton_drawable_dispose(spine_skeleton_drawable drawable); -SPINE_FLUTTER_EXPORT spine_skeleton spine_skeleton_drawable_get_skeleton(spine_skeleton_drawable drawable); -SPINE_FLUTTER_EXPORT spine_animation_state spine_skeleton_drawable_get_animation_state(spine_skeleton_drawable drawable); -SPINE_FLUTTER_EXPORT spine_animation_state_data spine_skeleton_drawable_get_animation_state_data(spine_skeleton_drawable drawable); -SPINE_FLUTTER_EXPORT spine_animation_state_events spine_skeleton_drawable_get_animation_state_events(spine_skeleton_drawable drawable); - -SPINE_FLUTTER_EXPORT float *spine_render_command_get_positions(spine_render_command command); -SPINE_FLUTTER_EXPORT float *spine_render_command_get_uvs(spine_render_command command); -SPINE_FLUTTER_EXPORT int32_t *spine_render_command_get_colors(spine_render_command command); -SPINE_FLUTTER_EXPORT int32_t spine_render_command_get_num_vertices(spine_render_command command); -SPINE_FLUTTER_EXPORT uint16_t *spine_render_command_get_indices(spine_render_command command); -SPINE_FLUTTER_EXPORT int32_t spine_render_command_get_num_indices(spine_render_command command); -SPINE_FLUTTER_EXPORT int32_t spine_render_command_get_atlas_page(spine_render_command command); -SPINE_FLUTTER_EXPORT spine_blend_mode spine_render_command_get_blend_mode(spine_render_command command); -SPINE_FLUTTER_EXPORT spine_render_command spine_render_command_get_next(spine_render_command command); - -SPINE_FLUTTER_EXPORT const utf8 *spine_animation_get_name(spine_animation animation); -// OMITTED getTimelines() -// OMITTED hasTimeline() -SPINE_FLUTTER_EXPORT float spine_animation_get_duration(spine_animation animation); -// OMITTED setDuration() - -SPINE_FLUTTER_EXPORT spine_skeleton_data spine_animation_state_data_get_skeleton_data(spine_animation_state_data stateData); -SPINE_FLUTTER_EXPORT float spine_animation_state_data_get_default_mix(spine_animation_state_data stateData); -SPINE_FLUTTER_EXPORT void spine_animation_state_data_set_default_mix(spine_animation_state_data stateData, float defaultMix); -SPINE_FLUTTER_EXPORT void spine_animation_state_data_set_mix(spine_animation_state_data stateData, spine_animation from, spine_animation to, float duration); -SPINE_FLUTTER_EXPORT float spine_animation_state_data_get_mix(spine_animation_state_data stateData, spine_animation from, spine_animation to); -SPINE_FLUTTER_EXPORT void spine_animation_state_data_set_mix_by_name(spine_animation_state_data stateData, const utf8 *fromName, const utf8 *toName, float duration); -SPINE_FLUTTER_EXPORT float spine_animation_state_data_get_mix_by_name(spine_animation_state_data stateData, const utf8 *fromName, const utf8 *toName); -SPINE_FLUTTER_EXPORT void spine_animation_state_data_clear(spine_animation_state_data stateData); - -SPINE_FLUTTER_EXPORT void spine_animation_state_update(spine_animation_state state, float delta); -SPINE_FLUTTER_EXPORT void spine_animation_state_apply(spine_animation_state state, spine_skeleton skeleton); -SPINE_FLUTTER_EXPORT void spine_animation_state_clear_tracks(spine_animation_state state); -SPINE_FLUTTER_EXPORT void spine_animation_state_clear_track(spine_animation_state state, int32_t trackIndex); -SPINE_FLUTTER_EXPORT int32_t spine_animation_state_get_num_tracks(spine_animation_state state); -SPINE_FLUTTER_EXPORT spine_track_entry spine_animation_state_set_animation_by_name(spine_animation_state state, int32_t trackIndex, const utf8 *animationName, int32_t loop); -SPINE_FLUTTER_EXPORT spine_track_entry spine_animation_state_set_animation(spine_animation_state state, int32_t trackIndex, spine_animation animation, int32_t loop); -SPINE_FLUTTER_EXPORT spine_track_entry spine_animation_state_add_animation_by_name(spine_animation_state state, int32_t trackIndex, const utf8 *animationName, int32_t loop, float delay); -SPINE_FLUTTER_EXPORT spine_track_entry spine_animation_state_add_animation(spine_animation_state state, int32_t trackIndex, spine_animation animation, int32_t loop, float delay); -SPINE_FLUTTER_EXPORT spine_track_entry spine_animation_state_set_empty_animation(spine_animation_state state, int32_t trackIndex, float mixDuration); -SPINE_FLUTTER_EXPORT spine_track_entry spine_animation_state_add_empty_animation(spine_animation_state state, int32_t trackIndex, float mixDuration, float delay); -SPINE_FLUTTER_EXPORT void spine_animation_state_set_empty_animations(spine_animation_state state, float mixDuration); -SPINE_FLUTTER_EXPORT spine_track_entry spine_animation_state_get_current(spine_animation_state state, int32_t trackIndex); -SPINE_FLUTTER_EXPORT spine_animation_state_data spine_animation_state_get_data(spine_animation_state state); -SPINE_FLUTTER_EXPORT float spine_animation_state_get_time_scale(spine_animation_state state); -SPINE_FLUTTER_EXPORT void spine_animation_state_set_time_scale(spine_animation_state state, float timeScale); -// OMITTED setListener() -// OMITTED setListener() -// OMITTED disableQueue() -// OMITTED enableQueue() -// OMITTED setManualTrackEntryDisposal() -// OMITTED getManualTrackEntryDisposal() -SPINE_FLUTTER_EXPORT void spine_animation_state_dispose_track_entry(spine_animation_state state, spine_track_entry entry); - -SPINE_FLUTTER_EXPORT int32_t spine_animation_state_events_get_num_events(spine_animation_state_events events); -SPINE_FLUTTER_EXPORT spine_event_type spine_animation_state_events_get_event_type(spine_animation_state_events events, int32_t index); -SPINE_FLUTTER_EXPORT spine_track_entry spine_animation_state_events_get_track_entry(spine_animation_state_events events, int32_t index); -SPINE_FLUTTER_EXPORT spine_event spine_animation_state_events_get_event(spine_animation_state_events events, int32_t index); -SPINE_FLUTTER_EXPORT void spine_animation_state_events_reset(spine_animation_state_events events); - -SPINE_FLUTTER_EXPORT int32_t spine_track_entry_get_track_index(spine_track_entry entry); -SPINE_FLUTTER_EXPORT spine_animation spine_track_entry_get_animation(spine_track_entry entry); -SPINE_FLUTTER_EXPORT spine_track_entry spine_track_entry_get_previous(spine_track_entry entry); -SPINE_FLUTTER_EXPORT int32_t spine_track_entry_get_loop(spine_track_entry entry); -SPINE_FLUTTER_EXPORT void spine_track_entry_set_loop(spine_track_entry entry, int32_t loop); -SPINE_FLUTTER_EXPORT int32_t spine_track_entry_get_hold_previous(spine_track_entry entry); -SPINE_FLUTTER_EXPORT void spine_track_entry_set_hold_previous(spine_track_entry entry, int32_t holdPrevious); -SPINE_FLUTTER_EXPORT int32_t spine_track_entry_get_reverse(spine_track_entry entry); -SPINE_FLUTTER_EXPORT void spine_track_entry_set_reverse(spine_track_entry entry, int32_t reverse); -SPINE_FLUTTER_EXPORT int32_t spine_track_entry_get_shortest_rotation(spine_track_entry entry); -SPINE_FLUTTER_EXPORT void spine_track_entry_set_shortest_rotation(spine_track_entry entry, int32_t shortestRotation); -SPINE_FLUTTER_EXPORT float spine_track_entry_get_delay(spine_track_entry entry); -SPINE_FLUTTER_EXPORT void spine_track_entry_set_delay(spine_track_entry entry, float delay); -SPINE_FLUTTER_EXPORT float spine_track_entry_get_track_time(spine_track_entry entry); -SPINE_FLUTTER_EXPORT void spine_track_entry_set_track_time(spine_track_entry entry, float trackTime); -SPINE_FLUTTER_EXPORT float spine_track_entry_get_track_end(spine_track_entry entry); -SPINE_FLUTTER_EXPORT void spine_track_entry_set_track_end(spine_track_entry entry, float trackEnd); -SPINE_FLUTTER_EXPORT float spine_track_entry_get_animation_start(spine_track_entry entry); -SPINE_FLUTTER_EXPORT void spine_track_entry_set_animation_start(spine_track_entry entry, float animationStart); -SPINE_FLUTTER_EXPORT float spine_track_entry_get_animation_end(spine_track_entry entry); -SPINE_FLUTTER_EXPORT void spine_track_entry_set_animation_end(spine_track_entry entry, float animationEnd); -SPINE_FLUTTER_EXPORT float spine_track_entry_get_animation_last(spine_track_entry entry); -SPINE_FLUTTER_EXPORT void spine_track_entry_set_animation_last(spine_track_entry entry, float animationLast); -SPINE_FLUTTER_EXPORT float spine_track_entry_get_animation_time(spine_track_entry entry); -SPINE_FLUTTER_EXPORT float spine_track_entry_get_time_scale(spine_track_entry entry); -SPINE_FLUTTER_EXPORT void spine_track_entry_set_time_scale(spine_track_entry entry, float timeScale); -SPINE_FLUTTER_EXPORT float spine_track_entry_get_alpha(spine_track_entry entry); -SPINE_FLUTTER_EXPORT void spine_track_entry_set_alpha(spine_track_entry entry, float alpha); -SPINE_FLUTTER_EXPORT float spine_track_entry_get_event_threshold(spine_track_entry entry); -SPINE_FLUTTER_EXPORT void spine_track_entry_set_event_threshold(spine_track_entry entry, float eventThreshold); -SPINE_FLUTTER_EXPORT float spine_track_entry_get_alpha_attachment_threshold(spine_track_entry entry); -SPINE_FLUTTER_EXPORT void spine_track_entry_set_alpha_attachment_threshold(spine_track_entry entry, float attachmentThreshold); -SPINE_FLUTTER_EXPORT float spine_track_entry_get_mix_attachment_threshold(spine_track_entry entry); -SPINE_FLUTTER_EXPORT void spine_track_entry_set_mix_attachment_threshold(spine_track_entry entry, float attachmentThreshold); -SPINE_FLUTTER_EXPORT float spine_track_entry_get_mix_draw_order_threshold(spine_track_entry entry); -SPINE_FLUTTER_EXPORT void spine_track_entry_set_mix_draw_order_threshold(spine_track_entry entry, float drawOrderThreshold); -SPINE_FLUTTER_EXPORT spine_track_entry spine_track_entry_get_next(spine_track_entry entry); -SPINE_FLUTTER_EXPORT int32_t spine_track_entry_is_complete(spine_track_entry entry); -SPINE_FLUTTER_EXPORT float spine_track_entry_get_mix_time(spine_track_entry entry); -SPINE_FLUTTER_EXPORT void spine_track_entry_set_mix_time(spine_track_entry entry, float mixTime); -SPINE_FLUTTER_EXPORT float spine_track_entry_get_mix_duration(spine_track_entry entry); -SPINE_FLUTTER_EXPORT void spine_track_entry_set_mix_duration(spine_track_entry entry, float mixDuration); -SPINE_FLUTTER_EXPORT spine_mix_blend spine_track_entry_get_mix_blend(spine_track_entry entry); -SPINE_FLUTTER_EXPORT void spine_track_entry_set_mix_blend(spine_track_entry entry, spine_mix_blend mixBlend); -SPINE_FLUTTER_EXPORT spine_track_entry spine_track_entry_get_mixing_from(spine_track_entry entry); -SPINE_FLUTTER_EXPORT spine_track_entry spine_track_entry_get_mixing_to(spine_track_entry entry); -SPINE_FLUTTER_EXPORT void spine_track_entry_reset_rotation_directions(spine_track_entry entry); -SPINE_FLUTTER_EXPORT float spine_track_entry_get_track_complete(spine_track_entry entry); -// OMITTED setListener() -// OMITTED setListener() - -SPINE_FLUTTER_EXPORT void spine_skeleton_update_cache(spine_skeleton skeleton); -// OMITTED printUpdateCache() -SPINE_FLUTTER_EXPORT void spine_skeleton_update_world_transform(spine_skeleton skeleton, spine_physics physics); -SPINE_FLUTTER_EXPORT void spine_skeleton_update_world_transform_bone(spine_skeleton skeleton, spine_physics physics, spine_bone parent); -SPINE_FLUTTER_EXPORT void spine_skeleton_set_to_setup_pose(spine_skeleton skeleton); -SPINE_FLUTTER_EXPORT void spine_skeleton_set_bones_to_setup_pose(spine_skeleton skeleton); -SPINE_FLUTTER_EXPORT void spine_skeleton_set_slots_to_setup_pose(spine_skeleton skeleton); -SPINE_FLUTTER_EXPORT spine_bone spine_skeleton_find_bone(spine_skeleton skeleton, const utf8 *boneName); -SPINE_FLUTTER_EXPORT spine_slot spine_skeleton_find_slot(spine_skeleton skeleton, const utf8 *slotName); -SPINE_FLUTTER_EXPORT void spine_skeleton_set_skin_by_name(spine_skeleton skeleton, const utf8 *skinName); -SPINE_FLUTTER_EXPORT void spine_skeleton_set_skin(spine_skeleton skeleton, spine_skin skin); -SPINE_FLUTTER_EXPORT spine_attachment spine_skeleton_get_attachment_by_name(spine_skeleton skeleton, const utf8 *slotName, const utf8 *attachmentName); -SPINE_FLUTTER_EXPORT spine_attachment spine_skeleton_get_attachment(spine_skeleton skeleton, int32_t slotIndex, const utf8 *attachmentName); -SPINE_FLUTTER_EXPORT void spine_skeleton_set_attachment(spine_skeleton skeleton, const utf8 *slotName, const utf8 *attachmentName); -SPINE_FLUTTER_EXPORT spine_ik_constraint spine_skeleton_find_ik_constraint(spine_skeleton skeleton, const utf8 *constraintName); -SPINE_FLUTTER_EXPORT spine_transform_constraint spine_skeleton_find_transform_constraint(spine_skeleton skeleton, const utf8 *constraintName); -SPINE_FLUTTER_EXPORT spine_path_constraint spine_skeleton_find_path_constraint(spine_skeleton skeleton, const utf8 *constraintName); -SPINE_FLUTTER_EXPORT spine_physics_constraint spine_skeleton_find_physics_constraint(spine_skeleton skeleton, const utf8 *constraintName); -SPINE_FLUTTER_EXPORT spine_bounds spine_skeleton_get_bounds(spine_skeleton skeleton); -SPINE_FLUTTER_EXPORT spine_bone spine_skeleton_get_root_bone(spine_skeleton skeleton); -SPINE_FLUTTER_EXPORT spine_skeleton_data spine_skeleton_get_data(spine_skeleton skeleton); -SPINE_FLUTTER_EXPORT int32_t spine_skeleton_get_num_bones(spine_skeleton skeleton); -SPINE_FLUTTER_EXPORT spine_bone *spine_skeleton_get_bones(spine_skeleton skeleton); -// OMITTED getUpdateCacheList() -SPINE_FLUTTER_EXPORT int32_t spine_skeleton_get_num_slots(spine_skeleton skeleton); -SPINE_FLUTTER_EXPORT spine_slot *spine_skeleton_get_slots(spine_skeleton skeleton); -SPINE_FLUTTER_EXPORT int32_t spine_skeleton_get_num_draw_order(spine_skeleton skeleton); -SPINE_FLUTTER_EXPORT spine_slot *spine_skeleton_get_draw_order(spine_skeleton skeleton); -SPINE_FLUTTER_EXPORT int32_t spine_skeleton_get_num_ik_constraints(spine_skeleton skeleton); -SPINE_FLUTTER_EXPORT spine_ik_constraint *spine_skeleton_get_ik_constraints(spine_skeleton skeleton); -SPINE_FLUTTER_EXPORT int32_t spine_skeleton_get_num_transform_constraints(spine_skeleton skeleton); -SPINE_FLUTTER_EXPORT spine_transform_constraint *spine_skeleton_get_transform_constraints(spine_skeleton skeleton); -SPINE_FLUTTER_EXPORT int32_t spine_skeleton_get_num_path_constraints(spine_skeleton skeleton); -SPINE_FLUTTER_EXPORT spine_path_constraint *spine_skeleton_get_path_constraints(spine_skeleton skeleton); -SPINE_FLUTTER_EXPORT int32_t spine_skeleton_get_num_physics_constraints(spine_skeleton skeleton); -SPINE_FLUTTER_EXPORT spine_physics_constraint *spine_skeleton_get_physics_constraints(spine_skeleton skeleton); -SPINE_FLUTTER_EXPORT spine_skin spine_skeleton_get_skin(spine_skeleton skeleton); -SPINE_FLUTTER_EXPORT spine_color spine_skeleton_get_color(spine_skeleton skeleton); -SPINE_FLUTTER_EXPORT void spine_skeleton_set_color(spine_skeleton skeleton, float r, float g, float b, float a); -SPINE_FLUTTER_EXPORT void spine_skeleton_set_position(spine_skeleton skeleton, float x, float y); -SPINE_FLUTTER_EXPORT float spine_skeleton_get_x(spine_skeleton skeleton); -SPINE_FLUTTER_EXPORT void spine_skeleton_set_x(spine_skeleton skeleton, float x); -SPINE_FLUTTER_EXPORT float spine_skeleton_get_y(spine_skeleton skeleton); -SPINE_FLUTTER_EXPORT void spine_skeleton_set_y(spine_skeleton skeleton, float y); -SPINE_FLUTTER_EXPORT float spine_skeleton_get_scale_x(spine_skeleton skeleton); -SPINE_FLUTTER_EXPORT void spine_skeleton_set_scale_x(spine_skeleton skeleton, float scaleX); -SPINE_FLUTTER_EXPORT float spine_skeleton_get_scale_y(spine_skeleton skeleton); -SPINE_FLUTTER_EXPORT void spine_skeleton_set_scale_y(spine_skeleton skeleton, float scaleY); -SPINE_FLUTTER_EXPORT float spine_skeleton_get_time(spine_skeleton skeleton); -SPINE_FLUTTER_EXPORT void spine_skeleton_set_time(spine_skeleton skeleton, float time); -SPINE_FLUTTER_EXPORT void spine_skeleton_update(spine_skeleton skeleton, float delta); - -SPINE_FLUTTER_EXPORT const utf8 *spine_event_data_get_name(spine_event_data event); -SPINE_FLUTTER_EXPORT int32_t spine_event_data_get_int_value(spine_event_data event); -SPINE_FLUTTER_EXPORT void spine_event_data_set_int_value(spine_event_data event, int32_t value); -SPINE_FLUTTER_EXPORT float spine_event_data_get_float_value(spine_event_data event); -SPINE_FLUTTER_EXPORT void spine_event_data_set_float_value(spine_event_data event, float value); -SPINE_FLUTTER_EXPORT const utf8 *spine_event_data_get_string_value(spine_event_data event); -SPINE_FLUTTER_EXPORT void spine_event_data_set_string_value(spine_event_data event, const utf8 *value); -SPINE_FLUTTER_EXPORT const utf8 *spine_event_data_get_audio_path(spine_event_data event); -// OMITTED setAudioPath() -SPINE_FLUTTER_EXPORT float spine_event_data_get_volume(spine_event_data event); -SPINE_FLUTTER_EXPORT void spine_event_data_set_volume(spine_event_data event, float volume); -SPINE_FLUTTER_EXPORT float spine_event_data_get_balance(spine_event_data event); -SPINE_FLUTTER_EXPORT void spine_event_data_set_balance(spine_event_data event, float balance); - -SPINE_FLUTTER_EXPORT spine_event_data spine_event_get_data(spine_event event); -SPINE_FLUTTER_EXPORT float spine_event_get_time(spine_event event); -SPINE_FLUTTER_EXPORT int32_t spine_event_get_int_value(spine_event event); -SPINE_FLUTTER_EXPORT void spine_event_set_int_value(spine_event event, int32_t value); -SPINE_FLUTTER_EXPORT float spine_event_get_float_value(spine_event event); -SPINE_FLUTTER_EXPORT void spine_event_set_float_value(spine_event event, float value); -SPINE_FLUTTER_EXPORT const utf8 *spine_event_get_string_value(spine_event event); -SPINE_FLUTTER_EXPORT void spine_event_set_string_value(spine_event event, const utf8 *value); -SPINE_FLUTTER_EXPORT float spine_event_get_volume(spine_event event); -SPINE_FLUTTER_EXPORT void spine_event_set_volume(spine_event event, float volume); -SPINE_FLUTTER_EXPORT float spine_event_get_balance(spine_event event); -SPINE_FLUTTER_EXPORT void spine_event_set_balance(spine_event event, float balance); - -SPINE_FLUTTER_EXPORT int32_t spine_slot_data_get_index(spine_slot_data slot); -SPINE_FLUTTER_EXPORT const utf8 *spine_slot_data_get_name(spine_slot_data slot); -SPINE_FLUTTER_EXPORT spine_bone_data spine_slot_data_get_bone_data(spine_slot_data slot); -SPINE_FLUTTER_EXPORT spine_color spine_slot_data_get_color(spine_slot_data slot); -SPINE_FLUTTER_EXPORT void spine_slot_data_set_color(spine_slot_data slot, float r, float g, float b, float a); -SPINE_FLUTTER_EXPORT spine_color spine_slot_data_get_dark_color(spine_slot_data slot); -SPINE_FLUTTER_EXPORT void spine_slot_data_set_dark_color(spine_slot_data slot, float r, float g, float b, float a); -SPINE_FLUTTER_EXPORT int32_t spine_slot_data_has_dark_color(spine_slot_data slot); -SPINE_FLUTTER_EXPORT void spine_slot_data_set_has_dark_color(spine_slot_data slot, int32_t hasDarkColor); -SPINE_FLUTTER_EXPORT const utf8 *spine_slot_data_get_attachment_name(spine_slot_data slot); -SPINE_FLUTTER_EXPORT void spine_slot_data_set_attachment_name(spine_slot_data slot, const utf8 *attachmentName); -SPINE_FLUTTER_EXPORT spine_blend_mode spine_slot_data_get_blend_mode(spine_slot_data slot); -SPINE_FLUTTER_EXPORT void spine_slot_data_set_blend_mode(spine_slot_data slot, spine_blend_mode blendMode); -SPINE_FLUTTER_EXPORT int32_t spine_slot_data_is_visible(spine_slot_data slot); -SPINE_FLUTTER_EXPORT void spine_slot_data_set_visible(spine_slot_data slot, int32_t visible); -// OMITTED getPath()/setPath() - -SPINE_FLUTTER_EXPORT void spine_slot_set_to_setup_pose(spine_slot slot); -SPINE_FLUTTER_EXPORT spine_slot_data spine_slot_get_data(spine_slot slot); -SPINE_FLUTTER_EXPORT spine_bone spine_slot_get_bone(spine_slot slot); -SPINE_FLUTTER_EXPORT spine_skeleton spine_slot_get_skeleton(spine_slot slot); -SPINE_FLUTTER_EXPORT spine_color spine_slot_get_color(spine_slot slot); -SPINE_FLUTTER_EXPORT void spine_slot_set_color(spine_slot slot, float r, float g, float b, float a); -SPINE_FLUTTER_EXPORT spine_color spine_slot_get_dark_color(spine_slot slot); -SPINE_FLUTTER_EXPORT void spine_slot_set_dark_color(spine_slot slot, float r, float g, float b, float a); -SPINE_FLUTTER_EXPORT int32_t spine_slot_has_dark_color(spine_slot slot); -SPINE_FLUTTER_EXPORT spine_attachment spine_slot_get_attachment(spine_slot slot); -SPINE_FLUTTER_EXPORT void spine_slot_set_attachment(spine_slot slot, spine_attachment attachment); -// OMITTED getDeform() -SPINE_FLUTTER_EXPORT int32_t spine_slot_get_sequence_index(spine_slot slot); -SPINE_FLUTTER_EXPORT void spine_slot_set_sequence_index(spine_slot slot, int32_t sequenceIndex); - -SPINE_FLUTTER_EXPORT int32_t spine_bone_data_get_index(spine_bone_data data); -SPINE_FLUTTER_EXPORT const utf8 *spine_bone_data_get_name(spine_bone_data data); -SPINE_FLUTTER_EXPORT spine_bone_data spine_bone_data_get_parent(spine_bone_data data); -SPINE_FLUTTER_EXPORT float spine_bone_data_get_length(spine_bone_data data); -SPINE_FLUTTER_EXPORT void spine_bone_data_set_length(spine_bone_data data, float length); -SPINE_FLUTTER_EXPORT float spine_bone_data_get_x(spine_bone_data data); -SPINE_FLUTTER_EXPORT void spine_bone_data_set_x(spine_bone_data data, float x); -SPINE_FLUTTER_EXPORT float spine_bone_data_get_y(spine_bone_data data); -SPINE_FLUTTER_EXPORT void spine_bone_data_set_y(spine_bone_data data, float y); -SPINE_FLUTTER_EXPORT float spine_bone_data_get_rotation(spine_bone_data data); -SPINE_FLUTTER_EXPORT void spine_bone_data_set_rotation(spine_bone_data data, float rotation); -SPINE_FLUTTER_EXPORT float spine_bone_data_get_scale_x(spine_bone_data data); -SPINE_FLUTTER_EXPORT void spine_bone_data_set_scale_x(spine_bone_data data, float scaleX); -SPINE_FLUTTER_EXPORT float spine_bone_data_get_scale_y(spine_bone_data data); -SPINE_FLUTTER_EXPORT void spine_bone_data_set_scale_y(spine_bone_data data, float scaleY); -SPINE_FLUTTER_EXPORT float spine_bone_data_get_shear_x(spine_bone_data data); -SPINE_FLUTTER_EXPORT void spine_bone_data_set_shear_x(spine_bone_data data, float shearx); -SPINE_FLUTTER_EXPORT float spine_bone_data_get_shear_y(spine_bone_data data); -SPINE_FLUTTER_EXPORT void spine_bone_data_set_shear_y(spine_bone_data data, float shearY); -SPINE_FLUTTER_EXPORT spine_inherit spine_bone_data_get_inherit(spine_bone_data data); -SPINE_FLUTTER_EXPORT void spine_bone_data_set_inherit(spine_bone_data data, spine_inherit inherit); -SPINE_FLUTTER_EXPORT int32_t spine_bone_data_is_skin_required(spine_bone_data data); -SPINE_FLUTTER_EXPORT void spine_bone_data_set_is_skin_required(spine_bone_data data, int32_t isSkinRequired); -SPINE_FLUTTER_EXPORT spine_color spine_bone_data_get_color(spine_bone_data data); -SPINE_FLUTTER_EXPORT void spine_bone_data_set_color(spine_bone_data data, float r, float g, float b, float a); -SPINE_FLUTTER_EXPORT int32_t spine_bone_data_is_visible(spine_bone_data data); -SPINE_FLUTTER_EXPORT void spine_bone_data_set_visible(spine_bone_data data, int32_t isVisible); -// Omitted getIcon()/setIcon() - -SPINE_FLUTTER_EXPORT void spine_bone_set_is_y_down(int32_t yDown); -SPINE_FLUTTER_EXPORT int32_t spine_bone_get_is_y_down(); -SPINE_FLUTTER_EXPORT void spine_bone_update(spine_bone bone); -SPINE_FLUTTER_EXPORT void spine_bone_update_world_transform(spine_bone bone); -SPINE_FLUTTER_EXPORT void spine_bone_update_world_transform_with(spine_bone bone, float x, float y, float rotation, float scaleX, float scaleY, float shearX, float shearY); -SPINE_FLUTTER_EXPORT void spine_bone_update_applied_transform(spine_bone bone); -SPINE_FLUTTER_EXPORT void spine_bone_set_to_setup_pose(spine_bone bone); -SPINE_FLUTTER_EXPORT spine_vector spine_bone_world_to_local(spine_bone bone, float worldX, float worldY); -SPINE_FLUTTER_EXPORT spine_vector spine_bone_world_to_parent(spine_bone bone, float worldX, float worldY); -SPINE_FLUTTER_EXPORT spine_vector spine_bone_local_to_world(spine_bone bone, float localX, float localY); -SPINE_FLUTTER_EXPORT spine_vector spine_bone_parent_to_world(spine_bone bone, float localX, float localY); -SPINE_FLUTTER_EXPORT float spine_bone_world_to_local_rotation(spine_bone bone, float worldRotation); -SPINE_FLUTTER_EXPORT float spine_bone_local_to_world_rotation(spine_bone bone, float localRotation); -SPINE_FLUTTER_EXPORT void spine_bone_rotate_world(spine_bone bone, float degrees); -SPINE_FLUTTER_EXPORT float spine_bone_get_world_to_local_rotation_x(spine_bone bone); -SPINE_FLUTTER_EXPORT float spine_bone_get_world_to_local_rotation_y(spine_bone bone); -SPINE_FLUTTER_EXPORT spine_bone_data spine_bone_get_data(spine_bone bone); -SPINE_FLUTTER_EXPORT spine_skeleton spine_bone_get_skeleton(spine_bone bone); -SPINE_FLUTTER_EXPORT spine_bone spine_bone_get_parent(spine_bone bone); -SPINE_FLUTTER_EXPORT int32_t spine_bone_get_num_children(spine_bone bone); -SPINE_FLUTTER_EXPORT spine_bone *spine_bone_get_children(spine_bone bone); -SPINE_FLUTTER_EXPORT float spine_bone_get_x(spine_bone bone); -SPINE_FLUTTER_EXPORT void spine_bone_set_x(spine_bone bone, float x); -SPINE_FLUTTER_EXPORT float spine_bone_get_y(spine_bone bone); -SPINE_FLUTTER_EXPORT void spine_bone_set_y(spine_bone bone, float y); -SPINE_FLUTTER_EXPORT float spine_bone_get_rotation(spine_bone bone); -SPINE_FLUTTER_EXPORT void spine_bone_set_rotation(spine_bone bone, float rotation); -SPINE_FLUTTER_EXPORT float spine_bone_get_scale_x(spine_bone bone); -SPINE_FLUTTER_EXPORT void spine_bone_set_scale_x(spine_bone bone, float scaleX); -SPINE_FLUTTER_EXPORT float spine_bone_get_scale_y(spine_bone bone); -SPINE_FLUTTER_EXPORT void spine_bone_set_scale_y(spine_bone bone, float scaleY); -SPINE_FLUTTER_EXPORT float spine_bone_get_shear_x(spine_bone bone); -SPINE_FLUTTER_EXPORT void spine_bone_set_shear_x(spine_bone bone, float shearX); -SPINE_FLUTTER_EXPORT float spine_bone_get_shear_y(spine_bone bone); -SPINE_FLUTTER_EXPORT void spine_bone_set_shear_y(spine_bone bone, float shearY); -SPINE_FLUTTER_EXPORT float spine_bone_get_applied_rotation(spine_bone bone); -SPINE_FLUTTER_EXPORT void spine_bone_set_applied_rotation(spine_bone bone, float rotation); -SPINE_FLUTTER_EXPORT float spine_bone_get_a_x(spine_bone bone); -SPINE_FLUTTER_EXPORT void spine_bone_set_a_x(spine_bone bone, float x); -SPINE_FLUTTER_EXPORT float spine_bone_get_a_y(spine_bone bone); -SPINE_FLUTTER_EXPORT void spine_bone_set_a_y(spine_bone bone, float y); -SPINE_FLUTTER_EXPORT float spine_bone_get_a_scale_x(spine_bone bone); -SPINE_FLUTTER_EXPORT void spine_bone_set_a_scale_x(spine_bone bone, float scaleX); -SPINE_FLUTTER_EXPORT float spine_bone_get_a_scale_y(spine_bone bone); -SPINE_FLUTTER_EXPORT void spine_bone_set_a_scale_y(spine_bone bone, float scaleY); -SPINE_FLUTTER_EXPORT float spine_bone_get_a_shear_x(spine_bone bone); -SPINE_FLUTTER_EXPORT void spine_bone_set_a_shear_x(spine_bone bone, float shearX); -SPINE_FLUTTER_EXPORT float spine_bone_get_a_shear_y(spine_bone bone); -SPINE_FLUTTER_EXPORT void spine_bone_set_a_shear_y(spine_bone bone, float shearY); -SPINE_FLUTTER_EXPORT float spine_bone_get_a(spine_bone bone); -SPINE_FLUTTER_EXPORT void spine_bone_set_a(spine_bone bone, float a); -SPINE_FLUTTER_EXPORT float spine_bone_get_b(spine_bone bone); -SPINE_FLUTTER_EXPORT void spine_bone_set_b(spine_bone bone, float b); -SPINE_FLUTTER_EXPORT float spine_bone_get_c(spine_bone bone); -SPINE_FLUTTER_EXPORT void spine_bone_set_c(spine_bone bone, float c); -SPINE_FLUTTER_EXPORT float spine_bone_get_d(spine_bone bone); -SPINE_FLUTTER_EXPORT void spine_bone_set_d(spine_bone bone, float d); -SPINE_FLUTTER_EXPORT float spine_bone_get_world_x(spine_bone bone); -SPINE_FLUTTER_EXPORT void spine_bone_set_world_x(spine_bone bone, float worldX); -SPINE_FLUTTER_EXPORT float spine_bone_get_world_y(spine_bone bone); -SPINE_FLUTTER_EXPORT void spine_bone_set_world_y(spine_bone bone, float worldY); -SPINE_FLUTTER_EXPORT float spine_bone_get_world_rotation_x(spine_bone bone); -SPINE_FLUTTER_EXPORT float spine_bone_get_world_rotation_y(spine_bone bone); -SPINE_FLUTTER_EXPORT float spine_bone_get_world_scale_x(spine_bone bone); -SPINE_FLUTTER_EXPORT float spine_bone_get_world_scale_y(spine_bone bone); -SPINE_FLUTTER_EXPORT int32_t spine_bone_get_is_active(spine_bone bone); -SPINE_FLUTTER_EXPORT void spine_bone_set_is_active(spine_bone bone, int32_t isActive); -SPINE_FLUTTER_EXPORT spine_inherit spine_bone_get_inherit(spine_bone data); -SPINE_FLUTTER_EXPORT void spine_bone_set_inherit(spine_bone data, spine_inherit inherit); - -SPINE_FLUTTER_EXPORT const utf8 *spine_attachment_get_name(spine_attachment attachment); -SPINE_FLUTTER_EXPORT spine_attachment_type spine_attachment_get_type(spine_attachment attachment); -SPINE_FLUTTER_EXPORT spine_attachment spine_attachment_copy(spine_attachment attachment); -SPINE_FLUTTER_EXPORT void spine_attachment_dispose(spine_attachment attachment); - -SPINE_FLUTTER_EXPORT spine_vector spine_point_attachment_compute_world_position(spine_point_attachment attachment, spine_bone bone); -SPINE_FLUTTER_EXPORT float spine_point_attachment_compute_world_rotation(spine_point_attachment attachment, spine_bone bone); -SPINE_FLUTTER_EXPORT float spine_point_attachment_get_x(spine_point_attachment attachment); -SPINE_FLUTTER_EXPORT void spine_point_attachment_set_x(spine_point_attachment attachment, float x); -SPINE_FLUTTER_EXPORT float spine_point_attachment_get_y(spine_point_attachment attachment); -SPINE_FLUTTER_EXPORT void spine_point_attachment_set_y(spine_point_attachment attachment, float y); -SPINE_FLUTTER_EXPORT float spine_point_attachment_get_rotation(spine_point_attachment attachment); -SPINE_FLUTTER_EXPORT void spine_point_attachment_set_rotation(spine_point_attachment attachment, float rotation); -SPINE_FLUTTER_EXPORT spine_color spine_point_attachment_get_color(spine_point_attachment attachment); -SPINE_FLUTTER_EXPORT void spine_point_attachment_set_color(spine_point_attachment attachment, float r, float g, float b, float a); - -SPINE_FLUTTER_EXPORT void spine_region_attachment_update_region(spine_region_attachment attachment); -SPINE_FLUTTER_EXPORT void spine_region_attachment_compute_world_vertices(spine_region_attachment attachment, spine_slot slot, float *worldVertices); -SPINE_FLUTTER_EXPORT float spine_region_attachment_get_x(spine_region_attachment attachment); -SPINE_FLUTTER_EXPORT void spine_region_attachment_set_x(spine_region_attachment attachment, float x); -SPINE_FLUTTER_EXPORT float spine_region_attachment_get_y(spine_region_attachment attachment); -SPINE_FLUTTER_EXPORT void spine_region_attachment_set_y(spine_region_attachment attachment, float y); -SPINE_FLUTTER_EXPORT float spine_region_attachment_get_rotation(spine_region_attachment attachment); -SPINE_FLUTTER_EXPORT void spine_region_attachment_set_rotation(spine_region_attachment attachment, float rotation); -SPINE_FLUTTER_EXPORT float spine_region_attachment_get_scale_x(spine_region_attachment attachment); -SPINE_FLUTTER_EXPORT void spine_region_attachment_set_scale_x(spine_region_attachment attachment, float scaleX); -SPINE_FLUTTER_EXPORT float spine_region_attachment_get_scale_y(spine_region_attachment attachment); -SPINE_FLUTTER_EXPORT void spine_region_attachment_set_scale_y(spine_region_attachment attachment, float scaleY); -SPINE_FLUTTER_EXPORT float spine_region_attachment_get_width(spine_region_attachment attachment); -SPINE_FLUTTER_EXPORT void spine_region_attachment_set_width(spine_region_attachment attachment, float width); -SPINE_FLUTTER_EXPORT float spine_region_attachment_get_height(spine_region_attachment attachment); -SPINE_FLUTTER_EXPORT void spine_region_attachment_set_height(spine_region_attachment attachment, float height); -SPINE_FLUTTER_EXPORT spine_color spine_region_attachment_get_color(spine_region_attachment attachment); -SPINE_FLUTTER_EXPORT void spine_region_attachment_set_color(spine_region_attachment attachment, float r, float g, float b, float a); -SPINE_FLUTTER_EXPORT const utf8 *spine_region_attachment_get_path(spine_region_attachment attachment); -// OMITTED setPath() -SPINE_FLUTTER_EXPORT spine_texture_region spine_region_attachment_get_region(spine_region_attachment attachment); -// OMITTED setRegion() -SPINE_FLUTTER_EXPORT spine_sequence spine_region_attachment_get_sequence(spine_region_attachment attachment); -// OMITTED setSequence() -SPINE_FLUTTER_EXPORT int32_t spine_region_attachment_get_num_offset(spine_region_attachment attachment); -SPINE_FLUTTER_EXPORT float *spine_region_attachment_get_offset(spine_region_attachment attachment); -SPINE_FLUTTER_EXPORT int32_t spine_region_attachment_get_num_uvs(spine_region_attachment attachment); -SPINE_FLUTTER_EXPORT float *spine_region_attachment_get_uvs(spine_region_attachment attachment); - -SPINE_FLUTTER_EXPORT int32_t spine_vertex_attachment_get_world_vertices_length(spine_vertex_attachment attachment); -SPINE_FLUTTER_EXPORT void spine_vertex_attachment_compute_world_vertices(spine_vertex_attachment attachment, spine_slot slot, float *worldVertices); -// OMITTED getId() -SPINE_FLUTTER_EXPORT int32_t spine_vertex_attachment_get_num_bones(spine_vertex_attachment attachment); -SPINE_FLUTTER_EXPORT int32_t *spine_vertex_attachment_get_bones(spine_vertex_attachment attachment); -SPINE_FLUTTER_EXPORT int32_t spine_vertex_attachment_get_num_vertices(spine_vertex_attachment attachment); -SPINE_FLUTTER_EXPORT float *spine_vertex_attachment_get_vertices(spine_vertex_attachment attachment); -SPINE_FLUTTER_EXPORT spine_attachment spine_vertex_attachment_get_timeline_attachment(spine_vertex_attachment timelineAttachment); -SPINE_FLUTTER_EXPORT void spine_vertex_attachment_set_timeline_attachment(spine_vertex_attachment attachment, spine_attachment timelineAttachment); -// OMITTED copyTo() - -SPINE_FLUTTER_EXPORT void spine_mesh_attachment_update_region(spine_mesh_attachment attachment); -SPINE_FLUTTER_EXPORT int32_t spine_mesh_attachment_get_hull_length(spine_mesh_attachment attachment); -SPINE_FLUTTER_EXPORT void spine_mesh_attachment_set_hull_length(spine_mesh_attachment attachment, int32_t hullLength); -SPINE_FLUTTER_EXPORT int32_t spine_mesh_attachment_get_num_region_uvs(spine_mesh_attachment attachment); -SPINE_FLUTTER_EXPORT float *spine_mesh_attachment_get_region_uvs(spine_mesh_attachment attachment); -SPINE_FLUTTER_EXPORT int32_t spine_mesh_attachment_get_num_uvs(spine_mesh_attachment attachment); -SPINE_FLUTTER_EXPORT float *spine_mesh_attachment_get_uvs(spine_mesh_attachment attachment); -SPINE_FLUTTER_EXPORT int32_t spine_mesh_attachment_get_num_triangles(spine_mesh_attachment attachment); -SPINE_FLUTTER_EXPORT uint16_t *spine_mesh_attachment_get_triangles(spine_mesh_attachment attachment); -SPINE_FLUTTER_EXPORT spine_color spine_mesh_attachment_get_color(spine_mesh_attachment attachment); -SPINE_FLUTTER_EXPORT void spine_mesh_attachment_set_color(spine_mesh_attachment attachment, float r, float g, float b, float a); -SPINE_FLUTTER_EXPORT const utf8 *spine_mesh_attachment_get_path(spine_mesh_attachment attachment); -// OMITTED setPath() -SPINE_FLUTTER_EXPORT spine_texture_region spine_mesh_attachment_get_region(spine_mesh_attachment attachment); -// OMITTED setRegion() -SPINE_FLUTTER_EXPORT spine_sequence spine_mesh_attachment_get_sequence(spine_mesh_attachment attachment); -// OMITTED setSequence() -SPINE_FLUTTER_EXPORT spine_mesh_attachment spine_mesh_attachment_get_parent_mesh(spine_mesh_attachment attachment); -SPINE_FLUTTER_EXPORT void spine_mesh_attachment_set_parent_mesh(spine_mesh_attachment attachment, spine_mesh_attachment parentMesh); -SPINE_FLUTTER_EXPORT int32_t spine_mesh_attachment_get_num_edges(spine_mesh_attachment attachment); -SPINE_FLUTTER_EXPORT uint16_t *spine_mesh_attachment_get_edges(spine_mesh_attachment attachment); -SPINE_FLUTTER_EXPORT float spine_mesh_attachment_get_width(spine_mesh_attachment attachment); -SPINE_FLUTTER_EXPORT void spine_mesh_attachment_set_width(spine_mesh_attachment attachment, float width); -SPINE_FLUTTER_EXPORT float spine_mesh_attachment_get_height(spine_mesh_attachment attachment); -SPINE_FLUTTER_EXPORT void spine_mesh_attachment_set_height(spine_mesh_attachment attachment, float height); -// OMITTED newLinkedMesh() - -SPINE_FLUTTER_EXPORT spine_slot_data spine_clipping_attachment_get_end_slot(spine_clipping_attachment attachment); -SPINE_FLUTTER_EXPORT void spine_clipping_attachment_set_end_slot(spine_clipping_attachment attachment, spine_slot_data endSlot); -SPINE_FLUTTER_EXPORT spine_color spine_clipping_attachment_get_color(spine_clipping_attachment attachment); -SPINE_FLUTTER_EXPORT void spine_clipping_attachment_set_color(spine_clipping_attachment attachment, float r, float g, float b, float a); - -SPINE_FLUTTER_EXPORT spine_color spine_bounding_box_attachment_get_color(spine_bounding_box_attachment attachment); -SPINE_FLUTTER_EXPORT void spine_bounding_box_attachment_set_color(spine_bounding_box_attachment attachment, float r, float g, float b, float a); - -SPINE_FLUTTER_EXPORT int32_t spine_path_attachment_get_num_lengths(spine_path_attachment attachment); -SPINE_FLUTTER_EXPORT float *spine_path_attachment_get_lengths(spine_path_attachment attachment); -SPINE_FLUTTER_EXPORT int32_t spine_path_attachment_get_is_closed(spine_path_attachment attachment); -SPINE_FLUTTER_EXPORT void spine_path_attachment_set_is_closed(spine_path_attachment attachment, int32_t isClosed); -SPINE_FLUTTER_EXPORT int32_t spine_path_attachment_get_is_constant_speed(spine_path_attachment attachment); -SPINE_FLUTTER_EXPORT void spine_path_attachment_set_is_constant_speed(spine_path_attachment attachment, int32_t isConstantSpeed); -SPINE_FLUTTER_EXPORT spine_color spine_path_attachment_get_color(spine_path_attachment attachment); -SPINE_FLUTTER_EXPORT void spine_path_attachment_set_color(spine_path_attachment attachment, float r, float g, float b, float a); - -SPINE_FLUTTER_EXPORT void spine_skin_set_attachment(spine_skin skin, int32_t slotIndex, const utf8 *name, spine_attachment attachment); -SPINE_FLUTTER_EXPORT spine_attachment spine_skin_get_attachment(spine_skin skin, int32_t slotIndex, const utf8 *name); -SPINE_FLUTTER_EXPORT void spine_skin_remove_attachment(spine_skin skin, int32_t slotIndex, const utf8 *name); -// OMITTED findNamesForSlot() -// OMITTED findAttachmentsForSlot() -// OMITTED getColor() -SPINE_FLUTTER_EXPORT const utf8 *spine_skin_get_name(spine_skin skin); -SPINE_FLUTTER_EXPORT void spine_skin_add_skin(spine_skin skin, spine_skin other); -SPINE_FLUTTER_EXPORT void spine_skin_copy_skin(spine_skin skin, spine_skin other); -SPINE_FLUTTER_EXPORT spine_skin_entries spine_skin_get_entries(spine_skin skin); -SPINE_FLUTTER_EXPORT int32_t spine_skin_entries_get_num_entries(spine_skin_entries entries); -SPINE_FLUTTER_EXPORT spine_skin_entry spine_skin_entries_get_entry(spine_skin_entries entries, int32_t index); -SPINE_FLUTTER_EXPORT void spine_skin_entries_dispose(spine_skin_entries entries); -SPINE_FLUTTER_EXPORT int32_t spine_skin_entry_get_slot_index(spine_skin_entry entry); -SPINE_FLUTTER_EXPORT utf8 *spine_skin_entry_get_name(spine_skin_entry entry); -SPINE_FLUTTER_EXPORT spine_attachment spine_skin_entry_get_attachment(spine_skin_entry entry); -SPINE_FLUTTER_EXPORT int32_t spine_skin_get_num_bones(spine_skin skin); -SPINE_FLUTTER_EXPORT spine_bone_data *spine_skin_get_bones(spine_skin skin); -SPINE_FLUTTER_EXPORT int32_t spine_skin_get_num_constraints(spine_skin skin); -SPINE_FLUTTER_EXPORT spine_constraint_data *spine_skin_get_constraints(spine_skin skin); -SPINE_FLUTTER_EXPORT spine_skin spine_skin_create(const utf8 *name); -SPINE_FLUTTER_EXPORT void spine_skin_dispose(spine_skin skin); - -SPINE_FLUTTER_EXPORT spine_constraint_type spine_constraint_data_get_type(spine_constraint_data data); -SPINE_FLUTTER_EXPORT const utf8 *spine_constraint_data_get_name(spine_constraint_data data); -SPINE_FLUTTER_EXPORT uint64_t spine_constraint_data_get_order(spine_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_constraint_data_set_order(spine_constraint_data data, uint64_t order); -SPINE_FLUTTER_EXPORT int32_t spine_constraint_data_get_is_skin_required(spine_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_constraint_data_set_is_skin_required(spine_constraint_data data, int32_t isSkinRequired); - -SPINE_FLUTTER_EXPORT int32_t spine_ik_constraint_data_get_num_bones(spine_ik_constraint_data data); -SPINE_FLUTTER_EXPORT spine_bone_data *spine_ik_constraint_data_get_bones(spine_ik_constraint_data data); -SPINE_FLUTTER_EXPORT spine_bone_data spine_ik_constraint_data_get_target(spine_ik_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_ik_constraint_data_set_target(spine_ik_constraint_data data, spine_bone_data target); -SPINE_FLUTTER_EXPORT int32_t spine_ik_constraint_data_get_bend_direction(spine_ik_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_ik_constraint_data_set_bend_direction(spine_ik_constraint_data data, int32_t bendDirection); -SPINE_FLUTTER_EXPORT int32_t spine_ik_constraint_data_get_compress(spine_ik_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_ik_constraint_data_set_compress(spine_ik_constraint_data data, int32_t compress); -SPINE_FLUTTER_EXPORT int32_t spine_ik_constraint_data_get_stretch(spine_ik_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_ik_constraint_data_set_stretch(spine_ik_constraint_data data, int32_t stretch); -SPINE_FLUTTER_EXPORT int32_t spine_ik_constraint_data_get_uniform(spine_ik_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_ik_constraint_data_set_uniform(spine_ik_constraint_data data, int32_t uniform); -SPINE_FLUTTER_EXPORT float spine_ik_constraint_data_get_mix(spine_ik_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_ik_constraint_data_set_mix(spine_ik_constraint_data data, float mix); -SPINE_FLUTTER_EXPORT float spine_ik_constraint_data_get_softness(spine_ik_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_ik_constraint_data_set_softness(spine_ik_constraint_data data, float softness); - -SPINE_FLUTTER_EXPORT void spine_ik_constraint_update(spine_ik_constraint constraint); -SPINE_FLUTTER_EXPORT int32_t spine_ik_constraint_get_order(spine_ik_constraint constraint); -SPINE_FLUTTER_EXPORT spine_ik_constraint_data spine_ik_constraint_get_data(spine_ik_constraint constraint); -SPINE_FLUTTER_EXPORT int32_t spine_ik_constraint_get_num_bones(spine_ik_constraint constraint); -SPINE_FLUTTER_EXPORT spine_bone *spine_ik_constraint_get_bones(spine_ik_constraint constraint); -SPINE_FLUTTER_EXPORT spine_bone spine_ik_constraint_get_target(spine_ik_constraint constraint); -SPINE_FLUTTER_EXPORT void spine_ik_constraint_set_target(spine_ik_constraint constraint, spine_bone target); -SPINE_FLUTTER_EXPORT int32_t spine_ik_constraint_get_bend_direction(spine_ik_constraint constraint); -SPINE_FLUTTER_EXPORT void spine_ik_constraint_set_bend_direction(spine_ik_constraint constraint, int32_t bendDirection); -SPINE_FLUTTER_EXPORT int32_t spine_ik_constraint_get_compress(spine_ik_constraint constraint); -SPINE_FLUTTER_EXPORT void spine_ik_constraint_set_compress(spine_ik_constraint constraint, int32_t compress); -SPINE_FLUTTER_EXPORT int32_t spine_ik_constraint_get_stretch(spine_ik_constraint constraint); -SPINE_FLUTTER_EXPORT void spine_ik_constraint_set_stretch(spine_ik_constraint constraint, int32_t stretch); -SPINE_FLUTTER_EXPORT float spine_ik_constraint_get_mix(spine_ik_constraint constraint); -SPINE_FLUTTER_EXPORT void spine_ik_constraint_set_mix(spine_ik_constraint constraint, float mix); -SPINE_FLUTTER_EXPORT float spine_ik_constraint_get_softness(spine_ik_constraint constraint); -SPINE_FLUTTER_EXPORT void spine_ik_constraint_set_softness(spine_ik_constraint constraint, float softness); -SPINE_FLUTTER_EXPORT int32_t spine_ik_constraint_get_is_active(spine_ik_constraint constraint); -SPINE_FLUTTER_EXPORT void spine_ik_constraint_set_is_active(spine_ik_constraint constraint, int32_t isActive); -// OMITTED setToSetupPose() - -SPINE_FLUTTER_EXPORT int32_t spine_transform_constraint_data_get_num_bones(spine_transform_constraint_data data); -SPINE_FLUTTER_EXPORT spine_bone_data *spine_transform_constraint_data_get_bones(spine_transform_constraint_data data); -SPINE_FLUTTER_EXPORT spine_bone_data spine_transform_constraint_data_get_target(spine_transform_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_transform_constraint_data_set_target(spine_transform_constraint_data data, spine_bone_data target); -SPINE_FLUTTER_EXPORT float spine_transform_constraint_data_get_mix_rotate(spine_transform_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_transform_constraint_data_set_mix_rotate(spine_transform_constraint_data data, float mixRotate); -SPINE_FLUTTER_EXPORT float spine_transform_constraint_data_get_mix_x(spine_transform_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_transform_constraint_data_set_mix_x(spine_transform_constraint_data data, float mixX); -SPINE_FLUTTER_EXPORT float spine_transform_constraint_data_get_mix_y(spine_transform_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_transform_constraint_data_set_mix_y(spine_transform_constraint_data data, float mixY); -SPINE_FLUTTER_EXPORT float spine_transform_constraint_data_get_mix_scale_x(spine_transform_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_transform_constraint_data_set_mix_scale_x(spine_transform_constraint_data data, float mixScaleX); -SPINE_FLUTTER_EXPORT float spine_transform_constraint_data_get_mix_scale_y(spine_transform_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_transform_constraint_data_set_mix_scale_y(spine_transform_constraint_data data, float mixScaleY); -SPINE_FLUTTER_EXPORT float spine_transform_constraint_data_get_mix_shear_y(spine_transform_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_transform_constraint_data_set_mix_shear_y(spine_transform_constraint_data data, float mixShearY); -SPINE_FLUTTER_EXPORT float spine_transform_constraint_data_get_offset_rotation(spine_transform_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_transform_constraint_data_set_offset_rotation(spine_transform_constraint_data data, float offsetRotation); -SPINE_FLUTTER_EXPORT float spine_transform_constraint_data_get_offset_x(spine_transform_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_transform_constraint_data_set_offset_x(spine_transform_constraint_data data, float offsetX); -SPINE_FLUTTER_EXPORT float spine_transform_constraint_data_get_offset_y(spine_transform_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_transform_constraint_data_set_offset_y(spine_transform_constraint_data data, float offsetY); -SPINE_FLUTTER_EXPORT float spine_transform_constraint_data_get_offset_scale_x(spine_transform_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_transform_constraint_data_set_offset_scale_x(spine_transform_constraint_data data, float offsetScaleX); -SPINE_FLUTTER_EXPORT float spine_transform_constraint_data_get_offset_scale_y(spine_transform_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_transform_constraint_data_set_offset_scale_y(spine_transform_constraint_data data, float offsetScaleY); -SPINE_FLUTTER_EXPORT float spine_transform_constraint_data_get_offset_shear_y(spine_transform_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_transform_constraint_data_set_offset_shear_y(spine_transform_constraint_data data, float offsetShearY); -SPINE_FLUTTER_EXPORT int32_t spine_transform_constraint_data_get_is_relative(spine_transform_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_transform_constraint_data_set_is_relative(spine_transform_constraint_data data, int32_t isRelative); -SPINE_FLUTTER_EXPORT int32_t spine_transform_constraint_data_get_is_local(spine_transform_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_transform_constraint_data_set_is_local(spine_transform_constraint_data data, int32_t isLocal); - -SPINE_FLUTTER_EXPORT void spine_transform_constraint_update(spine_transform_constraint constraint); -SPINE_FLUTTER_EXPORT int32_t spine_transform_constraint_get_order(spine_transform_constraint constraint); -SPINE_FLUTTER_EXPORT spine_transform_constraint_data spine_transform_constraint_get_data(spine_transform_constraint constraint); -SPINE_FLUTTER_EXPORT int32_t spine_transform_constraint_get_num_bones(spine_transform_constraint constraint); -SPINE_FLUTTER_EXPORT spine_bone *spine_transform_constraint_get_bones(spine_transform_constraint constraint); -SPINE_FLUTTER_EXPORT spine_bone spine_transform_constraint_get_target(spine_transform_constraint constraint); -SPINE_FLUTTER_EXPORT void spine_transform_constraint_set_target(spine_transform_constraint constraint, spine_bone target); -SPINE_FLUTTER_EXPORT float spine_transform_constraint_get_mix_rotate(spine_transform_constraint constraint); -SPINE_FLUTTER_EXPORT void spine_transform_constraint_set_mix_rotate(spine_transform_constraint constraint, float mixRotate); -SPINE_FLUTTER_EXPORT float spine_transform_constraint_get_mix_x(spine_transform_constraint constraint); -SPINE_FLUTTER_EXPORT void spine_transform_constraint_set_mix_x(spine_transform_constraint constraint, float mixX); -SPINE_FLUTTER_EXPORT float spine_transform_constraint_get_mix_y(spine_transform_constraint constraint); -SPINE_FLUTTER_EXPORT void spine_transform_constraint_set_mix_y(spine_transform_constraint constraint, float mixY); -SPINE_FLUTTER_EXPORT float spine_transform_constraint_get_mix_scale_x(spine_transform_constraint constraint); -SPINE_FLUTTER_EXPORT void spine_transform_constraint_set_mix_scale_x(spine_transform_constraint constraint, float mixScaleX); -SPINE_FLUTTER_EXPORT float spine_transform_constraint_get_mix_scale_y(spine_transform_constraint constraint); -SPINE_FLUTTER_EXPORT void spine_transform_constraint_set_mix_scale_y(spine_transform_constraint constraint, float mixScaleY); -SPINE_FLUTTER_EXPORT float spine_transform_constraint_get_mix_shear_y(spine_transform_constraint constraint); -SPINE_FLUTTER_EXPORT void spine_transform_constraint_set_mix_shear_y(spine_transform_constraint constraint, float mixShearY); -SPINE_FLUTTER_EXPORT float spine_transform_constraint_get_is_active(spine_transform_constraint constraint); -SPINE_FLUTTER_EXPORT void spine_transform_constraint_set_is_active(spine_transform_constraint constraint, int32_t isActive); -// OMITTED setToSetupPose() - -SPINE_FLUTTER_EXPORT int32_t spine_path_constraint_data_get_num_bones(spine_path_constraint_data data); -SPINE_FLUTTER_EXPORT spine_bone_data *spine_path_constraint_data_get_bones(spine_path_constraint_data data); -SPINE_FLUTTER_EXPORT spine_slot_data spine_path_constraint_data_get_target(spine_path_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_path_constraint_data_set_target(spine_path_constraint_data data, spine_slot_data target); -SPINE_FLUTTER_EXPORT spine_position_mode spine_path_constraint_data_get_position_mode(spine_path_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_path_constraint_data_set_position_mode(spine_path_constraint_data data, spine_position_mode positionMode); -SPINE_FLUTTER_EXPORT spine_spacing_mode spine_path_constraint_data_get_spacing_mode(spine_path_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_path_constraint_data_set_spacing_mode(spine_path_constraint_data data, spine_spacing_mode spacingMode); -SPINE_FLUTTER_EXPORT spine_rotate_mode spine_path_constraint_data_get_rotate_mode(spine_path_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_path_constraint_data_set_rotate_mode(spine_path_constraint_data data, spine_rotate_mode rotateMode); -SPINE_FLUTTER_EXPORT float spine_path_constraint_data_get_offset_rotation(spine_path_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_path_constraint_data_set_offset_rotation(spine_path_constraint_data data, float offsetRotation); -SPINE_FLUTTER_EXPORT float spine_path_constraint_data_get_position(spine_path_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_path_constraint_data_set_position(spine_path_constraint_data data, float position); -SPINE_FLUTTER_EXPORT float spine_path_constraint_data_get_spacing(spine_path_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_path_constraint_data_set_spacing(spine_path_constraint_data data, float spacing); -SPINE_FLUTTER_EXPORT float spine_path_constraint_data_get_mix_rotate(spine_path_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_path_constraint_data_set_mix_rotate(spine_path_constraint_data data, float mixRotate); -SPINE_FLUTTER_EXPORT float spine_path_constraint_data_get_mix_x(spine_path_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_path_constraint_data_set_mix_x(spine_path_constraint_data data, float mixX); -SPINE_FLUTTER_EXPORT float spine_path_constraint_data_get_mix_y(spine_path_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_path_constraint_data_set_mix_y(spine_path_constraint_data data, float mixY); - -SPINE_FLUTTER_EXPORT void spine_path_constraint_update(spine_path_constraint constraint); -SPINE_FLUTTER_EXPORT int32_t spine_path_constraint_get_order(spine_path_constraint constraint); -SPINE_FLUTTER_EXPORT spine_path_constraint_data spine_path_constraint_get_data(spine_path_constraint constraint); -SPINE_FLUTTER_EXPORT int32_t spine_path_constraint_get_num_bones(spine_path_constraint constraint); -SPINE_FLUTTER_EXPORT spine_bone *spine_path_constraint_get_bones(spine_path_constraint constraint); -SPINE_FLUTTER_EXPORT spine_slot spine_path_constraint_get_target(spine_path_constraint constraint); -SPINE_FLUTTER_EXPORT void spine_path_constraint_set_target(spine_path_constraint constraint, spine_slot target); -SPINE_FLUTTER_EXPORT float spine_path_constraint_get_position(spine_path_constraint constraint); -SPINE_FLUTTER_EXPORT void spine_path_constraint_set_position(spine_path_constraint constraint, float position); -SPINE_FLUTTER_EXPORT float spine_path_constraint_get_spacing(spine_path_constraint constraint); -SPINE_FLUTTER_EXPORT void spine_path_constraint_set_spacing(spine_path_constraint constraint, float spacing); -SPINE_FLUTTER_EXPORT float spine_path_constraint_get_mix_rotate(spine_path_constraint constraint); -SPINE_FLUTTER_EXPORT void spine_path_constraint_set_mix_rotate(spine_path_constraint constraint, float mixRotate); -SPINE_FLUTTER_EXPORT float spine_path_constraint_get_mix_x(spine_path_constraint constraint); -SPINE_FLUTTER_EXPORT void spine_path_constraint_set_mix_x(spine_path_constraint constraint, float mixX); -SPINE_FLUTTER_EXPORT float spine_path_constraint_get_mix_y(spine_path_constraint constraint); -SPINE_FLUTTER_EXPORT void spine_path_constraint_set_mix_y(spine_path_constraint constraint, float mixY); -SPINE_FLUTTER_EXPORT int32_t spine_path_constraint_get_is_active(spine_path_constraint constraint); -SPINE_FLUTTER_EXPORT void spine_path_constraint_set_is_active(spine_path_constraint constraint, int32_t isActive); -// OMITTED setToSetupPose() - -SPINE_FLUTTER_EXPORT void spine_physics_constraint_data_set_bone(spine_physics_constraint_data data, spine_bone_data bone); -SPINE_FLUTTER_EXPORT spine_bone_data spine_physics_constraint_data_get_bone(spine_physics_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_physics_constraint_data_set_x(spine_physics_constraint_data data, float x); -SPINE_FLUTTER_EXPORT float spine_physics_constraint_data_get_x(spine_physics_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_physics_constraint_data_set_y(spine_physics_constraint_data data, float y); -SPINE_FLUTTER_EXPORT float spine_physics_constraint_data_get_y(spine_physics_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_physics_constraint_data_set_rotate(spine_physics_constraint_data data, float rotate); -SPINE_FLUTTER_EXPORT float spine_physics_constraint_data_get_rotate(spine_physics_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_physics_constraint_data_set_scale_x(spine_physics_constraint_data data, float scaleX); -SPINE_FLUTTER_EXPORT float spine_physics_constraint_data_get_scale_x(spine_physics_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_physics_constraint_data_set_shear_x(spine_physics_constraint_data data, float shearX); -SPINE_FLUTTER_EXPORT float spine_physics_constraint_data_get_shear_x(spine_physics_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_physics_constraint_data_set_limit(spine_physics_constraint_data data, float limit); -SPINE_FLUTTER_EXPORT float spine_physics_constraint_data_get_limit(spine_physics_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_physics_constraint_data_set_step(spine_physics_constraint_data data, float step); -SPINE_FLUTTER_EXPORT float spine_physics_constraint_data_get_step(spine_physics_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_physics_constraint_data_set_inertia(spine_physics_constraint_data data, float inertia); -SPINE_FLUTTER_EXPORT float spine_physics_constraint_data_get_inertia(spine_physics_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_physics_constraint_data_set_strength(spine_physics_constraint_data data, float strength); -SPINE_FLUTTER_EXPORT float spine_physics_constraint_data_get_strength(spine_physics_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_physics_constraint_data_set_damping(spine_physics_constraint_data data, float damping); -SPINE_FLUTTER_EXPORT float spine_physics_constraint_data_get_damping(spine_physics_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_physics_constraint_data_set_mass_inverse(spine_physics_constraint_data data, float massInverse); -SPINE_FLUTTER_EXPORT float spine_physics_constraint_data_get_mass_inverse(spine_physics_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_physics_constraint_data_set_wind(spine_physics_constraint_data data, float wind); -SPINE_FLUTTER_EXPORT float spine_physics_constraint_data_get_wind(spine_physics_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_physics_constraint_data_set_gravity(spine_physics_constraint_data data, float gravity); -SPINE_FLUTTER_EXPORT float spine_physics_constraint_data_get_gravity(spine_physics_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_physics_constraint_data_set_mix(spine_physics_constraint_data data, float mix); -SPINE_FLUTTER_EXPORT float spine_physics_constraint_data_get_mix(spine_physics_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_physics_constraint_data_set_inertia_global(spine_physics_constraint_data data, int32_t inertiaGlobal); -SPINE_FLUTTER_EXPORT int32_t spine_physics_constraint_data_is_inertia_global(spine_physics_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_physics_constraint_data_set_strength_global(spine_physics_constraint_data data, int32_t strengthGlobal); -SPINE_FLUTTER_EXPORT int32_t spine_physics_constraint_data_is_strength_global(spine_physics_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_physics_constraint_data_set_damping_global(spine_physics_constraint_data data, int32_t dampingGlobal); -SPINE_FLUTTER_EXPORT int32_t spine_physics_constraint_data_is_damping_global(spine_physics_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_physics_constraint_data_set_mass_global(spine_physics_constraint_data data, int32_t massGlobal); -SPINE_FLUTTER_EXPORT int32_t spine_physics_constraint_data_is_mass_global(spine_physics_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_physics_constraint_data_set_wind_global(spine_physics_constraint_data data, int32_t windGlobal); -SPINE_FLUTTER_EXPORT int32_t spine_physics_constraint_data_is_wind_global(spine_physics_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_physics_constraint_data_set_gravity_global(spine_physics_constraint_data data, int32_t gravityGlobal); -SPINE_FLUTTER_EXPORT int32_t spine_physics_constraint_data_is_gravity_global(spine_physics_constraint_data data); -SPINE_FLUTTER_EXPORT void spine_physics_constraint_data_set_mix_global(spine_physics_constraint_data data, int32_t mixGlobal); -SPINE_FLUTTER_EXPORT int32_t spine_physics_constraint_data_is_mix_global(spine_physics_constraint_data data); - -SPINE_FLUTTER_EXPORT void spine_physics_constraint_set_bone(spine_physics_constraint constraint, spine_bone bone); -SPINE_FLUTTER_EXPORT spine_bone spine_physics_constraint_get_bone(spine_physics_constraint constraint); -SPINE_FLUTTER_EXPORT void spine_physics_constraint_set_inertia(spine_physics_constraint constraint, float value); -SPINE_FLUTTER_EXPORT float spine_physics_constraint_get_inertia(spine_physics_constraint constraint); -SPINE_FLUTTER_EXPORT void spine_physics_constraint_set_strength(spine_physics_constraint constraint, float value); -SPINE_FLUTTER_EXPORT float spine_physics_constraint_get_strength(spine_physics_constraint constraint); -SPINE_FLUTTER_EXPORT void spine_physics_constraint_set_damping(spine_physics_constraint constraint, float value); -SPINE_FLUTTER_EXPORT float spine_physics_constraint_get_damping(spine_physics_constraint constraint); -SPINE_FLUTTER_EXPORT void spine_physics_constraint_set_mass_inverse(spine_physics_constraint constraint, float value); -SPINE_FLUTTER_EXPORT float spine_physics_constraint_get_mass_inverse(spine_physics_constraint constraint); -SPINE_FLUTTER_EXPORT void spine_physics_constraint_set_wind(spine_physics_constraint constraint, float value); -SPINE_FLUTTER_EXPORT float spine_physics_constraint_get_wind(spine_physics_constraint constraint); -SPINE_FLUTTER_EXPORT void spine_physics_constraint_set_gravity(spine_physics_constraint constraint, float value); -SPINE_FLUTTER_EXPORT float spine_physics_constraint_get_gravity(spine_physics_constraint constraint); -SPINE_FLUTTER_EXPORT void spine_physics_constraint_set_mix(spine_physics_constraint constraint, float value); -SPINE_FLUTTER_EXPORT float spine_physics_constraint_get_mix(spine_physics_constraint constraint); -SPINE_FLUTTER_EXPORT void spine_physics_constraint_set_reset(spine_physics_constraint constraint, int32_t value); -SPINE_FLUTTER_EXPORT int32_t spine_physics_constraint_get_reset(spine_physics_constraint constraint); -SPINE_FLUTTER_EXPORT void spine_physics_constraint_set_ux(spine_physics_constraint constraint, float value); -SPINE_FLUTTER_EXPORT float spine_physics_constraint_get_ux(spine_physics_constraint constraint); -SPINE_FLUTTER_EXPORT void spine_physics_constraint_set_uy(spine_physics_constraint constraint, float value); -SPINE_FLUTTER_EXPORT float spine_physics_constraint_get_uy(spine_physics_constraint constraint); -SPINE_FLUTTER_EXPORT void spine_physics_constraint_set_cx(spine_physics_constraint constraint, float value); -SPINE_FLUTTER_EXPORT float spine_physics_constraint_get_cx(spine_physics_constraint constraint); -SPINE_FLUTTER_EXPORT void spine_physics_constraint_set_cy(spine_physics_constraint constraint, float value); -SPINE_FLUTTER_EXPORT float spine_physics_constraint_get_cy(spine_physics_constraint constraint); -SPINE_FLUTTER_EXPORT void spine_physics_constraint_set_tx(spine_physics_constraint constraint, float value); -SPINE_FLUTTER_EXPORT float spine_physics_constraint_get_tx(spine_physics_constraint constraint); -SPINE_FLUTTER_EXPORT void spine_physics_constraint_set_ty(spine_physics_constraint constraint, float value); -SPINE_FLUTTER_EXPORT float spine_physics_constraint_get_ty(spine_physics_constraint constraint); -SPINE_FLUTTER_EXPORT void spine_physics_constraint_set_x_offset(spine_physics_constraint constraint, float value); -SPINE_FLUTTER_EXPORT float spine_physics_constraint_get_x_offset(spine_physics_constraint constraint); -SPINE_FLUTTER_EXPORT void spine_physics_constraint_set_x_velocity(spine_physics_constraint constraint, float value); -SPINE_FLUTTER_EXPORT float spine_physics_constraint_get_x_velocity(spine_physics_constraint constraint); -SPINE_FLUTTER_EXPORT void spine_physics_constraint_set_y_offset(spine_physics_constraint constraint, float value); -SPINE_FLUTTER_EXPORT float spine_physics_constraint_get_y_offset(spine_physics_constraint constraint); -SPINE_FLUTTER_EXPORT void spine_physics_constraint_set_y_velocity(spine_physics_constraint constraint, float value); -SPINE_FLUTTER_EXPORT float spine_physics_constraint_get_y_velocity(spine_physics_constraint constraint); -SPINE_FLUTTER_EXPORT void spine_physics_constraint_set_rotate_offset(spine_physics_constraint constraint, float value); -SPINE_FLUTTER_EXPORT float spine_physics_constraint_get_rotate_offset(spine_physics_constraint constraint); -SPINE_FLUTTER_EXPORT void spine_physics_constraint_set_rotate_velocity(spine_physics_constraint constraint, float value); -SPINE_FLUTTER_EXPORT float spine_physics_constraint_get_rotate_velocity(spine_physics_constraint constraint); -SPINE_FLUTTER_EXPORT void spine_physics_constraint_set_scale_offset(spine_physics_constraint constraint, float value); -SPINE_FLUTTER_EXPORT float spine_physics_constraint_get_scale_offset(spine_physics_constraint constraint); -SPINE_FLUTTER_EXPORT void spine_physics_constraint_set_scale_velocity(spine_physics_constraint constraint, float value); -SPINE_FLUTTER_EXPORT float spine_physics_constraint_get_scale_velocity(spine_physics_constraint constraint); -SPINE_FLUTTER_EXPORT void spine_physics_constraint_set_active(spine_physics_constraint constraint, int32_t value); -SPINE_FLUTTER_EXPORT int32_t spine_physics_constraint_is_active(spine_physics_constraint constraint); -SPINE_FLUTTER_EXPORT void spine_physics_constraint_set_remaining(spine_physics_constraint constraint, float value); -SPINE_FLUTTER_EXPORT float spine_physics_constraint_get_remaining(spine_physics_constraint constraint); -SPINE_FLUTTER_EXPORT void spine_physics_constraint_set_last_time(spine_physics_constraint constraint, float value); -SPINE_FLUTTER_EXPORT float spine_physics_constraint_get_last_time(spine_physics_constraint constraint); -SPINE_FLUTTER_EXPORT void spine_physics_constraint_reset(spine_physics_constraint constraint); -// Omitted setToSetupPose() -SPINE_FLUTTER_EXPORT void spine_physics_constraint_update(spine_physics_constraint data, spine_physics physics); -SPINE_FLUTTER_EXPORT void spine_physics_constraint_translate(spine_physics_constraint data, float x, float y); -SPINE_FLUTTER_EXPORT void spine_physics_constraint_rotate(spine_physics_constraint data, float x, float y, float degrees); - - -// OMITTED copy() -SPINE_FLUTTER_EXPORT void spine_sequence_apply(spine_sequence sequence, spine_slot slot, spine_attachment attachment); -SPINE_FLUTTER_EXPORT const utf8 *spine_sequence_get_path(spine_sequence sequence, const utf8 *basePath, int32_t index); -SPINE_FLUTTER_EXPORT int32_t spine_sequence_get_id(spine_sequence sequence); -SPINE_FLUTTER_EXPORT void spine_sequence_set_id(spine_sequence sequence, int32_t id); -SPINE_FLUTTER_EXPORT int32_t spine_sequence_get_start(spine_sequence sequence); -SPINE_FLUTTER_EXPORT void spine_sequence_set_start(spine_sequence sequence, int32_t start); -SPINE_FLUTTER_EXPORT int32_t spine_sequence_get_digits(spine_sequence sequence); -SPINE_FLUTTER_EXPORT void spine_sequence_set_digits(spine_sequence sequence, int32_t digits); -SPINE_FLUTTER_EXPORT int32_t spine_sequence_get_setup_index(spine_sequence sequence); -SPINE_FLUTTER_EXPORT void spine_sequence_set_setup_index(spine_sequence sequence, int32_t setupIndex); -SPINE_FLUTTER_EXPORT int32_t spine_sequence_get_num_regions(spine_sequence sequence); -SPINE_FLUTTER_EXPORT spine_texture_region *spine_sequence_get_regions(spine_sequence sequence); - -SPINE_FLUTTER_EXPORT void *spine_texture_region_get_texture(spine_texture_region textureRegion); -SPINE_FLUTTER_EXPORT void spine_texture_region_set_texture(spine_texture_region textureRegion, void *texture); -SPINE_FLUTTER_EXPORT float spine_texture_region_get_u(spine_texture_region textureRegion); -SPINE_FLUTTER_EXPORT void spine_texture_region_set_u(spine_texture_region textureRegion, float u); -SPINE_FLUTTER_EXPORT float spine_texture_region_get_v(spine_texture_region textureRegion); -SPINE_FLUTTER_EXPORT void spine_texture_region_set_v(spine_texture_region textureRegion, float v); -SPINE_FLUTTER_EXPORT float spine_texture_region_get_u2(spine_texture_region textureRegion); -SPINE_FLUTTER_EXPORT void spine_texture_region_set_u2(spine_texture_region textureRegion, float u2); -SPINE_FLUTTER_EXPORT float spine_texture_region_get_v2(spine_texture_region textureRegion); -SPINE_FLUTTER_EXPORT void spine_texture_region_set_v2(spine_texture_region textureRegion, float v2); -SPINE_FLUTTER_EXPORT int32_t spine_texture_region_get_degrees(spine_texture_region textureRegion); -SPINE_FLUTTER_EXPORT void spine_texture_region_set_degrees(spine_texture_region textureRegion, int32_t degrees); -SPINE_FLUTTER_EXPORT float spine_texture_region_get_offset_x(spine_texture_region textureRegion); -SPINE_FLUTTER_EXPORT void spine_texture_region_set_offset_x(spine_texture_region textureRegion, float offsetX); -SPINE_FLUTTER_EXPORT float spine_texture_region_get_offset_y(spine_texture_region textureRegion); -SPINE_FLUTTER_EXPORT void spine_texture_region_set_offset_y(spine_texture_region textureRegion, float offsetY); -SPINE_FLUTTER_EXPORT int32_t spine_texture_region_get_width(spine_texture_region textureRegion); -SPINE_FLUTTER_EXPORT void spine_texture_region_set_width(spine_texture_region textureRegion, int32_t width); -SPINE_FLUTTER_EXPORT int32_t spine_texture_region_get_height(spine_texture_region textureRegion); -SPINE_FLUTTER_EXPORT void spine_texture_region_set_height(spine_texture_region textureRegion, int32_t height); -SPINE_FLUTTER_EXPORT int32_t spine_texture_region_get_original_width(spine_texture_region textureRegion); -SPINE_FLUTTER_EXPORT void spine_texture_region_set_original_width(spine_texture_region textureRegion, int32_t originalWidth); -SPINE_FLUTTER_EXPORT int32_t spine_texture_region_get_original_height(spine_texture_region textureRegion); -SPINE_FLUTTER_EXPORT void spine_texture_region_set_original_height(spine_texture_region textureRegion, int32_t originalHeight); - -#endif