[flutter][ios][haxe] Regenerate bindings for AnimationState/timeline API changes

Author: badlogic

spine-flutter/lib/assets/libspine_flutter.js

@@ -34,8 +34,6 @@ import 'package:universal_ffi/ffi_utils.dart';
 import 'spine_dart_bindings_generated.dart';
 import '../spine_bindings.dart';
 import 'arrays.dart';
-import 'mix_blend.dart';
-import 'mix_direction.dart';
 import 'skeleton.dart';
 
 /// Stores a list of timelines to animate a skeleton's pose over time.
@@ -91,18 +89,20 @@ class Animation {
   ///
   /// See Timeline::apply().
   ///
-  /// [skeleton] The skeleton the animation is being applied to. This provides access to the bones, slots, and other skeleton components the timelines may change.
-  /// [lastTime] The last time in seconds this animation was applied. Some timelines trigger only at specific times rather than every frame. Pass -1 the first time an animation is applied to ensure frame 0 is triggered.
-  /// [time] The time in seconds the skeleton is being posed for. Most timelines find the frame before and the frame after this time and interpolate between the frame values. If beyond the getDuration() and loop is true then the animation will repeat, else the last frame will be applied.
-  /// [loop] If true, the animation repeats after the getDuration().
-  /// [events] If any events are fired, they are added to this list. Can be null to ignore fired events or if no timelines fire events.
-  /// [alpha] 0 applies the current or setup values (depending on blend). 1 applies the timeline values. Between 0 and 1 applies values between the current or setup values and the timeline values. By adjusting alpha over time, an animation can be mixed in or out. alpha can also be useful to apply animations on top of each other (layering).
-  /// [blend] Controls how mixing is applied when alpha < 1.
-  /// [direction] Indicates whether the timelines are mixing in or out. Used by timelines which perform instant transitions, such as DrawOrderTimeline or AttachmentTimeline.
+  /// [skeleton] The skeleton the animation is applied to. This provides access to the bones, slots, and other skeleton components the timelines may change.
+  /// [lastTime] The last time in seconds this animation was applied. Some timelines trigger only at discrete times, in which case all keys are triggered between lastTime (exclusive) and time (inclusive). Pass -1 the first time an animation is applied to ensure frame 0 is triggered.
+  /// [time] The time in seconds the skeleton is being posed for. Timelines find the frame before and after this time and interpolate between the frame values.
+  /// [loop] True if time beyond the getDuration() repeats the animation, else the last frame is used.
+  /// [events] If any events are fired, they are added to this list. Can be NULL to ignore fired events or if no timelines fire events.
+  /// [alpha] 0 applies setup or current values (depending on fromSetup), 1 uses timeline values, and intermediate values interpolate between them. Adjusting alpha over time can mix an animation in or out.
+  /// [fromSetup] If true, alpha transitions between setup and timeline values, setup values are used before the first frame (current values are not used). If false, alpha transitions between current and timeline values, no change is made before the first frame.
+  /// [add] If true, for timelines that support it, their values are added to the setup or current values (depending on fromSetup).
+  /// [out] True when the animation is mixing out, else it is mixing in. Used by timelines that perform instant transitions.
+  /// [appliedPose] True to modify the applied pose, else the pose is modified.
   void apply(Skeleton skeleton, double lastTime, double time, bool loop, ArrayEvent? events, double alpha,
-      MixBlend blend, MixDirection direction, bool appliedPose) {
+      bool fromSetup, bool add, bool out, bool appliedPose) {
     SpineBindings.bindings.spine_animation_apply(_ptr, skeleton.nativePtr.cast(), lastTime, time, loop,
-        events?.nativePtr.cast() ?? Pointer.fromAddress(0), alpha, blend.value, direction.value, appliedPose);
+        events?.nativePtr.cast() ?? Pointer.fromAddress(0), alpha, fromSetup, add, out, appliedPose);
   }
 
   /// The animation's name, which is unique across all animations in the

spine-flutter/lib/assets/libspine_flutter.wasm

@@ -37,7 +37,7 @@ import 'animation.dart';
 import 'skeleton_data.dart';
 
 /// Stores mix (crossfade) durations to be applied when AnimationState
-/// animations are changed.
+/// animations are changed on the same track.
 class AnimationStateData {
   final Pointer<spine_animation_state_data_wrapper> _ptr;
 
@@ -72,8 +72,9 @@ class AnimationStateData {
     SpineBindings.bindings.spine_animation_state_data_set_default_mix(_ptr, value);
   }
 
-  /// The mix duration to use when changing from the specified animation to the
-  /// other, or the DefaultMix if no mix duration has been set.
+  /// Returns the mix duration to use when changing from the specified animation
+  /// to the other on the same track, or the DefaultMix if no mix duration has
+  /// been set.
   double getMix(Animation from, Animation to) {
     final result =
         SpineBindings.bindings.spine_animation_state_data_get_mix(_ptr, from.nativePtr.cast(), to.nativePtr.cast());

spine-flutter/lib/generated/animation.dart

@@ -37,8 +37,6 @@ export 'blend_mode.dart';
 export 'event_type.dart';
 export 'format.dart';
 export 'inherit.dart';
-export 'mix_blend.dart';
-export 'mix_direction.dart';
 export 'physics.dart';
 export 'position_mode.dart';
 export 'property.dart';

spine-flutter/lib/generated/animation_state_data.dart

@@ -43,13 +43,12 @@ import 'posed_active.dart';
 import 'skeleton.dart';
 import 'update.dart';
 
-/// The current pose for a bone, before constraints are applied.
-///
-/// A bone has a local transform which is used to compute its world transform. A
-/// bone also has an applied transform, which is a local transform that can be
-/// applied to compute the world transform. The local transform and applied
-/// transform may differ if a constraint or application code modifies the world
-/// transform after it was computed from the local transform.
+/// A bone has a number of poses: - BoneData::getSetupPose(): The setup pose. -
+/// getPose(): The local pose. Set by animations and app code. -
+/// getAppliedPose(): The applied local pose. This is the local pose modified by
+/// constraints and app code. - The world transform on the applied pose,
+/// computed by Skeleton::updateWorldTransform(Physics) and
+/// BonePose::updateWorldTransform(Skeleton).
 class Bone extends PosedActive implements Posed, Update {
   final Pointer<spine_bone_wrapper> _ptr;
 

spine-flutter/lib/generated/api.dart

@@ -58,13 +58,13 @@ class BoneData extends PosedData {
     SpineBindings.bindings.spine_bone_data_dispose(_ptr);
   }
 
-  /// The index of the bone in Skeleton.Bones
+  /// The Skeleton::getBones() index.
   int get index {
     final result = SpineBindings.bindings.spine_bone_data_get_index(_ptr);
     return result;
   }
 
-  /// May be NULL.
+  /// The parent bone, or NULL if this bone is the root.
   BoneData? get parent {
     final result = SpineBindings.bindings.spine_bone_data_get_parent(_ptr);
     return result.address == 0 ? null : BoneData.fromPointer(result);
@@ -84,6 +84,8 @@ class BoneData extends PosedData {
     return Color.fromPointer(result);
   }
 
+  /// The bone icon name as it was in Spine, or empty if nonessential data was
+  /// not exported.
   String get icon {
     final result = SpineBindings.bindings.spine_bone_data_get_icon(_ptr);
     return result.cast<Utf8>().toDartString();

spine-flutter/lib/generated/bone.dart

@@ -38,8 +38,18 @@ import 'physics.dart';
 import 'skeleton.dart';
 import 'update.dart';
 
-/// The applied pose for a bone. This is the Bone pose with constraints applied
-/// and the world transform computed by Skeleton::updateWorldTransform(Physics).
+/// The applied local pose and world transform for a bone. This is the
+/// Bone::getPose() with constraints applied and the world transform computed by
+/// Skeleton::updateWorldTransform(Physics) and updateWorldTransform(Skeleton).
+///
+/// If the world transform is changed, call updateLocalTransform(Skeleton)
+/// before using the local transform. The local transform may be needed by other
+/// code (eg to apply another constraint).
+///
+/// After changing the world transform, call updateWorldTransform(Skeleton) on
+/// every descendant bone. It may be more convenient to modify the local
+/// transform instead, then call Skeleton::updateWorldTransform(Physics) to
+/// update the world transforms for all bones and apply constraints.
 class BonePose extends BoneLocal implements Update {
   final Pointer<spine_bone_pose_wrapper> _ptr;
 
@@ -72,8 +82,8 @@ class BonePose extends BoneLocal implements Update {
     SpineBindings.bindings.spine_bone_pose_update(_ptr, skeleton.nativePtr.cast(), physics.value);
   }
 
-  /// Computes the world transform using the parent bone's applied pose and this
-  /// pose. Child bones are not updated.
+  /// Computes the world transform using the parent bone's world transform and
+  /// this applied local pose. Child bones are not updated.
   ///
   /// See World transforms in the Spine Runtimes Guide.
   void updateWorldTransform(Skeleton skeleton) {
@@ -82,11 +92,6 @@ class BonePose extends BoneLocal implements Update {
 
   /// Computes the local transform values from the world transform.
   ///
-  /// If the world transform is modified (by a constraint, rotateWorld(), etc)
-  /// then this method should be called so the local transform matches the world
-  /// transform. The local transform may be needed by other code (eg to apply
-  /// another constraint).
-  ///
   /// Some information is ambiguous in the world transform, such as -1,-1 scale
   /// versus 180 rotation. The local transform after calling this method is
   /// equivalent to the local transform used to compute the world transform, but
@@ -95,8 +100,10 @@ class BonePose extends BoneLocal implements Update {
     SpineBindings.bindings.spine_bone_pose_update_local_transform(_ptr, skeleton.nativePtr.cast());
   }
 
-  /// If the world transform has been modified and the local transform no longer
-  /// matches, updateLocalTransform() is called.
+  /// If the world transform has been modified by constraints and the local
+  /// transform no longer matches, updateLocalTransform() is called. Call this
+  /// after Skeleton::updateWorldTransform(Physics) before using the applied
+  /// local transform.
   void validateLocalTransform(Skeleton skeleton) {
     SpineBindings.bindings.spine_bone_pose_validate_local_transform(_ptr, skeleton.nativePtr.cast());
   }
@@ -113,8 +120,7 @@ class BonePose extends BoneLocal implements Update {
     SpineBindings.bindings.spine_bone_pose_reset_world(_ptr, update);
   }
 
-  /// Part of the world transform matrix for the X axis. If changed,
-  /// updateLocalTransform() should be called.
+  /// Part of the world transform matrix for the X axis.
   double get a {
     final result = SpineBindings.bindings.spine_bone_pose_get_a(_ptr);
     return result;
@@ -124,8 +130,7 @@ class BonePose extends BoneLocal implements Update {
     SpineBindings.bindings.spine_bone_pose_set_a(_ptr, value);
   }
 
-  /// Part of the world transform matrix for the Y axis. If changed,
-  /// updateLocalTransform() should be called.
+  /// Part of the world transform matrix for the Y axis.
   double get b {
     final result = SpineBindings.bindings.spine_bone_pose_get_b(_ptr);
     return result;
@@ -135,8 +140,7 @@ class BonePose extends BoneLocal implements Update {
     SpineBindings.bindings.spine_bone_pose_set_b(_ptr, value);
   }
 
-  /// Part of the world transform matrix for the X axis. If changed,
-  /// updateLocalTransform() should be called.
+  /// Part of the world transform matrix for the X axis.
   double get c {
     final result = SpineBindings.bindings.spine_bone_pose_get_c(_ptr);
     return result;
@@ -146,8 +150,7 @@ class BonePose extends BoneLocal implements Update {
     SpineBindings.bindings.spine_bone_pose_set_c(_ptr, value);
   }
 
-  /// Part of the world transform matrix for the Y axis. If changed,
-  /// updateLocalTransform() should be called.
+  /// Part of the world transform matrix for the Y axis.
   double get d {
     final result = SpineBindings.bindings.spine_bone_pose_get_d(_ptr);
     return result;
@@ -157,7 +160,7 @@ class BonePose extends BoneLocal implements Update {
     SpineBindings.bindings.spine_bone_pose_set_d(_ptr, value);
   }
 
-  /// The world X position. If changed, updateLocalTransform() should be called.
+  /// The world X position.
   double get worldX {
     final result = SpineBindings.bindings.spine_bone_pose_get_world_x(_ptr);
     return result;
@@ -167,7 +170,7 @@ class BonePose extends BoneLocal implements Update {
     SpineBindings.bindings.spine_bone_pose_set_world_x(_ptr, value);
   }
 
-  /// The world Y position. If changed, updateLocalTransform() should be called.
+  /// The world Y position.
   double get worldY {
     final result = SpineBindings.bindings.spine_bone_pose_get_world_y(_ptr);
     return result;
@@ -216,9 +219,6 @@ class BonePose extends BoneLocal implements Update {
   }
 
   /// Rotates the world transform the specified amount.
-  ///
-  /// After changes are made to the world transform, updateLocalTransform()
-  /// should be called on this bone and any child bones, recursively.
   void rotateWorld(double degrees) {
     SpineBindings.bindings.spine_bone_pose_rotate_world(_ptr, degrees);
   }

spine-flutter/lib/generated/bone_data.dart

@@ -57,6 +57,8 @@ class ClippingAttachment extends VertexAttachment {
     SpineBindings.bindings.spine_clipping_attachment_dispose(_ptr);
   }
 
+  /// Clipping is performed between the clipping attachment's slot and the end
+  /// slot. If NULL, clipping is done until the end of the skeleton's rendering.
   SlotData? get endSlot {
     final result = SpineBindings.bindings.spine_clipping_attachment_get_end_slot(_ptr);
     return result.address == 0 ? null : SlotData.fromPointer(result);

spine-flutter/lib/generated/bone_pose.dart

@@ -35,7 +35,7 @@ import '../spine_bindings.dart';
 import 'constraint_timeline.dart';
 import 'curve_timeline1.dart';
 
-/// Base class for single-value constraint timelines.
+/// The base class for timelines that change 1 constraint property with a curve.
 abstract class ConstraintTimeline1 extends CurveTimeline1 implements ConstraintTimeline {
   final Pointer<spine_constraint_timeline1_wrapper> _ptr;