From b64da9b6373416e2e3ca9b8d98c77cdb0ff1f71d Mon Sep 17 00:00:00 2001 From: badlogic Date: Wed, 10 Sep 2025 14:28:08 +0200 Subject: [PATCH] [cpp] Introduce base classes for constraints without SP_API, from which concrete clsases derrive MSVC issue. SP_API can't be used on classes with methods inherited from templated classes like ConstraintGeneric::getData(). we need an intermediate class that gets the method instantiation, and derrive from that instead. --- spine-c/include/spine-c.h | 5 ++ spine-c/src/generated/ik_constraint.cpp | 31 +++---- spine-c/src/generated/ik_constraint.h | 2 +- spine-c/src/generated/ik_constraint_base.cpp | 84 +++++++++++++++++++ spine-c/src/generated/ik_constraint_base.h | 32 +++++++ spine-c/src/generated/path_constraint.cpp | 23 ++--- .../src/generated/path_constraint_base.cpp | 84 +++++++++++++++++++ spine-c/src/generated/path_constraint_base.h | 32 +++++++ spine-c/src/generated/physics_constraint.cpp | 24 ++---- .../src/generated/physics_constraint_base.cpp | 84 +++++++++++++++++++ .../src/generated/physics_constraint_base.h | 32 +++++++ spine-c/src/generated/slider.cpp | 16 ++-- spine-c/src/generated/slider_base.cpp | 72 ++++++++++++++++ spine-c/src/generated/slider_base.h | 32 +++++++ .../src/generated/transform_constraint.cpp | 24 ++---- .../generated/transform_constraint_base.cpp | 84 +++++++++++++++++++ .../src/generated/transform_constraint_base.h | 32 +++++++ spine-c/src/generated/types.h | 5 ++ spine-cpp/include/spine/IkConstraint.h | 11 ++- spine-cpp/include/spine/PathConstraint.h | 12 ++- spine-cpp/include/spine/PhysicsConstraint.h | 10 ++- spine-cpp/include/spine/Slider.h | 9 +- spine-cpp/include/spine/TransformConstraint.h | 10 ++- spine-cpp/src/spine/IkConstraint.cpp | 7 +- spine-cpp/src/spine/PathConstraint.cpp | 7 +- spine-cpp/src/spine/PhysicsConstraint.cpp | 6 +- spine-cpp/src/spine/Slider.cpp | 2 +- spine-cpp/src/spine/TransformConstraint.cpp | 3 +- 28 files changed, 672 insertions(+), 103 deletions(-) create mode 100644 spine-c/src/generated/ik_constraint_base.cpp create mode 100644 spine-c/src/generated/ik_constraint_base.h create mode 100644 spine-c/src/generated/path_constraint_base.cpp create mode 100644 spine-c/src/generated/path_constraint_base.h create mode 100644 spine-c/src/generated/physics_constraint_base.cpp create mode 100644 spine-c/src/generated/physics_constraint_base.h create mode 100644 spine-c/src/generated/slider_base.cpp create mode 100644 spine-c/src/generated/slider_base.h create mode 100644 spine-c/src/generated/transform_constraint_base.cpp create mode 100644 spine-c/src/generated/transform_constraint_base.h diff --git a/spine-c/include/spine-c.h b/spine-c/include/spine-c.h index b28362293..3fcf0c4c7 100644 --- a/spine-c/include/spine-c.h +++ b/spine-c/include/spine-c.h @@ -81,6 +81,7 @@ #include "../src/generated/from_x.h" #include "../src/generated/from_y.h" #include "../src/generated/ik_constraint.h" +#include "../src/generated/ik_constraint_base.h" #include "../src/generated/ik_constraint_data.h" #include "../src/generated/ik_constraint_pose.h" #include "../src/generated/ik_constraint_timeline.h" @@ -89,12 +90,14 @@ #include "../src/generated/mesh_attachment.h" #include "../src/generated/path_attachment.h" #include "../src/generated/path_constraint.h" +#include "../src/generated/path_constraint_base.h" #include "../src/generated/path_constraint_data.h" #include "../src/generated/path_constraint_mix_timeline.h" #include "../src/generated/path_constraint_pose.h" #include "../src/generated/path_constraint_position_timeline.h" #include "../src/generated/path_constraint_spacing_timeline.h" #include "../src/generated/physics_constraint.h" +#include "../src/generated/physics_constraint_base.h" #include "../src/generated/physics_constraint_damping_timeline.h" #include "../src/generated/physics_constraint_data.h" #include "../src/generated/physics_constraint_gravity_timeline.h" @@ -136,6 +139,7 @@ #include "../src/generated/skeleton_renderer.h" #include "../src/generated/skin.h" #include "../src/generated/slider.h" +#include "../src/generated/slider_base.h" #include "../src/generated/slider_data.h" #include "../src/generated/slider_mix_timeline.h" #include "../src/generated/slider_pose.h" @@ -156,6 +160,7 @@ #include "../src/generated/to_y.h" #include "../src/generated/track_entry.h" #include "../src/generated/transform_constraint.h" +#include "../src/generated/transform_constraint_base.h" #include "../src/generated/transform_constraint_data.h" #include "../src/generated/transform_constraint_pose.h" #include "../src/generated/transform_constraint_timeline.h" diff --git a/spine-c/src/generated/ik_constraint.cpp b/spine-c/src/generated/ik_constraint.cpp index 62b9589dc..3dc6ce1dd 100644 --- a/spine-c/src/generated/ik_constraint.cpp +++ b/spine-c/src/generated/ik_constraint.cpp @@ -36,11 +36,6 @@ bool spine_ik_constraint_is_source_active(spine_ik_constraint self) { return _self->isSourceActive(); } -spine_ik_constraint_data spine_ik_constraint_get_data(spine_ik_constraint self) { - IkConstraint *_self = (IkConstraint *) self; - return (spine_ik_constraint_data) &_self->getData(); -} - spine_array_bone_pose spine_ik_constraint_get_bones(spine_ik_constraint self) { IkConstraint *_self = (IkConstraint *) self; return (spine_array_bone_pose) &_self->getBones(); @@ -67,45 +62,43 @@ void spine_ik_constraint_apply_2(spine_skeleton skeleton, spine_bone_pose parent softness, mix); } +spine_ik_constraint_data spine_ik_constraint_get_data(spine_ik_constraint self) { + IkConstraintBase *_self = (IkConstraintBase *) (IkConstraint *) self; + return (spine_ik_constraint_data) &_self->getData(); +} + spine_ik_constraint_pose spine_ik_constraint_get_pose(spine_ik_constraint self) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (IkConstraint *) self; + IkConstraintBase *_self = (IkConstraintBase *) (IkConstraint *) self; return (spine_ik_constraint_pose) &_self->getPose(); } spine_ik_constraint_pose spine_ik_constraint_get_applied_pose(spine_ik_constraint self) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (IkConstraint *) self; + IkConstraintBase *_self = (IkConstraintBase *) (IkConstraint *) self; return (spine_ik_constraint_pose) &_self->getAppliedPose(); } void spine_ik_constraint_reset_constrained(spine_ik_constraint self) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (IkConstraint *) self; + IkConstraintBase *_self = (IkConstraintBase *) (IkConstraint *) self; _self->resetConstrained(); } void spine_ik_constraint_constrained(spine_ik_constraint self) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (IkConstraint *) self; + IkConstraintBase *_self = (IkConstraintBase *) (IkConstraint *) self; _self->constrained(); } bool spine_ik_constraint_is_pose_equal_to_applied(spine_ik_constraint self) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (IkConstraint *) self; + IkConstraintBase *_self = (IkConstraintBase *) (IkConstraint *) self; return _self->isPoseEqualToApplied(); } bool spine_ik_constraint_is_active(spine_ik_constraint self) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (IkConstraint *) self; + IkConstraintBase *_self = (IkConstraintBase *) (IkConstraint *) self; return _self->isActive(); } void spine_ik_constraint_set_active(spine_ik_constraint self, bool active) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (IkConstraint *) self; + IkConstraintBase *_self = (IkConstraintBase *) (IkConstraint *) self; _self->setActive(active); } diff --git a/spine-c/src/generated/ik_constraint.h b/spine-c/src/generated/ik_constraint.h index 9752fe33b..4c7eb6fce 100644 --- a/spine-c/src/generated/ik_constraint.h +++ b/spine-c/src/generated/ik_constraint.h @@ -18,7 +18,6 @@ SPINE_C_API spine_ik_constraint spine_ik_constraint_copy(spine_ik_constraint sel SPINE_C_API void spine_ik_constraint_update(spine_ik_constraint self, spine_skeleton skeleton, spine_physics physics); SPINE_C_API void spine_ik_constraint_sort(spine_ik_constraint self, spine_skeleton skeleton); SPINE_C_API bool spine_ik_constraint_is_source_active(spine_ik_constraint self); -SPINE_C_API spine_ik_constraint_data spine_ik_constraint_get_data(spine_ik_constraint self); SPINE_C_API spine_array_bone_pose spine_ik_constraint_get_bones(spine_ik_constraint self); SPINE_C_API spine_bone spine_ik_constraint_get_target(spine_ik_constraint self); SPINE_C_API void spine_ik_constraint_set_target(spine_ik_constraint self, spine_bone inValue); @@ -26,6 +25,7 @@ SPINE_C_API void spine_ik_constraint_apply_1(spine_skeleton skeleton, spine_bone bool uniform, float mix); SPINE_C_API void spine_ik_constraint_apply_2(spine_skeleton skeleton, spine_bone_pose parent, spine_bone_pose child, float targetX, float targetY, int bendDirection, bool stretch, bool uniform, float softness, float mix); +SPINE_C_API spine_ik_constraint_data spine_ik_constraint_get_data(spine_ik_constraint self); SPINE_C_API spine_ik_constraint_pose spine_ik_constraint_get_pose(spine_ik_constraint self); SPINE_C_API spine_ik_constraint_pose spine_ik_constraint_get_applied_pose(spine_ik_constraint self); SPINE_C_API void spine_ik_constraint_reset_constrained(spine_ik_constraint self); diff --git a/spine-c/src/generated/ik_constraint_base.cpp b/spine-c/src/generated/ik_constraint_base.cpp new file mode 100644 index 000000000..f0dcfd8e3 --- /dev/null +++ b/spine-c/src/generated/ik_constraint_base.cpp @@ -0,0 +1,84 @@ +#include "ik_constraint_base.h" +#include + +using namespace spine; + +void spine_ik_constraint_base_dispose(spine_ik_constraint_base self) { + delete (IkConstraintBase *) self; +} + +spine_ik_constraint_data spine_ik_constraint_base_get_data(spine_ik_constraint_base self) { + ConstraintGeneric + *_self = (ConstraintGeneric *) (IkConstraintBase *) self; + return (spine_ik_constraint_data) &_self->getData(); +} + +spine_ik_constraint_pose spine_ik_constraint_base_get_pose(spine_ik_constraint_base self) { + ConstraintGeneric + *_self = (ConstraintGeneric *) (IkConstraintBase *) self; + return (spine_ik_constraint_pose) &_self->getPose(); +} + +spine_ik_constraint_pose spine_ik_constraint_base_get_applied_pose(spine_ik_constraint_base self) { + ConstraintGeneric + *_self = (ConstraintGeneric *) (IkConstraintBase *) self; + return (spine_ik_constraint_pose) &_self->getAppliedPose(); +} + +void spine_ik_constraint_base_reset_constrained(spine_ik_constraint_base self) { + ConstraintGeneric + *_self = (ConstraintGeneric *) (IkConstraintBase *) self; + _self->resetConstrained(); +} + +void spine_ik_constraint_base_constrained(spine_ik_constraint_base self) { + ConstraintGeneric + *_self = (ConstraintGeneric *) (IkConstraintBase *) self; + _self->constrained(); +} + +bool spine_ik_constraint_base_is_pose_equal_to_applied(spine_ik_constraint_base self) { + ConstraintGeneric + *_self = (ConstraintGeneric *) (IkConstraintBase *) self; + return _self->isPoseEqualToApplied(); +} + +bool spine_ik_constraint_base_is_active(spine_ik_constraint_base self) { + ConstraintGeneric + *_self = (ConstraintGeneric *) (IkConstraintBase *) self; + return _self->isActive(); +} + +void spine_ik_constraint_base_set_active(spine_ik_constraint_base self, bool active) { + ConstraintGeneric + *_self = (ConstraintGeneric *) (IkConstraintBase *) self; + _self->setActive(active); +} + +spine_rtti spine_ik_constraint_base_get_rtti(spine_ik_constraint_base self) { + ConstraintGeneric + *_self = (ConstraintGeneric *) (IkConstraintBase *) self; + return (spine_rtti) &_self->getRTTI(); +} + +void spine_ik_constraint_base_sort(spine_ik_constraint_base self, spine_skeleton skeleton) { + ConstraintGeneric + *_self = (ConstraintGeneric *) (IkConstraintBase *) self; + _self->sort(*((Skeleton *) skeleton)); +} + +bool spine_ik_constraint_base_is_source_active(spine_ik_constraint_base self) { + ConstraintGeneric + *_self = (ConstraintGeneric *) (IkConstraintBase *) self; + return _self->isSourceActive(); +} + +void spine_ik_constraint_base_update(spine_ik_constraint_base self, spine_skeleton skeleton, spine_physics physics) { + ConstraintGeneric + *_self = (ConstraintGeneric *) (IkConstraintBase *) self; + _self->update(*((Skeleton *) skeleton), (Physics) physics); +} + +spine_rtti spine_ik_constraint_base_rtti(void) { + return (spine_rtti) &IkConstraintBase::rtti; +} diff --git a/spine-c/src/generated/ik_constraint_base.h b/spine-c/src/generated/ik_constraint_base.h new file mode 100644 index 000000000..72ad0c36c --- /dev/null +++ b/spine-c/src/generated/ik_constraint_base.h @@ -0,0 +1,32 @@ +#ifndef SPINE_SPINE_IK_CONSTRAINT_BASE_H +#define SPINE_SPINE_IK_CONSTRAINT_BASE_H + +#include "../base.h" +#include "types.h" +#include "arrays.h" + +#ifdef __cplusplus +extern "C" { +#endif + +SPINE_C_API void spine_ik_constraint_base_dispose(spine_ik_constraint_base self); + +SPINE_C_API spine_ik_constraint_data spine_ik_constraint_base_get_data(spine_ik_constraint_base self); +SPINE_C_API spine_ik_constraint_pose spine_ik_constraint_base_get_pose(spine_ik_constraint_base self); +SPINE_C_API spine_ik_constraint_pose spine_ik_constraint_base_get_applied_pose(spine_ik_constraint_base self); +SPINE_C_API void spine_ik_constraint_base_reset_constrained(spine_ik_constraint_base self); +SPINE_C_API void spine_ik_constraint_base_constrained(spine_ik_constraint_base self); +SPINE_C_API bool spine_ik_constraint_base_is_pose_equal_to_applied(spine_ik_constraint_base self); +SPINE_C_API bool spine_ik_constraint_base_is_active(spine_ik_constraint_base self); +SPINE_C_API void spine_ik_constraint_base_set_active(spine_ik_constraint_base self, bool active); +SPINE_C_API spine_rtti spine_ik_constraint_base_get_rtti(spine_ik_constraint_base self); +SPINE_C_API void spine_ik_constraint_base_sort(spine_ik_constraint_base self, spine_skeleton skeleton); +SPINE_C_API bool spine_ik_constraint_base_is_source_active(spine_ik_constraint_base self); +SPINE_C_API void spine_ik_constraint_base_update(spine_ik_constraint_base self, spine_skeleton skeleton, spine_physics physics); +SPINE_C_API spine_rtti spine_ik_constraint_base_rtti(void); + +#ifdef __cplusplus +} +#endif + +#endif /* SPINE_SPINE_IK_CONSTRAINT_BASE_H */ diff --git a/spine-c/src/generated/path_constraint.cpp b/spine-c/src/generated/path_constraint.cpp index 65a61c164..2093b60b8 100644 --- a/spine-c/src/generated/path_constraint.cpp +++ b/spine-c/src/generated/path_constraint.cpp @@ -52,49 +52,42 @@ void spine_path_constraint_set_slot(spine_path_constraint self, spine_slot slot) } spine_path_constraint_data spine_path_constraint_get_data(spine_path_constraint self) { - PathConstraint *_self = (PathConstraint *) self; + PathConstraintBase *_self = (PathConstraintBase *) (PathConstraint *) self; return (spine_path_constraint_data) &_self->getData(); } spine_path_constraint_pose spine_path_constraint_get_pose(spine_path_constraint self) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (PathConstraint *) self; + PathConstraintBase *_self = (PathConstraintBase *) (PathConstraint *) self; return (spine_path_constraint_pose) &_self->getPose(); } spine_path_constraint_pose spine_path_constraint_get_applied_pose(spine_path_constraint self) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (PathConstraint *) self; + PathConstraintBase *_self = (PathConstraintBase *) (PathConstraint *) self; return (spine_path_constraint_pose) &_self->getAppliedPose(); } void spine_path_constraint_reset_constrained(spine_path_constraint self) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (PathConstraint *) self; + PathConstraintBase *_self = (PathConstraintBase *) (PathConstraint *) self; _self->resetConstrained(); } void spine_path_constraint_constrained(spine_path_constraint self) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (PathConstraint *) self; + PathConstraintBase *_self = (PathConstraintBase *) (PathConstraint *) self; _self->constrained(); } bool spine_path_constraint_is_pose_equal_to_applied(spine_path_constraint self) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (PathConstraint *) self; + PathConstraintBase *_self = (PathConstraintBase *) (PathConstraint *) self; return _self->isPoseEqualToApplied(); } bool spine_path_constraint_is_active(spine_path_constraint self) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (PathConstraint *) self; + PathConstraintBase *_self = (PathConstraintBase *) (PathConstraint *) self; return _self->isActive(); } void spine_path_constraint_set_active(spine_path_constraint self, bool active) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (PathConstraint *) self; + PathConstraintBase *_self = (PathConstraintBase *) (PathConstraint *) self; _self->setActive(active); } diff --git a/spine-c/src/generated/path_constraint_base.cpp b/spine-c/src/generated/path_constraint_base.cpp new file mode 100644 index 000000000..2804d54fc --- /dev/null +++ b/spine-c/src/generated/path_constraint_base.cpp @@ -0,0 +1,84 @@ +#include "path_constraint_base.h" +#include + +using namespace spine; + +void spine_path_constraint_base_dispose(spine_path_constraint_base self) { + delete (PathConstraintBase *) self; +} + +spine_path_constraint_data spine_path_constraint_base_get_data(spine_path_constraint_base self) { + ConstraintGeneric + *_self = (ConstraintGeneric *) (PathConstraintBase *) self; + return (spine_path_constraint_data) &_self->getData(); +} + +spine_path_constraint_pose spine_path_constraint_base_get_pose(spine_path_constraint_base self) { + ConstraintGeneric + *_self = (ConstraintGeneric *) (PathConstraintBase *) self; + return (spine_path_constraint_pose) &_self->getPose(); +} + +spine_path_constraint_pose spine_path_constraint_base_get_applied_pose(spine_path_constraint_base self) { + ConstraintGeneric + *_self = (ConstraintGeneric *) (PathConstraintBase *) self; + return (spine_path_constraint_pose) &_self->getAppliedPose(); +} + +void spine_path_constraint_base_reset_constrained(spine_path_constraint_base self) { + ConstraintGeneric + *_self = (ConstraintGeneric *) (PathConstraintBase *) self; + _self->resetConstrained(); +} + +void spine_path_constraint_base_constrained(spine_path_constraint_base self) { + ConstraintGeneric + *_self = (ConstraintGeneric *) (PathConstraintBase *) self; + _self->constrained(); +} + +bool spine_path_constraint_base_is_pose_equal_to_applied(spine_path_constraint_base self) { + ConstraintGeneric + *_self = (ConstraintGeneric *) (PathConstraintBase *) self; + return _self->isPoseEqualToApplied(); +} + +bool spine_path_constraint_base_is_active(spine_path_constraint_base self) { + ConstraintGeneric + *_self = (ConstraintGeneric *) (PathConstraintBase *) self; + return _self->isActive(); +} + +void spine_path_constraint_base_set_active(spine_path_constraint_base self, bool active) { + ConstraintGeneric + *_self = (ConstraintGeneric *) (PathConstraintBase *) self; + _self->setActive(active); +} + +spine_rtti spine_path_constraint_base_get_rtti(spine_path_constraint_base self) { + ConstraintGeneric + *_self = (ConstraintGeneric *) (PathConstraintBase *) self; + return (spine_rtti) &_self->getRTTI(); +} + +void spine_path_constraint_base_sort(spine_path_constraint_base self, spine_skeleton skeleton) { + ConstraintGeneric + *_self = (ConstraintGeneric *) (PathConstraintBase *) self; + _self->sort(*((Skeleton *) skeleton)); +} + +bool spine_path_constraint_base_is_source_active(spine_path_constraint_base self) { + ConstraintGeneric + *_self = (ConstraintGeneric *) (PathConstraintBase *) self; + return _self->isSourceActive(); +} + +void spine_path_constraint_base_update(spine_path_constraint_base self, spine_skeleton skeleton, spine_physics physics) { + ConstraintGeneric + *_self = (ConstraintGeneric *) (PathConstraintBase *) self; + _self->update(*((Skeleton *) skeleton), (Physics) physics); +} + +spine_rtti spine_path_constraint_base_rtti(void) { + return (spine_rtti) &PathConstraintBase::rtti; +} diff --git a/spine-c/src/generated/path_constraint_base.h b/spine-c/src/generated/path_constraint_base.h new file mode 100644 index 000000000..fc4c933be --- /dev/null +++ b/spine-c/src/generated/path_constraint_base.h @@ -0,0 +1,32 @@ +#ifndef SPINE_SPINE_PATH_CONSTRAINT_BASE_H +#define SPINE_SPINE_PATH_CONSTRAINT_BASE_H + +#include "../base.h" +#include "types.h" +#include "arrays.h" + +#ifdef __cplusplus +extern "C" { +#endif + +SPINE_C_API void spine_path_constraint_base_dispose(spine_path_constraint_base self); + +SPINE_C_API spine_path_constraint_data spine_path_constraint_base_get_data(spine_path_constraint_base self); +SPINE_C_API spine_path_constraint_pose spine_path_constraint_base_get_pose(spine_path_constraint_base self); +SPINE_C_API spine_path_constraint_pose spine_path_constraint_base_get_applied_pose(spine_path_constraint_base self); +SPINE_C_API void spine_path_constraint_base_reset_constrained(spine_path_constraint_base self); +SPINE_C_API void spine_path_constraint_base_constrained(spine_path_constraint_base self); +SPINE_C_API bool spine_path_constraint_base_is_pose_equal_to_applied(spine_path_constraint_base self); +SPINE_C_API bool spine_path_constraint_base_is_active(spine_path_constraint_base self); +SPINE_C_API void spine_path_constraint_base_set_active(spine_path_constraint_base self, bool active); +SPINE_C_API spine_rtti spine_path_constraint_base_get_rtti(spine_path_constraint_base self); +SPINE_C_API void spine_path_constraint_base_sort(spine_path_constraint_base self, spine_skeleton skeleton); +SPINE_C_API bool spine_path_constraint_base_is_source_active(spine_path_constraint_base self); +SPINE_C_API void spine_path_constraint_base_update(spine_path_constraint_base self, spine_skeleton skeleton, spine_physics physics); +SPINE_C_API spine_rtti spine_path_constraint_base_rtti(void); + +#ifdef __cplusplus +} +#endif + +#endif /* SPINE_SPINE_PATH_CONSTRAINT_BASE_H */ diff --git a/spine-c/src/generated/physics_constraint.cpp b/spine-c/src/generated/physics_constraint.cpp index 148683bf3..573863102 100644 --- a/spine-c/src/generated/physics_constraint.cpp +++ b/spine-c/src/generated/physics_constraint.cpp @@ -62,50 +62,42 @@ void spine_physics_constraint_set_bone(spine_physics_constraint self, spine_bone } spine_physics_constraint_data spine_physics_constraint_get_data(spine_physics_constraint self) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (PhysicsConstraint *) self; + PhysicsConstraintBase *_self = (PhysicsConstraintBase *) (PhysicsConstraint *) self; return (spine_physics_constraint_data) &_self->getData(); } spine_physics_constraint_pose spine_physics_constraint_get_pose(spine_physics_constraint self) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (PhysicsConstraint *) self; + PhysicsConstraintBase *_self = (PhysicsConstraintBase *) (PhysicsConstraint *) self; return (spine_physics_constraint_pose) &_self->getPose(); } spine_physics_constraint_pose spine_physics_constraint_get_applied_pose(spine_physics_constraint self) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (PhysicsConstraint *) self; + PhysicsConstraintBase *_self = (PhysicsConstraintBase *) (PhysicsConstraint *) self; return (spine_physics_constraint_pose) &_self->getAppliedPose(); } void spine_physics_constraint_reset_constrained(spine_physics_constraint self) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (PhysicsConstraint *) self; + PhysicsConstraintBase *_self = (PhysicsConstraintBase *) (PhysicsConstraint *) self; _self->resetConstrained(); } void spine_physics_constraint_constrained(spine_physics_constraint self) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (PhysicsConstraint *) self; + PhysicsConstraintBase *_self = (PhysicsConstraintBase *) (PhysicsConstraint *) self; _self->constrained(); } bool spine_physics_constraint_is_pose_equal_to_applied(spine_physics_constraint self) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (PhysicsConstraint *) self; + PhysicsConstraintBase *_self = (PhysicsConstraintBase *) (PhysicsConstraint *) self; return _self->isPoseEqualToApplied(); } bool spine_physics_constraint_is_active(spine_physics_constraint self) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (PhysicsConstraint *) self; + PhysicsConstraintBase *_self = (PhysicsConstraintBase *) (PhysicsConstraint *) self; return _self->isActive(); } void spine_physics_constraint_set_active(spine_physics_constraint self, bool active) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (PhysicsConstraint *) self; + PhysicsConstraintBase *_self = (PhysicsConstraintBase *) (PhysicsConstraint *) self; _self->setActive(active); } diff --git a/spine-c/src/generated/physics_constraint_base.cpp b/spine-c/src/generated/physics_constraint_base.cpp new file mode 100644 index 000000000..108079119 --- /dev/null +++ b/spine-c/src/generated/physics_constraint_base.cpp @@ -0,0 +1,84 @@ +#include "physics_constraint_base.h" +#include + +using namespace spine; + +void spine_physics_constraint_base_dispose(spine_physics_constraint_base self) { + delete (PhysicsConstraintBase *) self; +} + +spine_physics_constraint_data spine_physics_constraint_base_get_data(spine_physics_constraint_base self) { + ConstraintGeneric + *_self = (ConstraintGeneric *) (PhysicsConstraintBase *) self; + return (spine_physics_constraint_data) &_self->getData(); +} + +spine_physics_constraint_pose spine_physics_constraint_base_get_pose(spine_physics_constraint_base self) { + ConstraintGeneric + *_self = (ConstraintGeneric *) (PhysicsConstraintBase *) self; + return (spine_physics_constraint_pose) &_self->getPose(); +} + +spine_physics_constraint_pose spine_physics_constraint_base_get_applied_pose(spine_physics_constraint_base self) { + ConstraintGeneric + *_self = (ConstraintGeneric *) (PhysicsConstraintBase *) self; + return (spine_physics_constraint_pose) &_self->getAppliedPose(); +} + +void spine_physics_constraint_base_reset_constrained(spine_physics_constraint_base self) { + ConstraintGeneric + *_self = (ConstraintGeneric *) (PhysicsConstraintBase *) self; + _self->resetConstrained(); +} + +void spine_physics_constraint_base_constrained(spine_physics_constraint_base self) { + ConstraintGeneric + *_self = (ConstraintGeneric *) (PhysicsConstraintBase *) self; + _self->constrained(); +} + +bool spine_physics_constraint_base_is_pose_equal_to_applied(spine_physics_constraint_base self) { + ConstraintGeneric + *_self = (ConstraintGeneric *) (PhysicsConstraintBase *) self; + return _self->isPoseEqualToApplied(); +} + +bool spine_physics_constraint_base_is_active(spine_physics_constraint_base self) { + ConstraintGeneric + *_self = (ConstraintGeneric *) (PhysicsConstraintBase *) self; + return _self->isActive(); +} + +void spine_physics_constraint_base_set_active(spine_physics_constraint_base self, bool active) { + ConstraintGeneric + *_self = (ConstraintGeneric *) (PhysicsConstraintBase *) self; + _self->setActive(active); +} + +spine_rtti spine_physics_constraint_base_get_rtti(spine_physics_constraint_base self) { + ConstraintGeneric + *_self = (ConstraintGeneric *) (PhysicsConstraintBase *) self; + return (spine_rtti) &_self->getRTTI(); +} + +void spine_physics_constraint_base_sort(spine_physics_constraint_base self, spine_skeleton skeleton) { + ConstraintGeneric + *_self = (ConstraintGeneric *) (PhysicsConstraintBase *) self; + _self->sort(*((Skeleton *) skeleton)); +} + +bool spine_physics_constraint_base_is_source_active(spine_physics_constraint_base self) { + ConstraintGeneric + *_self = (ConstraintGeneric *) (PhysicsConstraintBase *) self; + return _self->isSourceActive(); +} + +void spine_physics_constraint_base_update(spine_physics_constraint_base self, spine_skeleton skeleton, spine_physics physics) { + ConstraintGeneric + *_self = (ConstraintGeneric *) (PhysicsConstraintBase *) self; + _self->update(*((Skeleton *) skeleton), (Physics) physics); +} + +spine_rtti spine_physics_constraint_base_rtti(void) { + return (spine_rtti) &PhysicsConstraintBase::rtti; +} diff --git a/spine-c/src/generated/physics_constraint_base.h b/spine-c/src/generated/physics_constraint_base.h new file mode 100644 index 000000000..87d775dc9 --- /dev/null +++ b/spine-c/src/generated/physics_constraint_base.h @@ -0,0 +1,32 @@ +#ifndef SPINE_SPINE_PHYSICS_CONSTRAINT_BASE_H +#define SPINE_SPINE_PHYSICS_CONSTRAINT_BASE_H + +#include "../base.h" +#include "types.h" +#include "arrays.h" + +#ifdef __cplusplus +extern "C" { +#endif + +SPINE_C_API void spine_physics_constraint_base_dispose(spine_physics_constraint_base self); + +SPINE_C_API spine_physics_constraint_data spine_physics_constraint_base_get_data(spine_physics_constraint_base self); +SPINE_C_API spine_physics_constraint_pose spine_physics_constraint_base_get_pose(spine_physics_constraint_base self); +SPINE_C_API spine_physics_constraint_pose spine_physics_constraint_base_get_applied_pose(spine_physics_constraint_base self); +SPINE_C_API void spine_physics_constraint_base_reset_constrained(spine_physics_constraint_base self); +SPINE_C_API void spine_physics_constraint_base_constrained(spine_physics_constraint_base self); +SPINE_C_API bool spine_physics_constraint_base_is_pose_equal_to_applied(spine_physics_constraint_base self); +SPINE_C_API bool spine_physics_constraint_base_is_active(spine_physics_constraint_base self); +SPINE_C_API void spine_physics_constraint_base_set_active(spine_physics_constraint_base self, bool active); +SPINE_C_API spine_rtti spine_physics_constraint_base_get_rtti(spine_physics_constraint_base self); +SPINE_C_API void spine_physics_constraint_base_sort(spine_physics_constraint_base self, spine_skeleton skeleton); +SPINE_C_API bool spine_physics_constraint_base_is_source_active(spine_physics_constraint_base self); +SPINE_C_API void spine_physics_constraint_base_update(spine_physics_constraint_base self, spine_skeleton skeleton, spine_physics physics); +SPINE_C_API spine_rtti spine_physics_constraint_base_rtti(void); + +#ifdef __cplusplus +} +#endif + +#endif /* SPINE_SPINE_PHYSICS_CONSTRAINT_BASE_H */ diff --git a/spine-c/src/generated/slider.cpp b/spine-c/src/generated/slider.cpp index 2463018b5..39cc7460f 100644 --- a/spine-c/src/generated/slider.cpp +++ b/spine-c/src/generated/slider.cpp @@ -47,42 +47,42 @@ void spine_slider_set_bone(spine_slider self, spine_bone bone) { } spine_slider_data spine_slider_get_data(spine_slider self) { - ConstraintGeneric *_self = (ConstraintGeneric *) (Slider *) self; + SliderBase *_self = (SliderBase *) (Slider *) self; return (spine_slider_data) &_self->getData(); } spine_slider_pose spine_slider_get_pose(spine_slider self) { - ConstraintGeneric *_self = (ConstraintGeneric *) (Slider *) self; + SliderBase *_self = (SliderBase *) (Slider *) self; return (spine_slider_pose) &_self->getPose(); } spine_slider_pose spine_slider_get_applied_pose(spine_slider self) { - ConstraintGeneric *_self = (ConstraintGeneric *) (Slider *) self; + SliderBase *_self = (SliderBase *) (Slider *) self; return (spine_slider_pose) &_self->getAppliedPose(); } void spine_slider_reset_constrained(spine_slider self) { - ConstraintGeneric *_self = (ConstraintGeneric *) (Slider *) self; + SliderBase *_self = (SliderBase *) (Slider *) self; _self->resetConstrained(); } void spine_slider_constrained(spine_slider self) { - ConstraintGeneric *_self = (ConstraintGeneric *) (Slider *) self; + SliderBase *_self = (SliderBase *) (Slider *) self; _self->constrained(); } bool spine_slider_is_pose_equal_to_applied(spine_slider self) { - ConstraintGeneric *_self = (ConstraintGeneric *) (Slider *) self; + SliderBase *_self = (SliderBase *) (Slider *) self; return _self->isPoseEqualToApplied(); } bool spine_slider_is_active(spine_slider self) { - ConstraintGeneric *_self = (ConstraintGeneric *) (Slider *) self; + SliderBase *_self = (SliderBase *) (Slider *) self; return _self->isActive(); } void spine_slider_set_active(spine_slider self, bool active) { - ConstraintGeneric *_self = (ConstraintGeneric *) (Slider *) self; + SliderBase *_self = (SliderBase *) (Slider *) self; _self->setActive(active); } diff --git a/spine-c/src/generated/slider_base.cpp b/spine-c/src/generated/slider_base.cpp new file mode 100644 index 000000000..dbeb5ec27 --- /dev/null +++ b/spine-c/src/generated/slider_base.cpp @@ -0,0 +1,72 @@ +#include "slider_base.h" +#include + +using namespace spine; + +void spine_slider_base_dispose(spine_slider_base self) { + delete (SliderBase *) self; +} + +spine_slider_data spine_slider_base_get_data(spine_slider_base self) { + ConstraintGeneric *_self = (ConstraintGeneric *) (SliderBase *) self; + return (spine_slider_data) &_self->getData(); +} + +spine_slider_pose spine_slider_base_get_pose(spine_slider_base self) { + ConstraintGeneric *_self = (ConstraintGeneric *) (SliderBase *) self; + return (spine_slider_pose) &_self->getPose(); +} + +spine_slider_pose spine_slider_base_get_applied_pose(spine_slider_base self) { + ConstraintGeneric *_self = (ConstraintGeneric *) (SliderBase *) self; + return (spine_slider_pose) &_self->getAppliedPose(); +} + +void spine_slider_base_reset_constrained(spine_slider_base self) { + ConstraintGeneric *_self = (ConstraintGeneric *) (SliderBase *) self; + _self->resetConstrained(); +} + +void spine_slider_base_constrained(spine_slider_base self) { + ConstraintGeneric *_self = (ConstraintGeneric *) (SliderBase *) self; + _self->constrained(); +} + +bool spine_slider_base_is_pose_equal_to_applied(spine_slider_base self) { + ConstraintGeneric *_self = (ConstraintGeneric *) (SliderBase *) self; + return _self->isPoseEqualToApplied(); +} + +bool spine_slider_base_is_active(spine_slider_base self) { + ConstraintGeneric *_self = (ConstraintGeneric *) (SliderBase *) self; + return _self->isActive(); +} + +void spine_slider_base_set_active(spine_slider_base self, bool active) { + ConstraintGeneric *_self = (ConstraintGeneric *) (SliderBase *) self; + _self->setActive(active); +} + +spine_rtti spine_slider_base_get_rtti(spine_slider_base self) { + ConstraintGeneric *_self = (ConstraintGeneric *) (SliderBase *) self; + return (spine_rtti) &_self->getRTTI(); +} + +void spine_slider_base_sort(spine_slider_base self, spine_skeleton skeleton) { + ConstraintGeneric *_self = (ConstraintGeneric *) (SliderBase *) self; + _self->sort(*((Skeleton *) skeleton)); +} + +bool spine_slider_base_is_source_active(spine_slider_base self) { + ConstraintGeneric *_self = (ConstraintGeneric *) (SliderBase *) self; + return _self->isSourceActive(); +} + +void spine_slider_base_update(spine_slider_base self, spine_skeleton skeleton, spine_physics physics) { + ConstraintGeneric *_self = (ConstraintGeneric *) (SliderBase *) self; + _self->update(*((Skeleton *) skeleton), (Physics) physics); +} + +spine_rtti spine_slider_base_rtti(void) { + return (spine_rtti) &SliderBase::rtti; +} diff --git a/spine-c/src/generated/slider_base.h b/spine-c/src/generated/slider_base.h new file mode 100644 index 000000000..bea866769 --- /dev/null +++ b/spine-c/src/generated/slider_base.h @@ -0,0 +1,32 @@ +#ifndef SPINE_SPINE_SLIDER_BASE_H +#define SPINE_SPINE_SLIDER_BASE_H + +#include "../base.h" +#include "types.h" +#include "arrays.h" + +#ifdef __cplusplus +extern "C" { +#endif + +SPINE_C_API void spine_slider_base_dispose(spine_slider_base self); + +SPINE_C_API spine_slider_data spine_slider_base_get_data(spine_slider_base self); +SPINE_C_API spine_slider_pose spine_slider_base_get_pose(spine_slider_base self); +SPINE_C_API spine_slider_pose spine_slider_base_get_applied_pose(spine_slider_base self); +SPINE_C_API void spine_slider_base_reset_constrained(spine_slider_base self); +SPINE_C_API void spine_slider_base_constrained(spine_slider_base self); +SPINE_C_API bool spine_slider_base_is_pose_equal_to_applied(spine_slider_base self); +SPINE_C_API bool spine_slider_base_is_active(spine_slider_base self); +SPINE_C_API void spine_slider_base_set_active(spine_slider_base self, bool active); +SPINE_C_API spine_rtti spine_slider_base_get_rtti(spine_slider_base self); +SPINE_C_API void spine_slider_base_sort(spine_slider_base self, spine_skeleton skeleton); +SPINE_C_API bool spine_slider_base_is_source_active(spine_slider_base self); +SPINE_C_API void spine_slider_base_update(spine_slider_base self, spine_skeleton skeleton, spine_physics physics); +SPINE_C_API spine_rtti spine_slider_base_rtti(void); + +#ifdef __cplusplus +} +#endif + +#endif /* SPINE_SPINE_SLIDER_BASE_H */ diff --git a/spine-c/src/generated/transform_constraint.cpp b/spine-c/src/generated/transform_constraint.cpp index 7921b718f..5f75845e9 100644 --- a/spine-c/src/generated/transform_constraint.cpp +++ b/spine-c/src/generated/transform_constraint.cpp @@ -52,50 +52,42 @@ void spine_transform_constraint_set_source(spine_transform_constraint self, spin } spine_transform_constraint_data spine_transform_constraint_get_data(spine_transform_constraint self) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (TransformConstraint *) self; + TransformConstraintBase *_self = (TransformConstraintBase *) (TransformConstraint *) self; return (spine_transform_constraint_data) &_self->getData(); } spine_transform_constraint_pose spine_transform_constraint_get_pose(spine_transform_constraint self) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (TransformConstraint *) self; + TransformConstraintBase *_self = (TransformConstraintBase *) (TransformConstraint *) self; return (spine_transform_constraint_pose) &_self->getPose(); } spine_transform_constraint_pose spine_transform_constraint_get_applied_pose(spine_transform_constraint self) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (TransformConstraint *) self; + TransformConstraintBase *_self = (TransformConstraintBase *) (TransformConstraint *) self; return (spine_transform_constraint_pose) &_self->getAppliedPose(); } void spine_transform_constraint_reset_constrained(spine_transform_constraint self) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (TransformConstraint *) self; + TransformConstraintBase *_self = (TransformConstraintBase *) (TransformConstraint *) self; _self->resetConstrained(); } void spine_transform_constraint_constrained(spine_transform_constraint self) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (TransformConstraint *) self; + TransformConstraintBase *_self = (TransformConstraintBase *) (TransformConstraint *) self; _self->constrained(); } bool spine_transform_constraint_is_pose_equal_to_applied(spine_transform_constraint self) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (TransformConstraint *) self; + TransformConstraintBase *_self = (TransformConstraintBase *) (TransformConstraint *) self; return _self->isPoseEqualToApplied(); } bool spine_transform_constraint_is_active(spine_transform_constraint self) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (TransformConstraint *) self; + TransformConstraintBase *_self = (TransformConstraintBase *) (TransformConstraint *) self; return _self->isActive(); } void spine_transform_constraint_set_active(spine_transform_constraint self, bool active) { - ConstraintGeneric - *_self = (ConstraintGeneric *) (TransformConstraint *) self; + TransformConstraintBase *_self = (TransformConstraintBase *) (TransformConstraint *) self; _self->setActive(active); } diff --git a/spine-c/src/generated/transform_constraint_base.cpp b/spine-c/src/generated/transform_constraint_base.cpp new file mode 100644 index 000000000..fcf471759 --- /dev/null +++ b/spine-c/src/generated/transform_constraint_base.cpp @@ -0,0 +1,84 @@ +#include "transform_constraint_base.h" +#include + +using namespace spine; + +void spine_transform_constraint_base_dispose(spine_transform_constraint_base self) { + delete (TransformConstraintBase *) self; +} + +spine_transform_constraint_data spine_transform_constraint_base_get_data(spine_transform_constraint_base self) { + ConstraintGeneric + *_self = (ConstraintGeneric *) (TransformConstraintBase *) self; + return (spine_transform_constraint_data) &_self->getData(); +} + +spine_transform_constraint_pose spine_transform_constraint_base_get_pose(spine_transform_constraint_base self) { + ConstraintGeneric + *_self = (ConstraintGeneric *) (TransformConstraintBase *) self; + return (spine_transform_constraint_pose) &_self->getPose(); +} + +spine_transform_constraint_pose spine_transform_constraint_base_get_applied_pose(spine_transform_constraint_base self) { + ConstraintGeneric + *_self = (ConstraintGeneric *) (TransformConstraintBase *) self; + return (spine_transform_constraint_pose) &_self->getAppliedPose(); +} + +void spine_transform_constraint_base_reset_constrained(spine_transform_constraint_base self) { + ConstraintGeneric + *_self = (ConstraintGeneric *) (TransformConstraintBase *) self; + _self->resetConstrained(); +} + +void spine_transform_constraint_base_constrained(spine_transform_constraint_base self) { + ConstraintGeneric + *_self = (ConstraintGeneric *) (TransformConstraintBase *) self; + _self->constrained(); +} + +bool spine_transform_constraint_base_is_pose_equal_to_applied(spine_transform_constraint_base self) { + ConstraintGeneric + *_self = (ConstraintGeneric *) (TransformConstraintBase *) self; + return _self->isPoseEqualToApplied(); +} + +bool spine_transform_constraint_base_is_active(spine_transform_constraint_base self) { + ConstraintGeneric + *_self = (ConstraintGeneric *) (TransformConstraintBase *) self; + return _self->isActive(); +} + +void spine_transform_constraint_base_set_active(spine_transform_constraint_base self, bool active) { + ConstraintGeneric + *_self = (ConstraintGeneric *) (TransformConstraintBase *) self; + _self->setActive(active); +} + +spine_rtti spine_transform_constraint_base_get_rtti(spine_transform_constraint_base self) { + ConstraintGeneric + *_self = (ConstraintGeneric *) (TransformConstraintBase *) self; + return (spine_rtti) &_self->getRTTI(); +} + +void spine_transform_constraint_base_sort(spine_transform_constraint_base self, spine_skeleton skeleton) { + ConstraintGeneric + *_self = (ConstraintGeneric *) (TransformConstraintBase *) self; + _self->sort(*((Skeleton *) skeleton)); +} + +bool spine_transform_constraint_base_is_source_active(spine_transform_constraint_base self) { + ConstraintGeneric + *_self = (ConstraintGeneric *) (TransformConstraintBase *) self; + return _self->isSourceActive(); +} + +void spine_transform_constraint_base_update(spine_transform_constraint_base self, spine_skeleton skeleton, spine_physics physics) { + ConstraintGeneric + *_self = (ConstraintGeneric *) (TransformConstraintBase *) self; + _self->update(*((Skeleton *) skeleton), (Physics) physics); +} + +spine_rtti spine_transform_constraint_base_rtti(void) { + return (spine_rtti) &TransformConstraintBase::rtti; +} diff --git a/spine-c/src/generated/transform_constraint_base.h b/spine-c/src/generated/transform_constraint_base.h new file mode 100644 index 000000000..7f95a2e50 --- /dev/null +++ b/spine-c/src/generated/transform_constraint_base.h @@ -0,0 +1,32 @@ +#ifndef SPINE_SPINE_TRANSFORM_CONSTRAINT_BASE_H +#define SPINE_SPINE_TRANSFORM_CONSTRAINT_BASE_H + +#include "../base.h" +#include "types.h" +#include "arrays.h" + +#ifdef __cplusplus +extern "C" { +#endif + +SPINE_C_API void spine_transform_constraint_base_dispose(spine_transform_constraint_base self); + +SPINE_C_API spine_transform_constraint_data spine_transform_constraint_base_get_data(spine_transform_constraint_base self); +SPINE_C_API spine_transform_constraint_pose spine_transform_constraint_base_get_pose(spine_transform_constraint_base self); +SPINE_C_API spine_transform_constraint_pose spine_transform_constraint_base_get_applied_pose(spine_transform_constraint_base self); +SPINE_C_API void spine_transform_constraint_base_reset_constrained(spine_transform_constraint_base self); +SPINE_C_API void spine_transform_constraint_base_constrained(spine_transform_constraint_base self); +SPINE_C_API bool spine_transform_constraint_base_is_pose_equal_to_applied(spine_transform_constraint_base self); +SPINE_C_API bool spine_transform_constraint_base_is_active(spine_transform_constraint_base self); +SPINE_C_API void spine_transform_constraint_base_set_active(spine_transform_constraint_base self, bool active); +SPINE_C_API spine_rtti spine_transform_constraint_base_get_rtti(spine_transform_constraint_base self); +SPINE_C_API void spine_transform_constraint_base_sort(spine_transform_constraint_base self, spine_skeleton skeleton); +SPINE_C_API bool spine_transform_constraint_base_is_source_active(spine_transform_constraint_base self); +SPINE_C_API void spine_transform_constraint_base_update(spine_transform_constraint_base self, spine_skeleton skeleton, spine_physics physics); +SPINE_C_API spine_rtti spine_transform_constraint_base_rtti(void); + +#ifdef __cplusplus +} +#endif + +#endif /* SPINE_SPINE_TRANSFORM_CONSTRAINT_BASE_H */ diff --git a/spine-c/src/generated/types.h b/spine-c/src/generated/types.h index 0acc20572..e6eaef9b1 100644 --- a/spine-c/src/generated/types.h +++ b/spine-c/src/generated/types.h @@ -78,6 +78,7 @@ SPINE_OPAQUE_TYPE(spine_from_shear_y) SPINE_OPAQUE_TYPE(spine_from_x) SPINE_OPAQUE_TYPE(spine_from_y) SPINE_OPAQUE_TYPE(spine_ik_constraint) +SPINE_OPAQUE_TYPE(spine_ik_constraint_base) SPINE_OPAQUE_TYPE(spine_ik_constraint_data) SPINE_OPAQUE_TYPE(spine_ik_constraint_pose) SPINE_OPAQUE_TYPE(spine_ik_constraint_timeline) @@ -86,12 +87,14 @@ SPINE_OPAQUE_TYPE(spine_linked_mesh) SPINE_OPAQUE_TYPE(spine_mesh_attachment) SPINE_OPAQUE_TYPE(spine_path_attachment) SPINE_OPAQUE_TYPE(spine_path_constraint) +SPINE_OPAQUE_TYPE(spine_path_constraint_base) SPINE_OPAQUE_TYPE(spine_path_constraint_data) SPINE_OPAQUE_TYPE(spine_path_constraint_mix_timeline) SPINE_OPAQUE_TYPE(spine_path_constraint_pose) SPINE_OPAQUE_TYPE(spine_path_constraint_position_timeline) SPINE_OPAQUE_TYPE(spine_path_constraint_spacing_timeline) SPINE_OPAQUE_TYPE(spine_physics_constraint) +SPINE_OPAQUE_TYPE(spine_physics_constraint_base) SPINE_OPAQUE_TYPE(spine_physics_constraint_damping_timeline) SPINE_OPAQUE_TYPE(spine_physics_constraint_data) SPINE_OPAQUE_TYPE(spine_physics_constraint_gravity_timeline) @@ -133,6 +136,7 @@ SPINE_OPAQUE_TYPE(spine_skeleton_json) SPINE_OPAQUE_TYPE(spine_skeleton_renderer) SPINE_OPAQUE_TYPE(spine_skin) SPINE_OPAQUE_TYPE(spine_slider) +SPINE_OPAQUE_TYPE(spine_slider_base) SPINE_OPAQUE_TYPE(spine_slider_data) SPINE_OPAQUE_TYPE(spine_slider_mix_timeline) SPINE_OPAQUE_TYPE(spine_slider_pose) @@ -153,6 +157,7 @@ SPINE_OPAQUE_TYPE(spine_to_x) SPINE_OPAQUE_TYPE(spine_to_y) SPINE_OPAQUE_TYPE(spine_track_entry) SPINE_OPAQUE_TYPE(spine_transform_constraint) +SPINE_OPAQUE_TYPE(spine_transform_constraint_base) SPINE_OPAQUE_TYPE(spine_transform_constraint_data) SPINE_OPAQUE_TYPE(spine_transform_constraint_pose) SPINE_OPAQUE_TYPE(spine_transform_constraint_timeline) diff --git a/spine-cpp/include/spine/IkConstraint.h b/spine-cpp/include/spine/IkConstraint.h index 304106e24..4b67ea4d1 100644 --- a/spine-cpp/include/spine/IkConstraint.h +++ b/spine-cpp/include/spine/IkConstraint.h @@ -41,7 +41,14 @@ namespace spine { class Bone; class BonePose; - class SP_API IkConstraint : public ConstraintGeneric { + // Non-exported base class that inherits from the template + class IkConstraintBase : public ConstraintGeneric { + public: + IkConstraintBase(IkConstraintData &data) : ConstraintGeneric(data) { + } + }; + + class SP_API IkConstraint : public IkConstraintBase { friend class Skeleton; friend class IkConstraintTimeline; @@ -59,8 +66,6 @@ namespace spine { virtual bool isSourceActive() override; - IkConstraintData &getData() override; - Array &getBones(); Bone &getTarget(); diff --git a/spine-cpp/include/spine/PathConstraint.h b/spine-cpp/include/spine/PathConstraint.h index 41cb36b1a..f9dc35ded 100644 --- a/spine-cpp/include/spine/PathConstraint.h +++ b/spine-cpp/include/spine/PathConstraint.h @@ -49,7 +49,14 @@ namespace spine { /// constrained bones so they follow a PathAttachment. /// /// See https://esotericsoftware.com/spine-path-constraints Path constraints in the Spine User Guide. - class SP_API PathConstraint : public ConstraintGeneric { + // Non-exported base class that inherits from the template + class PathConstraintBase : public ConstraintGeneric { + public: + PathConstraintBase(PathConstraintData &data) : ConstraintGeneric(data) { + } + }; + + class SP_API PathConstraint : public PathConstraintBase { friend class Skeleton; friend class PathConstraintMixTimeline; friend class PathConstraintPositionTimeline; @@ -83,9 +90,6 @@ namespace spine { void setSlot(Slot &slot); - virtual PathConstraintData &getData() override; - - private: Array _bones; Slot *_slot; diff --git a/spine-cpp/include/spine/PhysicsConstraint.h b/spine-cpp/include/spine/PhysicsConstraint.h index 121a4148b..bec98c924 100644 --- a/spine-cpp/include/spine/PhysicsConstraint.h +++ b/spine-cpp/include/spine/PhysicsConstraint.h @@ -44,7 +44,15 @@ namespace spine { /// Stores the current pose for a physics constraint. A physics constraint applies physics to bones. /// /// See https://esotericsoftware.com/spine-physics-constraints Physics constraints in the Spine User Guide. - class SP_API PhysicsConstraint : public ConstraintGeneric { + // Non-exported base class that inherits from the template + class PhysicsConstraintBase : public ConstraintGeneric { + public: + PhysicsConstraintBase(PhysicsConstraintData &data) + : ConstraintGeneric(data) { + } + }; + + class SP_API PhysicsConstraint : public PhysicsConstraintBase { friend class Skeleton; friend class PhysicsConstraintTimeline; friend class PhysicsConstraintInertiaTimeline; diff --git a/spine-cpp/include/spine/Slider.h b/spine-cpp/include/spine/Slider.h index 67c8a1d9b..2d2ba97b1 100644 --- a/spine-cpp/include/spine/Slider.h +++ b/spine-cpp/include/spine/Slider.h @@ -42,7 +42,14 @@ namespace spine { /// Stores the setup pose for a PhysicsConstraint. /// /// See https://esotericsoftware.com/spine-physics-constraints Physics constraints in the Spine User Guide. - class SP_API Slider : public ConstraintGeneric { + // Non-exported base class that inherits from the template + class SliderBase : public ConstraintGeneric { + public: + SliderBase(SliderData &data) : ConstraintGeneric(data) { + } + }; + + class SP_API Slider : public SliderBase { friend class Skeleton; friend class SliderTimeline; friend class SliderMixTimeline; diff --git a/spine-cpp/include/spine/TransformConstraint.h b/spine-cpp/include/spine/TransformConstraint.h index ecd803318..44ae1c423 100644 --- a/spine-cpp/include/spine/TransformConstraint.h +++ b/spine-cpp/include/spine/TransformConstraint.h @@ -40,7 +40,15 @@ namespace spine { class Bone; class BonePose; - class SP_API TransformConstraint : public ConstraintGeneric { + // Non-exported base class that inherits from the template + class TransformConstraintBase : public ConstraintGeneric { + public: + TransformConstraintBase(TransformConstraintData &data) + : ConstraintGeneric(data) { + } + }; + + class SP_API TransformConstraint : public TransformConstraintBase { friend class Skeleton; friend class TransformConstraintTimeline; diff --git a/spine-cpp/src/spine/IkConstraint.cpp b/spine-cpp/src/spine/IkConstraint.cpp index 5a51de4c2..8bc98be43 100644 --- a/spine-cpp/src/spine/IkConstraint.cpp +++ b/spine-cpp/src/spine/IkConstraint.cpp @@ -41,8 +41,7 @@ using namespace spine; RTTI_IMPL(IkConstraint, Constraint) -IkConstraint::IkConstraint(IkConstraintData &data, Skeleton &skeleton) - : ConstraintGeneric(data), _target(skeleton._bones[data._target->getIndex()]) { +IkConstraint::IkConstraint(IkConstraintData &data, Skeleton &skeleton) : IkConstraintBase(data), _target(skeleton._bones[data._target->getIndex()]) { _bones.ensureCapacity(data._bones.size()); for (size_t i = 0; i < data._bones.size(); i++) { @@ -83,10 +82,6 @@ void IkConstraint::sort(Skeleton &skeleton) { if (_bones.size() > 1) skeleton.constrained(*_bones[1]->_bone); } -IkConstraintData &IkConstraint::getData() { - return _data; -} - Array &IkConstraint::getBones() { return _bones; } diff --git a/spine-cpp/src/spine/PathConstraint.cpp b/spine-cpp/src/spine/PathConstraint.cpp index 3c55985c3..bb41ec253 100644 --- a/spine-cpp/src/spine/PathConstraint.cpp +++ b/spine-cpp/src/spine/PathConstraint.cpp @@ -51,8 +51,7 @@ const int PathConstraint::NONE = -1; const int PathConstraint::BEFORE = -2; const int PathConstraint::AFTER = -3; -PathConstraint::PathConstraint(PathConstraintData &data, Skeleton &skeleton) - : ConstraintGeneric(data) { +PathConstraint::PathConstraint(PathConstraintData &data, Skeleton &skeleton) : PathConstraintBase(data) { _bones.ensureCapacity(data.getBones().size()); for (size_t i = 0; i < data.getBones().size(); i++) { @@ -236,10 +235,6 @@ bool PathConstraint::isSourceActive() { return _slot->getBone().isActive(); } -PathConstraintData &PathConstraint::getData() { - return _data; -} - Array &PathConstraint::getBones() { return _bones; } diff --git a/spine-cpp/src/spine/PhysicsConstraint.cpp b/spine-cpp/src/spine/PhysicsConstraint.cpp index 8531600a3..a8fa26afa 100644 --- a/spine-cpp/src/spine/PhysicsConstraint.cpp +++ b/spine-cpp/src/spine/PhysicsConstraint.cpp @@ -42,9 +42,9 @@ using namespace spine; RTTI_IMPL(PhysicsConstraint, Constraint) PhysicsConstraint::PhysicsConstraint(PhysicsConstraintData &data, Skeleton &skeleton) - : ConstraintGeneric(data), _reset(true), _ux(0), _uy(0), _cx(0), _cy(0), _tx(0), - _ty(0), _xOffset(0), _xLag(0), _xVelocity(0), _yOffset(0), _yLag(0), _yVelocity(0), _rotateOffset(0), _rotateLag(0), _rotateVelocity(0), - _scaleOffset(0), _scaleLag(0), _scaleVelocity(0), _remaining(0), _lastTime(0) { + : PhysicsConstraintBase(data), _reset(true), _ux(0), _uy(0), _cx(0), _cy(0), _tx(0), _ty(0), _xOffset(0), _xLag(0), _xVelocity(0), _yOffset(0), + _yLag(0), _yVelocity(0), _rotateOffset(0), _rotateLag(0), _rotateVelocity(0), _scaleOffset(0), _scaleLag(0), _scaleVelocity(0), _remaining(0), + _lastTime(0) { _bone = &skeleton._bones[(size_t) data._bone->getIndex()]->_constrained; } diff --git a/spine-cpp/src/spine/Slider.cpp b/spine-cpp/src/spine/Slider.cpp index 6cdfa9268..014ea2ec3 100644 --- a/spine-cpp/src/spine/Slider.cpp +++ b/spine-cpp/src/spine/Slider.cpp @@ -50,7 +50,7 @@ RTTI_IMPL(Slider, Constraint) float Slider::_offsets[6]; -Slider::Slider(SliderData &data, Skeleton &skeleton) : ConstraintGeneric(data), _bone(NULL) { +Slider::Slider(SliderData &data, Skeleton &skeleton) : SliderBase(data), _bone(NULL) { if (data._bone != NULL) { _bone = skeleton._bones[data._bone->getIndex()]; } diff --git a/spine-cpp/src/spine/TransformConstraint.cpp b/spine-cpp/src/spine/TransformConstraint.cpp index ecb724c74..9966404dc 100644 --- a/spine-cpp/src/spine/TransformConstraint.cpp +++ b/spine-cpp/src/spine/TransformConstraint.cpp @@ -41,8 +41,7 @@ using namespace spine; RTTI_IMPL(TransformConstraint, Constraint) -TransformConstraint::TransformConstraint(TransformConstraintData &data, Skeleton &skeleton) - : ConstraintGeneric(data) { +TransformConstraint::TransformConstraint(TransformConstraintData &data, Skeleton &skeleton) : TransformConstraintBase(data) { _bones.ensureCapacity(data.getBones().size()); for (size_t i = 0; i < data.getBones().size(); i++) {