UnityMirror/spine-runtimes
1
0
Fork 0
mirror of https://github.com/EsotericSoftware/spine-runtimes.git synced 2026-02-04 22:34:53 +08:00
Code Issues Packages Projects Releases Wiki Activity

[godot] Clean-up SpineBone.

Browse Source
This commit is contained in:
badlogic 2022-04-12 12:47:04 +02:00
parent d62ef56066
commit b6018275f1
2 changed files with 168 additions and 69 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -30,6 +30,7 @@
#include "SpineBone.h"
#include "SpineSprite.h"
#include "SpineSkeleton.h"
#include "common.h"
void SpineBone::_bind_methods() {
ClassDB::bind_method(D_METHOD("update_world_transform"), &SpineBone::update_world_transform);
@ -91,262 +92,345 @@ void SpineBone::_bind_methods() {
ClassDB::bind_method(D_METHOD("get_world_scale_y"), &SpineBone::get_world_scale_y);
ClassDB::bind_method(D_METHOD("is_active"), &SpineBone::is_active);
ClassDB::bind_method(D_METHOD("set_active", "v"), &SpineBone::set_active);
ClassDB::bind_method(D_METHOD("apply_world_transform_2d", "node2d"), &SpineBone::apply_world_transform_2d);
ClassDB::bind_method(D_METHOD("get_godot_transform"), &SpineBone::get_godot_transform);
ClassDB::bind_method(D_METHOD("set_godot_transform", "local_transform"), &SpineBone::set_godot_transform);
ClassDB::bind_method(D_METHOD("get_godot_global_transform"), &SpineBone::get_godot_global_transform);
ClassDB::bind_method(D_METHOD("set_godot_global_transform", "global_transform"), &SpineBone::set_godot_global_transform);
ClassDB::bind_method(D_METHOD("apply_world_transform_2d", "node2d"), &SpineBone::apply_world_transform_2d);
}
SpineBone::SpineBone() : bone(nullptr), sprite(nullptr) {}
SpineBone::~SpineBone() {}
void SpineBone::set_spine_sprite(SpineSprite* sprite) {
this->sprite = sprite;
void SpineBone::set_spine_sprite(SpineSprite* _sprite) {
this->sprite = _sprite;
}
void SpineBone::update_world_transform() {
SPINE_CHECK(bone,)
bone->updateWorldTransform();
}
void SpineBone::set_to_setup_pose() {
SPINE_CHECK(bone,)
bone->setToSetupPose();
}
Vector2 SpineBone::world_to_local(Vector2 world_position) {
SPINE_CHECK(bone, Vector2())
float x, y;
bone->worldToLocal(world_position.x, world_position.y, x, y);
return Vector2(x, y);
}
Vector2 SpineBone::local_to_world(Vector2 local_position) {
SPINE_CHECK(bone, Vector2())
float x, y;
bone->localToWorld(local_position.x, local_position.y, x, y);
return Vector2(x, y);
}
float SpineBone::world_to_local_rotation(float world_rotation) {
SPINE_CHECK(bone, 0)
return bone->worldToLocalRotation(world_rotation);
}
float SpineBone::local_to_world_rotation(float local_rotation) {
SPINE_CHECK(bone, 0)
return bone->localToWorldRotation(local_rotation);
}
void SpineBone::rotate_world(float degrees) {
SPINE_CHECK(bone,)
bone->rotateWorld(degrees);
}
float SpineBone::get_world_to_local_rotation_x() {
SPINE_CHECK(bone, 0)
return bone->getWorldToLocalRotationX();
}
float SpineBone::get_world_to_local_rotation_y() {
SPINE_CHECK(bone, 0)
return bone->getWorldToLocalRotationY();
}
Ref<SpineBoneData> SpineBone::get_data() {
auto &bd = bone->getData();
Ref<SpineBoneData> gd_bd(memnew(SpineBoneData));
gd_bd->set_spine_object(&bd);
return gd_bd;
SPINE_CHECK(bone, nullptr)
auto &bone_data = bone->getData();
Ref<SpineBoneData> bone_data_ref(memnew(SpineBoneData));
bone_data_ref->set_spine_object(&bone_data);
return bone_data_ref;
}
Ref<SpineSkeleton> SpineBone::get_skeleton() {
auto &s = bone->getSkeleton();
Ref<SpineSkeleton> gd_s(memnew(SpineSkeleton));
gd_s->set_spine_object(&s);
gd_s->set_spine_sprite(sprite);
return gd_s;
SPINE_CHECK(bone, nullptr)
auto &skeleton = bone->getSkeleton();
Ref<SpineSkeleton> skeleton_ref(memnew(SpineSkeleton));
skeleton_ref->set_spine_object(&skeleton);
skeleton_ref->set_spine_sprite(sprite);
return skeleton_ref;
}
Ref<SpineBone> SpineBone::get_parent() {
auto b = bone->getParent();
if (b == NULL) return NULL;
Ref<SpineBone> gd_b(memnew(SpineBone));
gd_b->set_spine_object(b);
gd_b->set_spine_sprite(sprite);
return gd_b;
SPINE_CHECK(bone, nullptr)
auto parent = bone->getParent();
if (!parent) return nullptr;
Ref<SpineBone> parent_ref(memnew(SpineBone));
parent_ref->set_spine_object(parent);
parent_ref->set_spine_sprite(sprite);
return parent_ref;
}
Array SpineBone::get_children() {
auto bs = bone->getChildren();
Array gd_bs;
gd_bs.resize(bs.size());
for (size_t i = 0; i < bs.size(); ++i) {
auto b = bs[i];
if (b == NULL) gd_bs[i] = Ref<SpineBone>(NULL);
Ref<SpineBone> gd_b(memnew(SpineBone));
gd_b->set_spine_object(b);
gd_b->set_spine_sprite(sprite);
gd_bs[i] = gd_b;
Array result;
SPINE_CHECK(bone, result)
auto children = bone->getChildren();
result.resize((int)children.size());
for (int i = 0; i < children.size(); ++i) {
auto child = children[i];
Ref<SpineBone> bone_ref(memnew(SpineBone));
bone_ref->set_spine_object(child);
bone_ref->set_spine_sprite(sprite);
result[i] = bone_ref;
}
return gd_bs;
return result;
}
float SpineBone::get_x() {
SPINE_CHECK(bone, 0)
return bone->getX();
}
void SpineBone::set_x(float v) {
SPINE_CHECK(bone,)
bone->setX(v);
}
float SpineBone::get_y() {
SPINE_CHECK(bone, 0)
return bone->getY();
}
void SpineBone::set_y(float v) {
SPINE_CHECK(bone,)
bone->setY(v);
}
float SpineBone::get_rotation() {
SPINE_CHECK(bone, 0)
return bone->getRotation();
}
void SpineBone::set_rotation(float v) {
SPINE_CHECK(bone,)
bone->setRotation(v);
}
float SpineBone::get_scale_x() {
SPINE_CHECK(bone, 0)
return bone->getScaleX();
}
void SpineBone::set_scale_x(float v) {
SPINE_CHECK(bone,)
bone->setScaleX(v);
}
float SpineBone::get_scale_y() {
SPINE_CHECK(bone, 0)
return bone->getScaleY();
}
void SpineBone::set_scale_y(float v) {
SPINE_CHECK(bone,)
bone->setScaleY(v);
}
float SpineBone::get_shear_x() {
SPINE_CHECK(bone, 0)
return bone->getShearX();
}
void SpineBone::set_shear_x(float v) {
SPINE_CHECK(bone,)
bone->setShearX(v);
}
float SpineBone::get_shear_y() {
SPINE_CHECK(bone, 0)
return bone->getShearY();
}
void SpineBone::set_shear_y(float v) {
SPINE_CHECK(bone,)
bone->setShearY(v);
}
float SpineBone::get_applied_rotation() {
SPINE_CHECK(bone, 0)
return bone->getAppliedRotation();
}
void SpineBone::set_applied_rotation(float v) {
SPINE_CHECK(bone,)
bone->setAppliedRotation(v);
}
float SpineBone::get_a_x() {
SPINE_CHECK(bone, 0)
return bone->getAX();
}
void SpineBone::set_a_x(float v) {
SPINE_CHECK(bone,)
bone->setAX(v);
}
float SpineBone::get_a_y() {
SPINE_CHECK(bone, 0)
return bone->getAY();
}
void SpineBone::set_a_y(float v) {
SPINE_CHECK(bone,)
bone->setAY(v);
}
float SpineBone::get_a_scale_x() {
SPINE_CHECK(bone, 0)
return bone->getAScaleX();
}
void SpineBone::set_a_scale_x(float v) {
SPINE_CHECK(bone,)
bone->setAScaleX(v);
}
float SpineBone::get_a_scale_y() {
SPINE_CHECK(bone, 0)
return bone->getAScaleY();
}
void SpineBone::set_a_scale_y(float v) {
SPINE_CHECK(bone,)
bone->setAScaleY(v);
}
float SpineBone::get_a_shear_x() {
SPINE_CHECK(bone, 0)
return bone->getAShearX();
}
void SpineBone::set_a_shear_x(float v) {
SPINE_CHECK(bone,)
bone->setAShearX(v);
}
float SpineBone::get_a_shear_y() {
SPINE_CHECK(bone, 0)
return bone->getAShearY();
}
void SpineBone::set_a_shear_y(float v) {
SPINE_CHECK(bone,)
bone->setAShearY(v);
}
float SpineBone::get_a() {
SPINE_CHECK(bone, 0)
return bone->getA();
}
void SpineBone::set_a(float v) {
SPINE_CHECK(bone,)
bone->setA(v);
}
float SpineBone::get_b() {
SPINE_CHECK(bone, 0)
return bone->getB();
}
void SpineBone::set_b(float v) {
SPINE_CHECK(bone,)
bone->setB(v);
}
float SpineBone::get_c() {
SPINE_CHECK(bone, 0)
return bone->getC();
}
void SpineBone::set_c(float v) {
SPINE_CHECK(bone,)
bone->setC(v);
}
float SpineBone::get_d() {
SPINE_CHECK(bone, 0)
return bone->getD();
}
void SpineBone::set_d(float v) {
SPINE_CHECK(bone,)
bone->setD(v);
}
float SpineBone::get_world_x() {
SPINE_CHECK(bone, 0)
return bone->getWorldX();
}
void SpineBone::set_world_x(float v) {
SPINE_CHECK(bone,)
bone->setWorldX(v);
}
float SpineBone::get_world_y() {
SPINE_CHECK(bone, 0)
return bone->getWorldY();
}
void SpineBone::set_world_y(float v) {
SPINE_CHECK(bone,)
bone->setWorldY(v);
}
float SpineBone::get_world_rotation_x() {
SPINE_CHECK(bone, 0)
return bone->getWorldRotationX();
}
float SpineBone::get_world_rotation_y() {
SPINE_CHECK(bone, 0)
return bone->getWorldRotationY();
}
float SpineBone::get_world_scale_x() {
SPINE_CHECK(bone, 0)
return bone->getWorldScaleX();
}
float SpineBone::get_world_scale_y() {
SPINE_CHECK(bone, 0)
return bone->getWorldScaleY();
}
bool SpineBone::is_active() {
SPINE_CHECK(bone, false)
return bone->isActive();
}
void SpineBone::set_active(bool v) {
SPINE_CHECK(bone,)
bone->setActive(v);
}
// External feature functions
void SpineBone::apply_world_transform_2d(Variant o) {
SPINE_CHECK(bone,)
if (o.get_type() == Variant::OBJECT) {
auto node = (Node *) o;
if (node->is_class("Node2D")) {
@ -366,75 +450,68 @@ void SpineBone::apply_world_transform_2d(Variant o) {
}
Transform2D SpineBone::get_godot_transform() {
if (get_spine_object() == nullptr)
return Transform2D();
SPINE_CHECK(bone, Transform2D())
Transform2D trans;
trans.translate(get_x(), -get_y());
// It seems that spine uses degree for rotation
trans.rotate(Math::deg2rad(-get_rotation()));
trans.scale(Size2(get_scale_x(), get_scale_y()));
return trans;
}
void SpineBone::set_godot_transform(Transform2D trans) {
if (get_spine_object() == nullptr)
return;
SPINE_CHECK(bone,)
Vector2 position = trans.get_origin();
position.y *= -1;
real_t rotation = trans.get_rotation();
rotation = Math::rad2deg(-rotation);
Vector2 scale = trans.get_scale();
Vector2 scale_x_y = trans.get_scale();
set_x(position.x);
set_y(position.y);
set_rotation(rotation);
set_scale_x(scale.x);
set_scale_y(scale.y);
set_scale_x(scale_x_y.x);
set_scale_y(scale_x_y.y);
}
Transform2D SpineBone::get_godot_global_transform() {
if (get_spine_object() == nullptr)
return Transform2D();
if (sprite == nullptr)
return get_godot_transform();
Transform2D res = sprite->get_transform();
res.translate(get_world_x(), -get_world_y());
res.rotate(Math::deg2rad(-get_world_rotation_x()));
res.scale(Vector2(get_world_scale_x(), get_world_scale_y()));
auto p = sprite->get_parent() ? Object::cast_to<CanvasItem>(sprite->get_parent()) : nullptr;
if (p) {
return p->get_global_transform() * res;
SPINE_CHECK(bone, Transform2D())
if (!sprite) return get_godot_transform();
Transform2D result = sprite->get_transform();
result.translate(get_world_x(), -get_world_y());
result.rotate(Math::deg2rad(-get_world_rotation_x()));
result.scale(Vector2(get_world_scale_x(), get_world_scale_y()));
auto parent = sprite->get_parent() ? Object::cast_to<CanvasItem>(sprite->get_parent()) : nullptr;
if (parent) {
return parent->get_global_transform() * result;
}
return res;
return result;
}
void SpineBone::set_godot_global_transform(Transform2D transform) {
if (get_spine_object() == nullptr)
return;
if (sprite == nullptr)
set_godot_transform(transform);
SPINE_CHECK(bone,)
if (!sprite) set_godot_transform(transform);
transform = sprite->get_global_transform().affine_inverse() * transform;
Vector2 position = transform.get_origin();
real_t rotation = transform.get_rotation();
Vector2 scale = transform.get_scale();
Vector2 scale_x_y = transform.get_scale();
position.y *= -1;
auto parent = get_parent();
if (parent.is_valid()) {
position = parent->world_to_local(position);
if (parent->get_world_scale_x() != 0)
scale.x /= parent->get_world_scale_x();
scale_x_y.x /= parent->get_world_scale_x();
else
print_error("The parent scale.x is zero.");
ERR_PRINT("The parent scale.x is zero.");
if (parent->get_world_scale_y() != 0)
scale.y /= parent->get_world_scale_y();
scale_x_y.y /= parent->get_world_scale_y();
else
print_error("The parent scale.y is zero.");
ERR_PRINT("The parent scale.y is zero.");
}
rotation = world_to_local_rotation(Math::rad2deg(-rotation));
set_x(position.x);
set_y(position.y);
set_rotation(rotation);
set_scale_x(scale.x);
set_scale_y(scale.y);
set_scale_x(scale_x_y.x);
set_scale_y(scale_x_y.y);
}

40
spine-godot/spine_godot/SpineBone.h
View File

@ -39,28 +39,24 @@ class SpineSkeleton;
class SpineSprite;
class SpineBone : public Reference {
GDCLASS(SpineBone, Reference);
GDCLASS(SpineBone, Reference)
protected:
static void _bind_methods();
private:
spine::Bone *bone;
SpineSprite* sprite;
SpineSprite *sprite;
public:
SpineBone();
~SpineBone();
inline void set_spine_object(spine::Bone *b) {
bone = b;
}
void set_spine_object(spine::Bone *_bone) { bone = _bone; }
inline spine::Bone *get_spine_object() {
return bone;
}
spine::Bone *get_spine_object() { return bone; }
void set_spine_sprite(SpineSprite* sprite);
void set_spine_sprite(SpineSprite* _sprite);
void update_world_transform();
@ -77,6 +73,7 @@ public:
void rotate_world(float degrees);
float get_world_to_local_rotation_x();
float get_world_to_local_rotation_y();
Ref<SpineBoneData> get_data();
@ -88,81 +85,106 @@ public:
Array get_children();
float get_x();
void set_x(float v);
float get_y();
void set_y(float v);
float get_rotation();
void set_rotation(float v);
float get_scale_x();
void set_scale_x(float v);
float get_scale_y();
void set_scale_y(float v);
float get_shear_x();
void set_shear_x(float v);
float get_shear_y();
void set_shear_y(float v);
float get_applied_rotation();
void set_applied_rotation(float v);
float get_a_x();
void set_a_x(float v);
float get_a_y();
void set_a_y(float v);
float get_a_scale_x();
void set_a_scale_x(float v);
float get_a_scale_y();
void set_a_scale_y(float v);
float get_a_shear_x();
void set_a_shear_x(float v);
float get_a_shear_y();
void set_a_shear_y(float v);
float get_a();
void set_a(float v);
float get_b();
void set_b(float v);
float get_c();
void set_c(float v);
float get_d();
void set_d(float v);
float get_world_x();
void set_world_x(float v);
float get_world_y();
void set_world_y(float v);
float get_world_rotation_x();
float get_world_rotation_y();
float get_world_scale_x();
float get_world_scale_y();
bool is_active();
void set_active(bool v);
// External feature functions
void apply_world_transform_2d(Variant o);
Transform2D get_godot_transform();
void set_godot_transform(Transform2D trans);
Transform2D get_godot_global_transform();
void set_godot_global_transform(Transform2D trans);
};