[godot] Clean-up SpineTransformConstraint.

spine-godot/spine_godot/SpineTransformConstraint.cpp

@@ -28,6 +28,7 @@
  *****************************************************************************/
 
 #include "SpineTransformConstraint.h"
+#include "SpineCommon.h"
 
 void SpineTransformConstraint::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("update"), &SpineTransformConstraint::update);
@@ -51,98 +52,121 @@ void SpineTransformConstraint::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_active", "v"), &SpineTransformConstraint::set_active);
 }
 
-SpineTransformConstraint::SpineTransformConstraint() : transform_constraint(NULL) {}
+SpineTransformConstraint::SpineTransformConstraint() : transform_constraint(nullptr) {
-SpineTransformConstraint::~SpineTransformConstraint() {}
+}
 
 void SpineTransformConstraint::update() {
+	SPINE_CHECK(transform_constraint,)
 	transform_constraint->update();
 }
 
 int SpineTransformConstraint::get_order() {
+	SPINE_CHECK(transform_constraint, 0)
 	return transform_constraint->getOrder();
 }
 
 Ref<SpineTransformConstraintData> SpineTransformConstraint::get_data() {
-	auto &d = transform_constraint->getData();
+	SPINE_CHECK(transform_constraint, nullptr)
-	Ref<SpineTransformConstraintData> gd_d(memnew(SpineTransformConstraintData));
+	auto &data = transform_constraint->getData();
-	gd_d->set_spine_object(&d);
+	Ref<SpineTransformConstraintData> data_ref(memnew(SpineTransformConstraintData));
-	return gd_d;
+	data_ref->set_spine_object(&data);
+	return data_ref;
 }
 
 Array SpineTransformConstraint::get_bones() {
-	auto &bs = transform_constraint->getBones();
+	Array result;
-	Array gd_bs;
+	SPINE_CHECK(transform_constraint, result)
-	gd_bs.resize(bs.size());
+	auto &bones = transform_constraint->getBones();
-	for (size_t i = 0; i < bs.size(); ++i) {
+	result.resize((int)bones.size());
-		auto b = bs[i];
+	for (int i = 0; i < bones.size(); ++i) {
-		if (b == NULL) gd_bs[i] = Ref<SpineBone>(NULL);
+		auto bone = bones[i];
-		Ref<SpineBone> gd_b(memnew(SpineBone));
+		Ref<SpineBone> bone_ref(memnew(SpineBone));
-		gd_b->set_spine_object(b);
+		bone_ref->set_spine_object(bone);
-		gd_bs[i] = gd_b;
+		result[i] = bone_ref;
 	}
-	return gd_bs;
+	return result;
 }
 
 Ref<SpineBone> SpineTransformConstraint::get_target() {
-	auto b = transform_constraint->getTarget();
+	SPINE_CHECK(transform_constraint, nullptr)
-	if (b == NULL) return NULL;
+	auto target = transform_constraint->getTarget();
-	Ref<SpineBone> gd_b(memnew(SpineBone));
+	if (!target) return nullptr;
-	gd_b->set_spine_object(b);
+	Ref<SpineBone> target_ref(memnew(SpineBone));
-	return gd_b;
+	target_ref->set_spine_object(target);
+	return target_ref;
 }
+
 void SpineTransformConstraint::set_target(Ref<SpineBone> v) {
-	if (v.is_valid()) {
+	SPINE_CHECK(transform_constraint,)
-		transform_constraint->setTarget(v->get_spine_object());
+	transform_constraint->setTarget(v.is_valid() ? v->get_spine_object() : nullptr);
-	} else {
-		transform_constraint->setTarget(NULL);
-	}
 }
 
 float SpineTransformConstraint::get_mix_rotate() {
+	SPINE_CHECK(transform_constraint, 0)
 	return transform_constraint->getMixRotate();
 }
+
 void SpineTransformConstraint::set_mix_rotate(float v) {
+	SPINE_CHECK(transform_constraint,)
 	transform_constraint->setMixRotate(v);
 }
 
 float SpineTransformConstraint::get_mix_x() {
+	SPINE_CHECK(transform_constraint, 0)
 	return transform_constraint->getMixX();
 }
+
 void SpineTransformConstraint::set_mix_x(float v) {
+	SPINE_CHECK(transform_constraint,)
 	transform_constraint->setMixX(v);
 }
 
 float SpineTransformConstraint::get_mix_y() {
+	SPINE_CHECK(transform_constraint, 0)
 	return transform_constraint->getMixY();
 }
+
 void SpineTransformConstraint::set_mix_y(float v) {
+	SPINE_CHECK(transform_constraint,)
 	transform_constraint->setMixY(v);
 }
 
 float SpineTransformConstraint::get_mix_scale_x() {
+	SPINE_CHECK(transform_constraint, 0)
 	return transform_constraint->getMixScaleX();
 }
+
 void SpineTransformConstraint::set_mix_scale_x(float v) {
+	SPINE_CHECK(transform_constraint,)
 	transform_constraint->setMixScaleX(v);
 }
 
 float SpineTransformConstraint::get_mix_scale_y() {
+	SPINE_CHECK(transform_constraint, 0)
 	return transform_constraint->getMixScaleY();
 }
+
 void SpineTransformConstraint::set_mix_scale_y(float v) {
+	SPINE_CHECK(transform_constraint,)
 	transform_constraint->setMixScaleY(v);
 }
 
 float SpineTransformConstraint::get_mix_shear_y() {
+	SPINE_CHECK(transform_constraint, 0)
 	return transform_constraint->getMixShearY();
 }
+
 void SpineTransformConstraint::set_mix_shear_y(float v) {
+	SPINE_CHECK(transform_constraint,)
 	transform_constraint->setMixShearY(v);
 }
 
 bool SpineTransformConstraint::is_active() {
+	SPINE_CHECK(transform_constraint, false)
 	return transform_constraint->isActive();
 }
+
 void SpineTransformConstraint::set_active(bool v) {
+	SPINE_CHECK(transform_constraint,)
 	transform_constraint->setActive(v);
 }

spine-godot/spine_godot/SpineTransformConstraint.h

@@ -30,10 +30,6 @@
 #ifndef GODOT_SPINETRANSFORMCONSTRAINT_H
 #define GODOT_SPINETRANSFORMCONSTRAINT_H
 
-#include "core/variant_parser.h"
-
-#include <spine/spine.h>
-
 #include "SpineTransformConstraintData.h"
 #include "SpineBone.h"
 
@@ -48,14 +44,9 @@ private:
 
 public:
 	SpineTransformConstraint();
-	~SpineTransformConstraint();
 
-	inline void set_spine_object(spine::TransformConstraint *tc) {
+	void set_spine_object(spine::TransformConstraint *tc) { transform_constraint = tc; }
-		transform_constraint = tc;
+	spine::TransformConstraint *get_spine_object() { return transform_constraint; }
-	}
-	inline spine::TransformConstraint *get_spine_object() {
-		return transform_constraint;
-	}
 
 	void update();
 
@@ -66,27 +57,35 @@ public:
 	Array get_bones();
 
 	Ref<SpineBone> get_target();
+
 	void set_target(Ref<SpineBone> v);
 
 	float get_mix_rotate();
+
 	void set_mix_rotate(float v);
 
 	float get_mix_x();
+
 	void set_mix_x(float v);
 
 	float get_mix_y();
+
 	void set_mix_y(float v);
 
 	float get_mix_scale_x();
+
 	void set_mix_scale_x(float v);
 
 	float get_mix_scale_y();
+
 	void set_mix_scale_y(float v);
 
 	float get_mix_shear_y();
+
 	void set_mix_shear_y(float v);
 
 	bool is_active();
+
 	void set_active(bool v);
 };