[flutter] Working dart-writer plus headless smoke test

.gitignore

@@ -257,3 +257,4 @@ formatters/eclipse-formatter/format-diff.txt
 spine-cpp/build-debug
 spine-cpp/build-linux
 spine-cpp/build-release-debug
+spine-flutter/test/spine_flutter.dylib

spine-c/src/extensions.h

@@ -35,6 +35,8 @@ extern "C" {
 #endif
 
 #include "base.h"
+#include "generated/atlas.h"
+#include "generated/skeleton_data.h"
 
 // Custom types for spine-c-new (not generated)
 SPINE_OPAQUE_TYPE(spine_skeleton_data_result)

spine-flutter/README.md

@@ -63,7 +63,7 @@ Otherwise you can run the example like this:
 2. Clone this repository `git clone https://github.com/esotericsoftware/spine-runtimes`
 3. Run `setup.sh` in the `spine-flutter/` folder. On Windows, you can use [Git Bash](https://gitforwindows.org/) included in Git for Window to run the `setup.sh` Bash script.
 
-You can then open `spine-flutter` in an IDE or editor of your choice that supports Flutter, like [IntelliJ IDEA/Android Studio](https://docs.flutter.dev/get-started/editor?tab=androidstudio) or [Visual Studio Code](https://docs.flutter.dev/get-started/editor?tab=vscode) to inspect and run the example. 
+You can then open `spine-flutter` in an IDE or editor of your choice that supports Flutter, like [IntelliJ IDEA/Android Studio](https://docs.flutter.dev/get-started/editor?tab=androidstudio) or [Visual Studio Code](https://docs.flutter.dev/get-started/editor?tab=vscode) to inspect and run the example.
 
 Alternatively, you can run the example from the [command line](https://docs.flutter.dev/get-started/test-drive?tab=terminal).
 
@@ -72,6 +72,6 @@ If all you modify are the Dart sources of the plugin, then the development setup
 
 If you need to work on the `dart:ffi` bindings for `spine-cpp`, you will also need to install [Emscripten](https://emscripten.org/docs/getting_started/downloads.html).
 
-To generate the bindings based on the `src/spine_flutter.h` header, run `dart run ffigen --config ffigen.yaml`. After the bindings have been generated, you must replace the line `import 'dart:ffi' as ffi;` with `import 'ffi_proxy.dart' as ffi;` in the file `src/spine_flutter_bindings_generated.dart`. Otherwise the bindings will not compile for the web.
+To generate the bindings based on the `src/spine_flutter.h` header, run `dart run ffigen --config ffigen.yaml`. After the bindings have been generated, you must replace the line `import 'dart:ffi' as ffi;` with `import 'ffi_proxy.dart' as ffi;` in the file `src/generated/spine_dart_bindings_generated.dart`. Otherwise the bindings will not compile for the web.
 
-If you made changes to `spine-cpp` or the source files in `src/`, you must run `compile-wasm.sh`. This will compile `spine-cpp` and the bindings for the Web and place updated versions of `libspine_flutter.js` and `libspine_flutter.wasm` in the `lib/assets/` folder. For web builds, the `initSpineFlutterFFI()` function in `lib/init_web.dart` will load these files from the package's asset bundle.
+If you made changes to `spine-cpp` or the source files in `src/`, you must run `compile-wasm.sh`. This will compile `spine-cpp` and the bindings for the Web and place updated versions of `libspine_flutter.js` and `libspine_flutter.wasm` in the `lib/assets/` folder. For web builds, the `initSpineDartFFI()` function in `lib/spine_dart_init_web.dart` will load these files from the package's asset bundle.

spine-flutter/codegen/package.json

@@ -1,6 +1,10 @@
 {
   "name": "spine-flutter-codegen",
   "type": "module",
+  "scripts": {
+    "format": "npx -y typescript-formatter -r **/*.ts",
+    "build": "npx tsx src/index.ts"
+  },
   "dependencies": {
     "spine-c-codegen": "file:../../spine-c/codegen"
   },

spine-flutter/codegen/src/index.ts

@@ -21,25 +21,17 @@ async function generateFFIBindings(spineCDir: string): Promise<void> {
     // Generate ffigen.yaml configuration
     console.log('Generating ffigen.yaml configuration...');
     const ffigenConfig = `# Run with \`dart run ffigen --config ffigen.yaml\`.
-name: SpineFlutterBindings
+name: SpineDartBindings
 description: |
   Bindings for Spine C headers.
 
   Regenerate bindings with \`dart run ffigen --config ffigen.yaml\`.
-output: 'lib/generated/spine_flutter_bindings_generated.dart'
+output: 'lib/generated/spine_dart_bindings_generated.dart'
 llvm-path:
     - '/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/'
 headers:
   entry-points:
     - 'src/spine-c/include/spine-c.h'
-    - 'src/spine-c/src/base.h'
-    - 'src/spine-c/src/extensions.h'
-${headerFiles.map(h => `    - '${h}'`).join('\n')}
-  include-directives:
-    - 'src/spine-c/include/spine-c.h'
-    - 'src/spine-c/src/base.h'
-    - 'src/spine-c/src/extensions.h'
-${headerFiles.map(h => `    - '${h}'`).join('\n')}
 compiler-opts:
   - '-Isrc/spine-c/include'
   - '-Isrc/spine-c/src'
@@ -83,7 +75,7 @@ comments:
     }
 
     // Check if bindings were generated successfully
-    const bindingsPath = path.join(__dirname, '../../lib/generated/spine_flutter_bindings_generated.dart');
+    const bindingsPath = path.join(__dirname, '../../lib/generated/spine_dart_bindings_generated.dart');
     if (!fs.existsSync(bindingsPath)) {
         throw new Error('Failed to generate bindings');
     }
@@ -101,20 +93,91 @@ comments:
     console.log('✅ FFI bindings generated successfully!');
 }
 
+async function generateFFigenYamlOnly(spineCDir: string): Promise<void> {
+    console.log('Finding all header files...');
+    const generatedDir = path.join(spineCDir, 'src/generated');
+    const headerFiles = fs.readdirSync(generatedDir)
+        .filter(f => f.endsWith('.h'))
+        .map(f => path.join('src/spine-c/src/generated', f))
+        .sort();
+
+    console.log(`Found ${headerFiles.length} header files`);
+
+    // Generate ffigen.yaml configuration
+    console.log('Generating ffigen.yaml configuration...');
+    const ffigenConfig = `# Run with \`dart run ffigen --config ffigen.yaml\`.
+name: SpineDartBindings
+description: |
+  Bindings for Spine C headers.
+
+  Regenerate bindings with \`dart run ffigen --config ffigen.yaml\`.
+output: 'lib/generated/spine_dart_bindings_generated.dart'
+llvm-path:
+    - '/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/'
+headers:
+  entry-points:
+    - 'src/spine-c/include/spine-c.h'
+compiler-opts:
+  - '-Isrc/spine-c/include'
+  - '-Isrc/spine-c/src'
+  - '-Isrc/spine-c/src/generated'
+  - '-xc'
+  - '-std=c99'
+functions:
+  include:
+    - 'spine_.*'
+structs:
+  include:
+    - 'spine_.*'
+enums:
+  include:
+    - 'spine_.*'
+typedefs:
+  include:
+    - 'spine_.*'
+preamble: |
+  // ignore_for_file: always_specify_types, constant_identifier_names
+  // ignore_for_file: camel_case_types
+  // ignore_for_file: non_constant_identifier_names
+comments:
+  style: any
+  length: full
+`;
+
+    const ffigenPath = path.join(__dirname, '../../ffigen.yaml');
+    fs.writeFileSync(ffigenPath, ffigenConfig);
+    console.log(`FFigen config written to: ${ffigenPath}`);
+}
+
 async function main() {
+    const args = process.argv.slice(2);
+    const justGenerateYaml = args.includes('--yaml-only');
+
+    if (justGenerateYaml) {
+        console.log('Generating ffigen.yaml only...\n');
+        
+        // Generate FFI bindings YAML config only
+        const spineCDir = path.join(__dirname, '../../src/spine-c');
+        await generateFFigenYamlOnly(spineCDir);
+        console.log('✅ ffigen.yaml generated successfully!');
+        return;
+    }
+
     console.log('Generating Spine Flutter bindings and wrappers...\n');
 
+    console.log('🔧 Using Dart writer implementation\n');
+
     try {
         // Step 1: Generate C intermediate representation using spine-c codegen
         console.log('Step 1: Generating C intermediate representation...');
-        const { cTypes, cEnums, cArrayTypes } = await generate();
+        const { cTypes, cEnums, cArrayTypes, inheritance, supertypes, subtypes, isInterface } = await generate();
         console.log(`Generated ${cTypes.length} C types, ${cEnums.length} enums, and ${cArrayTypes.length} array types\n`);
 
         // Step 2: Write Dart wrapper classes
         console.log('Step 2: Writing Dart wrapper classes...');
         const outputDir = path.join(__dirname, '../../lib/generated');
         const dartWriter = new DartWriter(outputDir);
-        await dartWriter.writeAll(cTypes, cEnums, cArrayTypes);
+        await dartWriter.writeAll(cTypes, cEnums, cArrayTypes, inheritance, isInterface, supertypes);
         console.log();
 
         // Step 3: Generate FFI bindings using ffigen
@@ -122,6 +185,31 @@ async function main() {
         const spineCDir = path.join(__dirname, '../../src/spine-c');
         await generateFFIBindings(spineCDir);
 
+        // Step 4: Format and fix generated Dart code
+        console.log('Step 4: Formatting and fixing generated Dart code...');
+        try {
+            const projectRoot = path.join(__dirname, '../..');
+
+            // Run dart fix to remove unused imports and apply other fixes
+            console.log('Running dart fix --apply...');
+            execSync('dart fix --apply lib/generated/', {
+                cwd: projectRoot,
+                stdio: 'inherit'
+            });
+
+            // Run dart format to format the code
+            console.log('Running dart format...');
+            execSync('dart format lib/generated/', {
+                cwd: projectRoot,
+                stdio: 'inherit'
+            });
+
+            console.log('✅ Dart code formatting and fixes applied successfully!');
+        } catch (error) {
+            console.warn('⚠️ Warning: Could not format/fix Dart code:', error);
+            console.warn('You may want to run "dart fix --apply lib/generated/" and "dart format lib/generated/" manually');
+        }
+
         console.log('\n✅ All code generation completed successfully!');
     } catch (error) {
         console.error('\n❌ Error:', error);

spine-flutter/generate-bindings.sh

@@ -14,6 +14,9 @@ if [ ! -d "codegen/node_modules" ]; then
     popd > /dev/null
 fi
 
+# Copy spine-c and spine-cpp sources
+./setup.sh
+
 # Run the codegen
 npx tsx codegen/src/index.ts
 

spine-flutter/lib/extensions.dart

@@ -40,8 +40,8 @@ import 'package:http/http.dart' as http;
 import 'package:path/path.dart' as path;
 
 import 'ffi_proxy.dart';
-import 'init.dart' if (dart.library.html) 'init_web.dart';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_init.dart' if (dart.library.html) 'spine_flutter_init_web.dart';
+import 'spine_flutter.dart';
 import 'raw_image_provider.dart';
 
 export 'spine_widget.dart';
@@ -54,6 +54,10 @@ Future<void> initSpineFlutter({bool useStaticLinkage = false, bool enableMemoryD
   _bindings = SpineFlutterBindings(ffi.dylib);
   _allocator = ffi.allocator;
   if (enableMemoryDebugging) _bindings.spine_enable_debug_extension(true);
+
+  // Initialize the global bindings for generated code
+  initializeSpineFlutter(_bindings);
+
   return;
 }
 

spine-flutter/lib/generated/alpha_timeline.dart

@@ -30,12 +30,13 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 import 'curve_timeline1.dart';
+import 'slot_timeline.dart';
 
 /// AlphaTimeline wrapper
-class AlphaTimeline extends CurveTimeline1 {
+class AlphaTimeline extends CurveTimeline1 implements SlotTimeline {
   final Pointer<spine_alpha_timeline_wrapper> _ptr;
 
   AlphaTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
@@ -45,21 +46,20 @@ class AlphaTimeline extends CurveTimeline1 {
   Pointer get nativePtr => _ptr;
 
   factory AlphaTimeline(int frameCount, int bezierCount, int slotIndex) {
-    final ptr = SpineBindings.bindings.spine_alpha_timeline_create(frameCount, bezierCount, slotIndex);
+    final ptr = SpineBindings.bindings
+        .spine_alpha_timeline_create(frameCount, bezierCount, slotIndex);
     return AlphaTimeline.fromPointer(ptr);
   }
 
+  @override
   int get slotIndex {
-    final result = SpineBindings.bindings.spine_alpha_timeline_get_slot_index(_ptr);
+    final result =
+        SpineBindings.bindings.spine_alpha_timeline_get_slot_index(_ptr);
     return result;
   }
 
+  @override
   set slotIndex(int value) {
     SpineBindings.bindings.spine_alpha_timeline_set_slot_index(_ptr, value);
   }
-
-  @override
-  void dispose() {
-    SpineBindings.bindings.spine_alpha_timeline_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/animation.dart

@@ -31,12 +31,12 @@
 
 import 'dart:ffi';
 import 'package:ffi/ffi.dart';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
-import 'skeleton.dart';
+import 'arrays.dart';
 import 'mix_blend.dart';
 import 'mix_direction.dart';
-import 'arrays.dart';
+import 'skeleton.dart';
 
 /// Animation wrapper
 class Animation implements Finalizable {
@@ -48,7 +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(name.toNativeUtf8().cast<Char>(), timelines.nativePtr.cast(), duration);
+    final ptr = SpineBindings.bindings.spine_animation_create(
+        name.toNativeUtf8().cast<Char>(), timelines.nativePtr.cast(), duration);
     return Animation.fromPointer(ptr);
   }
 
@@ -58,11 +59,13 @@ class Animation implements Finalizable {
   }
 
   set timelines(ArrayTimeline value) {
-    SpineBindings.bindings.spine_animation_set_timelines(_ptr, value.nativePtr.cast());
+    SpineBindings.bindings
+        .spine_animation_set_timelines(_ptr, value.nativePtr.cast());
   }
 
   bool hasTimeline(ArrayPropertyId ids) {
-    final result = SpineBindings.bindings.spine_animation_has_timeline(_ptr, ids.nativePtr.cast());
+    final result = SpineBindings.bindings
+        .spine_animation_has_timeline(_ptr, ids.nativePtr.cast());
     return result;
   }
 
@@ -75,8 +78,27 @@ class Animation implements Finalizable {
     SpineBindings.bindings.spine_animation_set_duration(_ptr, value);
   }
 
-  void apply(Skeleton skeleton, double lastTime, double time, 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);
+  void apply(
+      Skeleton skeleton,
+      double lastTime,
+      double time,
+      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 {
@@ -89,17 +111,15 @@ class Animation implements Finalizable {
     return ArrayInt.fromPointer(result);
   }
 
-  static int search1(ArrayFloat values, double target) {
-    final result = SpineBindings.bindings.spine_animation_search_1(values.nativePtr.cast(), target);
+  static int search(ArrayFloat values, double target) {
+    final result = SpineBindings.bindings
+        .spine_animation_search_1(values.nativePtr.cast(), target);
     return result;
   }
 
   static int search2(ArrayFloat values, double target, int step) {
-    final result = SpineBindings.bindings.spine_animation_search_2(values.nativePtr.cast(), target, step);
+    final result = SpineBindings.bindings
+        .spine_animation_search_2(values.nativePtr.cast(), target, step);
     return result;
   }
-
-  void dispose() {
-    SpineBindings.bindings.spine_animation_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/animation_state.dart

@@ -31,13 +31,13 @@
 
 import 'dart:ffi';
 import 'package:ffi/ffi.dart';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
-import 'skeleton.dart';
-import 'track_entry.dart';
 import 'animation.dart';
 import 'animation_state_data.dart';
 import 'arrays.dart';
+import 'skeleton.dart';
+import 'track_entry.dart';
 
 /// AnimationState wrapper
 class AnimationState implements Finalizable {
@@ -49,7 +49,8 @@ class AnimationState implements Finalizable {
   Pointer get nativePtr => _ptr;
 
   factory AnimationState(AnimationStateData data) {
-    final ptr = SpineBindings.bindings.spine_animation_state_create(data.nativePtr.cast());
+    final ptr = SpineBindings.bindings
+        .spine_animation_state_create(data.nativePtr.cast());
     return AnimationState.fromPointer(ptr);
   }
 
@@ -58,7 +59,8 @@ class AnimationState implements Finalizable {
   }
 
   bool apply(Skeleton skeleton) {
-    final result = SpineBindings.bindings.spine_animation_state_apply(_ptr, skeleton.nativePtr.cast());
+    final result = SpineBindings.bindings
+        .spine_animation_state_apply(_ptr, skeleton.nativePtr.cast());
     return result;
   }
 
@@ -71,21 +73,28 @@ class AnimationState implements Finalizable {
   }
 
   TrackEntry setEmptyAnimation(int trackIndex, double mixDuration) {
-    final result = SpineBindings.bindings.spine_animation_state_set_empty_animation(_ptr, trackIndex, mixDuration);
+    final result = SpineBindings.bindings
+        .spine_animation_state_set_empty_animation(
+            _ptr, trackIndex, mixDuration);
     return TrackEntry.fromPointer(result);
   }
 
-  TrackEntry addEmptyAnimation(int trackIndex, double mixDuration, double delay) {
-    final result = SpineBindings.bindings.spine_animation_state_add_empty_animation(_ptr, trackIndex, mixDuration, delay);
+  TrackEntry addEmptyAnimation(
+      int trackIndex, double mixDuration, double delay) {
+    final result = SpineBindings.bindings
+        .spine_animation_state_add_empty_animation(
+            _ptr, trackIndex, mixDuration, delay);
     return TrackEntry.fromPointer(result);
   }
 
   set emptyAnimations(double value) {
-    SpineBindings.bindings.spine_animation_state_set_empty_animations(_ptr, value);
+    SpineBindings.bindings
+        .spine_animation_state_set_empty_animations(_ptr, value);
   }
 
   TrackEntry getCurrent(int trackIndex) {
-    final result = SpineBindings.bindings.spine_animation_state_get_current(_ptr, trackIndex);
+    final result = SpineBindings.bindings
+        .spine_animation_state_get_current(_ptr, trackIndex);
     return TrackEntry.fromPointer(result);
   }
 
@@ -95,12 +104,14 @@ class AnimationState implements Finalizable {
   }
 
   ArrayTrackEntry get tracks {
-    final result = SpineBindings.bindings.spine_animation_state_get_tracks(_ptr);
+    final result =
+        SpineBindings.bindings.spine_animation_state_get_tracks(_ptr);
     return ArrayTrackEntry.fromPointer(result);
   }
 
   double get timeScale {
-    final result = SpineBindings.bindings.spine_animation_state_get_time_scale(_ptr);
+    final result =
+        SpineBindings.bindings.spine_animation_state_get_time_scale(_ptr);
     return result;
   }
 
@@ -117,39 +128,54 @@ class AnimationState implements Finalizable {
   }
 
   set manualTrackEntryDisposal(bool value) {
-    SpineBindings.bindings.spine_animation_state_set_manual_track_entry_disposal(_ptr, value);
+    SpineBindings.bindings
+        .spine_animation_state_set_manual_track_entry_disposal(_ptr, value);
   }
 
   bool get manualTrackEntryDisposal {
-    final result = SpineBindings.bindings.spine_animation_state_get_manual_track_entry_disposal(_ptr);
+    final result = SpineBindings.bindings
+        .spine_animation_state_get_manual_track_entry_disposal(_ptr);
     return result;
   }
 
   void disposeTrackEntry(TrackEntry entry) {
-    SpineBindings.bindings.spine_animation_state_dispose_track_entry(_ptr, entry.nativePtr.cast());
+    SpineBindings.bindings.spine_animation_state_dispose_track_entry(
+        _ptr, entry.nativePtr.cast());
   }
 
-  TrackEntry setAnimation1(int trackIndex, String animationName, bool loop) {
-    final result = SpineBindings.bindings.spine_animation_state_set_animation_1(_ptr, trackIndex, animationName.toNativeUtf8().cast<Char>(), loop);
+  Pointer<Void> get rendererObject {
+    final result =
+        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(
+        _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(_ptr, trackIndex, animation.nativePtr.cast(), loop);
+    final result = SpineBindings.bindings.spine_animation_state_set_animation_2(
+        _ptr, trackIndex, animation.nativePtr.cast(), loop);
     return TrackEntry.fromPointer(result);
   }
 
-  TrackEntry addAnimation1(int trackIndex, String animationName, bool loop, double delay) {
-    final result = SpineBindings.bindings.spine_animation_state_add_animation_1(_ptr, trackIndex, animationName.toNativeUtf8().cast<Char>(), loop, delay);
+  TrackEntry addAnimation(
+      int trackIndex, String animationName, bool loop, double delay) {
+    final result = SpineBindings.bindings.spine_animation_state_add_animation_1(
+        _ptr,
+        trackIndex,
+        animationName.toNativeUtf8().cast<Char>(),
+        loop,
+        delay);
     return TrackEntry.fromPointer(result);
   }
 
-  TrackEntry addAnimation2(int trackIndex, Animation animation, bool loop, double delay) {
-    final result = SpineBindings.bindings.spine_animation_state_add_animation_2(_ptr, trackIndex, animation.nativePtr.cast(), loop, delay);
+  TrackEntry addAnimation2(
+      int trackIndex, Animation animation, bool loop, double delay) {
+    final result = SpineBindings.bindings.spine_animation_state_add_animation_2(
+        _ptr, trackIndex, animation.nativePtr.cast(), loop, delay);
     return TrackEntry.fromPointer(result);
   }
-
-  void dispose() {
-    SpineBindings.bindings.spine_animation_state_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/animation_state_data.dart

@@ -31,10 +31,10 @@
 
 import 'dart:ffi';
 import 'package:ffi/ffi.dart';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
-import 'skeleton_data.dart';
 import 'animation.dart';
+import 'skeleton_data.dart';
 
 /// AnimationStateData wrapper
 class AnimationStateData implements Finalizable {
@@ -46,26 +46,31 @@ class AnimationStateData implements Finalizable {
   Pointer get nativePtr => _ptr;
 
   factory AnimationStateData(SkeletonData skeletonData) {
-    final ptr = SpineBindings.bindings.spine_animation_state_data_create(skeletonData.nativePtr.cast());
+    final ptr = SpineBindings.bindings
+        .spine_animation_state_data_create(skeletonData.nativePtr.cast());
     return AnimationStateData.fromPointer(ptr);
   }
 
   SkeletonData get skeletonData {
-    final result = SpineBindings.bindings.spine_animation_state_data_get_skeleton_data(_ptr);
+    final result = SpineBindings.bindings
+        .spine_animation_state_data_get_skeleton_data(_ptr);
     return SkeletonData.fromPointer(result);
   }
 
   double get defaultMix {
-    final result = SpineBindings.bindings.spine_animation_state_data_get_default_mix(_ptr);
+    final result =
+        SpineBindings.bindings.spine_animation_state_data_get_default_mix(_ptr);
     return result;
   }
 
   set defaultMix(double value) {
-    SpineBindings.bindings.spine_animation_state_data_set_default_mix(_ptr, value);
+    SpineBindings.bindings
+        .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(_ptr, from.nativePtr.cast(), to.nativePtr.cast());
+    final result = SpineBindings.bindings.spine_animation_state_data_get_mix(
+        _ptr, from.nativePtr.cast(), to.nativePtr.cast());
     return result;
   }
 
@@ -73,15 +78,16 @@ class AnimationStateData implements Finalizable {
     SpineBindings.bindings.spine_animation_state_data_clear(_ptr);
   }
 
-  void setMix1(String fromName, String toName, double duration) {
-    SpineBindings.bindings.spine_animation_state_data_set_mix_1(_ptr, fromName.toNativeUtf8().cast<Char>(), toName.toNativeUtf8().cast<Char>(), duration);
+  void setMix(String fromName, String toName, double duration) {
+    SpineBindings.bindings.spine_animation_state_data_set_mix_1(
+        _ptr,
+        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(_ptr, from.nativePtr.cast(), to.nativePtr.cast(), duration);
+    SpineBindings.bindings.spine_animation_state_data_set_mix_2(
+        _ptr, from.nativePtr.cast(), to.nativePtr.cast(), duration);
   }
-
-  void dispose() {
-    SpineBindings.bindings.spine_animation_state_data_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/arrays.dart

@@ -31,7 +31,7 @@
 
 import 'dart:ffi';
 import 'package:ffi/ffi.dart';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 import '../native_array.dart';
 import 'alpha_timeline.dart';
@@ -59,15 +59,20 @@ import 'from_scale_y.dart';
 import 'from_shear_y.dart';
 import 'from_x.dart';
 import 'from_y.dart';
+import 'ik_constraint.dart';
+import 'ik_constraint_data.dart';
 import 'ik_constraint_timeline.dart';
 import 'inherit_timeline.dart';
 import 'mesh_attachment.dart';
 import 'path_attachment.dart';
+import 'path_constraint.dart';
+import 'path_constraint_data.dart';
 import 'path_constraint_mix_timeline.dart';
 import 'path_constraint_position_timeline.dart';
 import 'path_constraint_spacing_timeline.dart';
 import 'physics_constraint.dart';
 import 'physics_constraint_damping_timeline.dart';
+import 'physics_constraint_data.dart';
 import 'physics_constraint_gravity_timeline.dart';
 import 'physics_constraint_inertia_timeline.dart';
 import 'physics_constraint_mass_timeline.dart';
@@ -91,6 +96,8 @@ import 'shear_timeline.dart';
 import 'shear_x_timeline.dart';
 import 'shear_y_timeline.dart';
 import 'skin.dart';
+import 'slider.dart';
+import 'slider_data.dart';
 import 'slider_mix_timeline.dart';
 import 'slider_timeline.dart';
 import 'slot.dart';
@@ -105,13 +112,15 @@ import 'to_shear_y.dart';
 import 'to_x.dart';
 import 'to_y.dart';
 import 'track_entry.dart';
+import 'transform_constraint.dart';
+import 'transform_constraint_data.dart';
 import 'transform_constraint_timeline.dart';
 import 'translate_timeline.dart';
 import 'translate_x_timeline.dart';
 import 'translate_y_timeline.dart';
 import 'update.dart';
 
-/// Array of float elements
+/// ArrayFloat wrapper
 class ArrayFloat extends NativeArray<double> {
   ArrayFloat.fromPointer(Pointer<spine_array_float_wrapper> super.ptr);
 
@@ -125,13 +134,13 @@ class ArrayFloat extends NativeArray<double> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer = SpineBindings.bindings.spine_array_float_buffer(nativePtr.cast());
+    final buffer =
+        SpineBindings.bindings.spine_array_float_buffer(nativePtr.cast());
     return buffer.cast<Float>()[index];
   }
-
 }
 
-/// Array of int elements
+/// ArrayInt wrapper
 class ArrayInt extends NativeArray<int> {
   ArrayInt.fromPointer(Pointer<spine_array_int_wrapper> super.ptr);
 
@@ -145,19 +154,21 @@ class ArrayInt extends NativeArray<int> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer = SpineBindings.bindings.spine_array_int_buffer(nativePtr.cast());
+    final buffer =
+        SpineBindings.bindings.spine_array_int_buffer(nativePtr.cast());
     return buffer.cast<Int32>()[index];
   }
-
 }
 
-/// Array of unsigned_short elements
+/// ArrayUnsignedShort wrapper
 class ArrayUnsignedShort extends NativeArray<int> {
-  ArrayUnsignedShort.fromPointer(Pointer<spine_array_unsigned_short_wrapper> super.ptr);
+  ArrayUnsignedShort.fromPointer(
+      Pointer<spine_array_unsigned_short_wrapper> super.ptr);
 
   @override
   int get length {
-    return SpineBindings.bindings.spine_array_unsigned_short_size(nativePtr.cast());
+    return SpineBindings.bindings
+        .spine_array_unsigned_short_size(nativePtr.cast());
   }
 
   @override
@@ -165,19 +176,21 @@ class ArrayUnsignedShort extends NativeArray<int> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer = SpineBindings.bindings.spine_array_unsigned_short_buffer(nativePtr.cast());
+    final buffer = SpineBindings.bindings
+        .spine_array_unsigned_short_buffer(nativePtr.cast());
     return buffer.cast<Uint16>()[index];
   }
-
 }
 
-/// Array of property_id elements
+/// ArrayPropertyId wrapper
 class ArrayPropertyId extends NativeArray<int> {
-  ArrayPropertyId.fromPointer(Pointer<spine_array_property_id_wrapper> super.ptr);
+  ArrayPropertyId.fromPointer(
+      Pointer<spine_array_property_id_wrapper> super.ptr);
 
   @override
   int get length {
-    return SpineBindings.bindings.spine_array_property_id_size(nativePtr.cast());
+    return SpineBindings.bindings
+        .spine_array_property_id_size(nativePtr.cast());
   }
 
   @override
@@ -185,14 +198,14 @@ class ArrayPropertyId extends NativeArray<int> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer = SpineBindings.bindings.spine_array_property_id_buffer(nativePtr.cast());
+    final buffer =
+        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];
   }
-
 }
 
-/// Array of Animation elements
+/// ArrayAnimation wrapper
 class ArrayAnimation extends NativeArray<Animation> {
   ArrayAnimation.fromPointer(Pointer<spine_array_animation_wrapper> super.ptr);
 
@@ -206,13 +219,13 @@ class ArrayAnimation extends NativeArray<Animation> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer = SpineBindings.bindings.spine_array_animation_buffer(nativePtr.cast());
+    final buffer =
+        SpineBindings.bindings.spine_array_animation_buffer(nativePtr.cast());
     return Animation.fromPointer(buffer[index]);
   }
-
 }
 
-/// Array of AtlasPage elements
+/// ArrayAtlasPage wrapper
 class ArrayAtlasPage extends NativeArray<AtlasPage> {
   ArrayAtlasPage.fromPointer(Pointer<spine_array_atlas_page_wrapper> super.ptr);
 
@@ -226,19 +239,21 @@ class ArrayAtlasPage extends NativeArray<AtlasPage> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer = SpineBindings.bindings.spine_array_atlas_page_buffer(nativePtr.cast());
+    final buffer =
+        SpineBindings.bindings.spine_array_atlas_page_buffer(nativePtr.cast());
     return AtlasPage.fromPointer(buffer[index]);
   }
-
 }
 
-/// Array of AtlasRegion elements
+/// ArrayAtlasRegion wrapper
 class ArrayAtlasRegion extends NativeArray<AtlasRegion> {
-  ArrayAtlasRegion.fromPointer(Pointer<spine_array_atlas_region_wrapper> super.ptr);
+  ArrayAtlasRegion.fromPointer(
+      Pointer<spine_array_atlas_region_wrapper> super.ptr);
 
   @override
   int get length {
-    return SpineBindings.bindings.spine_array_atlas_region_size(nativePtr.cast());
+    return SpineBindings.bindings
+        .spine_array_atlas_region_size(nativePtr.cast());
   }
 
   @override
@@ -246,15 +261,16 @@ class ArrayAtlasRegion extends NativeArray<AtlasRegion> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer = SpineBindings.bindings.spine_array_atlas_region_buffer(nativePtr.cast());
+    final buffer = SpineBindings.bindings
+        .spine_array_atlas_region_buffer(nativePtr.cast());
     return AtlasRegion.fromPointer(buffer[index]);
   }
-
 }
 
-/// Array of Attachment elements
+/// ArrayAttachment wrapper
 class ArrayAttachment extends NativeArray<Attachment> {
-  ArrayAttachment.fromPointer(Pointer<spine_array_attachment_wrapper> super.ptr);
+  ArrayAttachment.fromPointer(
+      Pointer<spine_array_attachment_wrapper> super.ptr);
 
   @override
   int get length {
@@ -266,14 +282,15 @@ class ArrayAttachment extends NativeArray<Attachment> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer = SpineBindings.bindings.spine_array_attachment_buffer(nativePtr.cast());
-    final rtti = SpineBindings.bindings.spine_attachment_get_rtti(buffer[index]);
-    final className = SpineBindings.bindings.spine_rtti_get_class_name(rtti).cast<Utf8>().toDartString();
+    final buffer =
+        SpineBindings.bindings.spine_array_attachment_buffer(nativePtr.cast());
+    final rtti =
+        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_point_attachment':
-        return PointAttachment.fromPointer(buffer[index].cast());
-      case 'spine_region_attachment':
-        return RegionAttachment.fromPointer(buffer[index].cast());
       case 'spine_bounding_box_attachment':
         return BoundingBoxAttachment.fromPointer(buffer[index].cast());
       case 'spine_clipping_attachment':
@@ -282,14 +299,18 @@ class ArrayAttachment extends NativeArray<Attachment> {
         return MeshAttachment.fromPointer(buffer[index].cast());
       case 'spine_path_attachment':
         return PathAttachment.fromPointer(buffer[index].cast());
+      case 'spine_point_attachment':
+        return PointAttachment.fromPointer(buffer[index].cast());
+      case 'spine_region_attachment':
+        return RegionAttachment.fromPointer(buffer[index].cast());
       default:
-        throw UnsupportedError('Unknown concrete type: $className for abstract class Attachment');
+        throw UnsupportedError(
+            'Unknown concrete type: $className for abstract class Attachment');
     }
   }
-
 }
 
-/// Array of Bone elements
+/// ArrayBone wrapper
 class ArrayBone extends NativeArray<Bone> {
   ArrayBone.fromPointer(Pointer<spine_array_bone_wrapper> super.ptr);
 
@@ -303,13 +324,13 @@ class ArrayBone extends NativeArray<Bone> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer = SpineBindings.bindings.spine_array_bone_buffer(nativePtr.cast());
+    final buffer =
+        SpineBindings.bindings.spine_array_bone_buffer(nativePtr.cast());
     return Bone.fromPointer(buffer[index]);
   }
-
 }
 
-/// Array of BoneData elements
+/// ArrayBoneData wrapper
 class ArrayBoneData extends NativeArray<BoneData> {
   ArrayBoneData.fromPointer(Pointer<spine_array_bone_data_wrapper> super.ptr);
 
@@ -323,13 +344,13 @@ class ArrayBoneData extends NativeArray<BoneData> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer = SpineBindings.bindings.spine_array_bone_data_buffer(nativePtr.cast());
+    final buffer =
+        SpineBindings.bindings.spine_array_bone_data_buffer(nativePtr.cast());
     return BoneData.fromPointer(buffer[index]);
   }
-
 }
 
-/// Array of BonePose elements
+/// ArrayBonePose wrapper
 class ArrayBonePose extends NativeArray<BonePose> {
   ArrayBonePose.fromPointer(Pointer<spine_array_bone_pose_wrapper> super.ptr);
 
@@ -343,19 +364,21 @@ class ArrayBonePose extends NativeArray<BonePose> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer = SpineBindings.bindings.spine_array_bone_pose_buffer(nativePtr.cast());
+    final buffer =
+        SpineBindings.bindings.spine_array_bone_pose_buffer(nativePtr.cast());
     return BonePose.fromPointer(buffer[index]);
   }
-
 }
 
-/// Array of BoundingBoxAttachment elements
+/// ArrayBoundingBoxAttachment wrapper
 class ArrayBoundingBoxAttachment extends NativeArray<BoundingBoxAttachment> {
-  ArrayBoundingBoxAttachment.fromPointer(Pointer<spine_array_bounding_box_attachment_wrapper> super.ptr);
+  ArrayBoundingBoxAttachment.fromPointer(
+      Pointer<spine_array_bounding_box_attachment_wrapper> super.ptr);
 
   @override
   int get length {
-    return SpineBindings.bindings.spine_array_bounding_box_attachment_size(nativePtr.cast());
+    return SpineBindings.bindings
+        .spine_array_bounding_box_attachment_size(nativePtr.cast());
   }
 
   @override
@@ -363,15 +386,16 @@ class ArrayBoundingBoxAttachment extends NativeArray<BoundingBoxAttachment> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer = SpineBindings.bindings.spine_array_bounding_box_attachment_buffer(nativePtr.cast());
+    final buffer = SpineBindings.bindings
+        .spine_array_bounding_box_attachment_buffer(nativePtr.cast());
     return BoundingBoxAttachment.fromPointer(buffer[index]);
   }
-
 }
 
-/// Array of Constraint elements
+/// ArrayConstraint wrapper
 class ArrayConstraint extends NativeArray<Constraint> {
-  ArrayConstraint.fromPointer(Pointer<spine_array_constraint_wrapper> super.ptr);
+  ArrayConstraint.fromPointer(
+      Pointer<spine_array_constraint_wrapper> super.ptr);
 
   @override
   int get length {
@@ -383,19 +407,41 @@ class ArrayConstraint extends NativeArray<Constraint> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer = SpineBindings.bindings.spine_array_constraint_buffer(nativePtr.cast());
-    throw UnsupportedError('Cannot instantiate abstract class Constraint from pointer - no concrete subclasses found');
+    final buffer =
+        SpineBindings.bindings.spine_array_constraint_buffer(nativePtr.cast());
+    final rtti =
+        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());
+      case 'spine_path_constraint':
+        return PathConstraint.fromPointer(buffer[index].cast());
+      case 'spine_physics_constraint':
+        return PhysicsConstraint.fromPointer(buffer[index].cast());
+      case 'spine_slider':
+        return Slider.fromPointer(buffer[index].cast());
+      case 'spine_transform_constraint':
+        return TransformConstraint.fromPointer(buffer[index].cast());
+      default:
+        throw UnsupportedError(
+            'Unknown concrete type: $className for abstract class Constraint');
+    }
   }
-
 }
 
-/// Array of ConstraintData elements
+/// ArrayConstraintData wrapper
 class ArrayConstraintData extends NativeArray<ConstraintData> {
-  ArrayConstraintData.fromPointer(Pointer<spine_array_constraint_data_wrapper> super.ptr);
+  ArrayConstraintData.fromPointer(
+      Pointer<spine_array_constraint_data_wrapper> super.ptr);
 
   @override
   int get length {
-    return SpineBindings.bindings.spine_array_constraint_data_size(nativePtr.cast());
+    return SpineBindings.bindings
+        .spine_array_constraint_data_size(nativePtr.cast());
   }
 
   @override
@@ -403,13 +449,33 @@ class ArrayConstraintData extends NativeArray<ConstraintData> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer = SpineBindings.bindings.spine_array_constraint_data_buffer(nativePtr.cast());
-    throw UnsupportedError('Cannot instantiate abstract class ConstraintData from pointer - no concrete subclasses found');
+    final buffer = SpineBindings.bindings
+        .spine_array_constraint_data_buffer(nativePtr.cast());
+    final rtti =
+        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());
+      case 'spine_path_constraint_data':
+        return PathConstraintData.fromPointer(buffer[index].cast());
+      case 'spine_physics_constraint_data':
+        return PhysicsConstraintData.fromPointer(buffer[index].cast());
+      case 'spine_slider_data':
+        return SliderData.fromPointer(buffer[index].cast());
+      case 'spine_transform_constraint_data':
+        return TransformConstraintData.fromPointer(buffer[index].cast());
+      default:
+        throw UnsupportedError(
+            'Unknown concrete type: $className for abstract class ConstraintData');
+    }
   }
-
 }
 
-/// Array of Event elements
+/// ArrayEvent wrapper
 class ArrayEvent extends NativeArray<Event> {
   ArrayEvent.fromPointer(Pointer<spine_array_event_wrapper> super.ptr);
 
@@ -423,13 +489,13 @@ class ArrayEvent extends NativeArray<Event> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer = SpineBindings.bindings.spine_array_event_buffer(nativePtr.cast());
+    final buffer =
+        SpineBindings.bindings.spine_array_event_buffer(nativePtr.cast());
     return Event.fromPointer(buffer[index]);
   }
-
 }
 
-/// Array of EventData elements
+/// ArrayEventData wrapper
 class ArrayEventData extends NativeArray<EventData> {
   ArrayEventData.fromPointer(Pointer<spine_array_event_data_wrapper> super.ptr);
 
@@ -443,19 +509,21 @@ class ArrayEventData extends NativeArray<EventData> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer = SpineBindings.bindings.spine_array_event_data_buffer(nativePtr.cast());
+    final buffer =
+        SpineBindings.bindings.spine_array_event_data_buffer(nativePtr.cast());
     return EventData.fromPointer(buffer[index]);
   }
-
 }
 
-/// Array of FromProperty elements
+/// ArrayFromProperty wrapper
 class ArrayFromProperty extends NativeArray<FromProperty> {
-  ArrayFromProperty.fromPointer(Pointer<spine_array_from_property_wrapper> super.ptr);
+  ArrayFromProperty.fromPointer(
+      Pointer<spine_array_from_property_wrapper> super.ptr);
 
   @override
   int get length {
-    return SpineBindings.bindings.spine_array_from_property_size(nativePtr.cast());
+    return SpineBindings.bindings
+        .spine_array_from_property_size(nativePtr.cast());
   }
 
   @override
@@ -463,9 +531,14 @@ class ArrayFromProperty extends NativeArray<FromProperty> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer = SpineBindings.bindings.spine_array_from_property_buffer(nativePtr.cast());
-    final rtti = SpineBindings.bindings.spine_from_property_get_rtti(buffer[index]);
-    final className = SpineBindings.bindings.spine_rtti_get_class_name(rtti).cast<Utf8>().toDartString();
+    final buffer = SpineBindings.bindings
+        .spine_array_from_property_buffer(nativePtr.cast());
+    final rtti =
+        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());
@@ -480,19 +553,21 @@ class ArrayFromProperty extends NativeArray<FromProperty> {
       case 'spine_from_y':
         return FromY.fromPointer(buffer[index].cast());
       default:
-        throw UnsupportedError('Unknown concrete type: $className for abstract class FromProperty');
+        throw UnsupportedError(
+            'Unknown concrete type: $className for abstract class FromProperty');
     }
   }
-
 }
 
-/// Array of PhysicsConstraint elements
+/// ArrayPhysicsConstraint wrapper
 class ArrayPhysicsConstraint extends NativeArray<PhysicsConstraint> {
-  ArrayPhysicsConstraint.fromPointer(Pointer<spine_array_physics_constraint_wrapper> super.ptr);
+  ArrayPhysicsConstraint.fromPointer(
+      Pointer<spine_array_physics_constraint_wrapper> super.ptr);
 
   @override
   int get length {
-    return SpineBindings.bindings.spine_array_physics_constraint_size(nativePtr.cast());
+    return SpineBindings.bindings
+        .spine_array_physics_constraint_size(nativePtr.cast());
   }
 
   @override
@@ -500,13 +575,13 @@ class ArrayPhysicsConstraint extends NativeArray<PhysicsConstraint> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer = SpineBindings.bindings.spine_array_physics_constraint_buffer(nativePtr.cast());
+    final buffer = SpineBindings.bindings
+        .spine_array_physics_constraint_buffer(nativePtr.cast());
     return PhysicsConstraint.fromPointer(buffer[index]);
   }
-
 }
 
-/// Array of Polygon elements
+/// ArrayPolygon wrapper
 class ArrayPolygon extends NativeArray<Polygon> {
   ArrayPolygon.fromPointer(Pointer<spine_array_polygon_wrapper> super.ptr);
 
@@ -520,13 +595,13 @@ class ArrayPolygon extends NativeArray<Polygon> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer = SpineBindings.bindings.spine_array_polygon_buffer(nativePtr.cast());
+    final buffer =
+        SpineBindings.bindings.spine_array_polygon_buffer(nativePtr.cast());
     return Polygon.fromPointer(buffer[index]);
   }
-
 }
 
-/// Array of Skin elements
+/// ArraySkin wrapper
 class ArraySkin extends NativeArray<Skin> {
   ArraySkin.fromPointer(Pointer<spine_array_skin_wrapper> super.ptr);
 
@@ -540,13 +615,13 @@ class ArraySkin extends NativeArray<Skin> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer = SpineBindings.bindings.spine_array_skin_buffer(nativePtr.cast());
+    final buffer =
+        SpineBindings.bindings.spine_array_skin_buffer(nativePtr.cast());
     return Skin.fromPointer(buffer[index]);
   }
-
 }
 
-/// Array of Slot elements
+/// ArraySlot wrapper
 class ArraySlot extends NativeArray<Slot> {
   ArraySlot.fromPointer(Pointer<spine_array_slot_wrapper> super.ptr);
 
@@ -560,13 +635,13 @@ class ArraySlot extends NativeArray<Slot> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer = SpineBindings.bindings.spine_array_slot_buffer(nativePtr.cast());
+    final buffer =
+        SpineBindings.bindings.spine_array_slot_buffer(nativePtr.cast());
     return Slot.fromPointer(buffer[index]);
   }
-
 }
 
-/// Array of SlotData elements
+/// ArraySlotData wrapper
 class ArraySlotData extends NativeArray<SlotData> {
   ArraySlotData.fromPointer(Pointer<spine_array_slot_data_wrapper> super.ptr);
 
@@ -580,19 +655,21 @@ class ArraySlotData extends NativeArray<SlotData> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer = SpineBindings.bindings.spine_array_slot_data_buffer(nativePtr.cast());
+    final buffer =
+        SpineBindings.bindings.spine_array_slot_data_buffer(nativePtr.cast());
     return SlotData.fromPointer(buffer[index]);
   }
-
 }
 
-/// Array of TextureRegion elements
+/// ArrayTextureRegion wrapper
 class ArrayTextureRegion extends NativeArray<TextureRegion> {
-  ArrayTextureRegion.fromPointer(Pointer<spine_array_texture_region_wrapper> super.ptr);
+  ArrayTextureRegion.fromPointer(
+      Pointer<spine_array_texture_region_wrapper> super.ptr);
 
   @override
   int get length {
-    return SpineBindings.bindings.spine_array_texture_region_size(nativePtr.cast());
+    return SpineBindings.bindings
+        .spine_array_texture_region_size(nativePtr.cast());
   }
 
   @override
@@ -600,13 +677,13 @@ class ArrayTextureRegion extends NativeArray<TextureRegion> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer = SpineBindings.bindings.spine_array_texture_region_buffer(nativePtr.cast());
+    final buffer = SpineBindings.bindings
+        .spine_array_texture_region_buffer(nativePtr.cast());
     return TextureRegion.fromPointer(buffer[index]);
   }
-
 }
 
-/// Array of Timeline elements
+/// ArrayTimeline wrapper
 class ArrayTimeline extends NativeArray<Timeline> {
   ArrayTimeline.fromPointer(Pointer<spine_array_timeline_wrapper> super.ptr);
 
@@ -620,62 +697,54 @@ class ArrayTimeline extends NativeArray<Timeline> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer = SpineBindings.bindings.spine_array_timeline_buffer(nativePtr.cast());
+    final buffer =
+        SpineBindings.bindings.spine_array_timeline_buffer(nativePtr.cast());
     final rtti = SpineBindings.bindings.spine_timeline_get_rtti(buffer[index]);
-    final className = SpineBindings.bindings.spine_rtti_get_class_name(rtti).cast<Utf8>().toDartString();
+    final className = SpineBindings.bindings
+        .spine_rtti_get_class_name(rtti)
+        .cast<Utf8>()
+        .toDartString();
     switch (className) {
-      case 'spine_attachment_timeline':
-        return AttachmentTimeline.fromPointer(buffer[index].cast());
       case 'spine_alpha_timeline':
         return AlphaTimeline.fromPointer(buffer[index].cast());
-      case 'spine_rotate_timeline':
-        return RotateTimeline.fromPointer(buffer[index].cast());
-      case 'spine_scale_x_timeline':
-        return ScaleXTimeline.fromPointer(buffer[index].cast());
-      case 'spine_scale_y_timeline':
-        return ScaleYTimeline.fromPointer(buffer[index].cast());
-      case 'spine_shear_x_timeline':
-        return ShearXTimeline.fromPointer(buffer[index].cast());
-      case 'spine_shear_y_timeline':
-        return ShearYTimeline.fromPointer(buffer[index].cast());
-      case 'spine_translate_x_timeline':
-        return TranslateXTimeline.fromPointer(buffer[index].cast());
-      case 'spine_translate_y_timeline':
-        return TranslateYTimeline.fromPointer(buffer[index].cast());
+      case 'spine_attachment_timeline':
+        return AttachmentTimeline.fromPointer(buffer[index].cast());
+      case 'spine_deform_timeline':
+        return DeformTimeline.fromPointer(buffer[index].cast());
+      case 'spine_draw_order_timeline':
+        return DrawOrderTimeline.fromPointer(buffer[index].cast());
+      case 'spine_event_timeline':
+        return EventTimeline.fromPointer(buffer[index].cast());
+      case 'spine_ik_constraint_timeline':
+        return IkConstraintTimeline.fromPointer(buffer[index].cast());
+      case 'spine_inherit_timeline':
+        return InheritTimeline.fromPointer(buffer[index].cast());
+      case 'spine_path_constraint_mix_timeline':
+        return PathConstraintMixTimeline.fromPointer(buffer[index].cast());
       case 'spine_path_constraint_position_timeline':
         return PathConstraintPositionTimeline.fromPointer(buffer[index].cast());
       case 'spine_path_constraint_spacing_timeline':
         return PathConstraintSpacingTimeline.fromPointer(buffer[index].cast());
-      case 'spine_slider_mix_timeline':
-        return SliderMixTimeline.fromPointer(buffer[index].cast());
-      case 'spine_slider_timeline':
-        return SliderTimeline.fromPointer(buffer[index].cast());
       case 'spine_physics_constraint_damping_timeline':
-        return PhysicsConstraintDampingTimeline.fromPointer(buffer[index].cast());
+        return PhysicsConstraintDampingTimeline.fromPointer(
+            buffer[index].cast());
       case 'spine_physics_constraint_gravity_timeline':
-        return PhysicsConstraintGravityTimeline.fromPointer(buffer[index].cast());
+        return PhysicsConstraintGravityTimeline.fromPointer(
+            buffer[index].cast());
       case 'spine_physics_constraint_inertia_timeline':
-        return PhysicsConstraintInertiaTimeline.fromPointer(buffer[index].cast());
+        return PhysicsConstraintInertiaTimeline.fromPointer(
+            buffer[index].cast());
       case 'spine_physics_constraint_mass_timeline':
         return PhysicsConstraintMassTimeline.fromPointer(buffer[index].cast());
       case 'spine_physics_constraint_mix_timeline':
         return PhysicsConstraintMixTimeline.fromPointer(buffer[index].cast());
+      case 'spine_physics_constraint_reset_timeline':
+        return PhysicsConstraintResetTimeline.fromPointer(buffer[index].cast());
       case 'spine_physics_constraint_strength_timeline':
-        return PhysicsConstraintStrengthTimeline.fromPointer(buffer[index].cast());
+        return PhysicsConstraintStrengthTimeline.fromPointer(
+            buffer[index].cast());
       case 'spine_physics_constraint_wind_timeline':
         return PhysicsConstraintWindTimeline.fromPointer(buffer[index].cast());
-      case 'spine_scale_timeline':
-        return ScaleTimeline.fromPointer(buffer[index].cast());
-      case 'spine_shear_timeline':
-        return ShearTimeline.fromPointer(buffer[index].cast());
-      case 'spine_translate_timeline':
-        return TranslateTimeline.fromPointer(buffer[index].cast());
-      case 'spine_ik_constraint_timeline':
-        return IkConstraintTimeline.fromPointer(buffer[index].cast());
-      case 'spine_path_constraint_mix_timeline':
-        return PathConstraintMixTimeline.fromPointer(buffer[index].cast());
-      case 'spine_deform_timeline':
-        return DeformTimeline.fromPointer(buffer[index].cast());
       case 'spine_rgb2_timeline':
         return Rgb2Timeline.fromPointer(buffer[index].cast());
       case 'spine_rgba2_timeline':
@@ -684,32 +753,50 @@ class ArrayTimeline extends NativeArray<Timeline> {
         return RgbaTimeline.fromPointer(buffer[index].cast());
       case 'spine_rgb_timeline':
         return RgbTimeline.fromPointer(buffer[index].cast());
-      case 'spine_transform_constraint_timeline':
-        return TransformConstraintTimeline.fromPointer(buffer[index].cast());
-      case 'spine_draw_order_timeline':
-        return DrawOrderTimeline.fromPointer(buffer[index].cast());
-      case 'spine_event_timeline':
-        return EventTimeline.fromPointer(buffer[index].cast());
-      case 'spine_inherit_timeline':
-        return InheritTimeline.fromPointer(buffer[index].cast());
-      case 'spine_physics_constraint_reset_timeline':
-        return PhysicsConstraintResetTimeline.fromPointer(buffer[index].cast());
+      case 'spine_rotate_timeline':
+        return RotateTimeline.fromPointer(buffer[index].cast());
+      case 'spine_scale_timeline':
+        return ScaleTimeline.fromPointer(buffer[index].cast());
+      case 'spine_scale_x_timeline':
+        return ScaleXTimeline.fromPointer(buffer[index].cast());
+      case 'spine_scale_y_timeline':
+        return ScaleYTimeline.fromPointer(buffer[index].cast());
       case 'spine_sequence_timeline':
         return SequenceTimeline.fromPointer(buffer[index].cast());
+      case 'spine_shear_timeline':
+        return ShearTimeline.fromPointer(buffer[index].cast());
+      case 'spine_shear_x_timeline':
+        return ShearXTimeline.fromPointer(buffer[index].cast());
+      case 'spine_shear_y_timeline':
+        return ShearYTimeline.fromPointer(buffer[index].cast());
+      case 'spine_slider_mix_timeline':
+        return SliderMixTimeline.fromPointer(buffer[index].cast());
+      case 'spine_slider_timeline':
+        return SliderTimeline.fromPointer(buffer[index].cast());
+      case 'spine_transform_constraint_timeline':
+        return TransformConstraintTimeline.fromPointer(buffer[index].cast());
+      case 'spine_translate_timeline':
+        return TranslateTimeline.fromPointer(buffer[index].cast());
+      case 'spine_translate_x_timeline':
+        return TranslateXTimeline.fromPointer(buffer[index].cast());
+      case 'spine_translate_y_timeline':
+        return TranslateYTimeline.fromPointer(buffer[index].cast());
       default:
-        throw UnsupportedError('Unknown concrete type: $className for abstract class Timeline');
+        throw UnsupportedError(
+            'Unknown concrete type: $className for abstract class Timeline');
     }
   }
-
 }
 
-/// Array of ToProperty elements
+/// ArrayToProperty wrapper
 class ArrayToProperty extends NativeArray<ToProperty> {
-  ArrayToProperty.fromPointer(Pointer<spine_array_to_property_wrapper> super.ptr);
+  ArrayToProperty.fromPointer(
+      Pointer<spine_array_to_property_wrapper> super.ptr);
 
   @override
   int get length {
-    return SpineBindings.bindings.spine_array_to_property_size(nativePtr.cast());
+    return SpineBindings.bindings
+        .spine_array_to_property_size(nativePtr.cast());
   }
 
   @override
@@ -717,9 +804,14 @@ class ArrayToProperty extends NativeArray<ToProperty> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer = SpineBindings.bindings.spine_array_to_property_buffer(nativePtr.cast());
-    final rtti = SpineBindings.bindings.spine_to_property_get_rtti(buffer[index]);
-    final className = SpineBindings.bindings.spine_rtti_get_class_name(rtti).cast<Utf8>().toDartString();
+    final buffer =
+        SpineBindings.bindings.spine_array_to_property_buffer(nativePtr.cast());
+    final rtti =
+        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());
@@ -734,19 +826,21 @@ class ArrayToProperty extends NativeArray<ToProperty> {
       case 'spine_to_y':
         return ToY.fromPointer(buffer[index].cast());
       default:
-        throw UnsupportedError('Unknown concrete type: $className for abstract class ToProperty');
+        throw UnsupportedError(
+            'Unknown concrete type: $className for abstract class ToProperty');
     }
   }
-
 }
 
-/// Array of TrackEntry elements
+/// ArrayTrackEntry wrapper
 class ArrayTrackEntry extends NativeArray<TrackEntry> {
-  ArrayTrackEntry.fromPointer(Pointer<spine_array_track_entry_wrapper> super.ptr);
+  ArrayTrackEntry.fromPointer(
+      Pointer<spine_array_track_entry_wrapper> super.ptr);
 
   @override
   int get length {
-    return SpineBindings.bindings.spine_array_track_entry_size(nativePtr.cast());
+    return SpineBindings.bindings
+        .spine_array_track_entry_size(nativePtr.cast());
   }
 
   @override
@@ -754,13 +848,13 @@ class ArrayTrackEntry extends NativeArray<TrackEntry> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer = SpineBindings.bindings.spine_array_track_entry_buffer(nativePtr.cast());
+    final buffer =
+        SpineBindings.bindings.spine_array_track_entry_buffer(nativePtr.cast());
     return TrackEntry.fromPointer(buffer[index]);
   }
-
 }
 
-/// Array of Update elements
+/// ArrayUpdate wrapper
 class ArrayUpdate extends NativeArray<Update> {
   ArrayUpdate.fromPointer(Pointer<spine_array_update_wrapper> super.ptr);
 
@@ -774,8 +868,31 @@ class ArrayUpdate extends NativeArray<Update> {
     if (index < 0 || index >= length) {
       throw RangeError.index(index, this, 'index');
     }
-    final buffer = SpineBindings.bindings.spine_array_update_buffer(nativePtr.cast());
-    throw UnsupportedError('Cannot instantiate abstract class Update from pointer - no concrete subclasses found');
+    final buffer =
+        SpineBindings.bindings.spine_array_update_buffer(nativePtr.cast());
+    final rtti = SpineBindings.bindings.spine_update_get_rtti(buffer[index]);
+    final className = SpineBindings.bindings
+        .spine_rtti_get_class_name(rtti)
+        .cast<Utf8>()
+        .toDartString();
+    switch (className) {
+      case 'spine_bone':
+        return Bone.fromPointer(buffer[index].cast());
+      case 'spine_bone_pose':
+        return BonePose.fromPointer(buffer[index].cast());
+      case 'spine_ik_constraint':
+        return IkConstraint.fromPointer(buffer[index].cast());
+      case 'spine_path_constraint':
+        return PathConstraint.fromPointer(buffer[index].cast());
+      case 'spine_physics_constraint':
+        return PhysicsConstraint.fromPointer(buffer[index].cast());
+      case 'spine_slider':
+        return Slider.fromPointer(buffer[index].cast());
+      case 'spine_transform_constraint':
+        return TransformConstraint.fromPointer(buffer[index].cast());
+      default:
+        throw UnsupportedError(
+            'Unknown concrete type: $className for abstract class Update');
+    }
   }
-
-}
+}

spine-flutter/lib/generated/atlas.dart

@@ -31,10 +31,10 @@
 
 import 'dart:ffi';
 import 'package:ffi/ffi.dart';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
-import 'atlas_region.dart';
 import 'arrays.dart';
+import 'atlas_region.dart';
 
 /// Atlas wrapper
 class Atlas implements Finalizable {
@@ -50,7 +50,8 @@ class Atlas implements Finalizable {
   }
 
   AtlasRegion findRegion(String name) {
-    final result = SpineBindings.bindings.spine_atlas_find_region(_ptr, name.toNativeUtf8().cast<Char>());
+    final result = SpineBindings.bindings
+        .spine_atlas_find_region(_ptr, name.toNativeUtf8().cast<Char>());
     return AtlasRegion.fromPointer(result);
   }
 
@@ -63,5 +64,4 @@ class Atlas implements Finalizable {
     final result = SpineBindings.bindings.spine_atlas_get_regions(_ptr);
     return ArrayAtlasRegion.fromPointer(result);
   }
-
-}
+}

spine-flutter/lib/generated/atlas_attachment_loader.dart

@@ -31,34 +31,98 @@
 
 import 'dart:ffi';
 import 'package:ffi/ffi.dart';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
-import 'attachment_loader.dart';
-import 'atlas_region.dart';
 import 'atlas.dart';
+import 'atlas_region.dart';
+import 'attachment_loader.dart';
+import 'bounding_box_attachment.dart';
+import 'clipping_attachment.dart';
+import 'mesh_attachment.dart';
+import 'path_attachment.dart';
+import 'point_attachment.dart';
+import 'region_attachment.dart';
+import 'sequence.dart';
+import 'skin.dart';
 
 /// AtlasAttachmentLoader wrapper
-class AtlasAttachmentLoader extends AttachmentLoader {
+class AtlasAttachmentLoader implements Finalizable, AttachmentLoader {
   final Pointer<spine_atlas_attachment_loader_wrapper> _ptr;
 
-  AtlasAttachmentLoader.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
+  AtlasAttachmentLoader.fromPointer(this._ptr);
 
   /// Get the native pointer for FFI calls
   @override
   Pointer get nativePtr => _ptr;
 
   factory AtlasAttachmentLoader(Atlas atlas) {
-    final ptr = SpineBindings.bindings.spine_atlas_attachment_loader_create(atlas.nativePtr.cast());
+    final ptr = SpineBindings.bindings
+        .spine_atlas_attachment_loader_create(atlas.nativePtr.cast());
     return AtlasAttachmentLoader.fromPointer(ptr);
   }
 
-  AtlasRegion findRegion(String name) {
-    final result = SpineBindings.bindings.spine_atlas_attachment_loader_find_region(_ptr, name.toNativeUtf8().cast<Char>());
-    return AtlasRegion.fromPointer(result);
+  @override
+  RegionAttachment newRegionAttachment(
+      Skin skin, String name, String path, Sequence sequence) {
+    final result = SpineBindings.bindings
+        .spine_atlas_attachment_loader_new_region_attachment(
+            _ptr,
+            skin.nativePtr.cast(),
+            name.toNativeUtf8().cast<Char>(),
+            path.toNativeUtf8().cast<Char>(),
+            sequence.nativePtr.cast());
+    return RegionAttachment.fromPointer(result);
   }
 
   @override
-  void dispose() {
-    SpineBindings.bindings.spine_atlas_attachment_loader_dispose(_ptr);
+  MeshAttachment newMeshAttachment(
+      Skin skin, String name, String path, Sequence sequence) {
+    final result = SpineBindings.bindings
+        .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
+        .spine_atlas_attachment_loader_new_bounding_box_attachment(
+            _ptr, skin.nativePtr.cast(), name.toNativeUtf8().cast<Char>());
+    return BoundingBoxAttachment.fromPointer(result);
+  }
+
+  @override
+  PathAttachment newPathAttachment(Skin skin, String name) {
+    final result = SpineBindings.bindings
+        .spine_atlas_attachment_loader_new_path_attachment(
+            _ptr, skin.nativePtr.cast(), name.toNativeUtf8().cast<Char>());
+    return PathAttachment.fromPointer(result);
+  }
+
+  @override
+  PointAttachment newPointAttachment(Skin skin, String name) {
+    final result = SpineBindings.bindings
+        .spine_atlas_attachment_loader_new_point_attachment(
+            _ptr, skin.nativePtr.cast(), name.toNativeUtf8().cast<Char>());
+    return PointAttachment.fromPointer(result);
+  }
+
+  @override
+  ClippingAttachment newClippingAttachment(Skin skin, String name) {
+    final result = SpineBindings.bindings
+        .spine_atlas_attachment_loader_new_clipping_attachment(
+            _ptr, skin.nativePtr.cast(), name.toNativeUtf8().cast<Char>());
+    return ClippingAttachment.fromPointer(result);
+  }
+
+  AtlasRegion findRegion(String name) {
+    final result = SpineBindings.bindings
+        .spine_atlas_attachment_loader_find_region(
+            _ptr, name.toNativeUtf8().cast<Char>());
+    return AtlasRegion.fromPointer(result);
+  }
+}

spine-flutter/lib/generated/atlas_page.dart

@@ -31,7 +31,7 @@
 
 import 'dart:ffi';
 import 'package:ffi/ffi.dart';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 import 'format.dart';
 import 'texture_filter.dart';
@@ -47,7 +47,8 @@ class AtlasPage implements Finalizable {
   Pointer get nativePtr => _ptr;
 
   factory AtlasPage(String inName) {
-    final ptr = SpineBindings.bindings.spine_atlas_page_create(inName.toNativeUtf8().cast<Char>());
+    final ptr = SpineBindings.bindings
+        .spine_atlas_page_create(inName.toNativeUtf8().cast<Char>());
     return AtlasPage.fromPointer(ptr);
   }
 
@@ -57,16 +58,19 @@ class AtlasPage implements Finalizable {
   }
 
   set name(String value) {
-    SpineBindings.bindings.spine_atlas_page_set_name(_ptr, value.toNativeUtf8().cast<Char>());
+    SpineBindings.bindings
+        .spine_atlas_page_set_name(_ptr, value.toNativeUtf8().cast<Char>());
   }
 
   String get texturePath {
-    final result = SpineBindings.bindings.spine_atlas_page_get_texture_path(_ptr);
+    final result =
+        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(_ptr, value.toNativeUtf8().cast<Char>());
+    SpineBindings.bindings.spine_atlas_page_set_texture_path(
+        _ptr, value.toNativeUtf8().cast<Char>());
   }
 
   Format get format {
@@ -150,7 +154,8 @@ class AtlasPage implements Finalizable {
     SpineBindings.bindings.spine_atlas_page_set_index(_ptr, value);
   }
 
-  void dispose() {
-    SpineBindings.bindings.spine_atlas_page_dispose(_ptr);
+  Pointer<Void> get texture {
+    final result = SpineBindings.bindings.spine_atlas_page_get_texture(_ptr);
+    return result;
   }
-}
+}

spine-flutter/lib/generated/atlas_region.dart

@@ -31,11 +31,11 @@
 
 import 'dart:ffi';
 import 'package:ffi/ffi.dart';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
-import 'texture_region.dart';
-import 'atlas_page.dart';
 import 'arrays.dart';
+import 'atlas_page.dart';
+import 'texture_region.dart';
 
 /// AtlasRegion wrapper
 class AtlasRegion extends TextureRegion {
@@ -57,6 +57,11 @@ class AtlasRegion extends TextureRegion {
     return AtlasPage.fromPointer(result);
   }
 
+  String get name {
+    final result = SpineBindings.bindings.spine_atlas_region_get_name(_ptr);
+    return result.cast<Utf8>().toDartString();
+  }
+
   int get index {
     final result = SpineBindings.bindings.spine_atlas_region_get_index(_ptr);
     return result;
@@ -83,22 +88,26 @@ class AtlasRegion extends TextureRegion {
   }
 
   int get packedWidth {
-    final result = SpineBindings.bindings.spine_atlas_region_get_packed_width(_ptr);
+    final result =
+        SpineBindings.bindings.spine_atlas_region_get_packed_width(_ptr);
     return result;
   }
 
   int get packedHeight {
-    final result = SpineBindings.bindings.spine_atlas_region_get_packed_height(_ptr);
+    final result =
+        SpineBindings.bindings.spine_atlas_region_get_packed_height(_ptr);
     return result;
   }
 
   int get originalWidth {
-    final result = SpineBindings.bindings.spine_atlas_region_get_original_width(_ptr);
+    final result =
+        SpineBindings.bindings.spine_atlas_region_get_original_width(_ptr);
     return result;
   }
 
   int get originalHeight {
-    final result = SpineBindings.bindings.spine_atlas_region_get_original_height(_ptr);
+    final result =
+        SpineBindings.bindings.spine_atlas_region_get_original_height(_ptr);
     return result;
   }
 
@@ -128,11 +137,13 @@ class AtlasRegion extends TextureRegion {
   }
 
   set page(AtlasPage value) {
-    SpineBindings.bindings.spine_atlas_region_set_page(_ptr, value.nativePtr.cast());
+    SpineBindings.bindings
+        .spine_atlas_region_set_page(_ptr, value.nativePtr.cast());
   }
 
   set name(String value) {
-    SpineBindings.bindings.spine_atlas_region_set_name(_ptr, value.toNativeUtf8().cast<Char>());
+    SpineBindings.bindings
+        .spine_atlas_region_set_name(_ptr, value.toNativeUtf8().cast<Char>());
   }
 
   set index(int value) {
@@ -180,19 +191,17 @@ class AtlasRegion extends TextureRegion {
   }
 
   set splits(ArrayInt value) {
-    SpineBindings.bindings.spine_atlas_region_set_splits(_ptr, value.nativePtr.cast());
+    SpineBindings.bindings
+        .spine_atlas_region_set_splits(_ptr, value.nativePtr.cast());
   }
 
   set pads(ArrayInt value) {
-    SpineBindings.bindings.spine_atlas_region_set_pads(_ptr, value.nativePtr.cast());
+    SpineBindings.bindings
+        .spine_atlas_region_set_pads(_ptr, value.nativePtr.cast());
   }
 
   set values(ArrayFloat value) {
-    SpineBindings.bindings.spine_atlas_region_set_values(_ptr, value.nativePtr.cast());
+    SpineBindings.bindings
+        .spine_atlas_region_set_values(_ptr, value.nativePtr.cast());
   }
-
-  @override
-  void dispose() {
-    SpineBindings.bindings.spine_atlas_region_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/attachment.dart

@@ -31,15 +31,15 @@
 
 import 'dart:ffi';
 import 'package:ffi/ffi.dart';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 import 'rtti.dart';
-import 'point_attachment.dart';
-import 'region_attachment.dart';
 import 'bounding_box_attachment.dart';
 import 'clipping_attachment.dart';
 import 'mesh_attachment.dart';
 import 'path_attachment.dart';
+import 'point_attachment.dart';
+import 'region_attachment.dart';
 
 /// Attachment wrapper
 abstract class Attachment implements Finalizable {
@@ -63,12 +63,11 @@ 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.spine_rtti_get_class_name(rtti).cast<Utf8>().toDartString();
+    final className = SpineBindings.bindings
+        .spine_rtti_get_class_name(rtti)
+        .cast<Utf8>()
+        .toDartString();
     switch (className) {
-      case 'spine_point_attachment':
-        return PointAttachment.fromPointer(result.cast());
-      case 'spine_region_attachment':
-        return RegionAttachment.fromPointer(result.cast());
       case 'spine_bounding_box_attachment':
         return BoundingBoxAttachment.fromPointer(result.cast());
       case 'spine_clipping_attachment':
@@ -77,8 +76,13 @@ abstract class Attachment implements Finalizable {
         return MeshAttachment.fromPointer(result.cast());
       case 'spine_path_attachment':
         return PathAttachment.fromPointer(result.cast());
+      case 'spine_point_attachment':
+        return PointAttachment.fromPointer(result.cast());
+      case 'spine_region_attachment':
+        return RegionAttachment.fromPointer(result.cast());
       default:
-        throw UnsupportedError('Unknown concrete type: $className for abstract class Attachment');
+        throw UnsupportedError(
+            'Unknown concrete type: $className for abstract class Attachment');
     }
   }
 
@@ -99,8 +103,4 @@ abstract class Attachment implements Finalizable {
     final result = SpineBindings.bindings.spine_attachment_rtti();
     return Rtti.fromPointer(result);
   }
-
-  void dispose() {
-    SpineBindings.bindings.spine_attachment_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/attachment_loader.dart

@@ -30,58 +30,24 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'package:ffi/ffi.dart';
-import 'spine_flutter_bindings_generated.dart';
-import '../spine_bindings.dart';
-import 'region_attachment.dart';
-import 'skin.dart';
-import 'sequence.dart';
-import 'mesh_attachment.dart';
 import 'bounding_box_attachment.dart';
+import 'clipping_attachment.dart';
+import 'mesh_attachment.dart';
 import 'path_attachment.dart';
 import 'point_attachment.dart';
-import 'clipping_attachment.dart';
+import 'region_attachment.dart';
+import 'sequence.dart';
+import 'skin.dart';
 
 /// AttachmentLoader wrapper
-abstract class AttachmentLoader implements Finalizable {
-  final Pointer<spine_attachment_loader_wrapper> _ptr;
-
-  AttachmentLoader.fromPointer(this._ptr);
-
-  /// Get the native pointer for FFI calls
-  Pointer get nativePtr => _ptr;
-
-  RegionAttachment newRegionAttachment(Skin skin, String name, String path, Sequence sequence) {
-    final result = SpineBindings.bindings.spine_attachment_loader_new_region_attachment(_ptr, skin.nativePtr.cast(), name.toNativeUtf8().cast<Char>(), path.toNativeUtf8().cast<Char>(), sequence.nativePtr.cast());
-    return RegionAttachment.fromPointer(result);
-  }
-
-  MeshAttachment newMeshAttachment(Skin skin, String name, String path, Sequence sequence) {
-    final result = SpineBindings.bindings.spine_attachment_loader_new_mesh_attachment(_ptr, skin.nativePtr.cast(), name.toNativeUtf8().cast<Char>(), path.toNativeUtf8().cast<Char>(), sequence.nativePtr.cast());
-    return MeshAttachment.fromPointer(result);
-  }
-
-  BoundingBoxAttachment newBoundingBoxAttachment(Skin skin, String name) {
-    final result = SpineBindings.bindings.spine_attachment_loader_new_bounding_box_attachment(_ptr, skin.nativePtr.cast(), name.toNativeUtf8().cast<Char>());
-    return BoundingBoxAttachment.fromPointer(result);
-  }
-
-  PathAttachment newPathAttachment(Skin skin, String name) {
-    final result = SpineBindings.bindings.spine_attachment_loader_new_path_attachment(_ptr, skin.nativePtr.cast(), name.toNativeUtf8().cast<Char>());
-    return PathAttachment.fromPointer(result);
-  }
-
-  PointAttachment newPointAttachment(Skin skin, String name) {
-    final result = SpineBindings.bindings.spine_attachment_loader_new_point_attachment(_ptr, skin.nativePtr.cast(), name.toNativeUtf8().cast<Char>());
-    return PointAttachment.fromPointer(result);
-  }
-
-  ClippingAttachment newClippingAttachment(Skin skin, String name) {
-    final result = SpineBindings.bindings.spine_attachment_loader_new_clipping_attachment(_ptr, skin.nativePtr.cast(), name.toNativeUtf8().cast<Char>());
-    return ClippingAttachment.fromPointer(result);
-  }
-
-  void dispose() {
-    SpineBindings.bindings.spine_attachment_loader_dispose(_ptr);
-  }
-}
+abstract class AttachmentLoader {
+  Pointer get nativePtr;
+  RegionAttachment newRegionAttachment(
+      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);
+  ClippingAttachment newClippingAttachment(Skin skin, String name);
+}

spine-flutter/lib/generated/attachment_timeline.dart

@@ -31,12 +31,13 @@
 
 import 'dart:ffi';
 import 'package:ffi/ffi.dart';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
+import 'slot_timeline.dart';
 import 'timeline.dart';
 
 /// AttachmentTimeline wrapper
-class AttachmentTimeline extends Timeline {
+class AttachmentTimeline extends Timeline implements SlotTimeline {
   final Pointer<spine_attachment_timeline_wrapper> _ptr;
 
   AttachmentTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
@@ -46,25 +47,26 @@ class AttachmentTimeline extends Timeline {
   Pointer get nativePtr => _ptr;
 
   factory AttachmentTimeline(int frameCount, int slotIndex) {
-    final ptr = SpineBindings.bindings.spine_attachment_timeline_create(frameCount, slotIndex);
+    final ptr = SpineBindings.bindings
+        .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(_ptr, frame, time, attachmentName.toNativeUtf8().cast<Char>());
-  }
-
-  int get slotIndex {
-    final result = SpineBindings.bindings.spine_attachment_timeline_get_slot_index(_ptr);
-    return result;
-  }
-
-  set slotIndex(int value) {
-    SpineBindings.bindings.spine_attachment_timeline_set_slot_index(_ptr, value);
+    SpineBindings.bindings.spine_attachment_timeline_set_frame(
+        _ptr, frame, time, attachmentName.toNativeUtf8().cast<Char>());
   }
 
   @override
-  void dispose() {
-    SpineBindings.bindings.spine_attachment_timeline_dispose(_ptr);
+  int get slotIndex {
+    final result =
+        SpineBindings.bindings.spine_attachment_timeline_get_slot_index(_ptr);
+    return result;
   }
-}
+
+  @override
+  set slotIndex(int value) {
+    SpineBindings.bindings
+        .spine_attachment_timeline_set_slot_index(_ptr, value);
+  }
+}

spine-flutter/lib/generated/attachment_type.dart

@@ -32,12 +32,12 @@
 /// AttachmentType enum
 enum AttachmentType {
   region(0),
-  boundingbox(1),
-  mesh(2),
-  linkedmesh(3),
-  path(4),
-  point(5),
-  clipping(6);
+  boundingbox(0),
+  mesh(0),
+  linkedmesh(0),
+  path(0),
+  point(0),
+  clipping(0);
 
   const AttachmentType(this.value);
   final int value;
@@ -48,4 +48,4 @@ enum AttachmentType {
       orElse: () => throw ArgumentError('Invalid AttachmentType value: $value'),
     );
   }
-}
+}

spine-flutter/lib/generated/blend_mode.dart

@@ -32,9 +32,9 @@
 /// BlendMode enum
 enum BlendMode {
   normal(0),
-  additive(1),
-  multiply(2),
-  screen(3);
+  additive(0),
+  multiply(0),
+  screen(0);
 
   const BlendMode(this.value);
   final int value;
@@ -45,4 +45,4 @@ enum BlendMode {
       orElse: () => throw ArgumentError('Invalid BlendMode value: $value'),
     );
   }
-}
+}

spine-flutter/lib/generated/bone.dart

@@ -30,19 +30,21 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 import 'rtti.dart';
-import 'posed_active.dart';
-import 'skeleton.dart';
-import 'physics.dart';
+import 'arrays.dart';
 import 'bone_data.dart';
 import 'bone_local.dart';
 import 'bone_pose.dart';
-import 'arrays.dart';
+import 'physics.dart';
+import 'posed.dart';
+import 'posed_active.dart';
+import 'skeleton.dart';
+import 'update.dart';
 
 /// Bone wrapper
-class Bone extends PosedActive {
+class Bone extends PosedActive implements Posed, Update {
   final Pointer<spine_bone_wrapper> _ptr;
 
   Bone.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
@@ -52,15 +54,18 @@ class Bone extends PosedActive {
   Pointer get nativePtr => _ptr;
 
   factory Bone(BoneData data, Bone parent) {
-    final ptr = SpineBindings.bindings.spine_bone_create(data.nativePtr.cast(), parent.nativePtr.cast());
+    final ptr = SpineBindings.bindings
+        .spine_bone_create(data.nativePtr.cast(), parent.nativePtr.cast());
     return Bone.fromPointer(ptr);
   }
 
   factory Bone.from(Bone bone, Bone parent) {
-    final ptr = SpineBindings.bindings.spine_bone_create2(bone.nativePtr.cast(), parent.nativePtr.cast());
+    final ptr = SpineBindings.bindings
+        .spine_bone_create2(bone.nativePtr.cast(), parent.nativePtr.cast());
     return Bone.fromPointer(ptr);
   }
 
+  @override
   Rtti get rtti {
     final result = SpineBindings.bindings.spine_bone_get_rtti(_ptr);
     return Rtti.fromPointer(result);
@@ -85,8 +90,10 @@ class Bone extends PosedActive {
     SpineBindings.bindings.spine_bone_set_y_down(value);
   }
 
+  @override
   void update(Skeleton skeleton, Physics physics) {
-    SpineBindings.bindings.spine_bone_update(_ptr, skeleton.nativePtr.cast(), physics.value);
+    SpineBindings.bindings
+        .spine_bone_update(_ptr, skeleton.nativePtr.cast(), physics.value);
   }
 
   BoneData get data {
@@ -104,16 +111,20 @@ class Bone extends PosedActive {
     return BonePose.fromPointer(result);
   }
 
+  @override
   void resetConstrained() {
     SpineBindings.bindings.spine_bone_reset_constrained(_ptr);
   }
 
+  @override
   void constrained() {
     SpineBindings.bindings.spine_bone_constrained(_ptr);
   }
 
+  @override
   bool get isPoseEqualToApplied {
-    final result = SpineBindings.bindings.spine_bone_is_pose_equal_to_applied(_ptr);
+    final result =
+        SpineBindings.bindings.spine_bone_is_pose_equal_to_applied(_ptr);
     return result;
   }
 
@@ -121,9 +132,4 @@ class Bone extends PosedActive {
     final result = SpineBindings.bindings.spine_bone_rtti();
     return Rtti.fromPointer(result);
   }
-
-  @override
-  void dispose() {
-    SpineBindings.bindings.spine_bone_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/bone_data.dart

@@ -31,22 +31,25 @@
 
 import 'dart:ffi';
 import 'package:ffi/ffi.dart';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
-import 'color.dart';
 import 'bone_local.dart';
+import 'color.dart';
+import 'posed_data.dart';
 
 /// BoneData wrapper
-class BoneData implements Finalizable {
+class BoneData extends PosedData {
   final Pointer<spine_bone_data_wrapper> _ptr;
 
-  BoneData.fromPointer(this._ptr);
+  BoneData.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
   factory BoneData(int index, String name, BoneData parent) {
-    final ptr = SpineBindings.bindings.spine_bone_data_create(index, name.toNativeUtf8().cast<Char>(), parent.nativePtr.cast());
+    final ptr = SpineBindings.bindings.spine_bone_data_create(
+        index, name.toNativeUtf8().cast<Char>(), parent.nativePtr.cast());
     return BoneData.fromPointer(ptr);
   }
 
@@ -80,7 +83,8 @@ class BoneData implements Finalizable {
   }
 
   set icon(String value) {
-    SpineBindings.bindings.spine_bone_data_set_icon(_ptr, value.toNativeUtf8().cast<Char>());
+    SpineBindings.bindings
+        .spine_bone_data_set_icon(_ptr, value.toNativeUtf8().cast<Char>());
   }
 
   bool get visible {
@@ -96,22 +100,4 @@ class BoneData implements Finalizable {
     final result = SpineBindings.bindings.spine_bone_data_get_setup_pose(_ptr);
     return BoneLocal.fromPointer(result);
   }
-
-  String get name {
-    final result = SpineBindings.bindings.spine_bone_data_get_name(_ptr);
-    return result.cast<Utf8>().toDartString();
-  }
-
-  bool get skinRequired {
-    final result = SpineBindings.bindings.spine_bone_data_get_skin_required(_ptr);
-    return result;
-  }
-
-  set skinRequired(bool value) {
-    SpineBindings.bindings.spine_bone_data_set_skin_required(_ptr, value);
-  }
-
-  void dispose() {
-    SpineBindings.bindings.spine_bone_data_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/bone_local.dart

@@ -30,7 +30,7 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 import 'inherit.dart';
 
@@ -128,15 +128,11 @@ class BoneLocal implements Finalizable {
     SpineBindings.bindings.spine_bone_local_set_inherit(_ptr, value.value);
   }
 
-  void setScale1(double scaleX, double scaleY) {
+  void setScale(double scaleX, double scaleY) {
     SpineBindings.bindings.spine_bone_local_set_scale_1(_ptr, scaleX, scaleY);
   }
 
   set scale2(double value) {
     SpineBindings.bindings.spine_bone_local_set_scale_2(_ptr, value);
   }
-
-  void dispose() {
-    SpineBindings.bindings.spine_bone_local_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/bone_pose.dart

@@ -30,15 +30,16 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 import 'rtti.dart';
 import 'bone_local.dart';
-import 'skeleton.dart';
 import 'physics.dart';
+import 'skeleton.dart';
+import 'update.dart';
 
 /// BonePose wrapper
-class BonePose extends BoneLocal {
+class BonePose extends BoneLocal implements Update {
   final Pointer<spine_bone_pose_wrapper> _ptr;
 
   BonePose.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
@@ -52,29 +53,36 @@ class BonePose extends BoneLocal {
     return BonePose.fromPointer(ptr);
   }
 
+  @override
   Rtti get rtti {
     final result = SpineBindings.bindings.spine_bone_pose_get_rtti(_ptr);
     return Rtti.fromPointer(result);
   }
 
+  @override
   void update(Skeleton skeleton, Physics physics) {
-    SpineBindings.bindings.spine_bone_pose_update(_ptr, skeleton.nativePtr.cast(), physics.value);
+    SpineBindings.bindings
+        .spine_bone_pose_update(_ptr, skeleton.nativePtr.cast(), physics.value);
   }
 
   void updateWorldTransform(Skeleton skeleton) {
-    SpineBindings.bindings.spine_bone_pose_update_world_transform(_ptr, skeleton.nativePtr.cast());
+    SpineBindings.bindings.spine_bone_pose_update_world_transform(
+        _ptr, skeleton.nativePtr.cast());
   }
 
   void updateLocalTransform(Skeleton skeleton) {
-    SpineBindings.bindings.spine_bone_pose_update_local_transform(_ptr, skeleton.nativePtr.cast());
+    SpineBindings.bindings.spine_bone_pose_update_local_transform(
+        _ptr, skeleton.nativePtr.cast());
   }
 
   void validateLocalTransform(Skeleton skeleton) {
-    SpineBindings.bindings.spine_bone_pose_validate_local_transform(_ptr, skeleton.nativePtr.cast());
+    SpineBindings.bindings.spine_bone_pose_validate_local_transform(
+        _ptr, skeleton.nativePtr.cast());
   }
 
   void modifyLocal(Skeleton skeleton) {
-    SpineBindings.bindings.spine_bone_pose_modify_local(_ptr, skeleton.nativePtr.cast());
+    SpineBindings.bindings
+        .spine_bone_pose_modify_local(_ptr, skeleton.nativePtr.cast());
   }
 
   void modifyWorld(int update) {
@@ -140,32 +148,38 @@ class BonePose extends BoneLocal {
   }
 
   double get worldRotationX {
-    final result = SpineBindings.bindings.spine_bone_pose_get_world_rotation_x(_ptr);
+    final result =
+        SpineBindings.bindings.spine_bone_pose_get_world_rotation_x(_ptr);
     return result;
   }
 
   double get worldRotationY {
-    final result = SpineBindings.bindings.spine_bone_pose_get_world_rotation_y(_ptr);
+    final result =
+        SpineBindings.bindings.spine_bone_pose_get_world_rotation_y(_ptr);
     return result;
   }
 
   double get worldScaleX {
-    final result = SpineBindings.bindings.spine_bone_pose_get_world_scale_x(_ptr);
+    final result =
+        SpineBindings.bindings.spine_bone_pose_get_world_scale_x(_ptr);
     return result;
   }
 
   double get worldScaleY {
-    final result = SpineBindings.bindings.spine_bone_pose_get_world_scale_y(_ptr);
+    final result =
+        SpineBindings.bindings.spine_bone_pose_get_world_scale_y(_ptr);
     return result;
   }
 
   double worldToLocalRotation(double worldRotation) {
-    final result = SpineBindings.bindings.spine_bone_pose_world_to_local_rotation(_ptr, worldRotation);
+    final result = SpineBindings.bindings
+        .spine_bone_pose_world_to_local_rotation(_ptr, worldRotation);
     return result;
   }
 
   double localToWorldRotation(double localRotation) {
-    final result = SpineBindings.bindings.spine_bone_pose_local_to_world_rotation(_ptr, localRotation);
+    final result = SpineBindings.bindings
+        .spine_bone_pose_local_to_world_rotation(_ptr, localRotation);
     return result;
   }
 
@@ -177,9 +191,4 @@ class BonePose extends BoneLocal {
     final result = SpineBindings.bindings.spine_bone_pose_rtti();
     return Rtti.fromPointer(result);
   }
-
-  @override
-  void dispose() {
-    SpineBindings.bindings.spine_bone_pose_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/bone_timeline.dart

@@ -30,39 +30,17 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'spine_flutter_bindings_generated.dart';
 import '../spine_bindings.dart';
 import 'rtti.dart';
 
 /// BoneTimeline wrapper
-class BoneTimeline implements Finalizable {
-  final Pointer<spine_bone_timeline_wrapper> _ptr;
-
-  BoneTimeline.fromPointer(this._ptr);
-
-  /// Get the native pointer for FFI calls
-  Pointer get nativePtr => _ptr;
-
-  Rtti get rtti {
-    final result = SpineBindings.bindings.spine_bone_timeline_get_rtti(_ptr);
-    return Rtti.fromPointer(result);
-  }
-
-  int get boneIndex {
-    final result = SpineBindings.bindings.spine_bone_timeline_get_bone_index(_ptr);
-    return result;
-  }
-
-  set boneIndex(int value) {
-    SpineBindings.bindings.spine_bone_timeline_set_bone_index(_ptr, value);
-  }
-
+abstract class BoneTimeline {
+  Pointer get nativePtr;
+  Rtti get rtti;
+  int get boneIndex;
+  set boneIndex(int value);
   static Rtti rttiStatic() {
     final result = SpineBindings.bindings.spine_bone_timeline_rtti();
     return Rtti.fromPointer(result);
   }
-
-  void dispose() {
-    SpineBindings.bindings.spine_bone_timeline_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/bone_timeline1.dart

@@ -30,12 +30,13 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
+import 'bone_timeline.dart';
 import 'curve_timeline1.dart';
 
 /// BoneTimeline1 wrapper
-abstract class BoneTimeline1 extends CurveTimeline1 {
+abstract class BoneTimeline1 extends CurveTimeline1 implements BoneTimeline {
   final Pointer<spine_bone_timeline1_wrapper> _ptr;
 
   BoneTimeline1.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
@@ -44,17 +45,15 @@ abstract class BoneTimeline1 extends CurveTimeline1 {
   @override
   Pointer get nativePtr => _ptr;
 
+  @override
   int get boneIndex {
-    final result = SpineBindings.bindings.spine_bone_timeline1_get_bone_index(_ptr);
+    final result =
+        SpineBindings.bindings.spine_bone_timeline1_get_bone_index(_ptr);
     return result;
   }
 
+  @override
   set boneIndex(int value) {
     SpineBindings.bindings.spine_bone_timeline1_set_bone_index(_ptr, value);
   }
-
-  @override
-  void dispose() {
-    SpineBindings.bindings.spine_bone_timeline1_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/bone_timeline2.dart

@@ -30,12 +30,13 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
-import 'curve_timeline2.dart';
+import 'bone_timeline.dart';
+import 'curve_timeline.dart';
 
 /// BoneTimeline2 wrapper
-abstract class BoneTimeline2 extends CurveTimeline2 {
+abstract class BoneTimeline2 extends CurveTimeline implements BoneTimeline {
   final Pointer<spine_bone_timeline2_wrapper> _ptr;
 
   BoneTimeline2.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
@@ -44,17 +45,20 @@ abstract class BoneTimeline2 extends CurveTimeline2 {
   @override
   Pointer get nativePtr => _ptr;
 
+  @override
   int get boneIndex {
-    final result = SpineBindings.bindings.spine_bone_timeline2_get_bone_index(_ptr);
+    final result =
+        SpineBindings.bindings.spine_bone_timeline2_get_bone_index(_ptr);
     return result;
   }
 
+  @override
   set boneIndex(int value) {
     SpineBindings.bindings.spine_bone_timeline2_set_bone_index(_ptr, value);
   }
 
-  @override
-  void dispose() {
-    SpineBindings.bindings.spine_bone_timeline2_dispose(_ptr);
+  void setFrame(int frame, double time, double value1, double value2) {
+    SpineBindings.bindings
+        .spine_bone_timeline2_set_frame(_ptr, frame, time, value1, value2);
   }
-}
+}

spine-flutter/lib/generated/bounding_box_attachment.dart

@@ -31,10 +31,10 @@
 
 import 'dart:ffi';
 import 'package:ffi/ffi.dart';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
-import 'vertex_attachment.dart';
 import 'color.dart';
+import 'vertex_attachment.dart';
 
 /// BoundingBoxAttachment wrapper
 class BoundingBoxAttachment extends VertexAttachment {
@@ -47,17 +47,14 @@ class BoundingBoxAttachment extends VertexAttachment {
   Pointer get nativePtr => _ptr;
 
   factory BoundingBoxAttachment(String name) {
-    final ptr = SpineBindings.bindings.spine_bounding_box_attachment_create(name.toNativeUtf8().cast<Char>());
+    final ptr = SpineBindings.bindings
+        .spine_bounding_box_attachment_create(name.toNativeUtf8().cast<Char>());
     return BoundingBoxAttachment.fromPointer(ptr);
   }
 
   Color get color {
-    final result = SpineBindings.bindings.spine_bounding_box_attachment_get_color(_ptr);
+    final result =
+        SpineBindings.bindings.spine_bounding_box_attachment_get_color(_ptr);
     return Color.fromPointer(result);
   }
-
-  @override
-  void dispose() {
-    SpineBindings.bindings.spine_bounding_box_attachment_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/clipping_attachment.dart

@@ -31,11 +31,11 @@
 
 import 'dart:ffi';
 import 'package:ffi/ffi.dart';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
-import 'vertex_attachment.dart';
-import 'slot_data.dart';
 import 'color.dart';
+import 'slot_data.dart';
+import 'vertex_attachment.dart';
 
 /// ClippingAttachment wrapper
 class ClippingAttachment extends VertexAttachment {
@@ -48,26 +48,25 @@ class ClippingAttachment extends VertexAttachment {
   Pointer get nativePtr => _ptr;
 
   factory ClippingAttachment(String name) {
-    final ptr = SpineBindings.bindings.spine_clipping_attachment_create(name.toNativeUtf8().cast<Char>());
+    final ptr = SpineBindings.bindings
+        .spine_clipping_attachment_create(name.toNativeUtf8().cast<Char>());
     return ClippingAttachment.fromPointer(ptr);
   }
 
   SlotData get endSlot {
-    final result = SpineBindings.bindings.spine_clipping_attachment_get_end_slot(_ptr);
+    final result =
+        SpineBindings.bindings.spine_clipping_attachment_get_end_slot(_ptr);
     return SlotData.fromPointer(result);
   }
 
   set endSlot(SlotData value) {
-    SpineBindings.bindings.spine_clipping_attachment_set_end_slot(_ptr, value.nativePtr.cast());
+    SpineBindings.bindings
+        .spine_clipping_attachment_set_end_slot(_ptr, value.nativePtr.cast());
   }
 
   Color get color {
-    final result = SpineBindings.bindings.spine_clipping_attachment_get_color(_ptr);
+    final result =
+        SpineBindings.bindings.spine_clipping_attachment_get_color(_ptr);
     return Color.fromPointer(result);
   }
-
-  @override
-  void dispose() {
-    SpineBindings.bindings.spine_clipping_attachment_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/color.dart

@@ -31,7 +31,7 @@
 
 import 'dart:ffi';
 import 'package:ffi/ffi.dart';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 
 /// Color wrapper
@@ -59,7 +59,8 @@ class Color implements Finalizable {
   }
 
   static double parseHex(String value, int index) {
-    final result = SpineBindings.bindings.spine_color_parse_hex(value.toNativeUtf8().cast<Char>(), index);
+    final result = SpineBindings.bindings
+        .spine_color_parse_hex(value.toNativeUtf8().cast<Char>(), index);
     return result;
   }
 
@@ -107,7 +108,7 @@ class Color implements Finalizable {
     SpineBindings.bindings.spine_color_set_a(_ptr, value);
   }
 
-  Color set1(double r, double g, double b, double a) {
+  Color set(double r, double g, double b, double a) {
     final result = SpineBindings.bindings.spine_color_set_1(_ptr, r, g, b, a);
     return Color.fromPointer(result);
   }
@@ -118,11 +119,12 @@ class Color implements Finalizable {
   }
 
   Color set3(Color other) {
-    final result = SpineBindings.bindings.spine_color_set_3(_ptr, other.nativePtr.cast());
+    final result =
+        SpineBindings.bindings.spine_color_set_3(_ptr, other.nativePtr.cast());
     return Color.fromPointer(result);
   }
 
-  Color add1(double r, double g, double b, double a) {
+  Color add(double r, double g, double b, double a) {
     final result = SpineBindings.bindings.spine_color_add_1(_ptr, r, g, b, a);
     return Color.fromPointer(result);
   }
@@ -133,11 +135,8 @@ class Color implements Finalizable {
   }
 
   Color add3(Color other) {
-    final result = SpineBindings.bindings.spine_color_add_3(_ptr, other.nativePtr.cast());
+    final result =
+        SpineBindings.bindings.spine_color_add_3(_ptr, other.nativePtr.cast());
     return Color.fromPointer(result);
   }
-
-  void dispose() {
-    SpineBindings.bindings.spine_color_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/constraint.dart

@@ -30,38 +30,26 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'spine_flutter_bindings_generated.dart';
 import '../spine_bindings.dart';
-import 'update.dart';
+import 'rtti.dart';
 import 'constraint_data.dart';
+import 'physics.dart';
 import 'skeleton.dart';
+import 'update.dart';
 
 /// Constraint wrapper
-abstract class Constraint extends Update {
-  final Pointer<spine_constraint_wrapper> _ptr;
-
-  Constraint.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
-
-  /// Get the native pointer for FFI calls
+abstract class Constraint implements Update {
   @override
-  Pointer get nativePtr => _ptr;
-
-  ConstraintData get data {
-    final result = SpineBindings.bindings.spine_constraint_get_data(_ptr);
-    throw UnsupportedError('Cannot instantiate abstract class ConstraintData from pointer - no concrete subclasses found');
-  }
-
-  void sort(Skeleton skeleton) {
-    SpineBindings.bindings.spine_constraint_sort(_ptr, skeleton.nativePtr.cast());
-  }
-
-  bool get isSourceActive {
-    final result = SpineBindings.bindings.spine_constraint_is_source_active(_ptr);
-    return result;
-  }
-
+  Pointer get nativePtr;
   @override
-  void dispose() {
-    SpineBindings.bindings.spine_constraint_dispose(_ptr);
+  Rtti get rtti;
+  ConstraintData get data;
+  void sort(Skeleton skeleton);
+  bool get isSourceActive;
+  @override
+  void update(Skeleton skeleton, Physics physics);
+  static Rtti rttiStatic() {
+    final result = SpineBindings.bindings.spine_constraint_rtti();
+    return Rtti.fromPointer(result);
   }
-}
+}

spine-flutter/lib/generated/constraint_data.dart

@@ -30,48 +30,20 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'package:ffi/ffi.dart';
-import 'spine_flutter_bindings_generated.dart';
 import '../spine_bindings.dart';
 import 'rtti.dart';
 import 'constraint.dart';
 import 'skeleton.dart';
 
 /// ConstraintData wrapper
-abstract class ConstraintData implements Finalizable {
-  final Pointer<spine_constraint_data_wrapper> _ptr;
-
-  ConstraintData.fromPointer(this._ptr);
-
-  /// Get the native pointer for FFI calls
-  Pointer get nativePtr => _ptr;
-
-  Rtti get rtti {
-    final result = SpineBindings.bindings.spine_constraint_data_get_rtti(_ptr);
-    return Rtti.fromPointer(result);
-  }
-
-  Constraint createMethod(Skeleton skeleton) {
-    final result = SpineBindings.bindings.spine_constraint_data_create_method(_ptr, skeleton.nativePtr.cast());
-    throw UnsupportedError('Cannot instantiate abstract class Constraint from pointer - no concrete subclasses found');
-  }
-
-  String get name {
-    final result = SpineBindings.bindings.spine_constraint_data_get_name(_ptr);
-    return result.cast<Utf8>().toDartString();
-  }
-
-  bool get skinRequired {
-    final result = SpineBindings.bindings.spine_constraint_data_get_skin_required(_ptr);
-    return result;
-  }
-
+abstract class ConstraintData {
+  Pointer get nativePtr;
+  Rtti get rtti;
+  Constraint createMethod(Skeleton skeleton);
+  String get name;
+  bool get skinRequired;
   static Rtti rttiStatic() {
     final result = SpineBindings.bindings.spine_constraint_data_rtti();
     return Rtti.fromPointer(result);
   }
-
-  void dispose() {
-    SpineBindings.bindings.spine_constraint_data_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/constraint_timeline.dart

@@ -30,39 +30,17 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'spine_flutter_bindings_generated.dart';
 import '../spine_bindings.dart';
 import 'rtti.dart';
 
 /// ConstraintTimeline wrapper
-class ConstraintTimeline implements Finalizable {
-  final Pointer<spine_constraint_timeline_wrapper> _ptr;
-
-  ConstraintTimeline.fromPointer(this._ptr);
-
-  /// Get the native pointer for FFI calls
-  Pointer get nativePtr => _ptr;
-
-  Rtti get rtti {
-    final result = SpineBindings.bindings.spine_constraint_timeline_get_rtti(_ptr);
-    return Rtti.fromPointer(result);
-  }
-
-  int get constraintIndex {
-    final result = SpineBindings.bindings.spine_constraint_timeline_get_constraint_index(_ptr);
-    return result;
-  }
-
-  set constraintIndex(int value) {
-    SpineBindings.bindings.spine_constraint_timeline_set_constraint_index(_ptr, value);
-  }
-
+abstract class ConstraintTimeline {
+  Pointer get nativePtr;
+  Rtti get rtti;
+  int get constraintIndex;
+  set constraintIndex(int value);
   static Rtti rttiStatic() {
     final result = SpineBindings.bindings.spine_constraint_timeline_rtti();
     return Rtti.fromPointer(result);
   }
-
-  void dispose() {
-    SpineBindings.bindings.spine_constraint_timeline_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/constraint_timeline1.dart

@@ -30,12 +30,14 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
+import 'constraint_timeline.dart';
 import 'curve_timeline1.dart';
 
 /// ConstraintTimeline1 wrapper
-abstract class ConstraintTimeline1 extends CurveTimeline1 {
+abstract class ConstraintTimeline1 extends CurveTimeline1
+    implements ConstraintTimeline {
   final Pointer<spine_constraint_timeline1_wrapper> _ptr;
 
   ConstraintTimeline1.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
@@ -44,17 +46,16 @@ abstract class ConstraintTimeline1 extends CurveTimeline1 {
   @override
   Pointer get nativePtr => _ptr;
 
+  @override
   int get constraintIndex {
-    final result = SpineBindings.bindings.spine_constraint_timeline1_get_constraint_index(_ptr);
+    final result = SpineBindings.bindings
+        .spine_constraint_timeline1_get_constraint_index(_ptr);
     return result;
   }
 
-  set constraintIndex(int value) {
-    SpineBindings.bindings.spine_constraint_timeline1_set_constraint_index(_ptr, value);
-  }
-
   @override
-  void dispose() {
-    SpineBindings.bindings.spine_constraint_timeline1_dispose(_ptr);
+  set constraintIndex(int value) {
+    SpineBindings.bindings
+        .spine_constraint_timeline1_set_constraint_index(_ptr, value);
   }
-}
+}

spine-flutter/lib/generated/curve_timeline.dart

@@ -30,10 +30,10 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
-import 'timeline.dart';
 import 'arrays.dart';
+import 'timeline.dart';
 
 /// CurveTimeline wrapper
 abstract class CurveTimeline extends Timeline {
@@ -53,12 +53,25 @@ abstract class CurveTimeline extends Timeline {
     SpineBindings.bindings.spine_curve_timeline_set_stepped(_ptr, value);
   }
 
-  void setBezier(int bezier, int frame, double value, 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);
+  void setBezier(
+      int bezier,
+      int frame,
+      double value,
+      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(_ptr, time, frame, valueOffset, i);
+    final result = SpineBindings.bindings.spine_curve_timeline_get_bezier_value(
+        _ptr, time, frame, valueOffset, i);
     return result;
   }
 
@@ -66,9 +79,4 @@ abstract class CurveTimeline extends Timeline {
     final result = SpineBindings.bindings.spine_curve_timeline_get_curves(_ptr);
     return ArrayFloat.fromPointer(result);
   }
-
-  @override
-  void dispose() {
-    SpineBindings.bindings.spine_curve_timeline_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/curve_timeline1.dart

@@ -30,7 +30,7 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 import 'curve_timeline.dart';
 import 'mix_blend.dart';
@@ -47,36 +47,44 @@ abstract class CurveTimeline1 extends CurveTimeline {
   Pointer get nativePtr => _ptr;
 
   void setFrame(int frame, double time, double value) {
-    SpineBindings.bindings.spine_curve_timeline1_set_frame(_ptr, frame, time, value);
+    SpineBindings.bindings
+        .spine_curve_timeline1_set_frame(_ptr, frame, time, value);
   }
 
   double getCurveValue(double time) {
-    final result = SpineBindings.bindings.spine_curve_timeline1_get_curve_value(_ptr, time);
+    final result = SpineBindings.bindings
+        .spine_curve_timeline1_get_curve_value(_ptr, time);
     return result;
   }
 
-  double getRelativeValue(double time, double alpha, MixBlend blend, double current, double setup) {
-    final result = SpineBindings.bindings.spine_curve_timeline1_get_relative_value(_ptr, time, alpha, blend.value, current, setup);
+  double getRelativeValue(
+      double time, double alpha, MixBlend blend, double current, double setup) {
+    final result = SpineBindings.bindings
+        .spine_curve_timeline1_get_relative_value(
+            _ptr, time, alpha, blend.value, current, setup);
     return result;
   }
 
-  double getScaleValue(double time, double alpha, MixBlend blend, MixDirection direction, double current, double setup) {
-    final result = SpineBindings.bindings.spine_curve_timeline1_get_scale_value(_ptr, time, alpha, blend.value, direction.value, current, setup);
+  double getScaleValue(double time, double alpha, MixBlend blend,
+      MixDirection direction, double current, double setup) {
+    final result = SpineBindings.bindings.spine_curve_timeline1_get_scale_value(
+        _ptr, time, alpha, blend.value, direction.value, current, setup);
     return result;
   }
 
-  double getAbsoluteValue1(double time, double alpha, MixBlend blend, double current, double setup) {
-    final result = SpineBindings.bindings.spine_curve_timeline1_get_absolute_value_1(_ptr, time, alpha, blend.value, current, setup);
+  double getAbsoluteValue(
+      double time, double alpha, MixBlend blend, double current, double setup) {
+    final result = SpineBindings.bindings
+        .spine_curve_timeline1_get_absolute_value_1(
+            _ptr, time, alpha, blend.value, current, setup);
     return result;
   }
 
-  double getAbsoluteValue2(double time, double alpha, MixBlend blend, double current, double setup, double value) {
-    final result = SpineBindings.bindings.spine_curve_timeline1_get_absolute_value_2(_ptr, time, alpha, blend.value, current, setup, value);
+  double getAbsoluteValue2(double time, double alpha, MixBlend blend,
+      double current, double setup, double value) {
+    final result = SpineBindings.bindings
+        .spine_curve_timeline1_get_absolute_value_2(
+            _ptr, time, alpha, blend.value, current, setup, value);
     return result;
   }
-
-  @override
-  void dispose() {
-    SpineBindings.bindings.spine_curve_timeline1_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/curve_timeline2.dart

@@ -1,60 +0,0 @@
-//
-// Spine Runtimes License Agreement
-// Last updated April 5, 2025. Replaces all prior versions.
-//
-// Copyright (c) 2013-2025, Esoteric Software LLC
-//
-// Integration of the Spine Runtimes into software or otherwise creating
-// derivative works of the Spine Runtimes is permitted under the terms and
-// conditions of Section 2 of the Spine Editor License Agreement:
-// http://esotericsoftware.com/spine-editor-license
-//
-// Otherwise, it is permitted to integrate the Spine Runtimes into software
-// or otherwise create derivative works of the Spine Runtimes (collectively,
-// "Products"), provided that each user of the Products must obtain their own
-// Spine Editor license and redistribution of the Products in any form must
-// include this license and copyright notice.
-//
-// THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
-// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-// DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
-// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
-// BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
-// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-// THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-//
-
-// AUTO GENERATED FILE, DO NOT EDIT.
-
-import 'dart:ffi';
-import 'spine_flutter_bindings_generated.dart';
-import '../spine_bindings.dart';
-import 'curve_timeline.dart';
-
-/// CurveTimeline2 wrapper
-abstract class CurveTimeline2 extends CurveTimeline {
-  final Pointer<spine_curve_timeline2_wrapper> _ptr;
-
-  CurveTimeline2.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
-
-  /// Get the native pointer for FFI calls
-  @override
-  Pointer get nativePtr => _ptr;
-
-  void setFrame(int frame, double time, double value1, double value2) {
-    SpineBindings.bindings.spine_curve_timeline2_set_frame(_ptr, frame, time, value1, value2);
-  }
-
-  double getCurveValue(double time) {
-    final result = SpineBindings.bindings.spine_curve_timeline2_get_curve_value(_ptr, time);
-    return result;
-  }
-
-  @override
-  void dispose() {
-    SpineBindings.bindings.spine_curve_timeline2_dispose(_ptr);
-  }
-}

spine-flutter/lib/generated/deform_timeline.dart

@@ -31,15 +31,15 @@
 
 import 'dart:ffi';
 import 'package:ffi/ffi.dart';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
-import 'slot_curve_timeline.dart';
-import 'vertex_attachment.dart';
+import 'arrays.dart';
 import 'bounding_box_attachment.dart';
 import 'clipping_attachment.dart';
 import 'mesh_attachment.dart';
 import 'path_attachment.dart';
-import 'arrays.dart';
+import 'slot_curve_timeline.dart';
+import 'vertex_attachment.dart';
 
 /// DeformTimeline wrapper
 class DeformTimeline extends SlotCurveTimeline {
@@ -51,19 +51,27 @@ class DeformTimeline extends SlotCurveTimeline {
   @override
   Pointer get nativePtr => _ptr;
 
-  factory DeformTimeline(int frameCount, int bezierCount, int slotIndex, VertexAttachment attachment) {
-    final ptr = SpineBindings.bindings.spine_deform_timeline_create(frameCount, bezierCount, slotIndex, attachment.nativePtr.cast());
+  factory DeformTimeline(int frameCount, int bezierCount, int slotIndex,
+      VertexAttachment attachment) {
+    final ptr = SpineBindings.bindings.spine_deform_timeline_create(
+        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(_ptr, frameIndex, time, vertices.nativePtr.cast());
+    SpineBindings.bindings.spine_deform_timeline_set_frame(
+        _ptr, frameIndex, time, vertices.nativePtr.cast());
   }
 
   VertexAttachment get attachment {
-    final result = SpineBindings.bindings.spine_deform_timeline_get_attachment(_ptr);
-    final rtti = SpineBindings.bindings.spine_vertex_attachment_get_rtti(result);
-    final className = SpineBindings.bindings.spine_rtti_get_class_name(rtti).cast<Utf8>().toDartString();
+    final result =
+        SpineBindings.bindings.spine_deform_timeline_get_attachment(_ptr);
+    final rtti =
+        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());
@@ -74,21 +82,19 @@ class DeformTimeline extends SlotCurveTimeline {
       case 'spine_path_attachment':
         return PathAttachment.fromPointer(result.cast());
       default:
-        throw UnsupportedError('Unknown concrete type: $className for abstract class VertexAttachment');
+        throw UnsupportedError(
+            'Unknown concrete type: $className for abstract class VertexAttachment');
     }
   }
 
   set attachment(VertexAttachment value) {
-    SpineBindings.bindings.spine_deform_timeline_set_attachment(_ptr, value.nativePtr.cast());
+    SpineBindings.bindings
+        .spine_deform_timeline_set_attachment(_ptr, value.nativePtr.cast());
   }
 
   double getCurvePercent(double time, int frame) {
-    final result = SpineBindings.bindings.spine_deform_timeline_get_curve_percent(_ptr, time, frame);
+    final result = SpineBindings.bindings
+        .spine_deform_timeline_get_curve_percent(_ptr, time, frame);
     return result;
   }
-
-  @override
-  void dispose() {
-    SpineBindings.bindings.spine_deform_timeline_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/draw_order_timeline.dart

@@ -30,10 +30,10 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
-import 'timeline.dart';
 import 'arrays.dart';
+import 'timeline.dart';
 
 /// DrawOrderTimeline wrapper
 class DrawOrderTimeline extends Timeline {
@@ -46,16 +46,13 @@ class DrawOrderTimeline extends Timeline {
   Pointer get nativePtr => _ptr;
 
   factory DrawOrderTimeline(int frameCount) {
-    final ptr = SpineBindings.bindings.spine_draw_order_timeline_create(frameCount);
+    final ptr =
+        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(_ptr, frame, time, drawOrder.nativePtr.cast());
+    SpineBindings.bindings.spine_draw_order_timeline_set_frame(
+        _ptr, frame, time, drawOrder.nativePtr.cast());
   }
-
-  @override
-  void dispose() {
-    SpineBindings.bindings.spine_draw_order_timeline_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/event.dart

@@ -31,7 +31,7 @@
 
 import 'dart:ffi';
 import 'package:ffi/ffi.dart';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 import 'event_data.dart';
 
@@ -45,7 +45,8 @@ class Event implements Finalizable {
   Pointer get nativePtr => _ptr;
 
   factory Event(double time, EventData data) {
-    final ptr = SpineBindings.bindings.spine_event_create(time, data.nativePtr.cast());
+    final ptr =
+        SpineBindings.bindings.spine_event_create(time, data.nativePtr.cast());
     return Event.fromPointer(ptr);
   }
 
@@ -83,7 +84,8 @@ class Event implements Finalizable {
   }
 
   set stringValue(String value) {
-    SpineBindings.bindings.spine_event_set_string(_ptr, value.toNativeUtf8().cast<Char>());
+    SpineBindings.bindings
+        .spine_event_set_string(_ptr, value.toNativeUtf8().cast<Char>());
   }
 
   double get volume {
@@ -103,8 +105,4 @@ class Event implements Finalizable {
   set balance(double value) {
     SpineBindings.bindings.spine_event_set_balance(_ptr, value);
   }
-
-  void dispose() {
-    SpineBindings.bindings.spine_event_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/event_data.dart

@@ -31,7 +31,7 @@
 
 import 'dart:ffi';
 import 'package:ffi/ffi.dart';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 
 /// EventData wrapper
@@ -44,7 +44,8 @@ class EventData implements Finalizable {
   Pointer get nativePtr => _ptr;
 
   factory EventData(String name) {
-    final ptr = SpineBindings.bindings.spine_event_data_create(name.toNativeUtf8().cast<Char>());
+    final ptr = SpineBindings.bindings
+        .spine_event_data_create(name.toNativeUtf8().cast<Char>());
     return EventData.fromPointer(ptr);
   }
 
@@ -77,7 +78,8 @@ class EventData implements Finalizable {
   }
 
   set stringValue(String value) {
-    SpineBindings.bindings.spine_event_data_set_string(_ptr, value.toNativeUtf8().cast<Char>());
+    SpineBindings.bindings
+        .spine_event_data_set_string(_ptr, value.toNativeUtf8().cast<Char>());
   }
 
   String get audioPath {
@@ -86,7 +88,8 @@ class EventData implements Finalizable {
   }
 
   set audioPath(String value) {
-    SpineBindings.bindings.spine_event_data_set_audio_path(_ptr, value.toNativeUtf8().cast<Char>());
+    SpineBindings.bindings.spine_event_data_set_audio_path(
+        _ptr, value.toNativeUtf8().cast<Char>());
   }
 
   double get volume {
@@ -106,8 +109,4 @@ class EventData implements Finalizable {
   set balance(double value) {
     SpineBindings.bindings.spine_event_data_set_balance(_ptr, value);
   }
-
-  void dispose() {
-    SpineBindings.bindings.spine_event_data_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/event_queue_entry.dart

@@ -30,11 +30,11 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
+import 'event.dart';
 import 'event_type.dart';
 import 'track_entry.dart';
-import 'event.dart';
 
 /// EventQueueEntry wrapper
 class EventQueueEntry implements Finalizable {
@@ -45,13 +45,16 @@ class EventQueueEntry implements Finalizable {
   /// Get the native pointer for FFI calls
   Pointer get nativePtr => _ptr;
 
-  factory EventQueueEntry(EventType eventType, TrackEntry trackEntry, Event event) {
-    final ptr = SpineBindings.bindings.spine_event_queue_entry_create(eventType.value, trackEntry.nativePtr.cast(), event.nativePtr.cast());
+  factory EventQueueEntry(
+      EventType eventType, TrackEntry trackEntry, Event event) {
+    final ptr = SpineBindings.bindings.spine_event_queue_entry_create(
+        eventType.value, trackEntry.nativePtr.cast(), event.nativePtr.cast());
     return EventQueueEntry.fromPointer(ptr);
   }
 
   EventType get type {
-    final result = SpineBindings.bindings.spine_event_queue_entry_get__type(_ptr);
+    final result =
+        SpineBindings.bindings.spine_event_queue_entry_get__type(_ptr);
     return EventType.fromValue(result);
   }
 
@@ -60,24 +63,24 @@ class EventQueueEntry implements Finalizable {
   }
 
   TrackEntry get entry {
-    final result = SpineBindings.bindings.spine_event_queue_entry_get__entry(_ptr);
+    final result =
+        SpineBindings.bindings.spine_event_queue_entry_get__entry(_ptr);
     return TrackEntry.fromPointer(result);
   }
 
   set entry(TrackEntry value) {
-    SpineBindings.bindings.spine_event_queue_entry_set__entry(_ptr, value.nativePtr.cast());
+    SpineBindings.bindings
+        .spine_event_queue_entry_set__entry(_ptr, value.nativePtr.cast());
   }
 
   Event get event {
-    final result = SpineBindings.bindings.spine_event_queue_entry_get__event(_ptr);
+    final result =
+        SpineBindings.bindings.spine_event_queue_entry_get__event(_ptr);
     return Event.fromPointer(result);
   }
 
   set event(Event value) {
-    SpineBindings.bindings.spine_event_queue_entry_set__event(_ptr, value.nativePtr.cast());
+    SpineBindings.bindings
+        .spine_event_queue_entry_set__event(_ptr, value.nativePtr.cast());
   }
-
-  void dispose() {
-    SpineBindings.bindings.spine_event_queue_entry_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/event_timeline.dart

@@ -30,11 +30,11 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
-import 'timeline.dart';
-import 'event.dart';
 import 'arrays.dart';
+import 'event.dart';
+import 'timeline.dart';
 
 /// EventTimeline wrapper
 class EventTimeline extends Timeline {
@@ -57,11 +57,7 @@ class EventTimeline extends Timeline {
   }
 
   void setFrame(int frame, Event event) {
-    SpineBindings.bindings.spine_event_timeline_set_frame(_ptr, frame, event.nativePtr.cast());
+    SpineBindings.bindings
+        .spine_event_timeline_set_frame(_ptr, frame, event.nativePtr.cast());
   }
-
-  @override
-  void dispose() {
-    SpineBindings.bindings.spine_event_timeline_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/event_type.dart

@@ -32,11 +32,11 @@
 /// EventType enum
 enum EventType {
   start(0),
-  interrupt(1),
-  end(2),
-  dispose(3),
-  complete(4),
-  event(5);
+  interrupt(0),
+  end(0),
+  dispose(0),
+  complete(0),
+  event(0);
 
   const EventType(this.value);
   final int value;
@@ -47,4 +47,4 @@ enum EventType {
       orElse: () => throw ArgumentError('Invalid EventType value: $value'),
     );
   }
-}
+}

spine-flutter/lib/generated/format.dart

@@ -32,12 +32,12 @@
 /// Format enum
 enum Format {
   alpha(0),
-  intensity(1),
-  luminanceAlpha(2),
-  rgb565(3),
-  rgba4444(4),
-  rgb888(5),
-  rgba8888(6);
+  intensity(0),
+  luminanceAlpha(0),
+  rgb565(0),
+  rgba4444(0),
+  rgb888(0),
+  rgba8888(0);
 
   const Format(this.value);
   final int value;
@@ -48,4 +48,4 @@ enum Format {
       orElse: () => throw ArgumentError('Invalid Format value: $value'),
     );
   }
-}
+}

spine-flutter/lib/generated/from_property.dart

@@ -30,7 +30,7 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 import 'rtti.dart';
 import 'arrays.dart';
@@ -69,10 +69,7 @@ abstract class FromProperty implements Finalizable {
   }
 
   set to(ArrayToProperty value) {
-    SpineBindings.bindings.spine_from_property_set__to(_ptr, value.nativePtr.cast());
+    SpineBindings.bindings
+        .spine_from_property_set__to(_ptr, value.nativePtr.cast());
   }
-
-  void dispose() {
-    SpineBindings.bindings.spine_from_property_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/from_rotate.dart

@@ -30,7 +30,7 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 import 'from_property.dart';
 
@@ -48,9 +48,4 @@ class FromRotate extends FromProperty {
     final ptr = SpineBindings.bindings.spine_from_rotate_create();
     return FromRotate.fromPointer(ptr);
   }
-
-  @override
-  void dispose() {
-    SpineBindings.bindings.spine_from_rotate_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/from_scale_x.dart

@@ -30,7 +30,7 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 import 'from_property.dart';
 
@@ -48,9 +48,4 @@ class FromScaleX extends FromProperty {
     final ptr = SpineBindings.bindings.spine_from_scale_x_create();
     return FromScaleX.fromPointer(ptr);
   }
-
-  @override
-  void dispose() {
-    SpineBindings.bindings.spine_from_scale_x_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/from_scale_y.dart

@@ -30,7 +30,7 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 import 'from_property.dart';
 
@@ -48,9 +48,4 @@ class FromScaleY extends FromProperty {
     final ptr = SpineBindings.bindings.spine_from_scale_y_create();
     return FromScaleY.fromPointer(ptr);
   }
-
-  @override
-  void dispose() {
-    SpineBindings.bindings.spine_from_scale_y_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/from_shear_y.dart

@@ -30,7 +30,7 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 import 'from_property.dart';
 
@@ -48,9 +48,4 @@ class FromShearY extends FromProperty {
     final ptr = SpineBindings.bindings.spine_from_shear_y_create();
     return FromShearY.fromPointer(ptr);
   }
-
-  @override
-  void dispose() {
-    SpineBindings.bindings.spine_from_shear_y_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/from_x.dart

@@ -30,7 +30,7 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 import 'from_property.dart';
 
@@ -48,9 +48,4 @@ class FromX extends FromProperty {
     final ptr = SpineBindings.bindings.spine_from_x_create();
     return FromX.fromPointer(ptr);
   }
-
-  @override
-  void dispose() {
-    SpineBindings.bindings.spine_from_x_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/from_y.dart

@@ -30,7 +30,7 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 import 'from_property.dart';
 
@@ -48,9 +48,4 @@ class FromY extends FromProperty {
     final ptr = SpineBindings.bindings.spine_from_y_create();
     return FromY.fromPointer(ptr);
   }
-
-  @override
-  void dispose() {
-    SpineBindings.bindings.spine_from_y_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/ik_constraint.dart

@@ -30,54 +30,68 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 import 'rtti.dart';
-import 'skeleton.dart';
-import 'physics.dart';
-import 'ik_constraint_data.dart';
+import 'arrays.dart';
 import 'bone.dart';
 import 'bone_pose.dart';
+import 'constraint.dart';
+import 'ik_constraint_data.dart';
 import 'ik_constraint_pose.dart';
-import 'arrays.dart';
+import 'physics.dart';
+import 'posed.dart';
+import 'posed_active.dart';
+import 'skeleton.dart';
 
 /// IkConstraint wrapper
-class IkConstraint implements Finalizable {
+class IkConstraint extends PosedActive implements Posed, Constraint {
   final Pointer<spine_ik_constraint_wrapper> _ptr;
 
-  IkConstraint.fromPointer(this._ptr);
+  IkConstraint.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
   factory IkConstraint(IkConstraintData data, Skeleton skeleton) {
-    final ptr = SpineBindings.bindings.spine_ik_constraint_create(data.nativePtr.cast(), skeleton.nativePtr.cast());
+    final ptr = SpineBindings.bindings.spine_ik_constraint_create(
+        data.nativePtr.cast(), skeleton.nativePtr.cast());
     return IkConstraint.fromPointer(ptr);
   }
 
+  @override
   Rtti get rtti {
     final result = SpineBindings.bindings.spine_ik_constraint_get_rtti(_ptr);
     return Rtti.fromPointer(result);
   }
 
   IkConstraint copy(Skeleton skeleton) {
-    final result = SpineBindings.bindings.spine_ik_constraint_copy(_ptr, skeleton.nativePtr.cast());
+    final result = SpineBindings.bindings
+        .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(_ptr, skeleton.nativePtr.cast(), physics.value);
+    SpineBindings.bindings.spine_ik_constraint_update(
+        _ptr, skeleton.nativePtr.cast(), physics.value);
   }
 
+  @override
   void sort(Skeleton skeleton) {
-    SpineBindings.bindings.spine_ik_constraint_sort(_ptr, skeleton.nativePtr.cast());
+    SpineBindings.bindings
+        .spine_ik_constraint_sort(_ptr, skeleton.nativePtr.cast());
   }
 
+  @override
   bool get isSourceActive {
-    final result = SpineBindings.bindings.spine_ik_constraint_is_source_active(_ptr);
+    final result =
+        SpineBindings.bindings.spine_ik_constraint_is_source_active(_ptr);
     return result;
   }
 
+  @override
   IkConstraintData get data {
     final result = SpineBindings.bindings.spine_ik_constraint_get_data(_ptr);
     return IkConstraintData.fromPointer(result);
@@ -94,7 +108,8 @@ class IkConstraint implements Finalizable {
   }
 
   set target(Bone value) {
-    SpineBindings.bindings.spine_ik_constraint_set_target(_ptr, value.nativePtr.cast());
+    SpineBindings.bindings
+        .spine_ik_constraint_set_target(_ptr, value.nativePtr.cast());
   }
 
   IkConstraintPose get pose {
@@ -103,46 +118,67 @@ class IkConstraint implements Finalizable {
   }
 
   IkConstraintPose get appliedPose {
-    final result = SpineBindings.bindings.spine_ik_constraint_get_applied_pose(_ptr);
+    final result =
+        SpineBindings.bindings.spine_ik_constraint_get_applied_pose(_ptr);
     return IkConstraintPose.fromPointer(result);
   }
 
+  @override
   void resetConstrained() {
     SpineBindings.bindings.spine_ik_constraint_reset_constrained(_ptr);
   }
 
+  @override
   void constrained() {
     SpineBindings.bindings.spine_ik_constraint_constrained(_ptr);
   }
 
+  @override
   bool get isPoseEqualToApplied {
-    final result = SpineBindings.bindings.spine_ik_constraint_is_pose_equal_to_applied(_ptr);
+    final result = SpineBindings.bindings
+        .spine_ik_constraint_is_pose_equal_to_applied(_ptr);
     return result;
   }
 
-  bool get isActive {
-    final result = SpineBindings.bindings.spine_ik_constraint_is_active(_ptr);
-    return result;
-  }
-
-  set active(bool value) {
-    SpineBindings.bindings.spine_ik_constraint_set_active(_ptr, value);
-  }
-
   static Rtti rttiStatic() {
     final result = SpineBindings.bindings.spine_ik_constraint_rtti();
     return Rtti.fromPointer(result);
   }
 
-  static void apply1(Skeleton skeleton, BonePose bone, double targetX, double targetY, bool compress, bool stretch, bool uniform, double mix) {
-    SpineBindings.bindings.spine_ik_constraint_apply_1(skeleton.nativePtr.cast(), bone.nativePtr.cast(), targetX, targetY, compress, stretch, uniform, mix);
+  static void apply(Skeleton skeleton, BonePose bone, double targetX,
+      double targetY, bool compress, bool stretch, bool uniform, double mix) {
+    SpineBindings.bindings.spine_ik_constraint_apply_1(
+        skeleton.nativePtr.cast(),
+        bone.nativePtr.cast(),
+        targetX,
+        targetY,
+        compress,
+        stretch,
+        uniform,
+        mix);
   }
 
-  static void apply2(Skeleton skeleton, BonePose parent, BonePose child, 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);
+  static void apply2(
+      Skeleton skeleton,
+      BonePose parent,
+      BonePose child,
+      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);
   }
-
-  void dispose() {
-    SpineBindings.bindings.spine_ik_constraint_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/ik_constraint_data.dart

@@ -31,55 +31,92 @@
 
 import 'dart:ffi';
 import 'package:ffi/ffi.dart';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 import 'rtti.dart';
-import 'constraint.dart';
-import 'skeleton.dart';
-import 'bone_data.dart';
-import 'ik_constraint_pose.dart';
 import 'arrays.dart';
+import 'bone_data.dart';
+import 'constraint.dart';
+import 'constraint_data.dart';
+import 'ik_constraint.dart';
+import 'ik_constraint_pose.dart';
+import 'path_constraint.dart';
+import 'physics_constraint.dart';
+import 'posed_data.dart';
+import 'skeleton.dart';
+import 'slider.dart';
+import 'transform_constraint.dart';
 
 /// IkConstraintData wrapper
-class IkConstraintData implements Finalizable {
+class IkConstraintData extends PosedData implements ConstraintData {
   final Pointer<spine_ik_constraint_data_wrapper> _ptr;
 
-  IkConstraintData.fromPointer(this._ptr);
+  IkConstraintData.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
   factory IkConstraintData(String name) {
-    final ptr = SpineBindings.bindings.spine_ik_constraint_data_create(name.toNativeUtf8().cast<Char>());
+    final ptr = SpineBindings.bindings
+        .spine_ik_constraint_data_create(name.toNativeUtf8().cast<Char>());
     return IkConstraintData.fromPointer(ptr);
   }
 
+  @override
   Rtti get rtti {
-    final result = SpineBindings.bindings.spine_ik_constraint_data_get_rtti(_ptr);
+    final result =
+        SpineBindings.bindings.spine_ik_constraint_data_get_rtti(_ptr);
     return Rtti.fromPointer(result);
   }
 
+  @override
   Constraint createMethod(Skeleton skeleton) {
-    final result = SpineBindings.bindings.spine_ik_constraint_data_create_method(_ptr, skeleton.nativePtr.cast());
-    throw UnsupportedError('Cannot instantiate abstract class Constraint from pointer - no concrete subclasses found');
+    final result = SpineBindings.bindings
+        .spine_ik_constraint_data_create_method(
+            _ptr, skeleton.nativePtr.cast());
+    final rtti = SpineBindings.bindings.spine_constraint_get_rtti(result);
+    final className = SpineBindings.bindings
+        .spine_rtti_get_class_name(rtti)
+        .cast<Utf8>()
+        .toDartString();
+    switch (className) {
+      case 'spine_ik_constraint':
+        return IkConstraint.fromPointer(result.cast());
+      case 'spine_path_constraint':
+        return PathConstraint.fromPointer(result.cast());
+      case 'spine_physics_constraint':
+        return PhysicsConstraint.fromPointer(result.cast());
+      case 'spine_slider':
+        return Slider.fromPointer(result.cast());
+      case 'spine_transform_constraint':
+        return TransformConstraint.fromPointer(result.cast());
+      default:
+        throw UnsupportedError(
+            'Unknown concrete type: $className for abstract class Constraint');
+    }
   }
 
   ArrayBoneData get bones {
-    final result = SpineBindings.bindings.spine_ik_constraint_data_get_bones(_ptr);
+    final result =
+        SpineBindings.bindings.spine_ik_constraint_data_get_bones(_ptr);
     return ArrayBoneData.fromPointer(result);
   }
 
   BoneData get target {
-    final result = SpineBindings.bindings.spine_ik_constraint_data_get_target(_ptr);
+    final result =
+        SpineBindings.bindings.spine_ik_constraint_data_get_target(_ptr);
     return BoneData.fromPointer(result);
   }
 
   set target(BoneData value) {
-    SpineBindings.bindings.spine_ik_constraint_data_set_target(_ptr, value.nativePtr.cast());
+    SpineBindings.bindings
+        .spine_ik_constraint_data_set_target(_ptr, value.nativePtr.cast());
   }
 
   bool get uniform {
-    final result = SpineBindings.bindings.spine_ik_constraint_data_get_uniform(_ptr);
+    final result =
+        SpineBindings.bindings.spine_ik_constraint_data_get_uniform(_ptr);
     return result;
   }
 
@@ -87,31 +124,14 @@ class IkConstraintData implements Finalizable {
     SpineBindings.bindings.spine_ik_constraint_data_set_uniform(_ptr, value);
   }
 
-  String get name {
-    final result = SpineBindings.bindings.spine_ik_constraint_data_get_name(_ptr);
-    return result.cast<Utf8>().toDartString();
-  }
-
-  bool get skinRequired {
-    final result = SpineBindings.bindings.spine_ik_constraint_data_get_skin_required(_ptr);
-    return result;
-  }
-
   IkConstraintPose get setupPose {
-    final result = SpineBindings.bindings.spine_ik_constraint_data_get_setup_pose(_ptr);
+    final result =
+        SpineBindings.bindings.spine_ik_constraint_data_get_setup_pose(_ptr);
     return IkConstraintPose.fromPointer(result);
   }
 
-  set skinRequired(bool value) {
-    SpineBindings.bindings.spine_ik_constraint_data_set_skin_required(_ptr, value);
-  }
-
   static Rtti rttiStatic() {
     final result = SpineBindings.bindings.spine_ik_constraint_data_rtti();
     return Rtti.fromPointer(result);
   }
-
-  void dispose() {
-    SpineBindings.bindings.spine_ik_constraint_data_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/ik_constraint_pose.dart

@@ -30,7 +30,7 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 
 /// IkConstraintPose wrapper
@@ -48,11 +48,13 @@ class IkConstraintPose implements Finalizable {
   }
 
   void set(IkConstraintPose pose) {
-    SpineBindings.bindings.spine_ik_constraint_pose_set(_ptr, pose.nativePtr.cast());
+    SpineBindings.bindings
+        .spine_ik_constraint_pose_set(_ptr, pose.nativePtr.cast());
   }
 
   double get mix {
-    final result = SpineBindings.bindings.spine_ik_constraint_pose_get_mix(_ptr);
+    final result =
+        SpineBindings.bindings.spine_ik_constraint_pose_get_mix(_ptr);
     return result;
   }
 
@@ -61,7 +63,8 @@ class IkConstraintPose implements Finalizable {
   }
 
   double get softness {
-    final result = SpineBindings.bindings.spine_ik_constraint_pose_get_softness(_ptr);
+    final result =
+        SpineBindings.bindings.spine_ik_constraint_pose_get_softness(_ptr);
     return result;
   }
 
@@ -70,16 +73,19 @@ class IkConstraintPose implements Finalizable {
   }
 
   int get bendDirection {
-    final result = SpineBindings.bindings.spine_ik_constraint_pose_get_bend_direction(_ptr);
+    final result = SpineBindings.bindings
+        .spine_ik_constraint_pose_get_bend_direction(_ptr);
     return result;
   }
 
   set bendDirection(int value) {
-    SpineBindings.bindings.spine_ik_constraint_pose_set_bend_direction(_ptr, value);
+    SpineBindings.bindings
+        .spine_ik_constraint_pose_set_bend_direction(_ptr, value);
   }
 
   bool get compress {
-    final result = SpineBindings.bindings.spine_ik_constraint_pose_get_compress(_ptr);
+    final result =
+        SpineBindings.bindings.spine_ik_constraint_pose_get_compress(_ptr);
     return result;
   }
 
@@ -88,15 +94,12 @@ class IkConstraintPose implements Finalizable {
   }
 
   bool get stretch {
-    final result = SpineBindings.bindings.spine_ik_constraint_pose_get_stretch(_ptr);
+    final result =
+        SpineBindings.bindings.spine_ik_constraint_pose_get_stretch(_ptr);
     return result;
   }
 
   set stretch(bool value) {
     SpineBindings.bindings.spine_ik_constraint_pose_set_stretch(_ptr, value);
   }
-
-  void dispose() {
-    SpineBindings.bindings.spine_ik_constraint_pose_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/ik_constraint_timeline.dart

@@ -30,12 +30,13 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
+import 'constraint_timeline.dart';
 import 'curve_timeline.dart';
 
 /// IkConstraintTimeline wrapper
-class IkConstraintTimeline extends CurveTimeline {
+class IkConstraintTimeline extends CurveTimeline implements ConstraintTimeline {
   final Pointer<spine_ik_constraint_timeline_wrapper> _ptr;
 
   IkConstraintTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
@@ -44,26 +45,29 @@ class IkConstraintTimeline extends CurveTimeline {
   @override
   Pointer get nativePtr => _ptr;
 
-  factory IkConstraintTimeline(int frameCount, int bezierCount, int constraintIndex) {
-    final ptr = SpineBindings.bindings.spine_ik_constraint_timeline_create(frameCount, bezierCount, constraintIndex);
+  factory IkConstraintTimeline(
+      int frameCount, int bezierCount, int 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, int bendDirection, bool compress, bool stretch) {
-    SpineBindings.bindings.spine_ik_constraint_timeline_set_frame(_ptr, frame, time, mix, softness, bendDirection, compress, stretch);
-  }
-
-  int get constraintIndex {
-    final result = SpineBindings.bindings.spine_ik_constraint_timeline_get_constraint_index(_ptr);
-    return result;
-  }
-
-  set constraintIndex(int value) {
-    SpineBindings.bindings.spine_ik_constraint_timeline_set_constraint_index(_ptr, value);
+  void setFrame(int frame, double time, double mix, double softness,
+      int bendDirection, bool compress, bool stretch) {
+    SpineBindings.bindings.spine_ik_constraint_timeline_set_frame(
+        _ptr, frame, time, mix, softness, bendDirection, compress, stretch);
   }
 
   @override
-  void dispose() {
-    SpineBindings.bindings.spine_ik_constraint_timeline_dispose(_ptr);
+  int get constraintIndex {
+    final result = SpineBindings.bindings
+        .spine_ik_constraint_timeline_get_constraint_index(_ptr);
+    return result;
   }
-}
+
+  @override
+  set constraintIndex(int value) {
+    SpineBindings.bindings
+        .spine_ik_constraint_timeline_set_constraint_index(_ptr, value);
+  }
+}

spine-flutter/lib/generated/inherit.dart

@@ -32,10 +32,10 @@
 /// Inherit enum
 enum Inherit {
   normal(0),
-  onlyTranslation(1),
-  noRotationOrReflection(2),
-  noScale(3),
-  noScaleOrReflection(4);
+  onlyTranslation(0),
+  noRotationOrReflection(0),
+  noScale(0),
+  noScaleOrReflection(0);
 
   const Inherit(this.value);
   final int value;
@@ -46,4 +46,4 @@ enum Inherit {
       orElse: () => throw ArgumentError('Invalid Inherit value: $value'),
     );
   }
-}
+}

spine-flutter/lib/generated/inherit_timeline.dart

@@ -30,13 +30,14 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
-import 'timeline.dart';
+import 'bone_timeline.dart';
 import 'inherit.dart';
+import 'timeline.dart';
 
 /// InheritTimeline wrapper
-class InheritTimeline extends Timeline {
+class InheritTimeline extends Timeline implements BoneTimeline {
   final Pointer<spine_inherit_timeline_wrapper> _ptr;
 
   InheritTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
@@ -46,25 +47,25 @@ class InheritTimeline extends Timeline {
   Pointer get nativePtr => _ptr;
 
   factory InheritTimeline(int frameCount, int boneIndex) {
-    final ptr = SpineBindings.bindings.spine_inherit_timeline_create(frameCount, boneIndex);
+    final ptr = SpineBindings.bindings
+        .spine_inherit_timeline_create(frameCount, boneIndex);
     return InheritTimeline.fromPointer(ptr);
   }
 
   void setFrame(int frame, double time, Inherit inherit) {
-    SpineBindings.bindings.spine_inherit_timeline_set_frame(_ptr, frame, time, inherit.value);
-  }
-
-  int get boneIndex {
-    final result = SpineBindings.bindings.spine_inherit_timeline_get_bone_index(_ptr);
-    return result;
-  }
-
-  set boneIndex(int value) {
-    SpineBindings.bindings.spine_inherit_timeline_set_bone_index(_ptr, value);
+    SpineBindings.bindings
+        .spine_inherit_timeline_set_frame(_ptr, frame, time, inherit.value);
   }
 
   @override
-  void dispose() {
-    SpineBindings.bindings.spine_inherit_timeline_dispose(_ptr);
+  int get boneIndex {
+    final result =
+        SpineBindings.bindings.spine_inherit_timeline_get_bone_index(_ptr);
+    return result;
   }
-}
+
+  @override
+  set boneIndex(int value) {
+    SpineBindings.bindings.spine_inherit_timeline_set_bone_index(_ptr, value);
+  }
+}

spine-flutter/lib/generated/linked_mesh.dart

@@ -30,31 +30,8 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'package:ffi/ffi.dart';
-import 'spine_flutter_bindings_generated.dart';
-import '../spine_bindings.dart';
-import 'mesh_attachment.dart';
 
 /// LinkedMesh wrapper
-class LinkedMesh implements Finalizable {
-  final Pointer<spine_linked_mesh_wrapper> _ptr;
-
-  LinkedMesh.fromPointer(this._ptr);
-
-  /// Get the native pointer for FFI calls
-  Pointer get nativePtr => _ptr;
-
-  factory LinkedMesh(MeshAttachment mesh, dynamic skinIndex, int slotIndex, String parent, bool inheritTimelines) {
-    final ptr = SpineBindings.bindings.spine_linked_mesh_create(mesh.nativePtr.cast(), skinIndex, slotIndex, parent.toNativeUtf8().cast<Char>(), inheritTimelines);
-    return LinkedMesh.fromPointer(ptr);
-  }
-
-  factory LinkedMesh.variant2(MeshAttachment mesh, String skin, int slotIndex, String parent, bool inheritTimelines) {
-    final ptr = SpineBindings.bindings.spine_linked_mesh_create2(mesh.nativePtr.cast(), skin.toNativeUtf8().cast<Char>(), slotIndex, parent.toNativeUtf8().cast<Char>(), inheritTimelines);
-    return LinkedMesh.fromPointer(ptr);
-  }
-
-  void dispose() {
-    SpineBindings.bindings.spine_linked_mesh_dispose(_ptr);
-  }
-}
+abstract class LinkedMesh {
+  Pointer get nativePtr;
+}

spine-flutter/lib/generated/mesh_attachment.dart

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

spine-flutter/lib/generated/mix_blend.dart

@@ -32,9 +32,9 @@
 /// MixBlend enum
 enum MixBlend {
   setup(0),
-  first(1),
-  replace(2),
-  add(3);
+  first(0),
+  replace(0),
+  add(0);
 
   const MixBlend(this.value);
   final int value;
@@ -45,4 +45,4 @@ enum MixBlend {
       orElse: () => throw ArgumentError('Invalid MixBlend value: $value'),
     );
   }
-}
+}

spine-flutter/lib/generated/mix_direction.dart

@@ -32,7 +32,7 @@
 /// MixDirection enum
 enum MixDirection {
   directionIn(0),
-  directionOut(1);
+  directionOut(0);
 
   const MixDirection(this.value);
   final int value;
@@ -43,4 +43,4 @@ enum MixDirection {
       orElse: () => throw ArgumentError('Invalid MixDirection value: $value'),
     );
   }
-}
+}

spine-flutter/lib/generated/path_attachment.dart

@@ -31,11 +31,11 @@
 
 import 'dart:ffi';
 import 'package:ffi/ffi.dart';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
-import 'vertex_attachment.dart';
-import 'color.dart';
 import 'arrays.dart';
+import 'color.dart';
+import 'vertex_attachment.dart';
 
 /// PathAttachment wrapper
 class PathAttachment extends VertexAttachment {
@@ -48,21 +48,25 @@ class PathAttachment extends VertexAttachment {
   Pointer get nativePtr => _ptr;
 
   factory PathAttachment(String name) {
-    final ptr = SpineBindings.bindings.spine_path_attachment_create(name.toNativeUtf8().cast<Char>());
+    final ptr = SpineBindings.bindings
+        .spine_path_attachment_create(name.toNativeUtf8().cast<Char>());
     return PathAttachment.fromPointer(ptr);
   }
 
   ArrayFloat get lengths {
-    final result = SpineBindings.bindings.spine_path_attachment_get_lengths(_ptr);
+    final result =
+        SpineBindings.bindings.spine_path_attachment_get_lengths(_ptr);
     return ArrayFloat.fromPointer(result);
   }
 
   set lengths(ArrayFloat value) {
-    SpineBindings.bindings.spine_path_attachment_set_lengths(_ptr, value.nativePtr.cast());
+    SpineBindings.bindings
+        .spine_path_attachment_set_lengths(_ptr, value.nativePtr.cast());
   }
 
   bool get closed {
-    final result = SpineBindings.bindings.spine_path_attachment_get_closed(_ptr);
+    final result =
+        SpineBindings.bindings.spine_path_attachment_get_closed(_ptr);
     return result;
   }
 
@@ -71,21 +75,18 @@ class PathAttachment extends VertexAttachment {
   }
 
   bool get constantSpeed {
-    final result = SpineBindings.bindings.spine_path_attachment_get_constant_speed(_ptr);
+    final result =
+        SpineBindings.bindings.spine_path_attachment_get_constant_speed(_ptr);
     return result;
   }
 
   set constantSpeed(bool value) {
-    SpineBindings.bindings.spine_path_attachment_set_constant_speed(_ptr, value);
+    SpineBindings.bindings
+        .spine_path_attachment_set_constant_speed(_ptr, value);
   }
 
   Color get color {
     final result = SpineBindings.bindings.spine_path_attachment_get_color(_ptr);
     return Color.fromPointer(result);
   }
-
-  @override
-  void dispose() {
-    SpineBindings.bindings.spine_path_attachment_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/path_constraint.dart

@@ -30,50 +30,63 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 import 'rtti.dart';
-import 'skeleton.dart';
-import 'physics.dart';
-import 'slot.dart';
+import 'arrays.dart';
+import 'constraint.dart';
 import 'path_constraint_data.dart';
 import 'path_constraint_pose.dart';
-import 'arrays.dart';
+import 'physics.dart';
+import 'posed.dart';
+import 'posed_active.dart';
+import 'skeleton.dart';
+import 'slot.dart';
 
 /// PathConstraint wrapper
-class PathConstraint implements Finalizable {
+class PathConstraint extends PosedActive implements Posed, Constraint {
   final Pointer<spine_path_constraint_wrapper> _ptr;
 
-  PathConstraint.fromPointer(this._ptr);
+  PathConstraint.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
   factory PathConstraint(PathConstraintData data, Skeleton skeleton) {
-    final ptr = SpineBindings.bindings.spine_path_constraint_create(data.nativePtr.cast(), skeleton.nativePtr.cast());
+    final ptr = SpineBindings.bindings.spine_path_constraint_create(
+        data.nativePtr.cast(), skeleton.nativePtr.cast());
     return PathConstraint.fromPointer(ptr);
   }
 
+  @override
   Rtti get rtti {
     final result = SpineBindings.bindings.spine_path_constraint_get_rtti(_ptr);
     return Rtti.fromPointer(result);
   }
 
   PathConstraint copy(Skeleton skeleton) {
-    final result = SpineBindings.bindings.spine_path_constraint_copy(_ptr, skeleton.nativePtr.cast());
+    final result = SpineBindings.bindings
+        .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(_ptr, skeleton.nativePtr.cast(), physics.value);
+    SpineBindings.bindings.spine_path_constraint_update(
+        _ptr, skeleton.nativePtr.cast(), physics.value);
   }
 
+  @override
   void sort(Skeleton skeleton) {
-    SpineBindings.bindings.spine_path_constraint_sort(_ptr, skeleton.nativePtr.cast());
+    SpineBindings.bindings
+        .spine_path_constraint_sort(_ptr, skeleton.nativePtr.cast());
   }
 
+  @override
   bool get isSourceActive {
-    final result = SpineBindings.bindings.spine_path_constraint_is_source_active(_ptr);
+    final result =
+        SpineBindings.bindings.spine_path_constraint_is_source_active(_ptr);
     return result;
   }
 
@@ -88,9 +101,11 @@ class PathConstraint implements Finalizable {
   }
 
   set slot(Slot value) {
-    SpineBindings.bindings.spine_path_constraint_set_slot(_ptr, value.nativePtr.cast());
+    SpineBindings.bindings
+        .spine_path_constraint_set_slot(_ptr, value.nativePtr.cast());
   }
 
+  @override
   PathConstraintData get data {
     final result = SpineBindings.bindings.spine_path_constraint_get_data(_ptr);
     return PathConstraintData.fromPointer(result);
@@ -102,38 +117,30 @@ class PathConstraint implements Finalizable {
   }
 
   PathConstraintPose get appliedPose {
-    final result = SpineBindings.bindings.spine_path_constraint_get_applied_pose(_ptr);
+    final result =
+        SpineBindings.bindings.spine_path_constraint_get_applied_pose(_ptr);
     return PathConstraintPose.fromPointer(result);
   }
 
+  @override
   void resetConstrained() {
     SpineBindings.bindings.spine_path_constraint_reset_constrained(_ptr);
   }
 
+  @override
   void constrained() {
     SpineBindings.bindings.spine_path_constraint_constrained(_ptr);
   }
 
+  @override
   bool get isPoseEqualToApplied {
-    final result = SpineBindings.bindings.spine_path_constraint_is_pose_equal_to_applied(_ptr);
+    final result = SpineBindings.bindings
+        .spine_path_constraint_is_pose_equal_to_applied(_ptr);
     return result;
   }
 
-  bool get isActive {
-    final result = SpineBindings.bindings.spine_path_constraint_is_active(_ptr);
-    return result;
-  }
-
-  set active(bool value) {
-    SpineBindings.bindings.spine_path_constraint_set_active(_ptr, value);
-  }
-
   static Rtti rttiStatic() {
     final result = SpineBindings.bindings.spine_path_constraint_rtti();
     return Rtti.fromPointer(result);
   }
-
-  void dispose() {
-    SpineBindings.bindings.spine_path_constraint_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/path_constraint_data.dart

@@ -31,117 +31,144 @@
 
 import 'dart:ffi';
 import 'package:ffi/ffi.dart';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 import 'rtti.dart';
-import 'constraint.dart';
-import 'skeleton.dart';
-import 'slot_data.dart';
-import 'position_mode.dart';
-import 'spacing_mode.dart';
-import 'rotate_mode.dart';
-import 'path_constraint_pose.dart';
 import 'arrays.dart';
+import 'constraint.dart';
+import 'constraint_data.dart';
+import 'ik_constraint.dart';
+import 'path_constraint.dart';
+import 'path_constraint_pose.dart';
+import 'physics_constraint.dart';
+import 'posed_data.dart';
+import 'position_mode.dart';
+import 'rotate_mode.dart';
+import 'skeleton.dart';
+import 'slider.dart';
+import 'slot_data.dart';
+import 'spacing_mode.dart';
+import 'transform_constraint.dart';
 
 /// PathConstraintData wrapper
-class PathConstraintData implements Finalizable {
+class PathConstraintData extends PosedData implements ConstraintData {
   final Pointer<spine_path_constraint_data_wrapper> _ptr;
 
-  PathConstraintData.fromPointer(this._ptr);
+  PathConstraintData.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
   factory PathConstraintData(String name) {
-    final ptr = SpineBindings.bindings.spine_path_constraint_data_create(name.toNativeUtf8().cast<Char>());
+    final ptr = SpineBindings.bindings
+        .spine_path_constraint_data_create(name.toNativeUtf8().cast<Char>());
     return PathConstraintData.fromPointer(ptr);
   }
 
+  @override
   Rtti get rtti {
-    final result = SpineBindings.bindings.spine_path_constraint_data_get_rtti(_ptr);
+    final result =
+        SpineBindings.bindings.spine_path_constraint_data_get_rtti(_ptr);
     return Rtti.fromPointer(result);
   }
 
+  @override
   Constraint createMethod(Skeleton skeleton) {
-    final result = SpineBindings.bindings.spine_path_constraint_data_create_method(_ptr, skeleton.nativePtr.cast());
-    throw UnsupportedError('Cannot instantiate abstract class Constraint from pointer - no concrete subclasses found');
+    final result = SpineBindings.bindings
+        .spine_path_constraint_data_create_method(
+            _ptr, skeleton.nativePtr.cast());
+    final rtti = SpineBindings.bindings.spine_constraint_get_rtti(result);
+    final className = SpineBindings.bindings
+        .spine_rtti_get_class_name(rtti)
+        .cast<Utf8>()
+        .toDartString();
+    switch (className) {
+      case 'spine_ik_constraint':
+        return IkConstraint.fromPointer(result.cast());
+      case 'spine_path_constraint':
+        return PathConstraint.fromPointer(result.cast());
+      case 'spine_physics_constraint':
+        return PhysicsConstraint.fromPointer(result.cast());
+      case 'spine_slider':
+        return Slider.fromPointer(result.cast());
+      case 'spine_transform_constraint':
+        return TransformConstraint.fromPointer(result.cast());
+      default:
+        throw UnsupportedError(
+            'Unknown concrete type: $className for abstract class Constraint');
+    }
   }
 
   ArrayBoneData get bones {
-    final result = SpineBindings.bindings.spine_path_constraint_data_get_bones(_ptr);
+    final result =
+        SpineBindings.bindings.spine_path_constraint_data_get_bones(_ptr);
     return ArrayBoneData.fromPointer(result);
   }
 
   SlotData get slot {
-    final result = SpineBindings.bindings.spine_path_constraint_data_get_slot(_ptr);
+    final result =
+        SpineBindings.bindings.spine_path_constraint_data_get_slot(_ptr);
     return SlotData.fromPointer(result);
   }
 
   set slot(SlotData value) {
-    SpineBindings.bindings.spine_path_constraint_data_set_slot(_ptr, value.nativePtr.cast());
+    SpineBindings.bindings
+        .spine_path_constraint_data_set_slot(_ptr, value.nativePtr.cast());
   }
 
   PositionMode get positionMode {
-    final result = SpineBindings.bindings.spine_path_constraint_data_get_position_mode(_ptr);
+    final result = SpineBindings.bindings
+        .spine_path_constraint_data_get_position_mode(_ptr);
     return PositionMode.fromValue(result);
   }
 
   set positionMode(PositionMode value) {
-    SpineBindings.bindings.spine_path_constraint_data_set_position_mode(_ptr, value.value);
+    SpineBindings.bindings
+        .spine_path_constraint_data_set_position_mode(_ptr, value.value);
   }
 
   SpacingMode get spacingMode {
-    final result = SpineBindings.bindings.spine_path_constraint_data_get_spacing_mode(_ptr);
+    final result = SpineBindings.bindings
+        .spine_path_constraint_data_get_spacing_mode(_ptr);
     return SpacingMode.fromValue(result);
   }
 
   set spacingMode(SpacingMode value) {
-    SpineBindings.bindings.spine_path_constraint_data_set_spacing_mode(_ptr, value.value);
+    SpineBindings.bindings
+        .spine_path_constraint_data_set_spacing_mode(_ptr, value.value);
   }
 
   RotateMode get rotateMode {
-    final result = SpineBindings.bindings.spine_path_constraint_data_get_rotate_mode(_ptr);
+    final result =
+        SpineBindings.bindings.spine_path_constraint_data_get_rotate_mode(_ptr);
     return RotateMode.fromValue(result);
   }
 
   set rotateMode(RotateMode value) {
-    SpineBindings.bindings.spine_path_constraint_data_set_rotate_mode(_ptr, value.value);
+    SpineBindings.bindings
+        .spine_path_constraint_data_set_rotate_mode(_ptr, value.value);
   }
 
   double get offsetRotation {
-    final result = SpineBindings.bindings.spine_path_constraint_data_get_offset_rotation(_ptr);
+    final result = SpineBindings.bindings
+        .spine_path_constraint_data_get_offset_rotation(_ptr);
     return result;
   }
 
   set offsetRotation(double value) {
-    SpineBindings.bindings.spine_path_constraint_data_set_offset_rotation(_ptr, value);
-  }
-
-  String get name {
-    final result = SpineBindings.bindings.spine_path_constraint_data_get_name(_ptr);
-    return result.cast<Utf8>().toDartString();
-  }
-
-  bool get skinRequired {
-    final result = SpineBindings.bindings.spine_path_constraint_data_get_skin_required(_ptr);
-    return result;
+    SpineBindings.bindings
+        .spine_path_constraint_data_set_offset_rotation(_ptr, value);
   }
 
   PathConstraintPose get setupPose {
-    final result = SpineBindings.bindings.spine_path_constraint_data_get_setup_pose(_ptr);
+    final result =
+        SpineBindings.bindings.spine_path_constraint_data_get_setup_pose(_ptr);
     return PathConstraintPose.fromPointer(result);
   }
 
-  set skinRequired(bool value) {
-    SpineBindings.bindings.spine_path_constraint_data_set_skin_required(_ptr, value);
-  }
-
   static Rtti rttiStatic() {
     final result = SpineBindings.bindings.spine_path_constraint_data_rtti();
     return Rtti.fromPointer(result);
   }
-
-  void dispose() {
-    SpineBindings.bindings.spine_path_constraint_data_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/path_constraint_mix_timeline.dart

@@ -30,40 +30,47 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
+import 'constraint_timeline.dart';
 import 'curve_timeline.dart';
 
 /// PathConstraintMixTimeline wrapper
-class PathConstraintMixTimeline extends CurveTimeline {
+class PathConstraintMixTimeline extends CurveTimeline
+    implements ConstraintTimeline {
   final Pointer<spine_path_constraint_mix_timeline_wrapper> _ptr;
 
-  PathConstraintMixTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
+  PathConstraintMixTimeline.fromPointer(this._ptr)
+      : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
   @override
   Pointer get nativePtr => _ptr;
 
-  factory PathConstraintMixTimeline(int frameCount, int bezierCount, int constraintIndex) {
-    final ptr = SpineBindings.bindings.spine_path_constraint_mix_timeline_create(frameCount, bezierCount, constraintIndex);
+  factory PathConstraintMixTimeline(
+      int frameCount, int bezierCount, int constraintIndex) {
+    final ptr = SpineBindings.bindings
+        .spine_path_constraint_mix_timeline_create(
+            frameCount, bezierCount, constraintIndex);
     return PathConstraintMixTimeline.fromPointer(ptr);
   }
 
-  void setFrame(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);
-  }
-
-  int get constraintIndex {
-    final result = SpineBindings.bindings.spine_path_constraint_mix_timeline_get_constraint_index(_ptr);
-    return result;
-  }
-
-  set constraintIndex(int value) {
-    SpineBindings.bindings.spine_path_constraint_mix_timeline_set_constraint_index(_ptr, value);
+  void setFrame(
+      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);
   }
 
   @override
-  void dispose() {
-    SpineBindings.bindings.spine_path_constraint_mix_timeline_dispose(_ptr);
+  int get constraintIndex {
+    final result = SpineBindings.bindings
+        .spine_path_constraint_mix_timeline_get_constraint_index(_ptr);
+    return result;
   }
-}
+
+  @override
+  set constraintIndex(int value) {
+    SpineBindings.bindings
+        .spine_path_constraint_mix_timeline_set_constraint_index(_ptr, value);
+  }
+}

spine-flutter/lib/generated/path_constraint_pose.dart

@@ -30,7 +30,7 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 
 /// PathConstraintPose wrapper
@@ -48,11 +48,13 @@ class PathConstraintPose implements Finalizable {
   }
 
   void set(PathConstraintPose pose) {
-    SpineBindings.bindings.spine_path_constraint_pose_set(_ptr, pose.nativePtr.cast());
+    SpineBindings.bindings
+        .spine_path_constraint_pose_set(_ptr, pose.nativePtr.cast());
   }
 
   double get position {
-    final result = SpineBindings.bindings.spine_path_constraint_pose_get_position(_ptr);
+    final result =
+        SpineBindings.bindings.spine_path_constraint_pose_get_position(_ptr);
     return result;
   }
 
@@ -61,7 +63,8 @@ class PathConstraintPose implements Finalizable {
   }
 
   double get spacing {
-    final result = SpineBindings.bindings.spine_path_constraint_pose_get_spacing(_ptr);
+    final result =
+        SpineBindings.bindings.spine_path_constraint_pose_get_spacing(_ptr);
     return result;
   }
 
@@ -70,16 +73,19 @@ class PathConstraintPose implements Finalizable {
   }
 
   double get mixRotate {
-    final result = SpineBindings.bindings.spine_path_constraint_pose_get_mix_rotate(_ptr);
+    final result =
+        SpineBindings.bindings.spine_path_constraint_pose_get_mix_rotate(_ptr);
     return result;
   }
 
   set mixRotate(double value) {
-    SpineBindings.bindings.spine_path_constraint_pose_set_mix_rotate(_ptr, value);
+    SpineBindings.bindings
+        .spine_path_constraint_pose_set_mix_rotate(_ptr, value);
   }
 
   double get mixX {
-    final result = SpineBindings.bindings.spine_path_constraint_pose_get_mix_x(_ptr);
+    final result =
+        SpineBindings.bindings.spine_path_constraint_pose_get_mix_x(_ptr);
     return result;
   }
 
@@ -88,15 +94,12 @@ class PathConstraintPose implements Finalizable {
   }
 
   double get mixY {
-    final result = SpineBindings.bindings.spine_path_constraint_pose_get_mix_y(_ptr);
+    final result =
+        SpineBindings.bindings.spine_path_constraint_pose_get_mix_y(_ptr);
     return result;
   }
 
   set mixY(double value) {
     SpineBindings.bindings.spine_path_constraint_pose_set_mix_y(_ptr, value);
   }
-
-  void dispose() {
-    SpineBindings.bindings.spine_path_constraint_pose_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/path_constraint_position_timeline.dart

@@ -30,7 +30,7 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 import 'constraint_timeline1.dart';
 
@@ -38,19 +38,18 @@ import 'constraint_timeline1.dart';
 class PathConstraintPositionTimeline extends ConstraintTimeline1 {
   final Pointer<spine_path_constraint_position_timeline_wrapper> _ptr;
 
-  PathConstraintPositionTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
+  PathConstraintPositionTimeline.fromPointer(this._ptr)
+      : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
   @override
   Pointer get nativePtr => _ptr;
 
-  factory PathConstraintPositionTimeline(int frameCount, int bezierCount, int constraintIndex) {
-    final ptr = SpineBindings.bindings.spine_path_constraint_position_timeline_create(frameCount, bezierCount, constraintIndex);
+  factory PathConstraintPositionTimeline(
+      int frameCount, int bezierCount, int constraintIndex) {
+    final ptr = SpineBindings.bindings
+        .spine_path_constraint_position_timeline_create(
+            frameCount, bezierCount, constraintIndex);
     return PathConstraintPositionTimeline.fromPointer(ptr);
   }
-
-  @override
-  void dispose() {
-    SpineBindings.bindings.spine_path_constraint_position_timeline_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/path_constraint_spacing_timeline.dart

@@ -30,7 +30,7 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 import 'constraint_timeline1.dart';
 
@@ -38,19 +38,18 @@ import 'constraint_timeline1.dart';
 class PathConstraintSpacingTimeline extends ConstraintTimeline1 {
   final Pointer<spine_path_constraint_spacing_timeline_wrapper> _ptr;
 
-  PathConstraintSpacingTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
+  PathConstraintSpacingTimeline.fromPointer(this._ptr)
+      : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
   @override
   Pointer get nativePtr => _ptr;
 
-  factory PathConstraintSpacingTimeline(int frameCount, int bezierCount, int constraintIndex) {
-    final ptr = SpineBindings.bindings.spine_path_constraint_spacing_timeline_create(frameCount, bezierCount, constraintIndex);
+  factory PathConstraintSpacingTimeline(
+      int frameCount, int bezierCount, int constraintIndex) {
+    final ptr = SpineBindings.bindings
+        .spine_path_constraint_spacing_timeline_create(
+            frameCount, bezierCount, constraintIndex);
     return PathConstraintSpacingTimeline.fromPointer(ptr);
   }
-
-  @override
-  void dispose() {
-    SpineBindings.bindings.spine_path_constraint_spacing_timeline_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/physics.dart

@@ -32,9 +32,9 @@
 /// Physics enum
 enum Physics {
   none(0),
-  reset(1),
-  update(2),
-  pose(3);
+  reset(0),
+  update(0),
+  pose(0);
 
   const Physics(this.value);
   final int value;
@@ -45,4 +45,4 @@ enum Physics {
       orElse: () => throw ArgumentError('Invalid Physics value: $value'),
     );
   }
-}
+}

spine-flutter/lib/generated/physics_constraint.dart

@@ -30,54 +30,69 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 import 'rtti.dart';
-import 'skeleton.dart';
-import 'physics.dart';
 import 'bone_pose.dart';
+import 'constraint.dart';
+import 'physics.dart';
 import 'physics_constraint_data.dart';
 import 'physics_constraint_pose.dart';
+import 'posed.dart';
+import 'posed_active.dart';
+import 'skeleton.dart';
 
 /// PhysicsConstraint wrapper
-class PhysicsConstraint implements Finalizable {
+class PhysicsConstraint extends PosedActive implements Posed, Constraint {
   final Pointer<spine_physics_constraint_wrapper> _ptr;
 
-  PhysicsConstraint.fromPointer(this._ptr);
+  PhysicsConstraint.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
   factory PhysicsConstraint(PhysicsConstraintData data, Skeleton skeleton) {
-    final ptr = SpineBindings.bindings.spine_physics_constraint_create(data.nativePtr.cast(), skeleton.nativePtr.cast());
+    final ptr = SpineBindings.bindings.spine_physics_constraint_create(
+        data.nativePtr.cast(), skeleton.nativePtr.cast());
     return PhysicsConstraint.fromPointer(ptr);
   }
 
+  @override
   Rtti get rtti {
-    final result = SpineBindings.bindings.spine_physics_constraint_get_rtti(_ptr);
+    final result =
+        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(_ptr, skeleton.nativePtr.cast(), physics.value);
+    SpineBindings.bindings.spine_physics_constraint_update(
+        _ptr, skeleton.nativePtr.cast(), physics.value);
   }
 
+  @override
   void sort(Skeleton skeleton) {
-    SpineBindings.bindings.spine_physics_constraint_sort(_ptr, skeleton.nativePtr.cast());
+    SpineBindings.bindings
+        .spine_physics_constraint_sort(_ptr, skeleton.nativePtr.cast());
   }
 
+  @override
   bool get isSourceActive {
-    final result = SpineBindings.bindings.spine_physics_constraint_is_source_active(_ptr);
+    final result =
+        SpineBindings.bindings.spine_physics_constraint_is_source_active(_ptr);
     return result;
   }
 
   PhysicsConstraint copy(Skeleton skeleton) {
-    final result = SpineBindings.bindings.spine_physics_constraint_copy(_ptr, skeleton.nativePtr.cast());
+    final result = SpineBindings.bindings
+        .spine_physics_constraint_copy(_ptr, skeleton.nativePtr.cast());
     return PhysicsConstraint.fromPointer(result);
   }
 
   void reset(Skeleton skeleton) {
-    SpineBindings.bindings.spine_physics_constraint_reset(_ptr, skeleton.nativePtr.cast());
+    SpineBindings.bindings
+        .spine_physics_constraint_reset(_ptr, skeleton.nativePtr.cast());
   }
 
   void translate(double x, double y) {
@@ -89,57 +104,54 @@ class PhysicsConstraint implements Finalizable {
   }
 
   BonePose get bone {
-    final result = SpineBindings.bindings.spine_physics_constraint_get_bone(_ptr);
+    final result =
+        SpineBindings.bindings.spine_physics_constraint_get_bone(_ptr);
     return BonePose.fromPointer(result);
   }
 
   set bone(BonePose value) {
-    SpineBindings.bindings.spine_physics_constraint_set_bone(_ptr, value.nativePtr.cast());
+    SpineBindings.bindings
+        .spine_physics_constraint_set_bone(_ptr, value.nativePtr.cast());
   }
 
+  @override
   PhysicsConstraintData get data {
-    final result = SpineBindings.bindings.spine_physics_constraint_get_data(_ptr);
+    final result =
+        SpineBindings.bindings.spine_physics_constraint_get_data(_ptr);
     return PhysicsConstraintData.fromPointer(result);
   }
 
   PhysicsConstraintPose get pose {
-    final result = SpineBindings.bindings.spine_physics_constraint_get_pose(_ptr);
+    final result =
+        SpineBindings.bindings.spine_physics_constraint_get_pose(_ptr);
     return PhysicsConstraintPose.fromPointer(result);
   }
 
   PhysicsConstraintPose get appliedPose {
-    final result = SpineBindings.bindings.spine_physics_constraint_get_applied_pose(_ptr);
+    final result =
+        SpineBindings.bindings.spine_physics_constraint_get_applied_pose(_ptr);
     return PhysicsConstraintPose.fromPointer(result);
   }
 
+  @override
   void resetConstrained() {
     SpineBindings.bindings.spine_physics_constraint_reset_constrained(_ptr);
   }
 
+  @override
   void constrained() {
     SpineBindings.bindings.spine_physics_constraint_constrained(_ptr);
   }
 
+  @override
   bool get isPoseEqualToApplied {
-    final result = SpineBindings.bindings.spine_physics_constraint_is_pose_equal_to_applied(_ptr);
+    final result = SpineBindings.bindings
+        .spine_physics_constraint_is_pose_equal_to_applied(_ptr);
     return result;
   }
 
-  bool get isActive {
-    final result = SpineBindings.bindings.spine_physics_constraint_is_active(_ptr);
-    return result;
-  }
-
-  set active(bool value) {
-    SpineBindings.bindings.spine_physics_constraint_set_active(_ptr, value);
-  }
-
   static Rtti rttiStatic() {
     final result = SpineBindings.bindings.spine_physics_constraint_rtti();
     return Rtti.fromPointer(result);
   }
-
-  void dispose() {
-    SpineBindings.bindings.spine_physics_constraint_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/physics_constraint_damping_timeline.dart

@@ -30,7 +30,7 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 import 'physics_constraint_timeline.dart';
 
@@ -38,19 +38,18 @@ import 'physics_constraint_timeline.dart';
 class PhysicsConstraintDampingTimeline extends PhysicsConstraintTimeline {
   final Pointer<spine_physics_constraint_damping_timeline_wrapper> _ptr;
 
-  PhysicsConstraintDampingTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
+  PhysicsConstraintDampingTimeline.fromPointer(this._ptr)
+      : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
   @override
   Pointer get nativePtr => _ptr;
 
-  factory PhysicsConstraintDampingTimeline(int frameCount, int bezierCount, int physicsConstraintIndex) {
-    final ptr = SpineBindings.bindings.spine_physics_constraint_damping_timeline_create(frameCount, bezierCount, physicsConstraintIndex);
+  factory PhysicsConstraintDampingTimeline(
+      int frameCount, int bezierCount, int physicsConstraintIndex) {
+    final ptr = SpineBindings.bindings
+        .spine_physics_constraint_damping_timeline_create(
+            frameCount, bezierCount, physicsConstraintIndex);
     return PhysicsConstraintDampingTimeline.fromPointer(ptr);
   }
-
-  @override
-  void dispose() {
-    SpineBindings.bindings.spine_physics_constraint_damping_timeline_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/physics_constraint_data.dart

@@ -31,49 +31,85 @@
 
 import 'dart:ffi';
 import 'package:ffi/ffi.dart';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 import 'rtti.dart';
-import 'constraint.dart';
-import 'skeleton.dart';
 import 'bone_data.dart';
+import 'constraint.dart';
+import 'constraint_data.dart';
+import 'ik_constraint.dart';
+import 'path_constraint.dart';
+import 'physics_constraint.dart';
 import 'physics_constraint_pose.dart';
+import 'posed_data.dart';
+import 'skeleton.dart';
+import 'slider.dart';
+import 'transform_constraint.dart';
 
 /// PhysicsConstraintData wrapper
-class PhysicsConstraintData implements Finalizable {
+class PhysicsConstraintData extends PosedData implements ConstraintData {
   final Pointer<spine_physics_constraint_data_wrapper> _ptr;
 
-  PhysicsConstraintData.fromPointer(this._ptr);
+  PhysicsConstraintData.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
+  @override
   Pointer get nativePtr => _ptr;
 
   factory PhysicsConstraintData(String name) {
-    final ptr = SpineBindings.bindings.spine_physics_constraint_data_create(name.toNativeUtf8().cast<Char>());
+    final ptr = SpineBindings.bindings
+        .spine_physics_constraint_data_create(name.toNativeUtf8().cast<Char>());
     return PhysicsConstraintData.fromPointer(ptr);
   }
 
+  @override
   Rtti get rtti {
-    final result = SpineBindings.bindings.spine_physics_constraint_data_get_rtti(_ptr);
+    final result =
+        SpineBindings.bindings.spine_physics_constraint_data_get_rtti(_ptr);
     return Rtti.fromPointer(result);
   }
 
+  @override
   Constraint createMethod(Skeleton skeleton) {
-    final result = SpineBindings.bindings.spine_physics_constraint_data_create_method(_ptr, skeleton.nativePtr.cast());
-    throw UnsupportedError('Cannot instantiate abstract class Constraint from pointer - no concrete subclasses found');
+    final result = SpineBindings.bindings
+        .spine_physics_constraint_data_create_method(
+            _ptr, skeleton.nativePtr.cast());
+    final rtti = SpineBindings.bindings.spine_constraint_get_rtti(result);
+    final className = SpineBindings.bindings
+        .spine_rtti_get_class_name(rtti)
+        .cast<Utf8>()
+        .toDartString();
+    switch (className) {
+      case 'spine_ik_constraint':
+        return IkConstraint.fromPointer(result.cast());
+      case 'spine_path_constraint':
+        return PathConstraint.fromPointer(result.cast());
+      case 'spine_physics_constraint':
+        return PhysicsConstraint.fromPointer(result.cast());
+      case 'spine_slider':
+        return Slider.fromPointer(result.cast());
+      case 'spine_transform_constraint':
+        return TransformConstraint.fromPointer(result.cast());
+      default:
+        throw UnsupportedError(
+            'Unknown concrete type: $className for abstract class Constraint');
+    }
   }
 
   BoneData get bone {
-    final result = SpineBindings.bindings.spine_physics_constraint_data_get_bone(_ptr);
+    final result =
+        SpineBindings.bindings.spine_physics_constraint_data_get_bone(_ptr);
     return BoneData.fromPointer(result);
   }
 
   set bone(BoneData value) {
-    SpineBindings.bindings.spine_physics_constraint_data_set_bone(_ptr, value.nativePtr.cast());
+    SpineBindings.bindings
+        .spine_physics_constraint_data_set_bone(_ptr, value.nativePtr.cast());
   }
 
   double get step {
-    final result = SpineBindings.bindings.spine_physics_constraint_data_get_step(_ptr);
+    final result =
+        SpineBindings.bindings.spine_physics_constraint_data_get_step(_ptr);
     return result;
   }
 
@@ -82,7 +118,8 @@ class PhysicsConstraintData implements Finalizable {
   }
 
   double get x {
-    final result = SpineBindings.bindings.spine_physics_constraint_data_get_x(_ptr);
+    final result =
+        SpineBindings.bindings.spine_physics_constraint_data_get_x(_ptr);
     return result;
   }
 
@@ -91,7 +128,8 @@ class PhysicsConstraintData implements Finalizable {
   }
 
   double get y {
-    final result = SpineBindings.bindings.spine_physics_constraint_data_get_y(_ptr);
+    final result =
+        SpineBindings.bindings.spine_physics_constraint_data_get_y(_ptr);
     return result;
   }
 
@@ -100,34 +138,41 @@ class PhysicsConstraintData implements Finalizable {
   }
 
   double get rotate {
-    final result = SpineBindings.bindings.spine_physics_constraint_data_get_rotate(_ptr);
+    final result =
+        SpineBindings.bindings.spine_physics_constraint_data_get_rotate(_ptr);
     return result;
   }
 
   set rotate(double value) {
-    SpineBindings.bindings.spine_physics_constraint_data_set_rotate(_ptr, value);
+    SpineBindings.bindings
+        .spine_physics_constraint_data_set_rotate(_ptr, value);
   }
 
   double get scaleX {
-    final result = SpineBindings.bindings.spine_physics_constraint_data_get_scale_x(_ptr);
+    final result =
+        SpineBindings.bindings.spine_physics_constraint_data_get_scale_x(_ptr);
     return result;
   }
 
   set scaleX(double value) {
-    SpineBindings.bindings.spine_physics_constraint_data_set_scale_x(_ptr, value);
+    SpineBindings.bindings
+        .spine_physics_constraint_data_set_scale_x(_ptr, value);
   }
 
   double get shearX {
-    final result = SpineBindings.bindings.spine_physics_constraint_data_get_shear_x(_ptr);
+    final result =
+        SpineBindings.bindings.spine_physics_constraint_data_get_shear_x(_ptr);
     return result;
   }
 
   set shearX(double value) {
-    SpineBindings.bindings.spine_physics_constraint_data_set_shear_x(_ptr, value);
+    SpineBindings.bindings
+        .spine_physics_constraint_data_set_shear_x(_ptr, value);
   }
 
   double get limit {
-    final result = SpineBindings.bindings.spine_physics_constraint_data_get_limit(_ptr);
+    final result =
+        SpineBindings.bindings.spine_physics_constraint_data_get_limit(_ptr);
     return result;
   }
 
@@ -136,93 +181,90 @@ class PhysicsConstraintData implements Finalizable {
   }
 
   bool get inertiaGlobal {
-    final result = SpineBindings.bindings.spine_physics_constraint_data_get_inertia_global(_ptr);
+    final result = SpineBindings.bindings
+        .spine_physics_constraint_data_get_inertia_global(_ptr);
     return result;
   }
 
   set inertiaGlobal(bool value) {
-    SpineBindings.bindings.spine_physics_constraint_data_set_inertia_global(_ptr, value);
+    SpineBindings.bindings
+        .spine_physics_constraint_data_set_inertia_global(_ptr, value);
   }
 
   bool get strengthGlobal {
-    final result = SpineBindings.bindings.spine_physics_constraint_data_get_strength_global(_ptr);
+    final result = SpineBindings.bindings
+        .spine_physics_constraint_data_get_strength_global(_ptr);
     return result;
   }
 
   set strengthGlobal(bool value) {
-    SpineBindings.bindings.spine_physics_constraint_data_set_strength_global(_ptr, value);
+    SpineBindings.bindings
+        .spine_physics_constraint_data_set_strength_global(_ptr, value);
   }
 
   bool get dampingGlobal {
-    final result = SpineBindings.bindings.spine_physics_constraint_data_get_damping_global(_ptr);
+    final result = SpineBindings.bindings
+        .spine_physics_constraint_data_get_damping_global(_ptr);
     return result;
   }
 
   set dampingGlobal(bool value) {
-    SpineBindings.bindings.spine_physics_constraint_data_set_damping_global(_ptr, value);
+    SpineBindings.bindings
+        .spine_physics_constraint_data_set_damping_global(_ptr, value);
   }
 
   bool get massGlobal {
-    final result = SpineBindings.bindings.spine_physics_constraint_data_get_mass_global(_ptr);
+    final result = SpineBindings.bindings
+        .spine_physics_constraint_data_get_mass_global(_ptr);
     return result;
   }
 
   set massGlobal(bool value) {
-    SpineBindings.bindings.spine_physics_constraint_data_set_mass_global(_ptr, value);
+    SpineBindings.bindings
+        .spine_physics_constraint_data_set_mass_global(_ptr, value);
   }
 
   bool get windGlobal {
-    final result = SpineBindings.bindings.spine_physics_constraint_data_get_wind_global(_ptr);
+    final result = SpineBindings.bindings
+        .spine_physics_constraint_data_get_wind_global(_ptr);
     return result;
   }
 
   set windGlobal(bool value) {
-    SpineBindings.bindings.spine_physics_constraint_data_set_wind_global(_ptr, value);
+    SpineBindings.bindings
+        .spine_physics_constraint_data_set_wind_global(_ptr, value);
   }
 
   bool get gravityGlobal {
-    final result = SpineBindings.bindings.spine_physics_constraint_data_get_gravity_global(_ptr);
+    final result = SpineBindings.bindings
+        .spine_physics_constraint_data_get_gravity_global(_ptr);
     return result;
   }
 
   set gravityGlobal(bool value) {
-    SpineBindings.bindings.spine_physics_constraint_data_set_gravity_global(_ptr, value);
+    SpineBindings.bindings
+        .spine_physics_constraint_data_set_gravity_global(_ptr, value);
   }
 
   bool get mixGlobal {
-    final result = SpineBindings.bindings.spine_physics_constraint_data_get_mix_global(_ptr);
+    final result = SpineBindings.bindings
+        .spine_physics_constraint_data_get_mix_global(_ptr);
     return result;
   }
 
   set mixGlobal(bool value) {
-    SpineBindings.bindings.spine_physics_constraint_data_set_mix_global(_ptr, value);
-  }
-
-  String get name {
-    final result = SpineBindings.bindings.spine_physics_constraint_data_get_name(_ptr);
-    return result.cast<Utf8>().toDartString();
-  }
-
-  bool get skinRequired {
-    final result = SpineBindings.bindings.spine_physics_constraint_data_get_skin_required(_ptr);
-    return result;
+    SpineBindings.bindings
+        .spine_physics_constraint_data_set_mix_global(_ptr, value);
   }
 
   PhysicsConstraintPose get setupPose {
-    final result = SpineBindings.bindings.spine_physics_constraint_data_get_setup_pose(_ptr);
+    final result = SpineBindings.bindings
+        .spine_physics_constraint_data_get_setup_pose(_ptr);
     return PhysicsConstraintPose.fromPointer(result);
   }
 
-  set skinRequired(bool value) {
-    SpineBindings.bindings.spine_physics_constraint_data_set_skin_required(_ptr, value);
-  }
-
   static Rtti rttiStatic() {
     final result = SpineBindings.bindings.spine_physics_constraint_data_rtti();
     return Rtti.fromPointer(result);
   }
-
-  void dispose() {
-    SpineBindings.bindings.spine_physics_constraint_data_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/physics_constraint_gravity_timeline.dart

@@ -30,7 +30,7 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 import 'physics_constraint_timeline.dart';
 
@@ -38,19 +38,18 @@ import 'physics_constraint_timeline.dart';
 class PhysicsConstraintGravityTimeline extends PhysicsConstraintTimeline {
   final Pointer<spine_physics_constraint_gravity_timeline_wrapper> _ptr;
 
-  PhysicsConstraintGravityTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
+  PhysicsConstraintGravityTimeline.fromPointer(this._ptr)
+      : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
   @override
   Pointer get nativePtr => _ptr;
 
-  factory PhysicsConstraintGravityTimeline(int frameCount, int bezierCount, int physicsConstraintIndex) {
-    final ptr = SpineBindings.bindings.spine_physics_constraint_gravity_timeline_create(frameCount, bezierCount, physicsConstraintIndex);
+  factory PhysicsConstraintGravityTimeline(
+      int frameCount, int bezierCount, int physicsConstraintIndex) {
+    final ptr = SpineBindings.bindings
+        .spine_physics_constraint_gravity_timeline_create(
+            frameCount, bezierCount, physicsConstraintIndex);
     return PhysicsConstraintGravityTimeline.fromPointer(ptr);
   }
-
-  @override
-  void dispose() {
-    SpineBindings.bindings.spine_physics_constraint_gravity_timeline_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/physics_constraint_inertia_timeline.dart

@@ -30,7 +30,7 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 import 'physics_constraint_timeline.dart';
 
@@ -38,19 +38,18 @@ import 'physics_constraint_timeline.dart';
 class PhysicsConstraintInertiaTimeline extends PhysicsConstraintTimeline {
   final Pointer<spine_physics_constraint_inertia_timeline_wrapper> _ptr;
 
-  PhysicsConstraintInertiaTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
+  PhysicsConstraintInertiaTimeline.fromPointer(this._ptr)
+      : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
   @override
   Pointer get nativePtr => _ptr;
 
-  factory PhysicsConstraintInertiaTimeline(int frameCount, int bezierCount, int physicsConstraintIndex) {
-    final ptr = SpineBindings.bindings.spine_physics_constraint_inertia_timeline_create(frameCount, bezierCount, physicsConstraintIndex);
+  factory PhysicsConstraintInertiaTimeline(
+      int frameCount, int bezierCount, int physicsConstraintIndex) {
+    final ptr = SpineBindings.bindings
+        .spine_physics_constraint_inertia_timeline_create(
+            frameCount, bezierCount, physicsConstraintIndex);
     return PhysicsConstraintInertiaTimeline.fromPointer(ptr);
   }
-
-  @override
-  void dispose() {
-    SpineBindings.bindings.spine_physics_constraint_inertia_timeline_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/physics_constraint_mass_timeline.dart

@@ -30,7 +30,7 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 import 'physics_constraint_timeline.dart';
 
@@ -38,19 +38,18 @@ import 'physics_constraint_timeline.dart';
 class PhysicsConstraintMassTimeline extends PhysicsConstraintTimeline {
   final Pointer<spine_physics_constraint_mass_timeline_wrapper> _ptr;
 
-  PhysicsConstraintMassTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
+  PhysicsConstraintMassTimeline.fromPointer(this._ptr)
+      : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
   @override
   Pointer get nativePtr => _ptr;
 
-  factory PhysicsConstraintMassTimeline(int frameCount, int bezierCount, int physicsConstraintIndex) {
-    final ptr = SpineBindings.bindings.spine_physics_constraint_mass_timeline_create(frameCount, bezierCount, physicsConstraintIndex);
+  factory PhysicsConstraintMassTimeline(
+      int frameCount, int bezierCount, int physicsConstraintIndex) {
+    final ptr = SpineBindings.bindings
+        .spine_physics_constraint_mass_timeline_create(
+            frameCount, bezierCount, physicsConstraintIndex);
     return PhysicsConstraintMassTimeline.fromPointer(ptr);
   }
-
-  @override
-  void dispose() {
-    SpineBindings.bindings.spine_physics_constraint_mass_timeline_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/physics_constraint_mix_timeline.dart

@@ -30,7 +30,7 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 import 'physics_constraint_timeline.dart';
 
@@ -38,19 +38,18 @@ import 'physics_constraint_timeline.dart';
 class PhysicsConstraintMixTimeline extends PhysicsConstraintTimeline {
   final Pointer<spine_physics_constraint_mix_timeline_wrapper> _ptr;
 
-  PhysicsConstraintMixTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
+  PhysicsConstraintMixTimeline.fromPointer(this._ptr)
+      : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
   @override
   Pointer get nativePtr => _ptr;
 
-  factory PhysicsConstraintMixTimeline(int frameCount, int bezierCount, int physicsConstraintIndex) {
-    final ptr = SpineBindings.bindings.spine_physics_constraint_mix_timeline_create(frameCount, bezierCount, physicsConstraintIndex);
+  factory PhysicsConstraintMixTimeline(
+      int frameCount, int bezierCount, int physicsConstraintIndex) {
+    final ptr = SpineBindings.bindings
+        .spine_physics_constraint_mix_timeline_create(
+            frameCount, bezierCount, physicsConstraintIndex);
     return PhysicsConstraintMixTimeline.fromPointer(ptr);
   }
-
-  @override
-  void dispose() {
-    SpineBindings.bindings.spine_physics_constraint_mix_timeline_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/physics_constraint_pose.dart

@@ -30,7 +30,7 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 
 /// PhysicsConstraintPose wrapper
@@ -48,47 +48,57 @@ class PhysicsConstraintPose implements Finalizable {
   }
 
   void set(PhysicsConstraintPose pose) {
-    SpineBindings.bindings.spine_physics_constraint_pose_set(_ptr, pose.nativePtr.cast());
+    SpineBindings.bindings
+        .spine_physics_constraint_pose_set(_ptr, pose.nativePtr.cast());
   }
 
   double get inertia {
-    final result = SpineBindings.bindings.spine_physics_constraint_pose_get_inertia(_ptr);
+    final result =
+        SpineBindings.bindings.spine_physics_constraint_pose_get_inertia(_ptr);
     return result;
   }
 
   set inertia(double value) {
-    SpineBindings.bindings.spine_physics_constraint_pose_set_inertia(_ptr, value);
+    SpineBindings.bindings
+        .spine_physics_constraint_pose_set_inertia(_ptr, value);
   }
 
   double get strength {
-    final result = SpineBindings.bindings.spine_physics_constraint_pose_get_strength(_ptr);
+    final result =
+        SpineBindings.bindings.spine_physics_constraint_pose_get_strength(_ptr);
     return result;
   }
 
   set strength(double value) {
-    SpineBindings.bindings.spine_physics_constraint_pose_set_strength(_ptr, value);
+    SpineBindings.bindings
+        .spine_physics_constraint_pose_set_strength(_ptr, value);
   }
 
   double get damping {
-    final result = SpineBindings.bindings.spine_physics_constraint_pose_get_damping(_ptr);
+    final result =
+        SpineBindings.bindings.spine_physics_constraint_pose_get_damping(_ptr);
     return result;
   }
 
   set damping(double value) {
-    SpineBindings.bindings.spine_physics_constraint_pose_set_damping(_ptr, value);
+    SpineBindings.bindings
+        .spine_physics_constraint_pose_set_damping(_ptr, value);
   }
 
   double get massInverse {
-    final result = SpineBindings.bindings.spine_physics_constraint_pose_get_mass_inverse(_ptr);
+    final result = SpineBindings.bindings
+        .spine_physics_constraint_pose_get_mass_inverse(_ptr);
     return result;
   }
 
   set massInverse(double value) {
-    SpineBindings.bindings.spine_physics_constraint_pose_set_mass_inverse(_ptr, value);
+    SpineBindings.bindings
+        .spine_physics_constraint_pose_set_mass_inverse(_ptr, value);
   }
 
   double get wind {
-    final result = SpineBindings.bindings.spine_physics_constraint_pose_get_wind(_ptr);
+    final result =
+        SpineBindings.bindings.spine_physics_constraint_pose_get_wind(_ptr);
     return result;
   }
 
@@ -97,24 +107,23 @@ class PhysicsConstraintPose implements Finalizable {
   }
 
   double get gravity {
-    final result = SpineBindings.bindings.spine_physics_constraint_pose_get_gravity(_ptr);
+    final result =
+        SpineBindings.bindings.spine_physics_constraint_pose_get_gravity(_ptr);
     return result;
   }
 
   set gravity(double value) {
-    SpineBindings.bindings.spine_physics_constraint_pose_set_gravity(_ptr, value);
+    SpineBindings.bindings
+        .spine_physics_constraint_pose_set_gravity(_ptr, value);
   }
 
   double get mix {
-    final result = SpineBindings.bindings.spine_physics_constraint_pose_get_mix(_ptr);
+    final result =
+        SpineBindings.bindings.spine_physics_constraint_pose_get_mix(_ptr);
     return result;
   }
 
   set mix(double value) {
     SpineBindings.bindings.spine_physics_constraint_pose_set_mix(_ptr, value);
   }
-
-  void dispose() {
-    SpineBindings.bindings.spine_physics_constraint_pose_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/physics_constraint_reset_timeline.dart

@@ -30,40 +30,46 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
+import 'constraint_timeline.dart';
 import 'timeline.dart';
 
 /// PhysicsConstraintResetTimeline wrapper
-class PhysicsConstraintResetTimeline extends Timeline {
+class PhysicsConstraintResetTimeline extends Timeline
+    implements ConstraintTimeline {
   final Pointer<spine_physics_constraint_reset_timeline_wrapper> _ptr;
 
-  PhysicsConstraintResetTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
+  PhysicsConstraintResetTimeline.fromPointer(this._ptr)
+      : 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.spine_physics_constraint_reset_timeline_create(frameCount, constraintIndex);
+    final ptr = SpineBindings.bindings
+        .spine_physics_constraint_reset_timeline_create(
+            frameCount, constraintIndex);
     return PhysicsConstraintResetTimeline.fromPointer(ptr);
   }
 
+  @override
   int get constraintIndex {
-    final result = SpineBindings.bindings.spine_physics_constraint_reset_timeline_get_constraint_index(_ptr);
+    final result = SpineBindings.bindings
+        .spine_physics_constraint_reset_timeline_get_constraint_index(_ptr);
     return result;
   }
 
-  void setFrame(int frame, double time) {
-    SpineBindings.bindings.spine_physics_constraint_reset_timeline_set_frame(_ptr, frame, time);
-  }
-
-  set constraintIndex(int value) {
-    SpineBindings.bindings.spine_physics_constraint_reset_timeline_set_constraint_index(_ptr, value);
-  }
-
   @override
-  void dispose() {
-    SpineBindings.bindings.spine_physics_constraint_reset_timeline_dispose(_ptr);
+  set constraintIndex(int value) {
+    SpineBindings.bindings
+        .spine_physics_constraint_reset_timeline_set_constraint_index(
+            _ptr, value);
   }
-}
+
+  void setFrame(int frame, double time) {
+    SpineBindings.bindings
+        .spine_physics_constraint_reset_timeline_set_frame(_ptr, frame, time);
+  }
+}

spine-flutter/lib/generated/physics_constraint_strength_timeline.dart

@@ -30,7 +30,7 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 import 'physics_constraint_timeline.dart';
 
@@ -38,19 +38,18 @@ import 'physics_constraint_timeline.dart';
 class PhysicsConstraintStrengthTimeline extends PhysicsConstraintTimeline {
   final Pointer<spine_physics_constraint_strength_timeline_wrapper> _ptr;
 
-  PhysicsConstraintStrengthTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
+  PhysicsConstraintStrengthTimeline.fromPointer(this._ptr)
+      : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
   @override
   Pointer get nativePtr => _ptr;
 
-  factory PhysicsConstraintStrengthTimeline(int frameCount, int bezierCount, int physicsConstraintIndex) {
-    final ptr = SpineBindings.bindings.spine_physics_constraint_strength_timeline_create(frameCount, bezierCount, physicsConstraintIndex);
+  factory PhysicsConstraintStrengthTimeline(
+      int frameCount, int bezierCount, int physicsConstraintIndex) {
+    final ptr = SpineBindings.bindings
+        .spine_physics_constraint_strength_timeline_create(
+            frameCount, bezierCount, physicsConstraintIndex);
     return PhysicsConstraintStrengthTimeline.fromPointer(ptr);
   }
-
-  @override
-  void dispose() {
-    SpineBindings.bindings.spine_physics_constraint_strength_timeline_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/physics_constraint_timeline.dart

@@ -30,31 +30,33 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
+import 'constraint_timeline.dart';
 import 'curve_timeline1.dart';
 
 /// PhysicsConstraintTimeline wrapper
-abstract class PhysicsConstraintTimeline extends CurveTimeline1 {
+abstract class PhysicsConstraintTimeline extends CurveTimeline1
+    implements ConstraintTimeline {
   final Pointer<spine_physics_constraint_timeline_wrapper> _ptr;
 
-  PhysicsConstraintTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
+  PhysicsConstraintTimeline.fromPointer(this._ptr)
+      : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
   @override
   Pointer get nativePtr => _ptr;
 
+  @override
   int get constraintIndex {
-    final result = SpineBindings.bindings.spine_physics_constraint_timeline_get_constraint_index(_ptr);
+    final result = SpineBindings.bindings
+        .spine_physics_constraint_timeline_get_constraint_index(_ptr);
     return result;
   }
 
-  set constraintIndex(int value) {
-    SpineBindings.bindings.spine_physics_constraint_timeline_set_constraint_index(_ptr, value);
-  }
-
   @override
-  void dispose() {
-    SpineBindings.bindings.spine_physics_constraint_timeline_dispose(_ptr);
+  set constraintIndex(int value) {
+    SpineBindings.bindings
+        .spine_physics_constraint_timeline_set_constraint_index(_ptr, value);
   }
-}
+}

spine-flutter/lib/generated/physics_constraint_wind_timeline.dart

@@ -30,7 +30,7 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 import 'physics_constraint_timeline.dart';
 
@@ -38,19 +38,18 @@ import 'physics_constraint_timeline.dart';
 class PhysicsConstraintWindTimeline extends PhysicsConstraintTimeline {
   final Pointer<spine_physics_constraint_wind_timeline_wrapper> _ptr;
 
-  PhysicsConstraintWindTimeline.fromPointer(this._ptr) : super.fromPointer(_ptr.cast());
+  PhysicsConstraintWindTimeline.fromPointer(this._ptr)
+      : super.fromPointer(_ptr.cast());
 
   /// Get the native pointer for FFI calls
   @override
   Pointer get nativePtr => _ptr;
 
-  factory PhysicsConstraintWindTimeline(int frameCount, int bezierCount, int physicsConstraintIndex) {
-    final ptr = SpineBindings.bindings.spine_physics_constraint_wind_timeline_create(frameCount, bezierCount, physicsConstraintIndex);
+  factory PhysicsConstraintWindTimeline(
+      int frameCount, int bezierCount, int physicsConstraintIndex) {
+    final ptr = SpineBindings.bindings
+        .spine_physics_constraint_wind_timeline_create(
+            frameCount, bezierCount, physicsConstraintIndex);
     return PhysicsConstraintWindTimeline.fromPointer(ptr);
   }
-
-  @override
-  void dispose() {
-    SpineBindings.bindings.spine_physics_constraint_wind_timeline_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/point_attachment.dart

@@ -31,11 +31,11 @@
 
 import 'dart:ffi';
 import 'package:ffi/ffi.dart';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 import 'attachment.dart';
-import 'color.dart';
 import 'bone_pose.dart';
+import 'color.dart';
 
 /// PointAttachment wrapper
 class PointAttachment extends Attachment {
@@ -48,7 +48,8 @@ class PointAttachment extends Attachment {
   Pointer get nativePtr => _ptr;
 
   factory PointAttachment(String name) {
-    final ptr = SpineBindings.bindings.spine_point_attachment_create(name.toNativeUtf8().cast<Char>());
+    final ptr = SpineBindings.bindings
+        .spine_point_attachment_create(name.toNativeUtf8().cast<Char>());
     return PointAttachment.fromPointer(ptr);
   }
 
@@ -71,7 +72,8 @@ class PointAttachment extends Attachment {
   }
 
   double get rotation {
-    final result = SpineBindings.bindings.spine_point_attachment_get_rotation(_ptr);
+    final result =
+        SpineBindings.bindings.spine_point_attachment_get_rotation(_ptr);
     return result;
   }
 
@@ -80,17 +82,15 @@ class PointAttachment extends Attachment {
   }
 
   Color get color {
-    final result = SpineBindings.bindings.spine_point_attachment_get_color(_ptr);
+    final result =
+        SpineBindings.bindings.spine_point_attachment_get_color(_ptr);
     return Color.fromPointer(result);
   }
 
   double computeWorldRotation(BonePose bone) {
-    final result = SpineBindings.bindings.spine_point_attachment_compute_world_rotation(_ptr, bone.nativePtr.cast());
+    final result = SpineBindings.bindings
+        .spine_point_attachment_compute_world_rotation(
+            _ptr, bone.nativePtr.cast());
     return result;
   }
-
-  @override
-  void dispose() {
-    SpineBindings.bindings.spine_point_attachment_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/polygon.dart

@@ -30,7 +30,7 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 import 'arrays.dart';
 
@@ -54,7 +54,8 @@ class Polygon implements Finalizable {
   }
 
   set vertices(ArrayFloat value) {
-    SpineBindings.bindings.spine_polygon_set__vertices(_ptr, value.nativePtr.cast());
+    SpineBindings.bindings
+        .spine_polygon_set__vertices(_ptr, value.nativePtr.cast());
   }
 
   int get count {
@@ -65,8 +66,4 @@ class Polygon implements Finalizable {
   set count(int value) {
     SpineBindings.bindings.spine_polygon_set__count(_ptr, value);
   }
-
-  void dispose() {
-    SpineBindings.bindings.spine_polygon_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/posed.dart

@@ -30,32 +30,11 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'spine_flutter_bindings_generated.dart';
-import '../spine_bindings.dart';
 
 /// Posed wrapper
-abstract class Posed implements Finalizable {
-  final Pointer<spine_posed_wrapper> _ptr;
-
-  Posed.fromPointer(this._ptr);
-
-  /// Get the native pointer for FFI calls
-  Pointer get nativePtr => _ptr;
-
-  void constrained() {
-    SpineBindings.bindings.spine_posed_constrained(_ptr);
-  }
-
-  void resetConstrained() {
-    SpineBindings.bindings.spine_posed_reset_constrained(_ptr);
-  }
-
-  bool get isPoseEqualToApplied {
-    final result = SpineBindings.bindings.spine_posed_is_pose_equal_to_applied(_ptr);
-    return result;
-  }
-
-  void dispose() {
-    SpineBindings.bindings.spine_posed_dispose(_ptr);
-  }
-}
+abstract class Posed {
+  Pointer get nativePtr;
+  void constrained();
+  void resetConstrained();
+  bool get isPoseEqualToApplied;
+}

spine-flutter/lib/generated/posed_active.dart

@@ -30,7 +30,7 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 
 /// PosedActive wrapper
@@ -50,8 +50,4 @@ class PosedActive implements Finalizable {
   set active(bool value) {
     SpineBindings.bindings.spine_posed_active_set_active(_ptr, value);
   }
-
-  void dispose() {
-    SpineBindings.bindings.spine_posed_active_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/posed_data.dart

@@ -31,7 +31,7 @@
 
 import 'dart:ffi';
 import 'package:ffi/ffi.dart';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 
 /// PosedData wrapper
@@ -44,7 +44,8 @@ class PosedData implements Finalizable {
   Pointer get nativePtr => _ptr;
 
   factory PosedData(String name) {
-    final ptr = SpineBindings.bindings.spine_posed_data_create(name.toNativeUtf8().cast<Char>());
+    final ptr = SpineBindings.bindings
+        .spine_posed_data_create(name.toNativeUtf8().cast<Char>());
     return PosedData.fromPointer(ptr);
   }
 
@@ -54,15 +55,12 @@ class PosedData implements Finalizable {
   }
 
   bool get skinRequired {
-    final result = SpineBindings.bindings.spine_posed_data_get_skin_required(_ptr);
+    final result =
+        SpineBindings.bindings.spine_posed_data_get_skin_required(_ptr);
     return result;
   }
 
   set skinRequired(bool value) {
     SpineBindings.bindings.spine_posed_data_set_skin_required(_ptr, value);
   }
-
-  void dispose() {
-    SpineBindings.bindings.spine_posed_data_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/position_mode.dart

@@ -32,7 +32,7 @@
 /// PositionMode enum
 enum PositionMode {
   fixed(0),
-  percent(1);
+  percent(0);
 
   const PositionMode(this.value);
   final int value;
@@ -43,4 +43,4 @@ enum PositionMode {
       orElse: () => throw ArgumentError('Invalid PositionMode value: $value'),
     );
   }
-}
+}

spine-flutter/lib/generated/property.dart

@@ -31,37 +31,37 @@
 
 /// Property enum
 enum Property {
-  rotate(1 << 0),
-  x(1 << 1),
-  y(1 << 2),
-  scaleX(1 << 3),
-  scaleY(1 << 4),
-  shearX(1 << 5),
-  shearY(1 << 6),
-  inherit(1 << 7),
-  rgb(1 << 8),
-  alpha(1 << 9),
-  rgb2(1 << 10),
-  attachment(1 << 11),
-  deform(1 << 12),
-  event(1 << 13),
-  drawOrder(1 << 14),
-  ikConstraint(1 << 15),
-  transformConstraint(1 << 16),
-  pathConstraintPosition(1 << 17),
-  pathConstraintSpacing(1 << 18),
-  pathConstraintMix(1 << 19),
-  physicsConstraintInertia(1 << 20),
-  physicsConstraintStrength(1 << 21),
-  physicsConstraintDamping(1 << 22),
-  physicsConstraintMass(1 << 23),
-  physicsConstraintWind(1 << 24),
-  physicsConstraintGravity(1 << 25),
-  physicsConstraintMix(1 << 26),
-  physicsConstraintReset(1 << 27),
-  sequence(1 << 28),
-  sliderTime(1 << 29),
-  sliderMix(1 << 30);
+  rotate(1),
+  x(1),
+  y(1),
+  scaleX(1),
+  scaleY(1),
+  shearX(1),
+  shearY(1),
+  inherit(1),
+  rgb(1),
+  alpha(1),
+  rgb2(1),
+  attachment(1),
+  deform(1),
+  event(1),
+  drawOrder(1),
+  ikConstraint(1),
+  transformConstraint(1),
+  pathConstraintPosition(1),
+  pathConstraintSpacing(1),
+  pathConstraintMix(1),
+  physicsConstraintInertia(1),
+  physicsConstraintStrength(1),
+  physicsConstraintDamping(1),
+  physicsConstraintMass(1),
+  physicsConstraintWind(1),
+  physicsConstraintGravity(1),
+  physicsConstraintMix(1),
+  physicsConstraintReset(1),
+  sequence(1),
+  sliderTime(1),
+  sliderMix(1);
 
   const Property(this.value);
   final int value;
@@ -72,4 +72,4 @@ enum Property {
       orElse: () => throw ArgumentError('Invalid Property value: $value'),
     );
   }
-}
+}

spine-flutter/lib/generated/region_attachment.dart

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

spine-flutter/lib/generated/render_command.dart

@@ -30,7 +30,7 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 import 'blend_mode.dart';
 
@@ -43,27 +43,60 @@ class RenderCommand implements Finalizable {
   /// Get the native pointer for FFI calls
   Pointer get nativePtr => _ptr;
 
+  Pointer<Float> get positions {
+    final result =
+        SpineBindings.bindings.spine_render_command_get_positions(_ptr);
+    return result;
+  }
+
+  Pointer<Float> get uvs {
+    final result = SpineBindings.bindings.spine_render_command_get_uvs(_ptr);
+    return result;
+  }
+
+  Pointer<Uint32> get colors {
+    final result = SpineBindings.bindings.spine_render_command_get_colors(_ptr);
+    return result;
+  }
+
+  Pointer<Uint32> get darkColors {
+    final result =
+        SpineBindings.bindings.spine_render_command_get_dark_colors(_ptr);
+    return result;
+  }
+
   int get numVertices {
-    final result = SpineBindings.bindings.spine_render_command_get_num_vertices(_ptr);
+    final result =
+        SpineBindings.bindings.spine_render_command_get_num_vertices(_ptr);
+    return result;
+  }
+
+  Pointer<Uint16> get indices {
+    final result =
+        SpineBindings.bindings.spine_render_command_get_indices(_ptr);
     return result;
   }
 
   int get numIndices {
-    final result = SpineBindings.bindings.spine_render_command_get_num_indices(_ptr);
+    final result =
+        SpineBindings.bindings.spine_render_command_get_num_indices(_ptr);
     return result;
   }
 
   BlendMode get blendMode {
-    final result = SpineBindings.bindings.spine_render_command_get_blend_mode(_ptr);
+    final result =
+        SpineBindings.bindings.spine_render_command_get_blend_mode(_ptr);
     return BlendMode.fromValue(result);
   }
 
+  Pointer<Void> get texture {
+    final result =
+        SpineBindings.bindings.spine_render_command_get_texture(_ptr);
+    return result;
+  }
+
   RenderCommand get next {
     final result = SpineBindings.bindings.spine_render_command_get_next(_ptr);
     return RenderCommand.fromPointer(result);
   }
-
-  void dispose() {
-    SpineBindings.bindings.spine_render_command_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/rgb2_timeline.dart

@@ -30,7 +30,7 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 import 'slot_curve_timeline.dart';
 
@@ -45,16 +45,14 @@ class Rgb2Timeline extends SlotCurveTimeline {
   Pointer get nativePtr => _ptr;
 
   factory Rgb2Timeline(int frameCount, int bezierCount, int slotIndex) {
-    final ptr = SpineBindings.bindings.spine_rgb2_timeline_create(frameCount, bezierCount, slotIndex);
+    final ptr = SpineBindings.bindings
+        .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, double g2, double b2) {
-    SpineBindings.bindings.spine_rgb2_timeline_set_frame(_ptr, frame, time, r, g, b, r2, g2, b2);
+  void setFrame(int frame, double time, double r, double g, double b, double r2,
+      double g2, double b2) {
+    SpineBindings.bindings
+        .spine_rgb2_timeline_set_frame(_ptr, frame, time, r, g, b, r2, g2, b2);
   }
-
-  @override
-  void dispose() {
-    SpineBindings.bindings.spine_rgb2_timeline_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/rgb_timeline.dart

@@ -30,7 +30,7 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 import 'slot_curve_timeline.dart';
 
@@ -45,16 +45,13 @@ class RgbTimeline extends SlotCurveTimeline {
   Pointer get nativePtr => _ptr;
 
   factory RgbTimeline(int frameCount, int bezierCount, int slotIndex) {
-    final ptr = SpineBindings.bindings.spine_rgb_timeline_create(frameCount, bezierCount, slotIndex);
+    final ptr = SpineBindings.bindings
+        .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.spine_rgb_timeline_set_frame(_ptr, frame, time, r, g, b);
+    SpineBindings.bindings
+        .spine_rgb_timeline_set_frame(_ptr, frame, time, r, g, b);
   }
-
-  @override
-  void dispose() {
-    SpineBindings.bindings.spine_rgb_timeline_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/rgba2_timeline.dart

@@ -30,7 +30,7 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 import 'slot_curve_timeline.dart';
 
@@ -45,16 +45,14 @@ class Rgba2Timeline extends SlotCurveTimeline {
   Pointer get nativePtr => _ptr;
 
   factory Rgba2Timeline(int frameCount, int bezierCount, int slotIndex) {
-    final ptr = SpineBindings.bindings.spine_rgba2_timeline_create(frameCount, bezierCount, slotIndex);
+    final ptr = SpineBindings.bindings
+        .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, double r2, double g2, double b2) {
-    SpineBindings.bindings.spine_rgba2_timeline_set_frame(_ptr, frame, time, r, g, b, a, r2, g2, b2);
+  void setFrame(int frame, double time, double r, double g, double b, double a,
+      double r2, double g2, double b2) {
+    SpineBindings.bindings.spine_rgba2_timeline_set_frame(
+        _ptr, frame, time, r, g, b, a, r2, g2, b2);
   }
-
-  @override
-  void dispose() {
-    SpineBindings.bindings.spine_rgba2_timeline_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/rgba_timeline.dart

@@ -30,7 +30,7 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 import 'slot_curve_timeline.dart';
 
@@ -45,16 +45,14 @@ class RgbaTimeline extends SlotCurveTimeline {
   Pointer get nativePtr => _ptr;
 
   factory RgbaTimeline(int frameCount, int bezierCount, int slotIndex) {
-    final ptr = SpineBindings.bindings.spine_rgba_timeline_create(frameCount, bezierCount, slotIndex);
+    final ptr = SpineBindings.bindings
+        .spine_rgba_timeline_create(frameCount, bezierCount, slotIndex);
     return RgbaTimeline.fromPointer(ptr);
   }
 
-  void setFrame(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);
+  void setFrame(
+      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);
   }
-
-  @override
-  void dispose() {
-    SpineBindings.bindings.spine_rgba_timeline_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/rotate_mode.dart

@@ -32,8 +32,8 @@
 /// RotateMode enum
 enum RotateMode {
   tangent(0),
-  chain(1),
-  chainScale(2);
+  chain(0),
+  chainScale(0);
 
   const RotateMode(this.value);
   final int value;
@@ -44,4 +44,4 @@ enum RotateMode {
       orElse: () => throw ArgumentError('Invalid RotateMode value: $value'),
     );
   }
-}
+}

spine-flutter/lib/generated/rotate_timeline.dart

@@ -30,7 +30,7 @@
 // AUTO GENERATED FILE, DO NOT EDIT.
 
 import 'dart:ffi';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 import 'bone_timeline1.dart';
 
@@ -45,12 +45,8 @@ class RotateTimeline extends BoneTimeline1 {
   Pointer get nativePtr => _ptr;
 
   factory RotateTimeline(int frameCount, int bezierCount, int boneIndex) {
-    final ptr = SpineBindings.bindings.spine_rotate_timeline_create(frameCount, bezierCount, boneIndex);
+    final ptr = SpineBindings.bindings
+        .spine_rotate_timeline_create(frameCount, bezierCount, boneIndex);
     return RotateTimeline.fromPointer(ptr);
   }
-
-  @override
-  void dispose() {
-    SpineBindings.bindings.spine_rotate_timeline_dispose(_ptr);
-  }
-}
+}

spine-flutter/lib/generated/rtti.dart

@@ -31,7 +31,7 @@
 
 import 'dart:ffi';
 import 'package:ffi/ffi.dart';
-import 'spine_flutter_bindings_generated.dart';
+import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 
 /// Rtti wrapper
@@ -49,16 +49,14 @@ class Rtti implements Finalizable {
   }
 
   bool isExactly(Rtti rtti) {
-    final result = SpineBindings.bindings.spine_rtti_is_exactly(_ptr, rtti.nativePtr.cast());
+    final result = SpineBindings.bindings
+        .spine_rtti_is_exactly(_ptr, rtti.nativePtr.cast());
     return result;
   }
 
   bool instanceOf(Rtti rtti) {
-    final result = SpineBindings.bindings.spine_rtti_instance_of(_ptr, rtti.nativePtr.cast());
+    final result = SpineBindings.bindings
+        .spine_rtti_instance_of(_ptr, rtti.nativePtr.cast());
     return result;
   }
-
-  void dispose() {
-    SpineBindings.bindings.spine_rtti_dispose(_ptr);
-  }
-}
+}