[flutter] Wrap TransformConstraint

spine-flutter/lib/spine_flutter.dart

@@ -1334,11 +1334,96 @@ class TransformConstraintData extends ConstraintData {
   }
 }
 
-// FIXME
 class TransformConstraint {
   final spine_transform_constraint _constraint;
 
   TransformConstraint._(this._constraint);
+
+  void update() {
+    _bindings.spine_transform_constraint_update(_constraint);
+  }
+
+  int getOrder() {
+    return _bindings.spine_transform_constraint_get_order(_constraint);
+  }
+
+  TransformConstraintData getData() {
+    return TransformConstraintData._(_bindings.spine_transform_constraint_get_data(_constraint));
+  }
+
+  List<Bone> getBones() {
+    List<Bone> result = [];
+    final num = _bindings.spine_transform_constraint_get_num_bones(_constraint);
+    final nativeBones = _bindings.spine_transform_constraint_get_bones(_constraint);
+    for (int i = 0; i < num; i++) {
+      result.add(Bone._(nativeBones[i]));
+    }
+    return result;
+  }
+
+  Bone getTarget() {
+    return Bone._(_bindings.spine_transform_constraint_get_target(_constraint));
+  }
+
+  void setTarget(Bone target) {
+    _bindings.spine_transform_constraint_set_target(_constraint, target._bone);
+  }
+
+  double getMixRotate() {
+    return _bindings.spine_transform_constraint_get_mix_rotate(_constraint);
+  }
+
+  void setMixRotate(double mixRotate) {
+    _bindings.spine_transform_constraint_set_mix_rotate(_constraint, mixRotate);
+  }
+
+  double getMixX() {
+    return _bindings.spine_transform_constraint_get_mix_x(_constraint);
+  }
+
+  void setMixX(double mixX) {
+    _bindings.spine_transform_constraint_set_mix_x(_constraint, mixX);
+  }
+
+  double getMixY() {
+    return _bindings.spine_transform_constraint_get_mix_y(_constraint);
+  }
+
+  void setMixY(double mixY) {
+    _bindings.spine_transform_constraint_set_mix_y(_constraint, mixY);
+  }
+
+  double getMixScaleX() {
+    return _bindings.spine_transform_constraint_get_mix_scale_x(_constraint);
+  }
+
+  void setMixScaleX(double mixScaleX) {
+    _bindings.spine_transform_constraint_set_mix_scale_x(_constraint, mixScaleX);
+  }
+
+  double getMixScaleY() {
+    return _bindings.spine_transform_constraint_get_mix_scale_y(_constraint);
+  }
+
+  void setMixScaleY(double mixScaleY) {
+    _bindings.spine_transform_constraint_set_mix_scale_y(_constraint, mixScaleY);
+  }
+
+  double getMixShearY() {
+    return _bindings.spine_transform_constraint_get_mix_shear_y(_constraint);
+  }
+
+  void setMixShearY(double mixShearY) {
+    _bindings.spine_transform_constraint_set_mix_shear_y(_constraint, mixShearY);
+  }
+
+  bool isActive() {
+    return _bindings.spine_transform_constraint_get_is_active(_constraint) == -1;
+  }
+
+  void setIsActive(bool isActive) {
+    _bindings.spine_transform_constraint_set_is_active(_constraint, isActive ? -1 : 0);
+  }
 }
 
 // FIXME

spine-flutter/lib/spine_flutter_bindings_generated.dart

@@ -5894,6 +5894,349 @@ class SpineFlutterBindings {
   late final _spine_transform_constraint_data_set_is_local =
       _spine_transform_constraint_data_set_is_localPtr
           .asFunction<void Function(spine_transform_constraint_data, int)>();
+
+  void spine_transform_constraint_update(
+    spine_transform_constraint constraint,
+  ) {
+    return _spine_transform_constraint_update(
+      constraint,
+    );
+  }
+
+  late final _spine_transform_constraint_updatePtr = _lookup<
+          ffi.NativeFunction<ffi.Void Function(spine_transform_constraint)>>(
+      'spine_transform_constraint_update');
+  late final _spine_transform_constraint_update =
+      _spine_transform_constraint_updatePtr
+          .asFunction<void Function(spine_transform_constraint)>();
+
+  int spine_transform_constraint_get_order(
+    spine_transform_constraint constraint,
+  ) {
+    return _spine_transform_constraint_get_order(
+      constraint,
+    );
+  }
+
+  late final _spine_transform_constraint_get_orderPtr = _lookup<
+          ffi.NativeFunction<ffi.Int32 Function(spine_transform_constraint)>>(
+      'spine_transform_constraint_get_order');
+  late final _spine_transform_constraint_get_order =
+      _spine_transform_constraint_get_orderPtr
+          .asFunction<int Function(spine_transform_constraint)>();
+
+  spine_transform_constraint_data spine_transform_constraint_get_data(
+    spine_transform_constraint constraint,
+  ) {
+    return _spine_transform_constraint_get_data(
+      constraint,
+    );
+  }
+
+  late final _spine_transform_constraint_get_dataPtr = _lookup<
+          ffi.NativeFunction<
+              spine_transform_constraint_data Function(
+                  spine_transform_constraint)>>(
+      'spine_transform_constraint_get_data');
+  late final _spine_transform_constraint_get_data =
+      _spine_transform_constraint_get_dataPtr.asFunction<
+          spine_transform_constraint_data Function(
+              spine_transform_constraint)>();
+
+  int spine_transform_constraint_get_num_bones(
+    spine_transform_constraint constraint,
+  ) {
+    return _spine_transform_constraint_get_num_bones(
+      constraint,
+    );
+  }
+
+  late final _spine_transform_constraint_get_num_bonesPtr = _lookup<
+          ffi.NativeFunction<ffi.Int32 Function(spine_transform_constraint)>>(
+      'spine_transform_constraint_get_num_bones');
+  late final _spine_transform_constraint_get_num_bones =
+      _spine_transform_constraint_get_num_bonesPtr
+          .asFunction<int Function(spine_transform_constraint)>();
+
+  ffi.Pointer<spine_bone> spine_transform_constraint_get_bones(
+    spine_transform_constraint constraint,
+  ) {
+    return _spine_transform_constraint_get_bones(
+      constraint,
+    );
+  }
+
+  late final _spine_transform_constraint_get_bonesPtr = _lookup<
+          ffi.NativeFunction<
+              ffi.Pointer<spine_bone> Function(spine_transform_constraint)>>(
+      'spine_transform_constraint_get_bones');
+  late final _spine_transform_constraint_get_bones =
+      _spine_transform_constraint_get_bonesPtr.asFunction<
+          ffi.Pointer<spine_bone> Function(spine_transform_constraint)>();
+
+  spine_bone spine_transform_constraint_get_target(
+    spine_transform_constraint constraint,
+  ) {
+    return _spine_transform_constraint_get_target(
+      constraint,
+    );
+  }
+
+  late final _spine_transform_constraint_get_targetPtr = _lookup<
+          ffi.NativeFunction<spine_bone Function(spine_transform_constraint)>>(
+      'spine_transform_constraint_get_target');
+  late final _spine_transform_constraint_get_target =
+      _spine_transform_constraint_get_targetPtr
+          .asFunction<spine_bone Function(spine_transform_constraint)>();
+
+  void spine_transform_constraint_set_target(
+    spine_transform_constraint constraint,
+    spine_bone target,
+  ) {
+    return _spine_transform_constraint_set_target(
+      constraint,
+      target,
+    );
+  }
+
+  late final _spine_transform_constraint_set_targetPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Void Function(spine_transform_constraint,
+              spine_bone)>>('spine_transform_constraint_set_target');
+  late final _spine_transform_constraint_set_target =
+      _spine_transform_constraint_set_targetPtr
+          .asFunction<void Function(spine_transform_constraint, spine_bone)>();
+
+  double spine_transform_constraint_get_mix_rotate(
+    spine_transform_constraint constraint,
+  ) {
+    return _spine_transform_constraint_get_mix_rotate(
+      constraint,
+    );
+  }
+
+  late final _spine_transform_constraint_get_mix_rotatePtr = _lookup<
+          ffi.NativeFunction<ffi.Float Function(spine_transform_constraint)>>(
+      'spine_transform_constraint_get_mix_rotate');
+  late final _spine_transform_constraint_get_mix_rotate =
+      _spine_transform_constraint_get_mix_rotatePtr
+          .asFunction<double Function(spine_transform_constraint)>();
+
+  void spine_transform_constraint_set_mix_rotate(
+    spine_transform_constraint constraint,
+    double mixRotate,
+  ) {
+    return _spine_transform_constraint_set_mix_rotate(
+      constraint,
+      mixRotate,
+    );
+  }
+
+  late final _spine_transform_constraint_set_mix_rotatePtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Void Function(spine_transform_constraint,
+              ffi.Float)>>('spine_transform_constraint_set_mix_rotate');
+  late final _spine_transform_constraint_set_mix_rotate =
+      _spine_transform_constraint_set_mix_rotatePtr
+          .asFunction<void Function(spine_transform_constraint, double)>();
+
+  double spine_transform_constraint_get_mix_x(
+    spine_transform_constraint constraint,
+  ) {
+    return _spine_transform_constraint_get_mix_x(
+      constraint,
+    );
+  }
+
+  late final _spine_transform_constraint_get_mix_xPtr = _lookup<
+          ffi.NativeFunction<ffi.Float Function(spine_transform_constraint)>>(
+      'spine_transform_constraint_get_mix_x');
+  late final _spine_transform_constraint_get_mix_x =
+      _spine_transform_constraint_get_mix_xPtr
+          .asFunction<double Function(spine_transform_constraint)>();
+
+  void spine_transform_constraint_set_mix_x(
+    spine_transform_constraint constraint,
+    double mixX,
+  ) {
+    return _spine_transform_constraint_set_mix_x(
+      constraint,
+      mixX,
+    );
+  }
+
+  late final _spine_transform_constraint_set_mix_xPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Void Function(spine_transform_constraint,
+              ffi.Float)>>('spine_transform_constraint_set_mix_x');
+  late final _spine_transform_constraint_set_mix_x =
+      _spine_transform_constraint_set_mix_xPtr
+          .asFunction<void Function(spine_transform_constraint, double)>();
+
+  double spine_transform_constraint_get_mix_y(
+    spine_transform_constraint constraint,
+  ) {
+    return _spine_transform_constraint_get_mix_y(
+      constraint,
+    );
+  }
+
+  late final _spine_transform_constraint_get_mix_yPtr = _lookup<
+          ffi.NativeFunction<ffi.Float Function(spine_transform_constraint)>>(
+      'spine_transform_constraint_get_mix_y');
+  late final _spine_transform_constraint_get_mix_y =
+      _spine_transform_constraint_get_mix_yPtr
+          .asFunction<double Function(spine_transform_constraint)>();
+
+  void spine_transform_constraint_set_mix_y(
+    spine_transform_constraint constraint,
+    double mixY,
+  ) {
+    return _spine_transform_constraint_set_mix_y(
+      constraint,
+      mixY,
+    );
+  }
+
+  late final _spine_transform_constraint_set_mix_yPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Void Function(spine_transform_constraint,
+              ffi.Float)>>('spine_transform_constraint_set_mix_y');
+  late final _spine_transform_constraint_set_mix_y =
+      _spine_transform_constraint_set_mix_yPtr
+          .asFunction<void Function(spine_transform_constraint, double)>();
+
+  double spine_transform_constraint_get_mix_scale_x(
+    spine_transform_constraint constraint,
+  ) {
+    return _spine_transform_constraint_get_mix_scale_x(
+      constraint,
+    );
+  }
+
+  late final _spine_transform_constraint_get_mix_scale_xPtr = _lookup<
+          ffi.NativeFunction<ffi.Float Function(spine_transform_constraint)>>(
+      'spine_transform_constraint_get_mix_scale_x');
+  late final _spine_transform_constraint_get_mix_scale_x =
+      _spine_transform_constraint_get_mix_scale_xPtr
+          .asFunction<double Function(spine_transform_constraint)>();
+
+  void spine_transform_constraint_set_mix_scale_x(
+    spine_transform_constraint constraint,
+    double mixScaleX,
+  ) {
+    return _spine_transform_constraint_set_mix_scale_x(
+      constraint,
+      mixScaleX,
+    );
+  }
+
+  late final _spine_transform_constraint_set_mix_scale_xPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Void Function(spine_transform_constraint,
+              ffi.Float)>>('spine_transform_constraint_set_mix_scale_x');
+  late final _spine_transform_constraint_set_mix_scale_x =
+      _spine_transform_constraint_set_mix_scale_xPtr
+          .asFunction<void Function(spine_transform_constraint, double)>();
+
+  double spine_transform_constraint_get_mix_scale_y(
+    spine_transform_constraint constraint,
+  ) {
+    return _spine_transform_constraint_get_mix_scale_y(
+      constraint,
+    );
+  }
+
+  late final _spine_transform_constraint_get_mix_scale_yPtr = _lookup<
+          ffi.NativeFunction<ffi.Float Function(spine_transform_constraint)>>(
+      'spine_transform_constraint_get_mix_scale_y');
+  late final _spine_transform_constraint_get_mix_scale_y =
+      _spine_transform_constraint_get_mix_scale_yPtr
+          .asFunction<double Function(spine_transform_constraint)>();
+
+  void spine_transform_constraint_set_mix_scale_y(
+    spine_transform_constraint constraint,
+    double mixScaleY,
+  ) {
+    return _spine_transform_constraint_set_mix_scale_y(
+      constraint,
+      mixScaleY,
+    );
+  }
+
+  late final _spine_transform_constraint_set_mix_scale_yPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Void Function(spine_transform_constraint,
+              ffi.Float)>>('spine_transform_constraint_set_mix_scale_y');
+  late final _spine_transform_constraint_set_mix_scale_y =
+      _spine_transform_constraint_set_mix_scale_yPtr
+          .asFunction<void Function(spine_transform_constraint, double)>();
+
+  double spine_transform_constraint_get_mix_shear_y(
+    spine_transform_constraint constraint,
+  ) {
+    return _spine_transform_constraint_get_mix_shear_y(
+      constraint,
+    );
+  }
+
+  late final _spine_transform_constraint_get_mix_shear_yPtr = _lookup<
+          ffi.NativeFunction<ffi.Float Function(spine_transform_constraint)>>(
+      'spine_transform_constraint_get_mix_shear_y');
+  late final _spine_transform_constraint_get_mix_shear_y =
+      _spine_transform_constraint_get_mix_shear_yPtr
+          .asFunction<double Function(spine_transform_constraint)>();
+
+  void spine_transform_constraint_set_mix_shear_y(
+    spine_transform_constraint constraint,
+    double mixShearY,
+  ) {
+    return _spine_transform_constraint_set_mix_shear_y(
+      constraint,
+      mixShearY,
+    );
+  }
+
+  late final _spine_transform_constraint_set_mix_shear_yPtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Void Function(spine_transform_constraint,
+              ffi.Float)>>('spine_transform_constraint_set_mix_shear_y');
+  late final _spine_transform_constraint_set_mix_shear_y =
+      _spine_transform_constraint_set_mix_shear_yPtr
+          .asFunction<void Function(spine_transform_constraint, double)>();
+
+  double spine_transform_constraint_get_is_active(
+    spine_transform_constraint constraint,
+  ) {
+    return _spine_transform_constraint_get_is_active(
+      constraint,
+    );
+  }
+
+  late final _spine_transform_constraint_get_is_activePtr = _lookup<
+          ffi.NativeFunction<ffi.Float Function(spine_transform_constraint)>>(
+      'spine_transform_constraint_get_is_active');
+  late final _spine_transform_constraint_get_is_active =
+      _spine_transform_constraint_get_is_activePtr
+          .asFunction<double Function(spine_transform_constraint)>();
+
+  void spine_transform_constraint_set_is_active(
+    spine_transform_constraint constraint,
+    int isActive,
+  ) {
+    return _spine_transform_constraint_set_is_active(
+      constraint,
+      isActive,
+    );
+  }
+
+  late final _spine_transform_constraint_set_is_activePtr = _lookup<
+      ffi.NativeFunction<
+          ffi.Void Function(spine_transform_constraint,
+              ffi.Int32)>>('spine_transform_constraint_set_is_active');
+  late final _spine_transform_constraint_set_is_active =
+      _spine_transform_constraint_set_is_activePtr
+          .asFunction<void Function(spine_transform_constraint, int)>();
 }
 
 class spine_atlas extends ffi.Struct {

spine-flutter/src/spine_flutter.cpp

@@ -2487,3 +2487,129 @@ FFI_PLUGIN_EXPORT void spine_transform_constraint_data_set_is_local(spine_transf
     _data->setLocal(isLocal);
 }
 
+// TransformConstraint
+FFI_PLUGIN_EXPORT void spine_transform_constraint_update(spine_transform_constraint constraint) {
+    if (constraint == nullptr) return;
+    TransformConstraint *_constraint = (TransformConstraint*)constraint;
+    _constraint->update();
+}
+
+FFI_PLUGIN_EXPORT int spine_transform_constraint_get_order(spine_transform_constraint constraint) {
+    if (constraint == nullptr) return 0;
+    TransformConstraint *_constraint = (TransformConstraint*)constraint;
+    return _constraint->getOrder();
+}
+
+FFI_PLUGIN_EXPORT spine_transform_constraint_data spine_transform_constraint_get_data(spine_transform_constraint constraint) {
+    if (constraint == nullptr) return nullptr;
+    TransformConstraint *_constraint = (TransformConstraint*)constraint;
+    return (spine_transform_constraint_data)&_constraint->getData();
+}
+
+FFI_PLUGIN_EXPORT int spine_transform_constraint_get_num_bones(spine_transform_constraint constraint) {
+    if (constraint == nullptr) return 0;
+    TransformConstraint *_constraint = (TransformConstraint*)constraint;
+    return (int)_constraint->getBones().size();
+}
+
+FFI_PLUGIN_EXPORT spine_bone* spine_transform_constraint_get_bones(spine_transform_constraint constraint) {
+    if (constraint == nullptr) return nullptr;
+    TransformConstraint *_constraint = (TransformConstraint*)constraint;
+    return (spine_bone*)_constraint->getBones().buffer();
+}
+
+FFI_PLUGIN_EXPORT spine_bone spine_transform_constraint_get_target(spine_transform_constraint constraint) {
+    if (constraint == nullptr) return nullptr;
+    TransformConstraint *_constraint = (TransformConstraint*)constraint;
+    return _constraint->getTarget();
+}
+
+FFI_PLUGIN_EXPORT void spine_transform_constraint_set_target(spine_transform_constraint constraint, spine_bone target) {
+    if (constraint == nullptr) return;
+    TransformConstraint *_constraint = (TransformConstraint*)constraint;
+    _constraint->setTarget((Bone*)target);
+}
+
+FFI_PLUGIN_EXPORT float spine_transform_constraint_get_mix_rotate(spine_transform_constraint constraint) {
+    if (constraint == nullptr) return 0;
+    TransformConstraint *_constraint = (TransformConstraint*)constraint;
+    return _constraint->getMixRotate();
+}
+
+FFI_PLUGIN_EXPORT void spine_transform_constraint_set_mix_rotate(spine_transform_constraint constraint, float mixRotate) {
+    if (constraint == nullptr) return;
+    TransformConstraint *_constraint = (TransformConstraint*)constraint;
+    _constraint->setMixRotate(mixRotate);
+}
+
+FFI_PLUGIN_EXPORT float spine_transform_constraint_get_mix_x(spine_transform_constraint constraint) {
+    if (constraint == nullptr) return 0;
+    TransformConstraint *_constraint = (TransformConstraint*)constraint;
+    return _constraint->getMixX();
+}
+
+FFI_PLUGIN_EXPORT void spine_transform_constraint_set_mix_x(spine_transform_constraint constraint, float mixX) {
+    if (constraint == nullptr) return;
+    TransformConstraint *_constraint = (TransformConstraint*)constraint;
+    _constraint->setMixX(mixX);
+}
+
+FFI_PLUGIN_EXPORT float spine_transform_constraint_get_mix_y(spine_transform_constraint constraint) {
+    if (constraint == nullptr) return 0;
+    TransformConstraint *_constraint = (TransformConstraint*)constraint;
+    return _constraint->getMixY();
+}
+
+FFI_PLUGIN_EXPORT void spine_transform_constraint_set_mix_y(spine_transform_constraint constraint, float mixY) {
+    if (constraint == nullptr) return;
+    TransformConstraint *_constraint = (TransformConstraint*)constraint;
+    _constraint->setMixY(mixY);
+}
+
+FFI_PLUGIN_EXPORT float spine_transform_constraint_get_mix_scale_x(spine_transform_constraint constraint) {
+    if (constraint == nullptr) return 0;
+    TransformConstraint *_constraint = (TransformConstraint*)constraint;
+    return _constraint->getMixScaleX();
+}
+
+FFI_PLUGIN_EXPORT void spine_transform_constraint_set_mix_scale_x(spine_transform_constraint constraint, float mixScaleX) {
+    if (constraint == nullptr) return;
+    TransformConstraint *_constraint = (TransformConstraint*)constraint;
+    _constraint->setMixScaleX(mixScaleX);
+}
+
+FFI_PLUGIN_EXPORT float spine_transform_constraint_get_mix_scale_y(spine_transform_constraint constraint) {
+    if (constraint == nullptr) return 0;
+    TransformConstraint *_constraint = (TransformConstraint*)constraint;
+    return _constraint->getMixScaleY();
+}
+
+FFI_PLUGIN_EXPORT void spine_transform_constraint_set_mix_scale_y(spine_transform_constraint constraint, float mixScaleY) {
+    if (constraint == nullptr) return;
+    TransformConstraint *_constraint = (TransformConstraint*)constraint;
+    _constraint->setMixScaleY(mixScaleY);
+}
+
+FFI_PLUGIN_EXPORT float spine_transform_constraint_get_mix_shear_y(spine_transform_constraint constraint) {
+    if (constraint == nullptr) return 0;
+    TransformConstraint *_constraint = (TransformConstraint*)constraint;
+    return _constraint->getMixShearY();
+}
+
+FFI_PLUGIN_EXPORT void spine_transform_constraint_set_mix_shear_y(spine_transform_constraint constraint, float mixShearY) {
+    if (constraint == nullptr) return;
+    TransformConstraint *_constraint = (TransformConstraint*)constraint;
+    _constraint->setMixShearY(mixShearY);
+}
+
+FFI_PLUGIN_EXPORT float spine_transform_constraint_get_is_active(spine_transform_constraint constraint) {
+    if (constraint == nullptr) return 0;
+    TransformConstraint *_constraint = (TransformConstraint*)constraint;
+    return _constraint->isActive() ? -1 : 0;
+}
+
+FFI_PLUGIN_EXPORT void spine_transform_constraint_set_is_active(spine_transform_constraint constraint, int isActive) {
+    if (constraint == nullptr) return;
+    TransformConstraint *_constraint = (TransformConstraint*)constraint;
+    _constraint->setActive(isActive);
+}

spine-flutter/src/spine_flutter.h

@@ -533,4 +533,28 @@ FFI_PLUGIN_EXPORT void spine_transform_constraint_data_set_offset_shear_y(spine_
 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);
+FFI_PLUGIN_EXPORT void spine_transform_constraint_data_set_is_local(spine_transform_constraint_data data, int isLocal);
+
+FFI_PLUGIN_EXPORT void spine_transform_constraint_update(spine_transform_constraint constraint);
+FFI_PLUGIN_EXPORT int spine_transform_constraint_get_order(spine_transform_constraint constraint);
+FFI_PLUGIN_EXPORT spine_transform_constraint_data spine_transform_constraint_get_data(spine_transform_constraint constraint);
+FFI_PLUGIN_EXPORT int spine_transform_constraint_get_num_bones(spine_transform_constraint constraint);
+FFI_PLUGIN_EXPORT spine_bone* spine_transform_constraint_get_bones(spine_transform_constraint constraint);
+FFI_PLUGIN_EXPORT spine_bone spine_transform_constraint_get_target(spine_transform_constraint constraint);
+FFI_PLUGIN_EXPORT void spine_transform_constraint_set_target(spine_transform_constraint constraint, spine_bone target);
+FFI_PLUGIN_EXPORT float spine_transform_constraint_get_mix_rotate(spine_transform_constraint constraint);
+FFI_PLUGIN_EXPORT void spine_transform_constraint_set_mix_rotate(spine_transform_constraint constraint, float mixRotate);
+FFI_PLUGIN_EXPORT float spine_transform_constraint_get_mix_x(spine_transform_constraint constraint);
+FFI_PLUGIN_EXPORT void spine_transform_constraint_set_mix_x(spine_transform_constraint constraint, float mixX);
+FFI_PLUGIN_EXPORT float spine_transform_constraint_get_mix_y(spine_transform_constraint constraint);
+FFI_PLUGIN_EXPORT void spine_transform_constraint_set_mix_y(spine_transform_constraint constraint, float mixY);
+FFI_PLUGIN_EXPORT float spine_transform_constraint_get_mix_scale_x(spine_transform_constraint constraint);
+FFI_PLUGIN_EXPORT void spine_transform_constraint_set_mix_scale_x(spine_transform_constraint constraint, float mixScaleX);
+FFI_PLUGIN_EXPORT float spine_transform_constraint_get_mix_scale_y(spine_transform_constraint constraint);
+FFI_PLUGIN_EXPORT void spine_transform_constraint_set_mix_scale_y(spine_transform_constraint constraint, float mixScaleY);
+FFI_PLUGIN_EXPORT float spine_transform_constraint_get_mix_shear_y(spine_transform_constraint constraint);
+FFI_PLUGIN_EXPORT void spine_transform_constraint_set_mix_shear_y(spine_transform_constraint constraint, float mixShearY);
+FFI_PLUGIN_EXPORT float spine_transform_constraint_get_is_active(spine_transform_constraint constraint);
+FFI_PLUGIN_EXPORT void spine_transform_constraint_set_is_active(spine_transform_constraint constraint, int isActive);
+
+