[flutter] Wrap IkConstraintData

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<BoneData> getBones() {
+    final List<BoneData> 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

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 Function(spine_constraint_data)>();
+
+  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<ffi.NativeFunction<ffi.Int32 Function(spine_ik_constraint_data)>>(
+          'spine_ik_constraint_data_get_num_bones');
+  late final _spine_ik_constraint_data_get_num_bones =
+      _spine_ik_constraint_data_get_num_bonesPtr
+          .asFunction<int Function(spine_ik_constraint_data)>();
+
+  ffi.Pointer<spine_bone_data> 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<spine_bone_data> 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<spine_bone_data> 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<spine_bone_data Function(spine_ik_constraint_data)>();
+
+  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<ffi.NativeFunction<ffi.Int32 Function(spine_ik_constraint_data)>>(
+          'spine_ik_constraint_data_get_bend_direction');
+  late final _spine_ik_constraint_data_get_bend_direction =
+      _spine_ik_constraint_data_get_bend_directionPtr
+          .asFunction<int Function(spine_ik_constraint_data)>();
+
+  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<void Function(spine_ik_constraint_data, int)>();
+
+  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<ffi.NativeFunction<ffi.Int32 Function(spine_ik_constraint_data)>>(
+          'spine_ik_constraint_data_get_compress');
+  late final _spine_ik_constraint_data_get_compress =
+      _spine_ik_constraint_data_get_compressPtr
+          .asFunction<int Function(spine_ik_constraint_data)>();
+
+  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<void Function(spine_ik_constraint_data, int)>();
+
+  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<ffi.NativeFunction<ffi.Int32 Function(spine_ik_constraint_data)>>(
+          'spine_ik_constraint_data_get_stretch');
+  late final _spine_ik_constraint_data_get_stretch =
+      _spine_ik_constraint_data_get_stretchPtr
+          .asFunction<int Function(spine_ik_constraint_data)>();
+
+  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<void Function(spine_ik_constraint_data, int)>();
+
+  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<ffi.NativeFunction<ffi.Int32 Function(spine_ik_constraint_data)>>(
+          'spine_ik_constraint_data_get_uniform');
+  late final _spine_ik_constraint_data_get_uniform =
+      _spine_ik_constraint_data_get_uniformPtr
+          .asFunction<int Function(spine_ik_constraint_data)>();
+
+  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<void Function(spine_ik_constraint_data, int)>();
+
+  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<ffi.NativeFunction<ffi.Float Function(spine_ik_constraint_data)>>(
+          'spine_ik_constraint_data_get_mix');
+  late final _spine_ik_constraint_data_get_mix =
+      _spine_ik_constraint_data_get_mixPtr
+          .asFunction<double Function(spine_ik_constraint_data)>();
+
+  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<void Function(spine_ik_constraint_data, double)>();
+
+  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<ffi.NativeFunction<ffi.Float Function(spine_ik_constraint_data)>>(
+          'spine_ik_constraint_data_get_softness');
+  late final _spine_ik_constraint_data_get_softness =
+      _spine_ik_constraint_data_get_softnessPtr
+          .asFunction<double Function(spine_ik_constraint_data)>();
+
+  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<void Function(spine_ik_constraint_data, double)>();
 }
 
 class spine_atlas extends ffi.Struct {

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);
+}
+

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);
+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);