From 907f2783258d4660cbdc1abf68073ee8583a426d Mon Sep 17 00:00:00 2001 From: Mario Zechner Date: Mon, 5 Sep 2022 12:34:03 +0200 Subject: [PATCH] [flutter] Wrap TransformConstraintData --- .../include/spine/TransformConstraintData.h | 30 + .../src/spine/TransformConstraintData.cpp | 60 ++ spine-flutter/lib/spine_flutter.dart | 127 ++++- .../lib/spine_flutter_bindings_generated.dart | 526 ++++++++++++++++++ spine-flutter/src/spine_flutter.cpp | 188 +++++++ spine-flutter/src/spine_flutter.h | 34 +- 6 files changed, 963 insertions(+), 2 deletions(-) diff --git a/spine-cpp/spine-cpp/include/spine/TransformConstraintData.h b/spine-cpp/spine-cpp/include/spine/TransformConstraintData.h index 726f9e6e2..f8fcecfef 100644 --- a/spine-cpp/spine-cpp/include/spine/TransformConstraintData.h +++ b/spine-cpp/spine-cpp/include/spine/TransformConstraintData.h @@ -58,34 +58,64 @@ namespace spine { BoneData *getTarget(); + void setTarget(BoneData *target); + float getMixRotate(); + void setMixRotate(float mixRotate); + float getMixX(); + void setMixX(float mixX); + float getMixY(); + void setMixY(float mixY); + float getMixScaleX(); + void setMixScaleX(float mixScaleX); + float getMixScaleY(); + void setMixScaleY(float mixScaleY); + float getMixShearY(); + void setMixShearY(float mixShearY); + float getOffsetRotation(); + void setOffsetRotation(float offsetRotation); + float getOffsetX(); + void setOffsetX(float offsetX); + float getOffsetY(); + void setOffsetY(float offsetY); + float getOffsetScaleX(); + void setOffsetScaleX(float offsetScaleX); + float getOffsetScaleY(); + void setOffsetScaleY(float offsetScaleY); + float getOffsetShearY(); + void setOffsetShearY(float offsetShearY); + bool isRelative(); + void setRelative(bool isRelative); + bool isLocal(); + void setLocal(bool isLocal); + private: Vector _bones; BoneData *_target; diff --git a/spine-cpp/spine-cpp/src/spine/TransformConstraintData.cpp b/spine-cpp/spine-cpp/src/spine/TransformConstraintData.cpp index bb7168808..b45f61915 100644 --- a/spine-cpp/spine-cpp/src/spine/TransformConstraintData.cpp +++ b/spine-cpp/spine-cpp/src/spine/TransformConstraintData.cpp @@ -118,3 +118,63 @@ bool TransformConstraintData::isRelative() { bool TransformConstraintData::isLocal() { return _local; } + +void TransformConstraintData::setTarget(BoneData *target) { + _target = target; +} + +void TransformConstraintData::setMixRotate(float mixRotate) { + _mixRotate = mixRotate; +} + +void TransformConstraintData::setMixX(float mixX) { + _mixX = mixX; +} + +void TransformConstraintData::setMixY(float mixY) { + _mixY = mixY; +} + +void TransformConstraintData::setMixScaleX(float mixScaleX) { + _mixScaleX = mixScaleX; +} + +void TransformConstraintData::setMixScaleY(float mixScaleY) { + _mixScaleY = mixScaleY; +} + +void TransformConstraintData::setMixShearY(float mixShearY) { + _mixShearY = mixShearY; +} + +void TransformConstraintData::setOffsetRotation(float offsetRotation) { + _offsetRotation = offsetRotation; +} + +void TransformConstraintData::setOffsetX(float offsetX) { + _offsetX = offsetX; +} + +void TransformConstraintData::setOffsetY(float offsetY) { + _offsetY = offsetY; +} + +void TransformConstraintData::setOffsetScaleX(float offsetScaleX) { + _offsetScaleX = offsetScaleX; +} + +void TransformConstraintData::setOffsetScaleY(float offsetScaleY) { + _offsetScaleY = offsetScaleY; +} + +void TransformConstraintData::setOffsetShearY(float offsetShearY) { + _offsetShearY = offsetShearY; +} + +void TransformConstraintData::setRelative(bool isRelative) { + _relative = isRelative; +} + +void TransformConstraintData::setLocal(bool isLocal) { + _local = isLocal; +} diff --git a/spine-flutter/lib/spine_flutter.dart b/spine-flutter/lib/spine_flutter.dart index 8006f7b59..3d02b4c82 100644 --- a/spine-flutter/lib/spine_flutter.dart +++ b/spine-flutter/lib/spine_flutter.dart @@ -1204,9 +1204,134 @@ class IkConstraint { } } -// FIXME class TransformConstraintData extends ConstraintData { TransformConstraintData._(spine_transform_constraint_data data): super._(data); + + List getBones() { + final List result = []; + final numBones = _bindings.spine_transform_constraint_data_get_num_bones(_data); + final nativeBones = _bindings.spine_transform_constraint_data_get_bones(_data); + for (int i = 0; i < numBones; i++) { + result.add(BoneData._(nativeBones[i])); + } + return result; + } + + BoneData getTarget() { + return BoneData._(_bindings.spine_ik_constraint_data_get_target(_data)); + } + + double getMixRotate() { + return _bindings.spine_transform_constraint_data_get_mix_rotate(_data); + } + + void setMixRotate(double mixRotate) { + _bindings.spine_transform_constraint_data_set_mix_rotate(_data, mixRotate); + } + + double getMixX() { + return _bindings.spine_transform_constraint_data_get_mix_x(_data); + } + + void setMixX(double mixX) { + _bindings.spine_transform_constraint_data_set_mix_x(_data, mixX); + } + + double getMixY() { + return _bindings.spine_transform_constraint_data_get_mix_y(_data); + } + + void setMixY(double mixY) { + _bindings.spine_transform_constraint_data_set_mix_y(_data, mixY); + } + + double getMixScaleX() { + return _bindings.spine_transform_constraint_data_get_mix_scale_x(_data); + } + + void setMixScaleX(double mixScaleX) { + _bindings.spine_transform_constraint_data_set_mix_scale_x(_data, mixScaleX); + } + + double getMixScaleY() { + return _bindings.spine_transform_constraint_data_get_mix_scale_y(_data); + } + + void setMixScaleY(double mixScaleY) { + _bindings.spine_transform_constraint_data_set_mix_scale_y(_data, mixScaleY); + } + + double getMixShearY() { + return _bindings.spine_transform_constraint_data_get_mix_shear_y(_data); + } + + void setMixShearY(double mixShearY) { + _bindings.spine_transform_constraint_data_set_mix_shear_y(_data, mixShearY); + } + + double getOffsetRotation() { + return _bindings.spine_transform_constraint_data_get_offset_rotation(_data); + } + + void setOffsetRotation(double offsetRotation) { + _bindings.spine_transform_constraint_data_set_offset_rotation(_data, offsetRotation); + } + + double getOffsetX() { + return _bindings.spine_transform_constraint_data_get_offset_x(_data); + } + + void setOffsetX(double offsetX) { + _bindings.spine_transform_constraint_data_set_offset_x(_data, offsetX); + } + + double getOffsetY() { + return _bindings.spine_transform_constraint_data_get_offset_y(_data); + } + + void setOffsetY(double offsetY) { + _bindings.spine_transform_constraint_data_set_offset_y(_data, offsetY); + } + + double getOffsetScaleX() { + return _bindings.spine_transform_constraint_data_get_offset_scale_x(_data); + } + + void setOffsetScaleX(double offsetScaleX) { + _bindings.spine_transform_constraint_data_set_offset_x(_data, offsetScaleX); + } + + double getOffsetScaleY() { + return _bindings.spine_transform_constraint_data_get_offset_scale_y(_data); + } + + void setOffsetScaleY(double offsetScaleY) { + _bindings.spine_transform_constraint_data_set_offset_scale_y(_data, offsetScaleY); + } + + double getOffsetShearY() { + return _bindings.spine_transform_constraint_data_get_offset_shear_y(_data); + } + + void setOffsetShearY(double offsetShearY) { + _bindings.spine_transform_constraint_data_set_offset_shear_y(_data, offsetShearY); + } + + bool isRelative() { + return _bindings.spine_transform_constraint_data_get_is_relative(_data) == -1; + } + + void setIsRelative(bool isRelative) { + _bindings.spine_transform_constraint_data_set_is_relative(_data, isRelative ? -1 : 0); + } + + bool isLocal() { + return _bindings.spine_transform_constraint_data_get_is_local(_data) == -1; + } + + void setIsLocal(bool isLocal) { + _bindings.spine_transform_constraint_data_set_is_local(_data, isLocal ? -1 : 0); + } } // FIXME diff --git a/spine-flutter/lib/spine_flutter_bindings_generated.dart b/spine-flutter/lib/spine_flutter_bindings_generated.dart index 8a851eafc..2a1bc985e 100644 --- a/spine-flutter/lib/spine_flutter_bindings_generated.dart +++ b/spine-flutter/lib/spine_flutter_bindings_generated.dart @@ -5368,6 +5368,532 @@ class SpineFlutterBindings { late final _spine_ik_constraint_set_is_active = _spine_ik_constraint_set_is_activePtr .asFunction(); + + int spine_transform_constraint_data_get_num_bones( + spine_transform_constraint_data data, + ) { + return _spine_transform_constraint_data_get_num_bones( + data, + ); + } + + late final _spine_transform_constraint_data_get_num_bonesPtr = _lookup< + ffi.NativeFunction< + ffi.Int32 Function(spine_transform_constraint_data)>>( + 'spine_transform_constraint_data_get_num_bones'); + late final _spine_transform_constraint_data_get_num_bones = + _spine_transform_constraint_data_get_num_bonesPtr + .asFunction(); + + ffi.Pointer spine_transform_constraint_data_get_bones( + spine_transform_constraint_data data, + ) { + return _spine_transform_constraint_data_get_bones( + data, + ); + } + + late final _spine_transform_constraint_data_get_bonesPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + spine_transform_constraint_data)>>( + 'spine_transform_constraint_data_get_bones'); + late final _spine_transform_constraint_data_get_bones = + _spine_transform_constraint_data_get_bonesPtr.asFunction< + ffi.Pointer Function( + spine_transform_constraint_data)>(); + + spine_bone_data spine_transform_constraint_data_get_target( + spine_transform_constraint_data data, + ) { + return _spine_transform_constraint_data_get_target( + data, + ); + } + + late final _spine_transform_constraint_data_get_targetPtr = _lookup< + ffi.NativeFunction< + spine_bone_data Function(spine_transform_constraint_data)>>( + 'spine_transform_constraint_data_get_target'); + late final _spine_transform_constraint_data_get_target = + _spine_transform_constraint_data_get_targetPtr.asFunction< + spine_bone_data Function(spine_transform_constraint_data)>(); + + double spine_transform_constraint_data_get_mix_rotate( + spine_transform_constraint_data data, + ) { + return _spine_transform_constraint_data_get_mix_rotate( + data, + ); + } + + late final _spine_transform_constraint_data_get_mix_rotatePtr = _lookup< + ffi.NativeFunction< + ffi.Float Function(spine_transform_constraint_data)>>( + 'spine_transform_constraint_data_get_mix_rotate'); + late final _spine_transform_constraint_data_get_mix_rotate = + _spine_transform_constraint_data_get_mix_rotatePtr + .asFunction(); + + void spine_transform_constraint_data_set_mix_rotate( + spine_transform_constraint_data data, + double mixRotate, + ) { + return _spine_transform_constraint_data_set_mix_rotate( + data, + mixRotate, + ); + } + + late final _spine_transform_constraint_data_set_mix_rotatePtr = _lookup< + ffi.NativeFunction< + ffi.Void Function(spine_transform_constraint_data, + ffi.Float)>>('spine_transform_constraint_data_set_mix_rotate'); + late final _spine_transform_constraint_data_set_mix_rotate = + _spine_transform_constraint_data_set_mix_rotatePtr + .asFunction(); + + double spine_transform_constraint_data_get_mix_x( + spine_transform_constraint_data data, + ) { + return _spine_transform_constraint_data_get_mix_x( + data, + ); + } + + late final _spine_transform_constraint_data_get_mix_xPtr = _lookup< + ffi.NativeFunction< + ffi.Float Function(spine_transform_constraint_data)>>( + 'spine_transform_constraint_data_get_mix_x'); + late final _spine_transform_constraint_data_get_mix_x = + _spine_transform_constraint_data_get_mix_xPtr + .asFunction(); + + void spine_transform_constraint_data_set_mix_x( + spine_transform_constraint_data data, + double mixX, + ) { + return _spine_transform_constraint_data_set_mix_x( + data, + mixX, + ); + } + + late final _spine_transform_constraint_data_set_mix_xPtr = _lookup< + ffi.NativeFunction< + ffi.Void Function(spine_transform_constraint_data, + ffi.Float)>>('spine_transform_constraint_data_set_mix_x'); + late final _spine_transform_constraint_data_set_mix_x = + _spine_transform_constraint_data_set_mix_xPtr + .asFunction(); + + double spine_transform_constraint_data_get_mix_y( + spine_transform_constraint_data data, + ) { + return _spine_transform_constraint_data_get_mix_y( + data, + ); + } + + late final _spine_transform_constraint_data_get_mix_yPtr = _lookup< + ffi.NativeFunction< + ffi.Float Function(spine_transform_constraint_data)>>( + 'spine_transform_constraint_data_get_mix_y'); + late final _spine_transform_constraint_data_get_mix_y = + _spine_transform_constraint_data_get_mix_yPtr + .asFunction(); + + void spine_transform_constraint_data_set_mix_y( + spine_transform_constraint_data data, + double mixY, + ) { + return _spine_transform_constraint_data_set_mix_y( + data, + mixY, + ); + } + + late final _spine_transform_constraint_data_set_mix_yPtr = _lookup< + ffi.NativeFunction< + ffi.Void Function(spine_transform_constraint_data, + ffi.Float)>>('spine_transform_constraint_data_set_mix_y'); + late final _spine_transform_constraint_data_set_mix_y = + _spine_transform_constraint_data_set_mix_yPtr + .asFunction(); + + double spine_transform_constraint_data_get_mix_scale_x( + spine_transform_constraint_data data, + ) { + return _spine_transform_constraint_data_get_mix_scale_x( + data, + ); + } + + late final _spine_transform_constraint_data_get_mix_scale_xPtr = _lookup< + ffi.NativeFunction< + ffi.Float Function(spine_transform_constraint_data)>>( + 'spine_transform_constraint_data_get_mix_scale_x'); + late final _spine_transform_constraint_data_get_mix_scale_x = + _spine_transform_constraint_data_get_mix_scale_xPtr + .asFunction(); + + void spine_transform_constraint_data_set_mix_scale_x( + spine_transform_constraint_data data, + double mixScaleX, + ) { + return _spine_transform_constraint_data_set_mix_scale_x( + data, + mixScaleX, + ); + } + + late final _spine_transform_constraint_data_set_mix_scale_xPtr = _lookup< + ffi.NativeFunction< + ffi.Void Function(spine_transform_constraint_data, + ffi.Float)>>('spine_transform_constraint_data_set_mix_scale_x'); + late final _spine_transform_constraint_data_set_mix_scale_x = + _spine_transform_constraint_data_set_mix_scale_xPtr + .asFunction(); + + double spine_transform_constraint_data_get_mix_scale_y( + spine_transform_constraint_data data, + ) { + return _spine_transform_constraint_data_get_mix_scale_y( + data, + ); + } + + late final _spine_transform_constraint_data_get_mix_scale_yPtr = _lookup< + ffi.NativeFunction< + ffi.Float Function(spine_transform_constraint_data)>>( + 'spine_transform_constraint_data_get_mix_scale_y'); + late final _spine_transform_constraint_data_get_mix_scale_y = + _spine_transform_constraint_data_get_mix_scale_yPtr + .asFunction(); + + void spine_transform_constraint_data_set_mix_scale_y( + spine_transform_constraint_data data, + double mixScaleY, + ) { + return _spine_transform_constraint_data_set_mix_scale_y( + data, + mixScaleY, + ); + } + + late final _spine_transform_constraint_data_set_mix_scale_yPtr = _lookup< + ffi.NativeFunction< + ffi.Void Function(spine_transform_constraint_data, + ffi.Float)>>('spine_transform_constraint_data_set_mix_scale_y'); + late final _spine_transform_constraint_data_set_mix_scale_y = + _spine_transform_constraint_data_set_mix_scale_yPtr + .asFunction(); + + double spine_transform_constraint_data_get_mix_shear_y( + spine_transform_constraint_data data, + ) { + return _spine_transform_constraint_data_get_mix_shear_y( + data, + ); + } + + late final _spine_transform_constraint_data_get_mix_shear_yPtr = _lookup< + ffi.NativeFunction< + ffi.Float Function(spine_transform_constraint_data)>>( + 'spine_transform_constraint_data_get_mix_shear_y'); + late final _spine_transform_constraint_data_get_mix_shear_y = + _spine_transform_constraint_data_get_mix_shear_yPtr + .asFunction(); + + void spine_transform_constraint_data_set_mix_shear_y( + spine_transform_constraint_data data, + double mixShearY, + ) { + return _spine_transform_constraint_data_set_mix_shear_y( + data, + mixShearY, + ); + } + + late final _spine_transform_constraint_data_set_mix_shear_yPtr = _lookup< + ffi.NativeFunction< + ffi.Void Function(spine_transform_constraint_data, + ffi.Float)>>('spine_transform_constraint_data_set_mix_shear_y'); + late final _spine_transform_constraint_data_set_mix_shear_y = + _spine_transform_constraint_data_set_mix_shear_yPtr + .asFunction(); + + double spine_transform_constraint_data_get_offset_rotation( + spine_transform_constraint_data data, + ) { + return _spine_transform_constraint_data_get_offset_rotation( + data, + ); + } + + late final _spine_transform_constraint_data_get_offset_rotationPtr = _lookup< + ffi.NativeFunction< + ffi.Float Function(spine_transform_constraint_data)>>( + 'spine_transform_constraint_data_get_offset_rotation'); + late final _spine_transform_constraint_data_get_offset_rotation = + _spine_transform_constraint_data_get_offset_rotationPtr + .asFunction(); + + void spine_transform_constraint_data_set_offset_rotation( + spine_transform_constraint_data data, + double offsetRotation, + ) { + return _spine_transform_constraint_data_set_offset_rotation( + data, + offsetRotation, + ); + } + + late final _spine_transform_constraint_data_set_offset_rotationPtr = _lookup< + ffi.NativeFunction< + ffi.Void Function(spine_transform_constraint_data, ffi.Float)>>( + 'spine_transform_constraint_data_set_offset_rotation'); + late final _spine_transform_constraint_data_set_offset_rotation = + _spine_transform_constraint_data_set_offset_rotationPtr + .asFunction(); + + double spine_transform_constraint_data_get_offset_x( + spine_transform_constraint_data data, + ) { + return _spine_transform_constraint_data_get_offset_x( + data, + ); + } + + late final _spine_transform_constraint_data_get_offset_xPtr = _lookup< + ffi.NativeFunction< + ffi.Float Function(spine_transform_constraint_data)>>( + 'spine_transform_constraint_data_get_offset_x'); + late final _spine_transform_constraint_data_get_offset_x = + _spine_transform_constraint_data_get_offset_xPtr + .asFunction(); + + void spine_transform_constraint_data_set_offset_x( + spine_transform_constraint_data data, + double offsetX, + ) { + return _spine_transform_constraint_data_set_offset_x( + data, + offsetX, + ); + } + + late final _spine_transform_constraint_data_set_offset_xPtr = _lookup< + ffi.NativeFunction< + ffi.Void Function(spine_transform_constraint_data, + ffi.Float)>>('spine_transform_constraint_data_set_offset_x'); + late final _spine_transform_constraint_data_set_offset_x = + _spine_transform_constraint_data_set_offset_xPtr + .asFunction(); + + double spine_transform_constraint_data_get_offset_y( + spine_transform_constraint_data data, + ) { + return _spine_transform_constraint_data_get_offset_y( + data, + ); + } + + late final _spine_transform_constraint_data_get_offset_yPtr = _lookup< + ffi.NativeFunction< + ffi.Float Function(spine_transform_constraint_data)>>( + 'spine_transform_constraint_data_get_offset_y'); + late final _spine_transform_constraint_data_get_offset_y = + _spine_transform_constraint_data_get_offset_yPtr + .asFunction(); + + void spine_transform_constraint_data_set_offset_y( + spine_transform_constraint_data data, + double offsetY, + ) { + return _spine_transform_constraint_data_set_offset_y( + data, + offsetY, + ); + } + + late final _spine_transform_constraint_data_set_offset_yPtr = _lookup< + ffi.NativeFunction< + ffi.Void Function(spine_transform_constraint_data, + ffi.Float)>>('spine_transform_constraint_data_set_offset_y'); + late final _spine_transform_constraint_data_set_offset_y = + _spine_transform_constraint_data_set_offset_yPtr + .asFunction(); + + double spine_transform_constraint_data_get_offset_scale_x( + spine_transform_constraint_data data, + ) { + return _spine_transform_constraint_data_get_offset_scale_x( + data, + ); + } + + late final _spine_transform_constraint_data_get_offset_scale_xPtr = _lookup< + ffi.NativeFunction< + ffi.Float Function(spine_transform_constraint_data)>>( + 'spine_transform_constraint_data_get_offset_scale_x'); + late final _spine_transform_constraint_data_get_offset_scale_x = + _spine_transform_constraint_data_get_offset_scale_xPtr + .asFunction(); + + void spine_transform_constraint_data_set_offset_scale_x( + spine_transform_constraint_data data, + double offsetScaleX, + ) { + return _spine_transform_constraint_data_set_offset_scale_x( + data, + offsetScaleX, + ); + } + + late final _spine_transform_constraint_data_set_offset_scale_xPtr = _lookup< + ffi.NativeFunction< + ffi.Void Function(spine_transform_constraint_data, ffi.Float)>>( + 'spine_transform_constraint_data_set_offset_scale_x'); + late final _spine_transform_constraint_data_set_offset_scale_x = + _spine_transform_constraint_data_set_offset_scale_xPtr + .asFunction(); + + double spine_transform_constraint_data_get_offset_scale_y( + spine_transform_constraint_data data, + ) { + return _spine_transform_constraint_data_get_offset_scale_y( + data, + ); + } + + late final _spine_transform_constraint_data_get_offset_scale_yPtr = _lookup< + ffi.NativeFunction< + ffi.Float Function(spine_transform_constraint_data)>>( + 'spine_transform_constraint_data_get_offset_scale_y'); + late final _spine_transform_constraint_data_get_offset_scale_y = + _spine_transform_constraint_data_get_offset_scale_yPtr + .asFunction(); + + void spine_transform_constraint_data_set_offset_scale_y( + spine_transform_constraint_data data, + double offsetScaleY, + ) { + return _spine_transform_constraint_data_set_offset_scale_y( + data, + offsetScaleY, + ); + } + + late final _spine_transform_constraint_data_set_offset_scale_yPtr = _lookup< + ffi.NativeFunction< + ffi.Void Function(spine_transform_constraint_data, ffi.Float)>>( + 'spine_transform_constraint_data_set_offset_scale_y'); + late final _spine_transform_constraint_data_set_offset_scale_y = + _spine_transform_constraint_data_set_offset_scale_yPtr + .asFunction(); + + double spine_transform_constraint_data_get_offset_shear_y( + spine_transform_constraint_data data, + ) { + return _spine_transform_constraint_data_get_offset_shear_y( + data, + ); + } + + late final _spine_transform_constraint_data_get_offset_shear_yPtr = _lookup< + ffi.NativeFunction< + ffi.Float Function(spine_transform_constraint_data)>>( + 'spine_transform_constraint_data_get_offset_shear_y'); + late final _spine_transform_constraint_data_get_offset_shear_y = + _spine_transform_constraint_data_get_offset_shear_yPtr + .asFunction(); + + void spine_transform_constraint_data_set_offset_shear_y( + spine_transform_constraint_data data, + double offsetShearY, + ) { + return _spine_transform_constraint_data_set_offset_shear_y( + data, + offsetShearY, + ); + } + + late final _spine_transform_constraint_data_set_offset_shear_yPtr = _lookup< + ffi.NativeFunction< + ffi.Void Function(spine_transform_constraint_data, ffi.Float)>>( + 'spine_transform_constraint_data_set_offset_shear_y'); + late final _spine_transform_constraint_data_set_offset_shear_y = + _spine_transform_constraint_data_set_offset_shear_yPtr + .asFunction(); + + int spine_transform_constraint_data_get_is_relative( + spine_transform_constraint_data data, + ) { + return _spine_transform_constraint_data_get_is_relative( + data, + ); + } + + late final _spine_transform_constraint_data_get_is_relativePtr = _lookup< + ffi.NativeFunction< + ffi.Int32 Function(spine_transform_constraint_data)>>( + 'spine_transform_constraint_data_get_is_relative'); + late final _spine_transform_constraint_data_get_is_relative = + _spine_transform_constraint_data_get_is_relativePtr + .asFunction(); + + void spine_transform_constraint_data_set_is_relative( + spine_transform_constraint_data data, + int isRelative, + ) { + return _spine_transform_constraint_data_set_is_relative( + data, + isRelative, + ); + } + + late final _spine_transform_constraint_data_set_is_relativePtr = _lookup< + ffi.NativeFunction< + ffi.Void Function(spine_transform_constraint_data, + ffi.Int32)>>('spine_transform_constraint_data_set_is_relative'); + late final _spine_transform_constraint_data_set_is_relative = + _spine_transform_constraint_data_set_is_relativePtr + .asFunction(); + + int spine_transform_constraint_data_get_is_local( + spine_transform_constraint_data data, + ) { + return _spine_transform_constraint_data_get_is_local( + data, + ); + } + + late final _spine_transform_constraint_data_get_is_localPtr = _lookup< + ffi.NativeFunction< + ffi.Int32 Function(spine_transform_constraint_data)>>( + 'spine_transform_constraint_data_get_is_local'); + late final _spine_transform_constraint_data_get_is_local = + _spine_transform_constraint_data_get_is_localPtr + .asFunction(); + + void spine_transform_constraint_data_set_is_local( + spine_transform_constraint_data data, + int isLocal, + ) { + return _spine_transform_constraint_data_set_is_local( + data, + isLocal, + ); + } + + late final _spine_transform_constraint_data_set_is_localPtr = _lookup< + ffi.NativeFunction< + ffi.Void Function(spine_transform_constraint_data, + ffi.Int32)>>('spine_transform_constraint_data_set_is_local'); + late final _spine_transform_constraint_data_set_is_local = + _spine_transform_constraint_data_set_is_localPtr + .asFunction(); } class spine_atlas extends ffi.Struct { diff --git a/spine-flutter/src/spine_flutter.cpp b/spine-flutter/src/spine_flutter.cpp index c67cb2d16..0a3d6471c 100644 --- a/spine-flutter/src/spine_flutter.cpp +++ b/spine-flutter/src/spine_flutter.cpp @@ -2299,3 +2299,191 @@ FFI_PLUGIN_EXPORT void spine_ik_constraint_set_is_active(spine_ik_constraint con IkConstraint *_constraint = (IkConstraint*)constraint; _constraint->setActive(isActive); } + +// TransformConstraintData +FFI_PLUGIN_EXPORT int spine_transform_constraint_data_get_num_bones(spine_transform_constraint_data data) { + if (data == nullptr) return 0; + TransformConstraintData *_data = (TransformConstraintData*)data; + return (int)_data->getBones().size(); +} + +FFI_PLUGIN_EXPORT spine_bone_data* spine_transform_constraint_data_get_bones(spine_transform_constraint_data data) { + if (data == nullptr) return nullptr; + TransformConstraintData *_data = (TransformConstraintData*)data; + return (spine_bone_data*)_data->getBones().buffer(); +} + +FFI_PLUGIN_EXPORT spine_bone_data spine_transform_constraint_data_get_target(spine_transform_constraint_data data) { + if (data == nullptr) return nullptr; + TransformConstraintData *_data = (TransformConstraintData*)data; + return _data->getTarget(); +} + +FFI_PLUGIN_EXPORT float spine_transform_constraint_data_get_mix_rotate(spine_transform_constraint_data data) { + if (data == nullptr) return 0; + TransformConstraintData *_data = (TransformConstraintData*)data; + return _data->getMixRotate(); +} + +FFI_PLUGIN_EXPORT void spine_transform_constraint_data_set_mix_rotate(spine_transform_constraint_data data, float mixRotate) { + if (data == nullptr) return; + TransformConstraintData *_data = (TransformConstraintData*)data; + _data->setMixRotate(mixRotate); +} + +FFI_PLUGIN_EXPORT float spine_transform_constraint_data_get_mix_x(spine_transform_constraint_data data) { + if (data == nullptr) return 0; + TransformConstraintData *_data = (TransformConstraintData*)data; + return _data->getMixX(); +} + +FFI_PLUGIN_EXPORT void spine_transform_constraint_data_set_mix_x(spine_transform_constraint_data data, float mixX) { + if (data == nullptr) return; + TransformConstraintData *_data = (TransformConstraintData*)data; + _data->setMixX(mixX); +} + +FFI_PLUGIN_EXPORT float spine_transform_constraint_data_get_mix_y(spine_transform_constraint_data data) { + if (data == nullptr) return 0; + TransformConstraintData *_data = (TransformConstraintData*)data; + return _data->getMixY(); +} + +FFI_PLUGIN_EXPORT void spine_transform_constraint_data_set_mix_y(spine_transform_constraint_data data, float mixY) { + if (data == nullptr) return; + TransformConstraintData *_data = (TransformConstraintData*)data; + _data->setMixY(mixY); +} + +FFI_PLUGIN_EXPORT float spine_transform_constraint_data_get_mix_scale_x(spine_transform_constraint_data data) { + if (data == nullptr) return 0; + TransformConstraintData *_data = (TransformConstraintData*)data; + return _data->getMixScaleX(); +} + +FFI_PLUGIN_EXPORT void spine_transform_constraint_data_set_mix_scale_x(spine_transform_constraint_data data, float mixScaleX) { + if (data == nullptr) return; + TransformConstraintData *_data = (TransformConstraintData*)data; + _data->setMixScaleX(mixScaleX); +} + +FFI_PLUGIN_EXPORT float spine_transform_constraint_data_get_mix_scale_y(spine_transform_constraint_data data) { + if (data == nullptr) return 0; + TransformConstraintData *_data = (TransformConstraintData*)data; + return _data->getMixScaleY(); +} + +FFI_PLUGIN_EXPORT void spine_transform_constraint_data_set_mix_scale_y(spine_transform_constraint_data data, float mixScaleY) { + if (data == nullptr) return; + TransformConstraintData *_data = (TransformConstraintData*)data; + _data->setMixScaleY(mixScaleY); +} + +FFI_PLUGIN_EXPORT float spine_transform_constraint_data_get_mix_shear_y(spine_transform_constraint_data data) { + if (data == nullptr) return 0; + TransformConstraintData *_data = (TransformConstraintData*)data; + return _data->getMixShearY(); +} + +FFI_PLUGIN_EXPORT void spine_transform_constraint_data_set_mix_shear_y(spine_transform_constraint_data data, float mixShearY) { + if (data == nullptr) return; + TransformConstraintData *_data = (TransformConstraintData*)data; + _data->setMixShearY(mixShearY); +} + +FFI_PLUGIN_EXPORT float spine_transform_constraint_data_get_offset_rotation(spine_transform_constraint_data data) { + if (data == nullptr) return 0; + TransformConstraintData *_data = (TransformConstraintData*)data; + return _data->getOffsetRotation(); +} + +FFI_PLUGIN_EXPORT void spine_transform_constraint_data_set_offset_rotation(spine_transform_constraint_data data, float offsetRotation) { + if (data == nullptr) return; + TransformConstraintData *_data = (TransformConstraintData*)data; + _data->setOffsetRotation(offsetRotation); +} + +FFI_PLUGIN_EXPORT float spine_transform_constraint_data_get_offset_x(spine_transform_constraint_data data) { + if (data == nullptr) return 0; + TransformConstraintData *_data = (TransformConstraintData*)data; + return _data->getOffsetX(); +} + +FFI_PLUGIN_EXPORT void spine_transform_constraint_data_set_offset_x(spine_transform_constraint_data data, float offsetX) { + if (data == nullptr) return; + TransformConstraintData *_data = (TransformConstraintData*)data; + _data->setOffsetX(offsetX); +} + +FFI_PLUGIN_EXPORT float spine_transform_constraint_data_get_offset_y(spine_transform_constraint_data data) { + if (data == nullptr) return 0; + TransformConstraintData *_data = (TransformConstraintData*)data; + return _data->getOffsetY(); +} + +FFI_PLUGIN_EXPORT void spine_transform_constraint_data_set_offset_y(spine_transform_constraint_data data, float offsetY) { + if (data == nullptr) return; + TransformConstraintData *_data = (TransformConstraintData*)data; + _data->setOffsetY(offsetY); +} + +FFI_PLUGIN_EXPORT float spine_transform_constraint_data_get_offset_scale_x(spine_transform_constraint_data data) { + if (data == nullptr) return 0; + TransformConstraintData *_data = (TransformConstraintData*)data; + return _data->getOffsetScaleX(); +} + +FFI_PLUGIN_EXPORT void spine_transform_constraint_data_set_offset_scale_x(spine_transform_constraint_data data, float offsetScaleX) { + if (data == nullptr) return; + TransformConstraintData *_data = (TransformConstraintData*)data; + _data->setOffsetScaleX(offsetScaleX); +} + +FFI_PLUGIN_EXPORT float spine_transform_constraint_data_get_offset_scale_y(spine_transform_constraint_data data) { + if (data == nullptr) return 0; + TransformConstraintData *_data = (TransformConstraintData*)data; + return _data->getOffsetScaleY(); +} + +FFI_PLUGIN_EXPORT void spine_transform_constraint_data_set_offset_scale_y(spine_transform_constraint_data data, float offsetScaleY) { + if (data == nullptr) return; + TransformConstraintData *_data = (TransformConstraintData*)data; + _data->setOffsetScaleY(offsetScaleY); +} + +FFI_PLUGIN_EXPORT float spine_transform_constraint_data_get_offset_shear_y(spine_transform_constraint_data data) { + if (data == nullptr) return 0; + TransformConstraintData *_data = (TransformConstraintData*)data; + return _data->getOffsetShearY(); +} + +FFI_PLUGIN_EXPORT void spine_transform_constraint_data_set_offset_shear_y(spine_transform_constraint_data data, float offsetShearY) { + if (data == nullptr) return; + TransformConstraintData *_data = (TransformConstraintData*)data; + _data->setOffsetShearY(offsetShearY); +} + +FFI_PLUGIN_EXPORT int spine_transform_constraint_data_get_is_relative(spine_transform_constraint_data data) { + if (data == nullptr) return 0; + TransformConstraintData *_data = (TransformConstraintData*)data; + return _data->isRelative() ? -1 : 0; +} + +FFI_PLUGIN_EXPORT void spine_transform_constraint_data_set_is_relative(spine_transform_constraint_data data, int isRelative) { + if (data == nullptr) return; + TransformConstraintData *_data = (TransformConstraintData*)data; + _data->setRelative(isRelative); +} + +FFI_PLUGIN_EXPORT int spine_transform_constraint_data_get_is_local(spine_transform_constraint_data data) { + if (data == nullptr) return 0; + TransformConstraintData *_data = (TransformConstraintData*)data; + return _data->isLocal() ? -1 : 0; +} + +FFI_PLUGIN_EXPORT void spine_transform_constraint_data_set_is_local(spine_transform_constraint_data data, int isLocal) { + if (data == nullptr) return; + TransformConstraintData *_data = (TransformConstraintData*)data; + _data->setLocal(isLocal); +} + diff --git a/spine-flutter/src/spine_flutter.h b/spine-flutter/src/spine_flutter.h index e4557d1db..f29398f42 100644 --- a/spine-flutter/src/spine_flutter.h +++ b/spine-flutter/src/spine_flutter.h @@ -501,4 +501,36 @@ FFI_PLUGIN_EXPORT void spine_ik_constraint_set_mix(spine_ik_constraint constrain FFI_PLUGIN_EXPORT float spine_ik_constraint_get_softness(spine_ik_constraint constraint); FFI_PLUGIN_EXPORT void spine_ik_constraint_set_softness(spine_ik_constraint constraint, float softness); FFI_PLUGIN_EXPORT int spine_ik_constraint_get_is_active(spine_ik_constraint constraint); -FFI_PLUGIN_EXPORT void spine_ik_constraint_set_is_active(spine_ik_constraint constraint, int isActive); \ No newline at end of file +FFI_PLUGIN_EXPORT void spine_ik_constraint_set_is_active(spine_ik_constraint constraint, int isActive); + +FFI_PLUGIN_EXPORT int spine_transform_constraint_data_get_num_bones(spine_transform_constraint_data data); +FFI_PLUGIN_EXPORT spine_bone_data* spine_transform_constraint_data_get_bones(spine_transform_constraint_data data); +FFI_PLUGIN_EXPORT spine_bone_data spine_transform_constraint_data_get_target(spine_transform_constraint_data data); +FFI_PLUGIN_EXPORT float spine_transform_constraint_data_get_mix_rotate(spine_transform_constraint_data data); +FFI_PLUGIN_EXPORT void spine_transform_constraint_data_set_mix_rotate(spine_transform_constraint_data data, float mixRotate); +FFI_PLUGIN_EXPORT float spine_transform_constraint_data_get_mix_x(spine_transform_constraint_data data); +FFI_PLUGIN_EXPORT void spine_transform_constraint_data_set_mix_x(spine_transform_constraint_data data, float mixX); +FFI_PLUGIN_EXPORT float spine_transform_constraint_data_get_mix_y(spine_transform_constraint_data data); +FFI_PLUGIN_EXPORT void spine_transform_constraint_data_set_mix_y(spine_transform_constraint_data data, float mixY); +FFI_PLUGIN_EXPORT float spine_transform_constraint_data_get_mix_scale_x(spine_transform_constraint_data data); +FFI_PLUGIN_EXPORT void spine_transform_constraint_data_set_mix_scale_x(spine_transform_constraint_data data, float mixScaleX); +FFI_PLUGIN_EXPORT float spine_transform_constraint_data_get_mix_scale_y(spine_transform_constraint_data data); +FFI_PLUGIN_EXPORT void spine_transform_constraint_data_set_mix_scale_y(spine_transform_constraint_data data, float mixScaleY); +FFI_PLUGIN_EXPORT float spine_transform_constraint_data_get_mix_shear_y(spine_transform_constraint_data data); +FFI_PLUGIN_EXPORT void spine_transform_constraint_data_set_mix_shear_y(spine_transform_constraint_data data, float mixShearY); +FFI_PLUGIN_EXPORT float spine_transform_constraint_data_get_offset_rotation(spine_transform_constraint_data data); +FFI_PLUGIN_EXPORT void spine_transform_constraint_data_set_offset_rotation(spine_transform_constraint_data data, float offsetRotation); +FFI_PLUGIN_EXPORT float spine_transform_constraint_data_get_offset_x(spine_transform_constraint_data data); +FFI_PLUGIN_EXPORT void spine_transform_constraint_data_set_offset_x(spine_transform_constraint_data data, float offsetX); +FFI_PLUGIN_EXPORT float spine_transform_constraint_data_get_offset_y(spine_transform_constraint_data data); +FFI_PLUGIN_EXPORT void spine_transform_constraint_data_set_offset_y(spine_transform_constraint_data data, float offsetY); +FFI_PLUGIN_EXPORT float spine_transform_constraint_data_get_offset_scale_x(spine_transform_constraint_data data); +FFI_PLUGIN_EXPORT void spine_transform_constraint_data_set_offset_scale_x(spine_transform_constraint_data data, float offsetScaleX); +FFI_PLUGIN_EXPORT float spine_transform_constraint_data_get_offset_scale_y(spine_transform_constraint_data data); +FFI_PLUGIN_EXPORT void spine_transform_constraint_data_set_offset_scale_y(spine_transform_constraint_data data, float offsetScaleY); +FFI_PLUGIN_EXPORT float spine_transform_constraint_data_get_offset_shear_y(spine_transform_constraint_data data); +FFI_PLUGIN_EXPORT void spine_transform_constraint_data_set_offset_shear_y(spine_transform_constraint_data data, float offsetShearY); +FFI_PLUGIN_EXPORT int spine_transform_constraint_data_get_is_relative(spine_transform_constraint_data data); +FFI_PLUGIN_EXPORT void spine_transform_constraint_data_set_is_relative(spine_transform_constraint_data data, int isRelative); +FFI_PLUGIN_EXPORT int spine_transform_constraint_data_get_is_local(spine_transform_constraint_data data); +FFI_PLUGIN_EXPORT void spine_transform_constraint_data_set_is_local(spine_transform_constraint_data data, int isLocal); \ No newline at end of file