[dart] Formatting

spine-flutter/.vscode/launch.json

@@ -40,6 +40,13 @@
             "request": "launch",
             "type": "dart",
             "flutterMode": "release"
+        },
+        {
+            "name": "headless-test (dart)",
+            "cwd": "test",
+            "request": "launch",
+            "type": "dart",
+            "program": "bin/headless_test.dart"
         }
     ]
 }

spine-flutter/example/lib/flame_example.dart

@@ -50,8 +50,8 @@ class SpineComponent extends PositionComponent {
     Anchor super.anchor = Anchor.topLeft,
     super.children,
     super.priority,
-  }) : _ownsDrawable = ownsDrawable,
+  })  : _ownsDrawable = ownsDrawable,
-       _boundsProvider = boundsProvider {
+        _boundsProvider = boundsProvider {
     _drawable.update(0);
     _bounds = _boundsProvider.computeBounds(_drawable);
     size = Vector2(_bounds.width, _bounds.height);

spine-flutter/lib/extensions.dart

@@ -240,7 +240,8 @@ class SkeletonData {
     final Pointer<Uint8> binaryNative = _allocator.allocate(binary.lengthInBytes);
     binaryNative.asTypedList(binary.lengthInBytes).setAll(0, binary);
     final path = "".toNativeUtf8(allocator: _allocator);
-    final result = _bindings.spine_skeleton_data_load_binary(atlas._atlas, binaryNative.cast(), binary.lengthInBytes, path.cast());
+    final result =
+        _bindings.spine_skeleton_data_load_binary(atlas._atlas, binaryNative.cast(), binary.lengthInBytes, path.cast());
     _allocator.free(binaryNative);
     if (_bindings.spine_skeleton_data_result_get_error(result).address != nullptr.address) {
       final Pointer<Utf8> error = _bindings.spine_skeleton_data_result_get_error(result).cast();
@@ -4184,9 +4185,12 @@ class SkeletonDrawable {
   Future<RawImageData> renderToRawImageData(double width, double height, int bgColor) async {
     final recorder = renderToPictureRecorder(width, height, bgColor);
     var rawImageData = (await (await recorder.endRecording().toImage(
-      width.toInt(),
+                  width.toInt(),
-      height.toInt(),
+                  height.toInt(),
-    )).toByteData(format: ImageByteFormat.rawRgba))!.buffer.asUint8List();
+                ))
+            .toByteData(format: ImageByteFormat.rawRgba))!
+        .buffer
+        .asUint8List();
     return RawImageData(rawImageData, width.toInt(), height.toInt());
   }
 

spine-flutter/lib/generated/alpha_timeline.dart

@@ -46,15 +46,13 @@ class AlphaTimeline extends CurveTimeline1 implements SlotTimeline {
   Pointer get nativePtr => _ptr;
 
   factory AlphaTimeline(int frameCount, int bezierCount, int slotIndex) {
-    final ptr = SpineBindings.bindings
+    final ptr = SpineBindings.bindings.spine_alpha_timeline_create(frameCount, bezierCount, slotIndex);
-        .spine_alpha_timeline_create(frameCount, bezierCount, slotIndex);
     return AlphaTimeline.fromPointer(ptr);
   }
 
   @override
   int get slotIndex {
-    final result =
+    final result = SpineBindings.bindings.spine_alpha_timeline_get_slot_index(_ptr);
-        SpineBindings.bindings.spine_alpha_timeline_get_slot_index(_ptr);
     return result;
   }
 

spine-flutter/lib/generated/animation.dart

@@ -48,8 +48,8 @@ class Animation implements Finalizable {
   Pointer get nativePtr => _ptr;
 
   factory Animation(String name, ArrayTimeline timelines, double duration) {
-    final ptr = SpineBindings.bindings.spine_animation_create(
+    final ptr = SpineBindings.bindings
-        name.toNativeUtf8().cast<Char>(), timelines.nativePtr.cast(), duration);
+        .spine_animation_create(name.toNativeUtf8().cast<Char>(), timelines.nativePtr.cast(), duration);
     return Animation.fromPointer(ptr);
   }
 
@@ -59,13 +59,11 @@ class Animation implements Finalizable {
   }
 
   set timelines(ArrayTimeline value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_animation_set_timelines(_ptr, value.nativePtr.cast());
-        .spine_animation_set_timelines(_ptr, value.nativePtr.cast());
   }
 
   bool hasTimeline(ArrayPropertyId ids) {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_animation_has_timeline(_ptr, ids.nativePtr.cast());
-        .spine_animation_has_timeline(_ptr, ids.nativePtr.cast());
     return result;
   }
 
@@ -78,27 +76,10 @@ class Animation implements Finalizable {
     SpineBindings.bindings.spine_animation_set_duration(_ptr, value);
   }
 
-  void apply(
+  void apply(Skeleton skeleton, double lastTime, double time, bool loop, ArrayEvent pEvents, double alpha,
-      Skeleton skeleton,
+      MixBlend blend, MixDirection direction, bool appliedPose) {
-      double lastTime,
+    SpineBindings.bindings.spine_animation_apply(_ptr, skeleton.nativePtr.cast(), lastTime, time, loop,
-      double time,
+        pEvents.nativePtr.cast(), alpha, blend.value, direction.value, appliedPose);
-      bool loop,
-      ArrayEvent pEvents,
-      double alpha,
-      MixBlend blend,
-      MixDirection direction,
-      bool appliedPose) {
-    SpineBindings.bindings.spine_animation_apply(
-        _ptr,
-        skeleton.nativePtr.cast(),
-        lastTime,
-        time,
-        loop,
-        pEvents.nativePtr.cast(),
-        alpha,
-        blend.value,
-        direction.value,
-        appliedPose);
   }
 
   String get name {
@@ -112,14 +93,12 @@ class Animation implements Finalizable {
   }
 
   static int search(ArrayFloat values, double target) {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_animation_search_1(values.nativePtr.cast(), target);
-        .spine_animation_search_1(values.nativePtr.cast(), target);
     return result;
   }
 
   static int search2(ArrayFloat values, double target, int step) {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_animation_search_2(values.nativePtr.cast(), target, step);
-        .spine_animation_search_2(values.nativePtr.cast(), target, step);
     return result;
   }
 }

spine-flutter/lib/generated/animation_state.dart

@@ -49,8 +49,7 @@ class AnimationState implements Finalizable {
   Pointer get nativePtr => _ptr;
 
   factory AnimationState(AnimationStateData data) {
-    final ptr = SpineBindings.bindings
+    final ptr = SpineBindings.bindings.spine_animation_state_create(data.nativePtr.cast());
-        .spine_animation_state_create(data.nativePtr.cast());
     return AnimationState.fromPointer(ptr);
   }
 
@@ -59,8 +58,7 @@ class AnimationState implements Finalizable {
   }
 
   bool apply(Skeleton skeleton) {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_animation_state_apply(_ptr, skeleton.nativePtr.cast());
-        .spine_animation_state_apply(_ptr, skeleton.nativePtr.cast());
     return result;
   }
 
@@ -73,28 +71,22 @@ class AnimationState implements Finalizable {
   }
 
   TrackEntry setEmptyAnimation(int trackIndex, double mixDuration) {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_animation_state_set_empty_animation(_ptr, trackIndex, mixDuration);
-        .spine_animation_state_set_empty_animation(
-            _ptr, trackIndex, mixDuration);
     return TrackEntry.fromPointer(result);
   }
 
-  TrackEntry addEmptyAnimation(
+  TrackEntry addEmptyAnimation(int trackIndex, double mixDuration, double delay) {
-      int trackIndex, double mixDuration, double delay) {
+    final result =
-    final result = SpineBindings.bindings
+        SpineBindings.bindings.spine_animation_state_add_empty_animation(_ptr, trackIndex, mixDuration, delay);
-        .spine_animation_state_add_empty_animation(
-            _ptr, trackIndex, mixDuration, delay);
     return TrackEntry.fromPointer(result);
   }
 
   set emptyAnimations(double value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_animation_state_set_empty_animations(_ptr, value);
-        .spine_animation_state_set_empty_animations(_ptr, value);
   }
 
   TrackEntry getCurrent(int trackIndex) {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_animation_state_get_current(_ptr, trackIndex);
-        .spine_animation_state_get_current(_ptr, trackIndex);
     return TrackEntry.fromPointer(result);
   }
 
@@ -104,14 +96,12 @@ class AnimationState implements Finalizable {
   }
 
   ArrayTrackEntry get tracks {
-    final result =
+    final result = SpineBindings.bindings.spine_animation_state_get_tracks(_ptr);
-        SpineBindings.bindings.spine_animation_state_get_tracks(_ptr);
     return ArrayTrackEntry.fromPointer(result);
   }
 
   double get timeScale {
-    final result =
+    final result = SpineBindings.bindings.spine_animation_state_get_time_scale(_ptr);
-        SpineBindings.bindings.spine_animation_state_get_time_scale(_ptr);
     return result;
   }
 
@@ -128,54 +118,44 @@ class AnimationState implements Finalizable {
   }
 
   set manualTrackEntryDisposal(bool value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_animation_state_set_manual_track_entry_disposal(_ptr, value);
-        .spine_animation_state_set_manual_track_entry_disposal(_ptr, value);
   }
 
   bool get manualTrackEntryDisposal {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_animation_state_get_manual_track_entry_disposal(_ptr);
-        .spine_animation_state_get_manual_track_entry_disposal(_ptr);
     return result;
   }
 
   void disposeTrackEntry(TrackEntry entry) {
-    SpineBindings.bindings.spine_animation_state_dispose_track_entry(
+    SpineBindings.bindings.spine_animation_state_dispose_track_entry(_ptr, entry.nativePtr.cast());
-        _ptr, entry.nativePtr.cast());
   }
 
   Pointer<Void> get rendererObject {
-    final result =
+    final result = SpineBindings.bindings.spine_animation_state_get_renderer_object(_ptr);
-        SpineBindings.bindings.spine_animation_state_get_renderer_object(_ptr);
     return result;
   }
 
   TrackEntry setAnimation(int trackIndex, String animationName, bool loop) {
-    final result = SpineBindings.bindings.spine_animation_state_set_animation_1(
+    final result = SpineBindings.bindings
-        _ptr, trackIndex, animationName.toNativeUtf8().cast<Char>(), loop);
+        .spine_animation_state_set_animation_1(_ptr, trackIndex, animationName.toNativeUtf8().cast<Char>(), loop);
     return TrackEntry.fromPointer(result);
   }
 
   TrackEntry setAnimation2(int trackIndex, Animation animation, bool loop) {
-    final result = SpineBindings.bindings.spine_animation_state_set_animation_2(
+    final result = SpineBindings.bindings
-        _ptr, trackIndex, animation.nativePtr.cast(), loop);
+        .spine_animation_state_set_animation_2(_ptr, trackIndex, animation.nativePtr.cast(), loop);
     return TrackEntry.fromPointer(result);
   }
 
-  TrackEntry addAnimation(
+  TrackEntry addAnimation(int trackIndex, String animationName, bool loop, double delay) {
-      int trackIndex, String animationName, bool loop, double delay) {
     final result = SpineBindings.bindings.spine_animation_state_add_animation_1(
-        _ptr,
+        _ptr, trackIndex, animationName.toNativeUtf8().cast<Char>(), loop, delay);
-        trackIndex,
-        animationName.toNativeUtf8().cast<Char>(),
-        loop,
-        delay);
     return TrackEntry.fromPointer(result);
   }
 
-  TrackEntry addAnimation2(
+  TrackEntry addAnimation2(int trackIndex, Animation animation, bool loop, double delay) {
-      int trackIndex, Animation animation, bool loop, double delay) {
+    final result = SpineBindings.bindings
-    final result = SpineBindings.bindings.spine_animation_state_add_animation_2(
+        .spine_animation_state_add_animation_2(_ptr, trackIndex, animation.nativePtr.cast(), loop, delay);
-        _ptr, trackIndex, animation.nativePtr.cast(), loop, delay);
     return TrackEntry.fromPointer(result);
   }
 }

spine-flutter/lib/generated/animation_state_data.dart

@@ -46,31 +46,27 @@ class AnimationStateData implements Finalizable {
   Pointer get nativePtr => _ptr;
 
   factory AnimationStateData(SkeletonData skeletonData) {
-    final ptr = SpineBindings.bindings
+    final ptr = SpineBindings.bindings.spine_animation_state_data_create(skeletonData.nativePtr.cast());
-        .spine_animation_state_data_create(skeletonData.nativePtr.cast());
     return AnimationStateData.fromPointer(ptr);
   }
 
   SkeletonData get skeletonData {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_animation_state_data_get_skeleton_data(_ptr);
-        .spine_animation_state_data_get_skeleton_data(_ptr);
     return SkeletonData.fromPointer(result);
   }
 
   double get defaultMix {
-    final result =
+    final result = SpineBindings.bindings.spine_animation_state_data_get_default_mix(_ptr);
-        SpineBindings.bindings.spine_animation_state_data_get_default_mix(_ptr);
     return result;
   }
 
   set defaultMix(double value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_animation_state_data_set_default_mix(_ptr, value);
-        .spine_animation_state_data_set_default_mix(_ptr, value);
   }
 
   double getMix(Animation from, Animation to) {
-    final result = SpineBindings.bindings.spine_animation_state_data_get_mix(
+    final result =
-        _ptr, from.nativePtr.cast(), to.nativePtr.cast());
+        SpineBindings.bindings.spine_animation_state_data_get_mix(_ptr, from.nativePtr.cast(), to.nativePtr.cast());
     return result;
   }
 
@@ -80,14 +76,11 @@ class AnimationStateData implements Finalizable {
 
   void setMix(String fromName, String toName, double duration) {
     SpineBindings.bindings.spine_animation_state_data_set_mix_1(
-        _ptr,
+        _ptr, fromName.toNativeUtf8().cast<Char>(), toName.toNativeUtf8().cast<Char>(), duration);
-        fromName.toNativeUtf8().cast<Char>(),
-        toName.toNativeUtf8().cast<Char>(),
-        duration);
   }
 
   void setMix2(Animation from, Animation to, double duration) {
-    SpineBindings.bindings.spine_animation_state_data_set_mix_2(
+    SpineBindings.bindings
-        _ptr, from.nativePtr.cast(), to.nativePtr.cast(), duration);
+        .spine_animation_state_data_set_mix_2(_ptr, from.nativePtr.cast(), to.nativePtr.cast(), duration);
   }
 }

spine-flutter/lib/generated/arrays.dart

@@ -134,8 +134,7 @@ class ArrayFloat extends NativeArray<double> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer =
+    final buffer = SpineBindings.bindings.spine_array_float_buffer(nativePtr.cast());
-        SpineBindings.bindings.spine_array_float_buffer(nativePtr.cast());
     return buffer.cast<Float>()[index];
   }
 }
@@ -154,21 +153,18 @@ class ArrayInt extends NativeArray<int> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer =
+    final buffer = SpineBindings.bindings.spine_array_int_buffer(nativePtr.cast());
-        SpineBindings.bindings.spine_array_int_buffer(nativePtr.cast());
     return buffer.cast<Int32>()[index];
   }
 }
 
 /// ArrayUnsignedShort wrapper
 class ArrayUnsignedShort extends NativeArray<int> {
-  ArrayUnsignedShort.fromPointer(
+  ArrayUnsignedShort.fromPointer(Pointer<spine_array_unsigned_short_wrapper> super.ptr);
-      Pointer<spine_array_unsigned_short_wrapper> super.ptr);
 
   @override
   int get length {
-    return SpineBindings.bindings
+    return SpineBindings.bindings.spine_array_unsigned_short_size(nativePtr.cast());
-        .spine_array_unsigned_short_size(nativePtr.cast());
   }
 
   @override
@@ -176,21 +172,18 @@ class ArrayUnsignedShort extends NativeArray<int> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer = SpineBindings.bindings
+    final buffer = SpineBindings.bindings.spine_array_unsigned_short_buffer(nativePtr.cast());
-        .spine_array_unsigned_short_buffer(nativePtr.cast());
     return buffer.cast<Uint16>()[index];
   }
 }
 
 /// ArrayPropertyId wrapper
 class ArrayPropertyId extends NativeArray<int> {
-  ArrayPropertyId.fromPointer(
+  ArrayPropertyId.fromPointer(Pointer<spine_array_property_id_wrapper> super.ptr);
-      Pointer<spine_array_property_id_wrapper> super.ptr);
 
   @override
   int get length {
-    return SpineBindings.bindings
+    return SpineBindings.bindings.spine_array_property_id_size(nativePtr.cast());
-        .spine_array_property_id_size(nativePtr.cast());
   }
 
   @override
@@ -198,8 +191,7 @@ class ArrayPropertyId extends NativeArray<int> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer =
+    final buffer = SpineBindings.bindings.spine_array_property_id_buffer(nativePtr.cast());
-        SpineBindings.bindings.spine_array_property_id_buffer(nativePtr.cast());
     // NOTE: This will not compile due to C API bug - buffer() returns int instead of Pointer
     return buffer.cast<Int64>()[index];
   }
@@ -219,8 +211,7 @@ class ArrayAnimation extends NativeArray<Animation> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer =
+    final buffer = SpineBindings.bindings.spine_array_animation_buffer(nativePtr.cast());
-        SpineBindings.bindings.spine_array_animation_buffer(nativePtr.cast());
     return Animation.fromPointer(buffer[index]);
   }
 }
@@ -239,21 +230,18 @@ class ArrayAtlasPage extends NativeArray<AtlasPage> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer =
+    final buffer = SpineBindings.bindings.spine_array_atlas_page_buffer(nativePtr.cast());
-        SpineBindings.bindings.spine_array_atlas_page_buffer(nativePtr.cast());
     return AtlasPage.fromPointer(buffer[index]);
   }
 }
 
 /// ArrayAtlasRegion wrapper
 class ArrayAtlasRegion extends NativeArray<AtlasRegion> {
-  ArrayAtlasRegion.fromPointer(
+  ArrayAtlasRegion.fromPointer(Pointer<spine_array_atlas_region_wrapper> super.ptr);
-      Pointer<spine_array_atlas_region_wrapper> super.ptr);
 
   @override
   int get length {
-    return SpineBindings.bindings
+    return SpineBindings.bindings.spine_array_atlas_region_size(nativePtr.cast());
-        .spine_array_atlas_region_size(nativePtr.cast());
   }
 
   @override
@@ -261,16 +249,14 @@ class ArrayAtlasRegion extends NativeArray<AtlasRegion> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer = SpineBindings.bindings
+    final buffer = SpineBindings.bindings.spine_array_atlas_region_buffer(nativePtr.cast());
-        .spine_array_atlas_region_buffer(nativePtr.cast());
     return AtlasRegion.fromPointer(buffer[index]);
   }
 }
 
 /// ArrayAttachment wrapper
 class ArrayAttachment extends NativeArray<Attachment> {
-  ArrayAttachment.fromPointer(
+  ArrayAttachment.fromPointer(Pointer<spine_array_attachment_wrapper> super.ptr);
-      Pointer<spine_array_attachment_wrapper> super.ptr);
 
   @override
   int get length {
@@ -282,14 +268,9 @@ class ArrayAttachment extends NativeArray<Attachment> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer =
+    final buffer = SpineBindings.bindings.spine_array_attachment_buffer(nativePtr.cast());
-        SpineBindings.bindings.spine_array_attachment_buffer(nativePtr.cast());
+    final rtti = SpineBindings.bindings.spine_attachment_get_rtti(buffer[index]);
-    final rtti =
+    final className = SpineBindings.bindings.spine_rtti_get_class_name(rtti).cast<Utf8>().toDartString();
-        SpineBindings.bindings.spine_attachment_get_rtti(buffer[index]);
-    final className = SpineBindings.bindings
-        .spine_rtti_get_class_name(rtti)
-        .cast<Utf8>()
-        .toDartString();
     switch (className) {
       case 'spine_bounding_box_attachment':
         return BoundingBoxAttachment.fromPointer(buffer[index].cast());
@@ -304,8 +285,7 @@ class ArrayAttachment extends NativeArray<Attachment> {
       case 'spine_region_attachment':
         return RegionAttachment.fromPointer(buffer[index].cast());
       default:
-        throw UnsupportedError(
+        throw UnsupportedError('Unknown concrete type: $className for abstract class Attachment');
-            'Unknown concrete type: $className for abstract class Attachment');
     }
   }
 }
@@ -324,8 +304,7 @@ class ArrayBone extends NativeArray<Bone> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer =
+    final buffer = SpineBindings.bindings.spine_array_bone_buffer(nativePtr.cast());
-        SpineBindings.bindings.spine_array_bone_buffer(nativePtr.cast());
     return Bone.fromPointer(buffer[index]);
   }
 }
@@ -344,8 +323,7 @@ class ArrayBoneData extends NativeArray<BoneData> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer =
+    final buffer = SpineBindings.bindings.spine_array_bone_data_buffer(nativePtr.cast());
-        SpineBindings.bindings.spine_array_bone_data_buffer(nativePtr.cast());
     return BoneData.fromPointer(buffer[index]);
   }
 }
@@ -364,21 +342,18 @@ class ArrayBonePose extends NativeArray<BonePose> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer =
+    final buffer = SpineBindings.bindings.spine_array_bone_pose_buffer(nativePtr.cast());
-        SpineBindings.bindings.spine_array_bone_pose_buffer(nativePtr.cast());
     return BonePose.fromPointer(buffer[index]);
   }
 }
 
 /// ArrayBoundingBoxAttachment wrapper
 class ArrayBoundingBoxAttachment extends NativeArray<BoundingBoxAttachment> {
-  ArrayBoundingBoxAttachment.fromPointer(
+  ArrayBoundingBoxAttachment.fromPointer(Pointer<spine_array_bounding_box_attachment_wrapper> super.ptr);
-      Pointer<spine_array_bounding_box_attachment_wrapper> super.ptr);
 
   @override
   int get length {
-    return SpineBindings.bindings
+    return SpineBindings.bindings.spine_array_bounding_box_attachment_size(nativePtr.cast());
-        .spine_array_bounding_box_attachment_size(nativePtr.cast());
   }
 
   @override
@@ -386,16 +361,14 @@ class ArrayBoundingBoxAttachment extends NativeArray<BoundingBoxAttachment> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer = SpineBindings.bindings
+    final buffer = SpineBindings.bindings.spine_array_bounding_box_attachment_buffer(nativePtr.cast());
-        .spine_array_bounding_box_attachment_buffer(nativePtr.cast());
     return BoundingBoxAttachment.fromPointer(buffer[index]);
   }
 }
 
 /// ArrayConstraint wrapper
 class ArrayConstraint extends NativeArray<Constraint> {
-  ArrayConstraint.fromPointer(
+  ArrayConstraint.fromPointer(Pointer<spine_array_constraint_wrapper> super.ptr);
-      Pointer<spine_array_constraint_wrapper> super.ptr);
 
   @override
   int get length {
@@ -407,14 +380,9 @@ class ArrayConstraint extends NativeArray<Constraint> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer =
+    final buffer = SpineBindings.bindings.spine_array_constraint_buffer(nativePtr.cast());
-        SpineBindings.bindings.spine_array_constraint_buffer(nativePtr.cast());
+    final rtti = SpineBindings.bindings.spine_constraint_get_rtti(buffer[index]);
-    final rtti =
+    final className = SpineBindings.bindings.spine_rtti_get_class_name(rtti).cast<Utf8>().toDartString();
-        SpineBindings.bindings.spine_constraint_get_rtti(buffer[index]);
-    final className = SpineBindings.bindings
-        .spine_rtti_get_class_name(rtti)
-        .cast<Utf8>()
-        .toDartString();
     switch (className) {
       case 'spine_ik_constraint':
         return IkConstraint.fromPointer(buffer[index].cast());
@@ -427,21 +395,18 @@ class ArrayConstraint extends NativeArray<Constraint> {
       case 'spine_transform_constraint':
         return TransformConstraint.fromPointer(buffer[index].cast());
       default:
-        throw UnsupportedError(
+        throw UnsupportedError('Unknown concrete type: $className for abstract class Constraint');
-            'Unknown concrete type: $className for abstract class Constraint');
     }
   }
 }
 
 /// ArrayConstraintData wrapper
 class ArrayConstraintData extends NativeArray<ConstraintData> {
-  ArrayConstraintData.fromPointer(
+  ArrayConstraintData.fromPointer(Pointer<spine_array_constraint_data_wrapper> super.ptr);
-      Pointer<spine_array_constraint_data_wrapper> super.ptr);
 
   @override
   int get length {
-    return SpineBindings.bindings
+    return SpineBindings.bindings.spine_array_constraint_data_size(nativePtr.cast());
-        .spine_array_constraint_data_size(nativePtr.cast());
   }
 
   @override
@@ -449,14 +414,9 @@ class ArrayConstraintData extends NativeArray<ConstraintData> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer = SpineBindings.bindings
+    final buffer = SpineBindings.bindings.spine_array_constraint_data_buffer(nativePtr.cast());
-        .spine_array_constraint_data_buffer(nativePtr.cast());
+    final rtti = SpineBindings.bindings.spine_constraint_data_get_rtti(buffer[index]);
-    final rtti =
+    final className = SpineBindings.bindings.spine_rtti_get_class_name(rtti).cast<Utf8>().toDartString();
-        SpineBindings.bindings.spine_constraint_data_get_rtti(buffer[index]);
-    final className = SpineBindings.bindings
-        .spine_rtti_get_class_name(rtti)
-        .cast<Utf8>()
-        .toDartString();
     switch (className) {
       case 'spine_ik_constraint_data':
         return IkConstraintData.fromPointer(buffer[index].cast());
@@ -469,8 +429,7 @@ class ArrayConstraintData extends NativeArray<ConstraintData> {
       case 'spine_transform_constraint_data':
         return TransformConstraintData.fromPointer(buffer[index].cast());
       default:
-        throw UnsupportedError(
+        throw UnsupportedError('Unknown concrete type: $className for abstract class ConstraintData');
-            'Unknown concrete type: $className for abstract class ConstraintData');
     }
   }
 }
@@ -489,8 +448,7 @@ class ArrayEvent extends NativeArray<Event> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer =
+    final buffer = SpineBindings.bindings.spine_array_event_buffer(nativePtr.cast());
-        SpineBindings.bindings.spine_array_event_buffer(nativePtr.cast());
     return Event.fromPointer(buffer[index]);
   }
 }
@@ -509,21 +467,18 @@ class ArrayEventData extends NativeArray<EventData> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer =
+    final buffer = SpineBindings.bindings.spine_array_event_data_buffer(nativePtr.cast());
-        SpineBindings.bindings.spine_array_event_data_buffer(nativePtr.cast());
     return EventData.fromPointer(buffer[index]);
   }
 }
 
 /// ArrayFromProperty wrapper
 class ArrayFromProperty extends NativeArray<FromProperty> {
-  ArrayFromProperty.fromPointer(
+  ArrayFromProperty.fromPointer(Pointer<spine_array_from_property_wrapper> super.ptr);
-      Pointer<spine_array_from_property_wrapper> super.ptr);
 
   @override
   int get length {
-    return SpineBindings.bindings
+    return SpineBindings.bindings.spine_array_from_property_size(nativePtr.cast());
-        .spine_array_from_property_size(nativePtr.cast());
   }
 
   @override
@@ -531,14 +486,9 @@ class ArrayFromProperty extends NativeArray<FromProperty> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer = SpineBindings.bindings
+    final buffer = SpineBindings.bindings.spine_array_from_property_buffer(nativePtr.cast());
-        .spine_array_from_property_buffer(nativePtr.cast());
+    final rtti = SpineBindings.bindings.spine_from_property_get_rtti(buffer[index]);
-    final rtti =
+    final className = SpineBindings.bindings.spine_rtti_get_class_name(rtti).cast<Utf8>().toDartString();
-        SpineBindings.bindings.spine_from_property_get_rtti(buffer[index]);
-    final className = SpineBindings.bindings
-        .spine_rtti_get_class_name(rtti)
-        .cast<Utf8>()
-        .toDartString();
     switch (className) {
       case 'spine_from_rotate':
         return FromRotate.fromPointer(buffer[index].cast());
@@ -553,21 +503,18 @@ class ArrayFromProperty extends NativeArray<FromProperty> {
       case 'spine_from_y':
         return FromY.fromPointer(buffer[index].cast());
       default:
-        throw UnsupportedError(
+        throw UnsupportedError('Unknown concrete type: $className for abstract class FromProperty');
-            'Unknown concrete type: $className for abstract class FromProperty');
     }
   }
 }
 
 /// ArrayPhysicsConstraint wrapper
 class ArrayPhysicsConstraint extends NativeArray<PhysicsConstraint> {
-  ArrayPhysicsConstraint.fromPointer(
+  ArrayPhysicsConstraint.fromPointer(Pointer<spine_array_physics_constraint_wrapper> super.ptr);
-      Pointer<spine_array_physics_constraint_wrapper> super.ptr);
 
   @override
   int get length {
-    return SpineBindings.bindings
+    return SpineBindings.bindings.spine_array_physics_constraint_size(nativePtr.cast());
-        .spine_array_physics_constraint_size(nativePtr.cast());
   }
 
   @override
@@ -575,8 +522,7 @@ class ArrayPhysicsConstraint extends NativeArray<PhysicsConstraint> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer = SpineBindings.bindings
+    final buffer = SpineBindings.bindings.spine_array_physics_constraint_buffer(nativePtr.cast());
-        .spine_array_physics_constraint_buffer(nativePtr.cast());
     return PhysicsConstraint.fromPointer(buffer[index]);
   }
 }
@@ -595,8 +541,7 @@ class ArrayPolygon extends NativeArray<Polygon> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer =
+    final buffer = SpineBindings.bindings.spine_array_polygon_buffer(nativePtr.cast());
-        SpineBindings.bindings.spine_array_polygon_buffer(nativePtr.cast());
     return Polygon.fromPointer(buffer[index]);
   }
 }
@@ -615,8 +560,7 @@ class ArraySkin extends NativeArray<Skin> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer =
+    final buffer = SpineBindings.bindings.spine_array_skin_buffer(nativePtr.cast());
-        SpineBindings.bindings.spine_array_skin_buffer(nativePtr.cast());
     return Skin.fromPointer(buffer[index]);
   }
 }
@@ -635,8 +579,7 @@ class ArraySlot extends NativeArray<Slot> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer =
+    final buffer = SpineBindings.bindings.spine_array_slot_buffer(nativePtr.cast());
-        SpineBindings.bindings.spine_array_slot_buffer(nativePtr.cast());
     return Slot.fromPointer(buffer[index]);
   }
 }
@@ -655,21 +598,18 @@ class ArraySlotData extends NativeArray<SlotData> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer =
+    final buffer = SpineBindings.bindings.spine_array_slot_data_buffer(nativePtr.cast());
-        SpineBindings.bindings.spine_array_slot_data_buffer(nativePtr.cast());
     return SlotData.fromPointer(buffer[index]);
   }
 }
 
 /// ArrayTextureRegion wrapper
 class ArrayTextureRegion extends NativeArray<TextureRegion> {
-  ArrayTextureRegion.fromPointer(
+  ArrayTextureRegion.fromPointer(Pointer<spine_array_texture_region_wrapper> super.ptr);
-      Pointer<spine_array_texture_region_wrapper> super.ptr);
 
   @override
   int get length {
-    return SpineBindings.bindings
+    return SpineBindings.bindings.spine_array_texture_region_size(nativePtr.cast());
-        .spine_array_texture_region_size(nativePtr.cast());
   }
 
   @override
@@ -677,8 +617,7 @@ class ArrayTextureRegion extends NativeArray<TextureRegion> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer = SpineBindings.bindings
+    final buffer = SpineBindings.bindings.spine_array_texture_region_buffer(nativePtr.cast());
-        .spine_array_texture_region_buffer(nativePtr.cast());
     return TextureRegion.fromPointer(buffer[index]);
   }
 }
@@ -697,13 +636,9 @@ class ArrayTimeline extends NativeArray<Timeline> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer =
+    final buffer = SpineBindings.bindings.spine_array_timeline_buffer(nativePtr.cast());
-        SpineBindings.bindings.spine_array_timeline_buffer(nativePtr.cast());
     final rtti = SpineBindings.bindings.spine_timeline_get_rtti(buffer[index]);
-    final className = SpineBindings.bindings
+    final className = SpineBindings.bindings.spine_rtti_get_class_name(rtti).cast<Utf8>().toDartString();
-        .spine_rtti_get_class_name(rtti)
-        .cast<Utf8>()
-        .toDartString();
     switch (className) {
       case 'spine_alpha_timeline':
         return AlphaTimeline.fromPointer(buffer[index].cast());
@@ -726,14 +661,11 @@ class ArrayTimeline extends NativeArray<Timeline> {
       case 'spine_path_constraint_spacing_timeline':
         return PathConstraintSpacingTimeline.fromPointer(buffer[index].cast());
       case 'spine_physics_constraint_damping_timeline':
-        return PhysicsConstraintDampingTimeline.fromPointer(
+        return PhysicsConstraintDampingTimeline.fromPointer(buffer[index].cast());
-            buffer[index].cast());
       case 'spine_physics_constraint_gravity_timeline':
-        return PhysicsConstraintGravityTimeline.fromPointer(
+        return PhysicsConstraintGravityTimeline.fromPointer(buffer[index].cast());
-            buffer[index].cast());
       case 'spine_physics_constraint_inertia_timeline':
-        return PhysicsConstraintInertiaTimeline.fromPointer(
+        return PhysicsConstraintInertiaTimeline.fromPointer(buffer[index].cast());
-            buffer[index].cast());
       case 'spine_physics_constraint_mass_timeline':
         return PhysicsConstraintMassTimeline.fromPointer(buffer[index].cast());
       case 'spine_physics_constraint_mix_timeline':
@@ -741,8 +673,7 @@ class ArrayTimeline extends NativeArray<Timeline> {
       case 'spine_physics_constraint_reset_timeline':
         return PhysicsConstraintResetTimeline.fromPointer(buffer[index].cast());
       case 'spine_physics_constraint_strength_timeline':
-        return PhysicsConstraintStrengthTimeline.fromPointer(
+        return PhysicsConstraintStrengthTimeline.fromPointer(buffer[index].cast());
-            buffer[index].cast());
       case 'spine_physics_constraint_wind_timeline':
         return PhysicsConstraintWindTimeline.fromPointer(buffer[index].cast());
       case 'spine_rgb2_timeline':
@@ -782,21 +713,18 @@ class ArrayTimeline extends NativeArray<Timeline> {
       case 'spine_translate_y_timeline':
         return TranslateYTimeline.fromPointer(buffer[index].cast());
       default:
-        throw UnsupportedError(
+        throw UnsupportedError('Unknown concrete type: $className for abstract class Timeline');
-            'Unknown concrete type: $className for abstract class Timeline');
     }
   }
 }
 
 /// ArrayToProperty wrapper
 class ArrayToProperty extends NativeArray<ToProperty> {
-  ArrayToProperty.fromPointer(
+  ArrayToProperty.fromPointer(Pointer<spine_array_to_property_wrapper> super.ptr);
-      Pointer<spine_array_to_property_wrapper> super.ptr);
 
   @override
   int get length {
-    return SpineBindings.bindings
+    return SpineBindings.bindings.spine_array_to_property_size(nativePtr.cast());
-        .spine_array_to_property_size(nativePtr.cast());
   }
 
   @override
@@ -804,14 +732,9 @@ class ArrayToProperty extends NativeArray<ToProperty> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer =
+    final buffer = SpineBindings.bindings.spine_array_to_property_buffer(nativePtr.cast());
-        SpineBindings.bindings.spine_array_to_property_buffer(nativePtr.cast());
+    final rtti = SpineBindings.bindings.spine_to_property_get_rtti(buffer[index]);
-    final rtti =
+    final className = SpineBindings.bindings.spine_rtti_get_class_name(rtti).cast<Utf8>().toDartString();
-        SpineBindings.bindings.spine_to_property_get_rtti(buffer[index]);
-    final className = SpineBindings.bindings
-        .spine_rtti_get_class_name(rtti)
-        .cast<Utf8>()
-        .toDartString();
     switch (className) {
       case 'spine_to_rotate':
         return ToRotate.fromPointer(buffer[index].cast());
@@ -826,21 +749,18 @@ class ArrayToProperty extends NativeArray<ToProperty> {
       case 'spine_to_y':
         return ToY.fromPointer(buffer[index].cast());
       default:
-        throw UnsupportedError(
+        throw UnsupportedError('Unknown concrete type: $className for abstract class ToProperty');
-            'Unknown concrete type: $className for abstract class ToProperty');
     }
   }
 }
 
 /// ArrayTrackEntry wrapper
 class ArrayTrackEntry extends NativeArray<TrackEntry> {
-  ArrayTrackEntry.fromPointer(
+  ArrayTrackEntry.fromPointer(Pointer<spine_array_track_entry_wrapper> super.ptr);
-      Pointer<spine_array_track_entry_wrapper> super.ptr);
 
   @override
   int get length {
-    return SpineBindings.bindings
+    return SpineBindings.bindings.spine_array_track_entry_size(nativePtr.cast());
-        .spine_array_track_entry_size(nativePtr.cast());
   }
 
   @override
@@ -848,8 +768,7 @@ class ArrayTrackEntry extends NativeArray<TrackEntry> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer =
+    final buffer = SpineBindings.bindings.spine_array_track_entry_buffer(nativePtr.cast());
-        SpineBindings.bindings.spine_array_track_entry_buffer(nativePtr.cast());
     return TrackEntry.fromPointer(buffer[index]);
   }
 }
@@ -868,13 +787,9 @@ class ArrayUpdate extends NativeArray<Update> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer =
+    final buffer = SpineBindings.bindings.spine_array_update_buffer(nativePtr.cast());
-        SpineBindings.bindings.spine_array_update_buffer(nativePtr.cast());
     final rtti = SpineBindings.bindings.spine_update_get_rtti(buffer[index]);
-    final className = SpineBindings.bindings
+    final className = SpineBindings.bindings.spine_rtti_get_class_name(rtti).cast<Utf8>().toDartString();
-        .spine_rtti_get_class_name(rtti)
-        .cast<Utf8>()
-        .toDartString();
     switch (className) {
       case 'spine_bone':
         return Bone.fromPointer(buffer[index].cast());
@@ -891,8 +806,7 @@ class ArrayUpdate extends NativeArray<Update> {
       case 'spine_transform_constraint':
         return TransformConstraint.fromPointer(buffer[index].cast());
       default:
-        throw UnsupportedError(
+        throw UnsupportedError('Unknown concrete type: $className for abstract class Update');
-            'Unknown concrete type: $className for abstract class Update');
     }
   }
 }

spine-flutter/lib/generated/atlas.dart

@@ -50,8 +50,7 @@ class Atlas implements Finalizable {
   }
 
   AtlasRegion findRegion(String name) {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_atlas_find_region(_ptr, name.toNativeUtf8().cast<Char>());
-        .spine_atlas_find_region(_ptr, name.toNativeUtf8().cast<Char>());
     return AtlasRegion.fromPointer(result);
   }
 

spine-flutter/lib/generated/atlas_attachment_loader.dart

@@ -56,73 +56,59 @@ class AtlasAttachmentLoader implements Finalizable, AttachmentLoader {
   Pointer get nativePtr => _ptr;
 
   factory AtlasAttachmentLoader(Atlas atlas) {
-    final ptr = SpineBindings.bindings
+    final ptr = SpineBindings.bindings.spine_atlas_attachment_loader_create(atlas.nativePtr.cast());
-        .spine_atlas_attachment_loader_create(atlas.nativePtr.cast());
     return AtlasAttachmentLoader.fromPointer(ptr);
   }
 
   @override
-  RegionAttachment newRegionAttachment(
+  RegionAttachment newRegionAttachment(Skin skin, String name, String path, Sequence sequence) {
-      Skin skin, String name, String path, Sequence sequence) {
+    final result = SpineBindings.bindings.spine_atlas_attachment_loader_new_region_attachment(
-    final result = SpineBindings.bindings
+        _ptr,
-        .spine_atlas_attachment_loader_new_region_attachment(
+        skin.nativePtr.cast(),
-            _ptr,
+        name.toNativeUtf8().cast<Char>(),
-            skin.nativePtr.cast(),
+        path.toNativeUtf8().cast<Char>(),
-            name.toNativeUtf8().cast<Char>(),
+        sequence.nativePtr.cast());
-            path.toNativeUtf8().cast<Char>(),
-            sequence.nativePtr.cast());
     return RegionAttachment.fromPointer(result);
   }
 
   @override
-  MeshAttachment newMeshAttachment(
+  MeshAttachment newMeshAttachment(Skin skin, String name, String path, Sequence sequence) {
-      Skin skin, String name, String path, Sequence sequence) {
+    final result = SpineBindings.bindings.spine_atlas_attachment_loader_new_mesh_attachment(_ptr, skin.nativePtr.cast(),
-    final result = SpineBindings.bindings
+        name.toNativeUtf8().cast<Char>(), path.toNativeUtf8().cast<Char>(), sequence.nativePtr.cast());
-        .spine_atlas_attachment_loader_new_mesh_attachment(
-            _ptr,
-            skin.nativePtr.cast(),
-            name.toNativeUtf8().cast<Char>(),
-            path.toNativeUtf8().cast<Char>(),
-            sequence.nativePtr.cast());
     return MeshAttachment.fromPointer(result);
   }
 
   @override
   BoundingBoxAttachment newBoundingBoxAttachment(Skin skin, String name) {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_atlas_attachment_loader_new_bounding_box_attachment(
-        .spine_atlas_attachment_loader_new_bounding_box_attachment(
+        _ptr, skin.nativePtr.cast(), name.toNativeUtf8().cast<Char>());
-            _ptr, skin.nativePtr.cast(), name.toNativeUtf8().cast<Char>());
     return BoundingBoxAttachment.fromPointer(result);
   }
 
   @override
   PathAttachment newPathAttachment(Skin skin, String name) {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_atlas_attachment_loader_new_path_attachment(
-        .spine_atlas_attachment_loader_new_path_attachment(
+        _ptr, skin.nativePtr.cast(), name.toNativeUtf8().cast<Char>());
-            _ptr, skin.nativePtr.cast(), name.toNativeUtf8().cast<Char>());
     return PathAttachment.fromPointer(result);
   }
 
   @override
   PointAttachment newPointAttachment(Skin skin, String name) {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_atlas_attachment_loader_new_point_attachment(
-        .spine_atlas_attachment_loader_new_point_attachment(
+        _ptr, skin.nativePtr.cast(), name.toNativeUtf8().cast<Char>());
-            _ptr, skin.nativePtr.cast(), name.toNativeUtf8().cast<Char>());
     return PointAttachment.fromPointer(result);
   }
 
   @override
   ClippingAttachment newClippingAttachment(Skin skin, String name) {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_atlas_attachment_loader_new_clipping_attachment(
-        .spine_atlas_attachment_loader_new_clipping_attachment(
+        _ptr, skin.nativePtr.cast(), name.toNativeUtf8().cast<Char>());
-            _ptr, skin.nativePtr.cast(), name.toNativeUtf8().cast<Char>());
     return ClippingAttachment.fromPointer(result);
   }
 
   AtlasRegion findRegion(String name) {
-    final result = SpineBindings.bindings
+    final result =
-        .spine_atlas_attachment_loader_find_region(
+        SpineBindings.bindings.spine_atlas_attachment_loader_find_region(_ptr, name.toNativeUtf8().cast<Char>());
-            _ptr, name.toNativeUtf8().cast<Char>());
     return AtlasRegion.fromPointer(result);
   }
 }

spine-flutter/lib/generated/atlas_page.dart

@@ -47,8 +47,7 @@ class AtlasPage implements Finalizable {
   Pointer get nativePtr => _ptr;
 
   factory AtlasPage(String inName) {
-    final ptr = SpineBindings.bindings
+    final ptr = SpineBindings.bindings.spine_atlas_page_create(inName.toNativeUtf8().cast<Char>());
-        .spine_atlas_page_create(inName.toNativeUtf8().cast<Char>());
     return AtlasPage.fromPointer(ptr);
   }
 
@@ -58,19 +57,16 @@ class AtlasPage implements Finalizable {
   }
 
   set name(String value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_atlas_page_set_name(_ptr, value.toNativeUtf8().cast<Char>());
-        .spine_atlas_page_set_name(_ptr, value.toNativeUtf8().cast<Char>());
   }
 
   String get texturePath {
-    final result =
+    final result = SpineBindings.bindings.spine_atlas_page_get_texture_path(_ptr);
-        SpineBindings.bindings.spine_atlas_page_get_texture_path(_ptr);
     return result.cast<Utf8>().toDartString();
   }
 
   set texturePath(String value) {
-    SpineBindings.bindings.spine_atlas_page_set_texture_path(
+    SpineBindings.bindings.spine_atlas_page_set_texture_path(_ptr, value.toNativeUtf8().cast<Char>());
-        _ptr, value.toNativeUtf8().cast<Char>());
   }
 
   Format get format {

spine-flutter/lib/generated/atlas_region.dart

@@ -88,26 +88,22 @@ class AtlasRegion extends TextureRegion {
   }
 
   int get packedWidth {
-    final result =
+    final result = SpineBindings.bindings.spine_atlas_region_get_packed_width(_ptr);
-        SpineBindings.bindings.spine_atlas_region_get_packed_width(_ptr);
     return result;
   }
 
   int get packedHeight {
-    final result =
+    final result = SpineBindings.bindings.spine_atlas_region_get_packed_height(_ptr);
-        SpineBindings.bindings.spine_atlas_region_get_packed_height(_ptr);
     return result;
   }
 
   int get originalWidth {
-    final result =
+    final result = SpineBindings.bindings.spine_atlas_region_get_original_width(_ptr);
-        SpineBindings.bindings.spine_atlas_region_get_original_width(_ptr);
     return result;
   }
 
   int get originalHeight {
-    final result =
+    final result = SpineBindings.bindings.spine_atlas_region_get_original_height(_ptr);
-        SpineBindings.bindings.spine_atlas_region_get_original_height(_ptr);
     return result;
   }
 
@@ -137,13 +133,11 @@ class AtlasRegion extends TextureRegion {
   }
 
   set page(AtlasPage value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_atlas_region_set_page(_ptr, value.nativePtr.cast());
-        .spine_atlas_region_set_page(_ptr, value.nativePtr.cast());
   }
 
   set name(String value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_atlas_region_set_name(_ptr, value.toNativeUtf8().cast<Char>());
-        .spine_atlas_region_set_name(_ptr, value.toNativeUtf8().cast<Char>());
   }
 
   set index(int value) {
@@ -191,17 +185,14 @@ class AtlasRegion extends TextureRegion {
   }
 
   set splits(ArrayInt value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_atlas_region_set_splits(_ptr, value.nativePtr.cast());
-        .spine_atlas_region_set_splits(_ptr, value.nativePtr.cast());
   }
 
   set pads(ArrayInt value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_atlas_region_set_pads(_ptr, value.nativePtr.cast());
-        .spine_atlas_region_set_pads(_ptr, value.nativePtr.cast());
   }
 
   set values(ArrayFloat value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_atlas_region_set_values(_ptr, value.nativePtr.cast());
-        .spine_atlas_region_set_values(_ptr, value.nativePtr.cast());
   }
 }

spine-flutter/lib/generated/attachment.dart

@@ -63,10 +63,7 @@ abstract class Attachment implements Finalizable {
   Attachment copy() {
     final result = SpineBindings.bindings.spine_attachment_copy(_ptr);
     final rtti = SpineBindings.bindings.spine_attachment_get_rtti(result);
-    final className = SpineBindings.bindings
+    final className = SpineBindings.bindings.spine_rtti_get_class_name(rtti).cast<Utf8>().toDartString();
-        .spine_rtti_get_class_name(rtti)
-        .cast<Utf8>()
-        .toDartString();
     switch (className) {
       case 'spine_bounding_box_attachment':
         return BoundingBoxAttachment.fromPointer(result.cast());
@@ -81,8 +78,7 @@ abstract class Attachment implements Finalizable {
       case 'spine_region_attachment':
         return RegionAttachment.fromPointer(result.cast());
       default:
-        throw UnsupportedError(
+        throw UnsupportedError('Unknown concrete type: $className for abstract class Attachment');
-            'Unknown concrete type: $className for abstract class Attachment');
     }
   }
 

spine-flutter/lib/generated/attachment_loader.dart

@@ -42,10 +42,8 @@ import 'skin.dart';
 /// AttachmentLoader wrapper
 abstract class AttachmentLoader {
   Pointer get nativePtr;
-  RegionAttachment newRegionAttachment(
+  RegionAttachment newRegionAttachment(Skin skin, String name, String path, Sequence sequence);
-      Skin skin, String name, String path, Sequence sequence);
+  MeshAttachment newMeshAttachment(Skin skin, String name, String path, Sequence sequence);
-  MeshAttachment newMeshAttachment(
-      Skin skin, String name, String path, Sequence sequence);
   BoundingBoxAttachment newBoundingBoxAttachment(Skin skin, String name);
   PathAttachment newPathAttachment(Skin skin, String name);
   PointAttachment newPointAttachment(Skin skin, String name);

spine-flutter/lib/generated/attachment_timeline.dart

@@ -47,26 +47,23 @@ class AttachmentTimeline extends Timeline implements SlotTimeline {
   Pointer get nativePtr => _ptr;
 
   factory AttachmentTimeline(int frameCount, int slotIndex) {
-    final ptr = SpineBindings.bindings
+    final ptr = SpineBindings.bindings.spine_attachment_timeline_create(frameCount, slotIndex);
-        .spine_attachment_timeline_create(frameCount, slotIndex);
     return AttachmentTimeline.fromPointer(ptr);
   }
 
   void setFrame(int frame, double time, String attachmentName) {
-    SpineBindings.bindings.spine_attachment_timeline_set_frame(
+    SpineBindings.bindings
-        _ptr, frame, time, attachmentName.toNativeUtf8().cast<Char>());
+        .spine_attachment_timeline_set_frame(_ptr, frame, time, attachmentName.toNativeUtf8().cast<Char>());
   }
 
   @override
   int get slotIndex {
-    final result =
+    final result = SpineBindings.bindings.spine_attachment_timeline_get_slot_index(_ptr);
-        SpineBindings.bindings.spine_attachment_timeline_get_slot_index(_ptr);
     return result;
   }
 
   @override
   set slotIndex(int value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_attachment_timeline_set_slot_index(_ptr, value);
-        .spine_attachment_timeline_set_slot_index(_ptr, value);
   }
 }

spine-flutter/lib/generated/bone.dart

@@ -54,14 +54,12 @@ class Bone extends PosedActive implements Posed, Update {
   Pointer get nativePtr => _ptr;
 
   factory Bone(BoneData data, Bone parent) {
-    final ptr = SpineBindings.bindings
+    final ptr = SpineBindings.bindings.spine_bone_create(data.nativePtr.cast(), parent.nativePtr.cast());
-        .spine_bone_create(data.nativePtr.cast(), parent.nativePtr.cast());
     return Bone.fromPointer(ptr);
   }
 
   factory Bone.from(Bone bone, Bone parent) {
-    final ptr = SpineBindings.bindings
+    final ptr = SpineBindings.bindings.spine_bone_create2(bone.nativePtr.cast(), parent.nativePtr.cast());
-        .spine_bone_create2(bone.nativePtr.cast(), parent.nativePtr.cast());
     return Bone.fromPointer(ptr);
   }
 
@@ -92,8 +90,7 @@ class Bone extends PosedActive implements Posed, Update {
 
   @override
   void update(Skeleton skeleton, Physics physics) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_bone_update(_ptr, skeleton.nativePtr.cast(), physics.value);
-        .spine_bone_update(_ptr, skeleton.nativePtr.cast(), physics.value);
   }
 
   BoneData get data {
@@ -123,8 +120,7 @@ class Bone extends PosedActive implements Posed, Update {
 
   @override
   bool get isPoseEqualToApplied {
-    final result =
+    final result = SpineBindings.bindings.spine_bone_is_pose_equal_to_applied(_ptr);
-        SpineBindings.bindings.spine_bone_is_pose_equal_to_applied(_ptr);
     return result;
   }
 

spine-flutter/lib/generated/bone_data.dart

@@ -48,8 +48,8 @@ class BoneData extends PosedData {
   Pointer get nativePtr => _ptr;
 
   factory BoneData(int index, String name, BoneData parent) {
-    final ptr = SpineBindings.bindings.spine_bone_data_create(
+    final ptr =
-        index, name.toNativeUtf8().cast<Char>(), parent.nativePtr.cast());
+        SpineBindings.bindings.spine_bone_data_create(index, name.toNativeUtf8().cast<Char>(), parent.nativePtr.cast());
     return BoneData.fromPointer(ptr);
   }
 
@@ -83,8 +83,7 @@ class BoneData extends PosedData {
   }
 
   set icon(String value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_bone_data_set_icon(_ptr, value.toNativeUtf8().cast<Char>());
-        .spine_bone_data_set_icon(_ptr, value.toNativeUtf8().cast<Char>());
   }
 
   bool get visible {

spine-flutter/lib/generated/bone_pose.dart

@@ -61,28 +61,23 @@ class BonePose extends BoneLocal implements Update {
 
   @override
   void update(Skeleton skeleton, Physics physics) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_bone_pose_update(_ptr, skeleton.nativePtr.cast(), physics.value);
-        .spine_bone_pose_update(_ptr, skeleton.nativePtr.cast(), physics.value);
   }
 
   void updateWorldTransform(Skeleton skeleton) {
-    SpineBindings.bindings.spine_bone_pose_update_world_transform(
+    SpineBindings.bindings.spine_bone_pose_update_world_transform(_ptr, skeleton.nativePtr.cast());
-        _ptr, skeleton.nativePtr.cast());
   }
 
   void updateLocalTransform(Skeleton skeleton) {
-    SpineBindings.bindings.spine_bone_pose_update_local_transform(
+    SpineBindings.bindings.spine_bone_pose_update_local_transform(_ptr, skeleton.nativePtr.cast());
-        _ptr, skeleton.nativePtr.cast());
   }
 
   void validateLocalTransform(Skeleton skeleton) {
-    SpineBindings.bindings.spine_bone_pose_validate_local_transform(
+    SpineBindings.bindings.spine_bone_pose_validate_local_transform(_ptr, skeleton.nativePtr.cast());
-        _ptr, skeleton.nativePtr.cast());
   }
 
   void modifyLocal(Skeleton skeleton) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_bone_pose_modify_local(_ptr, skeleton.nativePtr.cast());
-        .spine_bone_pose_modify_local(_ptr, skeleton.nativePtr.cast());
   }
 
   void modifyWorld(int update) {
@@ -148,38 +143,32 @@ class BonePose extends BoneLocal implements Update {
   }
 
   double get worldRotationX {
-    final result =
+    final result = SpineBindings.bindings.spine_bone_pose_get_world_rotation_x(_ptr);
-        SpineBindings.bindings.spine_bone_pose_get_world_rotation_x(_ptr);
     return result;
   }
 
   double get worldRotationY {
-    final result =
+    final result = SpineBindings.bindings.spine_bone_pose_get_world_rotation_y(_ptr);
-        SpineBindings.bindings.spine_bone_pose_get_world_rotation_y(_ptr);
     return result;
   }
 
   double get worldScaleX {
-    final result =
+    final result = SpineBindings.bindings.spine_bone_pose_get_world_scale_x(_ptr);
-        SpineBindings.bindings.spine_bone_pose_get_world_scale_x(_ptr);
     return result;
   }
 
   double get worldScaleY {
-    final result =
+    final result = SpineBindings.bindings.spine_bone_pose_get_world_scale_y(_ptr);
-        SpineBindings.bindings.spine_bone_pose_get_world_scale_y(_ptr);
     return result;
   }
 
   double worldToLocalRotation(double worldRotation) {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_bone_pose_world_to_local_rotation(_ptr, worldRotation);
-        .spine_bone_pose_world_to_local_rotation(_ptr, worldRotation);
     return result;
   }
 
   double localToWorldRotation(double localRotation) {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_bone_pose_local_to_world_rotation(_ptr, localRotation);
-        .spine_bone_pose_local_to_world_rotation(_ptr, localRotation);
     return result;
   }
 

spine-flutter/lib/generated/bone_timeline1.dart

@@ -47,8 +47,7 @@ abstract class BoneTimeline1 extends CurveTimeline1 implements BoneTimeline {
 
   @override
   int get boneIndex {
-    final result =
+    final result = SpineBindings.bindings.spine_bone_timeline1_get_bone_index(_ptr);
-        SpineBindings.bindings.spine_bone_timeline1_get_bone_index(_ptr);
     return result;
   }
 

spine-flutter/lib/generated/bone_timeline2.dart

@@ -47,8 +47,7 @@ abstract class BoneTimeline2 extends CurveTimeline implements BoneTimeline {
 
   @override
   int get boneIndex {
-    final result =
+    final result = SpineBindings.bindings.spine_bone_timeline2_get_bone_index(_ptr);
-        SpineBindings.bindings.spine_bone_timeline2_get_bone_index(_ptr);
     return result;
   }
 
@@ -58,7 +57,6 @@ abstract class BoneTimeline2 extends CurveTimeline implements BoneTimeline {
   }
 
   void setFrame(int frame, double time, double value1, double value2) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_bone_timeline2_set_frame(_ptr, frame, time, value1, value2);
-        .spine_bone_timeline2_set_frame(_ptr, frame, time, value1, value2);
   }
 }

spine-flutter/lib/generated/bounding_box_attachment.dart

@@ -47,14 +47,12 @@ class BoundingBoxAttachment extends VertexAttachment {
   Pointer get nativePtr => _ptr;
 
   factory BoundingBoxAttachment(String name) {
-    final ptr = SpineBindings.bindings
+    final ptr = SpineBindings.bindings.spine_bounding_box_attachment_create(name.toNativeUtf8().cast<Char>());
-        .spine_bounding_box_attachment_create(name.toNativeUtf8().cast<Char>());
     return BoundingBoxAttachment.fromPointer(ptr);
   }
 
   Color get color {
-    final result =
+    final result = SpineBindings.bindings.spine_bounding_box_attachment_get_color(_ptr);
-        SpineBindings.bindings.spine_bounding_box_attachment_get_color(_ptr);
     return Color.fromPointer(result);
   }
 }

spine-flutter/lib/generated/clipping_attachment.dart

@@ -48,25 +48,21 @@ class ClippingAttachment extends VertexAttachment {
   Pointer get nativePtr => _ptr;
 
   factory ClippingAttachment(String name) {
-    final ptr = SpineBindings.bindings
+    final ptr = SpineBindings.bindings.spine_clipping_attachment_create(name.toNativeUtf8().cast<Char>());
-        .spine_clipping_attachment_create(name.toNativeUtf8().cast<Char>());
     return ClippingAttachment.fromPointer(ptr);
   }
 
   SlotData get endSlot {
-    final result =
+    final result = SpineBindings.bindings.spine_clipping_attachment_get_end_slot(_ptr);
-        SpineBindings.bindings.spine_clipping_attachment_get_end_slot(_ptr);
     return SlotData.fromPointer(result);
   }
 
   set endSlot(SlotData value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_clipping_attachment_set_end_slot(_ptr, value.nativePtr.cast());
-        .spine_clipping_attachment_set_end_slot(_ptr, value.nativePtr.cast());
   }
 
   Color get color {
-    final result =
+    final result = SpineBindings.bindings.spine_clipping_attachment_get_color(_ptr);
-        SpineBindings.bindings.spine_clipping_attachment_get_color(_ptr);
     return Color.fromPointer(result);
   }
 }

spine-flutter/lib/generated/color.dart

@@ -59,8 +59,7 @@ class Color implements Finalizable {
   }
 
   static double parseHex(String value, int index) {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_color_parse_hex(value.toNativeUtf8().cast<Char>(), index);
-        .spine_color_parse_hex(value.toNativeUtf8().cast<Char>(), index);
     return result;
   }
 
@@ -119,8 +118,7 @@ class Color implements Finalizable {
   }
 
   Color set3(Color other) {
-    final result =
+    final result = SpineBindings.bindings.spine_color_set_3(_ptr, other.nativePtr.cast());
-        SpineBindings.bindings.spine_color_set_3(_ptr, other.nativePtr.cast());
     return Color.fromPointer(result);
   }
 
@@ -135,8 +133,7 @@ class Color implements Finalizable {
   }
 
   Color add3(Color other) {
-    final result =
+    final result = SpineBindings.bindings.spine_color_add_3(_ptr, other.nativePtr.cast());
-        SpineBindings.bindings.spine_color_add_3(_ptr, other.nativePtr.cast());
     return Color.fromPointer(result);
   }
 }

spine-flutter/lib/generated/constraint_timeline1.dart

@@ -36,8 +36,7 @@ import 'constraint_timeline.dart';
 import 'curve_timeline1.dart';
 
 /// ConstraintTimeline1 wrapper
-abstract class ConstraintTimeline1 extends CurveTimeline1
+abstract class ConstraintTimeline1 extends CurveTimeline1 implements ConstraintTimeline {
-    implements ConstraintTimeline {
   final Pointer<spine_constraint_timeline1_wrapper> _ptr;
 
   ConstraintTimeline1.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
@@ -48,14 +47,12 @@ abstract class ConstraintTimeline1 extends CurveTimeline1
 
   @override
   int get constraintIndex {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_constraint_timeline1_get_constraint_index(_ptr);
-        .spine_constraint_timeline1_get_constraint_index(_ptr);
     return result;
   }
 
   @override
   set constraintIndex(int value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_constraint_timeline1_set_constraint_index(_ptr, value);
-        .spine_constraint_timeline1_set_constraint_index(_ptr, value);
   }
 }

spine-flutter/lib/generated/curve_timeline.dart

@@ -53,25 +53,14 @@ abstract class CurveTimeline extends Timeline {
     SpineBindings.bindings.spine_curve_timeline_set_stepped(_ptr, value);
   }
 
-  void setBezier(
+  void setBezier(int bezier, int frame, double value, double time1, double value1, double cx1, double cy1, double cx2,
-      int bezier,
+      double cy2, double time2, double value2) {
-      int frame,
+    SpineBindings.bindings
-      double value,
+        .spine_curve_timeline_set_bezier(_ptr, bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
-      double time1,
-      double value1,
-      double cx1,
-      double cy1,
-      double cx2,
-      double cy2,
-      double time2,
-      double value2) {
-    SpineBindings.bindings.spine_curve_timeline_set_bezier(_ptr, bezier, frame,
-        value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
   }
 
   double getBezierValue(double time, int frame, int valueOffset, int i) {
-    final result = SpineBindings.bindings.spine_curve_timeline_get_bezier_value(
+    final result = SpineBindings.bindings.spine_curve_timeline_get_bezier_value(_ptr, time, frame, valueOffset, i);
-        _ptr, time, frame, valueOffset, i);
     return result;
   }
 

spine-flutter/lib/generated/curve_timeline1.dart

@@ -47,44 +47,36 @@ abstract class CurveTimeline1 extends CurveTimeline {
   Pointer get nativePtr => _ptr;
 
   void setFrame(int frame, double time, double value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_curve_timeline1_set_frame(_ptr, frame, time, value);
-        .spine_curve_timeline1_set_frame(_ptr, frame, time, value);
   }
 
   double getCurveValue(double time) {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_curve_timeline1_get_curve_value(_ptr, time);
-        .spine_curve_timeline1_get_curve_value(_ptr, time);
     return result;
   }
 
-  double getRelativeValue(
+  double getRelativeValue(double time, double alpha, MixBlend blend, double current, double setup) {
-      double time, double alpha, MixBlend blend, double current, double setup) {
+    final result =
-    final result = SpineBindings.bindings
+        SpineBindings.bindings.spine_curve_timeline1_get_relative_value(_ptr, time, alpha, blend.value, current, setup);
-        .spine_curve_timeline1_get_relative_value(
-            _ptr, time, alpha, blend.value, current, setup);
     return result;
   }
 
-  double getScaleValue(double time, double alpha, MixBlend blend,
+  double getScaleValue(
-      MixDirection direction, double current, double setup) {
+      double time, double alpha, MixBlend blend, MixDirection direction, double current, double setup) {
-    final result = SpineBindings.bindings.spine_curve_timeline1_get_scale_value(
+    final result = SpineBindings.bindings
-        _ptr, time, alpha, blend.value, direction.value, current, setup);
+        .spine_curve_timeline1_get_scale_value(_ptr, time, alpha, blend.value, direction.value, current, setup);
     return result;
   }
 
-  double getAbsoluteValue(
+  double getAbsoluteValue(double time, double alpha, MixBlend blend, double current, double setup) {
-      double time, double alpha, MixBlend blend, double current, double setup) {
     final result = SpineBindings.bindings
-        .spine_curve_timeline1_get_absolute_value_1(
+        .spine_curve_timeline1_get_absolute_value_1(_ptr, time, alpha, blend.value, current, setup);
-            _ptr, time, alpha, blend.value, current, setup);
     return result;
   }
 
-  double getAbsoluteValue2(double time, double alpha, MixBlend blend,
+  double getAbsoluteValue2(double time, double alpha, MixBlend blend, double current, double setup, double value) {
-      double current, double setup, double value) {
     final result = SpineBindings.bindings
-        .spine_curve_timeline1_get_absolute_value_2(
+        .spine_curve_timeline1_get_absolute_value_2(_ptr, time, alpha, blend.value, current, setup, value);
-            _ptr, time, alpha, blend.value, current, setup, value);
     return result;
   }
 }

spine-flutter/lib/generated/deform_timeline.dart

@@ -51,27 +51,20 @@ class DeformTimeline extends SlotCurveTimeline {
   @override
   Pointer get nativePtr => _ptr;
 
-  factory DeformTimeline(int frameCount, int bezierCount, int slotIndex,
+  factory DeformTimeline(int frameCount, int bezierCount, int slotIndex, VertexAttachment attachment) {
-      VertexAttachment attachment) {
+    final ptr = SpineBindings.bindings
-    final ptr = SpineBindings.bindings.spine_deform_timeline_create(
+        .spine_deform_timeline_create(frameCount, bezierCount, slotIndex, attachment.nativePtr.cast());
-        frameCount, bezierCount, slotIndex, attachment.nativePtr.cast());
     return DeformTimeline.fromPointer(ptr);
   }
 
   void setFrame(int frameIndex, double time, ArrayFloat vertices) {
-    SpineBindings.bindings.spine_deform_timeline_set_frame(
+    SpineBindings.bindings.spine_deform_timeline_set_frame(_ptr, frameIndex, time, vertices.nativePtr.cast());
-        _ptr, frameIndex, time, vertices.nativePtr.cast());
   }
 
   VertexAttachment get attachment {
-    final result =
+    final result = SpineBindings.bindings.spine_deform_timeline_get_attachment(_ptr);
-        SpineBindings.bindings.spine_deform_timeline_get_attachment(_ptr);
+    final rtti = SpineBindings.bindings.spine_vertex_attachment_get_rtti(result);
-    final rtti =
+    final className = SpineBindings.bindings.spine_rtti_get_class_name(rtti).cast<Utf8>().toDartString();
-        SpineBindings.bindings.spine_vertex_attachment_get_rtti(result);
-    final className = SpineBindings.bindings
-        .spine_rtti_get_class_name(rtti)
-        .cast<Utf8>()
-        .toDartString();
     switch (className) {
       case 'spine_bounding_box_attachment':
         return BoundingBoxAttachment.fromPointer(result.cast());
@@ -82,19 +75,16 @@ class DeformTimeline extends SlotCurveTimeline {
       case 'spine_path_attachment':
         return PathAttachment.fromPointer(result.cast());
       default:
-        throw UnsupportedError(
+        throw UnsupportedError('Unknown concrete type: $className for abstract class VertexAttachment');
-            'Unknown concrete type: $className for abstract class VertexAttachment');
     }
   }
 
   set attachment(VertexAttachment value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_deform_timeline_set_attachment(_ptr, value.nativePtr.cast());
-        .spine_deform_timeline_set_attachment(_ptr, value.nativePtr.cast());
   }
 
   double getCurvePercent(double time, int frame) {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_deform_timeline_get_curve_percent(_ptr, time, frame);
-        .spine_deform_timeline_get_curve_percent(_ptr, time, frame);
     return result;
   }
 }

spine-flutter/lib/generated/draw_order_timeline.dart

@@ -46,13 +46,11 @@ class DrawOrderTimeline extends Timeline {
   Pointer get nativePtr => _ptr;
 
   factory DrawOrderTimeline(int frameCount) {
-    final ptr =
+    final ptr = SpineBindings.bindings.spine_draw_order_timeline_create(frameCount);
-        SpineBindings.bindings.spine_draw_order_timeline_create(frameCount);
     return DrawOrderTimeline.fromPointer(ptr);
   }
 
   void setFrame(int frame, double time, ArrayInt drawOrder) {
-    SpineBindings.bindings.spine_draw_order_timeline_set_frame(
+    SpineBindings.bindings.spine_draw_order_timeline_set_frame(_ptr, frame, time, drawOrder.nativePtr.cast());
-        _ptr, frame, time, drawOrder.nativePtr.cast());
   }
 }

spine-flutter/lib/generated/event.dart

@@ -45,8 +45,7 @@ class Event implements Finalizable {
   Pointer get nativePtr => _ptr;
 
   factory Event(double time, EventData data) {
-    final ptr =
+    final ptr = SpineBindings.bindings.spine_event_create(time, data.nativePtr.cast());
-        SpineBindings.bindings.spine_event_create(time, data.nativePtr.cast());
     return Event.fromPointer(ptr);
   }
 
@@ -84,8 +83,7 @@ class Event implements Finalizable {
   }
 
   set stringValue(String value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_event_set_string(_ptr, value.toNativeUtf8().cast<Char>());
-        .spine_event_set_string(_ptr, value.toNativeUtf8().cast<Char>());
   }
 
   double get volume {

spine-flutter/lib/generated/event_data.dart

@@ -44,8 +44,7 @@ class EventData implements Finalizable {
   Pointer get nativePtr => _ptr;
 
   factory EventData(String name) {
-    final ptr = SpineBindings.bindings
+    final ptr = SpineBindings.bindings.spine_event_data_create(name.toNativeUtf8().cast<Char>());
-        .spine_event_data_create(name.toNativeUtf8().cast<Char>());
     return EventData.fromPointer(ptr);
   }
 
@@ -78,8 +77,7 @@ class EventData implements Finalizable {
   }
 
   set stringValue(String value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_event_data_set_string(_ptr, value.toNativeUtf8().cast<Char>());
-        .spine_event_data_set_string(_ptr, value.toNativeUtf8().cast<Char>());
   }
 
   String get audioPath {
@@ -88,8 +86,7 @@ class EventData implements Finalizable {
   }
 
   set audioPath(String value) {
-    SpineBindings.bindings.spine_event_data_set_audio_path(
+    SpineBindings.bindings.spine_event_data_set_audio_path(_ptr, value.toNativeUtf8().cast<Char>());
-        _ptr, value.toNativeUtf8().cast<Char>());
   }
 
   double get volume {

spine-flutter/lib/generated/event_queue_entry.dart

@@ -45,16 +45,14 @@ class EventQueueEntry implements Finalizable {
   /// Get the native pointer for FFI calls
   Pointer get nativePtr => _ptr;
 
-  factory EventQueueEntry(
+  factory EventQueueEntry(EventType eventType, TrackEntry trackEntry, Event event) {
-      EventType eventType, TrackEntry trackEntry, Event event) {
+    final ptr = SpineBindings.bindings
-    final ptr = SpineBindings.bindings.spine_event_queue_entry_create(
+        .spine_event_queue_entry_create(eventType.value, trackEntry.nativePtr.cast(), event.nativePtr.cast());
-        eventType.value, trackEntry.nativePtr.cast(), event.nativePtr.cast());
     return EventQueueEntry.fromPointer(ptr);
   }
 
   EventType get type {
-    final result =
+    final result = SpineBindings.bindings.spine_event_queue_entry_get__type(_ptr);
-        SpineBindings.bindings.spine_event_queue_entry_get__type(_ptr);
     return EventType.fromValue(result);
   }
 
@@ -63,24 +61,20 @@ class EventQueueEntry implements Finalizable {
   }
 
   TrackEntry get entry {
-    final result =
+    final result = SpineBindings.bindings.spine_event_queue_entry_get__entry(_ptr);
-        SpineBindings.bindings.spine_event_queue_entry_get__entry(_ptr);
     return TrackEntry.fromPointer(result);
   }
 
   set entry(TrackEntry value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_event_queue_entry_set__entry(_ptr, value.nativePtr.cast());
-        .spine_event_queue_entry_set__entry(_ptr, value.nativePtr.cast());
   }
 
   Event get event {
-    final result =
+    final result = SpineBindings.bindings.spine_event_queue_entry_get__event(_ptr);
-        SpineBindings.bindings.spine_event_queue_entry_get__event(_ptr);
     return Event.fromPointer(result);
   }
 
   set event(Event value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_event_queue_entry_set__event(_ptr, value.nativePtr.cast());
-        .spine_event_queue_entry_set__event(_ptr, value.nativePtr.cast());
   }
 }

spine-flutter/lib/generated/event_timeline.dart

@@ -57,7 +57,6 @@ class EventTimeline extends Timeline {
   }
 
   void setFrame(int frame, Event event) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_event_timeline_set_frame(_ptr, frame, event.nativePtr.cast());
-        .spine_event_timeline_set_frame(_ptr, frame, event.nativePtr.cast());
   }
 }

spine-flutter/lib/generated/from_property.dart

@@ -69,7 +69,6 @@ abstract class FromProperty implements Finalizable {
   }
 
   set to(ArrayToProperty value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_from_property_set__to(_ptr, value.nativePtr.cast());
-        .spine_from_property_set__to(_ptr, value.nativePtr.cast());
   }
 }

spine-flutter/lib/generated/ik_constraint.dart

@@ -55,8 +55,7 @@ class IkConstraint extends PosedActive implements Posed, Constraint {
   Pointer get nativePtr => _ptr;
 
   factory IkConstraint(IkConstraintData data, Skeleton skeleton) {
-    final ptr = SpineBindings.bindings.spine_ik_constraint_create(
+    final ptr = SpineBindings.bindings.spine_ik_constraint_create(data.nativePtr.cast(), skeleton.nativePtr.cast());
-        data.nativePtr.cast(), skeleton.nativePtr.cast());
     return IkConstraint.fromPointer(ptr);
   }
 
@@ -67,27 +66,23 @@ class IkConstraint extends PosedActive implements Posed, Constraint {
   }
 
   IkConstraint copy(Skeleton skeleton) {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_ik_constraint_copy(_ptr, skeleton.nativePtr.cast());
-        .spine_ik_constraint_copy(_ptr, skeleton.nativePtr.cast());
     return IkConstraint.fromPointer(result);
   }
 
   @override
   void update(Skeleton skeleton, Physics physics) {
-    SpineBindings.bindings.spine_ik_constraint_update(
+    SpineBindings.bindings.spine_ik_constraint_update(_ptr, skeleton.nativePtr.cast(), physics.value);
-        _ptr, skeleton.nativePtr.cast(), physics.value);
   }
 
   @override
   void sort(Skeleton skeleton) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_ik_constraint_sort(_ptr, skeleton.nativePtr.cast());
-        .spine_ik_constraint_sort(_ptr, skeleton.nativePtr.cast());
   }
 
   @override
   bool get isSourceActive {
-    final result =
+    final result = SpineBindings.bindings.spine_ik_constraint_is_source_active(_ptr);
-        SpineBindings.bindings.spine_ik_constraint_is_source_active(_ptr);
     return result;
   }
 
@@ -108,8 +103,7 @@ class IkConstraint extends PosedActive implements Posed, Constraint {
   }
 
   set target(Bone value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_ik_constraint_set_target(_ptr, value.nativePtr.cast());
-        .spine_ik_constraint_set_target(_ptr, value.nativePtr.cast());
   }
 
   IkConstraintPose get pose {
@@ -118,8 +112,7 @@ class IkConstraint extends PosedActive implements Posed, Constraint {
   }
 
   IkConstraintPose get appliedPose {
-    final result =
+    final result = SpineBindings.bindings.spine_ik_constraint_get_applied_pose(_ptr);
-        SpineBindings.bindings.spine_ik_constraint_get_applied_pose(_ptr);
     return IkConstraintPose.fromPointer(result);
   }
 
@@ -135,8 +128,7 @@ class IkConstraint extends PosedActive implements Posed, Constraint {
 
   @override
   bool get isPoseEqualToApplied {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_ik_constraint_is_pose_equal_to_applied(_ptr);
-        .spine_ik_constraint_is_pose_equal_to_applied(_ptr);
     return result;
   }
 
@@ -145,40 +137,15 @@ class IkConstraint extends PosedActive implements Posed, Constraint {
     return Rtti.fromPointer(result);
   }
 
-  static void apply(Skeleton skeleton, BonePose bone, double targetX,
+  static void apply(Skeleton skeleton, BonePose bone, double targetX, double targetY, bool compress, bool stretch,
-      double targetY, bool compress, bool stretch, bool uniform, double mix) {
+      bool uniform, double mix) {
     SpineBindings.bindings.spine_ik_constraint_apply_1(
-        skeleton.nativePtr.cast(),
+        skeleton.nativePtr.cast(), bone.nativePtr.cast(), targetX, targetY, compress, stretch, uniform, mix);
-        bone.nativePtr.cast(),
-        targetX,
-        targetY,
-        compress,
-        stretch,
-        uniform,
-        mix);
   }
 
-  static void apply2(
+  static void apply2(Skeleton skeleton, BonePose parent, BonePose child, double targetX, double targetY,
-      Skeleton skeleton,
+      int bendDirection, bool stretch, bool uniform, double softness, double mix) {
-      BonePose parent,
+    SpineBindings.bindings.spine_ik_constraint_apply_2(skeleton.nativePtr.cast(), parent.nativePtr.cast(),
-      BonePose child,
+        child.nativePtr.cast(), targetX, targetY, bendDirection, stretch, uniform, softness, mix);
-      double targetX,
-      double targetY,
-      int bendDirection,
-      bool stretch,
-      bool uniform,
-      double softness,
-      double mix) {
-    SpineBindings.bindings.spine_ik_constraint_apply_2(
-        skeleton.nativePtr.cast(),
-        parent.nativePtr.cast(),
-        child.nativePtr.cast(),
-        targetX,
-        targetY,
-        bendDirection,
-        stretch,
-        uniform,
-        softness,
-        mix);
   }
 }

spine-flutter/lib/generated/ik_constraint_data.dart

@@ -58,28 +58,21 @@ class IkConstraintData extends PosedData implements ConstraintData {
   Pointer get nativePtr => _ptr;
 
   factory IkConstraintData(String name) {
-    final ptr = SpineBindings.bindings
+    final ptr = SpineBindings.bindings.spine_ik_constraint_data_create(name.toNativeUtf8().cast<Char>());
-        .spine_ik_constraint_data_create(name.toNativeUtf8().cast<Char>());
     return IkConstraintData.fromPointer(ptr);
   }
 
   @override
   Rtti get rtti {
-    final result =
+    final result = SpineBindings.bindings.spine_ik_constraint_data_get_rtti(_ptr);
-        SpineBindings.bindings.spine_ik_constraint_data_get_rtti(_ptr);
     return Rtti.fromPointer(result);
   }
 
   @override
   Constraint createMethod(Skeleton skeleton) {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_ik_constraint_data_create_method(_ptr, skeleton.nativePtr.cast());
-        .spine_ik_constraint_data_create_method(
-            _ptr, skeleton.nativePtr.cast());
     final rtti = SpineBindings.bindings.spine_constraint_get_rtti(result);
-    final className = SpineBindings.bindings
+    final className = SpineBindings.bindings.spine_rtti_get_class_name(rtti).cast<Utf8>().toDartString();
-        .spine_rtti_get_class_name(rtti)
-        .cast<Utf8>()
-        .toDartString();
     switch (className) {
       case 'spine_ik_constraint':
         return IkConstraint.fromPointer(result.cast());
@@ -92,31 +85,26 @@ class IkConstraintData extends PosedData implements ConstraintData {
       case 'spine_transform_constraint':
         return TransformConstraint.fromPointer(result.cast());
       default:
-        throw UnsupportedError(
+        throw UnsupportedError('Unknown concrete type: $className for abstract class Constraint');
-            'Unknown concrete type: $className for abstract class Constraint');
     }
   }
 
   ArrayBoneData get bones {
-    final result =
+    final result = SpineBindings.bindings.spine_ik_constraint_data_get_bones(_ptr);
-        SpineBindings.bindings.spine_ik_constraint_data_get_bones(_ptr);
     return ArrayBoneData.fromPointer(result);
   }
 
   BoneData get target {
-    final result =
+    final result = SpineBindings.bindings.spine_ik_constraint_data_get_target(_ptr);
-        SpineBindings.bindings.spine_ik_constraint_data_get_target(_ptr);
     return BoneData.fromPointer(result);
   }
 
   set target(BoneData value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_ik_constraint_data_set_target(_ptr, value.nativePtr.cast());
-        .spine_ik_constraint_data_set_target(_ptr, value.nativePtr.cast());
   }
 
   bool get uniform {
-    final result =
+    final result = SpineBindings.bindings.spine_ik_constraint_data_get_uniform(_ptr);
-        SpineBindings.bindings.spine_ik_constraint_data_get_uniform(_ptr);
     return result;
   }
 
@@ -125,8 +113,7 @@ class IkConstraintData extends PosedData implements ConstraintData {
   }
 
   IkConstraintPose get setupPose {
-    final result =
+    final result = SpineBindings.bindings.spine_ik_constraint_data_get_setup_pose(_ptr);
-        SpineBindings.bindings.spine_ik_constraint_data_get_setup_pose(_ptr);
     return IkConstraintPose.fromPointer(result);
   }
 

spine-flutter/lib/generated/ik_constraint_pose.dart

@@ -48,13 +48,11 @@ class IkConstraintPose implements Finalizable {
   }
 
   void set(IkConstraintPose pose) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_ik_constraint_pose_set(_ptr, pose.nativePtr.cast());
-        .spine_ik_constraint_pose_set(_ptr, pose.nativePtr.cast());
   }
 
   double get mix {
-    final result =
+    final result = SpineBindings.bindings.spine_ik_constraint_pose_get_mix(_ptr);
-        SpineBindings.bindings.spine_ik_constraint_pose_get_mix(_ptr);
     return result;
   }
 
@@ -63,8 +61,7 @@ class IkConstraintPose implements Finalizable {
   }
 
   double get softness {
-    final result =
+    final result = SpineBindings.bindings.spine_ik_constraint_pose_get_softness(_ptr);
-        SpineBindings.bindings.spine_ik_constraint_pose_get_softness(_ptr);
     return result;
   }
 
@@ -73,19 +70,16 @@ class IkConstraintPose implements Finalizable {
   }
 
   int get bendDirection {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_ik_constraint_pose_get_bend_direction(_ptr);
-        .spine_ik_constraint_pose_get_bend_direction(_ptr);
     return result;
   }
 
   set bendDirection(int value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_ik_constraint_pose_set_bend_direction(_ptr, value);
-        .spine_ik_constraint_pose_set_bend_direction(_ptr, value);
   }
 
   bool get compress {
-    final result =
+    final result = SpineBindings.bindings.spine_ik_constraint_pose_get_compress(_ptr);
-        SpineBindings.bindings.spine_ik_constraint_pose_get_compress(_ptr);
     return result;
   }
 
@@ -94,8 +88,7 @@ class IkConstraintPose implements Finalizable {
   }
 
   bool get stretch {
-    final result =
+    final result = SpineBindings.bindings.spine_ik_constraint_pose_get_stretch(_ptr);
-        SpineBindings.bindings.spine_ik_constraint_pose_get_stretch(_ptr);
     return result;
   }
 

spine-flutter/lib/generated/ik_constraint_timeline.dart

@@ -45,29 +45,24 @@ class IkConstraintTimeline extends CurveTimeline implements ConstraintTimeline {
   @override
   Pointer get nativePtr => _ptr;
 
-  factory IkConstraintTimeline(
+  factory IkConstraintTimeline(int frameCount, int bezierCount, int constraintIndex) {
-      int frameCount, int bezierCount, int constraintIndex) {
+    final ptr = SpineBindings.bindings.spine_ik_constraint_timeline_create(frameCount, bezierCount, constraintIndex);
-    final ptr = SpineBindings.bindings.spine_ik_constraint_timeline_create(
-        frameCount, bezierCount, constraintIndex);
     return IkConstraintTimeline.fromPointer(ptr);
   }
 
-  void setFrame(int frame, double time, double mix, double softness,
+  void setFrame(int frame, double time, double mix, double softness, int bendDirection, bool compress, bool stretch) {
-      int bendDirection, bool compress, bool stretch) {
+    SpineBindings.bindings
-    SpineBindings.bindings.spine_ik_constraint_timeline_set_frame(
+        .spine_ik_constraint_timeline_set_frame(_ptr, frame, time, mix, softness, bendDirection, compress, stretch);
-        _ptr, frame, time, mix, softness, bendDirection, compress, stretch);
   }
 
   @override
   int get constraintIndex {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_ik_constraint_timeline_get_constraint_index(_ptr);
-        .spine_ik_constraint_timeline_get_constraint_index(_ptr);
     return result;
   }
 
   @override
   set constraintIndex(int value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_ik_constraint_timeline_set_constraint_index(_ptr, value);
-        .spine_ik_constraint_timeline_set_constraint_index(_ptr, value);
   }
 }

spine-flutter/lib/generated/inherit_timeline.dart

@@ -47,20 +47,17 @@ class InheritTimeline extends Timeline implements BoneTimeline {
   Pointer get nativePtr => _ptr;
 
   factory InheritTimeline(int frameCount, int boneIndex) {
-    final ptr = SpineBindings.bindings
+    final ptr = SpineBindings.bindings.spine_inherit_timeline_create(frameCount, boneIndex);
-        .spine_inherit_timeline_create(frameCount, boneIndex);
     return InheritTimeline.fromPointer(ptr);
   }
 
   void setFrame(int frame, double time, Inherit inherit) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_inherit_timeline_set_frame(_ptr, frame, time, inherit.value);
-        .spine_inherit_timeline_set_frame(_ptr, frame, time, inherit.value);
   }
 
   @override
   int get boneIndex {
-    final result =
+    final result = SpineBindings.bindings.spine_inherit_timeline_get_bone_index(_ptr);
-        SpineBindings.bindings.spine_inherit_timeline_get_bone_index(_ptr);
     return result;
   }
 

spine-flutter/lib/generated/mesh_attachment.dart

@@ -50,8 +50,7 @@ class MeshAttachment extends VertexAttachment {
   Pointer get nativePtr => _ptr;
 
   factory MeshAttachment(String name) {
-    final ptr = SpineBindings.bindings
+    final ptr = SpineBindings.bindings.spine_mesh_attachment_create(name.toNativeUtf8().cast<Char>());
-        .spine_mesh_attachment_create(name.toNativeUtf8().cast<Char>());
     return MeshAttachment.fromPointer(ptr);
   }
 
@@ -60,8 +59,7 @@ class MeshAttachment extends VertexAttachment {
   }
 
   int get hullLength {
-    final result =
+    final result = SpineBindings.bindings.spine_mesh_attachment_get_hull_length(_ptr);
-        SpineBindings.bindings.spine_mesh_attachment_get_hull_length(_ptr);
     return result;
   }
 
@@ -70,14 +68,12 @@ class MeshAttachment extends VertexAttachment {
   }
 
   ArrayFloat get regionUVs {
-    final result =
+    final result = SpineBindings.bindings.spine_mesh_attachment_get_region_u_vs(_ptr);
-        SpineBindings.bindings.spine_mesh_attachment_get_region_u_vs(_ptr);
     return ArrayFloat.fromPointer(result);
   }
 
   set regionUVs(ArrayFloat value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_mesh_attachment_set_region_u_vs(_ptr, value.nativePtr.cast());
-        .spine_mesh_attachment_set_region_u_vs(_ptr, value.nativePtr.cast());
   }
 
   ArrayFloat get uVs {
@@ -86,14 +82,12 @@ class MeshAttachment extends VertexAttachment {
   }
 
   ArrayUnsignedShort get triangles {
-    final result =
+    final result = SpineBindings.bindings.spine_mesh_attachment_get_triangles(_ptr);
-        SpineBindings.bindings.spine_mesh_attachment_get_triangles(_ptr);
     return ArrayUnsignedShort.fromPointer(result);
   }
 
   set triangles(ArrayUnsignedShort value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_mesh_attachment_set_triangles(_ptr, value.nativePtr.cast());
-        .spine_mesh_attachment_set_triangles(_ptr, value.nativePtr.cast());
   }
 
   Color get color {
@@ -107,41 +101,34 @@ class MeshAttachment extends VertexAttachment {
   }
 
   set path(String value) {
-    SpineBindings.bindings.spine_mesh_attachment_set_path(
+    SpineBindings.bindings.spine_mesh_attachment_set_path(_ptr, value.toNativeUtf8().cast<Char>());
-        _ptr, value.toNativeUtf8().cast<Char>());
   }
 
   TextureRegion get region {
-    final result =
+    final result = SpineBindings.bindings.spine_mesh_attachment_get_region(_ptr);
-        SpineBindings.bindings.spine_mesh_attachment_get_region(_ptr);
     return TextureRegion.fromPointer(result);
   }
 
   set region(TextureRegion value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_mesh_attachment_set_region(_ptr, value.nativePtr.cast());
-        .spine_mesh_attachment_set_region(_ptr, value.nativePtr.cast());
   }
 
   Sequence get sequence {
-    final result =
+    final result = SpineBindings.bindings.spine_mesh_attachment_get_sequence(_ptr);
-        SpineBindings.bindings.spine_mesh_attachment_get_sequence(_ptr);
     return Sequence.fromPointer(result);
   }
 
   set sequence(Sequence value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_mesh_attachment_set_sequence(_ptr, value.nativePtr.cast());
-        .spine_mesh_attachment_set_sequence(_ptr, value.nativePtr.cast());
   }
 
   MeshAttachment get parentMesh {
-    final result =
+    final result = SpineBindings.bindings.spine_mesh_attachment_get_parent_mesh(_ptr);
-        SpineBindings.bindings.spine_mesh_attachment_get_parent_mesh(_ptr);
     return MeshAttachment.fromPointer(result);
   }
 
   set parentMesh(MeshAttachment value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_mesh_attachment_set_parent_mesh(_ptr, value.nativePtr.cast());
-        .spine_mesh_attachment_set_parent_mesh(_ptr, value.nativePtr.cast());
   }
 
   ArrayUnsignedShort get edges {
@@ -150,8 +137,7 @@ class MeshAttachment extends VertexAttachment {
   }
 
   set edges(ArrayUnsignedShort value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_mesh_attachment_set_edges(_ptr, value.nativePtr.cast());
-        .spine_mesh_attachment_set_edges(_ptr, value.nativePtr.cast());
   }
 
   double get width {
@@ -164,8 +150,7 @@ class MeshAttachment extends VertexAttachment {
   }
 
   double get height {
-    final result =
+    final result = SpineBindings.bindings.spine_mesh_attachment_get_height(_ptr);
-        SpineBindings.bindings.spine_mesh_attachment_get_height(_ptr);
     return result;
   }
 
@@ -174,8 +159,7 @@ class MeshAttachment extends VertexAttachment {
   }
 
   MeshAttachment newLinkedMesh() {
-    final result =
+    final result = SpineBindings.bindings.spine_mesh_attachment_new_linked_mesh(_ptr);
-        SpineBindings.bindings.spine_mesh_attachment_new_linked_mesh(_ptr);
     return MeshAttachment.fromPointer(result);
   }
 }

spine-flutter/lib/generated/path_attachment.dart

@@ -48,25 +48,21 @@ class PathAttachment extends VertexAttachment {
   Pointer get nativePtr => _ptr;
 
   factory PathAttachment(String name) {
-    final ptr = SpineBindings.bindings
+    final ptr = SpineBindings.bindings.spine_path_attachment_create(name.toNativeUtf8().cast<Char>());
-        .spine_path_attachment_create(name.toNativeUtf8().cast<Char>());
     return PathAttachment.fromPointer(ptr);
   }
 
   ArrayFloat get lengths {
-    final result =
+    final result = SpineBindings.bindings.spine_path_attachment_get_lengths(_ptr);
-        SpineBindings.bindings.spine_path_attachment_get_lengths(_ptr);
     return ArrayFloat.fromPointer(result);
   }
 
   set lengths(ArrayFloat value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_path_attachment_set_lengths(_ptr, value.nativePtr.cast());
-        .spine_path_attachment_set_lengths(_ptr, value.nativePtr.cast());
   }
 
   bool get closed {
-    final result =
+    final result = SpineBindings.bindings.spine_path_attachment_get_closed(_ptr);
-        SpineBindings.bindings.spine_path_attachment_get_closed(_ptr);
     return result;
   }
 
@@ -75,14 +71,12 @@ class PathAttachment extends VertexAttachment {
   }
 
   bool get constantSpeed {
-    final result =
+    final result = SpineBindings.bindings.spine_path_attachment_get_constant_speed(_ptr);
-        SpineBindings.bindings.spine_path_attachment_get_constant_speed(_ptr);
     return result;
   }
 
   set constantSpeed(bool value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_path_attachment_set_constant_speed(_ptr, value);
-        .spine_path_attachment_set_constant_speed(_ptr, value);
   }
 
   Color get color {

spine-flutter/lib/generated/path_constraint.dart

@@ -54,8 +54,7 @@ class PathConstraint extends PosedActive implements Posed, Constraint {
   Pointer get nativePtr => _ptr;
 
   factory PathConstraint(PathConstraintData data, Skeleton skeleton) {
-    final ptr = SpineBindings.bindings.spine_path_constraint_create(
+    final ptr = SpineBindings.bindings.spine_path_constraint_create(data.nativePtr.cast(), skeleton.nativePtr.cast());
-        data.nativePtr.cast(), skeleton.nativePtr.cast());
     return PathConstraint.fromPointer(ptr);
   }
 
@@ -66,27 +65,23 @@ class PathConstraint extends PosedActive implements Posed, Constraint {
   }
 
   PathConstraint copy(Skeleton skeleton) {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_path_constraint_copy(_ptr, skeleton.nativePtr.cast());
-        .spine_path_constraint_copy(_ptr, skeleton.nativePtr.cast());
     return PathConstraint.fromPointer(result);
   }
 
   @override
   void update(Skeleton skeleton, Physics physics) {
-    SpineBindings.bindings.spine_path_constraint_update(
+    SpineBindings.bindings.spine_path_constraint_update(_ptr, skeleton.nativePtr.cast(), physics.value);
-        _ptr, skeleton.nativePtr.cast(), physics.value);
   }
 
   @override
   void sort(Skeleton skeleton) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_path_constraint_sort(_ptr, skeleton.nativePtr.cast());
-        .spine_path_constraint_sort(_ptr, skeleton.nativePtr.cast());
   }
 
   @override
   bool get isSourceActive {
-    final result =
+    final result = SpineBindings.bindings.spine_path_constraint_is_source_active(_ptr);
-        SpineBindings.bindings.spine_path_constraint_is_source_active(_ptr);
     return result;
   }
 
@@ -101,8 +96,7 @@ class PathConstraint extends PosedActive implements Posed, Constraint {
   }
 
   set slot(Slot value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_path_constraint_set_slot(_ptr, value.nativePtr.cast());
-        .spine_path_constraint_set_slot(_ptr, value.nativePtr.cast());
   }
 
   @override
@@ -117,8 +111,7 @@ class PathConstraint extends PosedActive implements Posed, Constraint {
   }
 
   PathConstraintPose get appliedPose {
-    final result =
+    final result = SpineBindings.bindings.spine_path_constraint_get_applied_pose(_ptr);
-        SpineBindings.bindings.spine_path_constraint_get_applied_pose(_ptr);
     return PathConstraintPose.fromPointer(result);
   }
 
@@ -134,8 +127,7 @@ class PathConstraint extends PosedActive implements Posed, Constraint {
 
   @override
   bool get isPoseEqualToApplied {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_path_constraint_is_pose_equal_to_applied(_ptr);
-        .spine_path_constraint_is_pose_equal_to_applied(_ptr);
     return result;
   }
 

spine-flutter/lib/generated/path_constraint_data.dart

@@ -61,28 +61,21 @@ class PathConstraintData extends PosedData implements ConstraintData {
   Pointer get nativePtr => _ptr;
 
   factory PathConstraintData(String name) {
-    final ptr = SpineBindings.bindings
+    final ptr = SpineBindings.bindings.spine_path_constraint_data_create(name.toNativeUtf8().cast<Char>());
-        .spine_path_constraint_data_create(name.toNativeUtf8().cast<Char>());
     return PathConstraintData.fromPointer(ptr);
   }
 
   @override
   Rtti get rtti {
-    final result =
+    final result = SpineBindings.bindings.spine_path_constraint_data_get_rtti(_ptr);
-        SpineBindings.bindings.spine_path_constraint_data_get_rtti(_ptr);
     return Rtti.fromPointer(result);
   }
 
   @override
   Constraint createMethod(Skeleton skeleton) {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_path_constraint_data_create_method(_ptr, skeleton.nativePtr.cast());
-        .spine_path_constraint_data_create_method(
-            _ptr, skeleton.nativePtr.cast());
     final rtti = SpineBindings.bindings.spine_constraint_get_rtti(result);
-    final className = SpineBindings.bindings
+    final className = SpineBindings.bindings.spine_rtti_get_class_name(rtti).cast<Utf8>().toDartString();
-        .spine_rtti_get_class_name(rtti)
-        .cast<Utf8>()
-        .toDartString();
     switch (className) {
       case 'spine_ik_constraint':
         return IkConstraint.fromPointer(result.cast());
@@ -95,75 +88,62 @@ class PathConstraintData extends PosedData implements ConstraintData {
       case 'spine_transform_constraint':
         return TransformConstraint.fromPointer(result.cast());
       default:
-        throw UnsupportedError(
+        throw UnsupportedError('Unknown concrete type: $className for abstract class Constraint');
-            'Unknown concrete type: $className for abstract class Constraint');
     }
   }
 
   ArrayBoneData get bones {
-    final result =
+    final result = SpineBindings.bindings.spine_path_constraint_data_get_bones(_ptr);
-        SpineBindings.bindings.spine_path_constraint_data_get_bones(_ptr);
     return ArrayBoneData.fromPointer(result);
   }
 
   SlotData get slot {
-    final result =
+    final result = SpineBindings.bindings.spine_path_constraint_data_get_slot(_ptr);
-        SpineBindings.bindings.spine_path_constraint_data_get_slot(_ptr);
     return SlotData.fromPointer(result);
   }
 
   set slot(SlotData value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_path_constraint_data_set_slot(_ptr, value.nativePtr.cast());
-        .spine_path_constraint_data_set_slot(_ptr, value.nativePtr.cast());
   }
 
   PositionMode get positionMode {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_path_constraint_data_get_position_mode(_ptr);
-        .spine_path_constraint_data_get_position_mode(_ptr);
     return PositionMode.fromValue(result);
   }
 
   set positionMode(PositionMode value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_path_constraint_data_set_position_mode(_ptr, value.value);
-        .spine_path_constraint_data_set_position_mode(_ptr, value.value);
   }
 
   SpacingMode get spacingMode {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_path_constraint_data_get_spacing_mode(_ptr);
-        .spine_path_constraint_data_get_spacing_mode(_ptr);
     return SpacingMode.fromValue(result);
   }
 
   set spacingMode(SpacingMode value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_path_constraint_data_set_spacing_mode(_ptr, value.value);
-        .spine_path_constraint_data_set_spacing_mode(_ptr, value.value);
   }
 
   RotateMode get rotateMode {
-    final result =
+    final result = SpineBindings.bindings.spine_path_constraint_data_get_rotate_mode(_ptr);
-        SpineBindings.bindings.spine_path_constraint_data_get_rotate_mode(_ptr);
     return RotateMode.fromValue(result);
   }
 
   set rotateMode(RotateMode value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_path_constraint_data_set_rotate_mode(_ptr, value.value);
-        .spine_path_constraint_data_set_rotate_mode(_ptr, value.value);
   }
 
   double get offsetRotation {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_path_constraint_data_get_offset_rotation(_ptr);
-        .spine_path_constraint_data_get_offset_rotation(_ptr);
     return result;
   }
 
   set offsetRotation(double value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_path_constraint_data_set_offset_rotation(_ptr, value);
-        .spine_path_constraint_data_set_offset_rotation(_ptr, value);
   }
 
   PathConstraintPose get setupPose {
-    final result =
+    final result = SpineBindings.bindings.spine_path_constraint_data_get_setup_pose(_ptr);
-        SpineBindings.bindings.spine_path_constraint_data_get_setup_pose(_ptr);
     return PathConstraintPose.fromPointer(result);
   }
 

spine-flutter/lib/generated/path_constraint_mix_timeline.dart

@@ -36,41 +36,33 @@ import 'constraint_timeline.dart';
 import 'curve_timeline.dart';
 
 /// PathConstraintMixTimeline wrapper
-class PathConstraintMixTimeline extends CurveTimeline
+class PathConstraintMixTimeline extends CurveTimeline implements ConstraintTimeline {
-    implements ConstraintTimeline {
   final Pointer<spine_path_constraint_mix_timeline_wrapper> _ptr;
 
-  PathConstraintMixTimeline.fromPointer(this._ptr)
+  PathConstraintMixTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
-      : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
   @override
   Pointer get nativePtr => _ptr;
 
-  factory PathConstraintMixTimeline(
+  factory PathConstraintMixTimeline(int frameCount, int bezierCount, int constraintIndex) {
-      int frameCount, int bezierCount, int constraintIndex) {
+    final ptr =
-    final ptr = SpineBindings.bindings
+        SpineBindings.bindings.spine_path_constraint_mix_timeline_create(frameCount, bezierCount, constraintIndex);
-        .spine_path_constraint_mix_timeline_create(
-            frameCount, bezierCount, constraintIndex);
     return PathConstraintMixTimeline.fromPointer(ptr);
   }
 
-  void setFrame(
+  void setFrame(int frame, double time, double mixRotate, double mixX, double mixY) {
-      int frame, double time, double mixRotate, double mixX, double mixY) {
+    SpineBindings.bindings.spine_path_constraint_mix_timeline_set_frame(_ptr, frame, time, mixRotate, mixX, mixY);
-    SpineBindings.bindings.spine_path_constraint_mix_timeline_set_frame(
-        _ptr, frame, time, mixRotate, mixX, mixY);
   }
 
   @override
   int get constraintIndex {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_path_constraint_mix_timeline_get_constraint_index(_ptr);
-        .spine_path_constraint_mix_timeline_get_constraint_index(_ptr);
     return result;
   }
 
   @override
   set constraintIndex(int value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_path_constraint_mix_timeline_set_constraint_index(_ptr, value);
-        .spine_path_constraint_mix_timeline_set_constraint_index(_ptr, value);
   }
 }

spine-flutter/lib/generated/path_constraint_pose.dart

@@ -48,13 +48,11 @@ class PathConstraintPose implements Finalizable {
   }
 
   void set(PathConstraintPose pose) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_path_constraint_pose_set(_ptr, pose.nativePtr.cast());
-        .spine_path_constraint_pose_set(_ptr, pose.nativePtr.cast());
   }
 
   double get position {
-    final result =
+    final result = SpineBindings.bindings.spine_path_constraint_pose_get_position(_ptr);
-        SpineBindings.bindings.spine_path_constraint_pose_get_position(_ptr);
     return result;
   }
 
@@ -63,8 +61,7 @@ class PathConstraintPose implements Finalizable {
   }
 
   double get spacing {
-    final result =
+    final result = SpineBindings.bindings.spine_path_constraint_pose_get_spacing(_ptr);
-        SpineBindings.bindings.spine_path_constraint_pose_get_spacing(_ptr);
     return result;
   }
 
@@ -73,19 +70,16 @@ class PathConstraintPose implements Finalizable {
   }
 
   double get mixRotate {
-    final result =
+    final result = SpineBindings.bindings.spine_path_constraint_pose_get_mix_rotate(_ptr);
-        SpineBindings.bindings.spine_path_constraint_pose_get_mix_rotate(_ptr);
     return result;
   }
 
   set mixRotate(double value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_path_constraint_pose_set_mix_rotate(_ptr, value);
-        .spine_path_constraint_pose_set_mix_rotate(_ptr, value);
   }
 
   double get mixX {
-    final result =
+    final result = SpineBindings.bindings.spine_path_constraint_pose_get_mix_x(_ptr);
-        SpineBindings.bindings.spine_path_constraint_pose_get_mix_x(_ptr);
     return result;
   }
 
@@ -94,8 +88,7 @@ class PathConstraintPose implements Finalizable {
   }
 
   double get mixY {
-    final result =
+    final result = SpineBindings.bindings.spine_path_constraint_pose_get_mix_y(_ptr);
-        SpineBindings.bindings.spine_path_constraint_pose_get_mix_y(_ptr);
     return result;
   }
 

spine-flutter/lib/generated/path_constraint_position_timeline.dart

@@ -38,18 +38,15 @@ import 'constraint_timeline1.dart';
 class PathConstraintPositionTimeline extends ConstraintTimeline1 {
   final Pointer<spine_path_constraint_position_timeline_wrapper> _ptr;
 
-  PathConstraintPositionTimeline.fromPointer(this._ptr)
+  PathConstraintPositionTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
-      : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
   @override
   Pointer get nativePtr => _ptr;
 
-  factory PathConstraintPositionTimeline(
+  factory PathConstraintPositionTimeline(int frameCount, int bezierCount, int constraintIndex) {
-      int frameCount, int bezierCount, int constraintIndex) {
+    final ptr =
-    final ptr = SpineBindings.bindings
+        SpineBindings.bindings.spine_path_constraint_position_timeline_create(frameCount, bezierCount, constraintIndex);
-        .spine_path_constraint_position_timeline_create(
-            frameCount, bezierCount, constraintIndex);
     return PathConstraintPositionTimeline.fromPointer(ptr);
   }
 }

spine-flutter/lib/generated/path_constraint_spacing_timeline.dart

@@ -38,18 +38,15 @@ import 'constraint_timeline1.dart';
 class PathConstraintSpacingTimeline extends ConstraintTimeline1 {
   final Pointer<spine_path_constraint_spacing_timeline_wrapper> _ptr;
 
-  PathConstraintSpacingTimeline.fromPointer(this._ptr)
+  PathConstraintSpacingTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
-      : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
   @override
   Pointer get nativePtr => _ptr;
 
-  factory PathConstraintSpacingTimeline(
+  factory PathConstraintSpacingTimeline(int frameCount, int bezierCount, int constraintIndex) {
-      int frameCount, int bezierCount, int constraintIndex) {
+    final ptr =
-    final ptr = SpineBindings.bindings
+        SpineBindings.bindings.spine_path_constraint_spacing_timeline_create(frameCount, bezierCount, constraintIndex);
-        .spine_path_constraint_spacing_timeline_create(
-            frameCount, bezierCount, constraintIndex);
     return PathConstraintSpacingTimeline.fromPointer(ptr);
   }
 }

spine-flutter/lib/generated/physics_constraint.dart

@@ -53,46 +53,40 @@ class PhysicsConstraint extends PosedActive implements Posed, Constraint {
   Pointer get nativePtr => _ptr;
 
   factory PhysicsConstraint(PhysicsConstraintData data, Skeleton skeleton) {
-    final ptr = SpineBindings.bindings.spine_physics_constraint_create(
+    final ptr =
-        data.nativePtr.cast(), skeleton.nativePtr.cast());
+        SpineBindings.bindings.spine_physics_constraint_create(data.nativePtr.cast(), skeleton.nativePtr.cast());
     return PhysicsConstraint.fromPointer(ptr);
   }
 
   @override
   Rtti get rtti {
-    final result =
+    final result = SpineBindings.bindings.spine_physics_constraint_get_rtti(_ptr);
-        SpineBindings.bindings.spine_physics_constraint_get_rtti(_ptr);
     return Rtti.fromPointer(result);
   }
 
   @override
   void update(Skeleton skeleton, Physics physics) {
-    SpineBindings.bindings.spine_physics_constraint_update(
+    SpineBindings.bindings.spine_physics_constraint_update(_ptr, skeleton.nativePtr.cast(), physics.value);
-        _ptr, skeleton.nativePtr.cast(), physics.value);
   }
 
   @override
   void sort(Skeleton skeleton) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_physics_constraint_sort(_ptr, skeleton.nativePtr.cast());
-        .spine_physics_constraint_sort(_ptr, skeleton.nativePtr.cast());
   }
 
   @override
   bool get isSourceActive {
-    final result =
+    final result = SpineBindings.bindings.spine_physics_constraint_is_source_active(_ptr);
-        SpineBindings.bindings.spine_physics_constraint_is_source_active(_ptr);
     return result;
   }
 
   PhysicsConstraint copy(Skeleton skeleton) {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_physics_constraint_copy(_ptr, skeleton.nativePtr.cast());
-        .spine_physics_constraint_copy(_ptr, skeleton.nativePtr.cast());
     return PhysicsConstraint.fromPointer(result);
   }
 
   void reset(Skeleton skeleton) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_physics_constraint_reset(_ptr, skeleton.nativePtr.cast());
-        .spine_physics_constraint_reset(_ptr, skeleton.nativePtr.cast());
   }
 
   void translate(double x, double y) {
@@ -104,32 +98,27 @@ class PhysicsConstraint extends PosedActive implements Posed, Constraint {
   }
 
   BonePose get bone {
-    final result =
+    final result = SpineBindings.bindings.spine_physics_constraint_get_bone(_ptr);
-        SpineBindings.bindings.spine_physics_constraint_get_bone(_ptr);
     return BonePose.fromPointer(result);
   }
 
   set bone(BonePose value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_physics_constraint_set_bone(_ptr, value.nativePtr.cast());
-        .spine_physics_constraint_set_bone(_ptr, value.nativePtr.cast());
   }
 
   @override
   PhysicsConstraintData get data {
-    final result =
+    final result = SpineBindings.bindings.spine_physics_constraint_get_data(_ptr);
-        SpineBindings.bindings.spine_physics_constraint_get_data(_ptr);
     return PhysicsConstraintData.fromPointer(result);
   }
 
   PhysicsConstraintPose get pose {
-    final result =
+    final result = SpineBindings.bindings.spine_physics_constraint_get_pose(_ptr);
-        SpineBindings.bindings.spine_physics_constraint_get_pose(_ptr);
     return PhysicsConstraintPose.fromPointer(result);
   }
 
   PhysicsConstraintPose get appliedPose {
-    final result =
+    final result = SpineBindings.bindings.spine_physics_constraint_get_applied_pose(_ptr);
-        SpineBindings.bindings.spine_physics_constraint_get_applied_pose(_ptr);
     return PhysicsConstraintPose.fromPointer(result);
   }
 
@@ -145,8 +134,7 @@ class PhysicsConstraint extends PosedActive implements Posed, Constraint {
 
   @override
   bool get isPoseEqualToApplied {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_physics_constraint_is_pose_equal_to_applied(_ptr);
-        .spine_physics_constraint_is_pose_equal_to_applied(_ptr);
     return result;
   }
 

spine-flutter/lib/generated/physics_constraint_damping_timeline.dart

@@ -38,18 +38,15 @@ import 'physics_constraint_timeline.dart';
 class PhysicsConstraintDampingTimeline extends PhysicsConstraintTimeline {
   final Pointer<spine_physics_constraint_damping_timeline_wrapper> _ptr;
 
-  PhysicsConstraintDampingTimeline.fromPointer(this._ptr)
+  PhysicsConstraintDampingTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
-      : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
   @override
   Pointer get nativePtr => _ptr;
 
-  factory PhysicsConstraintDampingTimeline(
+  factory PhysicsConstraintDampingTimeline(int frameCount, int bezierCount, int physicsConstraintIndex) {
-      int frameCount, int bezierCount, int physicsConstraintIndex) {
     final ptr = SpineBindings.bindings
-        .spine_physics_constraint_damping_timeline_create(
+        .spine_physics_constraint_damping_timeline_create(frameCount, bezierCount, physicsConstraintIndex);
-            frameCount, bezierCount, physicsConstraintIndex);
     return PhysicsConstraintDampingTimeline.fromPointer(ptr);
   }
 }

spine-flutter/lib/generated/physics_constraint_data.dart

@@ -57,28 +57,21 @@ class PhysicsConstraintData extends PosedData implements ConstraintData {
   Pointer get nativePtr => _ptr;
 
   factory PhysicsConstraintData(String name) {
-    final ptr = SpineBindings.bindings
+    final ptr = SpineBindings.bindings.spine_physics_constraint_data_create(name.toNativeUtf8().cast<Char>());
-        .spine_physics_constraint_data_create(name.toNativeUtf8().cast<Char>());
     return PhysicsConstraintData.fromPointer(ptr);
   }
 
   @override
   Rtti get rtti {
-    final result =
+    final result = SpineBindings.bindings.spine_physics_constraint_data_get_rtti(_ptr);
-        SpineBindings.bindings.spine_physics_constraint_data_get_rtti(_ptr);
     return Rtti.fromPointer(result);
   }
 
   @override
   Constraint createMethod(Skeleton skeleton) {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_physics_constraint_data_create_method(_ptr, skeleton.nativePtr.cast());
-        .spine_physics_constraint_data_create_method(
-            _ptr, skeleton.nativePtr.cast());
     final rtti = SpineBindings.bindings.spine_constraint_get_rtti(result);
-    final className = SpineBindings.bindings
+    final className = SpineBindings.bindings.spine_rtti_get_class_name(rtti).cast<Utf8>().toDartString();
-        .spine_rtti_get_class_name(rtti)
-        .cast<Utf8>()
-        .toDartString();
     switch (className) {
       case 'spine_ik_constraint':
         return IkConstraint.fromPointer(result.cast());
@@ -91,25 +84,21 @@ class PhysicsConstraintData extends PosedData implements ConstraintData {
       case 'spine_transform_constraint':
         return TransformConstraint.fromPointer(result.cast());
       default:
-        throw UnsupportedError(
+        throw UnsupportedError('Unknown concrete type: $className for abstract class Constraint');
-            'Unknown concrete type: $className for abstract class Constraint');
     }
   }
 
   BoneData get bone {
-    final result =
+    final result = SpineBindings.bindings.spine_physics_constraint_data_get_bone(_ptr);
-        SpineBindings.bindings.spine_physics_constraint_data_get_bone(_ptr);
     return BoneData.fromPointer(result);
   }
 
   set bone(BoneData value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_physics_constraint_data_set_bone(_ptr, value.nativePtr.cast());
-        .spine_physics_constraint_data_set_bone(_ptr, value.nativePtr.cast());
   }
 
   double get step {
-    final result =
+    final result = SpineBindings.bindings.spine_physics_constraint_data_get_step(_ptr);
-        SpineBindings.bindings.spine_physics_constraint_data_get_step(_ptr);
     return result;
   }
 
@@ -118,8 +107,7 @@ class PhysicsConstraintData extends PosedData implements ConstraintData {
   }
 
   double get x {
-    final result =
+    final result = SpineBindings.bindings.spine_physics_constraint_data_get_x(_ptr);
-        SpineBindings.bindings.spine_physics_constraint_data_get_x(_ptr);
     return result;
   }
 
@@ -128,8 +116,7 @@ class PhysicsConstraintData extends PosedData implements ConstraintData {
   }
 
   double get y {
-    final result =
+    final result = SpineBindings.bindings.spine_physics_constraint_data_get_y(_ptr);
-        SpineBindings.bindings.spine_physics_constraint_data_get_y(_ptr);
     return result;
   }
 
@@ -138,41 +125,34 @@ class PhysicsConstraintData extends PosedData implements ConstraintData {
   }
 
   double get rotate {
-    final result =
+    final result = SpineBindings.bindings.spine_physics_constraint_data_get_rotate(_ptr);
-        SpineBindings.bindings.spine_physics_constraint_data_get_rotate(_ptr);
     return result;
   }
 
   set rotate(double value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_physics_constraint_data_set_rotate(_ptr, value);
-        .spine_physics_constraint_data_set_rotate(_ptr, value);
   }
 
   double get scaleX {
-    final result =
+    final result = SpineBindings.bindings.spine_physics_constraint_data_get_scale_x(_ptr);
-        SpineBindings.bindings.spine_physics_constraint_data_get_scale_x(_ptr);
     return result;
   }
 
   set scaleX(double value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_physics_constraint_data_set_scale_x(_ptr, value);
-        .spine_physics_constraint_data_set_scale_x(_ptr, value);
   }
 
   double get shearX {
-    final result =
+    final result = SpineBindings.bindings.spine_physics_constraint_data_get_shear_x(_ptr);
-        SpineBindings.bindings.spine_physics_constraint_data_get_shear_x(_ptr);
     return result;
   }
 
   set shearX(double value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_physics_constraint_data_set_shear_x(_ptr, value);
-        .spine_physics_constraint_data_set_shear_x(_ptr, value);
   }
 
   double get limit {
-    final result =
+    final result = SpineBindings.bindings.spine_physics_constraint_data_get_limit(_ptr);
-        SpineBindings.bindings.spine_physics_constraint_data_get_limit(_ptr);
     return result;
   }
 
@@ -181,85 +161,70 @@ class PhysicsConstraintData extends PosedData implements ConstraintData {
   }
 
   bool get inertiaGlobal {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_physics_constraint_data_get_inertia_global(_ptr);
-        .spine_physics_constraint_data_get_inertia_global(_ptr);
     return result;
   }
 
   set inertiaGlobal(bool value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_physics_constraint_data_set_inertia_global(_ptr, value);
-        .spine_physics_constraint_data_set_inertia_global(_ptr, value);
   }
 
   bool get strengthGlobal {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_physics_constraint_data_get_strength_global(_ptr);
-        .spine_physics_constraint_data_get_strength_global(_ptr);
     return result;
   }
 
   set strengthGlobal(bool value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_physics_constraint_data_set_strength_global(_ptr, value);
-        .spine_physics_constraint_data_set_strength_global(_ptr, value);
   }
 
   bool get dampingGlobal {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_physics_constraint_data_get_damping_global(_ptr);
-        .spine_physics_constraint_data_get_damping_global(_ptr);
     return result;
   }
 
   set dampingGlobal(bool value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_physics_constraint_data_set_damping_global(_ptr, value);
-        .spine_physics_constraint_data_set_damping_global(_ptr, value);
   }
 
   bool get massGlobal {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_physics_constraint_data_get_mass_global(_ptr);
-        .spine_physics_constraint_data_get_mass_global(_ptr);
     return result;
   }
 
   set massGlobal(bool value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_physics_constraint_data_set_mass_global(_ptr, value);
-        .spine_physics_constraint_data_set_mass_global(_ptr, value);
   }
 
   bool get windGlobal {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_physics_constraint_data_get_wind_global(_ptr);
-        .spine_physics_constraint_data_get_wind_global(_ptr);
     return result;
   }
 
   set windGlobal(bool value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_physics_constraint_data_set_wind_global(_ptr, value);
-        .spine_physics_constraint_data_set_wind_global(_ptr, value);
   }
 
   bool get gravityGlobal {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_physics_constraint_data_get_gravity_global(_ptr);
-        .spine_physics_constraint_data_get_gravity_global(_ptr);
     return result;
   }
 
   set gravityGlobal(bool value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_physics_constraint_data_set_gravity_global(_ptr, value);
-        .spine_physics_constraint_data_set_gravity_global(_ptr, value);
   }
 
   bool get mixGlobal {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_physics_constraint_data_get_mix_global(_ptr);
-        .spine_physics_constraint_data_get_mix_global(_ptr);
     return result;
   }
 
   set mixGlobal(bool value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_physics_constraint_data_set_mix_global(_ptr, value);
-        .spine_physics_constraint_data_set_mix_global(_ptr, value);
   }
 
   PhysicsConstraintPose get setupPose {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_physics_constraint_data_get_setup_pose(_ptr);
-        .spine_physics_constraint_data_get_setup_pose(_ptr);
     return PhysicsConstraintPose.fromPointer(result);
   }
 

spine-flutter/lib/generated/physics_constraint_gravity_timeline.dart

@@ -38,18 +38,15 @@ import 'physics_constraint_timeline.dart';
 class PhysicsConstraintGravityTimeline extends PhysicsConstraintTimeline {
   final Pointer<spine_physics_constraint_gravity_timeline_wrapper> _ptr;
 
-  PhysicsConstraintGravityTimeline.fromPointer(this._ptr)
+  PhysicsConstraintGravityTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
-      : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
   @override
   Pointer get nativePtr => _ptr;
 
-  factory PhysicsConstraintGravityTimeline(
+  factory PhysicsConstraintGravityTimeline(int frameCount, int bezierCount, int physicsConstraintIndex) {
-      int frameCount, int bezierCount, int physicsConstraintIndex) {
     final ptr = SpineBindings.bindings
-        .spine_physics_constraint_gravity_timeline_create(
+        .spine_physics_constraint_gravity_timeline_create(frameCount, bezierCount, physicsConstraintIndex);
-            frameCount, bezierCount, physicsConstraintIndex);
     return PhysicsConstraintGravityTimeline.fromPointer(ptr);
   }
 }

spine-flutter/lib/generated/physics_constraint_inertia_timeline.dart

@@ -38,18 +38,15 @@ import 'physics_constraint_timeline.dart';
 class PhysicsConstraintInertiaTimeline extends PhysicsConstraintTimeline {
   final Pointer<spine_physics_constraint_inertia_timeline_wrapper> _ptr;
 
-  PhysicsConstraintInertiaTimeline.fromPointer(this._ptr)
+  PhysicsConstraintInertiaTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
-      : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
   @override
   Pointer get nativePtr => _ptr;
 
-  factory PhysicsConstraintInertiaTimeline(
+  factory PhysicsConstraintInertiaTimeline(int frameCount, int bezierCount, int physicsConstraintIndex) {
-      int frameCount, int bezierCount, int physicsConstraintIndex) {
     final ptr = SpineBindings.bindings
-        .spine_physics_constraint_inertia_timeline_create(
+        .spine_physics_constraint_inertia_timeline_create(frameCount, bezierCount, physicsConstraintIndex);
-            frameCount, bezierCount, physicsConstraintIndex);
     return PhysicsConstraintInertiaTimeline.fromPointer(ptr);
   }
 }

spine-flutter/lib/generated/physics_constraint_mass_timeline.dart

@@ -38,18 +38,15 @@ import 'physics_constraint_timeline.dart';
 class PhysicsConstraintMassTimeline extends PhysicsConstraintTimeline {
   final Pointer<spine_physics_constraint_mass_timeline_wrapper> _ptr;
 
-  PhysicsConstraintMassTimeline.fromPointer(this._ptr)
+  PhysicsConstraintMassTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
-      : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
   @override
   Pointer get nativePtr => _ptr;
 
-  factory PhysicsConstraintMassTimeline(
+  factory PhysicsConstraintMassTimeline(int frameCount, int bezierCount, int physicsConstraintIndex) {
-      int frameCount, int bezierCount, int physicsConstraintIndex) {
     final ptr = SpineBindings.bindings
-        .spine_physics_constraint_mass_timeline_create(
+        .spine_physics_constraint_mass_timeline_create(frameCount, bezierCount, physicsConstraintIndex);
-            frameCount, bezierCount, physicsConstraintIndex);
     return PhysicsConstraintMassTimeline.fromPointer(ptr);
   }
 }

spine-flutter/lib/generated/physics_constraint_mix_timeline.dart

@@ -38,18 +38,15 @@ import 'physics_constraint_timeline.dart';
 class PhysicsConstraintMixTimeline extends PhysicsConstraintTimeline {
   final Pointer<spine_physics_constraint_mix_timeline_wrapper> _ptr;
 
-  PhysicsConstraintMixTimeline.fromPointer(this._ptr)
+  PhysicsConstraintMixTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
-      : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
   @override
   Pointer get nativePtr => _ptr;
 
-  factory PhysicsConstraintMixTimeline(
+  factory PhysicsConstraintMixTimeline(int frameCount, int bezierCount, int physicsConstraintIndex) {
-      int frameCount, int bezierCount, int physicsConstraintIndex) {
     final ptr = SpineBindings.bindings
-        .spine_physics_constraint_mix_timeline_create(
+        .spine_physics_constraint_mix_timeline_create(frameCount, bezierCount, physicsConstraintIndex);
-            frameCount, bezierCount, physicsConstraintIndex);
     return PhysicsConstraintMixTimeline.fromPointer(ptr);
   }
 }

spine-flutter/lib/generated/physics_constraint_pose.dart

@@ -48,57 +48,47 @@ class PhysicsConstraintPose implements Finalizable {
   }
 
   void set(PhysicsConstraintPose pose) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_physics_constraint_pose_set(_ptr, pose.nativePtr.cast());
-        .spine_physics_constraint_pose_set(_ptr, pose.nativePtr.cast());
   }
 
   double get inertia {
-    final result =
+    final result = SpineBindings.bindings.spine_physics_constraint_pose_get_inertia(_ptr);
-        SpineBindings.bindings.spine_physics_constraint_pose_get_inertia(_ptr);
     return result;
   }
 
   set inertia(double value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_physics_constraint_pose_set_inertia(_ptr, value);
-        .spine_physics_constraint_pose_set_inertia(_ptr, value);
   }
 
   double get strength {
-    final result =
+    final result = SpineBindings.bindings.spine_physics_constraint_pose_get_strength(_ptr);
-        SpineBindings.bindings.spine_physics_constraint_pose_get_strength(_ptr);
     return result;
   }
 
   set strength(double value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_physics_constraint_pose_set_strength(_ptr, value);
-        .spine_physics_constraint_pose_set_strength(_ptr, value);
   }
 
   double get damping {
-    final result =
+    final result = SpineBindings.bindings.spine_physics_constraint_pose_get_damping(_ptr);
-        SpineBindings.bindings.spine_physics_constraint_pose_get_damping(_ptr);
     return result;
   }
 
   set damping(double value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_physics_constraint_pose_set_damping(_ptr, value);
-        .spine_physics_constraint_pose_set_damping(_ptr, value);
   }
 
   double get massInverse {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_physics_constraint_pose_get_mass_inverse(_ptr);
-        .spine_physics_constraint_pose_get_mass_inverse(_ptr);
     return result;
   }
 
   set massInverse(double value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_physics_constraint_pose_set_mass_inverse(_ptr, value);
-        .spine_physics_constraint_pose_set_mass_inverse(_ptr, value);
   }
 
   double get wind {
-    final result =
+    final result = SpineBindings.bindings.spine_physics_constraint_pose_get_wind(_ptr);
-        SpineBindings.bindings.spine_physics_constraint_pose_get_wind(_ptr);
     return result;
   }
 
@@ -107,19 +97,16 @@ class PhysicsConstraintPose implements Finalizable {
   }
 
   double get gravity {
-    final result =
+    final result = SpineBindings.bindings.spine_physics_constraint_pose_get_gravity(_ptr);
-        SpineBindings.bindings.spine_physics_constraint_pose_get_gravity(_ptr);
     return result;
   }
 
   set gravity(double value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_physics_constraint_pose_set_gravity(_ptr, value);
-        .spine_physics_constraint_pose_set_gravity(_ptr, value);
   }
 
   double get mix {
-    final result =
+    final result = SpineBindings.bindings.spine_physics_constraint_pose_get_mix(_ptr);
-        SpineBindings.bindings.spine_physics_constraint_pose_get_mix(_ptr);
     return result;
   }
 

spine-flutter/lib/generated/physics_constraint_reset_timeline.dart

@@ -36,40 +36,32 @@ import 'constraint_timeline.dart';
 import 'timeline.dart';
 
 /// PhysicsConstraintResetTimeline wrapper
-class PhysicsConstraintResetTimeline extends Timeline
+class PhysicsConstraintResetTimeline extends Timeline implements ConstraintTimeline {
-    implements ConstraintTimeline {
   final Pointer<spine_physics_constraint_reset_timeline_wrapper> _ptr;
 
-  PhysicsConstraintResetTimeline.fromPointer(this._ptr)
+  PhysicsConstraintResetTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
-      : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
   @override
   Pointer get nativePtr => _ptr;
 
   factory PhysicsConstraintResetTimeline(int frameCount, int constraintIndex) {
-    final ptr = SpineBindings.bindings
+    final ptr = SpineBindings.bindings.spine_physics_constraint_reset_timeline_create(frameCount, constraintIndex);
-        .spine_physics_constraint_reset_timeline_create(
-            frameCount, constraintIndex);
     return PhysicsConstraintResetTimeline.fromPointer(ptr);
   }
 
   @override
   int get constraintIndex {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_physics_constraint_reset_timeline_get_constraint_index(_ptr);
-        .spine_physics_constraint_reset_timeline_get_constraint_index(_ptr);
     return result;
   }
 
   @override
   set constraintIndex(int value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_physics_constraint_reset_timeline_set_constraint_index(_ptr, value);
-        .spine_physics_constraint_reset_timeline_set_constraint_index(
-            _ptr, value);
   }
 
   void setFrame(int frame, double time) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_physics_constraint_reset_timeline_set_frame(_ptr, frame, time);
-        .spine_physics_constraint_reset_timeline_set_frame(_ptr, frame, time);
   }
 }

spine-flutter/lib/generated/physics_constraint_strength_timeline.dart

@@ -38,18 +38,15 @@ import 'physics_constraint_timeline.dart';
 class PhysicsConstraintStrengthTimeline extends PhysicsConstraintTimeline {
   final Pointer<spine_physics_constraint_strength_timeline_wrapper> _ptr;
 
-  PhysicsConstraintStrengthTimeline.fromPointer(this._ptr)
+  PhysicsConstraintStrengthTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
-      : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
   @override
   Pointer get nativePtr => _ptr;
 
-  factory PhysicsConstraintStrengthTimeline(
+  factory PhysicsConstraintStrengthTimeline(int frameCount, int bezierCount, int physicsConstraintIndex) {
-      int frameCount, int bezierCount, int physicsConstraintIndex) {
     final ptr = SpineBindings.bindings
-        .spine_physics_constraint_strength_timeline_create(
+        .spine_physics_constraint_strength_timeline_create(frameCount, bezierCount, physicsConstraintIndex);
-            frameCount, bezierCount, physicsConstraintIndex);
     return PhysicsConstraintStrengthTimeline.fromPointer(ptr);
   }
 }

spine-flutter/lib/generated/physics_constraint_timeline.dart

@@ -36,12 +36,10 @@ import 'constraint_timeline.dart';
 import 'curve_timeline1.dart';
 
 /// PhysicsConstraintTimeline wrapper
-abstract class PhysicsConstraintTimeline extends CurveTimeline1
+abstract class PhysicsConstraintTimeline extends CurveTimeline1 implements ConstraintTimeline {
-    implements ConstraintTimeline {
   final Pointer<spine_physics_constraint_timeline_wrapper> _ptr;
 
-  PhysicsConstraintTimeline.fromPointer(this._ptr)
+  PhysicsConstraintTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
-      : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
   @override
@@ -49,14 +47,12 @@ abstract class PhysicsConstraintTimeline extends CurveTimeline1
 
   @override
   int get constraintIndex {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_physics_constraint_timeline_get_constraint_index(_ptr);
-        .spine_physics_constraint_timeline_get_constraint_index(_ptr);
     return result;
   }
 
   @override
   set constraintIndex(int value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_physics_constraint_timeline_set_constraint_index(_ptr, value);
-        .spine_physics_constraint_timeline_set_constraint_index(_ptr, value);
   }
 }

spine-flutter/lib/generated/physics_constraint_wind_timeline.dart

@@ -38,18 +38,15 @@ import 'physics_constraint_timeline.dart';
 class PhysicsConstraintWindTimeline extends PhysicsConstraintTimeline {
   final Pointer<spine_physics_constraint_wind_timeline_wrapper> _ptr;
 
-  PhysicsConstraintWindTimeline.fromPointer(this._ptr)
+  PhysicsConstraintWindTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
-      : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
   @override
   Pointer get nativePtr => _ptr;
 
-  factory PhysicsConstraintWindTimeline(
+  factory PhysicsConstraintWindTimeline(int frameCount, int bezierCount, int physicsConstraintIndex) {
-      int frameCount, int bezierCount, int physicsConstraintIndex) {
     final ptr = SpineBindings.bindings
-        .spine_physics_constraint_wind_timeline_create(
+        .spine_physics_constraint_wind_timeline_create(frameCount, bezierCount, physicsConstraintIndex);
-            frameCount, bezierCount, physicsConstraintIndex);
     return PhysicsConstraintWindTimeline.fromPointer(ptr);
   }
 }

spine-flutter/lib/generated/point_attachment.dart

@@ -48,8 +48,7 @@ class PointAttachment extends Attachment {
   Pointer get nativePtr => _ptr;
 
   factory PointAttachment(String name) {
-    final ptr = SpineBindings.bindings
+    final ptr = SpineBindings.bindings.spine_point_attachment_create(name.toNativeUtf8().cast<Char>());
-        .spine_point_attachment_create(name.toNativeUtf8().cast<Char>());
     return PointAttachment.fromPointer(ptr);
   }
 
@@ -72,8 +71,7 @@ class PointAttachment extends Attachment {
   }
 
   double get rotation {
-    final result =
+    final result = SpineBindings.bindings.spine_point_attachment_get_rotation(_ptr);
-        SpineBindings.bindings.spine_point_attachment_get_rotation(_ptr);
     return result;
   }
 
@@ -82,15 +80,12 @@ class PointAttachment extends Attachment {
   }
 
   Color get color {
-    final result =
+    final result = SpineBindings.bindings.spine_point_attachment_get_color(_ptr);
-        SpineBindings.bindings.spine_point_attachment_get_color(_ptr);
     return Color.fromPointer(result);
   }
 
   double computeWorldRotation(BonePose bone) {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_point_attachment_compute_world_rotation(_ptr, bone.nativePtr.cast());
-        .spine_point_attachment_compute_world_rotation(
-            _ptr, bone.nativePtr.cast());
     return result;
   }
 }

spine-flutter/lib/generated/polygon.dart

@@ -54,8 +54,7 @@ class Polygon implements Finalizable {
   }
 
   set vertices(ArrayFloat value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_polygon_set__vertices(_ptr, value.nativePtr.cast());
-        .spine_polygon_set__vertices(_ptr, value.nativePtr.cast());
   }
 
   int get count {

spine-flutter/lib/generated/posed_data.dart

@@ -44,8 +44,7 @@ class PosedData implements Finalizable {
   Pointer get nativePtr => _ptr;
 
   factory PosedData(String name) {
-    final ptr = SpineBindings.bindings
+    final ptr = SpineBindings.bindings.spine_posed_data_create(name.toNativeUtf8().cast<Char>());
-        .spine_posed_data_create(name.toNativeUtf8().cast<Char>());
     return PosedData.fromPointer(ptr);
   }
 
@@ -55,8 +54,7 @@ class PosedData implements Finalizable {
   }
 
   bool get skinRequired {
-    final result =
+    final result = SpineBindings.bindings.spine_posed_data_get_skin_required(_ptr);
-        SpineBindings.bindings.spine_posed_data_get_skin_required(_ptr);
     return result;
   }
 

spine-flutter/lib/generated/region_attachment.dart

@@ -51,8 +51,7 @@ class RegionAttachment extends Attachment {
   Pointer get nativePtr => _ptr;
 
   factory RegionAttachment(String name) {
-    final ptr = SpineBindings.bindings
+    final ptr = SpineBindings.bindings.spine_region_attachment_create(name.toNativeUtf8().cast<Char>());
-        .spine_region_attachment_create(name.toNativeUtf8().cast<Char>());
     return RegionAttachment.fromPointer(ptr);
   }
 
@@ -79,8 +78,7 @@ class RegionAttachment extends Attachment {
   }
 
   double get rotation {
-    final result =
+    final result = SpineBindings.bindings.spine_region_attachment_get_rotation(_ptr);
-        SpineBindings.bindings.spine_region_attachment_get_rotation(_ptr);
     return result;
   }
 
@@ -89,8 +87,7 @@ class RegionAttachment extends Attachment {
   }
 
   double get scaleX {
-    final result =
+    final result = SpineBindings.bindings.spine_region_attachment_get_scale_x(_ptr);
-        SpineBindings.bindings.spine_region_attachment_get_scale_x(_ptr);
     return result;
   }
 
@@ -99,8 +96,7 @@ class RegionAttachment extends Attachment {
   }
 
   double get scaleY {
-    final result =
+    final result = SpineBindings.bindings.spine_region_attachment_get_scale_y(_ptr);
-        SpineBindings.bindings.spine_region_attachment_get_scale_y(_ptr);
     return result;
   }
 
@@ -109,8 +105,7 @@ class RegionAttachment extends Attachment {
   }
 
   double get width {
-    final result =
+    final result = SpineBindings.bindings.spine_region_attachment_get_width(_ptr);
-        SpineBindings.bindings.spine_region_attachment_get_width(_ptr);
     return result;
   }
 
@@ -119,8 +114,7 @@ class RegionAttachment extends Attachment {
   }
 
   double get height {
-    final result =
+    final result = SpineBindings.bindings.spine_region_attachment_get_height(_ptr);
-        SpineBindings.bindings.spine_region_attachment_get_height(_ptr);
     return result;
   }
 
@@ -129,63 +123,49 @@ class RegionAttachment extends Attachment {
   }
 
   Color get color {
-    final result =
+    final result = SpineBindings.bindings.spine_region_attachment_get_color(_ptr);
-        SpineBindings.bindings.spine_region_attachment_get_color(_ptr);
     return Color.fromPointer(result);
   }
 
   String get path {
-    final result =
+    final result = SpineBindings.bindings.spine_region_attachment_get_path(_ptr);
-        SpineBindings.bindings.spine_region_attachment_get_path(_ptr);
     return result.cast<Utf8>().toDartString();
   }
 
   set path(String value) {
-    SpineBindings.bindings.spine_region_attachment_set_path(
+    SpineBindings.bindings.spine_region_attachment_set_path(_ptr, value.toNativeUtf8().cast<Char>());
-        _ptr, value.toNativeUtf8().cast<Char>());
   }
 
   TextureRegion get region {
-    final result =
+    final result = SpineBindings.bindings.spine_region_attachment_get_region(_ptr);
-        SpineBindings.bindings.spine_region_attachment_get_region(_ptr);
     return TextureRegion.fromPointer(result);
   }
 
   set region(TextureRegion value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_region_attachment_set_region(_ptr, value.nativePtr.cast());
-        .spine_region_attachment_set_region(_ptr, value.nativePtr.cast());
   }
 
   Sequence get sequence {
-    final result =
+    final result = SpineBindings.bindings.spine_region_attachment_get_sequence(_ptr);
-        SpineBindings.bindings.spine_region_attachment_get_sequence(_ptr);
     return Sequence.fromPointer(result);
   }
 
   set sequence(Sequence value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_region_attachment_set_sequence(_ptr, value.nativePtr.cast());
-        .spine_region_attachment_set_sequence(_ptr, value.nativePtr.cast());
   }
 
   ArrayFloat get offset {
-    final result =
+    final result = SpineBindings.bindings.spine_region_attachment_get_offset(_ptr);
-        SpineBindings.bindings.spine_region_attachment_get_offset(_ptr);
     return ArrayFloat.fromPointer(result);
   }
 
   ArrayFloat get uVs {
-    final result =
+    final result = SpineBindings.bindings.spine_region_attachment_get_u_vs(_ptr);
-        SpineBindings.bindings.spine_region_attachment_get_u_vs(_ptr);
     return ArrayFloat.fromPointer(result);
   }
 
-  void computeWorldVertices(
+  void computeWorldVertices(Slot slot, ArrayFloat worldVertices, int offset, int stride) {
-      Slot slot, ArrayFloat worldVertices, int offset, int stride) {
     SpineBindings.bindings.spine_region_attachment_compute_world_vertices_2(
-        _ptr,
+        _ptr, slot.nativePtr.cast(), worldVertices.nativePtr.cast(), offset, stride);
-        slot.nativePtr.cast(),
-        worldVertices.nativePtr.cast(),
-        offset,
-        stride);
   }
 }

spine-flutter/lib/generated/render_command.dart

@@ -44,8 +44,7 @@ class RenderCommand implements Finalizable {
   Pointer get nativePtr => _ptr;
 
   Pointer<Float> get positions {
-    final result =
+    final result = SpineBindings.bindings.spine_render_command_get_positions(_ptr);
-        SpineBindings.bindings.spine_render_command_get_positions(_ptr);
     return result;
   }
 
@@ -60,38 +59,32 @@ class RenderCommand implements Finalizable {
   }
 
   Pointer<Uint32> get darkColors {
-    final result =
+    final result = SpineBindings.bindings.spine_render_command_get_dark_colors(_ptr);
-        SpineBindings.bindings.spine_render_command_get_dark_colors(_ptr);
     return result;
   }
 
   int get numVertices {
-    final result =
+    final result = SpineBindings.bindings.spine_render_command_get_num_vertices(_ptr);
-        SpineBindings.bindings.spine_render_command_get_num_vertices(_ptr);
     return result;
   }
 
   Pointer<Uint16> get indices {
-    final result =
+    final result = SpineBindings.bindings.spine_render_command_get_indices(_ptr);
-        SpineBindings.bindings.spine_render_command_get_indices(_ptr);
     return result;
   }
 
   int get numIndices {
-    final result =
+    final result = SpineBindings.bindings.spine_render_command_get_num_indices(_ptr);
-        SpineBindings.bindings.spine_render_command_get_num_indices(_ptr);
     return result;
   }
 
   BlendMode get blendMode {
-    final result =
+    final result = SpineBindings.bindings.spine_render_command_get_blend_mode(_ptr);
-        SpineBindings.bindings.spine_render_command_get_blend_mode(_ptr);
     return BlendMode.fromValue(result);
   }
 
   Pointer<Void> get texture {
-    final result =
+    final result = SpineBindings.bindings.spine_render_command_get_texture(_ptr);
-        SpineBindings.bindings.spine_render_command_get_texture(_ptr);
     return result;
   }
 

spine-flutter/lib/generated/rgb2_timeline.dart

@@ -45,14 +45,11 @@ class Rgb2Timeline extends SlotCurveTimeline {
   Pointer get nativePtr => _ptr;
 
   factory Rgb2Timeline(int frameCount, int bezierCount, int slotIndex) {
-    final ptr = SpineBindings.bindings
+    final ptr = SpineBindings.bindings.spine_rgb2_timeline_create(frameCount, bezierCount, slotIndex);
-        .spine_rgb2_timeline_create(frameCount, bezierCount, slotIndex);
     return Rgb2Timeline.fromPointer(ptr);
   }
 
-  void setFrame(int frame, double time, double r, double g, double b, double r2,
+  void setFrame(int frame, double time, double r, double g, double b, double r2, double g2, double b2) {
-      double g2, double b2) {
+    SpineBindings.bindings.spine_rgb2_timeline_set_frame(_ptr, frame, time, r, g, b, r2, g2, b2);
-    SpineBindings.bindings
-        .spine_rgb2_timeline_set_frame(_ptr, frame, time, r, g, b, r2, g2, b2);
   }
 }

spine-flutter/lib/generated/rgb_timeline.dart

@@ -45,13 +45,11 @@ class RgbTimeline extends SlotCurveTimeline {
   Pointer get nativePtr => _ptr;
 
   factory RgbTimeline(int frameCount, int bezierCount, int slotIndex) {
-    final ptr = SpineBindings.bindings
+    final ptr = SpineBindings.bindings.spine_rgb_timeline_create(frameCount, bezierCount, slotIndex);
-        .spine_rgb_timeline_create(frameCount, bezierCount, slotIndex);
     return RgbTimeline.fromPointer(ptr);
   }
 
   void setFrame(int frame, double time, double r, double g, double b) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_rgb_timeline_set_frame(_ptr, frame, time, r, g, b);
-        .spine_rgb_timeline_set_frame(_ptr, frame, time, r, g, b);
   }
 }

spine-flutter/lib/generated/rgba2_timeline.dart

@@ -45,14 +45,11 @@ class Rgba2Timeline extends SlotCurveTimeline {
   Pointer get nativePtr => _ptr;
 
   factory Rgba2Timeline(int frameCount, int bezierCount, int slotIndex) {
-    final ptr = SpineBindings.bindings
+    final ptr = SpineBindings.bindings.spine_rgba2_timeline_create(frameCount, bezierCount, slotIndex);
-        .spine_rgba2_timeline_create(frameCount, bezierCount, slotIndex);
     return Rgba2Timeline.fromPointer(ptr);
   }
 
-  void setFrame(int frame, double time, double r, double g, double b, double a,
+  void setFrame(int frame, double time, double r, double g, double b, double a, double r2, double g2, double b2) {
-      double r2, double g2, double b2) {
+    SpineBindings.bindings.spine_rgba2_timeline_set_frame(_ptr, frame, time, r, g, b, a, r2, g2, b2);
-    SpineBindings.bindings.spine_rgba2_timeline_set_frame(
-        _ptr, frame, time, r, g, b, a, r2, g2, b2);
   }
 }

spine-flutter/lib/generated/rgba_timeline.dart

@@ -45,14 +45,11 @@ class RgbaTimeline extends SlotCurveTimeline {
   Pointer get nativePtr => _ptr;
 
   factory RgbaTimeline(int frameCount, int bezierCount, int slotIndex) {
-    final ptr = SpineBindings.bindings
+    final ptr = SpineBindings.bindings.spine_rgba_timeline_create(frameCount, bezierCount, slotIndex);
-        .spine_rgba_timeline_create(frameCount, bezierCount, slotIndex);
     return RgbaTimeline.fromPointer(ptr);
   }
 
-  void setFrame(
+  void setFrame(int frame, double time, double r, double g, double b, double a) {
-      int frame, double time, double r, double g, double b, double a) {
+    SpineBindings.bindings.spine_rgba_timeline_set_frame(_ptr, frame, time, r, g, b, a);
-    SpineBindings.bindings
-        .spine_rgba_timeline_set_frame(_ptr, frame, time, r, g, b, a);
   }
 }

spine-flutter/lib/generated/rotate_timeline.dart

@@ -45,8 +45,7 @@ class RotateTimeline extends BoneTimeline1 {
   Pointer get nativePtr => _ptr;
 
   factory RotateTimeline(int frameCount, int bezierCount, int boneIndex) {
-    final ptr = SpineBindings.bindings
+    final ptr = SpineBindings.bindings.spine_rotate_timeline_create(frameCount, bezierCount, boneIndex);
-        .spine_rotate_timeline_create(frameCount, bezierCount, boneIndex);
     return RotateTimeline.fromPointer(ptr);
   }
 }

spine-flutter/lib/generated/rtti.dart

@@ -49,14 +49,12 @@ class Rtti implements Finalizable {
   }
 
   bool isExactly(Rtti rtti) {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_rtti_is_exactly(_ptr, rtti.nativePtr.cast());
-        .spine_rtti_is_exactly(_ptr, rtti.nativePtr.cast());
     return result;
   }
 
   bool instanceOf(Rtti rtti) {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_rtti_instance_of(_ptr, rtti.nativePtr.cast());
-        .spine_rtti_instance_of(_ptr, rtti.nativePtr.cast());
     return result;
   }
 }

spine-flutter/lib/generated/scale_timeline.dart

@@ -45,8 +45,7 @@ class ScaleTimeline extends BoneTimeline2 {
   Pointer get nativePtr => _ptr;
 
   factory ScaleTimeline(int frameCount, int bezierCount, int boneIndex) {
-    final ptr = SpineBindings.bindings
+    final ptr = SpineBindings.bindings.spine_scale_timeline_create(frameCount, bezierCount, boneIndex);
-        .spine_scale_timeline_create(frameCount, bezierCount, boneIndex);
     return ScaleTimeline.fromPointer(ptr);
   }
 }

spine-flutter/lib/generated/scale_x_timeline.dart

@@ -45,8 +45,7 @@ class ScaleXTimeline extends BoneTimeline1 {
   Pointer get nativePtr => _ptr;
 
   factory ScaleXTimeline(int frameCount, int bezierCount, int boneIndex) {
-    final ptr = SpineBindings.bindings
+    final ptr = SpineBindings.bindings.spine_scale_x_timeline_create(frameCount, bezierCount, boneIndex);
-        .spine_scale_x_timeline_create(frameCount, bezierCount, boneIndex);
     return ScaleXTimeline.fromPointer(ptr);
   }
 }

spine-flutter/lib/generated/scale_y_timeline.dart

@@ -45,8 +45,7 @@ class ScaleYTimeline extends BoneTimeline1 {
   Pointer get nativePtr => _ptr;
 
   factory ScaleYTimeline(int frameCount, int bezierCount, int boneIndex) {
-    final ptr = SpineBindings.bindings
+    final ptr = SpineBindings.bindings.spine_scale_y_timeline_create(frameCount, bezierCount, boneIndex);
-        .spine_scale_y_timeline_create(frameCount, bezierCount, boneIndex);
     return ScaleYTimeline.fromPointer(ptr);
   }
 }

spine-flutter/lib/generated/sequence.dart

@@ -57,13 +57,11 @@ class Sequence implements Finalizable {
   }
 
   void apply(SlotPose slot, Attachment attachment) {
-    SpineBindings.bindings.spine_sequence_apply(
+    SpineBindings.bindings.spine_sequence_apply(_ptr, slot.nativePtr.cast(), attachment.nativePtr.cast());
-        _ptr, slot.nativePtr.cast(), attachment.nativePtr.cast());
   }
 
   String getPath(String basePath, int index) {
-    final result = SpineBindings.bindings.spine_sequence_get_path(
+    final result = SpineBindings.bindings.spine_sequence_get_path(_ptr, basePath.toNativeUtf8().cast<Char>(), index);
-        _ptr, basePath.toNativeUtf8().cast<Char>(), index);
     return result.cast<Utf8>().toDartString();
   }
 

spine-flutter/lib/generated/sequence_timeline.dart

@@ -54,27 +54,20 @@ class SequenceTimeline extends Timeline implements SlotTimeline {
   @override
   Pointer get nativePtr => _ptr;
 
-  factory SequenceTimeline(
+  factory SequenceTimeline(int frameCount, int slotIndex, Attachment attachment) {
-      int frameCount, int slotIndex, Attachment attachment) {
+    final ptr =
-    final ptr = SpineBindings.bindings.spine_sequence_timeline_create(
+        SpineBindings.bindings.spine_sequence_timeline_create(frameCount, slotIndex, attachment.nativePtr.cast());
-        frameCount, slotIndex, attachment.nativePtr.cast());
     return SequenceTimeline.fromPointer(ptr);
   }
 
-  void setFrame(
+  void setFrame(int frame, double time, SequenceMode mode, int index, double delay) {
-      int frame, double time, SequenceMode mode, int index, double delay) {
+    SpineBindings.bindings.spine_sequence_timeline_set_frame(_ptr, frame, time, mode.value, index, delay);
-    SpineBindings.bindings.spine_sequence_timeline_set_frame(
-        _ptr, frame, time, mode.value, index, delay);
   }
 
   Attachment get attachment {
-    final result =
+    final result = SpineBindings.bindings.spine_sequence_timeline_get_attachment(_ptr);
-        SpineBindings.bindings.spine_sequence_timeline_get_attachment(_ptr);
     final rtti = SpineBindings.bindings.spine_attachment_get_rtti(result);
-    final className = SpineBindings.bindings
+    final className = SpineBindings.bindings.spine_rtti_get_class_name(rtti).cast<Utf8>().toDartString();
-        .spine_rtti_get_class_name(rtti)
-        .cast<Utf8>()
-        .toDartString();
     switch (className) {
       case 'spine_bounding_box_attachment':
         return BoundingBoxAttachment.fromPointer(result.cast());
@@ -89,15 +82,13 @@ class SequenceTimeline extends Timeline implements SlotTimeline {
       case 'spine_region_attachment':
         return RegionAttachment.fromPointer(result.cast());
       default:
-        throw UnsupportedError(
+        throw UnsupportedError('Unknown concrete type: $className for abstract class Attachment');
-            'Unknown concrete type: $className for abstract class Attachment');
     }
   }
 
   @override
   int get slotIndex {
-    final result =
+    final result = SpineBindings.bindings.spine_sequence_timeline_get_slot_index(_ptr);
-        SpineBindings.bindings.spine_sequence_timeline_get_slot_index(_ptr);
     return result;
   }
 

spine-flutter/lib/generated/shear_timeline.dart

@@ -45,8 +45,7 @@ class ShearTimeline extends BoneTimeline2 {
   Pointer get nativePtr => _ptr;
 
   factory ShearTimeline(int frameCount, int bezierCount, int boneIndex) {
-    final ptr = SpineBindings.bindings
+    final ptr = SpineBindings.bindings.spine_shear_timeline_create(frameCount, bezierCount, boneIndex);
-        .spine_shear_timeline_create(frameCount, bezierCount, boneIndex);
     return ShearTimeline.fromPointer(ptr);
   }
 }

spine-flutter/lib/generated/shear_x_timeline.dart

@@ -45,8 +45,7 @@ class ShearXTimeline extends BoneTimeline1 {
   Pointer get nativePtr => _ptr;
 
   factory ShearXTimeline(int frameCount, int bezierCount, int boneIndex) {
-    final ptr = SpineBindings.bindings
+    final ptr = SpineBindings.bindings.spine_shear_x_timeline_create(frameCount, bezierCount, boneIndex);
-        .spine_shear_x_timeline_create(frameCount, bezierCount, boneIndex);
     return ShearXTimeline.fromPointer(ptr);
   }
 }

spine-flutter/lib/generated/shear_y_timeline.dart

@@ -45,8 +45,7 @@ class ShearYTimeline extends BoneTimeline1 {
   Pointer get nativePtr => _ptr;
 
   factory ShearYTimeline(int frameCount, int bezierCount, int boneIndex) {
-    final ptr = SpineBindings.bindings
+    final ptr = SpineBindings.bindings.spine_shear_y_timeline_create(frameCount, bezierCount, boneIndex);
-        .spine_shear_y_timeline_create(frameCount, bezierCount, boneIndex);
     return ShearYTimeline.fromPointer(ptr);
   }
 }

spine-flutter/lib/generated/skeleton.dart

@@ -60,8 +60,7 @@ class Skeleton implements Finalizable {
   Pointer get nativePtr => _ptr;
 
   factory Skeleton(SkeletonData skeletonData) {
-    final ptr = SpineBindings.bindings
+    final ptr = SpineBindings.bindings.spine_skeleton_create(skeletonData.nativePtr.cast());
-        .spine_skeleton_create(skeletonData.nativePtr.cast());
     return Skeleton.fromPointer(ptr);
   }
 
@@ -74,13 +73,11 @@ class Skeleton implements Finalizable {
   }
 
   void constrained(Posed object) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_skeleton_constrained(_ptr, object.nativePtr.cast());
-        .spine_skeleton_constrained(_ptr, object.nativePtr.cast());
   }
 
   void sortBone(Bone bone) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_skeleton_sort_bone(_ptr, bone.nativePtr.cast());
-        .spine_skeleton_sort_bone(_ptr, bone.nativePtr.cast());
   }
 
   static void sortReset(ArrayBone bones) {
@@ -120,8 +117,7 @@ class Skeleton implements Finalizable {
   }
 
   Bone findBone(String boneName) {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_skeleton_find_bone(_ptr, boneName.toNativeUtf8().cast<Char>());
-        .spine_skeleton_find_bone(_ptr, boneName.toNativeUtf8().cast<Char>());
     return Bone.fromPointer(result);
   }
 
@@ -131,8 +127,7 @@ class Skeleton implements Finalizable {
   }
 
   Slot findSlot(String slotName) {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_skeleton_find_slot(_ptr, slotName.toNativeUtf8().cast<Char>());
-        .spine_skeleton_find_slot(_ptr, slotName.toNativeUtf8().cast<Char>());
     return Slot.fromPointer(result);
   }
 
@@ -148,9 +143,7 @@ class Skeleton implements Finalizable {
 
   void setAttachment(String slotName, String attachmentName) {
     SpineBindings.bindings.spine_skeleton_set_attachment(
-        _ptr,
+        _ptr, slotName.toNativeUtf8().cast<Char>(), attachmentName.toNativeUtf8().cast<Char>());
-        slotName.toNativeUtf8().cast<Char>(),
-        attachmentName.toNativeUtf8().cast<Char>());
   }
 
   ArrayConstraint get constraints {
@@ -159,8 +152,7 @@ class Skeleton implements Finalizable {
   }
 
   ArrayPhysicsConstraint get physicsConstraints {
-    final result =
+    final result = SpineBindings.bindings.spine_skeleton_get_physics_constraints(_ptr);
-        SpineBindings.bindings.spine_skeleton_get_physics_constraints(_ptr);
     return ArrayPhysicsConstraint.fromPointer(result);
   }
 
@@ -271,35 +263,26 @@ class Skeleton implements Finalizable {
   }
 
   void updateWorldTransform(Physics physics) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_skeleton_update_world_transform_1(_ptr, physics.value);
-        .spine_skeleton_update_world_transform_1(_ptr, physics.value);
   }
 
   void updateWorldTransform2(Physics physics, BonePose parent) {
-    SpineBindings.bindings.spine_skeleton_update_world_transform_2(
+    SpineBindings.bindings.spine_skeleton_update_world_transform_2(_ptr, physics.value, parent.nativePtr.cast());
-        _ptr, physics.value, parent.nativePtr.cast());
   }
 
   void setSkin(String skinName) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_skeleton_set_skin_1(_ptr, skinName.toNativeUtf8().cast<Char>());
-        .spine_skeleton_set_skin_1(_ptr, skinName.toNativeUtf8().cast<Char>());
   }
 
   void setSkin2(Skin newSkin) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_skeleton_set_skin_2(_ptr, newSkin.nativePtr.cast());
-        .spine_skeleton_set_skin_2(_ptr, newSkin.nativePtr.cast());
   }
 
   Attachment getAttachment(String slotName, String attachmentName) {
     final result = SpineBindings.bindings.spine_skeleton_get_attachment_1(
-        _ptr,
+        _ptr, slotName.toNativeUtf8().cast<Char>(), attachmentName.toNativeUtf8().cast<Char>());
-        slotName.toNativeUtf8().cast<Char>(),
-        attachmentName.toNativeUtf8().cast<Char>());
     final rtti = SpineBindings.bindings.spine_attachment_get_rtti(result);
-    final className = SpineBindings.bindings
+    final className = SpineBindings.bindings.spine_rtti_get_class_name(rtti).cast<Utf8>().toDartString();
-        .spine_rtti_get_class_name(rtti)
-        .cast<Utf8>()
-        .toDartString();
     switch (className) {
       case 'spine_bounding_box_attachment':
         return BoundingBoxAttachment.fromPointer(result.cast());
@@ -314,19 +297,15 @@ class Skeleton implements Finalizable {
       case 'spine_region_attachment':
         return RegionAttachment.fromPointer(result.cast());
       default:
-        throw UnsupportedError(
+        throw UnsupportedError('Unknown concrete type: $className for abstract class Attachment');
-            'Unknown concrete type: $className for abstract class Attachment');
     }
   }
 
   Attachment getAttachment2(int slotIndex, String attachmentName) {
-    final result = SpineBindings.bindings.spine_skeleton_get_attachment_2(
+    final result = SpineBindings.bindings
-        _ptr, slotIndex, attachmentName.toNativeUtf8().cast<Char>());
+        .spine_skeleton_get_attachment_2(_ptr, slotIndex, attachmentName.toNativeUtf8().cast<Char>());
     final rtti = SpineBindings.bindings.spine_attachment_get_rtti(result);
-    final className = SpineBindings.bindings
+    final className = SpineBindings.bindings.spine_rtti_get_class_name(rtti).cast<Utf8>().toDartString();
-        .spine_rtti_get_class_name(rtti)
-        .cast<Utf8>()
-        .toDartString();
     switch (className) {
       case 'spine_bounding_box_attachment':
         return BoundingBoxAttachment.fromPointer(result.cast());
@@ -341,14 +320,12 @@ class Skeleton implements Finalizable {
       case 'spine_region_attachment':
         return RegionAttachment.fromPointer(result.cast());
       default:
-        throw UnsupportedError(
+        throw UnsupportedError('Unknown concrete type: $className for abstract class Attachment');
-            'Unknown concrete type: $className for abstract class Attachment');
     }
   }
 
   set setColor(Color value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_skeleton_set_color_1(_ptr, value.nativePtr.cast());
-        .spine_skeleton_set_color_1(_ptr, value.nativePtr.cast());
   }
 
   void setColor2(double r, double g, double b, double a) {

spine-flutter/lib/generated/skeleton_binary.dart

@@ -47,22 +47,18 @@ class SkeletonBinary implements Finalizable {
   Pointer get nativePtr => _ptr;
 
   factory SkeletonBinary(Atlas atlas) {
-    final ptr = SpineBindings.bindings
+    final ptr = SpineBindings.bindings.spine_skeleton_binary_create(atlas.nativePtr.cast());
-        .spine_skeleton_binary_create(atlas.nativePtr.cast());
     return SkeletonBinary.fromPointer(ptr);
   }
 
-  factory SkeletonBinary.variant2(
+  factory SkeletonBinary.variant2(AttachmentLoader attachmentLoader, bool ownsLoader) {
-      AttachmentLoader attachmentLoader, bool ownsLoader) {
+    final ptr = SpineBindings.bindings.spine_skeleton_binary_create2(attachmentLoader.nativePtr.cast(), ownsLoader);
-    final ptr = SpineBindings.bindings.spine_skeleton_binary_create2(
-        attachmentLoader.nativePtr.cast(), ownsLoader);
     return SkeletonBinary.fromPointer(ptr);
   }
 
   SkeletonData readSkeletonDataFile(String path) {
-    final result = SpineBindings.bindings
+    final result =
-        .spine_skeleton_binary_read_skeleton_data_file(
+        SpineBindings.bindings.spine_skeleton_binary_read_skeleton_data_file(_ptr, path.toNativeUtf8().cast<Char>());
-            _ptr, path.toNativeUtf8().cast<Char>());
     return SkeletonData.fromPointer(result);
   }
 

spine-flutter/lib/generated/skeleton_bounds.dart

@@ -52,50 +52,41 @@ class SkeletonBounds implements Finalizable {
   }
 
   void update(Skeleton skeleton, bool updateAabb) {
-    SpineBindings.bindings.spine_skeleton_bounds_update(
+    SpineBindings.bindings.spine_skeleton_bounds_update(_ptr, skeleton.nativePtr.cast(), updateAabb);
-        _ptr, skeleton.nativePtr.cast(), updateAabb);
   }
 
   bool aabbContainsPoint(double x, double y) {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_skeleton_bounds_aabb_contains_point(_ptr, x, y);
-        .spine_skeleton_bounds_aabb_contains_point(_ptr, x, y);
     return result;
   }
 
   bool aabbIntersectsSegment(double x1, double y1, double x2, double y2) {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_skeleton_bounds_aabb_intersects_segment(_ptr, x1, y1, x2, y2);
-        .spine_skeleton_bounds_aabb_intersects_segment(_ptr, x1, y1, x2, y2);
     return result;
   }
 
   bool aabbIntersectsSkeleton(SkeletonBounds bounds) {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_skeleton_bounds_aabb_intersects_skeleton(_ptr, bounds.nativePtr.cast());
-        .spine_skeleton_bounds_aabb_intersects_skeleton(
-            _ptr, bounds.nativePtr.cast());
     return result;
   }
 
   Polygon getPolygon(BoundingBoxAttachment attachment) {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_skeleton_bounds_get_polygon(_ptr, attachment.nativePtr.cast());
-        .spine_skeleton_bounds_get_polygon(_ptr, attachment.nativePtr.cast());
     return Polygon.fromPointer(result);
   }
 
   BoundingBoxAttachment getBoundingBox(Polygon polygon) {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_skeleton_bounds_get_bounding_box(_ptr, polygon.nativePtr.cast());
-        .spine_skeleton_bounds_get_bounding_box(_ptr, polygon.nativePtr.cast());
     return BoundingBoxAttachment.fromPointer(result);
   }
 
   ArrayPolygon get polygons {
-    final result =
+    final result = SpineBindings.bindings.spine_skeleton_bounds_get_polygons(_ptr);
-        SpineBindings.bindings.spine_skeleton_bounds_get_polygons(_ptr);
     return ArrayPolygon.fromPointer(result);
   }
 
   ArrayBoundingBoxAttachment get boundingBoxes {
-    final result =
+    final result = SpineBindings.bindings.spine_skeleton_bounds_get_bounding_boxes(_ptr);
-        SpineBindings.bindings.spine_skeleton_bounds_get_bounding_boxes(_ptr);
     return ArrayBoundingBoxAttachment.fromPointer(result);
   }
 
@@ -125,36 +116,28 @@ class SkeletonBounds implements Finalizable {
   }
 
   double get height {
-    final result =
+    final result = SpineBindings.bindings.spine_skeleton_bounds_get_height(_ptr);
-        SpineBindings.bindings.spine_skeleton_bounds_get_height(_ptr);
     return result;
   }
 
   bool containsPoint(Polygon polygon, double x, double y) {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_skeleton_bounds_contains_point_1(_ptr, polygon.nativePtr.cast(), x, y);
-        .spine_skeleton_bounds_contains_point_1(
-            _ptr, polygon.nativePtr.cast(), x, y);
     return result;
   }
 
   BoundingBoxAttachment containsPoint2(double x, double y) {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_skeleton_bounds_contains_point_2(_ptr, x, y);
-        .spine_skeleton_bounds_contains_point_2(_ptr, x, y);
     return BoundingBoxAttachment.fromPointer(result);
   }
 
-  BoundingBoxAttachment intersectsSegment(
+  BoundingBoxAttachment intersectsSegment(double x1, double y1, double x2, double y2) {
-      double x1, double y1, double x2, double y2) {
+    final result = SpineBindings.bindings.spine_skeleton_bounds_intersects_segment_1(_ptr, x1, y1, x2, y2);
-    final result = SpineBindings.bindings
-        .spine_skeleton_bounds_intersects_segment_1(_ptr, x1, y1, x2, y2);
     return BoundingBoxAttachment.fromPointer(result);
   }
 
-  bool intersectsSegment2(
+  bool intersectsSegment2(Polygon polygon, double x1, double y1, double x2, double y2) {
-      Polygon polygon, double x1, double y1, double x2, double y2) {
     final result = SpineBindings.bindings
-        .spine_skeleton_bounds_intersects_segment_2(
+        .spine_skeleton_bounds_intersects_segment_2(_ptr, polygon.nativePtr.cast(), x1, y1, x2, y2);
-            _ptr, polygon.nativePtr.cast(), x1, y1, x2, y2);
     return result;
   }
 }

spine-flutter/lib/generated/skeleton_clipping.dart

@@ -53,55 +53,41 @@ class SkeletonClipping implements Finalizable {
 
   int clipStart(Skeleton skeleton, Slot slot, ClippingAttachment clip) {
     final result = SpineBindings.bindings.spine_skeleton_clipping_clip_start(
-        _ptr,
+        _ptr, skeleton.nativePtr.cast(), slot.nativePtr.cast(), clip.nativePtr.cast());
-        skeleton.nativePtr.cast(),
-        slot.nativePtr.cast(),
-        clip.nativePtr.cast());
     return result;
   }
 
   bool get isClipping {
-    final result =
+    final result = SpineBindings.bindings.spine_skeleton_clipping_is_clipping(_ptr);
-        SpineBindings.bindings.spine_skeleton_clipping_is_clipping(_ptr);
     return result;
   }
 
   ArrayFloat get clippedVertices {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_skeleton_clipping_get_clipped_vertices(_ptr);
-        .spine_skeleton_clipping_get_clipped_vertices(_ptr);
     return ArrayFloat.fromPointer(result);
   }
 
   ArrayUnsignedShort get clippedTriangles {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_skeleton_clipping_get_clipped_triangles(_ptr);
-        .spine_skeleton_clipping_get_clipped_triangles(_ptr);
     return ArrayUnsignedShort.fromPointer(result);
   }
 
   ArrayFloat get clippedUVs {
-    final result =
+    final result = SpineBindings.bindings.spine_skeleton_clipping_get_clipped_u_vs(_ptr);
-        SpineBindings.bindings.spine_skeleton_clipping_get_clipped_u_vs(_ptr);
     return ArrayFloat.fromPointer(result);
   }
 
   void clipEnd(Slot slot) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_skeleton_clipping_clip_end_1(_ptr, slot.nativePtr.cast());
-        .spine_skeleton_clipping_clip_end_1(_ptr, slot.nativePtr.cast());
   }
 
   void clipEnd2() {
     SpineBindings.bindings.spine_skeleton_clipping_clip_end_2(_ptr);
   }
 
-  bool clipTriangles(ArrayFloat vertices, ArrayUnsignedShort triangles,
+  bool clipTriangles(ArrayFloat vertices, ArrayUnsignedShort triangles, ArrayFloat uvs, int stride) {
-      ArrayFloat uvs, int stride) {
+    final result = SpineBindings.bindings.spine_skeleton_clipping_clip_triangles_3(
-    final result = SpineBindings.bindings
+        _ptr, vertices.nativePtr.cast(), triangles.nativePtr.cast(), uvs.nativePtr.cast(), stride);
-        .spine_skeleton_clipping_clip_triangles_3(
-            _ptr,
-            vertices.nativePtr.cast(),
-            triangles.nativePtr.cast(),
-            uvs.nativePtr.cast(),
-            stride);
     return result;
   }
 }

spine-flutter/lib/generated/skeleton_data.dart

@@ -55,32 +55,29 @@ class SkeletonData implements Finalizable {
   }
 
   BoneData findBone(String boneName) {
-    final result = SpineBindings.bindings.spine_skeleton_data_find_bone(
+    final result = SpineBindings.bindings.spine_skeleton_data_find_bone(_ptr, boneName.toNativeUtf8().cast<Char>());
-        _ptr, boneName.toNativeUtf8().cast<Char>());
     return BoneData.fromPointer(result);
   }
 
   SlotData findSlot(String slotName) {
-    final result = SpineBindings.bindings.spine_skeleton_data_find_slot(
+    final result = SpineBindings.bindings.spine_skeleton_data_find_slot(_ptr, slotName.toNativeUtf8().cast<Char>());
-        _ptr, slotName.toNativeUtf8().cast<Char>());
     return SlotData.fromPointer(result);
   }
 
   Skin findSkin(String skinName) {
-    final result = SpineBindings.bindings.spine_skeleton_data_find_skin(
+    final result = SpineBindings.bindings.spine_skeleton_data_find_skin(_ptr, skinName.toNativeUtf8().cast<Char>());
-        _ptr, skinName.toNativeUtf8().cast<Char>());
     return Skin.fromPointer(result);
   }
 
   EventData findEvent(String eventDataName) {
-    final result = SpineBindings.bindings.spine_skeleton_data_find_event(
+    final result =
-        _ptr, eventDataName.toNativeUtf8().cast<Char>());
+        SpineBindings.bindings.spine_skeleton_data_find_event(_ptr, eventDataName.toNativeUtf8().cast<Char>());
     return EventData.fromPointer(result);
   }
 
   Animation findAnimation(String animationName) {
-    final result = SpineBindings.bindings.spine_skeleton_data_find_animation(
+    final result =
-        _ptr, animationName.toNativeUtf8().cast<Char>());
+        SpineBindings.bindings.spine_skeleton_data_find_animation(_ptr, animationName.toNativeUtf8().cast<Char>());
     return Animation.fromPointer(result);
   }
 
@@ -90,8 +87,7 @@ class SkeletonData implements Finalizable {
   }
 
   set name(String value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_skeleton_data_set_name(_ptr, value.toNativeUtf8().cast<Char>());
-        .spine_skeleton_data_set_name(_ptr, value.toNativeUtf8().cast<Char>());
   }
 
   ArrayBoneData get bones {
@@ -110,14 +106,12 @@ class SkeletonData implements Finalizable {
   }
 
   Skin get defaultSkin {
-    final result =
+    final result = SpineBindings.bindings.spine_skeleton_data_get_default_skin(_ptr);
-        SpineBindings.bindings.spine_skeleton_data_get_default_skin(_ptr);
     return Skin.fromPointer(result);
   }
 
   set defaultSkin(Skin value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_skeleton_data_set_default_skin(_ptr, value.nativePtr.cast());
-        .spine_skeleton_data_set_default_skin(_ptr, value.nativePtr.cast());
   }
 
   ArrayEventData get events {
@@ -126,14 +120,12 @@ class SkeletonData implements Finalizable {
   }
 
   ArrayAnimation get animations {
-    final result =
+    final result = SpineBindings.bindings.spine_skeleton_data_get_animations(_ptr);
-        SpineBindings.bindings.spine_skeleton_data_get_animations(_ptr);
     return ArrayAnimation.fromPointer(result);
   }
 
   ArrayConstraintData get constraints {
-    final result =
+    final result = SpineBindings.bindings.spine_skeleton_data_get_constraints(_ptr);
-        SpineBindings.bindings.spine_skeleton_data_get_constraints(_ptr);
     return ArrayConstraintData.fromPointer(result);
   }
 
@@ -174,8 +166,7 @@ class SkeletonData implements Finalizable {
   }
 
   double get referenceScale {
-    final result =
+    final result = SpineBindings.bindings.spine_skeleton_data_get_reference_scale(_ptr);
-        SpineBindings.bindings.spine_skeleton_data_get_reference_scale(_ptr);
     return result;
   }
 
@@ -189,8 +180,7 @@ class SkeletonData implements Finalizable {
   }
 
   set version(String value) {
-    SpineBindings.bindings.spine_skeleton_data_set_version(
+    SpineBindings.bindings.spine_skeleton_data_set_version(_ptr, value.toNativeUtf8().cast<Char>());
-        _ptr, value.toNativeUtf8().cast<Char>());
   }
 
   String get hash {
@@ -199,30 +189,25 @@ class SkeletonData implements Finalizable {
   }
 
   set hash(String value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_skeleton_data_set_hash(_ptr, value.toNativeUtf8().cast<Char>());
-        .spine_skeleton_data_set_hash(_ptr, value.toNativeUtf8().cast<Char>());
   }
 
   String get imagesPath {
-    final result =
+    final result = SpineBindings.bindings.spine_skeleton_data_get_images_path(_ptr);
-        SpineBindings.bindings.spine_skeleton_data_get_images_path(_ptr);
     return result.cast<Utf8>().toDartString();
   }
 
   set imagesPath(String value) {
-    SpineBindings.bindings.spine_skeleton_data_set_images_path(
+    SpineBindings.bindings.spine_skeleton_data_set_images_path(_ptr, value.toNativeUtf8().cast<Char>());
-        _ptr, value.toNativeUtf8().cast<Char>());
   }
 
   String get audioPath {
-    final result =
+    final result = SpineBindings.bindings.spine_skeleton_data_get_audio_path(_ptr);
-        SpineBindings.bindings.spine_skeleton_data_get_audio_path(_ptr);
     return result.cast<Utf8>().toDartString();
   }
 
   set audioPath(String value) {
-    SpineBindings.bindings.spine_skeleton_data_set_audio_path(
+    SpineBindings.bindings.spine_skeleton_data_set_audio_path(_ptr, value.toNativeUtf8().cast<Char>());
-        _ptr, value.toNativeUtf8().cast<Char>());
   }
 
   double get fps {

spine-flutter/lib/generated/skeleton_json.dart

@@ -47,29 +47,24 @@ class SkeletonJson implements Finalizable {
   Pointer get nativePtr => _ptr;
 
   factory SkeletonJson(Atlas atlas) {
-    final ptr = SpineBindings.bindings
+    final ptr = SpineBindings.bindings.spine_skeleton_json_create(atlas.nativePtr.cast());
-        .spine_skeleton_json_create(atlas.nativePtr.cast());
     return SkeletonJson.fromPointer(ptr);
   }
 
-  factory SkeletonJson.variant2(
+  factory SkeletonJson.variant2(AttachmentLoader attachmentLoader, bool ownsLoader) {
-      AttachmentLoader attachmentLoader, bool ownsLoader) {
+    final ptr = SpineBindings.bindings.spine_skeleton_json_create2(attachmentLoader.nativePtr.cast(), ownsLoader);
-    final ptr = SpineBindings.bindings.spine_skeleton_json_create2(
-        attachmentLoader.nativePtr.cast(), ownsLoader);
     return SkeletonJson.fromPointer(ptr);
   }
 
   SkeletonData readSkeletonDataFile(String path) {
-    final result = SpineBindings.bindings
+    final result =
-        .spine_skeleton_json_read_skeleton_data_file(
+        SpineBindings.bindings.spine_skeleton_json_read_skeleton_data_file(_ptr, path.toNativeUtf8().cast<Char>());
-            _ptr, path.toNativeUtf8().cast<Char>());
     return SkeletonData.fromPointer(result);
   }
 
   SkeletonData readSkeletonData(String json) {
-    final result = SpineBindings.bindings
+    final result =
-        .spine_skeleton_json_read_skeleton_data(
+        SpineBindings.bindings.spine_skeleton_json_read_skeleton_data(_ptr, json.toNativeUtf8().cast<Char>());
-            _ptr, json.toNativeUtf8().cast<Char>());
     return SkeletonData.fromPointer(result);
   }
 

spine-flutter/lib/generated/skeleton_renderer.dart

@@ -50,8 +50,7 @@ class SkeletonRenderer implements Finalizable {
   }
 
   RenderCommand render(Skeleton skeleton) {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_skeleton_renderer_render(_ptr, skeleton.nativePtr.cast());
-        .spine_skeleton_renderer_render(_ptr, skeleton.nativePtr.cast());
     return RenderCommand.fromPointer(result);
   }
 }

spine-flutter/lib/generated/skin.dart

@@ -53,24 +53,19 @@ class Skin implements Finalizable {
   Pointer get nativePtr => _ptr;
 
   factory Skin(String name) {
-    final ptr = SpineBindings.bindings
+    final ptr = SpineBindings.bindings.spine_skin_create(name.toNativeUtf8().cast<Char>());
-        .spine_skin_create(name.toNativeUtf8().cast<Char>());
     return Skin.fromPointer(ptr);
   }
 
   void setAttachment(int slotIndex, String name, Attachment attachment) {
-    SpineBindings.bindings.spine_skin_set_attachment(_ptr, slotIndex,
+    SpineBindings.bindings
-        name.toNativeUtf8().cast<Char>(), attachment.nativePtr.cast());
+        .spine_skin_set_attachment(_ptr, slotIndex, name.toNativeUtf8().cast<Char>(), attachment.nativePtr.cast());
   }
 
   Attachment getAttachment(int slotIndex, String name) {
-    final result = SpineBindings.bindings.spine_skin_get_attachment(
+    final result = SpineBindings.bindings.spine_skin_get_attachment(_ptr, slotIndex, name.toNativeUtf8().cast<Char>());
-        _ptr, slotIndex, name.toNativeUtf8().cast<Char>());
     final rtti = SpineBindings.bindings.spine_attachment_get_rtti(result);
-    final className = SpineBindings.bindings
+    final className = SpineBindings.bindings.spine_rtti_get_class_name(rtti).cast<Utf8>().toDartString();
-        .spine_rtti_get_class_name(rtti)
-        .cast<Utf8>()
-        .toDartString();
     switch (className) {
       case 'spine_bounding_box_attachment':
         return BoundingBoxAttachment.fromPointer(result.cast());
@@ -85,19 +80,16 @@ class Skin implements Finalizable {
       case 'spine_region_attachment':
         return RegionAttachment.fromPointer(result.cast());
       default:
-        throw UnsupportedError(
+        throw UnsupportedError('Unknown concrete type: $className for abstract class Attachment');
-            'Unknown concrete type: $className for abstract class Attachment');
     }
   }
 
   void removeAttachment(int slotIndex, String name) {
-    SpineBindings.bindings.spine_skin_remove_attachment(
+    SpineBindings.bindings.spine_skin_remove_attachment(_ptr, slotIndex, name.toNativeUtf8().cast<Char>());
-        _ptr, slotIndex, name.toNativeUtf8().cast<Char>());
   }
 
   void findAttachmentsForSlot(int slotIndex, ArrayAttachment attachments) {
-    SpineBindings.bindings.spine_skin_find_attachments_for_slot(
+    SpineBindings.bindings.spine_skin_find_attachments_for_slot(_ptr, slotIndex, attachments.nativePtr.cast());
-        _ptr, slotIndex, attachments.nativePtr.cast());
   }
 
   String get name {

spine-flutter/lib/generated/slider.dart

@@ -53,8 +53,7 @@ class Slider extends PosedActive implements Posed, Constraint {
   Pointer get nativePtr => _ptr;
 
   factory Slider(SliderData data, Skeleton skeleton) {
-    final ptr = SpineBindings.bindings
+    final ptr = SpineBindings.bindings.spine_slider_create(data.nativePtr.cast(), skeleton.nativePtr.cast());
-        .spine_slider_create(data.nativePtr.cast(), skeleton.nativePtr.cast());
     return Slider.fromPointer(ptr);
   }
 
@@ -65,15 +64,13 @@ class Slider extends PosedActive implements Posed, Constraint {
   }
 
   Slider copy(Skeleton skeleton) {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_slider_copy(_ptr, skeleton.nativePtr.cast());
-        .spine_slider_copy(_ptr, skeleton.nativePtr.cast());
     return Slider.fromPointer(result);
   }
 
   @override
   void update(Skeleton skeleton, Physics physics) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_slider_update(_ptr, skeleton.nativePtr.cast(), physics.value);
-        .spine_slider_update(_ptr, skeleton.nativePtr.cast(), physics.value);
   }
 
   @override
@@ -124,8 +121,7 @@ class Slider extends PosedActive implements Posed, Constraint {
 
   @override
   bool get isPoseEqualToApplied {
-    final result =
+    final result = SpineBindings.bindings.spine_slider_is_pose_equal_to_applied(_ptr);
-        SpineBindings.bindings.spine_slider_is_pose_equal_to_applied(_ptr);
     return result;
   }
 

spine-flutter/lib/generated/slider_data.dart

@@ -65,8 +65,7 @@ class SliderData extends PosedData implements ConstraintData {
   Pointer get nativePtr => _ptr;
 
   factory SliderData(String name) {
-    final ptr = SpineBindings.bindings
+    final ptr = SpineBindings.bindings.spine_slider_data_create(name.toNativeUtf8().cast<Char>());
-        .spine_slider_data_create(name.toNativeUtf8().cast<Char>());
     return SliderData.fromPointer(ptr);
   }
 
@@ -78,13 +77,9 @@ class SliderData extends PosedData implements ConstraintData {
 
   @override
   Constraint createMethod(Skeleton skeleton) {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_slider_data_create_method(_ptr, skeleton.nativePtr.cast());
-        .spine_slider_data_create_method(_ptr, skeleton.nativePtr.cast());
     final rtti = SpineBindings.bindings.spine_constraint_get_rtti(result);
-    final className = SpineBindings.bindings
+    final className = SpineBindings.bindings.spine_rtti_get_class_name(rtti).cast<Utf8>().toDartString();
-        .spine_rtti_get_class_name(rtti)
-        .cast<Utf8>()
-        .toDartString();
     switch (className) {
       case 'spine_ik_constraint':
         return IkConstraint.fromPointer(result.cast());
@@ -97,8 +92,7 @@ class SliderData extends PosedData implements ConstraintData {
       case 'spine_transform_constraint':
         return TransformConstraint.fromPointer(result.cast());
       default:
-        throw UnsupportedError(
+        throw UnsupportedError('Unknown concrete type: $className for abstract class Constraint');
-            'Unknown concrete type: $className for abstract class Constraint');
     }
   }
 
@@ -108,8 +102,7 @@ class SliderData extends PosedData implements ConstraintData {
   }
 
   set animation(Animation value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_slider_data_set_animation(_ptr, value.nativePtr.cast());
-        .spine_slider_data_set_animation(_ptr, value.nativePtr.cast());
   }
 
   bool get additive {
@@ -136,17 +129,13 @@ class SliderData extends PosedData implements ConstraintData {
   }
 
   set bone(BoneData value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_slider_data_set_bone(_ptr, value.nativePtr.cast());
-        .spine_slider_data_set_bone(_ptr, value.nativePtr.cast());
   }
 
   FromProperty get property {
     final result = SpineBindings.bindings.spine_slider_data_get_property(_ptr);
     final rtti = SpineBindings.bindings.spine_from_property_get_rtti(result);
-    final className = SpineBindings.bindings
+    final className = SpineBindings.bindings.spine_rtti_get_class_name(rtti).cast<Utf8>().toDartString();
-        .spine_rtti_get_class_name(rtti)
-        .cast<Utf8>()
-        .toDartString();
     switch (className) {
       case 'spine_from_rotate':
         return FromRotate.fromPointer(result.cast());
@@ -161,14 +150,12 @@ class SliderData extends PosedData implements ConstraintData {
       case 'spine_from_y':
         return FromY.fromPointer(result.cast());
       default:
-        throw UnsupportedError(
+        throw UnsupportedError('Unknown concrete type: $className for abstract class FromProperty');
-            'Unknown concrete type: $className for abstract class FromProperty');
     }
   }
 
   set property(FromProperty value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_slider_data_set_property(_ptr, value.nativePtr.cast());
-        .spine_slider_data_set_property(_ptr, value.nativePtr.cast());
   }
 
   double get scale {
@@ -199,8 +186,7 @@ class SliderData extends PosedData implements ConstraintData {
   }
 
   SliderPose get setupPose {
-    final result =
+    final result = SpineBindings.bindings.spine_slider_data_get_setup_pose(_ptr);
-        SpineBindings.bindings.spine_slider_data_get_setup_pose(_ptr);
     return SliderPose.fromPointer(result);
   }
 

spine-flutter/lib/generated/slider_mix_timeline.dart

@@ -45,8 +45,7 @@ class SliderMixTimeline extends ConstraintTimeline1 {
   Pointer get nativePtr => _ptr;
 
   factory SliderMixTimeline(int frameCount, int bezierCount, int sliderIndex) {
-    final ptr = SpineBindings.bindings
+    final ptr = SpineBindings.bindings.spine_slider_mix_timeline_create(frameCount, bezierCount, sliderIndex);
-        .spine_slider_mix_timeline_create(frameCount, bezierCount, sliderIndex);
     return SliderMixTimeline.fromPointer(ptr);
   }
 }

spine-flutter/lib/generated/slider_timeline.dart

@@ -45,8 +45,7 @@ class SliderTimeline extends ConstraintTimeline1 {
   Pointer get nativePtr => _ptr;
 
   factory SliderTimeline(int frameCount, int bezierCount, int sliderIndex) {
-    final ptr = SpineBindings.bindings
+    final ptr = SpineBindings.bindings.spine_slider_timeline_create(frameCount, bezierCount, sliderIndex);
-        .spine_slider_timeline_create(frameCount, bezierCount, sliderIndex);
     return SliderTimeline.fromPointer(ptr);
   }
 }

spine-flutter/lib/generated/slot.dart

@@ -49,8 +49,7 @@ class Slot implements Finalizable, Posed {
   Pointer get nativePtr => _ptr;
 
   factory Slot(SlotData data, Skeleton skeleton) {
-    final ptr = SpineBindings.bindings
+    final ptr = SpineBindings.bindings.spine_slot_create(data.nativePtr.cast(), skeleton.nativePtr.cast());
-        .spine_slot_create(data.nativePtr.cast(), skeleton.nativePtr.cast());
     return Slot.fromPointer(ptr);
   }
 
@@ -90,8 +89,7 @@ class Slot implements Finalizable, Posed {
 
   @override
   bool get isPoseEqualToApplied {
-    final result =
+    final result = SpineBindings.bindings.spine_slot_is_pose_equal_to_applied(_ptr);
-        SpineBindings.bindings.spine_slot_is_pose_equal_to_applied(_ptr);
     return result;
   }
 }

spine-flutter/lib/generated/slot_curve_timeline.dart

@@ -47,14 +47,12 @@ abstract class SlotCurveTimeline extends CurveTimeline implements SlotTimeline {
 
   @override
   int get slotIndex {
-    final result =
+    final result = SpineBindings.bindings.spine_slot_curve_timeline_get_slot_index(_ptr);
-        SpineBindings.bindings.spine_slot_curve_timeline_get_slot_index(_ptr);
     return result;
   }
 
   @override
   set slotIndex(int value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_slot_curve_timeline_set_slot_index(_ptr, value);
-        .spine_slot_curve_timeline_set_slot_index(_ptr, value);
   }
 }

spine-flutter/lib/generated/slot_data.dart

@@ -49,8 +49,8 @@ class SlotData extends PosedData {
   Pointer get nativePtr => _ptr;
 
   factory SlotData(int index, String name, BoneData boneData) {
-    final ptr = SpineBindings.bindings.spine_slot_data_create(
+    final ptr = SpineBindings.bindings
-        index, name.toNativeUtf8().cast<Char>(), boneData.nativePtr.cast());
+        .spine_slot_data_create(index, name.toNativeUtf8().cast<Char>(), boneData.nativePtr.cast());
     return SlotData.fromPointer(ptr);
   }
 
@@ -65,13 +65,11 @@ class SlotData extends PosedData {
   }
 
   set attachmentName(String value) {
-    SpineBindings.bindings.spine_slot_data_set_attachment_name(
+    SpineBindings.bindings.spine_slot_data_set_attachment_name(_ptr, value.toNativeUtf8().cast<Char>());
-        _ptr, value.toNativeUtf8().cast<Char>());
   }
 
   String get attachmentName {
-    final result =
+    final result = SpineBindings.bindings.spine_slot_data_get_attachment_name(_ptr);
-        SpineBindings.bindings.spine_slot_data_get_attachment_name(_ptr);
     return result.cast<Utf8>().toDartString();
   }
 

spine-flutter/lib/generated/slot_pose.dart

@@ -83,10 +83,7 @@ class SlotPose implements Finalizable {
   Attachment get attachment {
     final result = SpineBindings.bindings.spine_slot_pose_get_attachment(_ptr);
     final rtti = SpineBindings.bindings.spine_attachment_get_rtti(result);
-    final className = SpineBindings.bindings
+    final className = SpineBindings.bindings.spine_rtti_get_class_name(rtti).cast<Utf8>().toDartString();
-        .spine_rtti_get_class_name(rtti)
-        .cast<Utf8>()
-        .toDartString();
     switch (className) {
       case 'spine_bounding_box_attachment':
         return BoundingBoxAttachment.fromPointer(result.cast());
@@ -101,19 +98,16 @@ class SlotPose implements Finalizable {
       case 'spine_region_attachment':
         return RegionAttachment.fromPointer(result.cast());
       default:
-        throw UnsupportedError(
+        throw UnsupportedError('Unknown concrete type: $className for abstract class Attachment');
-            'Unknown concrete type: $className for abstract class Attachment');
     }
   }
 
   set attachment(Attachment value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_slot_pose_set_attachment(_ptr, value.nativePtr.cast());
-        .spine_slot_pose_set_attachment(_ptr, value.nativePtr.cast());
   }
 
   int get sequenceIndex {
-    final result =
+    final result = SpineBindings.bindings.spine_slot_pose_get_sequence_index(_ptr);
-        SpineBindings.bindings.spine_slot_pose_get_sequence_index(_ptr);
     return result;
   }
 

spine-flutter/lib/generated/texture_region.dart

@@ -90,8 +90,7 @@ class TextureRegion implements Finalizable {
   }
 
   int get regionWidth {
-    final result =
+    final result = SpineBindings.bindings.spine_texture_region_get_region_width(_ptr);
-        SpineBindings.bindings.spine_texture_region_get_region_width(_ptr);
     return result;
   }
 
@@ -100,8 +99,7 @@ class TextureRegion implements Finalizable {
   }
 
   int get regionHeight {
-    final result =
+    final result = SpineBindings.bindings.spine_texture_region_get_region_height(_ptr);
-        SpineBindings.bindings.spine_texture_region_get_region_height(_ptr);
     return result;
   }
 

spine-flutter/lib/generated/timeline.dart

@@ -52,30 +52,14 @@ abstract class Timeline implements Finalizable {
     return Rtti.fromPointer(result);
   }
 
-  void apply(
+  void apply(Skeleton skeleton, double lastTime, double time, ArrayEvent pEvents, double alpha, MixBlend blend,
-      Skeleton skeleton,
+      MixDirection direction, bool appliedPose) {
-      double lastTime,
+    SpineBindings.bindings.spine_timeline_apply(_ptr, skeleton.nativePtr.cast(), lastTime, time,
-      double time,
+        pEvents.nativePtr.cast(), alpha, blend.value, direction.value, appliedPose);
-      ArrayEvent pEvents,
-      double alpha,
-      MixBlend blend,
-      MixDirection direction,
-      bool appliedPose) {
-    SpineBindings.bindings.spine_timeline_apply(
-        _ptr,
-        skeleton.nativePtr.cast(),
-        lastTime,
-        time,
-        pEvents.nativePtr.cast(),
-        alpha,
-        blend.value,
-        direction.value,
-        appliedPose);
   }
 
   int get frameEntries {
-    final result =
+    final result = SpineBindings.bindings.spine_timeline_get_frame_entries(_ptr);
-        SpineBindings.bindings.spine_timeline_get_frame_entries(_ptr);
     return result;
   }
 

spine-flutter/lib/generated/to_property.dart

@@ -52,21 +52,13 @@ abstract class ToProperty implements Finalizable {
   }
 
   double mix(TransformConstraintPose pose) {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_to_property_mix(_ptr, pose.nativePtr.cast());
-        .spine_to_property_mix(_ptr, pose.nativePtr.cast());
     return result;
   }
 
-  void apply(Skeleton skeleton, TransformConstraintPose pose, BonePose bone,
+  void apply(Skeleton skeleton, TransformConstraintPose pose, BonePose bone, double value, bool local, bool additive) {
-      double value, bool local, bool additive) {
     SpineBindings.bindings.spine_to_property_apply(
-        _ptr,
+        _ptr, skeleton.nativePtr.cast(), pose.nativePtr.cast(), bone.nativePtr.cast(), value, local, additive);
-        skeleton.nativePtr.cast(),
-        pose.nativePtr.cast(),
-        bone.nativePtr.cast(),
-        value,
-        local,
-        additive);
   }
 
   static Rtti rttiStatic() {

spine-flutter/lib/generated/track_entry.dart

@@ -50,8 +50,7 @@ class TrackEntry implements Finalizable {
   }
 
   int get trackIndex {
-    final result =
+    final result = SpineBindings.bindings.spine_track_entry_get_track_index(_ptr);
-        SpineBindings.bindings.spine_track_entry_get_track_index(_ptr);
     return result;
   }
 
@@ -61,8 +60,7 @@ class TrackEntry implements Finalizable {
   }
 
   set animation(Animation value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_track_entry_set_animation(_ptr, value.nativePtr.cast());
-        .spine_track_entry_set_animation(_ptr, value.nativePtr.cast());
   }
 
   TrackEntry get previous {
@@ -80,8 +78,7 @@ class TrackEntry implements Finalizable {
   }
 
   bool get holdPrevious {
-    final result =
+    final result = SpineBindings.bindings.spine_track_entry_get_hold_previous(_ptr);
-        SpineBindings.bindings.spine_track_entry_get_hold_previous(_ptr);
     return result;
   }
 
@@ -99,8 +96,7 @@ class TrackEntry implements Finalizable {
   }
 
   bool get shortestRotation {
-    final result =
+    final result = SpineBindings.bindings.spine_track_entry_get_shortest_rotation(_ptr);
-        SpineBindings.bindings.spine_track_entry_get_shortest_rotation(_ptr);
     return result;
   }
 
@@ -118,8 +114,7 @@ class TrackEntry implements Finalizable {
   }
 
   double get trackTime {
-    final result =
+    final result = SpineBindings.bindings.spine_track_entry_get_track_time(_ptr);
-        SpineBindings.bindings.spine_track_entry_get_track_time(_ptr);
     return result;
   }
 
@@ -137,8 +132,7 @@ class TrackEntry implements Finalizable {
   }
 
   double get animationStart {
-    final result =
+    final result = SpineBindings.bindings.spine_track_entry_get_animation_start(_ptr);
-        SpineBindings.bindings.spine_track_entry_get_animation_start(_ptr);
     return result;
   }
 
@@ -147,8 +141,7 @@ class TrackEntry implements Finalizable {
   }
 
   double get animationEnd {
-    final result =
+    final result = SpineBindings.bindings.spine_track_entry_get_animation_end(_ptr);
-        SpineBindings.bindings.spine_track_entry_get_animation_end(_ptr);
     return result;
   }
 
@@ -157,8 +150,7 @@ class TrackEntry implements Finalizable {
   }
 
   double get animationLast {
-    final result =
+    final result = SpineBindings.bindings.spine_track_entry_get_animation_last(_ptr);
-        SpineBindings.bindings.spine_track_entry_get_animation_last(_ptr);
     return result;
   }
 
@@ -167,14 +159,12 @@ class TrackEntry implements Finalizable {
   }
 
   double get animationTime {
-    final result =
+    final result = SpineBindings.bindings.spine_track_entry_get_animation_time(_ptr);
-        SpineBindings.bindings.spine_track_entry_get_animation_time(_ptr);
     return result;
   }
 
   double get timeScale {
-    final result =
+    final result = SpineBindings.bindings.spine_track_entry_get_time_scale(_ptr);
-        SpineBindings.bindings.spine_track_entry_get_time_scale(_ptr);
     return result;
   }
 
@@ -192,8 +182,7 @@ class TrackEntry implements Finalizable {
   }
 
   double get eventThreshold {
-    final result =
+    final result = SpineBindings.bindings.spine_track_entry_get_event_threshold(_ptr);
-        SpineBindings.bindings.spine_track_entry_get_event_threshold(_ptr);
     return result;
   }
 
@@ -202,36 +191,30 @@ class TrackEntry implements Finalizable {
   }
 
   double get mixAttachmentThreshold {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_track_entry_get_mix_attachment_threshold(_ptr);
-        .spine_track_entry_get_mix_attachment_threshold(_ptr);
     return result;
   }
 
   set mixAttachmentThreshold(double value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_track_entry_set_mix_attachment_threshold(_ptr, value);
-        .spine_track_entry_set_mix_attachment_threshold(_ptr, value);
   }
 
   double get alphaAttachmentThreshold {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_track_entry_get_alpha_attachment_threshold(_ptr);
-        .spine_track_entry_get_alpha_attachment_threshold(_ptr);
     return result;
   }
 
   set alphaAttachmentThreshold(double value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_track_entry_set_alpha_attachment_threshold(_ptr, value);
-        .spine_track_entry_set_alpha_attachment_threshold(_ptr, value);
   }
 
   double get mixDrawOrderThreshold {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_track_entry_get_mix_draw_order_threshold(_ptr);
-        .spine_track_entry_get_mix_draw_order_threshold(_ptr);
     return result;
   }
 
   set mixDrawOrderThreshold(double value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_track_entry_set_mix_draw_order_threshold(_ptr, value);
-        .spine_track_entry_set_mix_draw_order_threshold(_ptr, value);
   }
 
   TrackEntry get next {
@@ -254,8 +237,7 @@ class TrackEntry implements Finalizable {
   }
 
   double get mixDuration {
-    final result =
+    final result = SpineBindings.bindings.spine_track_entry_get_mix_duration(_ptr);
-        SpineBindings.bindings.spine_track_entry_get_mix_duration(_ptr);
     return result;
   }
 
@@ -269,8 +251,7 @@ class TrackEntry implements Finalizable {
   }
 
   TrackEntry get mixingFrom {
-    final result =
+    final result = SpineBindings.bindings.spine_track_entry_get_mixing_from(_ptr);
-        SpineBindings.bindings.spine_track_entry_get_mixing_from(_ptr);
     return TrackEntry.fromPointer(result);
   }
 
@@ -284,14 +265,12 @@ class TrackEntry implements Finalizable {
   }
 
   double get trackComplete {
-    final result =
+    final result = SpineBindings.bindings.spine_track_entry_get_track_complete(_ptr);
-        SpineBindings.bindings.spine_track_entry_get_track_complete(_ptr);
     return result;
   }
 
   bool get isEmptyAnimation {
-    final result =
+    final result = SpineBindings.bindings.spine_track_entry_is_empty_animation(_ptr);
-        SpineBindings.bindings.spine_track_entry_is_empty_animation(_ptr);
     return result;
   }
 
@@ -306,8 +285,7 @@ class TrackEntry implements Finalizable {
   }
 
   Pointer<Void> get rendererObject {
-    final result =
+    final result = SpineBindings.bindings.spine_track_entry_get_renderer_object(_ptr);
-        SpineBindings.bindings.spine_track_entry_get_renderer_object(_ptr);
     return result;
   }
 
@@ -316,7 +294,6 @@ class TrackEntry implements Finalizable {
   }
 
   void setMixDuration2(double mixDuration, double delay) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_track_entry_set_mix_duration_2(_ptr, mixDuration, delay);
-        .spine_track_entry_set_mix_duration_2(_ptr, mixDuration, delay);
   }
 }

spine-flutter/lib/generated/transform_constraint.dart

@@ -54,76 +54,65 @@ class TransformConstraint extends PosedActive implements Posed, Constraint {
   Pointer get nativePtr => _ptr;
 
   factory TransformConstraint(TransformConstraintData data, Skeleton skeleton) {
-    final ptr = SpineBindings.bindings.spine_transform_constraint_create(
+    final ptr =
-        data.nativePtr.cast(), skeleton.nativePtr.cast());
+        SpineBindings.bindings.spine_transform_constraint_create(data.nativePtr.cast(), skeleton.nativePtr.cast());
     return TransformConstraint.fromPointer(ptr);
   }
 
   @override
   Rtti get rtti {
-    final result =
+    final result = SpineBindings.bindings.spine_transform_constraint_get_rtti(_ptr);
-        SpineBindings.bindings.spine_transform_constraint_get_rtti(_ptr);
     return Rtti.fromPointer(result);
   }
 
   TransformConstraint copy(Skeleton skeleton) {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_transform_constraint_copy(_ptr, skeleton.nativePtr.cast());
-        .spine_transform_constraint_copy(_ptr, skeleton.nativePtr.cast());
     return TransformConstraint.fromPointer(result);
   }
 
   @override
   void update(Skeleton skeleton, Physics physics) {
-    SpineBindings.bindings.spine_transform_constraint_update(
+    SpineBindings.bindings.spine_transform_constraint_update(_ptr, skeleton.nativePtr.cast(), physics.value);
-        _ptr, skeleton.nativePtr.cast(), physics.value);
   }
 
   @override
   void sort(Skeleton skeleton) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_transform_constraint_sort(_ptr, skeleton.nativePtr.cast());
-        .spine_transform_constraint_sort(_ptr, skeleton.nativePtr.cast());
   }
 
   @override
   bool get isSourceActive {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_transform_constraint_is_source_active(_ptr);
-        .spine_transform_constraint_is_source_active(_ptr);
     return result;
   }
 
   ArrayBonePose get bones {
-    final result =
+    final result = SpineBindings.bindings.spine_transform_constraint_get_bones(_ptr);
-        SpineBindings.bindings.spine_transform_constraint_get_bones(_ptr);
     return ArrayBonePose.fromPointer(result);
   }
 
   Bone get source {
-    final result =
+    final result = SpineBindings.bindings.spine_transform_constraint_get_source(_ptr);
-        SpineBindings.bindings.spine_transform_constraint_get_source(_ptr);
     return Bone.fromPointer(result);
   }
 
   set source(Bone value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_transform_constraint_set_source(_ptr, value.nativePtr.cast());
-        .spine_transform_constraint_set_source(_ptr, value.nativePtr.cast());
   }
 
   @override
   TransformConstraintData get data {
-    final result =
+    final result = SpineBindings.bindings.spine_transform_constraint_get_data(_ptr);
-        SpineBindings.bindings.spine_transform_constraint_get_data(_ptr);
     return TransformConstraintData.fromPointer(result);
   }
 
   TransformConstraintPose get pose {
-    final result =
+    final result = SpineBindings.bindings.spine_transform_constraint_get_pose(_ptr);
-        SpineBindings.bindings.spine_transform_constraint_get_pose(_ptr);
     return TransformConstraintPose.fromPointer(result);
   }
 
   TransformConstraintPose get appliedPose {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_transform_constraint_get_applied_pose(_ptr);
-        .spine_transform_constraint_get_applied_pose(_ptr);
     return TransformConstraintPose.fromPointer(result);
   }
 
@@ -139,8 +128,7 @@ class TransformConstraint extends PosedActive implements Posed, Constraint {
 
   @override
   bool get isPoseEqualToApplied {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_transform_constraint_is_pose_equal_to_applied(_ptr);
-        .spine_transform_constraint_is_pose_equal_to_applied(_ptr);
     return result;
   }
 

spine-flutter/lib/generated/transform_constraint_data.dart

@@ -51,36 +51,29 @@ import 'transform_constraint_pose.dart';
 class TransformConstraintData extends PosedData implements ConstraintData {
   final Pointer<spine_transform_constraint_data_wrapper> _ptr;
 
-  TransformConstraintData.fromPointer(this._ptr)
+  TransformConstraintData.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
-      : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
   @override
   Pointer get nativePtr => _ptr;
 
   factory TransformConstraintData(String name) {
-    final ptr = SpineBindings.bindings.spine_transform_constraint_data_create(
+    final ptr = SpineBindings.bindings.spine_transform_constraint_data_create(name.toNativeUtf8().cast<Char>());
-        name.toNativeUtf8().cast<Char>());
     return TransformConstraintData.fromPointer(ptr);
   }
 
   @override
   Rtti get rtti {
-    final result =
+    final result = SpineBindings.bindings.spine_transform_constraint_data_get_rtti(_ptr);
-        SpineBindings.bindings.spine_transform_constraint_data_get_rtti(_ptr);
     return Rtti.fromPointer(result);
   }
 
   @override
   Constraint createMethod(Skeleton skeleton) {
-    final result = SpineBindings.bindings
+    final result =
-        .spine_transform_constraint_data_create_method(
+        SpineBindings.bindings.spine_transform_constraint_data_create_method(_ptr, skeleton.nativePtr.cast());
-            _ptr, skeleton.nativePtr.cast());
     final rtti = SpineBindings.bindings.spine_constraint_get_rtti(result);
-    final className = SpineBindings.bindings
+    final className = SpineBindings.bindings.spine_rtti_get_class_name(rtti).cast<Utf8>().toDartString();
-        .spine_rtti_get_class_name(rtti)
-        .cast<Utf8>()
-        .toDartString();
     switch (className) {
       case 'spine_ik_constraint':
         return IkConstraint.fromPointer(result.cast());
@@ -93,153 +86,126 @@ class TransformConstraintData extends PosedData implements ConstraintData {
       case 'spine_transform_constraint':
         return TransformConstraint.fromPointer(result.cast());
       default:
-        throw UnsupportedError(
+        throw UnsupportedError('Unknown concrete type: $className for abstract class Constraint');
-            'Unknown concrete type: $className for abstract class Constraint');
     }
   }
 
   ArrayBoneData get bones {
-    final result =
+    final result = SpineBindings.bindings.spine_transform_constraint_data_get_bones(_ptr);
-        SpineBindings.bindings.spine_transform_constraint_data_get_bones(_ptr);
     return ArrayBoneData.fromPointer(result);
   }
 
   BoneData get source {
-    final result =
+    final result = SpineBindings.bindings.spine_transform_constraint_data_get_source(_ptr);
-        SpineBindings.bindings.spine_transform_constraint_data_get_source(_ptr);
     return BoneData.fromPointer(result);
   }
 
   set source(BoneData value) {
-    SpineBindings.bindings.spine_transform_constraint_data_set_source(
+    SpineBindings.bindings.spine_transform_constraint_data_set_source(_ptr, value.nativePtr.cast());
-        _ptr, value.nativePtr.cast());
   }
 
   double get offsetRotation {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_transform_constraint_data_get_offset_rotation(_ptr);
-        .spine_transform_constraint_data_get_offset_rotation(_ptr);
     return result;
   }
 
   set offsetRotation(double value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_transform_constraint_data_set_offset_rotation(_ptr, value);
-        .spine_transform_constraint_data_set_offset_rotation(_ptr, value);
   }
 
   double get offsetX {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_transform_constraint_data_get_offset_x(_ptr);
-        .spine_transform_constraint_data_get_offset_x(_ptr);
     return result;
   }
 
   set offsetX(double value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_transform_constraint_data_set_offset_x(_ptr, value);
-        .spine_transform_constraint_data_set_offset_x(_ptr, value);
   }
 
   double get offsetY {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_transform_constraint_data_get_offset_y(_ptr);
-        .spine_transform_constraint_data_get_offset_y(_ptr);
     return result;
   }
 
   set offsetY(double value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_transform_constraint_data_set_offset_y(_ptr, value);
-        .spine_transform_constraint_data_set_offset_y(_ptr, value);
   }
 
   double get offsetScaleX {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_transform_constraint_data_get_offset_scale_x(_ptr);
-        .spine_transform_constraint_data_get_offset_scale_x(_ptr);
     return result;
   }
 
   set offsetScaleX(double value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_transform_constraint_data_set_offset_scale_x(_ptr, value);
-        .spine_transform_constraint_data_set_offset_scale_x(_ptr, value);
   }
 
   double get offsetScaleY {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_transform_constraint_data_get_offset_scale_y(_ptr);
-        .spine_transform_constraint_data_get_offset_scale_y(_ptr);
     return result;
   }
 
   set offsetScaleY(double value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_transform_constraint_data_set_offset_scale_y(_ptr, value);
-        .spine_transform_constraint_data_set_offset_scale_y(_ptr, value);
   }
 
   double get offsetShearY {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_transform_constraint_data_get_offset_shear_y(_ptr);
-        .spine_transform_constraint_data_get_offset_shear_y(_ptr);
     return result;
   }
 
   set offsetShearY(double value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_transform_constraint_data_set_offset_shear_y(_ptr, value);
-        .spine_transform_constraint_data_set_offset_shear_y(_ptr, value);
   }
 
   bool get localSource {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_transform_constraint_data_get_local_source(_ptr);
-        .spine_transform_constraint_data_get_local_source(_ptr);
     return result;
   }
 
   set localSource(bool value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_transform_constraint_data_set_local_source(_ptr, value);
-        .spine_transform_constraint_data_set_local_source(_ptr, value);
   }
 
   bool get localTarget {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_transform_constraint_data_get_local_target(_ptr);
-        .spine_transform_constraint_data_get_local_target(_ptr);
     return result;
   }
 
   set localTarget(bool value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_transform_constraint_data_set_local_target(_ptr, value);
-        .spine_transform_constraint_data_set_local_target(_ptr, value);
   }
 
   bool get additive {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_transform_constraint_data_get_additive(_ptr);
-        .spine_transform_constraint_data_get_additive(_ptr);
     return result;
   }
 
   set additive(bool value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_transform_constraint_data_set_additive(_ptr, value);
-        .spine_transform_constraint_data_set_additive(_ptr, value);
   }
 
   bool get clamp {
-    final result =
+    final result = SpineBindings.bindings.spine_transform_constraint_data_get_clamp(_ptr);
-        SpineBindings.bindings.spine_transform_constraint_data_get_clamp(_ptr);
     return result;
   }
 
   set clamp(bool value) {
-    SpineBindings.bindings
+    SpineBindings.bindings.spine_transform_constraint_data_set_clamp(_ptr, value);
-        .spine_transform_constraint_data_set_clamp(_ptr, value);
   }
 
   ArrayFromProperty get properties {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_transform_constraint_data_get_properties(_ptr);
-        .spine_transform_constraint_data_get_properties(_ptr);
     return ArrayFromProperty.fromPointer(result);
   }
 
   TransformConstraintPose get setupPose {
-    final result = SpineBindings.bindings
+    final result = SpineBindings.bindings.spine_transform_constraint_data_get_setup_pose(_ptr);
-        .spine_transform_constraint_data_get_setup_pose(_ptr);
     return TransformConstraintPose.fromPointer(result);
   }
 
   static Rtti rttiStatic() {
-    final result =
+    final result = SpineBindings.bindings.spine_transform_constraint_data_rtti();
-        SpineBindings.bindings.spine_transform_constraint_data_rtti();
     return Rtti.fromPointer(result);
   }
 }