From 10c2e2195e759fbc3a04734ba7e11297c9518200 Mon Sep 17 00:00:00 2001 From: Mario Zechner Date: Mon, 5 Sep 2022 09:42:10 +0200 Subject: [PATCH] [flutter] Wrap IkConstraintData --- spine-flutter/lib/spine_flutter.dart | 68 ++++- .../lib/spine_flutter_bindings_generated.dart | 263 ++++++++++++++++++ spine-flutter/src/spine_flutter.cpp | 96 ++++++- spine-flutter/src/spine_flutter.h | 19 +- 4 files changed, 441 insertions(+), 5 deletions(-) diff --git a/spine-flutter/lib/spine_flutter.dart b/spine-flutter/lib/spine_flutter.dart index 054b71de0..379a99e62 100644 --- a/spine-flutter/lib/spine_flutter.dart +++ b/spine-flutter/lib/spine_flutter.dart @@ -1044,16 +1044,80 @@ class Skin { } } -// FIXME class ConstraintData { final spine_constraint_data _data; ConstraintData._(this._data); } -// FIXME class IkConstraintData extends ConstraintData { IkConstraintData._(spine_ik_constraint_data data): super._(data); + + List getBones() { + final List result = []; + final numBones = _bindings.spine_ik_constraint_data_get_num_bones(_data); + final nativeBones = _bindings.spine_ik_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)); + } + + void setTarget(BoneData target) { + _bindings.spine_ik_constraint_data_set_target(_data, target._data); + } + + int getBendDirection() { + return _bindings.spine_ik_constraint_data_get_bend_direction(_data); + } + + void setBendDirection(int bendDirection) { + _bindings.spine_ik_constraint_data_set_bend_direction(_data, bendDirection); + } + + bool getCompress() { + return _bindings.spine_ik_constraint_data_get_compress(_data) == -1 ? true : false; + } + + void setCompress(bool compress) { + _bindings.spine_ik_constraint_data_set_compress(_data, compress ? -1 : 0); + } + + bool getStretch() { + return _bindings.spine_ik_constraint_data_get_stretch(_data) == -1 ? true : false; + } + + void setStretch(bool stretch) { + _bindings.spine_ik_constraint_data_set_stretch(_data, stretch ? -1 : 0); + } + + bool getUniform() { + return _bindings.spine_ik_constraint_data_get_uniform(_data) == -1 ? true : false; + } + + void setUniform(bool uniform) { + _bindings.spine_ik_constraint_data_set_uniform(_data, uniform ? -1 : 0); + } + + double getMix() { + return _bindings.spine_ik_constraint_data_get_mix(_data); + } + + void setMix(double mix) { + _bindings.spine_ik_constraint_data_set_mix(_data, mix); + } + + double getSoftness() { + return _bindings.spine_ik_constraint_data_get_softness(_data); + } + + void setSoftness(double softness) { + _bindings.spine_ik_constraint_data_set_softness(_data, softness); + } } // FIXME diff --git a/spine-flutter/lib/spine_flutter_bindings_generated.dart b/spine-flutter/lib/spine_flutter_bindings_generated.dart index 3fad779b5..b2876b2c5 100644 --- a/spine-flutter/lib/spine_flutter_bindings_generated.dart +++ b/spine-flutter/lib/spine_flutter_bindings_generated.dart @@ -4803,6 +4803,269 @@ class SpineFlutterBindings { late final _spine_constraint_data_get_type = _spine_constraint_data_get_typePtr .asFunction(); + + int spine_ik_constraint_data_get_num_bones( + spine_ik_constraint_data data, + ) { + return _spine_ik_constraint_data_get_num_bones( + data, + ); + } + + late final _spine_ik_constraint_data_get_num_bonesPtr = + _lookup>( + 'spine_ik_constraint_data_get_num_bones'); + late final _spine_ik_constraint_data_get_num_bones = + _spine_ik_constraint_data_get_num_bonesPtr + .asFunction(); + + ffi.Pointer spine_ik_constraint_data_get_bones( + spine_ik_constraint_data data, + ) { + return _spine_ik_constraint_data_get_bones( + data, + ); + } + + late final _spine_ik_constraint_data_get_bonesPtr = _lookup< + ffi.NativeFunction< + ffi.Pointer Function( + spine_ik_constraint_data)>>('spine_ik_constraint_data_get_bones'); + late final _spine_ik_constraint_data_get_bones = + _spine_ik_constraint_data_get_bonesPtr.asFunction< + ffi.Pointer Function(spine_ik_constraint_data)>(); + + spine_bone_data spine_ik_constraint_data_get_target( + spine_ik_constraint_data data, + ) { + return _spine_ik_constraint_data_get_target( + data, + ); + } + + late final _spine_ik_constraint_data_get_targetPtr = _lookup< + ffi.NativeFunction< + spine_bone_data Function(spine_ik_constraint_data)>>( + 'spine_ik_constraint_data_get_target'); + late final _spine_ik_constraint_data_get_target = + _spine_ik_constraint_data_get_targetPtr + .asFunction(); + + void spine_ik_constraint_data_set_target( + spine_ik_constraint_data data, + spine_bone_data target, + ) { + return _spine_ik_constraint_data_set_target( + data, + target, + ); + } + + late final _spine_ik_constraint_data_set_targetPtr = _lookup< + ffi.NativeFunction< + ffi.Void Function(spine_ik_constraint_data, + spine_bone_data)>>('spine_ik_constraint_data_set_target'); + late final _spine_ik_constraint_data_set_target = + _spine_ik_constraint_data_set_targetPtr.asFunction< + void Function(spine_ik_constraint_data, spine_bone_data)>(); + + int spine_ik_constraint_data_get_bend_direction( + spine_ik_constraint_data data, + ) { + return _spine_ik_constraint_data_get_bend_direction( + data, + ); + } + + late final _spine_ik_constraint_data_get_bend_directionPtr = + _lookup>( + 'spine_ik_constraint_data_get_bend_direction'); + late final _spine_ik_constraint_data_get_bend_direction = + _spine_ik_constraint_data_get_bend_directionPtr + .asFunction(); + + void spine_ik_constraint_data_set_bend_direction( + spine_ik_constraint_data data, + int bendDirection, + ) { + return _spine_ik_constraint_data_set_bend_direction( + data, + bendDirection, + ); + } + + late final _spine_ik_constraint_data_set_bend_directionPtr = _lookup< + ffi.NativeFunction< + ffi.Void Function(spine_ik_constraint_data, + ffi.Int32)>>('spine_ik_constraint_data_set_bend_direction'); + late final _spine_ik_constraint_data_set_bend_direction = + _spine_ik_constraint_data_set_bend_directionPtr + .asFunction(); + + int spine_ik_constraint_data_get_compress( + spine_ik_constraint_data data, + ) { + return _spine_ik_constraint_data_get_compress( + data, + ); + } + + late final _spine_ik_constraint_data_get_compressPtr = + _lookup>( + 'spine_ik_constraint_data_get_compress'); + late final _spine_ik_constraint_data_get_compress = + _spine_ik_constraint_data_get_compressPtr + .asFunction(); + + void spine_ik_constraint_data_set_compress( + spine_ik_constraint_data data, + int compress, + ) { + return _spine_ik_constraint_data_set_compress( + data, + compress, + ); + } + + late final _spine_ik_constraint_data_set_compressPtr = _lookup< + ffi.NativeFunction< + ffi.Void Function(spine_ik_constraint_data, + ffi.Int32)>>('spine_ik_constraint_data_set_compress'); + late final _spine_ik_constraint_data_set_compress = + _spine_ik_constraint_data_set_compressPtr + .asFunction(); + + int spine_ik_constraint_data_get_stretch( + spine_ik_constraint_data data, + ) { + return _spine_ik_constraint_data_get_stretch( + data, + ); + } + + late final _spine_ik_constraint_data_get_stretchPtr = + _lookup>( + 'spine_ik_constraint_data_get_stretch'); + late final _spine_ik_constraint_data_get_stretch = + _spine_ik_constraint_data_get_stretchPtr + .asFunction(); + + void spine_ik_constraint_data_set_stretch( + spine_ik_constraint_data data, + int stretch, + ) { + return _spine_ik_constraint_data_set_stretch( + data, + stretch, + ); + } + + late final _spine_ik_constraint_data_set_stretchPtr = _lookup< + ffi.NativeFunction< + ffi.Void Function(spine_ik_constraint_data, + ffi.Int32)>>('spine_ik_constraint_data_set_stretch'); + late final _spine_ik_constraint_data_set_stretch = + _spine_ik_constraint_data_set_stretchPtr + .asFunction(); + + int spine_ik_constraint_data_get_uniform( + spine_ik_constraint_data data, + ) { + return _spine_ik_constraint_data_get_uniform( + data, + ); + } + + late final _spine_ik_constraint_data_get_uniformPtr = + _lookup>( + 'spine_ik_constraint_data_get_uniform'); + late final _spine_ik_constraint_data_get_uniform = + _spine_ik_constraint_data_get_uniformPtr + .asFunction(); + + void spine_ik_constraint_data_set_uniform( + spine_ik_constraint_data data, + int uniform, + ) { + return _spine_ik_constraint_data_set_uniform( + data, + uniform, + ); + } + + late final _spine_ik_constraint_data_set_uniformPtr = _lookup< + ffi.NativeFunction< + ffi.Void Function(spine_ik_constraint_data, + ffi.Int32)>>('spine_ik_constraint_data_set_uniform'); + late final _spine_ik_constraint_data_set_uniform = + _spine_ik_constraint_data_set_uniformPtr + .asFunction(); + + double spine_ik_constraint_data_get_mix( + spine_ik_constraint_data data, + ) { + return _spine_ik_constraint_data_get_mix( + data, + ); + } + + late final _spine_ik_constraint_data_get_mixPtr = + _lookup>( + 'spine_ik_constraint_data_get_mix'); + late final _spine_ik_constraint_data_get_mix = + _spine_ik_constraint_data_get_mixPtr + .asFunction(); + + void spine_ik_constraint_data_set_mix( + spine_ik_constraint_data data, + double mix, + ) { + return _spine_ik_constraint_data_set_mix( + data, + mix, + ); + } + + late final _spine_ik_constraint_data_set_mixPtr = _lookup< + ffi.NativeFunction< + ffi.Void Function(spine_ik_constraint_data, + ffi.Float)>>('spine_ik_constraint_data_set_mix'); + late final _spine_ik_constraint_data_set_mix = + _spine_ik_constraint_data_set_mixPtr + .asFunction(); + + double spine_ik_constraint_data_get_softness( + spine_ik_constraint_data data, + ) { + return _spine_ik_constraint_data_get_softness( + data, + ); + } + + late final _spine_ik_constraint_data_get_softnessPtr = + _lookup>( + 'spine_ik_constraint_data_get_softness'); + late final _spine_ik_constraint_data_get_softness = + _spine_ik_constraint_data_get_softnessPtr + .asFunction(); + + void spine_ik_constraint_data_set_softness( + spine_ik_constraint_data data, + double softness, + ) { + return _spine_ik_constraint_data_set_softness( + data, + softness, + ); + } + + late final _spine_ik_constraint_data_set_softnessPtr = _lookup< + ffi.NativeFunction< + ffi.Void Function(spine_ik_constraint_data, + ffi.Float)>>('spine_ik_constraint_data_set_softness'); + late final _spine_ik_constraint_data_set_softness = + _spine_ik_constraint_data_set_softnessPtr + .asFunction(); } class spine_atlas extends ffi.Struct { diff --git a/spine-flutter/src/spine_flutter.cpp b/spine-flutter/src/spine_flutter.cpp index 4959b5543..55a7967f2 100644 --- a/spine-flutter/src/spine_flutter.cpp +++ b/spine-flutter/src/spine_flutter.cpp @@ -2048,7 +2048,7 @@ FFI_PLUGIN_EXPORT void spine_skin_entries_dispose(spine_skin_entries *entries) { FFI_PLUGIN_EXPORT int spine_skin_get_num_bones(spine_skin skin) { if (skin == nullptr) return 0; Skin *_skin = (Skin*)skin; - return _skin->getBones().size(); + return (int)_skin->getBones().size(); } FFI_PLUGIN_EXPORT spine_bone_data* spine_skin_get_bones(spine_skin skin) { @@ -2060,7 +2060,7 @@ FFI_PLUGIN_EXPORT spine_bone_data* spine_skin_get_bones(spine_skin skin) { FFI_PLUGIN_EXPORT int spine_skin_get_num_constraints(spine_skin skin) { if (skin == nullptr) return 0; Skin *_skin = (Skin*)skin; - return _skin->getConstraints().size(); + return (int)_skin->getConstraints().size(); } FFI_PLUGIN_EXPORT spine_constraint_data* spine_skin_get_constraints(spine_skin skin) { @@ -2093,3 +2093,95 @@ FFI_PLUGIN_EXPORT spine_constraint_type spine_constraint_data_get_type(spine_con return SPINE_CONSTRAINT_IK; } } + +// IkConstraintData +FFI_PLUGIN_EXPORT int spine_ik_constraint_data_get_num_bones(spine_ik_constraint_data data) { + if (data == nullptr) return 0; + IkConstraintData *_data = (IkConstraintData*)data; + return (int)_data->getBones().size(); +} + +FFI_PLUGIN_EXPORT spine_bone_data* spine_ik_constraint_data_get_bones(spine_ik_constraint_data data) { + if (data == nullptr) return nullptr; + IkConstraintData *_data = (IkConstraintData*)data; + return (spine_bone_data*)_data->getBones().buffer(); +} + +FFI_PLUGIN_EXPORT spine_bone_data spine_ik_constraint_data_get_target(spine_ik_constraint_data data) { + if (data == nullptr) return nullptr; + IkConstraintData *_data = (IkConstraintData*)data; + return _data->getTarget(); +} + +FFI_PLUGIN_EXPORT void spine_ik_constraint_data_set_target(spine_ik_constraint_data data, spine_bone_data target) { + if (data == nullptr) return; + IkConstraintData *_data = (IkConstraintData*)data; + _data->setTarget((BoneData*)target); +} + +FFI_PLUGIN_EXPORT int spine_ik_constraint_data_get_bend_direction(spine_ik_constraint_data data) { + if (data == nullptr) return 1; + IkConstraintData *_data = (IkConstraintData*)data; + return _data->getBendDirection(); +} + +FFI_PLUGIN_EXPORT void spine_ik_constraint_data_set_bend_direction(spine_ik_constraint_data data, int bendDirection) { + if (data == nullptr) return; + IkConstraintData *_data = (IkConstraintData*)data; + _data->setBendDirection(bendDirection); +} + +FFI_PLUGIN_EXPORT int spine_ik_constraint_data_get_compress(spine_ik_constraint_data data) { + if (data == nullptr) return 0; + IkConstraintData *_data = (IkConstraintData*)data; + return _data->getCompress() ? -1 : 0; +} + +FFI_PLUGIN_EXPORT void spine_ik_constraint_data_set_compress(spine_ik_constraint_data data, int compress) { + if (data == nullptr) return; + IkConstraintData *_data = (IkConstraintData*)data; + _data->setCompress(compress); +} + +FFI_PLUGIN_EXPORT int spine_ik_constraint_data_get_stretch(spine_ik_constraint_data data) { + if (data == nullptr) return 0; + IkConstraintData *_data = (IkConstraintData*)data; + return _data->getStretch() ? -1 : 0; +} + +FFI_PLUGIN_EXPORT void spine_ik_constraint_data_set_stretch(spine_ik_constraint_data data, int stretch) { + if (data == nullptr) return; + IkConstraintData *_data = (IkConstraintData*)data; + _data->setStretch(stretch); +} + +FFI_PLUGIN_EXPORT int spine_ik_constraint_data_get_uniform(spine_ik_constraint_data data) { + if (data == nullptr) return 0; + IkConstraintData *_data = (IkConstraintData*)data; + return _data->getUniform() ? -1 : 0; +} + +FFI_PLUGIN_EXPORT float spine_ik_constraint_data_get_mix(spine_ik_constraint_data data) { + if (data == nullptr) return 0; + IkConstraintData *_data = (IkConstraintData*)data; + return _data->getMix(); +} + +FFI_PLUGIN_EXPORT void spine_ik_constraint_data_set_mix(spine_ik_constraint_data data, float mix) { + if (data == nullptr) return; + IkConstraintData *_data = (IkConstraintData*)data; + _data->setMix(mix); +} + +FFI_PLUGIN_EXPORT float spine_ik_constraint_data_get_softness(spine_ik_constraint_data data) { + if (data == nullptr) return 0; + IkConstraintData *_data = (IkConstraintData*)data; + return _data->getSoftness(); +} + +FFI_PLUGIN_EXPORT void spine_ik_constraint_data_set_softness(spine_ik_constraint_data data, float softness) { + if (data == nullptr) return; + IkConstraintData *_data = (IkConstraintData*)data; + _data->setSoftness(softness); +} + diff --git a/spine-flutter/src/spine_flutter.h b/spine-flutter/src/spine_flutter.h index 51bcc82f5..3a6e11295 100644 --- a/spine-flutter/src/spine_flutter.h +++ b/spine-flutter/src/spine_flutter.h @@ -464,4 +464,21 @@ FFI_PLUGIN_EXPORT spine_constraint_data* spine_skin_get_constraints(spine_skin s FFI_PLUGIN_EXPORT spine_skin spine_skin_create(const char* name); FFI_PLUGIN_EXPORT void spine_skin_dispose(spine_skin skin); -FFI_PLUGIN_EXPORT spine_constraint_type spine_constraint_data_get_type(spine_constraint_data data); \ No newline at end of file +FFI_PLUGIN_EXPORT spine_constraint_type spine_constraint_data_get_type(spine_constraint_data data); + +FFI_PLUGIN_EXPORT int spine_ik_constraint_data_get_num_bones(spine_ik_constraint_data data); +FFI_PLUGIN_EXPORT spine_bone_data* spine_ik_constraint_data_get_bones(spine_ik_constraint_data data); +FFI_PLUGIN_EXPORT spine_bone_data spine_ik_constraint_data_get_target(spine_ik_constraint_data data); +FFI_PLUGIN_EXPORT void spine_ik_constraint_data_set_target(spine_ik_constraint_data data, spine_bone_data target); +FFI_PLUGIN_EXPORT int spine_ik_constraint_data_get_bend_direction(spine_ik_constraint_data data); +FFI_PLUGIN_EXPORT void spine_ik_constraint_data_set_bend_direction(spine_ik_constraint_data data, int bendDirection); +FFI_PLUGIN_EXPORT int spine_ik_constraint_data_get_compress(spine_ik_constraint_data data); +FFI_PLUGIN_EXPORT void spine_ik_constraint_data_set_compress(spine_ik_constraint_data data, int compress); +FFI_PLUGIN_EXPORT int spine_ik_constraint_data_get_stretch(spine_ik_constraint_data data); +FFI_PLUGIN_EXPORT void spine_ik_constraint_data_set_stretch(spine_ik_constraint_data data, int stretch); +FFI_PLUGIN_EXPORT int spine_ik_constraint_data_get_uniform(spine_ik_constraint_data data); +FFI_PLUGIN_EXPORT void spine_ik_constraint_data_set_uniform(spine_ik_constraint_data data, int uniform); +FFI_PLUGIN_EXPORT float spine_ik_constraint_data_get_mix(spine_ik_constraint_data data); +FFI_PLUGIN_EXPORT void spine_ik_constraint_data_set_mix(spine_ik_constraint_data data, float mix); +FFI_PLUGIN_EXPORT float spine_ik_constraint_data_get_softness(spine_ik_constraint_data data); +FFI_PLUGIN_EXPORT void spine_ik_constraint_data_set_softness(spine_ik_constraint_data data, float softness); \ No newline at end of file