UnityMirror/spine-runtimes
1
0
Fork 0
mirror of https://github.com/EsotericSoftware/spine-runtimes.git synced 2026-03-26 22:49:01 +08:00
Code Issues Packages Projects Releases Wiki Activity

[godot] Fix up formatter.

Browse Source
This commit is contained in:
Mario Zechner 2022-05-31 12:29:25 +02:00
parent 934034fce4
commit 4239af0a1a
39 changed files with 635 additions and 609 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
formatters/build.gradle
View File

@ -26,8 +26,8 @@ spotless {
'spine-sfml/**/*.h', 'spine-sfml/**/*.h',
'spine-ue4/**/*.cpp', 'spine-ue4/**/*.cpp',
'spine-ue4/**/*.h', 'spine-ue4/**/*.h',
'spine-godot/godot/modules/spine_godot/*.cpp', 'spine-godot/spine_godot/*.cpp',
'spine-godot/godot/modules/spine_godot/*.h' 'spine-godot/spine_godot/*.h'
clangFormat("13.0.1").pathToExe("$System.env.CLANGFORMAT").style('file') clangFormat("13.0.1").pathToExe("$System.env.CLANGFORMAT").style('file')
} }

8
spine-cpp/spine-cpp/src/spine/SkeletonBinary.cpp
View File

@ -455,25 +455,25 @@ Skin *SkeletonBinary::readSkin(DataInput *input, bool defaultSkin, SkeletonData
skin = new (__FILE__, __LINE__) Skin(readStringRef(input, skeletonData)); skin = new (__FILE__, __LINE__) Skin(readStringRef(input, skeletonData));
for (int i = 0, n = readVarint(input, true); i < n; i++) { for (int i = 0, n = readVarint(input, true); i < n; i++) {
int boneIndex = readVarint(input, true); int boneIndex = readVarint(input, true);
if (boneIndex >= (int)skeletonData->_bones.size()) return NULL; if (boneIndex >= (int) skeletonData->_bones.size()) return NULL;
skin->getBones().add(skeletonData->_bones[boneIndex]); skin->getBones().add(skeletonData->_bones[boneIndex]);
} }
for (int i = 0, n = readVarint(input, true); i < n; i++) { for (int i = 0, n = readVarint(input, true); i < n; i++) {
int ikIndex = readVarint(input, true); int ikIndex = readVarint(input, true);
if (ikIndex >= (int)skeletonData->_ikConstraints.size()) return NULL; if (ikIndex >= (int) skeletonData->_ikConstraints.size()) return NULL;
skin->getConstraints().add(skeletonData->_ikConstraints[ikIndex]); skin->getConstraints().add(skeletonData->_ikConstraints[ikIndex]);
} }
for (int i = 0, n = readVarint(input, true); i < n; i++) { for (int i = 0, n = readVarint(input, true); i < n; i++) {
int transformIndex = readVarint(input, true); int transformIndex = readVarint(input, true);
if (transformIndex >= (int)skeletonData->_transformConstraints.size()) return NULL; if (transformIndex >= (int) skeletonData->_transformConstraints.size()) return NULL;
skin->getConstraints().add(skeletonData->_transformConstraints[transformIndex]); skin->getConstraints().add(skeletonData->_transformConstraints[transformIndex]);
} }
for (int i = 0, n = readVarint(input, true); i < n; i++) { for (int i = 0, n = readVarint(input, true); i < n; i++) {
int pathIndex = readVarint(input, true); int pathIndex = readVarint(input, true);
if (pathIndex >= (int)skeletonData->_pathConstraints.size()) return NULL; if (pathIndex >= (int) skeletonData->_pathConstraints.size()) return NULL;
skin->getConstraints().add(skeletonData->_pathConstraints[pathIndex]); skin->getConstraints().add(skeletonData->_pathConstraints[pathIndex]);
} }
slotCount = readVarint(input, true); slotCount = readVarint(input, true);

16
spine-godot/spine_godot/SpineAnimation.cpp
View File

@ -56,17 +56,17 @@ float SpineAnimation::get_duration() {
} }
void SpineAnimation::set_duration(float duration) { void SpineAnimation::set_duration(float duration) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setDuration(duration); get_spine_object()->setDuration(duration);
} }
void SpineAnimation::apply(Ref<SpineSkeleton> skeleton, float last_time, float time, bool loop, void SpineAnimation::apply(Ref<SpineSkeleton> skeleton, float last_time, float time, bool loop,
Array events, float alpha, SpineConstant::MixBlend blend, Array events, float alpha, SpineConstant::MixBlend blend,
SpineConstant::MixDirection direction) { SpineConstant::MixDirection direction) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
spine::Vector<spine::Event *> spineEvents; spine::Vector<spine::Event *> spineEvents;
get_spine_object()->apply(*(skeleton->get_spine_object()), last_time, time, loop, &spineEvents, alpha, (spine::MixBlend) blend, (spine::MixDirection) direction); get_spine_object()->apply(*(skeleton->get_spine_object()), last_time, time, loop, &spineEvents, alpha, (spine::MixBlend) blend, (spine::MixDirection) direction);
for (int i = 0; i < (int)spineEvents.size(); ++i) { for (int i = 0; i < (int) spineEvents.size(); ++i) {
auto event_ref = memnew(SpineEvent); auto event_ref = memnew(SpineEvent);
event_ref->set_spine_object(skeleton->get_spine_owner(), spineEvents[i]); event_ref->set_spine_object(skeleton->get_spine_owner(), spineEvents[i]);
events.append(event_ref); events.append(event_ref);
@ -77,9 +77,9 @@ Array SpineAnimation::get_timelines() {
Array result; Array result;
SPINE_CHECK(get_spine_object(), result) SPINE_CHECK(get_spine_object(), result)
auto &timelines = get_spine_object()->getTimelines(); auto &timelines = get_spine_object()->getTimelines();
result.resize((int)timelines.size()); result.resize((int) timelines.size());
for (int i = 0; i < (int)result.size(); ++i) { for (int i = 0; i < (int) result.size(); ++i) {
auto timeline_ref = Ref<SpineTimeline>(memnew(SpineTimeline)); auto timeline_ref = Ref<SpineTimeline>(memnew(SpineTimeline));
timeline_ref->set_spine_object(get_spine_owner(), timelines[i]); timeline_ref->set_spine_object(get_spine_owner(), timelines[i]);
result.set(i, timeline_ref); result.set(i, timeline_ref);
@ -92,7 +92,7 @@ bool SpineAnimation::has_timeline(Array ids) {
spine::Vector<spine::PropertyId> property_ids; spine::Vector<spine::PropertyId> property_ids;
property_ids.setSize(ids.size(), 0); property_ids.setSize(ids.size(), 0);
for (int i = 0; i < (int)property_ids.size(); ++i) { for (int i = 0; i < (int) property_ids.size(); ++i) {
property_ids[i] = (spine::PropertyId) ids[i]; property_ids[i] = (spine::PropertyId) ids[i];
} }
return get_spine_object()->hasTimeline(property_ids); return get_spine_object()->hasTimeline(property_ids);

14
spine-godot/spine_godot/SpineAnimationState.cpp
View File

@ -63,7 +63,7 @@ void SpineAnimationState::set_spine_sprite(SpineSprite *_sprite) {
} }
void SpineAnimationState::update(float delta) { void SpineAnimationState::update(float delta) {
SPINE_CHECK(animation_state,) SPINE_CHECK(animation_state, )
animation_state->update(delta); animation_state->update(delta);
} }
@ -74,12 +74,12 @@ bool SpineAnimationState::apply(Ref<SpineSkeleton> skeleton) {
} }
void SpineAnimationState::clear_tracks() { void SpineAnimationState::clear_tracks() {
SPINE_CHECK(animation_state,) SPINE_CHECK(animation_state, )
animation_state->clearTracks(); animation_state->clearTracks();
} }
void SpineAnimationState::clear_track(int track_id) { void SpineAnimationState::clear_track(int track_id) {
SPINE_CHECK(animation_state,) SPINE_CHECK(animation_state, )
animation_state->clearTrack(track_id); animation_state->clearTrack(track_id);
} }
@ -126,7 +126,7 @@ Ref<SpineTrackEntry> SpineAnimationState::add_empty_animation(int track_id, floa
return track_entry_ref; return track_entry_ref;
} }
void SpineAnimationState::set_empty_animations(float mix_duration) { void SpineAnimationState::set_empty_animations(float mix_duration) {
SPINE_CHECK(animation_state,) SPINE_CHECK(animation_state, )
animation_state->setEmptyAnimations(mix_duration); animation_state->setEmptyAnimations(mix_duration);
} }
@ -145,16 +145,16 @@ float SpineAnimationState::get_time_scale() {
} }
void SpineAnimationState::set_time_scale(float time_scale) { void SpineAnimationState::set_time_scale(float time_scale) {
SPINE_CHECK(animation_state,) SPINE_CHECK(animation_state, )
animation_state->setTimeScale(time_scale); animation_state->setTimeScale(time_scale);
} }
void SpineAnimationState::disable_queue() { void SpineAnimationState::disable_queue() {
SPINE_CHECK(animation_state,) SPINE_CHECK(animation_state, )
animation_state->disableQueue(); animation_state->disableQueue();
} }
void SpineAnimationState::enable_queue() { void SpineAnimationState::enable_queue() {
SPINE_CHECK(animation_state,) SPINE_CHECK(animation_state, )
animation_state->enableQueue(); animation_state->enableQueue();
} }

103
spine-godot/spine_godot/SpineAnimationTrack.cpp
View File

@ -17,7 +17,7 @@ void SpineAnimationTrack::_bind_methods() {
ClassDB::bind_method(D_METHOD("get_animation_name"), &SpineAnimationTrack::get_animation_name); ClassDB::bind_method(D_METHOD("get_animation_name"), &SpineAnimationTrack::get_animation_name);
ClassDB::bind_method(D_METHOD("set_loop", "loop"), &SpineAnimationTrack::set_loop); ClassDB::bind_method(D_METHOD("set_loop", "loop"), &SpineAnimationTrack::set_loop);
ClassDB::bind_method(D_METHOD("get_loop"), &SpineAnimationTrack::get_loop); ClassDB::bind_method(D_METHOD("get_loop"), &SpineAnimationTrack::get_loop);
ClassDB::bind_method(D_METHOD("set_track_index", "track_index"), &SpineAnimationTrack::set_track_index); ClassDB::bind_method(D_METHOD("set_track_index", "track_index"), &SpineAnimationTrack::set_track_index);
ClassDB::bind_method(D_METHOD("get_track_index"), &SpineAnimationTrack::get_track_index); ClassDB::bind_method(D_METHOD("get_track_index"), &SpineAnimationTrack::get_track_index);
ClassDB::bind_method(D_METHOD("set_mix_duration", "mix_duration"), &SpineAnimationTrack::set_mix_duration); ClassDB::bind_method(D_METHOD("set_mix_duration", "mix_duration"), &SpineAnimationTrack::set_mix_duration);
@ -40,12 +40,12 @@ void SpineAnimationTrack::_bind_methods() {
ClassDB::bind_method(D_METHOD("get_mix_blend"), &SpineAnimationTrack::get_mix_blend); ClassDB::bind_method(D_METHOD("get_mix_blend"), &SpineAnimationTrack::get_mix_blend);
ClassDB::bind_method(D_METHOD("set_debug", "debug"), &SpineAnimationTrack::set_debug); ClassDB::bind_method(D_METHOD("set_debug", "debug"), &SpineAnimationTrack::set_debug);
ClassDB::bind_method(D_METHOD("get_debug"), &SpineAnimationTrack::get_debug); ClassDB::bind_method(D_METHOD("get_debug"), &SpineAnimationTrack::get_debug);
ClassDB::bind_method(D_METHOD("update_animation_state", "spine_sprite"), &SpineAnimationTrack::update_animation_state); ClassDB::bind_method(D_METHOD("update_animation_state", "spine_sprite"), &SpineAnimationTrack::update_animation_state);
ADD_PROPERTY(PropertyInfo(Variant::STRING, "animation_name", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_STORAGE | PROPERTY_USAGE_INTERNAL | PROPERTY_USAGE_NOEDITOR), "set_animation_name", "get_animation_name"); ADD_PROPERTY(PropertyInfo(Variant::STRING, "animation_name", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_STORAGE | PROPERTY_USAGE_INTERNAL | PROPERTY_USAGE_NOEDITOR), "set_animation_name", "get_animation_name");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "loop", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_STORAGE | PROPERTY_USAGE_INTERNAL | PROPERTY_USAGE_NOEDITOR), "set_loop", "get_loop"); ADD_PROPERTY(PropertyInfo(Variant::BOOL, "loop", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_STORAGE | PROPERTY_USAGE_INTERNAL | PROPERTY_USAGE_NOEDITOR), "set_loop", "get_loop");
ADD_PROPERTY(PropertyInfo(Variant::INT, "track_index", PROPERTY_HINT_RANGE, "0,256,0"), "set_track_index", "get_track_index"); ADD_PROPERTY(PropertyInfo(Variant::INT, "track_index", PROPERTY_HINT_RANGE, "0,256,0"), "set_track_index", "get_track_index");
ADD_PROPERTY(PropertyInfo(VARIANT_FLOAT, "mix_duration"), "set_mix_duration", "get_mix_duration"); ADD_PROPERTY(PropertyInfo(VARIANT_FLOAT, "mix_duration"), "set_mix_duration", "get_mix_duration");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "hold_previous"), "set_hold_previous", "get_hold_previous"); ADD_PROPERTY(PropertyInfo(Variant::BOOL, "hold_previous"), "set_hold_previous", "get_hold_previous");
@ -59,40 +59,39 @@ void SpineAnimationTrack::_bind_methods() {
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "debug"), "set_debug", "get_debug"); ADD_PROPERTY(PropertyInfo(Variant::BOOL, "debug"), "set_debug", "get_debug");
} }
SpineAnimationTrack::SpineAnimationTrack(): SpineAnimationTrack::SpineAnimationTrack() : loop(false),
loop(false), track_index(-1),
track_index(-1), mix_duration(-1),
mix_duration(-1), hold_previous(false),
hold_previous(false), reverse(false),
reverse(false), shortest_rotation(false),
shortest_rotation(false), time_scale(1),
time_scale(1), alpha(1),
alpha(1), attachment_threshold(0),
attachment_threshold(0), draw_order_threshold(0),
draw_order_threshold(0), mix_blend(SpineConstant::MixBlend_Replace),
mix_blend(SpineConstant::MixBlend_Replace), debug(false),
debug(false), sprite(nullptr) {
sprite(nullptr) {
} }
void SpineAnimationTrack::_notification(int what) { void SpineAnimationTrack::_notification(int what) {
switch(what) { switch (what) {
case NOTIFICATION_PARENTED: { case NOTIFICATION_PARENTED: {
sprite = Object::cast_to<SpineSprite>(get_parent()); sprite = Object::cast_to<SpineSprite>(get_parent());
if (sprite) if (sprite)
#if VERSION_MAJOR > 3 #if VERSION_MAJOR > 3
sprite->connect("before_animation_state_update", callable_mp(this, &SpineAnimationTrack::update_animation_state)); sprite->connect("before_animation_state_update", callable_mp(this, &SpineAnimationTrack::update_animation_state));
#else #else
sprite->connect("before_animation_state_update", this, "update_animation_state"); sprite->connect("before_animation_state_update", this, "update_animation_state");
#endif #endif
NOTIFY_PROPERTY_LIST_CHANGED(); NOTIFY_PROPERTY_LIST_CHANGED();
break; break;
} }
case NOTIFICATION_READY: { case NOTIFICATION_READY: {
setup_animation_player(); setup_animation_player();
break; break;
} }
case NOTIFICATION_UNPARENTED: { case NOTIFICATION_UNPARENTED: {
if (sprite) { if (sprite) {
#if VERSION_MAJOR > 3 #if VERSION_MAJOR > 3
sprite->disconnect("before_animation_state_update", callable_mp(this, &SpineAnimationTrack::update_animation_state)); sprite->disconnect("before_animation_state_update", callable_mp(this, &SpineAnimationTrack::update_animation_state));
@ -102,13 +101,13 @@ void SpineAnimationTrack::_notification(int what) {
sprite = nullptr; sprite = nullptr;
} }
break; break;
} }
default: default:
break; break;
} }
} }
AnimationPlayer* SpineAnimationTrack::find_animation_player() { AnimationPlayer *SpineAnimationTrack::find_animation_player() {
AnimationPlayer *animation_player = nullptr; AnimationPlayer *animation_player = nullptr;
for (int i = 0; i < get_child_count(); i++) { for (int i = 0; i < get_child_count(); i++) {
animation_player = cast_to<AnimationPlayer>(get_child(i)); animation_player = cast_to<AnimationPlayer>(get_child(i));
@ -132,7 +131,7 @@ void SpineAnimationTrack::setup_animation_player() {
for (int i = 0; i < sprite->get_child_count(); i++) { for (int i = 0; i < sprite->get_child_count(); i++) {
auto other_track = cast_to<SpineAnimationTrack>(sprite->get_child(i)); auto other_track = cast_to<SpineAnimationTrack>(sprite->get_child(i));
if (other_track) { if (other_track) {
if (other_track->track_index > highest_track_number) if (other_track->track_index > highest_track_number)
highest_track_number = other_track->track_index; highest_track_number = other_track->track_index;
} }
} }
@ -161,7 +160,7 @@ void SpineAnimationTrack::setup_animation_player() {
} }
#endif #endif
} }
auto skeleton_data = sprite->get_skeleton_data_res()->get_skeleton_data(); auto skeleton_data = sprite->get_skeleton_data_res()->get_skeleton_data();
auto &animations = skeleton_data->getAnimations(); auto &animations = skeleton_data->getAnimations();
#if VERSION_MAJOR > 3 #if VERSION_MAJOR > 3
@ -169,7 +168,7 @@ void SpineAnimationTrack::setup_animation_player() {
animation_library.instantiate(); animation_library.instantiate();
animation_player->add_animation_library("", animation_library); animation_player->add_animation_library("", animation_library);
#endif #endif
for (int i = 0; i < (int)animations.size(); i++) { for (int i = 0; i < (int) animations.size(); i++) {
auto &animation = animations[i]; auto &animation = animations[i];
Ref<Animation> animation_ref = create_animation(animation, false); Ref<Animation> animation_ref = create_animation(animation, false);
Ref<Animation> animation_looped_ref = create_animation(animation, true); Ref<Animation> animation_looped_ref = create_animation(animation, true);
@ -181,9 +180,9 @@ void SpineAnimationTrack::setup_animation_player() {
animation_player->add_animation(animation_looped_ref->get_name(), animation_looped_ref); animation_player->add_animation(animation_looped_ref->get_name(), animation_looped_ref);
#endif #endif
} }
Ref<Animation> reset_animation_ref; Ref<Animation> reset_animation_ref;
INSTANTIATE(reset_animation_ref); INSTANTIATE(reset_animation_ref);
reset_animation_ref->set_name("RESET"); reset_animation_ref->set_name("RESET");
#if VERSION_MAJOR > 3 #if VERSION_MAJOR > 3
// reset_animation_ref->set_loop(true); // reset_animation_ref->set_loop(true);
@ -192,10 +191,10 @@ void SpineAnimationTrack::setup_animation_player() {
#endif #endif
reset_animation_ref->set_length(0.5f); reset_animation_ref->set_length(0.5f);
reset_animation_ref->add_track(Animation::TYPE_VALUE); reset_animation_ref->add_track(Animation::TYPE_VALUE);
reset_animation_ref->track_set_path(0, NodePath(".:animation_name")); reset_animation_ref->track_set_path(0, NodePath(".:animation_name"));
reset_animation_ref->track_insert_key(0, 0, ""); reset_animation_ref->track_insert_key(0, 0, "");
reset_animation_ref->add_track(Animation::TYPE_VALUE); reset_animation_ref->add_track(Animation::TYPE_VALUE);
reset_animation_ref->track_set_path(1, NodePath(".:loop")); reset_animation_ref->track_set_path(1, NodePath(".:loop"));
reset_animation_ref->track_insert_key(1, 0, false); reset_animation_ref->track_insert_key(1, 0, false);
#if VERSION_MAJOR > 3 #if VERSION_MAJOR > 3
animation_library->add_animation(reset_animation_ref->get_name(), reset_animation_ref); animation_library->add_animation(reset_animation_ref->get_name(), reset_animation_ref);
@ -209,9 +208,9 @@ void SpineAnimationTrack::setup_animation_player() {
Ref<Animation> SpineAnimationTrack::create_animation(spine::Animation *animation, bool loop) { Ref<Animation> SpineAnimationTrack::create_animation(spine::Animation *animation, bool loop) {
float duration = animation->getDuration(); float duration = animation->getDuration();
if (duration == 0) duration = 0.5; if (duration == 0) duration = 0.5;
Ref<Animation> animation_ref; Ref<Animation> animation_ref;
INSTANTIATE(animation_ref); INSTANTIATE(animation_ref);
animation_ref->set_name(String(animation->getName().buffer()) + (loop ? "" : "_looped")); animation_ref->set_name(String(animation->getName().buffer()) + (loop ? "" : "_looped"));
#if VERSION_MAJOR > 3 #if VERSION_MAJOR > 3
// animation_ref->set_loop(!loop); // animation_ref->set_loop(!loop);
@ -221,9 +220,9 @@ Ref<Animation> SpineAnimationTrack::create_animation(spine::Animation *animation
animation_ref->set_length(duration); animation_ref->set_length(duration);
animation_ref->add_track(Animation::TYPE_VALUE); animation_ref->add_track(Animation::TYPE_VALUE);
animation_ref->track_set_path(0, NodePath(".:animation_name")); animation_ref->track_set_path(0, NodePath(".:animation_name"));
animation_ref->track_insert_key(0, 0, animation->getName().buffer()); animation_ref->track_insert_key(0, 0, animation->getName().buffer());
animation_ref->add_track(Animation::TYPE_VALUE); animation_ref->add_track(Animation::TYPE_VALUE);
animation_ref->track_set_path(1, NodePath(".:loop")); animation_ref->track_set_path(1, NodePath(".:loop"));
animation_ref->track_insert_key(1, 0, !loop); animation_ref->track_insert_key(1, 0, !loop);
@ -246,7 +245,7 @@ void SpineAnimationTrack::update_animation_state(const Variant &variant_sprite)
if (Engine::get_singleton()->is_editor_hint()) { if (Engine::get_singleton()->is_editor_hint()) {
#ifdef TOOLS_ENABLED #ifdef TOOLS_ENABLED
// When the animation dock is no longer visible or we aren't being // When the animation dock is no longer visible or we aren't being
// keyed in the current animation, bail. // keyed in the current animation, bail.
#if VERSION_MAJOR > 3 #if VERSION_MAJOR > 3
auto player_editor = AnimationPlayerEditor::get_singleton(); auto player_editor = AnimationPlayerEditor::get_singleton();
@ -259,7 +258,7 @@ void SpineAnimationTrack::update_animation_state(const Variant &variant_sprite)
animation_state->setTimeScale(1); animation_state->setTimeScale(1);
return; return;
} }
// Check if the player is actually editing an animation for which there is a track // Check if the player is actually editing an animation for which there is a track
// for us. // for us.
Ref<Animation> edited_animation = player_editor->get_track_editor()->get_current_animation(); Ref<Animation> edited_animation = player_editor->get_track_editor()->get_current_animation();
@ -269,7 +268,7 @@ void SpineAnimationTrack::update_animation_state(const Variant &variant_sprite)
animation_state->setTimeScale(1); animation_state->setTimeScale(1);
return; return;
} }
int found_track_index = -1; int found_track_index = -1;
auto scene_path = EditorNode::get_singleton()->get_edited_scene()->get_path(); auto scene_path = EditorNode::get_singleton()->get_edited_scene()->get_path();
auto animation_player_path = scene_path.rel_path_to(animation_player->get_path()); auto animation_player_path = scene_path.rel_path_to(animation_player->get_path());
@ -279,9 +278,9 @@ void SpineAnimationTrack::update_animation_state(const Variant &variant_sprite)
if (path == animation_player_path) { if (path == animation_player_path) {
found_track_index = i; found_track_index = i;
break; break;
} }
} }
// if we are track 0, set the skeleton to the setup pose // if we are track 0, set the skeleton to the setup pose
// and the animation state time scale to 0, as we are // and the animation state time scale to 0, as we are
// setting track times manually. Also, kill anything // setting track times manually. Also, kill anything
@ -295,10 +294,10 @@ void SpineAnimationTrack::update_animation_state(const Variant &variant_sprite)
// If no animation is set or it's set to "[stop]", we are done. // If no animation is set or it's set to "[stop]", we are done.
if (EMPTY(animation_name) || animation_name == "[stop]") return; if (EMPTY(animation_name) || animation_name == "[stop]") return;
// If there's no keys on the timeline for this track, we are done. // If there's no keys on the timeline for this track, we are done.
if (edited_animation->track_get_key_count(found_track_index) == 0) return; if (edited_animation->track_get_key_count(found_track_index) == 0) return;
// Find the key in the track that matches the editor's playback position // Find the key in the track that matches the editor's playback position
auto playback_position = player_editor->get_player()->get_current_animation_position(); auto playback_position = player_editor->get_player()->get_current_animation_position();
int key_index = -1; int key_index = -1;
@ -338,7 +337,7 @@ void SpineAnimationTrack::update_animation_state(const Variant &variant_sprite)
entry->setAlpha(alpha); entry->setAlpha(alpha);
entry->setAttachmentThreshold(attachment_threshold); entry->setAttachmentThreshold(attachment_threshold);
entry->setDrawOrderThreshold(draw_order_threshold); entry->setDrawOrderThreshold(draw_order_threshold);
entry->setMixBlend((spine::MixBlend)mix_blend); entry->setMixBlend((spine::MixBlend) mix_blend);
#endif #endif
} else { } else {
if (animation_player->is_playing()) { if (animation_player->is_playing()) {
@ -358,14 +357,14 @@ void SpineAnimationTrack::update_animation_state(const Variant &variant_sprite)
entry->setAlpha(alpha); entry->setAlpha(alpha);
entry->setAttachmentThreshold(attachment_threshold); entry->setAttachmentThreshold(attachment_threshold);
entry->setDrawOrderThreshold(draw_order_threshold); entry->setDrawOrderThreshold(draw_order_threshold);
entry->setMixBlend((spine::MixBlend)mix_blend); entry->setMixBlend((spine::MixBlend) mix_blend);
if (debug) print_line(String("Setting animation {0} with mix_duration {1} on track {2} on {3}").format(varray(animation_name, mix_duration, track_index, sprite->get_name())).utf8().ptr()); if (debug) print_line(String("Setting animation {0} with mix_duration {1} on track {2} on {3}").format(varray(animation_name, mix_duration, track_index, sprite->get_name())).utf8().ptr());
} else { } else {
if (!current_entry || (String("<empty>") != current_entry->getAnimation()->getName().buffer())) { if (!current_entry || (String("<empty>") != current_entry->getAnimation()->getName().buffer())) {
auto entry = animation_state->setEmptyAnimation(track_index, should_set_mix ? mix_duration : 0); auto entry = animation_state->setEmptyAnimation(track_index, should_set_mix ? mix_duration : 0);
entry->setTrackEnd(FLT_MAX); entry->setTrackEnd(FLT_MAX);
if (debug) print_line(String("Setting empty animation with mix_duration {0} on track {1} on {2}").format(varray(mix_duration, track_index, sprite->get_name())).utf8().ptr()); if (debug) print_line(String("Setting empty animation with mix_duration {0} on track {1} on {2}").format(varray(mix_duration, track_index, sprite->get_name())).utf8().ptr());
} }
} }
} }
@ -373,7 +372,7 @@ void SpineAnimationTrack::update_animation_state(const Variant &variant_sprite)
} }
} }
void SpineAnimationTrack::set_animation_name(const String& _animation_name) { void SpineAnimationTrack::set_animation_name(const String &_animation_name) {
animation_name = _animation_name; animation_name = _animation_name;
} }

20
spine-godot/spine_godot/SpineAnimationTrack.h
View File

@ -58,34 +58,34 @@ protected:
SpineSprite *sprite; SpineSprite *sprite;
static void _bind_methods(); static void _bind_methods();
void _notification(int what); void _notification(int what);
AnimationPlayer *find_animation_player(); AnimationPlayer *find_animation_player();
void setup_animation_player(); void setup_animation_player();
static Ref<Animation> create_animation(spine::Animation *animation, bool loop); static Ref<Animation> create_animation(spine::Animation *animation, bool loop);
void update_animation_state(const Variant &variant_sprite); void update_animation_state(const Variant &variant_sprite);
public: public:
SpineAnimationTrack(); SpineAnimationTrack();
void set_animation_name(const String& _animation_name); void set_animation_name(const String &_animation_name);
String get_animation_name(); String get_animation_name();
void set_animation_time (float _animation_time); void set_animation_time(float _animation_time);
float get_animation_time(); float get_animation_time();
void set_loop(bool _loop); void set_loop(bool _loop);
bool get_loop(); bool get_loop();
void set_track_index(int _track_index); void set_track_index(int _track_index);
int get_track_index(); int get_track_index();
void set_mix_duration(float _mix_duration); void set_mix_duration(float _mix_duration);

4
spine-godot/spine_godot/SpineAtlasResource.h
View File

@ -65,9 +65,9 @@ public:
Error load_from_atlas_file(const String &path);// .atlas Error load_from_atlas_file(const String &path);// .atlas
Error load_from_file(const String &path); // .spatlas Error load_from_file(const String &path);// .spatlas
Error save_to_file(const String &path); // .spatlas Error save_to_file(const String &path);// .spatlas
String get_source_path(); String get_source_path();

64
spine-godot/spine_godot/SpineBone.cpp
View File

@ -99,12 +99,12 @@ void SpineBone::_bind_methods() {
} }
void SpineBone::update_world_transform() { void SpineBone::update_world_transform() {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->updateWorldTransform(); get_spine_object()->updateWorldTransform();
} }
void SpineBone::set_to_setup_pose() { void SpineBone::set_to_setup_pose() {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setToSetupPose(); get_spine_object()->setToSetupPose();
} }
@ -133,7 +133,7 @@ float SpineBone::local_to_world_rotation(float local_rotation) {
} }
void SpineBone::rotate_world(float degrees) { void SpineBone::rotate_world(float degrees) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->rotateWorld(degrees); get_spine_object()->rotateWorld(degrees);
} }
@ -168,7 +168,7 @@ Array SpineBone::get_children() {
Array result; Array result;
SPINE_CHECK(get_spine_object(), result) SPINE_CHECK(get_spine_object(), result)
auto children = get_spine_object()->getChildren(); auto children = get_spine_object()->getChildren();
result.resize((int)children.size()); result.resize((int) children.size());
for (int i = 0; i < children.size(); ++i) { for (int i = 0; i < children.size(); ++i) {
auto child = children[i]; auto child = children[i];
Ref<SpineBone> bone_ref(memnew(SpineBone)); Ref<SpineBone> bone_ref(memnew(SpineBone));
@ -184,7 +184,7 @@ float SpineBone::get_x() {
} }
void SpineBone::set_x(float v) { void SpineBone::set_x(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setX(v); get_spine_object()->setX(v);
} }
@ -194,7 +194,7 @@ float SpineBone::get_y() {
} }
void SpineBone::set_y(float v) { void SpineBone::set_y(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setY(v); get_spine_object()->setY(v);
} }
@ -204,7 +204,7 @@ float SpineBone::get_rotation() {
} }
void SpineBone::set_rotation(float v) { void SpineBone::set_rotation(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setRotation(v); get_spine_object()->setRotation(v);
} }
@ -214,7 +214,7 @@ float SpineBone::get_scale_x() {
} }
void SpineBone::set_scale_x(float v) { void SpineBone::set_scale_x(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setScaleX(v); get_spine_object()->setScaleX(v);
} }
@ -224,7 +224,7 @@ float SpineBone::get_scale_y() {
} }
void SpineBone::set_scale_y(float v) { void SpineBone::set_scale_y(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setScaleY(v); get_spine_object()->setScaleY(v);
} }
@ -234,7 +234,7 @@ float SpineBone::get_shear_x() {
} }
void SpineBone::set_shear_x(float v) { void SpineBone::set_shear_x(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setShearX(v); get_spine_object()->setShearX(v);
} }
@ -244,7 +244,7 @@ float SpineBone::get_shear_y() {
} }
void SpineBone::set_shear_y(float v) { void SpineBone::set_shear_y(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setShearY(v); get_spine_object()->setShearY(v);
} }
@ -254,7 +254,7 @@ float SpineBone::get_applied_rotation() {
} }
void SpineBone::set_applied_rotation(float v) { void SpineBone::set_applied_rotation(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setAppliedRotation(v); get_spine_object()->setAppliedRotation(v);
} }
@ -264,7 +264,7 @@ float SpineBone::get_a_x() {
} }
void SpineBone::set_a_x(float v) { void SpineBone::set_a_x(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setAX(v); get_spine_object()->setAX(v);
} }
@ -274,7 +274,7 @@ float SpineBone::get_a_y() {
} }
void SpineBone::set_a_y(float v) { void SpineBone::set_a_y(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setAY(v); get_spine_object()->setAY(v);
} }
@ -284,7 +284,7 @@ float SpineBone::get_a_scale_x() {
} }
void SpineBone::set_a_scale_x(float v) { void SpineBone::set_a_scale_x(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setAScaleX(v); get_spine_object()->setAScaleX(v);
} }
@ -294,7 +294,7 @@ float SpineBone::get_a_scale_y() {
} }
void SpineBone::set_a_scale_y(float v) { void SpineBone::set_a_scale_y(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setAScaleY(v); get_spine_object()->setAScaleY(v);
} }
@ -304,7 +304,7 @@ float SpineBone::get_a_shear_x() {
} }
void SpineBone::set_a_shear_x(float v) { void SpineBone::set_a_shear_x(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setAShearX(v); get_spine_object()->setAShearX(v);
} }
@ -314,7 +314,7 @@ float SpineBone::get_a_shear_y() {
} }
void SpineBone::set_a_shear_y(float v) { void SpineBone::set_a_shear_y(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setAShearY(v); get_spine_object()->setAShearY(v);
} }
@ -324,7 +324,7 @@ float SpineBone::get_a() {
} }
void SpineBone::set_a(float v) { void SpineBone::set_a(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setA(v); get_spine_object()->setA(v);
} }
@ -334,7 +334,7 @@ float SpineBone::get_b() {
} }
void SpineBone::set_b(float v) { void SpineBone::set_b(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setB(v); get_spine_object()->setB(v);
} }
@ -344,7 +344,7 @@ float SpineBone::get_c() {
} }
void SpineBone::set_c(float v) { void SpineBone::set_c(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setC(v); get_spine_object()->setC(v);
} }
@ -354,7 +354,7 @@ float SpineBone::get_d() {
} }
void SpineBone::set_d(float v) { void SpineBone::set_d(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setD(v); get_spine_object()->setD(v);
} }
@ -364,7 +364,7 @@ float SpineBone::get_world_x() {
} }
void SpineBone::set_world_x(float v) { void SpineBone::set_world_x(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setWorldX(v); get_spine_object()->setWorldX(v);
} }
@ -374,7 +374,7 @@ float SpineBone::get_world_y() {
} }
void SpineBone::set_world_y(float v) { void SpineBone::set_world_y(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setWorldY(v); get_spine_object()->setWorldY(v);
} }
@ -404,16 +404,16 @@ bool SpineBone::is_active() {
return get_spine_object()->isActive(); return get_spine_object()->isActive();
} }
void SpineBone::set_active(bool v) { void SpineBone::set_active(bool v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setActive(v); get_spine_object()->setActive(v);
} }
// External feature functions // External feature functions
void SpineBone::apply_world_transform_2d(const Variant &o) { void SpineBone::apply_world_transform_2d(const Variant &o) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
if (o.get_type() == Variant::OBJECT) { if (o.get_type() == Variant::OBJECT) {
auto node2d = Object::cast_to<Node2D>(o.operator Object*()); auto node2d = Object::cast_to<Node2D>(o.operator Object *());
if (node2d) { if (node2d) {
// In godot the y-axis is nag to spine // In godot the y-axis is nag to spine
node2d->set_transform(Transform2D( node2d->set_transform(Transform2D(
get_a(), get_c(), get_a(), get_c(),
@ -438,7 +438,7 @@ Transform2D SpineBone::get_transform() {
} }
void SpineBone::set_transform(Transform2D transform) { void SpineBone::set_transform(Transform2D transform) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
Vector2 position = transform.get_origin(); Vector2 position = transform.get_origin();
float rotation = Math::rad2deg(transform.get_rotation()); float rotation = Math::rad2deg(transform.get_rotation());
Vector2 scale = transform.get_scale(); Vector2 scale = transform.get_scale();
@ -464,12 +464,12 @@ Transform2D SpineBone::get_global_transform() {
} }
void SpineBone::set_global_transform(Transform2D transform) { void SpineBone::set_global_transform(Transform2D transform) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
if (!get_spine_owner()) set_transform(transform); if (!get_spine_owner()) set_transform(transform);
if (!get_spine_owner()->is_visible_in_tree()) return; if (!get_spine_owner()->is_visible_in_tree()) return;
auto bone = get_spine_object(); auto bone = get_spine_object();
Transform2D inverse_sprite_transform = get_spine_owner()->get_global_transform().affine_inverse(); Transform2D inverse_sprite_transform = get_spine_owner()->get_global_transform().affine_inverse();
transform = inverse_sprite_transform * transform; transform = inverse_sprite_transform * transform;
Vector2 position = transform.get_origin(); Vector2 position = transform.get_origin();
@ -480,7 +480,7 @@ void SpineBone::set_global_transform(Transform2D transform) {
Vector2 local_scale = scale; Vector2 local_scale = scale;
spine::Bone *parent = bone->getParent(); spine::Bone *parent = bone->getParent();
if (parent) { if (parent) {
parent->worldToLocal(local_position.x, local_position.y, local_position.x, local_position.y); parent->worldToLocal(local_position.x, local_position.y, local_position.x, local_position.y);
} }
bone->setX(local_position.x); bone->setX(local_position.x);
bone->setY(local_position.y); bone->setY(local_position.y);

22
spine-godot/spine_godot/SpineBoneData.cpp
View File

@ -83,7 +83,7 @@ float SpineBoneData::get_length() {
} }
void SpineBoneData::set_length(float v) { void SpineBoneData::set_length(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setLength(v); get_spine_object()->setLength(v);
} }
@ -93,7 +93,7 @@ float SpineBoneData::get_x() {
} }
void SpineBoneData::set_x(float v) { void SpineBoneData::set_x(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setX(v); get_spine_object()->setX(v);
} }
@ -103,7 +103,7 @@ float SpineBoneData::get_y() {
} }
void SpineBoneData::set_y(float v) { void SpineBoneData::set_y(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setY(v); get_spine_object()->setY(v);
} }
@ -113,7 +113,7 @@ float SpineBoneData::get_rotation() {
} }
void SpineBoneData::set_rotation(float v) { void SpineBoneData::set_rotation(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setRotation(v); get_spine_object()->setRotation(v);
} }
@ -123,7 +123,7 @@ float SpineBoneData::get_scale_x() {
} }
void SpineBoneData::set_scale_x(float v) { void SpineBoneData::set_scale_x(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setScaleX(v); get_spine_object()->setScaleX(v);
} }
@ -133,7 +133,7 @@ float SpineBoneData::get_scale_y() {
} }
void SpineBoneData::set_scale_y(float v) { void SpineBoneData::set_scale_y(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setScaleY(v); get_spine_object()->setScaleY(v);
} }
@ -143,7 +143,7 @@ float SpineBoneData::get_shear_x() {
} }
void SpineBoneData::set_shear_x(float v) { void SpineBoneData::set_shear_x(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setShearX(v); get_spine_object()->setShearX(v);
} }
@ -153,7 +153,7 @@ float SpineBoneData::get_shear_y() {
} }
void SpineBoneData::set_shear_y(float v) { void SpineBoneData::set_shear_y(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setShearY(v); get_spine_object()->setShearY(v);
} }
@ -163,7 +163,7 @@ SpineConstant::TransformMode SpineBoneData::get_transform_mode() {
} }
void SpineBoneData::set_transform_mode(SpineConstant::TransformMode v) { void SpineBoneData::set_transform_mode(SpineConstant::TransformMode v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setTransformMode((spine::TransformMode) v); get_spine_object()->setTransformMode((spine::TransformMode) v);
} }
@ -173,7 +173,7 @@ bool SpineBoneData::is_skin_required() {
} }
void SpineBoneData::set_skin_required(bool v) { void SpineBoneData::set_skin_required(bool v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setSkinRequired(v); get_spine_object()->setSkinRequired(v);
} }
@ -184,6 +184,6 @@ Color SpineBoneData::get_color() {
} }
void SpineBoneData::set_color(Color color) { void SpineBoneData::set_color(Color color) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->getColor().set(color.r, color.g, color.b, color.a); get_spine_object()->getColor().set(color.r, color.g, color.b, color.a);
} }

37
spine-godot/spine_godot/SpineBoneNode.cpp
View File

@ -54,8 +54,8 @@ void SpineBoneNode::_bind_methods() {
} }
void SpineBoneNode::_notification(int what) { void SpineBoneNode::_notification(int what) {
switch(what) { switch (what) {
case NOTIFICATION_PARENTED: { case NOTIFICATION_PARENTED: {
SpineSprite *sprite = find_parent_sprite(); SpineSprite *sprite = find_parent_sprite();
if (sprite) { if (sprite) {
#if VERSION_MAJOR > 3 #if VERSION_MAJOR > 3
@ -78,8 +78,8 @@ void SpineBoneNode::_notification(int what) {
} }
NOTIFY_PROPERTY_LIST_CHANGED(); NOTIFY_PROPERTY_LIST_CHANGED();
break; break;
} }
case NOTIFICATION_UNPARENTED: { case NOTIFICATION_UNPARENTED: {
SpineSprite *sprite = find_parent_sprite(); SpineSprite *sprite = find_parent_sprite();
if (sprite) { if (sprite) {
#if VERSION_MAJOR > 3 #if VERSION_MAJOR > 3
@ -89,21 +89,22 @@ void SpineBoneNode::_notification(int what) {
#endif #endif
} }
break; break;
} }
case NOTIFICATION_DRAW: { case NOTIFICATION_DRAW: {
draw(); draw();
break; break;
} }
default: default:
break; break;
} }
} }
void SpineBoneNode::_get_property_list(List<PropertyInfo>* list) const { void SpineBoneNode::_get_property_list(List<PropertyInfo> *list) const {
Vector<String> bone_names; Vector<String> bone_names;
SpineSprite *sprite = find_parent_sprite(); SpineSprite *sprite = find_parent_sprite();
if (sprite) sprite->get_skeleton_data_res()->get_bone_names(bone_names); if (sprite) sprite->get_skeleton_data_res()->get_bone_names(bone_names);
else bone_names.push_back(bone_name); else
bone_names.push_back(bone_name);
auto element = list->front(); auto element = list->front();
while (element) { while (element) {
auto property_info = element->get(); auto property_info = element->get();
@ -119,7 +120,7 @@ void SpineBoneNode::_get_property_list(List<PropertyInfo>* list) const {
list->insert_after(element, slot_name_property); list->insert_after(element, slot_name_property);
} }
bool SpineBoneNode::_get(const StringName& property, Variant& value) const { bool SpineBoneNode::_get(const StringName &property, Variant &value) const {
if (property == "bone_name") { if (property == "bone_name") {
value = bone_name; value = bone_name;
return true; return true;
@ -127,7 +128,7 @@ bool SpineBoneNode::_get(const StringName& property, Variant& value) const {
return false; return false;
} }
bool SpineBoneNode::_set(const StringName& property, const Variant& value) { bool SpineBoneNode::_set(const StringName &property, const Variant &value) {
if (property == "bone_name") { if (property == "bone_name") {
bone_name = value; bone_name = value;
SpineSprite *sprite = find_parent_sprite(); SpineSprite *sprite = find_parent_sprite();
@ -137,20 +138,20 @@ bool SpineBoneNode::_set(const StringName& property, const Variant& value) {
return false; return false;
} }
void SpineBoneNode::on_world_transforms_changed(const Variant& _sprite) { void SpineBoneNode::on_world_transforms_changed(const Variant &_sprite) {
SpineSprite* sprite = cast_to<SpineSprite>(_sprite.operator Object*()); SpineSprite *sprite = cast_to<SpineSprite>(_sprite.operator Object *());
update_transform(sprite); update_transform(sprite);
update(); update();
} }
void SpineBoneNode::update_transform(SpineSprite* sprite) { void SpineBoneNode::update_transform(SpineSprite *sprite) {
if (!enabled) return; if (!enabled) return;
Ref<SpineBone> bone = find_bone(); Ref<SpineBone> bone = find_bone();
if (!bone.is_valid()) return; if (!bone.is_valid()) return;
Transform2D bone_transform = bone->get_global_transform(); Transform2D bone_transform = bone->get_global_transform();
Transform2D this_transform = get_global_transform(); Transform2D this_transform = get_global_transform();
if (bone_mode == SpineConstant::BoneMode_Drive) { if (bone_mode == SpineConstant::BoneMode_Drive) {
bone->set_global_transform(this_transform); bone->set_global_transform(this_transform);
} else { } else {
@ -170,7 +171,7 @@ void SpineBoneNode::update_transform(SpineSprite* sprite) {
} }
} }
void SpineBoneNode::init_transform(SpineSprite* sprite) { void SpineBoneNode::init_transform(SpineSprite *sprite) {
if (!sprite) return; if (!sprite) return;
if (bone_mode == SpineConstant::BoneMode_Drive) return; if (bone_mode == SpineConstant::BoneMode_Drive) return;
sprite->get_skeleton()->set_to_setup_pose(); sprite->get_skeleton()->set_to_setup_pose();

8
spine-godot/spine_godot/SpineBoneNode.h
View File

@ -33,7 +33,7 @@
#include "SpineSprite.h" #include "SpineSprite.h"
#include "scene/2d/node_2d.h" #include "scene/2d/node_2d.h"
class SpineBoneNode: public Node2D { class SpineBoneNode : public Node2D {
GDCLASS(SpineBoneNode, Node2D) GDCLASS(SpineBoneNode, Node2D)
protected: protected:
@ -42,7 +42,7 @@ protected:
bool enabled; bool enabled;
Color debug_color; Color debug_color;
float debug_thickness; float debug_thickness;
static void _bind_methods(); static void _bind_methods();
void _notification(int what); void _notification(int what);
void _get_property_list(List<PropertyInfo> *list) const; void _get_property_list(List<PropertyInfo> *list) const;
@ -54,9 +54,9 @@ protected:
SpineSprite *find_parent_sprite() const; SpineSprite *find_parent_sprite() const;
Ref<SpineBone> find_bone() const; Ref<SpineBone> find_bone() const;
void draw(); void draw();
public: public:
SpineBoneNode(): bone_mode(SpineConstant::BoneMode_Follow), enabled(true), debug_color(Color::hex(0xff000077)), debug_thickness(5) {} SpineBoneNode() : bone_mode(SpineConstant::BoneMode_Follow), enabled(true), debug_color(Color::hex(0xff000077)), debug_thickness(5) {}
SpineConstant::BoneMode get_bone_mode(); SpineConstant::BoneMode get_bone_mode();

49
spine-godot/spine_godot/SpineCommon.h
View File

@ -58,20 +58,20 @@
#define GEOMETRY2D Geometry #define GEOMETRY2D Geometry
#endif #endif
#define SPINE_CHECK(obj, ret) \ #define SPINE_CHECK(obj, ret) \
if (!(obj)) { \ if (!(obj)) { \
ERR_PRINT("Native Spine object not set."); \ ERR_PRINT("Native Spine object not set."); \
return ret; \ return ret; \
} }
#define SPINE_STRING(x) spine::String((x).utf8()) #define SPINE_STRING(x) spine::String((x).utf8())
// Can't do template classes with Godot's object model :( // Can't do template classes with Godot's object model :(
class SpineObjectWrapper : public REFCOUNTED { class SpineObjectWrapper : public REFCOUNTED {
GDCLASS(SpineObjectWrapper, REFCOUNTED) GDCLASS(SpineObjectWrapper, REFCOUNTED)
Object* spine_owner; Object *spine_owner;
void* spine_object; void *spine_object;
protected: protected:
static void _bind_methods() { static void _bind_methods() {
@ -86,11 +86,12 @@ protected:
spine_owner->disconnect("_internal_spine_objects_invalidated", this, "_internal_spine_objects_invalidated"); spine_owner->disconnect("_internal_spine_objects_invalidated", this, "_internal_spine_objects_invalidated");
#endif #endif
} }
SpineObjectWrapper(): spine_owner(nullptr), spine_object(nullptr) { SpineObjectWrapper() : spine_owner(nullptr), spine_object(nullptr) {
} }
template <typename OWNER, typename OBJECT> void _set_spine_object_internal(const OWNER* _owner, OBJECT* _object) { template<typename OWNER, typename OBJECT>
void _set_spine_object_internal(const OWNER *_owner, OBJECT *_object) {
if (spine_owner) { if (spine_owner) {
ERR_PRINT("Owner already set."); ERR_PRINT("Owner already set.");
return; return;
@ -104,7 +105,7 @@ protected:
return; return;
} }
spine_owner = (Object*)_owner; spine_owner = (Object *) _owner;
spine_object = _object; spine_object = _object;
#if VERSION_MAJOR > 3 #if VERSION_MAJOR > 3
spine_owner->connect("_internal_spine_objects_invalidated", callable_mp(this, &SpineObjectWrapper::spine_objects_invalidated)); spine_owner->connect("_internal_spine_objects_invalidated", callable_mp(this, &SpineObjectWrapper::spine_objects_invalidated));
@ -119,35 +120,37 @@ protected:
class SpineSprite; class SpineSprite;
template <typename OBJECT> class SpineSpriteOwnedObject: public SpineObjectWrapper { template<typename OBJECT>
class SpineSpriteOwnedObject : public SpineObjectWrapper {
public: public:
void set_spine_object(const SpineSprite* _owner, OBJECT* _object) { void set_spine_object(const SpineSprite *_owner, OBJECT *_object) {
_set_spine_object_internal(_owner, _object); _set_spine_object_internal(_owner, _object);
} }
OBJECT *get_spine_object() { OBJECT *get_spine_object() {
return (OBJECT*)_get_spine_object_internal(); return (OBJECT *) _get_spine_object_internal();
} }
SpineSprite *get_spine_owner() { SpineSprite *get_spine_owner() {
return (SpineSprite*)_get_spine_owner_internal(); return (SpineSprite *) _get_spine_owner_internal();
} }
}; };
class SpineSkeletonDataResource; class SpineSkeletonDataResource;
template <typename OBJECT> class SpineSkeletonDataResourceOwnedObject: public SpineObjectWrapper { template<typename OBJECT>
class SpineSkeletonDataResourceOwnedObject : public SpineObjectWrapper {
public: public:
void set_spine_object(const SpineSkeletonDataResource* _owner, OBJECT* _object) { void set_spine_object(const SpineSkeletonDataResource *_owner, OBJECT *_object) {
_set_spine_object_internal(_owner, _object); _set_spine_object_internal(_owner, _object);
} }
OBJECT *get_spine_object() { OBJECT *get_spine_object() {
return (OBJECT*)_get_spine_object_internal(); return (OBJECT *) _get_spine_object_internal();
} }
SpineSkeletonDataResource *get_spine_owner() { SpineSkeletonDataResource *get_spine_owner() {
return (SpineSkeletonDataResource*)_get_spine_owner_internal(); return (SpineSkeletonDataResource *) _get_spine_owner_internal();
} }
}; };

6
spine-godot/spine_godot/SpineConstraintData.cpp
View File

@ -46,11 +46,11 @@ String SpineConstraintData::get_constraint_name() {
int SpineConstraintData::get_order() { int SpineConstraintData::get_order() {
SPINE_CHECK(get_spine_object(), 0) SPINE_CHECK(get_spine_object(), 0)
return (int)get_spine_object()->getOrder(); return (int) get_spine_object()->getOrder();
} }
void SpineConstraintData::set_order(int v) { void SpineConstraintData::set_order(int v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setOrder(v); get_spine_object()->setOrder(v);
} }
@ -60,6 +60,6 @@ bool SpineConstraintData::is_skin_required() {
} }
void SpineConstraintData::set_skin_required(bool v) { void SpineConstraintData::set_skin_required(bool v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setSkinRequired(v); get_spine_object()->setSkinRequired(v);
} }

18
spine-godot/spine_godot/SpineEditorPlugin.cpp
View File

@ -100,10 +100,10 @@ bool SpineSkeletonDataResourceInspectorPlugin::can_handle(Object *object) {
} }
#if VERSION_MAJOR > 3 #if VERSION_MAJOR > 3
bool SpineSkeletonDataResourceInspectorPlugin:: parse_property(Object *object, const Variant::Type type, const String &path, const PropertyHint hint, const String &hint_text, const uint32_t usage, const bool wide) { bool SpineSkeletonDataResourceInspectorPlugin::parse_property(Object *object, const Variant::Type type, const String &path, const PropertyHint hint, const String &hint_text, const uint32_t usage, const bool wide) {
#else #else
bool SpineSkeletonDataResourceInspectorPlugin::parse_property(Object *object, Variant::Type type, const String &path, bool SpineSkeletonDataResourceInspectorPlugin::parse_property(Object *object, Variant::Type type, const String &path,
PropertyHint hint, const String &hint_text, int usage) { PropertyHint hint, const String &hint_text, int usage) {
#endif #endif
if (path == "animation_mixes") { if (path == "animation_mixes") {
Ref<SpineSkeletonDataResource> skeleton_data = Object::cast_to<SpineSkeletonDataResource>(object); Ref<SpineSkeletonDataResource> skeleton_data = Object::cast_to<SpineSkeletonDataResource>(object);
@ -116,7 +116,7 @@ bool SpineSkeletonDataResourceInspectorPlugin::parse_property(Object *object, Va
return false; return false;
} }
SpineEditorPropertyAnimationMixes::SpineEditorPropertyAnimationMixes(): skeleton_data(nullptr), container(nullptr), updating(false) { SpineEditorPropertyAnimationMixes::SpineEditorPropertyAnimationMixes() : skeleton_data(nullptr), container(nullptr), updating(false) {
INSTANTIATE(array_object); INSTANTIATE(array_object);
} }
@ -146,9 +146,9 @@ void SpineEditorPropertyAnimationMixes::delete_mix(int idx) {
auto mixes = skeleton_data->get_animation_mixes().duplicate(); auto mixes = skeleton_data->get_animation_mixes().duplicate();
#if VERSION_MAJOR > 3 #if VERSION_MAJOR > 3
mixes.remove_at((int)idx); mixes.remove_at((int) idx);
#else #else
mixes.remove((int)idx); mixes.remove((int) idx);
#endif #endif
emit_changed(get_edited_property(), mixes); emit_changed(get_edited_property(), mixes);
} }
@ -224,7 +224,7 @@ void SpineEditorPropertyAnimationMixes::update_property() {
updating = false; updating = false;
} }
SpineEditorPropertyAnimationMix::SpineEditorPropertyAnimationMix(): mixes_property(nullptr), skeleton_data(nullptr), index(0), container(nullptr), updating(false) { SpineEditorPropertyAnimationMix::SpineEditorPropertyAnimationMix() : mixes_property(nullptr), skeleton_data(nullptr), index(0), container(nullptr), updating(false) {
} }
void SpineEditorPropertyAnimationMix::setup(SpineEditorPropertyAnimationMixes *_mixes_property, const Ref<SpineSkeletonDataResource> &_skeleton_data, int _index) { void SpineEditorPropertyAnimationMix::setup(SpineEditorPropertyAnimationMixes *_mixes_property, const Ref<SpineSkeletonDataResource> &_skeleton_data, int _index) {
@ -331,14 +331,14 @@ void SpineSpriteInspectorPlugin::_bind_methods() {
ClassDB::bind_method(D_METHOD("button_clicked"), &SpineSpriteInspectorPlugin::button_clicked); ClassDB::bind_method(D_METHOD("button_clicked"), &SpineSpriteInspectorPlugin::button_clicked);
} }
void SpineSpriteInspectorPlugin::button_clicked(const String& button_name) { void SpineSpriteInspectorPlugin::button_clicked(const String &button_name) {
} }
bool SpineSpriteInspectorPlugin::can_handle(Object* object) { bool SpineSpriteInspectorPlugin::can_handle(Object *object) {
return Object::cast_to<SpineSprite>(object) != nullptr; return Object::cast_to<SpineSprite>(object) != nullptr;
} }
void SpineSpriteInspectorPlugin::parse_begin(Object* object) { void SpineSpriteInspectorPlugin::parse_begin(Object *object) {
sprite = Object::cast_to<SpineSprite>(object); sprite = Object::cast_to<SpineSprite>(object);
if (!sprite) return; if (!sprite) return;
if (!sprite->get_skeleton_data_res().is_valid() || !sprite->get_skeleton_data_res()->is_skeleton_data_loaded()) return; if (!sprite->get_skeleton_data_res().is_valid() || !sprite->get_skeleton_data_res()->is_skeleton_data_loaded()) return;

29
spine-godot/spine_godot/SpineEditorPlugin.h
View File

@ -68,7 +68,7 @@ public:
bool get_option_visibility(const String &option, const Map<StringName, Variant> &options) const override { return true; } bool get_option_visibility(const String &option, const Map<StringName, Variant> &options) const override { return true; }
Error import(const String &source_file, const String &save_path, const Map<StringName, Variant> &options, List<String> *platform_variants, List<String> *gen_files, Variant *metadata) override; Error import(const String &source_file, const String &save_path, const Map<StringName, Variant> &options, List<String> *platform_variants, List<String> *gen_files, Variant *metadata) override;
#endif #endif
}; };
class SpineJsonResourceImportPlugin : public EditorImportPlugin { class SpineJsonResourceImportPlugin : public EditorImportPlugin {
@ -92,18 +92,18 @@ public:
#if VERSION_MAJOR > 3 #if VERSION_MAJOR > 3
int get_import_order() const override { return IMPORT_ORDER_DEFAULT; } int get_import_order() const override { return IMPORT_ORDER_DEFAULT; }
void get_import_options(const String &path, List<ImportOption> *options, int preset) const override { } void get_import_options(const String &path, List<ImportOption> *options, int preset) const override {}
bool get_option_visibility(const String &path, const String &option, const HashMap<StringName, Variant> &options) const override { return true; } bool get_option_visibility(const String &path, const String &option, const HashMap<StringName, Variant> &options) const override { return true; }
Error import(const String &source_file, const String &save_path, const HashMap<StringName, Variant> &options, List<String> *platform_variants, List<String> *gen_files, Variant *metadata) override; Error import(const String &source_file, const String &save_path, const HashMap<StringName, Variant> &options, List<String> *platform_variants, List<String> *gen_files, Variant *metadata) override;
#else #else
void get_import_options(List<ImportOption> *options, int preset) const override { } void get_import_options(List<ImportOption> *options, int preset) const override {}
bool get_option_visibility(const String &option, const Map<StringName, Variant> &options) const override { return true; } bool get_option_visibility(const String &option, const Map<StringName, Variant> &options) const override { return true; }
Error import(const String &source_file, const String &save_path, const Map<StringName, Variant> &options, List<String> *platform_variants, List<String> *gen_files, Variant *metadata) override; Error import(const String &source_file, const String &save_path, const Map<StringName, Variant> &options, List<String> *platform_variants, List<String> *gen_files, Variant *metadata) override;
#endif #endif
}; };
class SpineBinaryResourceImportPlugin : public EditorImportPlugin { class SpineBinaryResourceImportPlugin : public EditorImportPlugin {
@ -127,18 +127,18 @@ public:
#if VERSION_MAJOR > 3 #if VERSION_MAJOR > 3
int get_import_order() const override { return IMPORT_ORDER_DEFAULT; } int get_import_order() const override { return IMPORT_ORDER_DEFAULT; }
void get_import_options(const String &path, List<ImportOption> *options, int preset) const override { } void get_import_options(const String &path, List<ImportOption> *options, int preset) const override {}
bool get_option_visibility(const String &path, const String &option, const HashMap<StringName, Variant> &options) const override { return true; } bool get_option_visibility(const String &path, const String &option, const HashMap<StringName, Variant> &options) const override { return true; }
Error import(const String &source_file, const String &save_path, const HashMap<StringName, Variant> &options, List<String> *platform_variants, List<String> *gen_files, Variant *metadata) override; Error import(const String &source_file, const String &save_path, const HashMap<StringName, Variant> &options, List<String> *platform_variants, List<String> *gen_files, Variant *metadata) override;
#else #else
void get_import_options(List<ImportOption> *options, int preset) const override { } void get_import_options(List<ImportOption> *options, int preset) const override {}
bool get_option_visibility(const String &option, const Map<StringName, Variant> &options) const override { return true; } bool get_option_visibility(const String &option, const Map<StringName, Variant> &options) const override { return true; }
Error import(const String &source_file, const String &save_path, const Map<StringName, Variant> &options, List<String> *platform_variants, List<String> *gen_files, Variant *metadata) override; Error import(const String &source_file, const String &save_path, const Map<StringName, Variant> &options, List<String> *platform_variants, List<String> *gen_files, Variant *metadata) override;
#endif #endif
}; };
class SpineEditorPlugin : public EditorPlugin { class SpineEditorPlugin : public EditorPlugin {
@ -150,7 +150,7 @@ public:
String get_name() const override { return "SpineEditorPlugin"; } String get_name() const override { return "SpineEditorPlugin"; }
}; };
class SpineSkeletonDataResourceInspectorPlugin: public EditorInspectorPlugin { class SpineSkeletonDataResourceInspectorPlugin : public EditorInspectorPlugin {
GDCLASS(SpineSkeletonDataResourceInspectorPlugin, EditorInspectorPlugin) GDCLASS(SpineSkeletonDataResourceInspectorPlugin, EditorInspectorPlugin)
public: public:
@ -164,26 +164,27 @@ public:
class SpineEditorPropertyAnimationMix; class SpineEditorPropertyAnimationMix;
class SpineEditorPropertyAnimationMixes: public EditorProperty { class SpineEditorPropertyAnimationMixes : public EditorProperty {
GDCLASS(SpineEditorPropertyAnimationMixes, EditorProperty) GDCLASS(SpineEditorPropertyAnimationMixes, EditorProperty)
Ref<EditorPropertyArrayObject> array_object; Ref<EditorPropertyArrayObject> array_object;
Ref<SpineSkeletonDataResource> skeleton_data; Ref<SpineSkeletonDataResource> skeleton_data;
VBoxContainer *container; VBoxContainer *container;
Vector<SpineEditorPropertyAnimationMix*> mix_properties; Vector<SpineEditorPropertyAnimationMix *> mix_properties;
bool updating; bool updating;
static void _bind_methods(); static void _bind_methods();
void add_mix(); void add_mix();
void delete_mix(int idx); void delete_mix(int idx);
void update_mix_property(int index); void update_mix_property(int index);
public: public:
SpineEditorPropertyAnimationMixes(); SpineEditorPropertyAnimationMixes();
void setup(const Ref<SpineSkeletonDataResource> &_skeleton_data) { this->skeleton_data = _skeleton_data; }; void setup(const Ref<SpineSkeletonDataResource> &_skeleton_data) { this->skeleton_data = _skeleton_data; };
void update_property() override; void update_property() override;
}; };
class SpineEditorPropertyAnimationMix: public EditorProperty { class SpineEditorPropertyAnimationMix : public EditorProperty {
GDCLASS(SpineEditorPropertyAnimationMix, EditorProperty) GDCLASS(SpineEditorPropertyAnimationMix, EditorProperty)
SpineEditorPropertyAnimationMixes *mixes_property; SpineEditorPropertyAnimationMixes *mixes_property;
@ -194,19 +195,21 @@ class SpineEditorPropertyAnimationMix: public EditorProperty {
static void _bind_methods(); static void _bind_methods();
void data_changed(const String &property, const Variant &value, const String &name, bool changing); void data_changed(const String &property, const Variant &value, const String &name, bool changing);
public: public:
SpineEditorPropertyAnimationMix(); SpineEditorPropertyAnimationMix();
void setup(SpineEditorPropertyAnimationMixes *mixes_property, const Ref<SpineSkeletonDataResource> &skeleton_data, int index); void setup(SpineEditorPropertyAnimationMixes *mixes_property, const Ref<SpineSkeletonDataResource> &skeleton_data, int index);
void update_property() override; void update_property() override;
}; };
class SpineSpriteInspectorPlugin: public EditorInspectorPlugin { class SpineSpriteInspectorPlugin : public EditorInspectorPlugin {
GDCLASS(SpineSpriteInspectorPlugin, EditorInspectorPlugin) GDCLASS(SpineSpriteInspectorPlugin, EditorInspectorPlugin)
SpineSprite *sprite; SpineSprite *sprite;
static void _bind_methods(); static void _bind_methods();
void button_clicked(const String &button_name); void button_clicked(const String &button_name);
public: public:
bool can_handle(Object *object) override; bool can_handle(Object *object) override;
void parse_begin(Object *object) override; void parse_begin(Object *object) override;

12
spine-godot/spine_godot/SpineEvent.cpp
View File

@ -49,7 +49,7 @@ void SpineEvent::_bind_methods() {
Ref<SpineEventData> SpineEvent::get_data() { Ref<SpineEventData> SpineEvent::get_data() {
SPINE_CHECK(get_spine_object(), nullptr) SPINE_CHECK(get_spine_object(), nullptr)
Ref<SpineEventData> event_data(memnew(SpineEventData)); Ref<SpineEventData> event_data(memnew(SpineEventData));
event_data->set_spine_object(*get_spine_owner()->get_skeleton_data_res(), (spine::EventData*)&get_spine_object()->getData()); event_data->set_spine_object(*get_spine_owner()->get_skeleton_data_res(), (spine::EventData *) &get_spine_object()->getData());
return event_data; return event_data;
} }
@ -64,7 +64,7 @@ int SpineEvent::get_int_value() {
} }
void SpineEvent::set_int_value(int v) { void SpineEvent::set_int_value(int v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setIntValue(v); get_spine_object()->setIntValue(v);
} }
@ -74,7 +74,7 @@ float SpineEvent::get_float_value() {
} }
void SpineEvent::set_float_value(float v) { void SpineEvent::set_float_value(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setFloatValue(v); get_spine_object()->setFloatValue(v);
} }
@ -84,7 +84,7 @@ String SpineEvent::get_string_value() {
} }
void SpineEvent::set_string_value(const String &v) { void SpineEvent::set_string_value(const String &v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setStringValue(spine::String(v.utf8())); get_spine_object()->setStringValue(spine::String(v.utf8()));
} }
@ -94,7 +94,7 @@ float SpineEvent::get_volume() {
} }
void SpineEvent::set_volume(float v) { void SpineEvent::set_volume(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setVolume(v); get_spine_object()->setVolume(v);
} }
@ -104,6 +104,6 @@ float SpineEvent::get_balance() {
} }
void SpineEvent::set_balance(float v) { void SpineEvent::set_balance(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setBalance(v); get_spine_object()->setBalance(v);
} }

66
spine-godot/spine_godot/SpineEventData.cpp
View File

@ -31,70 +31,70 @@
#include "SpineCommon.h" #include "SpineCommon.h"
void SpineEventData::_bind_methods() { void SpineEventData::_bind_methods() {
ClassDB::bind_method(D_METHOD("get_event_name"), &SpineEventData::get_event_name); ClassDB::bind_method(D_METHOD("get_event_name"), &SpineEventData::get_event_name);
ClassDB::bind_method(D_METHOD("get_int_value"), &SpineEventData::get_int_value); ClassDB::bind_method(D_METHOD("get_int_value"), &SpineEventData::get_int_value);
ClassDB::bind_method(D_METHOD("set_int_value", "v"), &SpineEventData::set_int_value); ClassDB::bind_method(D_METHOD("set_int_value", "v"), &SpineEventData::set_int_value);
ClassDB::bind_method(D_METHOD("get_float_value"), &SpineEventData::get_float_value); ClassDB::bind_method(D_METHOD("get_float_value"), &SpineEventData::get_float_value);
ClassDB::bind_method(D_METHOD("set_float_value", "v"), &SpineEventData::set_float_value); ClassDB::bind_method(D_METHOD("set_float_value", "v"), &SpineEventData::set_float_value);
ClassDB::bind_method(D_METHOD("get_string_value"), &SpineEventData::get_string_value); ClassDB::bind_method(D_METHOD("get_string_value"), &SpineEventData::get_string_value);
ClassDB::bind_method(D_METHOD("set_string_value", "v"), &SpineEventData::set_string_value); ClassDB::bind_method(D_METHOD("set_string_value", "v"), &SpineEventData::set_string_value);
ClassDB::bind_method(D_METHOD("get_volume"), &SpineEventData::get_volume); ClassDB::bind_method(D_METHOD("get_volume"), &SpineEventData::get_volume);
ClassDB::bind_method(D_METHOD("set_volume", "v"), &SpineEventData::set_volume); ClassDB::bind_method(D_METHOD("set_volume", "v"), &SpineEventData::set_volume);
ClassDB::bind_method(D_METHOD("get_balance"), &SpineEventData::get_balance); ClassDB::bind_method(D_METHOD("get_balance"), &SpineEventData::get_balance);
ClassDB::bind_method(D_METHOD("set_balance", "v"), &SpineEventData::set_balance); ClassDB::bind_method(D_METHOD("set_balance", "v"), &SpineEventData::set_balance);
} }
String SpineEventData::get_event_name() { String SpineEventData::get_event_name() {
SPINE_CHECK(get_spine_object(), "") SPINE_CHECK(get_spine_object(), "")
return get_spine_object()->getName().buffer(); return get_spine_object()->getName().buffer();
} }
int SpineEventData::get_int_value() { int SpineEventData::get_int_value() {
SPINE_CHECK(get_spine_object(), 0) SPINE_CHECK(get_spine_object(), 0)
return get_spine_object()->getIntValue(); return get_spine_object()->getIntValue();
} }
void SpineEventData::set_int_value(int v) { void SpineEventData::set_int_value(int v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setIntValue(v); get_spine_object()->setIntValue(v);
} }
float SpineEventData::get_float_value() { float SpineEventData::get_float_value() {
SPINE_CHECK(get_spine_object(), 0) SPINE_CHECK(get_spine_object(), 0)
return get_spine_object()->getFloatValue(); return get_spine_object()->getFloatValue();
} }
void SpineEventData::set_float_value(float v) { void SpineEventData::set_float_value(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setFloatValue(v); get_spine_object()->setFloatValue(v);
} }
String SpineEventData::get_string_value() { String SpineEventData::get_string_value() {
SPINE_CHECK(get_spine_object(), "") SPINE_CHECK(get_spine_object(), "")
return get_spine_object()->getStringValue().buffer(); return get_spine_object()->getStringValue().buffer();
} }
void SpineEventData::set_string_value(const String &v) { void SpineEventData::set_string_value(const String &v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setStringValue(spine::String(v.utf8())); get_spine_object()->setStringValue(spine::String(v.utf8()));
} }
float SpineEventData::get_volume() { float SpineEventData::get_volume() {
SPINE_CHECK(get_spine_object(), 0) SPINE_CHECK(get_spine_object(), 0)
return get_spine_object()->getVolume(); return get_spine_object()->getVolume();
} }
void SpineEventData::set_volume(float v) { void SpineEventData::set_volume(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setVolume(v); get_spine_object()->setVolume(v);
} }
float SpineEventData::get_balance() { float SpineEventData::get_balance() {
SPINE_CHECK(get_spine_object(), 0) SPINE_CHECK(get_spine_object(), 0)
return get_spine_object()->getBalance(); return get_spine_object()->getBalance();
} }
void SpineEventData::set_balance(float v) { void SpineEventData::set_balance(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setBalance(v); get_spine_object()->setBalance(v);
} }

18
spine-godot/spine_godot/SpineIkConstraint.cpp
View File

@ -54,7 +54,7 @@ void SpineIkConstraint::_bind_methods() {
} }
void SpineIkConstraint::update() { void SpineIkConstraint::update() {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->update(); get_spine_object()->update();
} }
@ -75,7 +75,7 @@ Array SpineIkConstraint::get_bones() {
Array result; Array result;
SPINE_CHECK(get_spine_object(), result) SPINE_CHECK(get_spine_object(), result)
auto &bones = get_spine_object()->getBones(); auto &bones = get_spine_object()->getBones();
result.resize((int)bones.size()); result.resize((int) bones.size());
for (int i = 0; i < bones.size(); ++i) { for (int i = 0; i < bones.size(); ++i) {
auto bone = bones[i]; auto bone = bones[i];
Ref<SpineBone> bone_ref(memnew(SpineBone)); Ref<SpineBone> bone_ref(memnew(SpineBone));
@ -95,7 +95,7 @@ Ref<SpineBone> SpineIkConstraint::get_target() {
} }
void SpineIkConstraint::set_target(Ref<SpineBone> v) { void SpineIkConstraint::set_target(Ref<SpineBone> v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setTarget(v.is_valid() && v->get_spine_object() ? v->get_spine_object() : nullptr); get_spine_object()->setTarget(v.is_valid() && v->get_spine_object() ? v->get_spine_object() : nullptr);
} }
@ -105,7 +105,7 @@ int SpineIkConstraint::get_bend_direction() {
} }
void SpineIkConstraint::set_bend_direction(int v) { void SpineIkConstraint::set_bend_direction(int v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setBendDirection(v); get_spine_object()->setBendDirection(v);
} }
@ -115,7 +115,7 @@ bool SpineIkConstraint::get_compress() {
} }
void SpineIkConstraint::set_compress(bool v) { void SpineIkConstraint::set_compress(bool v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setCompress(v); get_spine_object()->setCompress(v);
} }
@ -125,7 +125,7 @@ bool SpineIkConstraint::get_stretch() {
} }
void SpineIkConstraint::set_stretch(bool v) { void SpineIkConstraint::set_stretch(bool v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setStretch(v); get_spine_object()->setStretch(v);
} }
@ -134,7 +134,7 @@ float SpineIkConstraint::get_mix() {
return get_spine_object()->getMix(); return get_spine_object()->getMix();
} }
void SpineIkConstraint::set_mix(float v) { void SpineIkConstraint::set_mix(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setMix(v); get_spine_object()->setMix(v);
} }
@ -144,7 +144,7 @@ float SpineIkConstraint::get_softness() {
} }
void SpineIkConstraint::set_softness(float v) { void SpineIkConstraint::set_softness(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setSoftness(v); get_spine_object()->setSoftness(v);
} }
@ -154,6 +154,6 @@ bool SpineIkConstraint::is_active() {
} }
void SpineIkConstraint::set_active(bool v) { void SpineIkConstraint::set_active(bool v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setActive(v); get_spine_object()->setActive(v);
} }

16
spine-godot/spine_godot/SpineIkConstraintData.cpp
View File

@ -52,7 +52,7 @@ Array SpineIkConstraintData::get_bones() {
Array result; Array result;
SPINE_CHECK(get_spine_object(), result) SPINE_CHECK(get_spine_object(), result)
auto bones = get_spine_constraint_data()->getBones(); auto bones = get_spine_constraint_data()->getBones();
result.resize((int)bones.size()); result.resize((int) bones.size());
for (int i = 0; i < bones.size(); ++i) { for (int i = 0; i < bones.size(); ++i) {
Ref<SpineBoneData> bone_ref(memnew(SpineBoneData)); Ref<SpineBoneData> bone_ref(memnew(SpineBoneData));
bone_ref->set_spine_object(get_spine_owner(), bones[i]); bone_ref->set_spine_object(get_spine_owner(), bones[i]);
@ -71,7 +71,7 @@ Ref<SpineBoneData> SpineIkConstraintData::get_target() {
} }
void SpineIkConstraintData::set_target(Ref<SpineBoneData> v) { void SpineIkConstraintData::set_target(Ref<SpineBoneData> v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_constraint_data()->setTarget(v.is_valid() && v->get_spine_object() ? v->get_spine_object() : nullptr); get_spine_constraint_data()->setTarget(v.is_valid() && v->get_spine_object() ? v->get_spine_object() : nullptr);
} }
@ -81,7 +81,7 @@ int SpineIkConstraintData::get_bend_direction() {
} }
void SpineIkConstraintData::set_bend_direction(int v) { void SpineIkConstraintData::set_bend_direction(int v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_constraint_data()->setBendDirection(v); get_spine_constraint_data()->setBendDirection(v);
} }
@ -91,7 +91,7 @@ bool SpineIkConstraintData::get_compress() {
} }
void SpineIkConstraintData::set_compress(bool v) { void SpineIkConstraintData::set_compress(bool v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_constraint_data()->setCompress(v); get_spine_constraint_data()->setCompress(v);
} }
@ -101,7 +101,7 @@ bool SpineIkConstraintData::get_stretch() {
} }
void SpineIkConstraintData::set_stretch(bool v) { void SpineIkConstraintData::set_stretch(bool v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_constraint_data()->setStretch(v); get_spine_constraint_data()->setStretch(v);
} }
@ -111,7 +111,7 @@ bool SpineIkConstraintData::get_uniform() {
} }
void SpineIkConstraintData::set_uniform(bool v) { void SpineIkConstraintData::set_uniform(bool v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_constraint_data()->setUniform(v); get_spine_constraint_data()->setUniform(v);
} }
@ -121,7 +121,7 @@ float SpineIkConstraintData::get_mix() {
} }
void SpineIkConstraintData::set_mix(float v) { void SpineIkConstraintData::set_mix(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_constraint_data()->setMix(v); get_spine_constraint_data()->setMix(v);
} }
@ -131,6 +131,6 @@ float SpineIkConstraintData::get_softness() {
} }
void SpineIkConstraintData::set_softness(float v) { void SpineIkConstraintData::set_softness(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_constraint_data()->setSoftness(v); get_spine_constraint_data()->setSoftness(v);
} }

2
spine-godot/spine_godot/SpineIkConstraintData.h
View File

@ -36,7 +36,7 @@
class SpineIkConstraintData : public SpineConstraintData { class SpineIkConstraintData : public SpineConstraintData {
GDCLASS(SpineIkConstraintData, SpineConstraintData) GDCLASS(SpineIkConstraintData, SpineConstraintData)
spine::IkConstraintData *get_spine_constraint_data() { return (spine::IkConstraintData *)get_spine_object(); } spine::IkConstraintData *get_spine_constraint_data() { return (spine::IkConstraintData *) get_spine_object(); }
protected: protected:
static void _bind_methods(); static void _bind_methods();

18
spine-godot/spine_godot/SpinePathConstraint.cpp
View File

@ -54,7 +54,7 @@ void SpinePathConstraint::_bind_methods() {
} }
void SpinePathConstraint::update() { void SpinePathConstraint::update() {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->update(); get_spine_object()->update();
} }
@ -69,7 +69,7 @@ float SpinePathConstraint::get_position() {
} }
void SpinePathConstraint::set_position(float v) { void SpinePathConstraint::set_position(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setPosition(v); get_spine_object()->setPosition(v);
} }
@ -79,7 +79,7 @@ float SpinePathConstraint::get_spacing() {
} }
void SpinePathConstraint::set_spacing(float v) { void SpinePathConstraint::set_spacing(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setSpacing(v); get_spine_object()->setSpacing(v);
} }
@ -89,7 +89,7 @@ float SpinePathConstraint::get_mix_rotate() {
} }
void SpinePathConstraint::set_mix_rotate(float v) { void SpinePathConstraint::set_mix_rotate(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setMixRotate(v); get_spine_object()->setMixRotate(v);
} }
@ -99,7 +99,7 @@ float SpinePathConstraint::get_mix_x() {
} }
void SpinePathConstraint::set_mix_x(float v) { void SpinePathConstraint::set_mix_x(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setMixX(v); get_spine_object()->setMixX(v);
} }
@ -109,7 +109,7 @@ float SpinePathConstraint::get_mix_y() {
} }
void SpinePathConstraint::set_mix_y(float v) { void SpinePathConstraint::set_mix_y(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setMixY(v); get_spine_object()->setMixY(v);
} }
@ -117,7 +117,7 @@ Array SpinePathConstraint::get_bones() {
Array result; Array result;
SPINE_CHECK(get_spine_object(), result) SPINE_CHECK(get_spine_object(), result)
auto &bones = get_spine_object()->getBones(); auto &bones = get_spine_object()->getBones();
result.resize((int)bones.size()); result.resize((int) bones.size());
for (int i = 0; i < bones.size(); ++i) { for (int i = 0; i < bones.size(); ++i) {
auto bone = bones[i]; auto bone = bones[i];
Ref<SpineBone> bone_ref(memnew(SpineBone)); Ref<SpineBone> bone_ref(memnew(SpineBone));
@ -137,7 +137,7 @@ Ref<SpineSlot> SpinePathConstraint::get_target() {
} }
void SpinePathConstraint::set_target(Ref<SpineSlot> v) { void SpinePathConstraint::set_target(Ref<SpineSlot> v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setTarget(v.is_valid() && v->get_spine_object() ? v->get_spine_object() : nullptr); get_spine_object()->setTarget(v.is_valid() && v->get_spine_object() ? v->get_spine_object() : nullptr);
} }
@ -155,6 +155,6 @@ bool SpinePathConstraint::is_active() {
} }
void SpinePathConstraint::set_active(bool v) { void SpinePathConstraint::set_active(bool v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setActive(v); get_spine_object()->setActive(v);
} }

32
spine-godot/spine_godot/SpinePathConstraintData.cpp
View File

@ -59,7 +59,7 @@ Array SpinePathConstraintData::get_bones() {
Array result; Array result;
SPINE_CHECK(get_spine_constraint_data(), result) SPINE_CHECK(get_spine_constraint_data(), result)
auto bones = get_spine_constraint_data()->getBones(); auto bones = get_spine_constraint_data()->getBones();
result.resize((int)bones.size()); result.resize((int) bones.size());
for (int i = 0; i < bones.size(); ++i) { for (int i = 0; i < bones.size(); ++i) {
Ref<SpineBoneData> bone_ref(memnew(SpineBoneData)); Ref<SpineBoneData> bone_ref(memnew(SpineBoneData));
bone_ref->set_spine_object(get_spine_owner(), bones[i]); bone_ref->set_spine_object(get_spine_owner(), bones[i]);
@ -78,8 +78,8 @@ Ref<SpineSlotData> SpinePathConstraintData::get_target() {
} }
void SpinePathConstraintData::set_target(Ref<SpineSlotData> v) { void SpinePathConstraintData::set_target(Ref<SpineSlotData> v) {
SPINE_CHECK(get_spine_constraint_data(),) SPINE_CHECK(get_spine_constraint_data(), )
get_spine_constraint_data()->setTarget(v.is_valid() && v->get_spine_object()? v->get_spine_object() : nullptr); get_spine_constraint_data()->setTarget(v.is_valid() && v->get_spine_object() ? v->get_spine_object() : nullptr);
} }
SpineConstant::PositionMode SpinePathConstraintData::get_position_mode() { SpineConstant::PositionMode SpinePathConstraintData::get_position_mode() {
@ -88,27 +88,27 @@ SpineConstant::PositionMode SpinePathConstraintData::get_position_mode() {
} }
void SpinePathConstraintData::set_position_mode(SpineConstant::PositionMode v) { void SpinePathConstraintData::set_position_mode(SpineConstant::PositionMode v) {
SPINE_CHECK(get_spine_constraint_data(),) SPINE_CHECK(get_spine_constraint_data(), )
get_spine_constraint_data()->setPositionMode((spine::PositionMode)v); get_spine_constraint_data()->setPositionMode((spine::PositionMode) v);
} }
SpineConstant::SpacingMode SpinePathConstraintData::get_spacing_mode() { SpineConstant::SpacingMode SpinePathConstraintData::get_spacing_mode() {
SPINE_CHECK(get_spine_constraint_data(),SpineConstant::SpacingMode_Fixed) SPINE_CHECK(get_spine_constraint_data(), SpineConstant::SpacingMode_Fixed)
return (SpineConstant::SpacingMode) get_spine_constraint_data()->getSpacingMode(); return (SpineConstant::SpacingMode) get_spine_constraint_data()->getSpacingMode();
} }
void SpinePathConstraintData::set_spacing_mode(SpineConstant::SpacingMode v) { void SpinePathConstraintData::set_spacing_mode(SpineConstant::SpacingMode v) {
SPINE_CHECK(get_spine_constraint_data(),) SPINE_CHECK(get_spine_constraint_data(), )
get_spine_constraint_data()->setSpacingMode((spine::SpacingMode) v); get_spine_constraint_data()->setSpacingMode((spine::SpacingMode) v);
} }
SpineConstant::RotateMode SpinePathConstraintData::get_rotate_mode() { SpineConstant::RotateMode SpinePathConstraintData::get_rotate_mode() {
SPINE_CHECK(get_spine_constraint_data(),SpineConstant::RotateMode_Tangent) SPINE_CHECK(get_spine_constraint_data(), SpineConstant::RotateMode_Tangent)
return (SpineConstant::RotateMode)get_spine_constraint_data()->getRotateMode(); return (SpineConstant::RotateMode) get_spine_constraint_data()->getRotateMode();
} }
void SpinePathConstraintData::set_rotate_mode(SpineConstant::RotateMode v) { void SpinePathConstraintData::set_rotate_mode(SpineConstant::RotateMode v) {
SPINE_CHECK(get_spine_constraint_data(),) SPINE_CHECK(get_spine_constraint_data(), )
get_spine_constraint_data()->setRotateMode((spine::RotateMode) v); get_spine_constraint_data()->setRotateMode((spine::RotateMode) v);
} }
@ -118,7 +118,7 @@ float SpinePathConstraintData::get_offset_rotation() {
} }
void SpinePathConstraintData::set_offset_rotation(float v) { void SpinePathConstraintData::set_offset_rotation(float v) {
SPINE_CHECK(get_spine_constraint_data(),) SPINE_CHECK(get_spine_constraint_data(), )
get_spine_constraint_data()->setOffsetRotation(v); get_spine_constraint_data()->setOffsetRotation(v);
} }
@ -128,7 +128,7 @@ float SpinePathConstraintData::get_position() {
} }
void SpinePathConstraintData::set_position(float v) { void SpinePathConstraintData::set_position(float v) {
SPINE_CHECK(get_spine_constraint_data(),) SPINE_CHECK(get_spine_constraint_data(), )
get_spine_constraint_data()->setPosition(v); get_spine_constraint_data()->setPosition(v);
} }
@ -138,7 +138,7 @@ float SpinePathConstraintData::get_spacing() {
} }
void SpinePathConstraintData::set_spacing(float v) { void SpinePathConstraintData::set_spacing(float v) {
SPINE_CHECK(get_spine_constraint_data(),) SPINE_CHECK(get_spine_constraint_data(), )
get_spine_constraint_data()->setSpacing(v); get_spine_constraint_data()->setSpacing(v);
} }
@ -148,7 +148,7 @@ float SpinePathConstraintData::get_mix_rotate() {
} }
void SpinePathConstraintData::set_mix_rotate(float v) { void SpinePathConstraintData::set_mix_rotate(float v) {
SPINE_CHECK(get_spine_constraint_data(),) SPINE_CHECK(get_spine_constraint_data(), )
get_spine_constraint_data()->setMixRotate(v); get_spine_constraint_data()->setMixRotate(v);
} }
@ -158,7 +158,7 @@ float SpinePathConstraintData::get_mix_x() {
} }
void SpinePathConstraintData::set_mix_x(float v) { void SpinePathConstraintData::set_mix_x(float v) {
SPINE_CHECK(get_spine_constraint_data(),) SPINE_CHECK(get_spine_constraint_data(), )
get_spine_constraint_data()->setMixX(v); get_spine_constraint_data()->setMixX(v);
} }
@ -168,6 +168,6 @@ float SpinePathConstraintData::get_mix_y() {
} }
void SpinePathConstraintData::set_mix_y(float v) { void SpinePathConstraintData::set_mix_y(float v) {
SPINE_CHECK(get_spine_constraint_data(),) SPINE_CHECK(get_spine_constraint_data(), )
get_spine_constraint_data()->setMixY(v); get_spine_constraint_data()->setMixY(v);
} }

2
spine-godot/spine_godot/SpinePathConstraintData.h
View File

@ -38,7 +38,7 @@
class SpinePathConstraintData : public SpineConstraintData { class SpinePathConstraintData : public SpineConstraintData {
GDCLASS(SpinePathConstraintData, SpineConstraintData) GDCLASS(SpinePathConstraintData, SpineConstraintData)
spine::PathConstraintData *get_spine_constraint_data() { return (spine::PathConstraintData *)get_spine_object(); } spine::PathConstraintData *get_spine_constraint_data() { return (spine::PathConstraintData *) get_spine_object(); }
protected: protected:
static void _bind_methods(); static void _bind_methods();

38
spine-godot/spine_godot/SpineSkeleton.cpp
View File

@ -90,22 +90,22 @@ Ref<SpineSkeletonDataResource> SpineSkeleton::get_skeleton_data_res() const {
} }
void SpineSkeleton::update_world_transform() { void SpineSkeleton::update_world_transform() {
SPINE_CHECK(skeleton,) SPINE_CHECK(skeleton, )
skeleton->updateWorldTransform(); skeleton->updateWorldTransform();
} }
void SpineSkeleton::set_to_setup_pose() { void SpineSkeleton::set_to_setup_pose() {
SPINE_CHECK(skeleton,) SPINE_CHECK(skeleton, )
skeleton->setToSetupPose(); skeleton->setToSetupPose();
} }
void SpineSkeleton::set_bones_to_setup_pose() { void SpineSkeleton::set_bones_to_setup_pose() {
SPINE_CHECK(skeleton,) SPINE_CHECK(skeleton, )
skeleton->setBonesToSetupPose(); skeleton->setBonesToSetupPose();
} }
void SpineSkeleton::set_slots_to_setup_pose() { void SpineSkeleton::set_slots_to_setup_pose() {
SPINE_CHECK(skeleton,) SPINE_CHECK(skeleton, )
skeleton->setSlotsToSetupPose(); skeleton->setSlotsToSetupPose();
} }
@ -130,12 +130,12 @@ Ref<SpineSlot> SpineSkeleton::find_slot(const String &name) {
} }
void SpineSkeleton::set_skin_by_name(const String &skin_name) { void SpineSkeleton::set_skin_by_name(const String &skin_name) {
SPINE_CHECK(skeleton,) SPINE_CHECK(skeleton, )
skeleton->setSkin(SPINE_STRING(skin_name)); skeleton->setSkin(SPINE_STRING(skin_name));
} }
void SpineSkeleton::set_skin(Ref<SpineSkin> new_skin) { void SpineSkeleton::set_skin(Ref<SpineSkin> new_skin) {
SPINE_CHECK(skeleton,) SPINE_CHECK(skeleton, )
skeleton->setSkin(new_skin.is_valid() && new_skin->get_spine_object() ? new_skin->get_spine_object() : nullptr); skeleton->setSkin(new_skin.is_valid() && new_skin->get_spine_object() ? new_skin->get_spine_object() : nullptr);
} }
@ -158,7 +158,7 @@ Ref<SpineAttachment> SpineSkeleton::get_attachment_by_slot_index(int slot_index,
} }
void SpineSkeleton::set_attachment(const String &slot_name, const String &attachment_name) { void SpineSkeleton::set_attachment(const String &slot_name, const String &attachment_name) {
SPINE_CHECK(skeleton,) SPINE_CHECK(skeleton, )
skeleton->setAttachment(SPINE_STRING(slot_name), SPINE_STRING(attachment_name)); skeleton->setAttachment(SPINE_STRING(slot_name), SPINE_STRING(attachment_name));
} }
@ -212,7 +212,7 @@ Array SpineSkeleton::get_bones() {
Array result; Array result;
SPINE_CHECK(skeleton, result) SPINE_CHECK(skeleton, result)
auto &bones = skeleton->getBones(); auto &bones = skeleton->getBones();
result.resize((int)bones.size()); result.resize((int) bones.size());
for (int i = 0; i < result.size(); ++i) { for (int i = 0; i < result.size(); ++i) {
auto bone = bones[i]; auto bone = bones[i];
Ref<SpineBone> bone_ref(memnew(SpineBone)); Ref<SpineBone> bone_ref(memnew(SpineBone));
@ -226,7 +226,7 @@ Array SpineSkeleton::get_slots() {
Array result; Array result;
SPINE_CHECK(skeleton, result) SPINE_CHECK(skeleton, result)
auto &slots = skeleton->getSlots(); auto &slots = skeleton->getSlots();
result.resize((int)slots.size()); result.resize((int) slots.size());
for (int i = 0; i < result.size(); ++i) { for (int i = 0; i < result.size(); ++i) {
auto slot = slots[i]; auto slot = slots[i];
Ref<SpineSlot> slot_ref(memnew(SpineSlot)); Ref<SpineSlot> slot_ref(memnew(SpineSlot));
@ -240,7 +240,7 @@ Array SpineSkeleton::get_draw_order() {
Array result; Array result;
SPINE_CHECK(skeleton, result) SPINE_CHECK(skeleton, result)
auto &slots = skeleton->getDrawOrder(); auto &slots = skeleton->getDrawOrder();
result.resize((int)slots.size()); result.resize((int) slots.size());
for (int i = 0; i < result.size(); ++i) { for (int i = 0; i < result.size(); ++i) {
auto slot = slots[i]; auto slot = slots[i];
Ref<SpineSlot> slot_ref(memnew(SpineSlot)); Ref<SpineSlot> slot_ref(memnew(SpineSlot));
@ -254,7 +254,7 @@ Array SpineSkeleton::get_ik_constraints() {
Array result; Array result;
SPINE_CHECK(skeleton, result) SPINE_CHECK(skeleton, result)
auto &constraints = skeleton->getIkConstraints(); auto &constraints = skeleton->getIkConstraints();
result.resize((int)constraints.size()); result.resize((int) constraints.size());
for (int i = 0; i < result.size(); ++i) { for (int i = 0; i < result.size(); ++i) {
auto constraint = constraints[i]; auto constraint = constraints[i];
Ref<SpineIkConstraint> constraint_ref(memnew(SpineIkConstraint)); Ref<SpineIkConstraint> constraint_ref(memnew(SpineIkConstraint));
@ -268,7 +268,7 @@ Array SpineSkeleton::get_path_constraints() {
Array result; Array result;
SPINE_CHECK(skeleton, result) SPINE_CHECK(skeleton, result)
auto &constraints = skeleton->getPathConstraints(); auto &constraints = skeleton->getPathConstraints();
result.resize((int)constraints.size()); result.resize((int) constraints.size());
for (int i = 0; i < result.size(); ++i) { for (int i = 0; i < result.size(); ++i) {
auto constraint = constraints[i]; auto constraint = constraints[i];
Ref<SpinePathConstraint> constraint_ref(memnew(SpinePathConstraint)); Ref<SpinePathConstraint> constraint_ref(memnew(SpinePathConstraint));
@ -281,7 +281,7 @@ Array SpineSkeleton::get_transform_constraints() {
Array result; Array result;
SPINE_CHECK(skeleton, result) SPINE_CHECK(skeleton, result)
auto &constraints = skeleton->getTransformConstraints(); auto &constraints = skeleton->getTransformConstraints();
result.resize((int)constraints.size()); result.resize((int) constraints.size());
for (int i = 0; i < result.size(); ++i) { for (int i = 0; i < result.size(); ++i) {
auto constraint = constraints[i]; auto constraint = constraints[i];
Ref<SpineTransformConstraint> constraint_ref(memnew(SpineTransformConstraint)); Ref<SpineTransformConstraint> constraint_ref(memnew(SpineTransformConstraint));
@ -307,13 +307,13 @@ Color SpineSkeleton::get_color() {
} }
void SpineSkeleton::set_color(Color v) { void SpineSkeleton::set_color(Color v) {
SPINE_CHECK(skeleton,) SPINE_CHECK(skeleton, )
auto &color = skeleton->getColor(); auto &color = skeleton->getColor();
color.set(v.r, v.g, v.b, v.a); color.set(v.r, v.g, v.b, v.a);
} }
void SpineSkeleton::set_position(Vector2 position) { void SpineSkeleton::set_position(Vector2 position) {
SPINE_CHECK(skeleton,) SPINE_CHECK(skeleton, )
skeleton->setPosition(position.x, position.y); skeleton->setPosition(position.x, position.y);
} }
@ -323,7 +323,7 @@ float SpineSkeleton::get_x() {
} }
void SpineSkeleton::set_x(float v) { void SpineSkeleton::set_x(float v) {
SPINE_CHECK(skeleton,) SPINE_CHECK(skeleton, )
skeleton->setX(v); skeleton->setX(v);
} }
@ -333,7 +333,7 @@ float SpineSkeleton::get_y() {
} }
void SpineSkeleton::set_y(float v) { void SpineSkeleton::set_y(float v) {
SPINE_CHECK(skeleton,) SPINE_CHECK(skeleton, )
skeleton->setY(v); skeleton->setY(v);
} }
@ -343,7 +343,7 @@ float SpineSkeleton::get_scale_x() {
} }
void SpineSkeleton::set_scale_x(float v) { void SpineSkeleton::set_scale_x(float v) {
SPINE_CHECK(skeleton,) SPINE_CHECK(skeleton, )
skeleton->setScaleX(v); skeleton->setScaleX(v);
} }
@ -353,6 +353,6 @@ float SpineSkeleton::get_scale_y() {
} }
void SpineSkeleton::set_scale_y(float v) { void SpineSkeleton::set_scale_y(float v) {
SPINE_CHECK(skeleton,) SPINE_CHECK(skeleton, )
skeleton->setScaleY(v); skeleton->setScaleY(v);
} }

30
spine-godot/spine_godot/SpineSkeletonDataResource.cpp
View File

@ -48,7 +48,7 @@ void SpineAnimationMix::_bind_methods() {
#endif #endif
} }
SpineAnimationMix::SpineAnimationMix(): from(""), to(""), mix(0) { SpineAnimationMix::SpineAnimationMix() : from(""), to(""), mix(0) {
} }
void SpineAnimationMix::set_from(const StringName &_from) { void SpineAnimationMix::set_from(const StringName &_from) {
@ -226,7 +226,7 @@ void SpineSkeletonDataResource::get_skin_names(Vector<String> &skin_names) const
} }
} }
void SpineSkeletonDataResource::get_slot_names(Vector<String>& slot_names) { void SpineSkeletonDataResource::get_slot_names(Vector<String> &slot_names) {
slot_names.clear(); slot_names.clear();
if (!is_skeleton_data_loaded()) return; if (!is_skeleton_data_loaded()) return;
auto slots = skeleton_data->getSlots(); auto slots = skeleton_data->getSlots();
@ -236,7 +236,7 @@ void SpineSkeletonDataResource::get_slot_names(Vector<String>& slot_names) {
} }
} }
void SpineSkeletonDataResource::get_bone_names(Vector<String>& bone_names) { void SpineSkeletonDataResource::get_bone_names(Vector<String> &bone_names) {
bone_names.clear(); bone_names.clear();
if (!is_skeleton_data_loaded()) return; if (!is_skeleton_data_loaded()) return;
auto bones = skeleton_data->getBones(); auto bones = skeleton_data->getBones();
@ -371,7 +371,7 @@ Ref<SpinePathConstraintData> SpineSkeletonDataResource::find_path_constraint(con
return constraint_ref; return constraint_ref;
} }
String SpineSkeletonDataResource::get_skeleton_name() const{ String SpineSkeletonDataResource::get_skeleton_name() const {
SPINE_CHECK(skeleton_data, "") SPINE_CHECK(skeleton_data, "")
return skeleton_data->getName().buffer(); return skeleton_data->getName().buffer();
} }
@ -380,7 +380,7 @@ Array SpineSkeletonDataResource::get_bones() const {
Array result; Array result;
SPINE_CHECK(skeleton_data, result) SPINE_CHECK(skeleton_data, result)
auto bones = skeleton_data->getBones(); auto bones = skeleton_data->getBones();
result.resize((int)bones.size()); result.resize((int) bones.size());
for (int i = 0; i < bones.size(); ++i) { for (int i = 0; i < bones.size(); ++i) {
Ref<SpineBoneData> bone_ref(memnew(SpineBoneData)); Ref<SpineBoneData> bone_ref(memnew(SpineBoneData));
bone_ref->set_spine_object(this, bones[i]); bone_ref->set_spine_object(this, bones[i]);
@ -393,7 +393,7 @@ Array SpineSkeletonDataResource::get_slots() const {
Array result; Array result;
SPINE_CHECK(skeleton_data, result) SPINE_CHECK(skeleton_data, result)
auto slots = skeleton_data->getSlots(); auto slots = skeleton_data->getSlots();
result.resize((int)slots.size()); result.resize((int) slots.size());
for (int i = 0; i < slots.size(); ++i) { for (int i = 0; i < slots.size(); ++i) {
Ref<SpineSlotData> slot_ref(memnew(SpineSlotData)); Ref<SpineSlotData> slot_ref(memnew(SpineSlotData));
slot_ref->set_spine_object(this, slots[i]); slot_ref->set_spine_object(this, slots[i]);
@ -406,7 +406,7 @@ Array SpineSkeletonDataResource::get_skins() const {
Array result; Array result;
SPINE_CHECK(skeleton_data, result) SPINE_CHECK(skeleton_data, result)
auto skins = skeleton_data->getSkins(); auto skins = skeleton_data->getSkins();
result.resize((int)skins.size()); result.resize((int) skins.size());
for (int i = 0; i < skins.size(); ++i) { for (int i = 0; i < skins.size(); ++i) {
Ref<SpineSkin> skin_ref(memnew(SpineSkin)); Ref<SpineSkin> skin_ref(memnew(SpineSkin));
skin_ref->set_spine_object(this, skins[i]); skin_ref->set_spine_object(this, skins[i]);
@ -425,7 +425,7 @@ Ref<SpineSkin> SpineSkeletonDataResource::get_default_skin() const {
} }
void SpineSkeletonDataResource::set_default_skin(Ref<SpineSkin> skin) { void SpineSkeletonDataResource::set_default_skin(Ref<SpineSkin> skin) {
SPINE_CHECK(skeleton_data,) SPINE_CHECK(skeleton_data, )
skeleton_data->setDefaultSkin(skin.is_valid() && skin->get_spine_object() ? skin->get_spine_object() : nullptr); skeleton_data->setDefaultSkin(skin.is_valid() && skin->get_spine_object() ? skin->get_spine_object() : nullptr);
} }
@ -433,7 +433,7 @@ Array SpineSkeletonDataResource::get_events() const {
Array result; Array result;
SPINE_CHECK(skeleton_data, result) SPINE_CHECK(skeleton_data, result)
auto events = skeleton_data->getEvents(); auto events = skeleton_data->getEvents();
result.resize((int)events.size()); result.resize((int) events.size());
for (int i = 0; i < events.size(); ++i) { for (int i = 0; i < events.size(); ++i) {
Ref<SpineEventData> event_ref(memnew(SpineEventData)); Ref<SpineEventData> event_ref(memnew(SpineEventData));
event_ref->set_spine_object(this, events[i]); event_ref->set_spine_object(this, events[i]);
@ -446,7 +446,7 @@ Array SpineSkeletonDataResource::get_animations() const {
Array result; Array result;
SPINE_CHECK(skeleton_data, result) SPINE_CHECK(skeleton_data, result)
auto animations = skeleton_data->getAnimations(); auto animations = skeleton_data->getAnimations();
result.resize((int)animations.size()); result.resize((int) animations.size());
for (int i = 0; i < animations.size(); ++i) { for (int i = 0; i < animations.size(); ++i) {
Ref<SpineAnimation> animation_ref(memnew(SpineAnimation)); Ref<SpineAnimation> animation_ref(memnew(SpineAnimation));
animation_ref->set_spine_object(this, animations[i]); animation_ref->set_spine_object(this, animations[i]);
@ -459,7 +459,7 @@ Array SpineSkeletonDataResource::get_ik_constraints() const {
Array result; Array result;
SPINE_CHECK(skeleton_data, result) SPINE_CHECK(skeleton_data, result)
auto constraints = skeleton_data->getIkConstraints(); auto constraints = skeleton_data->getIkConstraints();
result.resize((int)constraints.size()); result.resize((int) constraints.size());
for (int i = 0; i < constraints.size(); ++i) { for (int i = 0; i < constraints.size(); ++i) {
Ref<SpineIkConstraintData> constraint_ref(memnew(SpineIkConstraintData)); Ref<SpineIkConstraintData> constraint_ref(memnew(SpineIkConstraintData));
constraint_ref->set_spine_object(this, constraints[i]); constraint_ref->set_spine_object(this, constraints[i]);
@ -472,7 +472,7 @@ Array SpineSkeletonDataResource::get_transform_constraints() const {
Array result; Array result;
SPINE_CHECK(skeleton_data, result) SPINE_CHECK(skeleton_data, result)
auto constraints = skeleton_data->getTransformConstraints(); auto constraints = skeleton_data->getTransformConstraints();
result.resize((int)constraints.size()); result.resize((int) constraints.size());
for (int i = 0; i < constraints.size(); ++i) { for (int i = 0; i < constraints.size(); ++i) {
Ref<SpineTransformConstraintData> constraint_ref(memnew(SpineTransformConstraintData)); Ref<SpineTransformConstraintData> constraint_ref(memnew(SpineTransformConstraintData));
constraint_ref->set_spine_object(this, constraints[i]); constraint_ref->set_spine_object(this, constraints[i]);
@ -485,7 +485,7 @@ Array SpineSkeletonDataResource::get_path_constraints() const {
Array result; Array result;
SPINE_CHECK(skeleton_data, result) SPINE_CHECK(skeleton_data, result)
auto constraints = skeleton_data->getPathConstraints(); auto constraints = skeleton_data->getPathConstraints();
result.resize((int)constraints.size()); result.resize((int) constraints.size());
for (int i = 0; i < constraints.size(); ++i) { for (int i = 0; i < constraints.size(); ++i) {
Ref<SpinePathConstraintData> constraint_ref(memnew(SpinePathConstraintData)); Ref<SpinePathConstraintData> constraint_ref(memnew(SpinePathConstraintData));
constraint_ref->set_spine_object(this, constraints[i]); constraint_ref->set_spine_object(this, constraints[i]);
@ -494,7 +494,7 @@ Array SpineSkeletonDataResource::get_path_constraints() const {
return result; return result;
} }
float SpineSkeletonDataResource::get_x() const{ float SpineSkeletonDataResource::get_x() const {
SPINE_CHECK(skeleton_data, 0) SPINE_CHECK(skeleton_data, 0)
return skeleton_data->getX(); return skeleton_data->getX();
} }
@ -504,7 +504,7 @@ float SpineSkeletonDataResource::get_y() const {
return skeleton_data->getY(); return skeleton_data->getY();
} }
float SpineSkeletonDataResource::get_width() const{ float SpineSkeletonDataResource::get_width() const {
SPINE_CHECK(skeleton_data, 0) SPINE_CHECK(skeleton_data, 0)
return skeleton_data->getWidth(); return skeleton_data->getWidth();
} }

1
spine-godot/spine_godot/SpineSkeletonDataResource.h
View File

@ -20,6 +20,7 @@ protected:
String from; String from;
String to; String to;
float mix; float mix;
public: public:
SpineAnimationMix(); SpineAnimationMix();

20
spine-godot/spine_godot/SpineSkin.cpp
View File

@ -73,8 +73,8 @@ Ref<SpineSkin> SpineSkin::init(const String &name, SpineSprite *sprite) {
} }
void SpineSkin::set_attachment(int slot_index, const String &name, Ref<SpineAttachment> attachment) { void SpineSkin::set_attachment(int slot_index, const String &name, Ref<SpineAttachment> attachment) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setAttachment(slot_index, SPINE_STRING(name), attachment.is_valid() && attachment->get_spine_owner()? attachment->get_spine_object() : nullptr); get_spine_object()->setAttachment(slot_index, SPINE_STRING(name), attachment.is_valid() && attachment->get_spine_owner() ? attachment->get_spine_object() : nullptr);
} }
Ref<SpineAttachment> SpineSkin::get_attachment(int slot_index, const String &name) { Ref<SpineAttachment> SpineSkin::get_attachment(int slot_index, const String &name) {
@ -87,7 +87,7 @@ Ref<SpineAttachment> SpineSkin::get_attachment(int slot_index, const String &nam
} }
void SpineSkin::remove_attachment(int slot_index, const String &name) { void SpineSkin::remove_attachment(int slot_index, const String &name) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->removeAttachment(slot_index, SPINE_STRING(name)); get_spine_object()->removeAttachment(slot_index, SPINE_STRING(name));
} }
@ -96,7 +96,7 @@ Array SpineSkin::find_names_for_slot(int slot_index) {
SPINE_CHECK(get_spine_object(), result) SPINE_CHECK(get_spine_object(), result)
spine::Vector<spine::String> names; spine::Vector<spine::String> names;
get_spine_object()->findNamesForSlot(slot_index, names); get_spine_object()->findNamesForSlot(slot_index, names);
result.resize((int)names.size()); result.resize((int) names.size());
for (int i = 0; i < names.size(); ++i) { for (int i = 0; i < names.size(); ++i) {
result[i] = names[i].buffer(); result[i] = names[i].buffer();
} }
@ -108,7 +108,7 @@ Array SpineSkin::find_attachments_for_slot(int slot_index) {
SPINE_CHECK(get_spine_object(), result) SPINE_CHECK(get_spine_object(), result)
spine::Vector<spine::Attachment *> attachments; spine::Vector<spine::Attachment *> attachments;
get_spine_object()->findAttachmentsForSlot(slot_index, attachments); get_spine_object()->findAttachmentsForSlot(slot_index, attachments);
result.resize((int)attachments.size()); result.resize((int) attachments.size());
for (int i = 0; i < attachments.size(); ++i) { for (int i = 0; i < attachments.size(); ++i) {
if (!attachments[i]) { if (!attachments[i]) {
result[i] = Ref<SpineAttachment>(nullptr); result[i] = Ref<SpineAttachment>(nullptr);
@ -127,7 +127,7 @@ String SpineSkin::get_name() {
} }
void SpineSkin::add_skin(Ref<SpineSkin> other) { void SpineSkin::add_skin(Ref<SpineSkin> other) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
if (!other.is_valid() || !other->get_spine_object()) { if (!other.is_valid() || !other->get_spine_object()) {
ERR_PRINT("other is not a valid SpineSkin."); ERR_PRINT("other is not a valid SpineSkin.");
return; return;
@ -136,7 +136,7 @@ void SpineSkin::add_skin(Ref<SpineSkin> other) {
} }
void SpineSkin::copy_skin(Ref<SpineSkin> other) { void SpineSkin::copy_skin(Ref<SpineSkin> other) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
if (!other.is_valid() || !other->get_spine_object()) { if (!other.is_valid() || !other->get_spine_object()) {
ERR_PRINT("other is not a valid SpineSkin."); ERR_PRINT("other is not a valid SpineSkin.");
return; return;
@ -148,7 +148,7 @@ Array SpineSkin::get_attachments() {
Array result; Array result;
SPINE_CHECK(get_spine_object(), result) SPINE_CHECK(get_spine_object(), result)
auto entries = get_spine_object()->getAttachments(); auto entries = get_spine_object()->getAttachments();
while(entries.hasNext()) { while (entries.hasNext()) {
spine::Skin::AttachmentMap::Entry &entry = entries.next(); spine::Skin::AttachmentMap::Entry &entry = entries.next();
Ref<SpineSkinEntry> entry_ref = memnew(SpineSkinEntry); Ref<SpineSkinEntry> entry_ref = memnew(SpineSkinEntry);
Ref<SpineAttachment> attachment_ref = nullptr; Ref<SpineAttachment> attachment_ref = nullptr;
@ -166,7 +166,7 @@ Array SpineSkin::get_bones() {
Array result; Array result;
SPINE_CHECK(get_spine_object(), result) SPINE_CHECK(get_spine_object(), result)
auto bones = get_spine_object()->getBones(); auto bones = get_spine_object()->getBones();
result.resize((int)bones.size()); result.resize((int) bones.size());
for (int i = 0; i < bones.size(); ++i) { for (int i = 0; i < bones.size(); ++i) {
Ref<SpineBoneData> bone_ref(memnew(SpineBoneData)); Ref<SpineBoneData> bone_ref(memnew(SpineBoneData));
bone_ref->set_spine_object(get_spine_owner(), bones[i]); bone_ref->set_spine_object(get_spine_owner(), bones[i]);
@ -179,7 +179,7 @@ Array SpineSkin::get_constraints() {
Array result; Array result;
SPINE_CHECK(get_spine_object(), result) SPINE_CHECK(get_spine_object(), result)
auto constraints = get_spine_object()->getConstraints(); auto constraints = get_spine_object()->getConstraints();
result.resize((int)constraints.size()); result.resize((int) constraints.size());
for (int i = 0; i < constraints.size(); ++i) { for (int i = 0; i < constraints.size(); ++i) {
Ref<SpineConstraintData> constraint_ref(memnew(SpineConstraintData)); Ref<SpineConstraintData> constraint_ref(memnew(SpineConstraintData));
constraint_ref->set_spine_object(get_spine_owner(), constraints[i]); constraint_ref->set_spine_object(get_spine_owner(), constraints[i]);

3
spine-godot/spine_godot/SpineSkin.h
View File

@ -74,7 +74,7 @@ public:
}; };
class SpineSkinEntry : public REFCOUNTED { class SpineSkinEntry : public REFCOUNTED {
GDCLASS(SpineSkinEntry, REFCOUNTED); GDCLASS(SpineSkinEntry, REFCOUNTED);
friend class SpineSkin; friend class SpineSkin;
@ -86,6 +86,7 @@ protected:
this->name = _name; this->name = _name;
this->attachment = _attachment; this->attachment = _attachment;
} }
private: private:
int slot_index; int slot_index;
String name; String name;

18
spine-godot/spine_godot/SpineSlot.cpp
View File

@ -53,7 +53,7 @@ void SpineSlot::_bind_methods() {
} }
void SpineSlot::set_to_setup_pose() { void SpineSlot::set_to_setup_pose() {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setToSetupPose(); get_spine_object()->setToSetupPose();
} }
@ -80,7 +80,7 @@ Color SpineSlot::get_color() {
} }
void SpineSlot::set_color(Color v) { void SpineSlot::set_color(Color v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
auto &color = get_spine_object()->getColor(); auto &color = get_spine_object()->getColor();
color.set(v.r, v.g, v.b, v.a); color.set(v.r, v.g, v.b, v.a);
} }
@ -92,7 +92,7 @@ Color SpineSlot::get_dark_color() {
} }
void SpineSlot::set_dark_color(Color v) { void SpineSlot::set_dark_color(Color v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
auto &color = get_spine_object()->getDarkColor(); auto &color = get_spine_object()->getDarkColor();
color.set(v.r, v.g, v.b, v.a); color.set(v.r, v.g, v.b, v.a);
} }
@ -112,7 +112,7 @@ Ref<SpineAttachment> SpineSlot::get_attachment() {
} }
void SpineSlot::set_attachment(Ref<SpineAttachment> v) { void SpineSlot::set_attachment(Ref<SpineAttachment> v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setAttachment(v.is_valid() && v->get_spine_object() ? v->get_spine_object() : nullptr); get_spine_object()->setAttachment(v.is_valid() && v->get_spine_object() ? v->get_spine_object() : nullptr);
} }
@ -122,7 +122,7 @@ int SpineSlot::get_attachment_state() {
} }
void SpineSlot::set_attachment_state(int v) { void SpineSlot::set_attachment_state(int v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setAttachmentState(v); get_spine_object()->setAttachmentState(v);
} }
@ -130,15 +130,15 @@ Array SpineSlot::get_deform() {
Array result; Array result;
SPINE_CHECK(get_spine_object(), result) SPINE_CHECK(get_spine_object(), result)
auto &deform = get_spine_object()->getDeform(); auto &deform = get_spine_object()->getDeform();
result.resize((int)deform.size()); result.resize((int) deform.size());
for (int i = 0; i < (int)deform.size(); ++i) { for (int i = 0; i < (int) deform.size(); ++i) {
result[i] = deform[i]; result[i] = deform[i];
} }
return result; return result;
} }
void SpineSlot::set_deform(Array v) { void SpineSlot::set_deform(Array v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
auto &deform = get_spine_object()->getDeform(); auto &deform = get_spine_object()->getDeform();
deform.setSize(v.size(), 0); deform.setSize(v.size(), 0);
for (int i = 0; i < v.size(); ++i) { for (int i = 0; i < v.size(); ++i) {
@ -152,6 +152,6 @@ int SpineSlot::get_sequence_index() {
} }
void SpineSlot::set_sequence_index(int v) { void SpineSlot::set_sequence_index(int v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setAttachmentState(v); get_spine_object()->setAttachmentState(v);
} }

13
spine-godot/spine_godot/SpineSlotData.cpp
View File

@ -44,7 +44,6 @@ void SpineSlotData::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_attachment_name", "v"), &SpineSlotData::set_attachment_name); ClassDB::bind_method(D_METHOD("set_attachment_name", "v"), &SpineSlotData::set_attachment_name);
ClassDB::bind_method(D_METHOD("get_blend_mode"), &SpineSlotData::get_blend_mode); ClassDB::bind_method(D_METHOD("get_blend_mode"), &SpineSlotData::get_blend_mode);
ClassDB::bind_method(D_METHOD("set_blend_mode", "v"), &SpineSlotData::set_blend_mode); ClassDB::bind_method(D_METHOD("set_blend_mode", "v"), &SpineSlotData::set_blend_mode);
} }
int SpineSlotData::get_index() { int SpineSlotData::get_index() {
@ -72,7 +71,7 @@ Color SpineSlotData::get_color() {
} }
void SpineSlotData::set_color(Color v) { void SpineSlotData::set_color(Color v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
auto &color = get_spine_object()->getColor(); auto &color = get_spine_object()->getColor();
color.set(v.r, v.g, v.b, v.a); color.set(v.r, v.g, v.b, v.a);
} }
@ -84,7 +83,7 @@ Color SpineSlotData::get_dark_color() {
} }
void SpineSlotData::set_dark_color(Color v) { void SpineSlotData::set_dark_color(Color v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
auto &color = get_spine_object()->getDarkColor(); auto &color = get_spine_object()->getDarkColor();
color.set(v.r, v.g, v.b, v.a); color.set(v.r, v.g, v.b, v.a);
} }
@ -95,7 +94,7 @@ bool SpineSlotData::has_dark_color() {
} }
void SpineSlotData::set_has_dark_color(bool v) { void SpineSlotData::set_has_dark_color(bool v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setHasDarkColor(v); get_spine_object()->setHasDarkColor(v);
} }
@ -104,15 +103,15 @@ String SpineSlotData::get_attachment_name() {
return get_spine_object()->getAttachmentName().buffer(); return get_spine_object()->getAttachmentName().buffer();
} }
void SpineSlotData::set_attachment_name(const String &v) { void SpineSlotData::set_attachment_name(const String &v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setAttachmentName(SPINE_STRING(v)); get_spine_object()->setAttachmentName(SPINE_STRING(v));
} }
SpineConstant::BlendMode SpineSlotData::get_blend_mode() { SpineConstant::BlendMode SpineSlotData::get_blend_mode() {
SPINE_CHECK(get_spine_object(), SpineConstant::BlendMode_Normal) SPINE_CHECK(get_spine_object(), SpineConstant::BlendMode_Normal)
return (SpineConstant::BlendMode)get_spine_object()->getBlendMode(); return (SpineConstant::BlendMode) get_spine_object()->getBlendMode();
} }
void SpineSlotData::set_blend_mode(SpineConstant::BlendMode v) { void SpineSlotData::set_blend_mode(SpineConstant::BlendMode v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setBlendMode((spine::BlendMode) v); get_spine_object()->setBlendMode((spine::BlendMode) v);
} }

225
spine-godot/spine_godot/SpineSlotNode.cpp
View File

@ -33,173 +33,174 @@
#include "scene/main/viewport.h" #include "scene/main/viewport.h"
void SpineSlotNode::_bind_methods() { void SpineSlotNode::_bind_methods() {
ClassDB::bind_method(D_METHOD("_on_world_transforms_changed", "spine_sprite"), &SpineSlotNode::on_world_transforms_changed); ClassDB::bind_method(D_METHOD("_on_world_transforms_changed", "spine_sprite"), &SpineSlotNode::on_world_transforms_changed);
ClassDB::bind_method(D_METHOD("set_normal_material", "material"), &SpineSlotNode::set_normal_material); ClassDB::bind_method(D_METHOD("set_normal_material", "material"), &SpineSlotNode::set_normal_material);
ClassDB::bind_method(D_METHOD("get_normal_material"), &SpineSlotNode::get_normal_material); ClassDB::bind_method(D_METHOD("get_normal_material"), &SpineSlotNode::get_normal_material);
ClassDB::bind_method(D_METHOD("set_additive_material", "material"), &SpineSlotNode::set_additive_material); ClassDB::bind_method(D_METHOD("set_additive_material", "material"), &SpineSlotNode::set_additive_material);
ClassDB::bind_method(D_METHOD("get_additive_material"), &SpineSlotNode::get_additive_material); ClassDB::bind_method(D_METHOD("get_additive_material"), &SpineSlotNode::get_additive_material);
ClassDB::bind_method(D_METHOD("set_multiply_material", "material"), &SpineSlotNode::set_multiply_material); ClassDB::bind_method(D_METHOD("set_multiply_material", "material"), &SpineSlotNode::set_multiply_material);
ClassDB::bind_method(D_METHOD("get_multiply_material"), &SpineSlotNode::get_multiply_material); ClassDB::bind_method(D_METHOD("get_multiply_material"), &SpineSlotNode::get_multiply_material);
ClassDB::bind_method(D_METHOD("set_screen_material", "material"), &SpineSlotNode::set_screen_material); ClassDB::bind_method(D_METHOD("set_screen_material", "material"), &SpineSlotNode::set_screen_material);
ClassDB::bind_method(D_METHOD("get_screen_material"), &SpineSlotNode::get_screen_material); ClassDB::bind_method(D_METHOD("get_screen_material"), &SpineSlotNode::get_screen_material);
ADD_GROUP("Materials", ""); ADD_GROUP("Materials", "");
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "normal_material", PROPERTY_HINT_RESOURCE_TYPE, "Material"), "set_normal_material", "get_normal_material"); ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "normal_material", PROPERTY_HINT_RESOURCE_TYPE, "Material"), "set_normal_material", "get_normal_material");
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "additive_material", PROPERTY_HINT_RESOURCE_TYPE, "Material"), "set_additive_material", "get_additive_material"); ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "additive_material", PROPERTY_HINT_RESOURCE_TYPE, "Material"), "set_additive_material", "get_additive_material");
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "multiply_material", PROPERTY_HINT_RESOURCE_TYPE, "Material"), "set_multiply_material", "get_multiply_material"); ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "multiply_material", PROPERTY_HINT_RESOURCE_TYPE, "Material"), "set_multiply_material", "get_multiply_material");
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "screen_material", PROPERTY_HINT_RESOURCE_TYPE, "Material"), "set_screen_material", "get_screen_material"); ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "screen_material", PROPERTY_HINT_RESOURCE_TYPE, "Material"), "set_screen_material", "get_screen_material");
} }
SpineSlotNode::SpineSlotNode(): slot_index(-1) { SpineSlotNode::SpineSlotNode() : slot_index(-1) {
} }
void SpineSlotNode::_notification(int what) { void SpineSlotNode::_notification(int what) {
switch(what) { switch (what) {
case NOTIFICATION_PARENTED: { case NOTIFICATION_PARENTED: {
SpineSprite *sprite = cast_to<SpineSprite>(get_parent()); SpineSprite *sprite = cast_to<SpineSprite>(get_parent());
if (sprite) { if (sprite) {
#if VERSION_MAJOR > 3 #if VERSION_MAJOR > 3
sprite->connect("world_transforms_changed", callable_mp(this, &SpineSlotNode::on_world_transforms_changed)); sprite->connect("world_transforms_changed", callable_mp(this, &SpineSlotNode::on_world_transforms_changed));
#else #else
sprite->connect("world_transforms_changed", this, "_on_world_transforms_changed"); sprite->connect("world_transforms_changed", this, "_on_world_transforms_changed");
#endif #endif
update_transform(sprite); update_transform(sprite);
#if VERSION_MAJOR == 3 #if VERSION_MAJOR == 3
_change_notify("transform/translation"); _change_notify("transform/translation");
_change_notify("transform/rotation"); _change_notify("transform/rotation");
_change_notify("transform/scale"); _change_notify("transform/scale");
_change_notify("translation"); _change_notify("translation");
_change_notify("rotation"); _change_notify("rotation");
_change_notify("rotation_deg"); _change_notify("rotation_deg");
_change_notify("scale"); _change_notify("scale");
#endif #endif
} else { } else {
WARN_PRINT("SpineSlotNode parent is not a SpineSprite."); WARN_PRINT("SpineSlotNode parent is not a SpineSprite.");
} }
NOTIFY_PROPERTY_LIST_CHANGED(); NOTIFY_PROPERTY_LIST_CHANGED();
break; break;
} }
case NOTIFICATION_UNPARENTED: { case NOTIFICATION_UNPARENTED: {
SpineSprite *sprite = cast_to<SpineSprite>(get_parent()); SpineSprite *sprite = cast_to<SpineSprite>(get_parent());
if (sprite) { if (sprite) {
#if VERSION_MAJOR > 3 #if VERSION_MAJOR > 3
sprite->disconnect("world_transforms_changed", callable_mp(this, &SpineSlotNode::on_world_transforms_changed)); sprite->disconnect("world_transforms_changed", callable_mp(this, &SpineSlotNode::on_world_transforms_changed));
#else #else
sprite->disconnect("world_transforms_changed", this, "_on_world_transforms_changed"); sprite->disconnect("world_transforms_changed", this, "_on_world_transforms_changed");
#endif #endif
} }
break; break;
} }
default: default:
break; break;
} }
} }
void SpineSlotNode::_get_property_list(List<PropertyInfo>* list) const { void SpineSlotNode::_get_property_list(List<PropertyInfo> *list) const {
Vector<String> slot_names; Vector<String> slot_names;
SpineSprite *sprite = cast_to<SpineSprite>(get_parent()); SpineSprite *sprite = cast_to<SpineSprite>(get_parent());
if (sprite) sprite->get_skeleton_data_res()->get_slot_names(slot_names); if (sprite) sprite->get_skeleton_data_res()->get_slot_names(slot_names);
else slot_names.push_back(slot_name); else
auto element = list->front(); slot_names.push_back(slot_name);
while (element) { auto element = list->front();
auto property_info = element->get(); while (element) {
if (property_info.name == "SpineSlotNode") break; auto property_info = element->get();
element = element->next(); if (property_info.name == "SpineSlotNode") break;
} element = element->next();
PropertyInfo slot_name_property; }
slot_name_property.name = "slot_name"; PropertyInfo slot_name_property;
slot_name_property.type = Variant::STRING; slot_name_property.name = "slot_name";
slot_name_property.hint_string = String(",").join(slot_names); slot_name_property.type = Variant::STRING;
slot_name_property.hint = PROPERTY_HINT_ENUM; slot_name_property.hint_string = String(",").join(slot_names);
slot_name_property.usage = PROPERTY_USAGE_DEFAULT; slot_name_property.hint = PROPERTY_HINT_ENUM;
list->insert_after(element, slot_name_property); slot_name_property.usage = PROPERTY_USAGE_DEFAULT;
list->insert_after(element, slot_name_property);
} }
bool SpineSlotNode::_get(const StringName& property, Variant& value) const { bool SpineSlotNode::_get(const StringName &property, Variant &value) const {
if (property == "slot_name") { if (property == "slot_name") {
value = slot_name; value = slot_name;
return true; return true;
} }
return false; return false;
} }
bool SpineSlotNode::_set(const StringName& property, const Variant& value) { bool SpineSlotNode::_set(const StringName &property, const Variant &value) {
if (property == "slot_name") { if (property == "slot_name") {
slot_name = value; slot_name = value;
SpineSprite *sprite = cast_to<SpineSprite>(get_parent()); SpineSprite *sprite = cast_to<SpineSprite>(get_parent());
update_transform(sprite); update_transform(sprite);
#if VERSION_MAJOR == 3 #if VERSION_MAJOR == 3
_change_notify("transform/translation"); _change_notify("transform/translation");
_change_notify("transform/rotation"); _change_notify("transform/rotation");
_change_notify("transform/scale"); _change_notify("transform/scale");
_change_notify("translation"); _change_notify("translation");
_change_notify("rotation"); _change_notify("rotation");
_change_notify("rotation_deg"); _change_notify("rotation_deg");
_change_notify("scale"); _change_notify("scale");
#endif #endif
return true; return true;
} }
return false; return false;
} }
void SpineSlotNode::on_world_transforms_changed(const Variant& _sprite) { void SpineSlotNode::on_world_transforms_changed(const Variant &_sprite) {
SpineSprite* sprite = cast_to<SpineSprite>(_sprite.operator Object*()); SpineSprite *sprite = cast_to<SpineSprite>(_sprite.operator Object *());
update_transform(sprite); update_transform(sprite);
} }
void SpineSlotNode::update_transform(SpineSprite *sprite) { void SpineSlotNode::update_transform(SpineSprite *sprite) {
if (!is_visible_in_tree()) return; if (!is_visible_in_tree()) return;
if (!sprite) return; if (!sprite) return;
if (!sprite->get_skeleton().is_valid() || !sprite->get_skeleton()->get_spine_object()) return; if (!sprite->get_skeleton().is_valid() || !sprite->get_skeleton()->get_spine_object()) return;
auto slot = sprite->get_skeleton()->find_slot(slot_name); auto slot = sprite->get_skeleton()->find_slot(slot_name);
if (!slot.is_valid()) { if (!slot.is_valid()) {
slot_index = -1; slot_index = -1;
return; return;
} else { } else {
slot_index = slot->get_data()->get_index(); slot_index = slot->get_data()->get_index();
} }
auto bone = slot->get_bone(); auto bone = slot->get_bone();
if (!bone.is_valid()) return; if (!bone.is_valid()) return;
this->set_global_transform(bone->get_global_transform()); this->set_global_transform(bone->get_global_transform());
} }
void SpineSlotNode::set_slot_name(const String& _slot_name) { void SpineSlotNode::set_slot_name(const String &_slot_name) {
slot_name = _slot_name; slot_name = _slot_name;
} }
String SpineSlotNode::get_slot_name() { String SpineSlotNode::get_slot_name() {
return slot_name; return slot_name;
} }
Ref<Material> SpineSlotNode::get_normal_material() { Ref<Material> SpineSlotNode::get_normal_material() {
return normal_material; return normal_material;
} }
void SpineSlotNode::set_normal_material(Ref<Material> material) { void SpineSlotNode::set_normal_material(Ref<Material> material) {
normal_material = material; normal_material = material;
} }
Ref<Material> SpineSlotNode::get_additive_material() { Ref<Material> SpineSlotNode::get_additive_material() {
return additive_material; return additive_material;
} }
void SpineSlotNode::set_additive_material(Ref<Material> material) { void SpineSlotNode::set_additive_material(Ref<Material> material) {
additive_material = material; additive_material = material;
} }
Ref<Material> SpineSlotNode::get_multiply_material() { Ref<Material> SpineSlotNode::get_multiply_material() {
return multiply_material; return multiply_material;
} }
void SpineSlotNode::set_multiply_material(Ref<Material> material) { void SpineSlotNode::set_multiply_material(Ref<Material> material) {
multiply_material = material; multiply_material = material;
} }
Ref<Material> SpineSlotNode::get_screen_material() { Ref<Material> SpineSlotNode::get_screen_material() {
return screen_material; return screen_material;
} }
void SpineSlotNode::set_screen_material(Ref<Material> material) { void SpineSlotNode::set_screen_material(Ref<Material> material) {
screen_material = material; screen_material = material;
} }

55
spine-godot/spine_godot/SpineSlotNode.h
View File

@ -33,46 +33,47 @@
#include "SpineSprite.h" #include "SpineSprite.h"
#include "scene/2d/node_2d.h" #include "scene/2d/node_2d.h"
class SpineSlotNode: public Node2D { class SpineSlotNode : public Node2D {
GDCLASS(SpineSlotNode, Node2D) GDCLASS(SpineSlotNode, Node2D)
protected: protected:
String slot_name; String slot_name;
int slot_index; int slot_index;
Ref<Material> normal_material; Ref<Material> normal_material;
Ref<Material> additive_material; Ref<Material> additive_material;
Ref<Material> multiply_material; Ref<Material> multiply_material;
Ref<Material> screen_material; Ref<Material> screen_material;
static void _bind_methods();
void _notification(int what);
void _get_property_list(List<PropertyInfo> *list) const;
bool _get(const StringName &property, Variant &value) const;
bool _set(const StringName &property, const Variant &value);
void on_world_transforms_changed(const Variant &_sprite);
void update_transform(SpineSprite *sprite);
static void _bind_methods();
void _notification(int what);
void _get_property_list(List<PropertyInfo> *list) const;
bool _get(const StringName &property, Variant &value) const;
bool _set(const StringName &property, const Variant &value);
void on_world_transforms_changed(const Variant &_sprite);
void update_transform(SpineSprite *sprite);
public: public:
SpineSlotNode(); SpineSlotNode();
void set_slot_name(const String &_slot_name); void set_slot_name(const String &_slot_name);
String get_slot_name(); String get_slot_name();
int get_slot_index() { return slot_index; } int get_slot_index() { return slot_index; }
Ref<Material> get_normal_material(); Ref<Material> get_normal_material();
void set_normal_material(Ref<Material> material); void set_normal_material(Ref<Material> material);
Ref<Material> get_additive_material(); Ref<Material> get_additive_material();
void set_additive_material(Ref<Material> material); void set_additive_material(Ref<Material> material);
Ref<Material> get_multiply_material(); Ref<Material> get_multiply_material();
void set_multiply_material(Ref<Material> material); void set_multiply_material(Ref<Material> material);
Ref<Material> get_screen_material(); Ref<Material> get_screen_material();
void set_screen_material(Ref<Material> material); void set_screen_material(Ref<Material> material);
}; };

171
spine-godot/spine_godot/SpineSprite.cpp
View File

@ -105,7 +105,7 @@ void SpineSprite::_bind_methods() {
ClassDB::bind_method(D_METHOD("get_debug_clipping"), &SpineSprite::get_debug_clipping); ClassDB::bind_method(D_METHOD("get_debug_clipping"), &SpineSprite::get_debug_clipping);
ClassDB::bind_method(D_METHOD("set_debug_clipping_color", "v"), &SpineSprite::set_debug_clipping_color); ClassDB::bind_method(D_METHOD("set_debug_clipping_color", "v"), &SpineSprite::set_debug_clipping_color);
ClassDB::bind_method(D_METHOD("get_debug_clipping_color"), &SpineSprite::get_debug_clipping_color); ClassDB::bind_method(D_METHOD("get_debug_clipping_color"), &SpineSprite::get_debug_clipping_color);
ClassDB::bind_method(D_METHOD("update_skeleton", "delta"), &SpineSprite::update_skeleton); ClassDB::bind_method(D_METHOD("update_skeleton", "delta"), &SpineSprite::update_skeleton);
ClassDB::bind_method(D_METHOD("new_skin", "name"), &SpineSprite::new_skin); ClassDB::bind_method(D_METHOD("new_skin", "name"), &SpineSprite::new_skin);
@ -128,7 +128,7 @@ void SpineSprite::_bind_methods() {
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "additive_material", PROPERTY_HINT_RESOURCE_TYPE, "Material"), "set_additive_material", "get_additive_material"); ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "additive_material", PROPERTY_HINT_RESOURCE_TYPE, "Material"), "set_additive_material", "get_additive_material");
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "multiply_material", PROPERTY_HINT_RESOURCE_TYPE, "Material"), "set_multiply_material", "get_multiply_material"); ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "multiply_material", PROPERTY_HINT_RESOURCE_TYPE, "Material"), "set_multiply_material", "get_multiply_material");
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "screen_material", PROPERTY_HINT_RESOURCE_TYPE, "Material"), "set_screen_material", "get_screen_material"); ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "screen_material", PROPERTY_HINT_RESOURCE_TYPE, "Material"), "set_screen_material", "get_screen_material");
ADD_GROUP("Debug", ""); ADD_GROUP("Debug", "");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "bones"), "set_debug_bones", "get_debug_bones"); ADD_PROPERTY(PropertyInfo(Variant::BOOL, "bones"), "set_debug_bones", "get_debug_bones");
ADD_PROPERTY(PropertyInfo(Variant::COLOR, "bones_color"), "set_debug_bones_color", "get_debug_bones_color"); ADD_PROPERTY(PropertyInfo(Variant::COLOR, "bones_color"), "set_debug_bones_color", "get_debug_bones_color");
@ -196,7 +196,7 @@ SpineSprite::SpineSprite() : update_mode(SpineConstant::UpdateMode_Process), pre
debug_paths_color = Color::hex(0xff7f0077); debug_paths_color = Color::hex(0xff7f0077);
debug_clipping = false; debug_clipping = false;
debug_clipping_color = Color(0.8, 0, 0, 0.8); debug_clipping_color = Color(0.8, 0, 0, 0.8);
sprite_count++; sprite_count++;
} }
@ -258,7 +258,7 @@ void SpineSprite::on_skeleton_data_changed() {
void SpineSprite::generate_meshes_for_slots(Ref<SpineSkeleton> skeleton_ref) { void SpineSprite::generate_meshes_for_slots(Ref<SpineSkeleton> skeleton_ref) {
auto skeleton = skeleton_ref->get_spine_object(); auto skeleton = skeleton_ref->get_spine_object();
for (int i = 0, n = (int)skeleton->getSlots().size(); i < n; i++) { for (int i = 0, n = (int) skeleton->getSlots().size(); i < n; i++) {
auto mesh_instance = memnew(MeshInstance2D); auto mesh_instance = memnew(MeshInstance2D);
mesh_instance->set_position(Vector2(0, 0)); mesh_instance->set_position(Vector2(0, 0));
mesh_instance->set_material(default_materials[spine::BlendMode_Normal]); mesh_instance->set_material(default_materials[spine::BlendMode_Normal]);
@ -266,7 +266,7 @@ void SpineSprite::generate_meshes_for_slots(Ref<SpineSkeleton> skeleton_ref) {
mesh_instance->set_draw_behind_parent(true); mesh_instance->set_draw_behind_parent(true);
add_child(mesh_instance); add_child(mesh_instance);
mesh_instances.push_back(mesh_instance); mesh_instances.push_back(mesh_instance);
slot_nodes.add(spine::Vector<SpineSlotNode*>()); slot_nodes.add(spine::Vector<SpineSlotNode *>());
} }
} }
@ -280,10 +280,10 @@ void SpineSprite::remove_meshes() {
} }
void SpineSprite::sort_slot_nodes() { void SpineSprite::sort_slot_nodes() {
for (int i = 0; i < (int)slot_nodes.size(); i++) { for (int i = 0; i < (int) slot_nodes.size(); i++) {
slot_nodes[i].setSize(0, nullptr); slot_nodes[i].setSize(0, nullptr);
} }
auto draw_order = skeleton->get_spine_object()->getDrawOrder(); auto draw_order = skeleton->get_spine_object()->getDrawOrder();
for (int i = 0; i < get_child_count(); i++) { for (int i = 0; i < get_child_count(); i++) {
auto child = cast_to<Node2D>(get_child(i)); auto child = cast_to<Node2D>(get_child(i));
@ -292,17 +292,17 @@ void SpineSprite::sort_slot_nodes() {
child->set_draw_behind_parent(true); child->set_draw_behind_parent(true);
auto slot_node = Object::cast_to<SpineSlotNode>(get_child(i)); auto slot_node = Object::cast_to<SpineSlotNode>(get_child(i));
if (!slot_node) continue; if (!slot_node) continue;
if (slot_node->get_slot_index() == -1 || slot_node->get_slot_index() >= (int)draw_order.size()) { if (slot_node->get_slot_index() == -1 || slot_node->get_slot_index() >= (int) draw_order.size()) {
continue; continue;
} }
slot_nodes[slot_node->get_slot_index()].add(slot_node); slot_nodes[slot_node->get_slot_index()].add(slot_node);
} }
for (int i = 0; i < (int)draw_order.size(); i++) { for (int i = 0; i < (int) draw_order.size(); i++) {
int slot_index = draw_order[i]->getData().getIndex(); int slot_index = draw_order[i]->getData().getIndex();
int mesh_index = mesh_instances[i]->get_index(); int mesh_index = mesh_instances[i]->get_index();
spine::Vector<SpineSlotNode*> &nodes = slot_nodes[slot_index]; spine::Vector<SpineSlotNode *> &nodes = slot_nodes[slot_index];
for (int j = 0; j < (int)nodes.size(); j++) { for (int j = 0; j < (int) nodes.size(); j++) {
auto node = nodes[j]; auto node = nodes[j];
move_child(node, mesh_index + 1); move_child(node, mesh_index + 1);
} }
@ -343,13 +343,13 @@ void SpineSprite::_notification(int what) {
} }
} }
void SpineSprite::_get_property_list(List<PropertyInfo>* list) const { void SpineSprite::_get_property_list(List<PropertyInfo> *list) const {
if (!skeleton_data_res.is_valid() || !skeleton_data_res->is_skeleton_data_loaded()) return; if (!skeleton_data_res.is_valid() || !skeleton_data_res->is_skeleton_data_loaded()) return;
Vector<String> animation_names; Vector<String> animation_names;
skeleton_data_res->get_animation_names(animation_names); skeleton_data_res->get_animation_names(animation_names);
animation_names.insert(0, "-- Empty --"); animation_names.insert(0, "-- Empty --");
PropertyInfo preview_anim_property; PropertyInfo preview_anim_property;
preview_anim_property.name = "preview_animation"; preview_anim_property.name = "preview_animation";
preview_anim_property.type = Variant::STRING; preview_anim_property.type = Variant::STRING;
preview_anim_property.usage = PROPERTY_USAGE_EDITOR | PROPERTY_USAGE_STORAGE; preview_anim_property.usage = PROPERTY_USAGE_EDITOR | PROPERTY_USAGE_STORAGE;
@ -357,13 +357,13 @@ void SpineSprite::_get_property_list(List<PropertyInfo>* list) const {
preview_anim_property.hint = PROPERTY_HINT_ENUM; preview_anim_property.hint = PROPERTY_HINT_ENUM;
list->push_back(preview_anim_property); list->push_back(preview_anim_property);
PropertyInfo preview_frame_property; PropertyInfo preview_frame_property;
preview_frame_property.name = "preview_frame"; preview_frame_property.name = "preview_frame";
preview_frame_property.type = Variant::BOOL; preview_frame_property.type = Variant::BOOL;
preview_frame_property.usage = PROPERTY_USAGE_EDITOR | PROPERTY_USAGE_STORAGE; preview_frame_property.usage = PROPERTY_USAGE_EDITOR | PROPERTY_USAGE_STORAGE;
list->push_back(preview_frame_property); list->push_back(preview_frame_property);
PropertyInfo preview_time_property; PropertyInfo preview_time_property;
preview_time_property.name = "preview_time"; preview_time_property.name = "preview_time";
preview_time_property.type = VARIANT_FLOAT; preview_time_property.type = VARIANT_FLOAT;
preview_time_property.usage = PROPERTY_USAGE_EDITOR | PROPERTY_USAGE_STORAGE; preview_time_property.usage = PROPERTY_USAGE_EDITOR | PROPERTY_USAGE_STORAGE;
@ -377,7 +377,7 @@ void SpineSprite::_get_property_list(List<PropertyInfo>* list) const {
list->push_back(preview_time_property); list->push_back(preview_time_property);
} }
bool SpineSprite::_get(const StringName& property, Variant& value) const { bool SpineSprite::_get(const StringName &property, Variant &value) const {
if (property == "preview_animation") { if (property == "preview_animation") {
value = preview_animation; value = preview_animation;
return true; return true;
@ -410,7 +410,7 @@ static void update_preview_animation(SpineSprite *sprite, const String &animatio
} }
} }
bool SpineSprite::_set(const StringName& property, const Variant& value) { bool SpineSprite::_set(const StringName &property, const Variant &value) {
if (property == "preview_animation") { if (property == "preview_animation") {
preview_animation = value; preview_animation = value;
update_preview_animation(this, preview_animation, preview_frame, preview_time); update_preview_animation(this, preview_animation, preview_frame, preview_time);
@ -429,7 +429,7 @@ bool SpineSprite::_set(const StringName& property, const Variant& value) {
update_preview_animation(this, preview_animation, preview_frame, preview_time); update_preview_animation(this, preview_animation, preview_frame, preview_time);
return true; return true;
} }
return false; return false;
} }
@ -466,22 +466,22 @@ static void clear_mesh_instance(MeshInstance2D *mesh_instance) {
} }
static void add_triangles(MeshInstance2D *mesh_instance, static void add_triangles(MeshInstance2D *mesh_instance,
const Vector<Point2> &vertices, const Vector<Point2> &vertices,
const Vector<Point2> &uvs, const Vector<Point2> &uvs,
const Vector<Color> &colors, const Vector<Color> &colors,
const Vector<int> &indices, const Vector<int> &indices,
Ref<Texture> texture, Ref<Texture> texture,
Ref<Texture> normal_map) { Ref<Texture> normal_map) {
#if VERSION_MAJOR > 3 #if VERSION_MAJOR > 3
RenderingServer::get_singleton()->canvas_item_add_triangle_array(mesh_instance->get_canvas_item(), RenderingServer::get_singleton()->canvas_item_add_triangle_array(mesh_instance->get_canvas_item(),
indices, indices,
vertices, vertices,
colors, colors,
uvs, uvs,
Vector<int>(), Vector<int>(),
Vector<float>(), Vector<float>(),
texture.is_null() ? RID() : texture->get_rid(), texture.is_null() ? RID() : texture->get_rid(),
-1); -1);
#else #else
VisualServer::get_singleton()->canvas_item_add_triangle_array(mesh_instance->get_canvas_item(), VisualServer::get_singleton()->canvas_item_add_triangle_array(mesh_instance->get_canvas_item(),
indices, indices,
@ -498,7 +498,7 @@ static void add_triangles(MeshInstance2D *mesh_instance,
void SpineSprite::update_meshes(Ref<SpineSkeleton> skeleton_ref) { void SpineSprite::update_meshes(Ref<SpineSkeleton> skeleton_ref) {
spine::Skeleton *skeleton = skeleton_ref->get_spine_object(); spine::Skeleton *skeleton = skeleton_ref->get_spine_object();
for (int i = 0, n = (int)skeleton->getSlots().size(); i < n; ++i) { for (int i = 0, n = (int) skeleton->getSlots().size(); i < n; ++i) {
spine::Slot *slot = skeleton->getDrawOrder()[i]; spine::Slot *slot = skeleton->getDrawOrder()[i];
spine::Attachment *attachment = slot->getAttachment(); spine::Attachment *attachment = slot->getAttachment();
MeshInstance2D *mesh_instance = mesh_instances[i]; MeshInstance2D *mesh_instance = mesh_instances[i];
@ -524,7 +524,7 @@ void SpineSprite::update_meshes(Ref<SpineSkeleton> skeleton_ref) {
auto renderer_object = (SpineRendererObject *) ((spine::AtlasRegion *) region->getRendererObject())->page->getRendererObject(); auto renderer_object = (SpineRendererObject *) ((spine::AtlasRegion *) region->getRendererObject())->page->getRendererObject();
texture = renderer_object->texture; texture = renderer_object->texture;
normal_map = renderer_object->normal_map; normal_map = renderer_object->normal_map;
vertices->setSize(8, 0); vertices->setSize(8, 0);
region->computeWorldVertices(*slot, *vertices, 0); region->computeWorldVertices(*slot, *vertices, 0);
uvs = &region->getUVs(); uvs = &region->getUVs();
@ -540,7 +540,7 @@ void SpineSprite::update_meshes(Ref<SpineSkeleton> skeleton_ref) {
auto renderer_object = (SpineRendererObject *) ((spine::AtlasRegion *) mesh->getRendererObject())->page->getRendererObject(); auto renderer_object = (SpineRendererObject *) ((spine::AtlasRegion *) mesh->getRendererObject())->page->getRendererObject();
texture = renderer_object->texture; texture = renderer_object->texture;
normal_map = renderer_object->normal_map; normal_map = renderer_object->normal_map;
vertices->setSize(mesh->getWorldVerticesLength(), 0); vertices->setSize(mesh->getWorldVerticesLength(), 0);
mesh->computeWorldVertices(*slot, *vertices); mesh->computeWorldVertices(*slot, *vertices);
uvs = &mesh->getUVs(); uvs = &mesh->getUVs();
@ -571,19 +571,19 @@ void SpineSprite::update_meshes(Ref<SpineSkeleton> skeleton_ref) {
uvs = &skeleton_clipper->getClippedUVs(); uvs = &skeleton_clipper->getClippedUVs();
indices = &skeleton_clipper->getClippedTriangles(); indices = &skeleton_clipper->getClippedTriangles();
} }
if (indices->size() > 0) { if (indices->size() > 0) {
size_t num_vertices = vertices->size() / 2; size_t num_vertices = vertices->size() / 2;
scratch_points.resize((int)num_vertices); scratch_points.resize((int) num_vertices);
memcpy(scratch_points.ptrw(), vertices->buffer(), num_vertices * 2 * sizeof(float)); memcpy(scratch_points.ptrw(), vertices->buffer(), num_vertices * 2 * sizeof(float));
scratch_uvs.resize((int)num_vertices); scratch_uvs.resize((int) num_vertices);
memcpy(scratch_uvs.ptrw(), uvs->buffer(), num_vertices * 2 * sizeof(float)); memcpy(scratch_uvs.ptrw(), uvs->buffer(), num_vertices * 2 * sizeof(float));
scratch_colors.resize((int)num_vertices); scratch_colors.resize((int) num_vertices);
for (int j = 0; j < (int)num_vertices; j++) { for (int j = 0; j < (int) num_vertices; j++) {
scratch_colors.set(j, Color(tint.r, tint.g, tint.b, tint.a)); scratch_colors.set(j, Color(tint.r, tint.g, tint.b, tint.a));
} }
scratch_indices.resize((int)indices->size()); scratch_indices.resize((int) indices->size());
for (int j = 0; j < (int)indices->size(); ++j) { for (int j = 0; j < (int) indices->size(); ++j) {
scratch_indices.set(j, indices->buffer()[j]); scratch_indices.set(j, indices->buffer()[j]);
} }
@ -598,10 +598,18 @@ void SpineSprite::update_meshes(Ref<SpineSkeleton> skeleton_ref) {
auto slot_node = nodes[0]; auto slot_node = nodes[0];
if (slot_node) { if (slot_node) {
switch (blend_mode) { switch (blend_mode) {
case spine::BlendMode_Normal: custom_material = slot_node->get_normal_material(); break; case spine::BlendMode_Normal:
case spine::BlendMode_Additive: custom_material = slot_node->get_additive_material(); break; custom_material = slot_node->get_normal_material();
case spine::BlendMode_Multiply: custom_material = slot_node->get_multiply_material(); break; break;
case spine::BlendMode_Screen: custom_material = slot_node->get_screen_material(); break; case spine::BlendMode_Additive:
custom_material = slot_node->get_additive_material();
break;
case spine::BlendMode_Multiply:
custom_material = slot_node->get_multiply_material();
break;
case spine::BlendMode_Screen:
custom_material = slot_node->get_screen_material();
break;
} }
} }
} }
@ -609,16 +617,25 @@ void SpineSprite::update_meshes(Ref<SpineSkeleton> skeleton_ref) {
// Else, check if we have a material on the sprite itself // Else, check if we have a material on the sprite itself
if (!custom_material.is_valid()) { if (!custom_material.is_valid()) {
switch (blend_mode) { switch (blend_mode) {
case spine::BlendMode_Normal: custom_material = normal_material; break; case spine::BlendMode_Normal:
case spine::BlendMode_Additive: custom_material = additive_material; break; custom_material = normal_material;
case spine::BlendMode_Multiply: custom_material = multiply_material; break; break;
case spine::BlendMode_Screen: custom_material = screen_material; break; case spine::BlendMode_Additive:
custom_material = additive_material;
break;
case spine::BlendMode_Multiply:
custom_material = multiply_material;
break;
case spine::BlendMode_Screen:
custom_material = screen_material;
break;
} }
} }
// Set the custom material, or the default material // Set the custom material, or the default material
if (custom_material.is_valid()) mesh_instance->set_material(custom_material); if (custom_material.is_valid()) mesh_instance->set_material(custom_material);
else mesh_instance->set_material(default_materials[slot->getData().getBlendMode()]); else
mesh_instance->set_material(default_materials[slot->getData().getBlendMode()]);
} }
skeleton_clipper->clipEnd(*slot); skeleton_clipper->clipEnd(*slot);
} }
@ -631,17 +648,17 @@ void SpineSprite::draw() {
auto mouse_position = get_local_mouse_position(); auto mouse_position = get_local_mouse_position();
spine::Slot *hovered_slot = nullptr; spine::Slot *hovered_slot = nullptr;
if (debug_regions) { if (debug_regions) {
draw_set_transform(Vector2(0, 0), 0, Vector2(1, 1)); draw_set_transform(Vector2(0, 0), 0, Vector2(1, 1));
auto &draw_order = skeleton->get_spine_object()->getDrawOrder(); auto &draw_order = skeleton->get_spine_object()->getDrawOrder();
for (int i = 0; i < (int)draw_order.size(); i++) { for (int i = 0; i < (int) draw_order.size(); i++) {
auto *slot = draw_order[i]; auto *slot = draw_order[i];
if (!slot->getBone().isActive()) continue; if (!slot->getBone().isActive()) continue;
auto *attachment = slot->getAttachment(); auto *attachment = slot->getAttachment();
if (!attachment) continue; if (!attachment) continue;
if (!attachment->getRTTI().isExactly(spine::RegionAttachment::rtti)) continue; if (!attachment->getRTTI().isExactly(spine::RegionAttachment::rtti)) continue;
auto *region = (spine::RegionAttachment*)attachment; auto *region = (spine::RegionAttachment *) attachment;
auto *vertices = &scratch_vertices; auto *vertices = &scratch_vertices;
vertices->setSize(8, 0); vertices->setSize(8, 0);
region->computeWorldVertices(*slot, *vertices, 0); region->computeWorldVertices(*slot, *vertices, 0);
@ -666,13 +683,13 @@ void SpineSprite::draw() {
if (debug_meshes) { if (debug_meshes) {
draw_set_transform(Vector2(0, 0), 0, Vector2(1, 1)); draw_set_transform(Vector2(0, 0), 0, Vector2(1, 1));
auto &draw_order = skeleton->get_spine_object()->getDrawOrder(); auto &draw_order = skeleton->get_spine_object()->getDrawOrder();
for (int i = 0; i < (int)draw_order.size(); i++) { for (int i = 0; i < (int) draw_order.size(); i++) {
auto *slot = draw_order[i]; auto *slot = draw_order[i];
if (!slot->getBone().isActive()) continue; if (!slot->getBone().isActive()) continue;
auto *attachment = slot->getAttachment(); auto *attachment = slot->getAttachment();
if (!attachment) continue; if (!attachment) continue;
if (!attachment->getRTTI().isExactly(spine::MeshAttachment::rtti)) continue; if (!attachment->getRTTI().isExactly(spine::MeshAttachment::rtti)) continue;
auto *mesh = (spine::MeshAttachment*)attachment; auto *mesh = (spine::MeshAttachment *) attachment;
auto *vertices = &scratch_vertices; auto *vertices = &scratch_vertices;
vertices->setSize(mesh->getWorldVerticesLength(), 0); vertices->setSize(mesh->getWorldVerticesLength(), 0);
mesh->computeWorldVertices(*slot, *vertices); mesh->computeWorldVertices(*slot, *vertices);
@ -682,7 +699,7 @@ void SpineSprite::draw() {
float y = vertices->buffer()[j + 1]; float y = vertices->buffer()[j + 1];
scratch_points.push_back(Vector2(x, y)); scratch_points.push_back(Vector2(x, y));
} }
Color color = debug_meshes_color; Color color = debug_meshes_color;
if (GEOMETRY2D::is_point_in_polygon(mouse_position, scratch_points)) { if (GEOMETRY2D::is_point_in_polygon(mouse_position, scratch_points)) {
hovered_slot = slot; hovered_slot = slot;
@ -696,18 +713,18 @@ void SpineSprite::draw() {
if (debug_bounding_boxes) { if (debug_bounding_boxes) {
draw_set_transform(Vector2(0, 0), 0, Vector2(1, 1)); draw_set_transform(Vector2(0, 0), 0, Vector2(1, 1));
auto &draw_order = skeleton->get_spine_object()->getDrawOrder(); auto &draw_order = skeleton->get_spine_object()->getDrawOrder();
for (int i = 0; i < (int)draw_order.size(); i++) { for (int i = 0; i < (int) draw_order.size(); i++) {
auto *slot = draw_order[i]; auto *slot = draw_order[i];
if (!slot->getBone().isActive()) continue; if (!slot->getBone().isActive()) continue;
auto *attachment = slot->getAttachment(); auto *attachment = slot->getAttachment();
if (!attachment) continue; if (!attachment) continue;
if (!attachment->getRTTI().isExactly(spine::BoundingBoxAttachment::rtti)) continue; if (!attachment->getRTTI().isExactly(spine::BoundingBoxAttachment::rtti)) continue;
auto *bounding_box = (spine::BoundingBoxAttachment*)attachment; auto *bounding_box = (spine::BoundingBoxAttachment *) attachment;
auto *vertices = &scratch_vertices; auto *vertices = &scratch_vertices;
vertices->setSize(bounding_box->getWorldVerticesLength(), 0); vertices->setSize(bounding_box->getWorldVerticesLength(), 0);
bounding_box->computeWorldVertices(*slot, *vertices); bounding_box->computeWorldVertices(*slot, *vertices);
size_t num_vertices = vertices->size() / 2; size_t num_vertices = vertices->size() / 2;
scratch_points.resize((int)num_vertices); scratch_points.resize((int) num_vertices);
memcpy(scratch_points.ptrw(), vertices->buffer(), num_vertices * 2 * sizeof(float)); memcpy(scratch_points.ptrw(), vertices->buffer(), num_vertices * 2 * sizeof(float));
scratch_points.push_back(Vector2(vertices->buffer()[0], vertices->buffer()[1])); scratch_points.push_back(Vector2(vertices->buffer()[0], vertices->buffer()[1]));
draw_polyline(scratch_points, debug_bounding_boxes_color, 2); draw_polyline(scratch_points, debug_bounding_boxes_color, 2);
@ -717,18 +734,18 @@ void SpineSprite::draw() {
if (debug_clipping) { if (debug_clipping) {
draw_set_transform(Vector2(0, 0), 0, Vector2(1, 1)); draw_set_transform(Vector2(0, 0), 0, Vector2(1, 1));
auto &draw_order = skeleton->get_spine_object()->getDrawOrder(); auto &draw_order = skeleton->get_spine_object()->getDrawOrder();
for (int i = 0; i < (int)draw_order.size(); i++) { for (int i = 0; i < (int) draw_order.size(); i++) {
auto *slot = draw_order[i]; auto *slot = draw_order[i];
if (!slot->getBone().isActive()) continue; if (!slot->getBone().isActive()) continue;
auto *attachment = slot->getAttachment(); auto *attachment = slot->getAttachment();
if (!attachment) continue; if (!attachment) continue;
if (!attachment->getRTTI().isExactly(spine::ClippingAttachment::rtti)) continue; if (!attachment->getRTTI().isExactly(spine::ClippingAttachment::rtti)) continue;
auto *clipping = (spine::ClippingAttachment*)attachment; auto *clipping = (spine::ClippingAttachment *) attachment;
auto *vertices = &scratch_vertices; auto *vertices = &scratch_vertices;
vertices->setSize(clipping->getWorldVerticesLength(), 0); vertices->setSize(clipping->getWorldVerticesLength(), 0);
clipping->computeWorldVertices(*slot, *vertices); clipping->computeWorldVertices(*slot, *vertices);
size_t num_vertices = vertices->size() / 2; size_t num_vertices = vertices->size() / 2;
scratch_points.resize((int)num_vertices); scratch_points.resize((int) num_vertices);
memcpy(scratch_points.ptrw(), vertices->buffer(), num_vertices * 2 * sizeof(float)); memcpy(scratch_points.ptrw(), vertices->buffer(), num_vertices * 2 * sizeof(float));
scratch_points.push_back(Vector2(vertices->buffer()[0], vertices->buffer()[1])); scratch_points.push_back(Vector2(vertices->buffer()[0], vertices->buffer()[1]));
draw_polyline(scratch_points, debug_clipping_color, 2); draw_polyline(scratch_points, debug_clipping_color, 2);
@ -739,14 +756,14 @@ void SpineSprite::draw() {
spine::Bone *hovered_bone = nullptr; spine::Bone *hovered_bone = nullptr;
if (debug_bones) { if (debug_bones) {
auto &bones = skeleton->get_spine_object()->getBones(); auto &bones = skeleton->get_spine_object()->getBones();
for (int i = 0; i < (int)bones.size(); i++) { for (int i = 0; i < (int) bones.size(); i++) {
auto *bone = bones[i]; auto *bone = bones[i];
if (!bone->isActive()) continue; if (!bone->isActive()) continue;
draw_bone(bone, debug_bones_color); draw_bone(bone, debug_bones_color);
float bone_length = bone->getData().getLength(); float bone_length = bone->getData().getLength();
if (bone_length == 0) bone_length = debug_bones_thickness * 2; if (bone_length == 0) bone_length = debug_bones_thickness * 2;
scratch_points.resize(5); scratch_points.resize(5);
scratch_points.set(0, Vector2(-debug_bones_thickness, 0)); scratch_points.set(0, Vector2(-debug_bones_thickness, 0));
scratch_points.set(1, Vector2(0, debug_bones_thickness)); scratch_points.set(1, Vector2(0, debug_bones_thickness));
@ -778,7 +795,7 @@ void SpineSprite::draw() {
if (hovered_slot) { if (hovered_slot) {
hover_text_lines.push_back(String("Slot: ") + hovered_slot->getData().getName().buffer()); hover_text_lines.push_back(String("Slot: ") + hovered_slot->getData().getName().buffer());
} }
if (hovered_bone) { if (hovered_bone) {
float thickness = debug_bones_thickness; float thickness = debug_bones_thickness;
debug_bones_thickness *= 1.1; debug_bones_thickness *= 1.1;
@ -786,7 +803,7 @@ void SpineSprite::draw() {
debug_bones_thickness = thickness; debug_bones_thickness = thickness;
hover_text_lines.push_back(String("Bone: ") + hovered_bone->getData().getName().buffer()); hover_text_lines.push_back(String("Bone: ") + hovered_bone->getData().getName().buffer());
} }
auto global_scale = get_global_scale(); auto global_scale = get_global_scale();
draw_set_transform(mouse_position + Vector2(20, 0), -get_global_rotation(), Vector2(inverse_zoom * (1 / global_scale.x), inverse_zoom * (1 / global_scale.y))); draw_set_transform(mouse_position + Vector2(20, 0), -get_global_rotation(), Vector2(inverse_zoom * (1 / global_scale.x), inverse_zoom * (1 / global_scale.y)));
@ -796,18 +813,18 @@ void SpineSprite::draw() {
rect_width = MAX(rect_width, default_font->get_string_size(hover_text_lines[i]).x); rect_width = MAX(rect_width, default_font->get_string_size(hover_text_lines[i]).x);
} }
Rect2 background_rect(0, -default_font->get_height() - 5, rect_width + 20, line_height * hover_text_lines.size() + 10); Rect2 background_rect(0, -default_font->get_height() - 5, rect_width + 20, line_height * hover_text_lines.size() + 10);
if (hover_text_lines.size() > 0) draw_rect(background_rect, Color(0, 0, 0 ,0.8)); if (hover_text_lines.size() > 0) draw_rect(background_rect, Color(0, 0, 0, 0.8));
for (int i = 0; i < hover_text_lines.size(); i++) { for (int i = 0; i < hover_text_lines.size(); i++) {
#if VERSION_MAJOR > 3 #if VERSION_MAJOR > 3
draw_string(default_font, Vector2(10, 0 + i * default_font->get_height()), hover_text_lines[i], HORIZONTAL_ALIGNMENT_LEFT, -1, Font::DEFAULT_FONT_SIZE, Color (1, 1, 1, 1)); draw_string(default_font, Vector2(10, 0 + i * default_font->get_height()), hover_text_lines[i], HORIZONTAL_ALIGNMENT_LEFT, -1, Font::DEFAULT_FONT_SIZE, Color(1, 1, 1, 1));
#else #else
draw_string(default_font, Vector2(10, 0 + i * default_font->get_height()), hover_text_lines[i], Color (1, 1, 1, 1)); draw_string(default_font, Vector2(10, 0 + i * default_font->get_height()), hover_text_lines[i], Color(1, 1, 1, 1));
#endif #endif
} }
#endif #endif
} }
void SpineSprite::draw_bone(spine::Bone* bone, const Color &color) { void SpineSprite::draw_bone(spine::Bone *bone, const Color &color) {
draw_set_transform(Vector2(bone->getWorldX(), bone->getWorldY()), Math::deg2rad(bone->getWorldRotationX()), Vector2(bone->getWorldScaleX(), bone->getWorldScaleY())); draw_set_transform(Vector2(bone->getWorldX(), bone->getWorldY()), Math::deg2rad(bone->getWorldRotationX()), Vector2(bone->getWorldScaleX(), bone->getWorldScaleY()));
float bone_length = bone->getData().getLength(); float bone_length = bone->getData().getLength();
if (bone_length == 0) bone_length = debug_bones_thickness * 2; if (bone_length == 0) bone_length = debug_bones_thickness * 2;
@ -821,8 +838,8 @@ void SpineSprite::draw_bone(spine::Bone* bone, const Color &color) {
void SpineSprite::callback(spine::AnimationState *state, spine::EventType type, spine::TrackEntry *entry, spine::Event *event) { void SpineSprite::callback(spine::AnimationState *state, spine::EventType type, spine::TrackEntry *entry, spine::Event *event) {
Ref<SpineTrackEntry> entry_ref = Ref<SpineTrackEntry>(memnew(SpineTrackEntry)); Ref<SpineTrackEntry> entry_ref = Ref<SpineTrackEntry>(memnew(SpineTrackEntry));
entry_ref->set_spine_object(this, entry); entry_ref->set_spine_object(this, entry);
Ref<SpineEvent> event_ref(nullptr); Ref<SpineEvent> event_ref(nullptr);
if (event) { if (event) {
event_ref = Ref<SpineEvent>(memnew(SpineEvent)); event_ref = Ref<SpineEvent>(memnew(SpineEvent));
@ -878,7 +895,7 @@ void SpineSprite::set_update_mode(SpineConstant::UpdateMode v) {
set_physics_process_internal(update_mode == SpineConstant::UpdateMode_Physics); set_physics_process_internal(update_mode == SpineConstant::UpdateMode_Physics);
} }
Ref<SpineSkin> SpineSprite::new_skin(const String& name) { Ref<SpineSkin> SpineSprite::new_skin(const String &name) {
Ref<SpineSkin> skin = memnew(SpineSkin); Ref<SpineSkin> skin = memnew(SpineSkin);
skin->init(name, this); skin->init(name, this);
return skin; return skin;

18
spine-godot/spine_godot/SpineSprite.h
View File

@ -40,13 +40,13 @@ class SpineSprite : public Node2D, public spine::AnimationStateListenerObject {
GDCLASS(SpineSprite, Node2D) GDCLASS(SpineSprite, Node2D)
friend class SpineBone; friend class SpineBone;
protected: protected:
Ref<SpineSkeletonDataResource> skeleton_data_res; Ref<SpineSkeletonDataResource> skeleton_data_res;
Ref<SpineSkeleton> skeleton; Ref<SpineSkeleton> skeleton;
Ref<SpineAnimationState> animation_state; Ref<SpineAnimationState> animation_state;
SpineConstant::UpdateMode update_mode; SpineConstant::UpdateMode update_mode;
String preview_animation; String preview_animation;
bool preview_frame; bool preview_frame;
float preview_time; float preview_time;
@ -65,7 +65,7 @@ protected:
bool debug_clipping; bool debug_clipping;
Color debug_clipping_color; Color debug_clipping_color;
spine::Vector<spine::Vector<SpineSlotNode*> > slot_nodes; spine::Vector<spine::Vector<SpineSlotNode *>> slot_nodes;
Vector<MeshInstance2D *> mesh_instances; Vector<MeshInstance2D *> mesh_instances;
static Ref<CanvasItemMaterial> default_materials[4]; static Ref<CanvasItemMaterial> default_materials[4];
Ref<Material> normal_material; Ref<Material> normal_material;
@ -74,7 +74,7 @@ protected:
Ref<Material> screen_material; Ref<Material> screen_material;
spine::SkeletonClipping *skeleton_clipper; spine::SkeletonClipping *skeleton_clipper;
bool modified_bones; bool modified_bones;
static void _bind_methods(); static void _bind_methods();
void _notification(int what); void _notification(int what);
void _get_property_list(List<PropertyInfo> *list) const; void _get_property_list(List<PropertyInfo> *list) const;
@ -96,11 +96,11 @@ public:
~SpineSprite(); ~SpineSprite();
void set_skeleton_data_res(const Ref<SpineSkeletonDataResource> &_spine_skeleton_data_resource); void set_skeleton_data_res(const Ref<SpineSkeletonDataResource> &_spine_skeleton_data_resource);
Ref<SpineSkeletonDataResource> get_skeleton_data_res(); Ref<SpineSkeletonDataResource> get_skeleton_data_res();
Ref<SpineSkeleton> get_skeleton(); Ref<SpineSkeleton> get_skeleton();
Ref<SpineAnimationState> get_animation_state(); Ref<SpineAnimationState> get_animation_state();
void on_skeleton_data_changed(); void on_skeleton_data_changed();
@ -110,7 +110,7 @@ public:
Transform2D get_global_bone_transform(const String &bone_name); Transform2D get_global_bone_transform(const String &bone_name);
void set_global_bone_transform(const String &bone_name, Transform2D transform); void set_global_bone_transform(const String &bone_name, Transform2D transform);
SpineConstant::UpdateMode get_update_mode(); SpineConstant::UpdateMode get_update_mode();
void set_update_mode(SpineConstant::UpdateMode v); void set_update_mode(SpineConstant::UpdateMode v);
@ -135,7 +135,7 @@ public:
bool get_debug_bones() { return debug_bones; } bool get_debug_bones() { return debug_bones; }
void set_debug_bones (bool bones) { debug_bones = bones; } void set_debug_bones(bool bones) { debug_bones = bones; }
Color get_debug_bones_color() { return debug_bones_color; } Color get_debug_bones_color() { return debug_bones_color; }
@ -168,7 +168,7 @@ public:
Color get_debug_paths_color() { return debug_paths_color; } Color get_debug_paths_color() { return debug_paths_color; }
void set_debug_paths_color(const Color &color) { debug_paths_color = color; } void set_debug_paths_color(const Color &color) { debug_paths_color = color; }
bool get_debug_bounding_boxes() { return debug_bounding_boxes; } bool get_debug_bounding_boxes() { return debug_bounding_boxes; }
void set_debug_bounding_boxes(bool paths) { debug_bounding_boxes = paths; } void set_debug_bounding_boxes(bool paths) { debug_bounding_boxes = paths; }

12
spine-godot/spine_godot/SpineTimeline.cpp
View File

@ -46,10 +46,10 @@ void SpineTimeline::_bind_methods() {
void SpineTimeline::apply(Ref<SpineSkeleton> skeleton, float last_time, float time, Array events, float alpha, void SpineTimeline::apply(Ref<SpineSkeleton> skeleton, float last_time, float time, Array events, float alpha,
SpineConstant::MixBlend blend, SpineConstant::MixDirection direction) { SpineConstant::MixBlend blend, SpineConstant::MixDirection direction) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
if (!skeleton->get_spine_object()) return; if (!skeleton->get_spine_object()) return;
spine::Vector<spine::Event *> spine_events; spine::Vector<spine::Event *> spine_events;
spine_events.setSize((int)events.size(), nullptr); spine_events.setSize((int) events.size(), nullptr);
for (int i = 0; i < events.size(); ++i) { for (int i = 0; i < events.size(); ++i) {
events[i] = ((Ref<SpineEvent>) spine_events[i])->get_spine_object(); events[i] = ((Ref<SpineEvent>) spine_events[i])->get_spine_object();
} }
@ -58,19 +58,19 @@ void SpineTimeline::apply(Ref<SpineSkeleton> skeleton, float last_time, float ti
int SpineTimeline::get_frame_entries() { int SpineTimeline::get_frame_entries() {
SPINE_CHECK(get_spine_object(), 0) SPINE_CHECK(get_spine_object(), 0)
return (int)get_spine_object()->getFrameEntries(); return (int) get_spine_object()->getFrameEntries();
} }
int SpineTimeline::get_frame_count() { int SpineTimeline::get_frame_count() {
SPINE_CHECK(get_spine_object(), 0) SPINE_CHECK(get_spine_object(), 0)
return (int)get_spine_object()->getFrameCount(); return (int) get_spine_object()->getFrameCount();
} }
Array SpineTimeline::get_frames() { Array SpineTimeline::get_frames() {
Array result; Array result;
SPINE_CHECK(get_spine_object(), result) SPINE_CHECK(get_spine_object(), result)
auto &frames = get_spine_object()->getFrames(); auto &frames = get_spine_object()->getFrames();
result.resize((int)frames.size()); result.resize((int) frames.size());
for (int i = 0; i < result.size(); ++i) { for (int i = 0; i < result.size(); ++i) {
result[i] = frames[i]; result[i] = frames[i];
} }
@ -86,7 +86,7 @@ Array SpineTimeline::get_property_ids() {
Array result; Array result;
SPINE_CHECK(get_spine_object(), result) SPINE_CHECK(get_spine_object(), result)
auto &ids = get_spine_object()->getPropertyIds(); auto &ids = get_spine_object()->getPropertyIds();
result.resize((int)ids.size()); result.resize((int) ids.size());
for (int i = 0; i < result.size(); ++i) { for (int i = 0; i < result.size(); ++i) {
result[i] = (spine::PropertyId) ids[i]; result[i] = (spine::PropertyId) ids[i];
} }

44
spine-godot/spine_godot/SpineTrackEntry.cpp
View File

@ -108,7 +108,7 @@ bool SpineTrackEntry::get_loop() {
} }
void SpineTrackEntry::set_loop(bool v) { void SpineTrackEntry::set_loop(bool v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setLoop(v); get_spine_object()->setLoop(v);
} }
@ -118,7 +118,7 @@ bool SpineTrackEntry::get_hold_previous() {
} }
void SpineTrackEntry::set_hold_previous(bool v) { void SpineTrackEntry::set_hold_previous(bool v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setHoldPrevious(v); get_spine_object()->setHoldPrevious(v);
} }
@ -128,17 +128,17 @@ bool SpineTrackEntry::get_reverse() {
} }
void SpineTrackEntry::set_reverse(bool v) { void SpineTrackEntry::set_reverse(bool v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setReverse(v); get_spine_object()->setReverse(v);
} }
bool SpineTrackEntry::get_shortest_rotation() { bool SpineTrackEntry::get_shortest_rotation() {
SPINE_CHECK(get_spine_object(), false) SPINE_CHECK(get_spine_object(), false)
return get_spine_object()->getShortestRotation(); return get_spine_object()->getShortestRotation();
} }
void SpineTrackEntry::set_shortest_rotation(bool v) { void SpineTrackEntry::set_shortest_rotation(bool v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setShortestRotation(v); get_spine_object()->setShortestRotation(v);
} }
@ -148,7 +148,7 @@ float SpineTrackEntry::get_delay() {
} }
void SpineTrackEntry::set_delay(float v) { void SpineTrackEntry::set_delay(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setDelay(v); get_spine_object()->setDelay(v);
} }
@ -158,7 +158,7 @@ float SpineTrackEntry::get_track_time() {
} }
void SpineTrackEntry::set_track_time(float v) { void SpineTrackEntry::set_track_time(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setTrackTime(v); get_spine_object()->setTrackTime(v);
} }
@ -168,7 +168,7 @@ float SpineTrackEntry::get_track_end() {
} }
void SpineTrackEntry::set_track_end(float v) { void SpineTrackEntry::set_track_end(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setTrackEnd(v); get_spine_object()->setTrackEnd(v);
} }
@ -178,7 +178,7 @@ float SpineTrackEntry::get_animation_start() {
} }
void SpineTrackEntry::set_animation_start(float v) { void SpineTrackEntry::set_animation_start(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setAnimationStart(v); get_spine_object()->setAnimationStart(v);
} }
@ -188,7 +188,7 @@ float SpineTrackEntry::get_animation_end() {
} }
void SpineTrackEntry::set_animation_end(float v) { void SpineTrackEntry::set_animation_end(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setAnimationEnd(v); get_spine_object()->setAnimationEnd(v);
} }
@ -198,7 +198,7 @@ float SpineTrackEntry::get_animation_last() {
} }
void SpineTrackEntry::set_animation_last(float v) { void SpineTrackEntry::set_animation_last(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setAnimationLast(v); get_spine_object()->setAnimationLast(v);
} }
@ -213,7 +213,7 @@ float SpineTrackEntry::get_time_scale() {
} }
void SpineTrackEntry::set_time_scale(float v) { void SpineTrackEntry::set_time_scale(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setTimeScale(v); get_spine_object()->setTimeScale(v);
} }
@ -223,7 +223,7 @@ float SpineTrackEntry::get_alpha() {
} }
void SpineTrackEntry::set_alpha(float v) { void SpineTrackEntry::set_alpha(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setAlpha(v); get_spine_object()->setAlpha(v);
} }
@ -233,7 +233,7 @@ float SpineTrackEntry::get_event_threshold() {
} }
void SpineTrackEntry::set_event_threshold(float v) { void SpineTrackEntry::set_event_threshold(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setEventThreshold(v); get_spine_object()->setEventThreshold(v);
} }
@ -243,7 +243,7 @@ float SpineTrackEntry::get_attachment_threshold() {
} }
void SpineTrackEntry::set_attachment_threshold(float v) { void SpineTrackEntry::set_attachment_threshold(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setAttachmentThreshold(v); get_spine_object()->setAttachmentThreshold(v);
} }
@ -253,7 +253,7 @@ float SpineTrackEntry::get_draw_order_threshold() {
} }
void SpineTrackEntry::set_draw_order_threshold(float v) { void SpineTrackEntry::set_draw_order_threshold(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setDrawOrderThreshold(v); get_spine_object()->setDrawOrderThreshold(v);
} }
@ -277,7 +277,7 @@ float SpineTrackEntry::get_mix_time() {
} }
void SpineTrackEntry::set_mix_time(float v) { void SpineTrackEntry::set_mix_time(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setMixTime(v); get_spine_object()->setMixTime(v);
} }
@ -287,17 +287,17 @@ float SpineTrackEntry::get_mix_duration() {
} }
void SpineTrackEntry::set_mix_duration(float v) { void SpineTrackEntry::set_mix_duration(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setMixDuration(v); get_spine_object()->setMixDuration(v);
} }
SpineConstant::MixBlend SpineTrackEntry::get_mix_blend() { SpineConstant::MixBlend SpineTrackEntry::get_mix_blend() {
SPINE_CHECK(get_spine_object(), SpineConstant::MixBlend_Setup) SPINE_CHECK(get_spine_object(), SpineConstant::MixBlend_Setup)
return (SpineConstant::MixBlend)get_spine_object()->getMixBlend(); return (SpineConstant::MixBlend) get_spine_object()->getMixBlend();
} }
void SpineTrackEntry::set_mix_blend(SpineConstant::MixBlend v) { void SpineTrackEntry::set_mix_blend(SpineConstant::MixBlend v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setMixBlend((spine::MixBlend) v); get_spine_object()->setMixBlend((spine::MixBlend) v);
} }
@ -320,7 +320,7 @@ Ref<SpineTrackEntry> SpineTrackEntry::get_mixing_to() {
} }
void SpineTrackEntry::reset_rotation_directions() { void SpineTrackEntry::reset_rotation_directions() {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->resetRotationDirections(); get_spine_object()->resetRotationDirections();
} }

20
spine-godot/spine_godot/SpineTransformConstraint.cpp
View File

@ -54,7 +54,7 @@ void SpineTransformConstraint::_bind_methods() {
} }
void SpineTransformConstraint::update() { void SpineTransformConstraint::update() {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->update(); get_spine_object()->update();
} }
@ -75,7 +75,7 @@ Array SpineTransformConstraint::get_bones() {
Array result; Array result;
SPINE_CHECK(get_spine_object(), result) SPINE_CHECK(get_spine_object(), result)
auto &bones = get_spine_object()->getBones(); auto &bones = get_spine_object()->getBones();
result.resize((int)bones.size()); result.resize((int) bones.size());
for (int i = 0; i < bones.size(); ++i) { for (int i = 0; i < bones.size(); ++i) {
auto bone = bones[i]; auto bone = bones[i];
Ref<SpineBone> bone_ref(memnew(SpineBone)); Ref<SpineBone> bone_ref(memnew(SpineBone));
@ -95,7 +95,7 @@ Ref<SpineBone> SpineTransformConstraint::get_target() {
} }
void SpineTransformConstraint::set_target(Ref<SpineBone> v) { void SpineTransformConstraint::set_target(Ref<SpineBone> v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setTarget(v.is_valid() && v->get_spine_object() ? v->get_spine_object() : nullptr); get_spine_object()->setTarget(v.is_valid() && v->get_spine_object() ? v->get_spine_object() : nullptr);
} }
@ -105,7 +105,7 @@ float SpineTransformConstraint::get_mix_rotate() {
} }
void SpineTransformConstraint::set_mix_rotate(float v) { void SpineTransformConstraint::set_mix_rotate(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setMixRotate(v); get_spine_object()->setMixRotate(v);
} }
@ -115,7 +115,7 @@ float SpineTransformConstraint::get_mix_x() {
} }
void SpineTransformConstraint::set_mix_x(float v) { void SpineTransformConstraint::set_mix_x(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setMixX(v); get_spine_object()->setMixX(v);
} }
@ -125,7 +125,7 @@ float SpineTransformConstraint::get_mix_y() {
} }
void SpineTransformConstraint::set_mix_y(float v) { void SpineTransformConstraint::set_mix_y(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setMixY(v); get_spine_object()->setMixY(v);
} }
@ -135,7 +135,7 @@ float SpineTransformConstraint::get_mix_scale_x() {
} }
void SpineTransformConstraint::set_mix_scale_x(float v) { void SpineTransformConstraint::set_mix_scale_x(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setMixScaleX(v); get_spine_object()->setMixScaleX(v);
} }
@ -145,7 +145,7 @@ float SpineTransformConstraint::get_mix_scale_y() {
} }
void SpineTransformConstraint::set_mix_scale_y(float v) { void SpineTransformConstraint::set_mix_scale_y(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setMixScaleY(v); get_spine_object()->setMixScaleY(v);
} }
@ -155,7 +155,7 @@ float SpineTransformConstraint::get_mix_shear_y() {
} }
void SpineTransformConstraint::set_mix_shear_y(float v) { void SpineTransformConstraint::set_mix_shear_y(float v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setMixShearY(v); get_spine_object()->setMixShearY(v);
} }
@ -165,6 +165,6 @@ bool SpineTransformConstraint::is_active() {
} }
void SpineTransformConstraint::set_active(bool v) { void SpineTransformConstraint::set_active(bool v) {
SPINE_CHECK(get_spine_object(),) SPINE_CHECK(get_spine_object(), )
get_spine_object()->setActive(v); get_spine_object()->setActive(v);
} }

4
spine-godot/spine_godot/SpineTransformConstraintData.cpp
View File

@ -53,8 +53,8 @@ Array SpineTransformConstraintData::get_bones() {
Array result; Array result;
SPINE_CHECK(get_spine_constraint_data(), result) SPINE_CHECK(get_spine_constraint_data(), result)
auto bones = get_spine_constraint_data()->getBones(); auto bones = get_spine_constraint_data()->getBones();
result.resize((int)bones.size()); result.resize((int) bones.size());
for (int i = 0; i < (int)bones.size(); ++i) { for (int i = 0; i < (int) bones.size(); ++i) {
Ref<SpineBoneData> bone_ref(memnew(SpineBoneData)); Ref<SpineBoneData> bone_ref(memnew(SpineBoneData));
bone_ref->set_spine_object(get_spine_owner(), bones[i]); bone_ref->set_spine_object(get_spine_owner(), bones[i]);
result[i] = bone_ref; result[i] = bone_ref;

4
spine-godot/spine_godot/register_types.cpp
View File

@ -78,7 +78,7 @@ void register_spine_godot_types() {
GDREGISTER_CLASS(SpineEditorPropertyAnimationMixes); GDREGISTER_CLASS(SpineEditorPropertyAnimationMixes);
#endif #endif
spine::Bone::setYDown(true); spine::Bone::setYDown(true);
GDREGISTER_CLASS(SpineAtlasResource); GDREGISTER_CLASS(SpineAtlasResource);
GDREGISTER_CLASS(SpineSkeletonFileResource); GDREGISTER_CLASS(SpineSkeletonFileResource);
GDREGISTER_CLASS(SpineSkeletonDataResource); GDREGISTER_CLASS(SpineSkeletonDataResource);
@ -106,7 +106,7 @@ void register_spine_godot_types() {
GDREGISTER_CLASS(SpineTransformConstraint); GDREGISTER_CLASS(SpineTransformConstraint);
GDREGISTER_CLASS(SpineTimeline); GDREGISTER_CLASS(SpineTimeline);
GDREGISTER_CLASS(SpineConstant); GDREGISTER_CLASS(SpineConstant);
GDREGISTER_CLASS(SpineSlotNode); GDREGISTER_CLASS(SpineSlotNode);
GDREGISTER_CLASS(SpineBoneNode); GDREGISTER_CLASS(SpineBoneNode);
GDREGISTER_CLASS(SpineAnimationTrack); GDREGISTER_CLASS(SpineAnimationTrack);