[flutter] Ported 4.2 changes in native code. PhysicsConstraint(Data) missing on Flutter side.

spine-flutter/example/lib/dress_up.dart

@@ -57,7 +57,8 @@ class DressUpState extends State<DressUp> {
         var skeleton = drawable.skeleton;
         skeleton.setSkin(skin);
         skeleton.setToSetupPose();
-        skeleton.updateWorldTransform();
+        skeleton.update(0);
+        skeleton.updateWorldTransform(Physics.update);
         _skinImages[skin.getName()] = await drawable.renderToRawImageData(thumbnailSize, thumbnailSize, 0xffffffff);
         _selectedSkins[skin.getName()] = false;
       }

spine-flutter/example/lib/flame_example.dart

@@ -137,7 +137,7 @@ class DragonExample extends FlameGame {
   @override
   Future<void> onLoad() async {
     cachedAtlas = await Atlas.fromAsset("assets/dragon.atlas");
-    cachedSkeletonData =  await SkeletonData.fromAsset(cachedAtlas, "assets/dragon-ess.json");
+    cachedSkeletonData =  await SkeletonData.fromAsset(cachedAtlas, "assets/dragon-ess.skel");
     final drawable = SkeletonDrawable(cachedAtlas, cachedSkeletonData, false);
     dragon = SpineComponent(
       drawable,

spine-flutter/example/lib/pause_play_animation.dart

@@ -65,7 +65,7 @@ class PlayPauseAnimationState extends State<PlayPauseAnimation> {
       appBar: AppBar(title: const Text('Play/Pause')),
       body: SpineWidget.fromAsset(
         "assets/dragon.atlas",
-        "assets/dragon-ess.json",
+        "assets/dragon-ess.skel",
         controller,
         boundsProvider: SkinAndAnimationBounds(animation: "flying"),
       ),

spine-flutter/example/pubspec.lock

@@ -169,7 +169,7 @@ packages:
       path: ".."
       relative: true
     source: path
-    version: "4.2.18"
+    version: "4.1.14"
   string_scanner:
     dependency: transitive
     description:

spine-flutter/lib/spine_flutter.dart

@@ -563,7 +563,7 @@ enum BlendMode {
 
 /// Determines how a bone inherits world transforms from parent bones. See [Transform inheritance](esotericsoftware.com/spine-bones#Transform-inheritance)
 /// in the Spine User Guide.
-enum TransformMode {
+enum Inherit {
   normal(0),
   onlyTranslation(1),
   noRotationOrReflection(2),
@@ -572,7 +572,19 @@ enum TransformMode {
 
   final int value;
 
-  const TransformMode(this.value);
+  const Inherit(this.value);
+}
+
+/// Determines how physics and other non-deterministic updates are applied.
+enum Physics {
+  none(0),
+  reset(1),
+  update(2),
+  pose(3);
+
+  final int value;
+
+  const Physics(this.value);
 }
 
 /// Controls how the first bone is positioned along the path.
@@ -710,14 +722,14 @@ class BoneData {
     _bindings.spine_bone_data_set_shear_y(_data, shearY);
   }
 
-  /// The [TransformMode] for how parent world transforms affect this bone.
-  TransformMode getTransformMode() {
-    final nativeMode = _bindings.spine_bone_data_get_transform_mode(_data);
-    return TransformMode.values[nativeMode];
+  /// The [Inherit] for how parent world transforms affect this bone.
+  Inherit getInherit() {
+    final nativeMode = _bindings.spine_bone_data_get_inherit(_data);
+    return Inherit.values[nativeMode];
   }
 
-  void setTransformMode(TransformMode mode) {
-    _bindings.spine_bone_data_set_transform_mode(_data, mode.value);
+  void setInherit(Inherit inherit) {
+    _bindings.spine_bone_data_set_inherit(_data, inherit.value);
   }
 
   /// When true, [Skeleton.updateWorldTransform] only updates this bone if the [Skeleton.getSkin] contains this bone.
@@ -2746,8 +2758,8 @@ class Skeleton {
   ///
   /// See [World transforms](http://esotericsoftware.com/spine-runtime-skeletons#World-transforms) in the Spine
   /// Runtimes Guide.
-  void updateWorldTransform() {
-    _bindings.spine_skeleton_update_world_transform(_skeleton);
+  void updateWorldTransform(Physics physics) {
+    _bindings.spine_skeleton_update_world_transform(_skeleton, physics.value);
   }
 
   /// Temporarily sets the root bone as a child of the specified bone, then updates the world transform for each bone and applies
@@ -2755,8 +2767,8 @@ class Skeleton {
   ///
   /// See [World transforms](http://esotericsoftware.com/spine-runtime-skeletons#World-transforms) in the Spine
   /// Runtimes Guide.
-  void updateWorldTransformBone(Bone parent) {
-    _bindings.spine_skeleton_update_world_transform_bone(_skeleton, parent._bone);
+  void updateWorldTransformBone(Physics physics, Bone parent) {
+    _bindings.spine_skeleton_update_world_transform_bone(_skeleton, physics.value, parent._bone);
   }
 
   /// Sets the bones, constraints, slots, and draw order to their setup pose values.
@@ -3039,6 +3051,18 @@ class Skeleton {
   void setScaleY(double scaleY) {
     _bindings.spine_skeleton_set_scale_y(_skeleton, scaleY);
   }
+
+  double getTime() {
+    return _bindings.spine_skeleton_get_time(_skeleton);
+  }
+
+  void setTime(double time) {
+    return _bindings.spine_skeleton_set_time(_skeleton, time);
+  }
+
+  void update(double delta) {
+    _bindings.spine_skeleton_update(_skeleton, delta);
+  }
 }
 
 /// Stores a list of timelines to animate a skeleton's pose over time.
@@ -3297,26 +3321,39 @@ class TrackEntry {
     _bindings.spine_track_entry_set_event_threshold(_entry, eventThreshold);
   }
 
+  /// Values less than 1 mix this animation with the last skeleton pose. Defaults to 1, which overwrites the last skeleton pose with
+  /// this animation.
+  ///
+  /// Typically track 0 is used to completely pose the skeleton, then alpha can be used on higher tracks. It doesn't make sense
+  /// to use alpha on track 0 if the skeleton pose is from the last frame render.
+  double getAlphaAttachmentThreshold() {
+    return _bindings.spine_track_entry_get_alpha_attachment_threshold(_entry);
+  }
+
+  void setAlphaAttachmentThreshold(double attachmentThreshold) {
+    _bindings.spine_track_entry_set_alpha_attachment_threshold(_entry, attachmentThreshold);
+  }
+
   /// When the mix percentage ([getMixTime] / [getMixDuration]) is less than the
   /// <code>attachmentThreshold</code>, attachment timelines are applied while this animation is being mixed out. Defaults to
   /// 0, so attachment timelines are not applied while this animation is being mixed out.
-  double getAttachmentThreshold() {
-    return _bindings.spine_track_entry_get_attachment_threshold(_entry);
+  double getMixAttachmentThreshold() {
+    return _bindings.spine_track_entry_get_mix_attachment_threshold(_entry);
   }
 
-  void setAttachmentThreshold(double attachmentThreshold) {
-    _bindings.spine_track_entry_set_attachment_threshold(_entry, attachmentThreshold);
+  void setMixAttachmentThreshold(double attachmentThreshold) {
+    _bindings.spine_track_entry_set_mix_attachment_threshold(_entry, attachmentThreshold);
   }
 
   /// When the mix percentage ([getMixTime] / [getMixDuration]) is less than the
   /// <code>drawOrderThreshold</code>, draw order timelines are applied while this animation is being mixed out. Defaults to 0,
   /// so draw order timelines are not applied while this animation is being mixed out.
-  double getDrawOrderThreshold() {
-    return _bindings.spine_track_entry_get_draw_order_threshold(_entry);
+  double getMixDrawOrderThreshold() {
+    return _bindings.spine_track_entry_get_mix_draw_order_threshold(_entry);
   }
 
-  void setDrawOrderThreshold(double drawOrderThreshold) {
-    _bindings.spine_track_entry_set_draw_order_threshold(_entry, drawOrderThreshold);
+  void setMixDrawOrderThreshold(double drawOrderThreshold) {
+    _bindings.spine_track_entry_set_mix_draw_order_threshold(_entry, drawOrderThreshold);
   }
 
   /// The animation queued to start after this animation, or null if there is none. <code>next</code> makes up a doubly linked
@@ -3917,7 +3954,7 @@ class SkeletonDrawable {
     animationStateData = AnimationStateData._(_bindings.spine_skeleton_drawable_get_animation_state_data(_drawable));
     animationState = AnimationState._(_bindings.spine_skeleton_drawable_get_animation_state(_drawable),
         _bindings.spine_skeleton_drawable_get_animation_state_events(_drawable));
-    skeleton.updateWorldTransform();
+    skeleton.updateWorldTransform(Physics.none);
   }
 
   /// Constructs a new skeleton drawable from the [atlasFile] and [skeletonFile] from the root asset bundle
@@ -3956,7 +3993,8 @@ class SkeletonDrawable {
     if (_disposed) return;
     animationState.update(delta);
     animationState.apply(skeleton);
-    skeleton.updateWorldTransform();
+    skeleton.update(delta);
+    skeleton.updateWorldTransform(Physics.update);
   }
 
   /// Renders to current skeleton pose to a list of [RenderCommand] instances. The render commands

spine-flutter/src/spine_flutter.cpp

@@ -415,6 +415,12 @@ spine_path_constraint_data spine_skeleton_data_find_path_constraint(spine_skelet
 	return (spine_path_constraint_data) _data->findPathConstraint(name);
 }
 
+spine_physics_constraint_data spine_skeleton_data_find_physics_constraint(spine_skeleton_data data, const utf8 *name) {
+	if (data == nullptr) return nullptr;
+	SkeletonData *_data = (SkeletonData *) data;
+	return (spine_physics_constraint_data) _data->findPhysicsConstraint(name);
+}
+
 const utf8 *spine_skeleton_data_get_name(spine_skeleton_data data) {
 	if (data == nullptr) return nullptr;
 	SkeletonData *_data = (SkeletonData *) data;
@@ -529,6 +535,18 @@ spine_path_constraint_data *spine_skeleton_data_get_path_constraints(spine_skele
 	return (spine_path_constraint_data *) _data->getPathConstraints().buffer();
 }
 
+int32_t spine_skeleton_data_get_num_physics_constraints(spine_skeleton_data data) {
+	if (data == nullptr) return 0;
+	SkeletonData *_data = (SkeletonData *) data;
+	return (int32_t) _data->getPhysicsConstraints().size();
+}
+
+spine_physics_constraint_data *spine_skeleton_data_get_physics_constraints(spine_skeleton_data data) {
+	if (data == nullptr) return nullptr;
+	SkeletonData *_data = (SkeletonData *) data;
+	return (spine_physics_constraint_data *) _data->getPhysicsConstraints().buffer();
+}
+
 float spine_skeleton_data_get_x(spine_skeleton_data data) {
 	if (data == nullptr) return 0;
 	SkeletonData *_data = (SkeletonData *) data;
@@ -607,6 +625,12 @@ float spine_skeleton_data_get_fps(spine_skeleton_data data) {
 	return _data->getFps();
 }
 
+float spine_skeleton_data_get_reference_scale(spine_skeleton_data data) {
+	if (data == nullptr) return 0;
+	SkeletonData *_data = (SkeletonData *) data;
+	return _data->getReferenceScale();
+}
+
 void spine_skeleton_data_dispose(spine_skeleton_data data) {
 	if (!data) return;
 	delete (SkeletonData *) data;
@@ -1279,28 +1303,40 @@ void spine_track_entry_set_event_threshold(spine_track_entry entry, float eventT
 	_entry->setEventThreshold(eventThreshold);
 }
 
-float spine_track_entry_get_attachment_threshold(spine_track_entry entry) {
+float spine_track_entry_get_alpha_attachment_threshold(spine_track_entry entry) {
+	if (entry == nullptr) return 0;
+	TrackEntry *_entry = (TrackEntry *) entry;
+	return _entry->getAlphaAttachmentThreshold();
+}
+
+void spine_track_entry_set_alpha_attachment_threshold(spine_track_entry entry, float attachmentThreshold) {
+	if (entry == nullptr) return;
+	TrackEntry *_entry = (TrackEntry *) entry;
+	_entry->setAlphaAttachmentThreshold(attachmentThreshold);
+}
+
+float spine_track_entry_get_mix_attachment_threshold(spine_track_entry entry) {
 	if (entry == nullptr) return 0;
 	TrackEntry *_entry = (TrackEntry *) entry;
-	return _entry->getAttachmentThreshold();
+	return _entry->getMixAttachmentThreshold();
 }
 
-void spine_track_entry_set_attachment_threshold(spine_track_entry entry, float attachmentThreshold) {
+void spine_track_entry_set_mix_attachment_threshold(spine_track_entry entry, float attachmentThreshold) {
 	if (entry == nullptr) return;
 	TrackEntry *_entry = (TrackEntry *) entry;
-	_entry->setAttachmentThreshold(attachmentThreshold);
+	_entry->setMixAttachmentThreshold(attachmentThreshold);
 }
 
-float spine_track_entry_get_draw_order_threshold(spine_track_entry entry) {
+float spine_track_entry_get_mix_draw_order_threshold(spine_track_entry entry) {
 	if (entry == nullptr) return 0;
 	TrackEntry *_entry = (TrackEntry *) entry;
-	return _entry->getDrawOrderThreshold();
+	return _entry->getMixDrawOrderThreshold();
 }
 
-void spine_track_entry_set_draw_order_threshold(spine_track_entry entry, float drawOrderThreshold) {
+void spine_track_entry_set_mix_draw_order_threshold(spine_track_entry entry, float drawOrderThreshold) {
 	if (entry == nullptr) return;
 	TrackEntry *_entry = (TrackEntry *) entry;
-	_entry->setDrawOrderThreshold(drawOrderThreshold);
+	_entry->setMixDrawOrderThreshold(drawOrderThreshold);
 }
 
 spine_track_entry spine_track_entry_get_next(spine_track_entry entry) {
@@ -1383,18 +1419,18 @@ void spine_skeleton_update_cache(spine_skeleton skeleton) {
 	_skeleton->updateCache();
 }
 
-void spine_skeleton_update_world_transform(spine_skeleton skeleton) {
+void spine_skeleton_update_world_transform(spine_skeleton skeleton, spine_physics physics) {
 	if (skeleton == nullptr) return;
 	Skeleton *_skeleton = (Skeleton *) skeleton;
-	_skeleton->updateWorldTransform();
+	_skeleton->updateWorldTransform((spine::Physics)physics);
 }
 
-void spine_skeleton_update_world_transform_bone(spine_skeleton skeleton, spine_bone parent) {
+void spine_skeleton_update_world_transform_bone(spine_skeleton skeleton, spine_physics physics, spine_bone parent) {
 	if (skeleton == nullptr) return;
 	if (parent == nullptr) return;
 	Skeleton *_skeleton = (Skeleton *) skeleton;
 	Bone *_bone = (Bone *) parent;
-	_skeleton->updateWorldTransform(_bone);
+	_skeleton->updateWorldTransform((spine::Physics)physics, _bone);
 }
 
 void spine_skeleton_set_to_setup_pose(spine_skeleton skeleton) {
@@ -1476,6 +1512,12 @@ spine_path_constraint spine_skeleton_find_path_constraint(spine_skeleton skeleto
 	return (spine_path_constraint) _skeleton->findPathConstraint(constraintName);
 }
 
+spine_physics_constraint spine_skeleton_find_physics_constraint(spine_skeleton skeleton, const utf8 *constraintName) {
+	if (skeleton == nullptr) return nullptr;
+	Skeleton *_skeleton = (Skeleton *) skeleton;
+	return (spine_physics_constraint) _skeleton->findPhysicsConstraint(constraintName);
+}
+
 _spine_bounds tmp_bounds;
 spine_bounds spine_skeleton_get_bounds(spine_skeleton skeleton) {
 	_spine_bounds *bounds = &tmp_bounds;
@@ -1570,6 +1612,18 @@ spine_path_constraint *spine_skeleton_get_path_constraints(spine_skeleton skelet
 	return (spine_path_constraint *) _skeleton->getPathConstraints().buffer();
 }
 
+int32_t spine_skeleton_get_num_physics_constraints(spine_skeleton skeleton) {
+	if (skeleton == nullptr) return 0;
+	Skeleton *_skeleton = (Skeleton *) skeleton;
+	return (int32_t) _skeleton->getPhysicsConstraints().size();
+}
+
+spine_physics_constraint *spine_skeleton_get_physics_constraints(spine_skeleton skeleton) {
+	if (skeleton == nullptr) return nullptr;
+	Skeleton *_skeleton = (Skeleton *) skeleton;
+	return (spine_physics_constraint *) _skeleton->getPhysicsConstraints().buffer();
+}
+
 spine_skin spine_skeleton_get_skin(spine_skeleton skeleton) {
 	if (skeleton == nullptr) return nullptr;
 	Skeleton *_skeleton = (Skeleton *) skeleton;
@@ -1642,8 +1696,25 @@ void spine_skeleton_set_scale_y(spine_skeleton skeleton, float scaleY) {
 	_skeleton->setScaleY(scaleY);
 }
 
-// EventData
+float spine_skeleton_get_time(spine_skeleton skeleton) {
+	if (skeleton == nullptr) return 0;
+	Skeleton *_skeleton = (Skeleton *) skeleton;
+	return _skeleton->getTime();
+}
+
+void spine_skeleton_set_time(spine_skeleton skeleton, float time) {
+	if (skeleton == nullptr) return;
+	Skeleton *_skeleton = (Skeleton *) skeleton;
+	_skeleton->setTime(time);
+}
 
+void spine_skeleton_update(spine_skeleton skeleton, float delta) {
+	if (skeleton == nullptr) return;
+	Skeleton *_skeleton = (Skeleton *) skeleton;
+	_skeleton->update(delta);
+}
+
+// EventData
 const utf8 *spine_event_data_get_name(spine_event_data event) {
 	if (event == nullptr) return nullptr;
 	EventData *_event = (EventData *) event;
@@ -1869,6 +1940,18 @@ void spine_slot_data_set_blend_mode(spine_slot_data slot, spine_blend_mode blend
 	_slot->setBlendMode((BlendMode) blendMode);
 }
 
+int32_t spine_slot_data_is_visible(spine_slot_data slot) {
+	if (slot == nullptr) return false;
+	SlotData *_slot = (SlotData *) slot;
+	return _slot->isVisible();
+}
+
+void spine_slot_data_set_visible(spine_slot_data slot, int32_t visible) {
+	if (slot == nullptr) return;
+	SlotData *_slot = (SlotData *) slot;
+	_slot->setVisible(visible);
+}
+
 // Slot
 void spine_slot_set_to_setup_pose(spine_slot slot) {
 	if (slot == nullptr) return;
@@ -2063,16 +2146,16 @@ void spine_bone_data_set_shear_y(spine_bone_data data, float y) {
 	_data->setShearY(y);
 }
 
-spine_transform_mode spine_bone_data_get_transform_mode(spine_bone_data data) {
-	if (data == nullptr) return SPINE_TRANSFORM_MODE_NORMAL;
+spine_inherit spine_bone_data_get_inherit(spine_bone_data data) {
+	if (data == nullptr) return SPINE_INHERIT_NORMAL;
 	BoneData *_data = (BoneData *) data;
-	return (spine_transform_mode) _data->getTransformMode();
+	return (spine_inherit) _data->getInherit();
 }
 
-void spine_bone_data_set_transform_mode(spine_bone_data data, spine_transform_mode mode) {
+void spine_bone_data_set_inherit(spine_bone_data data, spine_inherit inherit) {
 	if (data == nullptr) return;
 	BoneData *_data = (BoneData *) data;
-	_data->setTransformMode((TransformMode) mode);
+	_data->setInherit((Inherit) inherit);
 }
 
 int32_t spine_bone_data_is_skin_required(spine_bone_data data) {
@@ -2099,6 +2182,18 @@ void spine_bone_data_set_color(spine_bone_data data, float r, float g, float b,
 	_data->getColor().set(r, g, b, a);
 }
 
+int32_t spine_bone_data_is_visible(spine_bone_data data) {
+	if (data == nullptr) return false;
+	BoneData *_data = (BoneData *) data;
+	return _data->isVisible();
+}
+
+void spine_bone_data_set_visible(spine_bone_data data, int32_t isVisible) {
+	if (data == nullptr) return;
+	BoneData *_data = (BoneData *) data;
+	_data->setVisible(isVisible);
+}
+
 // Bone
 void spine_bone_set_is_y_down(int32_t yDown) {
 	Bone::setYDown(yDown);
@@ -2111,7 +2206,7 @@ int32_t spine_bone_get_is_y_down() {
 void spine_bone_update(spine_bone bone) {
 	if (bone == nullptr) return;
 	Bone *_bone = (Bone *) bone;
-	_bone->update();
+	_bone->update(spine::Physics_Update);
 }
 
 void spine_bone_update_world_transform(spine_bone bone) {
@@ -2147,6 +2242,14 @@ spine_vector spine_bone_world_to_local(spine_bone bone, float worldX, float worl
 	return (spine_vector) coords;
 }
 
+spine_vector spine_bone_world_to_parent(spine_bone bone, float worldX, float worldY) {
+	_spine_vector *coords = &tmp_vector;
+	if (bone == nullptr) return (spine_vector) coords;
+	Bone *_bone = (Bone *) bone;
+	_bone->worldToParent(worldX, worldY, coords->x, coords->y);
+	return (spine_vector) coords;
+}
+
 spine_vector spine_bone_local_to_world(spine_bone bone, float localX, float localY) {
 	_spine_vector *coords = &tmp_vector;
 	if (bone == nullptr) return (spine_vector) coords;
@@ -2155,6 +2258,14 @@ spine_vector spine_bone_local_to_world(spine_bone bone, float localX, float loca
 	return (spine_vector) coords;
 }
 
+spine_vector spine_bone_parent_to_world(spine_bone bone, float localX, float localY) {
+	_spine_vector *coords = &tmp_vector;
+	if (bone == nullptr) return (spine_vector) coords;
+	Bone *_bone = (Bone *) bone;
+	_bone->parentToWorld(localX, localY, coords->x, coords->y);
+	return (spine_vector) coords;
+}
+
 float spine_bone_world_to_local_rotation(spine_bone bone, float worldRotation) {
 	if (bone == nullptr) return 0;
 	Bone *_bone = (Bone *) bone;
@@ -2491,6 +2602,18 @@ void spine_bone_set_is_active(spine_bone bone, int32_t isActive) {
 	_bone->setActive(isActive);
 }
 
+spine_inherit spine_bone_get_inherit(spine_bone bone) {
+	if (bone == nullptr) return SPINE_INHERIT_NORMAL;
+	Bone *_bone = (Bone *) bone;
+	return (spine_inherit)_bone->getInherit();
+}
+
+void spine_bone_set_inherit(spine_bone bone, spine_inherit inherit) {
+	if (bone == nullptr) return;
+	Bone *_bone = (Bone *) bone;
+	_bone->setInherit((spine::Inherit)inherit);
+}
+
 // Attachment
 const utf8 *spine_attachment_get_name(spine_attachment attachment) {
 	if (attachment == nullptr) return nullptr;
@@ -3279,7 +3402,7 @@ void spine_ik_constraint_data_set_softness(spine_ik_constraint_data data, float
 void spine_ik_constraint_update(spine_ik_constraint constraint) {
 	if (constraint == nullptr) return;
 	IkConstraint *_constraint = (IkConstraint *) constraint;
-	_constraint->update();
+	_constraint->update(spine::Physics_Update);
 }
 
 int32_t spine_ik_constraint_get_order(spine_ik_constraint constraint) {
@@ -3587,7 +3710,7 @@ void spine_transform_constraint_data_set_is_local(spine_transform_constraint_dat
 void spine_transform_constraint_update(spine_transform_constraint constraint) {
 	if (constraint == nullptr) return;
 	TransformConstraint *_constraint = (TransformConstraint *) constraint;
-	_constraint->update();
+	_constraint->update(spine::Physics_Update);
 }
 
 int32_t spine_transform_constraint_get_order(spine_transform_constraint constraint) {
@@ -3847,7 +3970,7 @@ void spine_path_constraint_data_set_mix_y(spine_path_constraint_data data, float
 void spine_path_constraint_update(spine_path_constraint constraint) {
 	if (constraint == nullptr) return;
 	PathConstraint *_constraint = (PathConstraint *) constraint;
-	_constraint->update();
+	_constraint->update(spine::Physics_Update);
 }
 
 int32_t spine_path_constraint_get_order(spine_path_constraint constraint) {
@@ -3958,6 +4081,608 @@ void spine_path_constraint_set_is_active(spine_path_constraint constraint, int32
 	_constraint->setActive(isActive);
 }
 
+// PhysicsConstraintData
+void spine_physics_constraint_data_set_bone(spine_physics_constraint_data data, spine_bone_data bone) {
+	if (data == nullptr) return;
+	PhysicsConstraintData *_data = (PhysicsConstraintData *) data;
+	_data->setBone((BoneData *) bone);
+}
+
+spine_bone_data spine_physics_constraint_data_get_bone(spine_physics_constraint_data data) {
+	if (data == nullptr) return nullptr;
+	PhysicsConstraintData *_data = (PhysicsConstraintData *) data;
+	return (spine_bone_data) _data->getBone();
+}
+
+void spine_physics_constraint_data_set_x(spine_physics_constraint_data data, float x) {
+	if (data == nullptr) return;
+	PhysicsConstraintData *_data = (PhysicsConstraintData *) data;
+	_data->setX(x);
+}
+
+float spine_physics_constraint_data_get_x(spine_physics_constraint_data data) {
+	if (data == nullptr) return 0.0f;
+	PhysicsConstraintData *_data = (PhysicsConstraintData *) data;
+	return _data->getX();
+}
+
+void spine_physics_constraint_data_set_y(spine_physics_constraint_data data, float y) {
+	if (data == nullptr) return;
+	PhysicsConstraintData *_data = (PhysicsConstraintData *) data;
+	_data->setY(y);
+}
+
+float spine_physics_constraint_data_get_y(spine_physics_constraint_data data) {
+	if (data == nullptr) return 0.0f;
+	PhysicsConstraintData *_data = (PhysicsConstraintData *) data;
+	return _data->getY();
+}
+
+void spine_physics_constraint_data_set_rotate(spine_physics_constraint_data data, float rotate) {
+	if (data == nullptr) return;
+	PhysicsConstraintData *_data = (PhysicsConstraintData *) data;
+	_data->setRotate(rotate);
+}
+
+float spine_physics_constraint_data_get_rotate(spine_physics_constraint_data data) {
+	if (data == nullptr) return 0.0f;
+	PhysicsConstraintData *_data = (PhysicsConstraintData *) data;
+	return _data->getRotate();
+}
+
+void spine_physics_constraint_data_set_scale_x(spine_physics_constraint_data data, float scaleX) {
+	if (data == nullptr) return;
+	PhysicsConstraintData *_data = (PhysicsConstraintData *) data;
+	_data->setScaleX(scaleX);
+}
+
+float spine_physics_constraint_data_get_scale_x(spine_physics_constraint_data data) {
+	if (data == nullptr) return 0.0f;
+	PhysicsConstraintData *_data = (PhysicsConstraintData *) data;
+	return _data->getScaleX();
+}
+
+void spine_physics_constraint_data_set_shear_x(spine_physics_constraint_data data, float shearX) {
+	if (data == nullptr) return;
+	PhysicsConstraintData *_data = (PhysicsConstraintData *) data;
+	_data->setShearX(shearX);
+}
+
+float spine_physics_constraint_data_get_shear_x(spine_physics_constraint_data data) {
+	if (data == nullptr) return 0.0f;
+	PhysicsConstraintData *_data = (PhysicsConstraintData *) data;
+	return _data->getShearX();
+}
+
+void spine_physics_constraint_data_set_limit(spine_physics_constraint_data data, float limit) {
+	if (data == nullptr) return;
+	PhysicsConstraintData *_data = (PhysicsConstraintData *) data;
+	_data->setLimit(limit);
+}
+
+float spine_physics_constraint_data_get_limit(spine_physics_constraint_data data) {
+	if (data == nullptr) return 0.0f;
+	PhysicsConstraintData *_data = (PhysicsConstraintData *) data;
+	return _data->getLimit();
+}
+
+void spine_physics_constraint_data_set_step(spine_physics_constraint_data data, float step) {
+	if (data == nullptr) return;
+	PhysicsConstraintData *_data = (PhysicsConstraintData *) data;
+	_data->setStep(step);
+}
+
+float spine_physics_constraint_data_get_step(spine_physics_constraint_data data) {
+	if (data == nullptr) return 0.0f;
+	PhysicsConstraintData *_data = (PhysicsConstraintData *) data;
+	return _data->getStep();
+}
+
+void spine_physics_constraint_data_set_inertia(spine_physics_constraint_data data, float inertia) {
+	if (data == nullptr) return;
+	PhysicsConstraintData *_data = (PhysicsConstraintData *) data;
+	_data->setInertia(inertia);
+}
+
+float spine_physics_constraint_data_get_inertia(spine_physics_constraint_data data) {
+	if (data == nullptr) return 0.0f;
+	PhysicsConstraintData *_data = (PhysicsConstraintData *) data;
+	return _data->getInertia();
+}
+
+void spine_physics_constraint_data_set_strength(spine_physics_constraint_data data, float strength) {
+	if (data == nullptr) return;
+	PhysicsConstraintData *_data = (PhysicsConstraintData *) data;
+	_data->setStrength(strength);
+}
+
+float spine_physics_constraint_data_get_strength(spine_physics_constraint_data data) {
+	if (data == nullptr) return 0.0f;
+	PhysicsConstraintData *_data = (PhysicsConstraintData *) data;
+	return _data->getStrength();
+}
+
+void spine_physics_constraint_data_set_damping(spine_physics_constraint_data data, float damping) {
+	if (data == nullptr) return;
+	PhysicsConstraintData *_data = (PhysicsConstraintData *) data;
+	_data->setDamping(damping);
+}
+
+float spine_physics_constraint_data_get_damping(spine_physics_constraint_data data) {
+	if (data == nullptr) return 0.0f;
+	PhysicsConstraintData *_data = (PhysicsConstraintData *) data;
+	return _data->getDamping();
+}
+
+void spine_physics_constraint_data_set_mass_inverse(spine_physics_constraint_data data, float massInverse) {
+	if (data == nullptr) return;
+	PhysicsConstraintData *_data = (PhysicsConstraintData *) data;
+	_data->setMassInverse(massInverse);
+}
+
+float spine_physics_constraint_data_get_mass_inverse(spine_physics_constraint_data data) {
+	if (data == nullptr) return 0.0f;
+	PhysicsConstraintData *_data = (PhysicsConstraintData *) data;
+	return _data->getMassInverse();
+}
+
+void spine_physics_constraint_data_set_wind(spine_physics_constraint_data data, float wind) {
+	if (data == nullptr) return;
+	PhysicsConstraintData *_data = (PhysicsConstraintData *) data;
+	_data->setWind(wind);
+}
+
+float spine_physics_constraint_data_get_wind(spine_physics_constraint_data data) {
+	if (data == nullptr) return 0.0f;
+	PhysicsConstraintData *_data = (PhysicsConstraintData *) data;
+	return _data->getWind();
+}
+
+void spine_physics_constraint_data_set_gravity(spine_physics_constraint_data data, float gravity) {
+	if (data == nullptr) return;
+	PhysicsConstraintData *_data = (PhysicsConstraintData *) data;
+	_data->setGravity(gravity);
+}
+
+float spine_physics_constraint_data_get_gravity(spine_physics_constraint_data data) {
+	if (data == nullptr) return 0.0f;
+	PhysicsConstraintData *_data = (PhysicsConstraintData *) data;
+	return _data->getGravity();
+}
+
+void spine_physics_constraint_data_set_mix(spine_physics_constraint_data data, float mix) {
+	if (data == nullptr) return;
+	PhysicsConstraintData *_data = (PhysicsConstraintData *) data;
+	_data->setMix(mix);
+}
+
+float spine_physics_constraint_data_get_mix(spine_physics_constraint_data data) {
+	if (data == nullptr) return 0.0f;
+	PhysicsConstraintData *_data = (PhysicsConstraintData *) data;
+	return _data->getMix();
+}
+
+void spine_physics_constraint_data_set_inertia_global(spine_physics_constraint_data data, int32_t inertiaGlobal) {
+	if (data == nullptr) return;
+	PhysicsConstraintData *_data = (PhysicsConstraintData *) data;
+	_data->setInertiaGlobal(inertiaGlobal);
+}
+
+int32_t spine_physics_constraint_data_is_inertia_global(spine_physics_constraint_data data) {
+	if (data == nullptr) return false;
+	PhysicsConstraintData *_data = (PhysicsConstraintData *) data;
+	return _data->isInertiaGlobal();
+}
+
+void spine_physics_constraint_data_set_strength_global(spine_physics_constraint_data data, int32_t strengthGlobal) {
+	if (data == nullptr) return;
+	PhysicsConstraintData *_data = (PhysicsConstraintData *) data;
+	_data->setStrengthGlobal(strengthGlobal);
+}
+
+int32_t spine_physics_constraint_data_is_strength_global(spine_physics_constraint_data data) {
+	if (data == nullptr) return false;
+	PhysicsConstraintData *_data = (PhysicsConstraintData *) data;
+	return _data->isStrengthGlobal();
+}
+
+void spine_physics_constraint_data_set_damping_global(spine_physics_constraint_data data, int32_t dampingGlobal) {
+	if (data == nullptr) return;
+	PhysicsConstraintData *_data = (PhysicsConstraintData *) data;
+	_data->setDampingGlobal(dampingGlobal);
+}
+
+int32_t spine_physics_constraint_data_is_damping_global(spine_physics_constraint_data data) {
+	if (data == nullptr) return false;
+	PhysicsConstraintData *_data = (PhysicsConstraintData *) data;
+	return _data->isDampingGlobal();
+}
+
+void spine_physics_constraint_data_set_mass_global(spine_physics_constraint_data data, int32_t massGlobal) {
+	if (data == nullptr) return;
+	PhysicsConstraintData *_data = (PhysicsConstraintData *) data;
+	_data->setMassGlobal(massGlobal);
+}
+
+int32_t spine_physics_constraint_data_is_mass_global(spine_physics_constraint_data data) {
+	if (data == nullptr) return false;
+	PhysicsConstraintData *_data = (PhysicsConstraintData *) data;
+	return _data->isMassGlobal();
+}
+
+void spine_physics_constraint_data_set_wind_global(spine_physics_constraint_data data, int32_t windGlobal) {
+	if (data == nullptr) return;
+	PhysicsConstraintData *_data = (PhysicsConstraintData *) data;
+	_data->setWindGlobal(windGlobal);
+}
+
+int32_t spine_physics_constraint_data_is_wind_global(spine_physics_constraint_data data) {
+	if (data == nullptr) return false;
+	PhysicsConstraintData *_data = (PhysicsConstraintData *) data;
+	return _data->isWindGlobal();
+}
+
+void spine_physics_constraint_data_set_gravity_global(spine_physics_constraint_data data, int32_t gravityGlobal) {
+	if (data == nullptr) return;
+	PhysicsConstraintData *_data = (PhysicsConstraintData *) data;
+	_data->setGravityGlobal(gravityGlobal);
+}
+
+int32_t spine_physics_constraint_data_is_gravity_global(spine_physics_constraint_data data) {
+	if (data == nullptr) return false;
+	PhysicsConstraintData *_data = (PhysicsConstraintData *) data;
+	return _data->isGravityGlobal();
+}
+
+void spine_physics_constraint_data_set_mix_global(spine_physics_constraint_data data, int32_t mixGlobal) {
+	if (data == nullptr) return;
+	PhysicsConstraintData *_data = (PhysicsConstraintData *) data;
+	_data->setMixGlobal(mixGlobal);
+}
+
+int32_t spine_physics_constraint_data_is_mix_global(spine_physics_constraint_data data) {
+	if (data == nullptr) return false;
+	PhysicsConstraintData *_data = (PhysicsConstraintData *) data;
+	return _data->isMixGlobal();
+}
+
+// PhysicsConstraint
+void spine_physics_constraint_set_bone(spine_physics_constraint constraint, spine_bone bone) {
+	if (constraint == nullptr) return;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)constraint;
+	_constraint->setBone((Bone*)bone);
+}
+
+spine_bone spine_physics_constraint_get_bone(spine_physics_constraint constraint) {
+	if (constraint == nullptr) return nullptr;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)constraint;
+	return (spine_bone)_constraint->getBone();
+}
+
+void spine_physics_constraint_set_inertia(spine_physics_constraint constraint, float value) {
+	if (constraint == nullptr) return;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)constraint;
+	_constraint->setInertia(value);
+}
+
+float spine_physics_constraint_get_inertia(spine_physics_constraint constraint) {
+	if (constraint == nullptr) return 0.0f;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)constraint;
+	return _constraint->getInertia();
+}
+
+void spine_physics_constraint_set_strength(spine_physics_constraint constraint, float value) {
+	if (constraint == nullptr) return;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)constraint;
+	_constraint->setStrength(value);
+}
+
+float spine_physics_constraint_get_strength(spine_physics_constraint constraint) {
+	if (constraint == nullptr) return 0.0f;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)constraint;
+	return _constraint->getStrength();
+}
+
+void spine_physics_constraint_set_damping(spine_physics_constraint constraint, float value) {
+	if (constraint == nullptr) return;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)constraint;
+	_constraint->setDamping(value);
+}
+
+float spine_physics_constraint_get_damping(spine_physics_constraint constraint) {
+	if (constraint == nullptr) return 0.0f;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)constraint;
+	return _constraint->getDamping();
+}
+
+void spine_physics_constraint_set_mass_inverse(spine_physics_constraint constraint, float value) {
+	if (constraint == nullptr) return;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)constraint;
+	_constraint->setMassInverse(value);
+}
+
+float spine_physics_constraint_get_mass_inverse(spine_physics_constraint constraint) {
+	if (constraint == nullptr) return 0.0f;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)constraint;
+	return _constraint->getMassInverse();
+}
+
+void spine_physics_constraint_set_wind(spine_physics_constraint constraint, float value) {
+	if (constraint == nullptr) return;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)constraint;
+	_constraint->setWind(value);
+}
+
+float spine_physics_constraint_get_wind(spine_physics_constraint constraint) {
+	if (constraint == nullptr) return 0.0f;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)constraint;
+	return _constraint->getWind();
+}
+
+void spine_physics_constraint_set_gravity(spine_physics_constraint constraint, float value) {
+	if (constraint == nullptr) return;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)constraint;
+	_constraint->setGravity(value);
+}
+
+float spine_physics_constraint_get_gravity(spine_physics_constraint constraint) {
+	if (constraint == nullptr) return 0.0f;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)constraint;
+	return _constraint->getGravity();
+}
+
+void spine_physics_constraint_set_mix(spine_physics_constraint constraint, float value) {
+	if (constraint == nullptr) return;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)constraint;
+	_constraint->setMix(value);
+}
+
+float spine_physics_constraint_get_mix(spine_physics_constraint constraint) {
+	if (constraint == nullptr) return 0.0f;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)constraint;
+	return _constraint->getMix();
+}
+
+void spine_physics_constraint_set_reset(spine_physics_constraint constraint, int32_t value) {
+	if (constraint == nullptr) return;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)constraint;
+	_constraint->setReset(value);
+}
+
+int32_t spine_physics_constraint_get_reset(spine_physics_constraint constraint) {
+	if (constraint == nullptr) return false;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)constraint;
+	return _constraint->getReset();
+}
+
+void spine_physics_constraint_set_ux(spine_physics_constraint constraint, float value) {
+	if (constraint == nullptr) return;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)constraint;
+	_constraint->setUx(value);
+}
+
+float spine_physics_constraint_get_ux(spine_physics_constraint constraint) {
+	if (constraint == nullptr) return 0.0f;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)constraint;
+	return _constraint->getUx();
+}
+
+void spine_physics_constraint_set_uy(spine_physics_constraint constraint, float value) {
+	if (constraint == nullptr) return;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)constraint;
+	_constraint->setUy(value);
+}
+
+float spine_physics_constraint_get_uy(spine_physics_constraint constraint) {
+	if (constraint == nullptr) return 0.0f;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)constraint;
+	return _constraint->getUy();
+}
+
+void spine_physics_constraint_set_cx(spine_physics_constraint constraint, float value) {
+	if (constraint == nullptr) return;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)constraint;
+	_constraint->setCx(value);
+}
+
+float spine_physics_constraint_get_cx(spine_physics_constraint constraint) {
+	if (constraint == nullptr) return 0.0f;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)constraint;
+	return _constraint->getCx();
+}
+
+void spine_physics_constraint_set_cy(spine_physics_constraint constraint, float value) {
+	if (constraint == nullptr) return;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)constraint;
+	_constraint->setCy(value);
+}
+
+float spine_physics_constraint_get_cy(spine_physics_constraint constraint) {
+	if (constraint == nullptr) return 0.0f;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)constraint;
+	return _constraint->getCy();
+}
+
+void spine_physics_constraint_set_tx(spine_physics_constraint constraint, float value) {
+	if (constraint == nullptr) return;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)constraint;
+	_constraint->setTx(value);
+}
+
+float spine_physics_constraint_get_tx(spine_physics_constraint constraint) {
+	if (constraint == nullptr) return 0.0f;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)constraint;
+	return _constraint->getTx();
+}
+
+void spine_physics_constraint_set_ty(spine_physics_constraint constraint, float value) {
+	if (constraint == nullptr) return;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)constraint;
+	_constraint->setTy(value);
+}
+
+float spine_physics_constraint_get_ty(spine_physics_constraint constraint) {
+	if (constraint == nullptr) return 0.0f;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)constraint;
+	return _constraint->getTy();
+}
+
+void spine_physics_constraint_set_x_offset(spine_physics_constraint constraint, float value) {
+	if (constraint == nullptr) return;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)constraint;
+	_constraint->setXOffset(value);
+}
+
+float spine_physics_constraint_get_x_offset(spine_physics_constraint constraint) {
+	if (constraint == nullptr) return 0.0f;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)constraint;
+	return _constraint->getXOffset();
+}
+
+void spine_physics_constraint_set_x_velocity(spine_physics_constraint constraint, float value) {
+	if (constraint == nullptr) return;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)constraint;
+	_constraint->setXVelocity(value);
+}
+
+float spine_physics_constraint_get_x_velocity(spine_physics_constraint constraint) {
+	if (constraint == nullptr) return 0.0f;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)constraint;
+	return _constraint->getXVelocity();
+}
+
+void spine_physics_constraint_set_y_offset(spine_physics_constraint constraint, float value) {
+	if (constraint == nullptr) return;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)constraint;
+	_constraint->setYOffset(value);
+}
+
+float spine_physics_constraint_get_y_offset(spine_physics_constraint constraint) {
+	if (constraint == nullptr) return 0.0f;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)constraint;
+	return _constraint->getYOffset();
+}
+
+void spine_physics_constraint_set_y_velocity(spine_physics_constraint constraint, float value) {
+	if (constraint == nullptr) return;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)constraint;
+	_constraint->setYVelocity(value);
+}
+
+float spine_physics_constraint_get_y_velocity(spine_physics_constraint constraint) {
+	if (constraint == nullptr) return 0.0f;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)constraint;
+	return _constraint->getYVelocity();
+}
+
+void spine_physics_constraint_set_rotate_offset(spine_physics_constraint constraint, float value) {
+	if (constraint == nullptr) return;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)constraint;
+	_constraint->setRotateOffset(value);
+}
+
+float spine_physics_constraint_get_rotate_offset(spine_physics_constraint constraint) {
+	if (constraint == nullptr) return 0.0f;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)constraint;
+	return _constraint->getRotateOffset();
+}
+
+void spine_physics_constraint_set_rotate_velocity(spine_physics_constraint constraint, float value) {
+	if (constraint == nullptr) return;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)constraint;
+	_constraint->setRotateVelocity(value);
+}
+
+float spine_physics_constraint_get_rotate_velocity(spine_physics_constraint constraint) {
+	if (constraint == nullptr) return 0.0f;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)constraint;
+	return _constraint->getRotateVelocity();
+}
+
+void spine_physics_constraint_set_scale_offset(spine_physics_constraint constraint, float value) {
+	if (constraint == nullptr) return;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)constraint;
+	_constraint->setScaleOffset(value);
+}
+
+float spine_physics_constraint_get_scale_offset(spine_physics_constraint constraint) {
+	if (constraint == nullptr) return 0.0f;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)constraint;
+	return _constraint->getScaleOffset();
+}
+
+void spine_physics_constraint_set_scale_velocity(spine_physics_constraint constraint, float value) {
+	if (constraint == nullptr) return;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)constraint;
+	_constraint->setScaleVelocity(value);
+}
+
+float spine_physics_constraint_get_scale_velocity(spine_physics_constraint constraint) {
+	if (constraint == nullptr) return 0.0f;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)constraint;
+	return _constraint->getScaleVelocity();
+}
+
+void spine_physics_constraint_set_active(spine_physics_constraint constraint, int32_t value) {
+	if (constraint == nullptr) return;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)constraint;
+	_constraint->setActive(value);
+}
+
+int32_t spine_physics_constraint_is_active(spine_physics_constraint constraint) {
+	if (constraint == nullptr) return false;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)constraint;
+	return _constraint->isActive();
+}
+
+void spine_physics_constraint_set_remaining(spine_physics_constraint constraint, float value) {
+	if (constraint == nullptr) return;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)constraint;
+	_constraint->setRemaining(value);
+}
+
+float spine_physics_constraint_get_remaining(spine_physics_constraint constraint) {
+	if (constraint == nullptr) return 0.0f;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)constraint;
+	return _constraint->getRemaining();
+}
+
+void spine_physics_constraint_set_last_time(spine_physics_constraint constraint, float value) {
+	if (constraint == nullptr) return;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)constraint;
+	_constraint->setLastTime(value);
+}
+
+float spine_physics_constraint_get_last_time(spine_physics_constraint constraint) {
+	if (constraint == nullptr) return 0.0f;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)constraint;
+	return _constraint->getLastTime();
+}
+
+void spine_physics_constraint_reset(spine_physics_constraint constraint) {
+	if (constraint == nullptr) return;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)constraint;
+	_constraint->reset();
+}
+
+void spine_physics_constraint_update(spine_physics_constraint data, spine_physics physics) {
+	if (data == nullptr) return;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)data;
+	_constraint->update((spine::Physics)physics);
+}
+
+void spine_physics_constraint_translate(spine_physics_constraint data, float x, float y) {
+	if (data == nullptr) return;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)data;
+	_constraint->translate(x, y);
+}
+
+void spine_physics_constraint_rotate(spine_physics_constraint data, float x, float y, float degrees) {
+	if (data == nullptr) return;
+	PhysicsConstraint *_constraint = (PhysicsConstraint *)data;
+	_constraint->rotate(x, y, degrees);
+}
+
 // Sequence
 void spine_sequence_apply(spine_sequence sequence, spine_slot slot, spine_attachment attachment) {
 	if (sequence == nullptr) return;

spine-flutter/src/spine_flutter.h

@@ -84,6 +84,8 @@ SPINE_OPAQUE_TYPE(spine_transform_constraint)
 SPINE_OPAQUE_TYPE(spine_transform_constraint_data)
 SPINE_OPAQUE_TYPE(spine_path_constraint)
 SPINE_OPAQUE_TYPE(spine_path_constraint_data)
+SPINE_OPAQUE_TYPE(spine_physics_constraint)
+SPINE_OPAQUE_TYPE(spine_physics_constraint_data)
 SPINE_OPAQUE_TYPE(spine_animation_state)
 SPINE_OPAQUE_TYPE(spine_animation_state_data)
 SPINE_OPAQUE_TYPE(spine_animation_state_events)
@@ -141,13 +143,13 @@ typedef enum spine_constraint_type {
 	SPINE_CONSTRAINT_PATH
 } spine_constraint_type;
 
-typedef enum spine_transform_mode {
-	SPINE_TRANSFORM_MODE_NORMAL = 0,
-	SPINE_TRANSFORM_ONLY_TRANSLATION,
-	SPINE_TRANSFORM_NO_ROTATION_OR_REFLECTION,
-	SPINE_TRANSFORM_NO_SCALE,
-	SPINE_TRANSFORM_NO_SCALE_OR_REFLECTION
-} spine_transform_mode;
+typedef enum spine_inherit {
+	SPINE_INHERIT_NORMAL = 0,
+	SPINE_INHERIT_ONLY_TRANSLATION,
+	SPINE_INHERIT_NO_ROTATION_OR_REFLECTION,
+	SPINE_INHERIT_NO_SCALE,
+	SPINE_INHERIT_NO_SCALE_OR_REFLECTION
+} spine_inherit;
 
 typedef enum spine_position_mode {
 	SPINE_POSITION_MODE_FIXED = 0,
@@ -167,6 +169,14 @@ typedef enum spine_rotate_mode {
 	SPINE_ROTATE_MODE_CHAIN_SCALE
 } spine_rotate_mode;
 
+typedef enum spine_physics {
+	SPINE_PHYSICS_NONE = 0,
+	SPINE_PHYSICS_RESET,
+	SPINE_PHYSICS_UPDATE,
+	SPINE_PHYSICS_POSE
+
+} spine_physics;
+
 SPINE_FLUTTER_EXPORT int32_t spine_major_version();
 SPINE_FLUTTER_EXPORT int32_t spine_minor_version();
 SPINE_FLUTTER_EXPORT void spine_enable_debug_extension(int32_t enable);
@@ -204,6 +214,7 @@ SPINE_FLUTTER_EXPORT spine_animation spine_skeleton_data_find_animation(spine_sk
 SPINE_FLUTTER_EXPORT spine_ik_constraint_data spine_skeleton_data_find_ik_constraint(spine_skeleton_data data, const utf8 *name);
 SPINE_FLUTTER_EXPORT spine_transform_constraint_data spine_skeleton_data_find_transform_constraint(spine_skeleton_data data, const utf8 *name);
 SPINE_FLUTTER_EXPORT spine_path_constraint_data spine_skeleton_data_find_path_constraint(spine_skeleton_data data, const utf8 *name);
+SPINE_FLUTTER_EXPORT spine_physics_constraint_data spine_skeleton_data_find_physics_constraint(spine_skeleton_data data, const utf8 *name);
 SPINE_FLUTTER_EXPORT const utf8 *spine_skeleton_data_get_name(spine_skeleton_data data);
 // OMITTED setName()
 SPINE_FLUTTER_EXPORT int32_t spine_skeleton_data_get_num_bones(spine_skeleton_data data);
@@ -224,6 +235,8 @@ SPINE_FLUTTER_EXPORT int32_t spine_skeleton_data_get_num_transform_constraints(s
 SPINE_FLUTTER_EXPORT spine_transform_constraint_data *spine_skeleton_data_get_transform_constraints(spine_skeleton_data data);
 SPINE_FLUTTER_EXPORT int32_t spine_skeleton_data_get_num_path_constraints(spine_skeleton_data data);
 SPINE_FLUTTER_EXPORT spine_path_constraint_data *spine_skeleton_data_get_path_constraints(spine_skeleton_data data);
+SPINE_FLUTTER_EXPORT int32_t spine_skeleton_data_get_num_physics_constraints(spine_skeleton_data data);
+SPINE_FLUTTER_EXPORT spine_physics_constraint_data *spine_skeleton_data_get_physics_constraints(spine_skeleton_data data);
 SPINE_FLUTTER_EXPORT float spine_skeleton_data_get_x(spine_skeleton_data data);
 SPINE_FLUTTER_EXPORT void spine_skeleton_data_set_x(spine_skeleton_data data, float x);
 SPINE_FLUTTER_EXPORT float spine_skeleton_data_get_y(spine_skeleton_data data);
@@ -242,6 +255,7 @@ SPINE_FLUTTER_EXPORT const utf8 *spine_skeleton_data_get_audio_path(spine_skelet
 // OMITTED setAudioPath()
 SPINE_FLUTTER_EXPORT float spine_skeleton_data_get_fps(spine_skeleton_data data);
 // OMITTED setFps()
+SPINE_FLUTTER_EXPORT float spine_skeleton_data_get_reference_scale(spine_skeleton_data data);
 SPINE_FLUTTER_EXPORT void spine_skeleton_data_dispose(spine_skeleton_data data);
 
 SPINE_FLUTTER_EXPORT spine_skeleton_drawable spine_skeleton_drawable_create(spine_skeleton_data skeletonData);
@@ -337,10 +351,12 @@ SPINE_FLUTTER_EXPORT float spine_track_entry_get_alpha(spine_track_entry entry);
 SPINE_FLUTTER_EXPORT void spine_track_entry_set_alpha(spine_track_entry entry, float alpha);
 SPINE_FLUTTER_EXPORT float spine_track_entry_get_event_threshold(spine_track_entry entry);
 SPINE_FLUTTER_EXPORT void spine_track_entry_set_event_threshold(spine_track_entry entry, float eventThreshold);
-SPINE_FLUTTER_EXPORT float spine_track_entry_get_attachment_threshold(spine_track_entry entry);
-SPINE_FLUTTER_EXPORT void spine_track_entry_set_attachment_threshold(spine_track_entry entry, float attachmentThreshold);
-SPINE_FLUTTER_EXPORT float spine_track_entry_get_draw_order_threshold(spine_track_entry entry);
-SPINE_FLUTTER_EXPORT void spine_track_entry_set_draw_order_threshold(spine_track_entry entry, float drawOrderThreshold);
+SPINE_FLUTTER_EXPORT float spine_track_entry_get_alpha_attachment_threshold(spine_track_entry entry);
+SPINE_FLUTTER_EXPORT void spine_track_entry_set_alpha_attachment_threshold(spine_track_entry entry, float attachmentThreshold);
+SPINE_FLUTTER_EXPORT float spine_track_entry_get_mix_attachment_threshold(spine_track_entry entry);
+SPINE_FLUTTER_EXPORT void spine_track_entry_set_mix_attachment_threshold(spine_track_entry entry, float attachmentThreshold);
+SPINE_FLUTTER_EXPORT float spine_track_entry_get_mix_draw_order_threshold(spine_track_entry entry);
+SPINE_FLUTTER_EXPORT void spine_track_entry_set_mix_draw_order_threshold(spine_track_entry entry, float drawOrderThreshold);
 SPINE_FLUTTER_EXPORT spine_track_entry spine_track_entry_get_next(spine_track_entry entry);
 SPINE_FLUTTER_EXPORT int32_t spine_track_entry_is_complete(spine_track_entry entry);
 SPINE_FLUTTER_EXPORT float spine_track_entry_get_mix_time(spine_track_entry entry);
@@ -358,8 +374,8 @@ SPINE_FLUTTER_EXPORT float spine_track_entry_get_track_complete(spine_track_entr
 
 SPINE_FLUTTER_EXPORT void spine_skeleton_update_cache(spine_skeleton skeleton);
 // OMITTED printUpdateCache()
-SPINE_FLUTTER_EXPORT void spine_skeleton_update_world_transform(spine_skeleton skeleton);
-SPINE_FLUTTER_EXPORT void spine_skeleton_update_world_transform_bone(spine_skeleton skeleton, spine_bone parent);
+SPINE_FLUTTER_EXPORT void spine_skeleton_update_world_transform(spine_skeleton skeleton, spine_physics physics);
+SPINE_FLUTTER_EXPORT void spine_skeleton_update_world_transform_bone(spine_skeleton skeleton, spine_physics physics, spine_bone parent);
 SPINE_FLUTTER_EXPORT void spine_skeleton_set_to_setup_pose(spine_skeleton skeleton);
 SPINE_FLUTTER_EXPORT void spine_skeleton_set_bones_to_setup_pose(spine_skeleton skeleton);
 SPINE_FLUTTER_EXPORT void spine_skeleton_set_slots_to_setup_pose(spine_skeleton skeleton);
@@ -373,6 +389,7 @@ SPINE_FLUTTER_EXPORT void spine_skeleton_set_attachment(spine_skeleton skeleton,
 SPINE_FLUTTER_EXPORT spine_ik_constraint spine_skeleton_find_ik_constraint(spine_skeleton skeleton, const utf8 *constraintName);
 SPINE_FLUTTER_EXPORT spine_transform_constraint spine_skeleton_find_transform_constraint(spine_skeleton skeleton, const utf8 *constraintName);
 SPINE_FLUTTER_EXPORT spine_path_constraint spine_skeleton_find_path_constraint(spine_skeleton skeleton, const utf8 *constraintName);
+SPINE_FLUTTER_EXPORT spine_physics_constraint spine_skeleton_find_physics_constraint(spine_skeleton skeleton, const utf8 *constraintName);
 SPINE_FLUTTER_EXPORT spine_bounds spine_skeleton_get_bounds(spine_skeleton skeleton);
 SPINE_FLUTTER_EXPORT spine_bone spine_skeleton_get_root_bone(spine_skeleton skeleton);
 SPINE_FLUTTER_EXPORT spine_skeleton_data spine_skeleton_get_data(spine_skeleton skeleton);
@@ -389,6 +406,8 @@ SPINE_FLUTTER_EXPORT int32_t spine_skeleton_get_num_transform_constraints(spine_
 SPINE_FLUTTER_EXPORT spine_transform_constraint *spine_skeleton_get_transform_constraints(spine_skeleton skeleton);
 SPINE_FLUTTER_EXPORT int32_t spine_skeleton_get_num_path_constraints(spine_skeleton skeleton);
 SPINE_FLUTTER_EXPORT spine_path_constraint *spine_skeleton_get_path_constraints(spine_skeleton skeleton);
+SPINE_FLUTTER_EXPORT int32_t spine_skeleton_get_num_physics_constraints(spine_skeleton skeleton);
+SPINE_FLUTTER_EXPORT spine_physics_constraint *spine_skeleton_get_physics_constraints(spine_skeleton skeleton);
 SPINE_FLUTTER_EXPORT spine_skin spine_skeleton_get_skin(spine_skeleton skeleton);
 SPINE_FLUTTER_EXPORT spine_color spine_skeleton_get_color(spine_skeleton skeleton);
 SPINE_FLUTTER_EXPORT void spine_skeleton_set_color(spine_skeleton skeleton, float r, float g, float b, float a);
@@ -401,6 +420,9 @@ SPINE_FLUTTER_EXPORT float spine_skeleton_get_scale_x(spine_skeleton skeleton);
 SPINE_FLUTTER_EXPORT void spine_skeleton_set_scale_x(spine_skeleton skeleton, float scaleX);
 SPINE_FLUTTER_EXPORT float spine_skeleton_get_scale_y(spine_skeleton skeleton);
 SPINE_FLUTTER_EXPORT void spine_skeleton_set_scale_y(spine_skeleton skeleton, float scaleY);
+SPINE_FLUTTER_EXPORT float spine_skeleton_get_time(spine_skeleton skeleton);
+SPINE_FLUTTER_EXPORT void spine_skeleton_set_time(spine_skeleton skeleton, float time);
+SPINE_FLUTTER_EXPORT void spine_skeleton_update(spine_skeleton skeleton, float delta);
 
 SPINE_FLUTTER_EXPORT const utf8 *spine_event_data_get_name(spine_event_data event);
 SPINE_FLUTTER_EXPORT int32_t spine_event_data_get_int_value(spine_event_data event);
@@ -442,6 +464,9 @@ SPINE_FLUTTER_EXPORT const utf8 *spine_slot_data_get_attachment_name(spine_slot_
 SPINE_FLUTTER_EXPORT void spine_slot_data_set_attachment_name(spine_slot_data slot, const utf8 *attachmentName);
 SPINE_FLUTTER_EXPORT spine_blend_mode spine_slot_data_get_blend_mode(spine_slot_data slot);
 SPINE_FLUTTER_EXPORT void spine_slot_data_set_blend_mode(spine_slot_data slot, spine_blend_mode blendMode);
+SPINE_FLUTTER_EXPORT int32_t spine_slot_data_is_visible(spine_slot_data slot);
+SPINE_FLUTTER_EXPORT void spine_slot_data_set_visible(spine_slot_data slot, int32_t visible);
+// OMITTED getPath()/setPath()
 
 SPINE_FLUTTER_EXPORT void spine_slot_set_to_setup_pose(spine_slot slot);
 SPINE_FLUTTER_EXPORT spine_slot_data spine_slot_get_data(spine_slot slot);
@@ -477,12 +502,15 @@ SPINE_FLUTTER_EXPORT float spine_bone_data_get_shear_x(spine_bone_data data);
 SPINE_FLUTTER_EXPORT void spine_bone_data_set_shear_x(spine_bone_data data, float shearx);
 SPINE_FLUTTER_EXPORT float spine_bone_data_get_shear_y(spine_bone_data data);
 SPINE_FLUTTER_EXPORT void spine_bone_data_set_shear_y(spine_bone_data data, float shearY);
-SPINE_FLUTTER_EXPORT spine_transform_mode spine_bone_data_get_transform_mode(spine_bone_data data);
-SPINE_FLUTTER_EXPORT void spine_bone_data_set_transform_mode(spine_bone_data data, spine_transform_mode mode);
+SPINE_FLUTTER_EXPORT spine_inherit spine_bone_data_get_inherit(spine_bone_data data);
+SPINE_FLUTTER_EXPORT void spine_bone_data_set_inherit(spine_bone_data data, spine_inherit inherit);
 SPINE_FLUTTER_EXPORT int32_t spine_bone_data_is_skin_required(spine_bone_data data);
 SPINE_FLUTTER_EXPORT void spine_bone_data_set_is_skin_required(spine_bone_data data, int32_t isSkinRequired);
 SPINE_FLUTTER_EXPORT spine_color spine_bone_data_get_color(spine_bone_data data);
 SPINE_FLUTTER_EXPORT void spine_bone_data_set_color(spine_bone_data data, float r, float g, float b, float a);
+SPINE_FLUTTER_EXPORT int32_t spine_bone_data_is_visible(spine_bone_data data);
+SPINE_FLUTTER_EXPORT void spine_bone_data_set_visible(spine_bone_data data, int32_t isVisible);
+// Omitted getIcon()/setIcon()
 
 SPINE_FLUTTER_EXPORT void spine_bone_set_is_y_down(int32_t yDown);
 SPINE_FLUTTER_EXPORT int32_t spine_bone_get_is_y_down();
@@ -492,7 +520,9 @@ SPINE_FLUTTER_EXPORT void spine_bone_update_world_transform_with(spine_bone bone
 SPINE_FLUTTER_EXPORT void spine_bone_update_applied_transform(spine_bone bone);
 SPINE_FLUTTER_EXPORT void spine_bone_set_to_setup_pose(spine_bone bone);
 SPINE_FLUTTER_EXPORT spine_vector spine_bone_world_to_local(spine_bone bone, float worldX, float worldY);
+SPINE_FLUTTER_EXPORT spine_vector spine_bone_world_to_parent(spine_bone bone, float worldX, float worldY);
 SPINE_FLUTTER_EXPORT spine_vector spine_bone_local_to_world(spine_bone bone, float localX, float localY);
+SPINE_FLUTTER_EXPORT spine_vector spine_bone_parent_to_world(spine_bone bone, float localX, float localY);
 SPINE_FLUTTER_EXPORT float spine_bone_world_to_local_rotation(spine_bone bone, float worldRotation);
 SPINE_FLUTTER_EXPORT float spine_bone_local_to_world_rotation(spine_bone bone, float localRotation);
 SPINE_FLUTTER_EXPORT void spine_bone_rotate_world(spine_bone bone, float degrees);
@@ -549,6 +579,8 @@ SPINE_FLUTTER_EXPORT float spine_bone_get_world_scale_x(spine_bone bone);
 SPINE_FLUTTER_EXPORT float spine_bone_get_world_scale_y(spine_bone bone);
 SPINE_FLUTTER_EXPORT int32_t spine_bone_get_is_active(spine_bone bone);
 SPINE_FLUTTER_EXPORT void spine_bone_set_is_active(spine_bone bone, int32_t isActive);
+SPINE_FLUTTER_EXPORT spine_inherit spine_bone_get_inherit(spine_bone data);
+SPINE_FLUTTER_EXPORT void spine_bone_set_inherit(spine_bone data, spine_inherit inherit);
 
 SPINE_FLUTTER_EXPORT const utf8 *spine_attachment_get_name(spine_attachment attachment);
 SPINE_FLUTTER_EXPORT spine_attachment_type spine_attachment_get_type(spine_attachment attachment);
@@ -655,6 +687,7 @@ SPINE_FLUTTER_EXPORT spine_attachment spine_skin_get_attachment(spine_skin skin,
 SPINE_FLUTTER_EXPORT void spine_skin_remove_attachment(spine_skin skin, int32_t slotIndex, const utf8 *name);
 // OMITTED findNamesForSlot()
 // OMITTED findAttachmentsForSlot()
+// OMITTED getColor()
 SPINE_FLUTTER_EXPORT const utf8 *spine_skin_get_name(spine_skin skin);
 SPINE_FLUTTER_EXPORT void spine_skin_add_skin(spine_skin skin, spine_skin other);
 SPINE_FLUTTER_EXPORT void spine_skin_copy_skin(spine_skin skin, spine_skin other);
@@ -715,6 +748,7 @@ SPINE_FLUTTER_EXPORT float spine_ik_constraint_get_softness(spine_ik_constraint
 SPINE_FLUTTER_EXPORT void spine_ik_constraint_set_softness(spine_ik_constraint constraint, float softness);
 SPINE_FLUTTER_EXPORT int32_t spine_ik_constraint_get_is_active(spine_ik_constraint constraint);
 SPINE_FLUTTER_EXPORT void spine_ik_constraint_set_is_active(spine_ik_constraint constraint, int32_t isActive);
+// OMITTED setToSetupPose()
 
 SPINE_FLUTTER_EXPORT int32_t spine_transform_constraint_data_get_num_bones(spine_transform_constraint_data data);
 SPINE_FLUTTER_EXPORT spine_bone_data *spine_transform_constraint_data_get_bones(spine_transform_constraint_data data);
@@ -770,6 +804,7 @@ SPINE_FLUTTER_EXPORT float spine_transform_constraint_get_mix_shear_y(spine_tran
 SPINE_FLUTTER_EXPORT void spine_transform_constraint_set_mix_shear_y(spine_transform_constraint constraint, float mixShearY);
 SPINE_FLUTTER_EXPORT float spine_transform_constraint_get_is_active(spine_transform_constraint constraint);
 SPINE_FLUTTER_EXPORT void spine_transform_constraint_set_is_active(spine_transform_constraint constraint, int32_t isActive);
+// OMITTED setToSetupPose()
 
 SPINE_FLUTTER_EXPORT int32_t spine_path_constraint_data_get_num_bones(spine_path_constraint_data data);
 SPINE_FLUTTER_EXPORT spine_bone_data *spine_path_constraint_data_get_bones(spine_path_constraint_data data);
@@ -813,6 +848,111 @@ SPINE_FLUTTER_EXPORT float spine_path_constraint_get_mix_y(spine_path_constraint
 SPINE_FLUTTER_EXPORT void spine_path_constraint_set_mix_y(spine_path_constraint constraint, float mixY);
 SPINE_FLUTTER_EXPORT int32_t spine_path_constraint_get_is_active(spine_path_constraint constraint);
 SPINE_FLUTTER_EXPORT void spine_path_constraint_set_is_active(spine_path_constraint constraint, int32_t isActive);
+// OMITTED setToSetupPose()
+
+SPINE_FLUTTER_EXPORT void spine_physics_constraint_data_set_bone(spine_physics_constraint_data data, spine_bone_data bone);
+SPINE_FLUTTER_EXPORT spine_bone_data spine_physics_constraint_data_get_bone(spine_physics_constraint_data data);
+SPINE_FLUTTER_EXPORT void spine_physics_constraint_data_set_x(spine_physics_constraint_data data, float x);
+SPINE_FLUTTER_EXPORT float spine_physics_constraint_data_get_x(spine_physics_constraint_data data);
+SPINE_FLUTTER_EXPORT void spine_physics_constraint_data_set_y(spine_physics_constraint_data data, float y);
+SPINE_FLUTTER_EXPORT float spine_physics_constraint_data_get_y(spine_physics_constraint_data data);
+SPINE_FLUTTER_EXPORT void spine_physics_constraint_data_set_rotate(spine_physics_constraint_data data, float rotate);
+SPINE_FLUTTER_EXPORT float spine_physics_constraint_data_get_rotate(spine_physics_constraint_data data);
+SPINE_FLUTTER_EXPORT void spine_physics_constraint_data_set_scale_x(spine_physics_constraint_data data, float scaleX);
+SPINE_FLUTTER_EXPORT float spine_physics_constraint_data_get_scale_x(spine_physics_constraint_data data);
+SPINE_FLUTTER_EXPORT void spine_physics_constraint_data_set_shear_x(spine_physics_constraint_data data, float shearX);
+SPINE_FLUTTER_EXPORT float spine_physics_constraint_data_get_shear_x(spine_physics_constraint_data data);
+SPINE_FLUTTER_EXPORT void spine_physics_constraint_data_set_limit(spine_physics_constraint_data data, float limit);
+SPINE_FLUTTER_EXPORT float spine_physics_constraint_data_get_limit(spine_physics_constraint_data data);
+SPINE_FLUTTER_EXPORT void spine_physics_constraint_data_set_step(spine_physics_constraint_data data, float step);
+SPINE_FLUTTER_EXPORT float spine_physics_constraint_data_get_step(spine_physics_constraint_data data);
+SPINE_FLUTTER_EXPORT void spine_physics_constraint_data_set_inertia(spine_physics_constraint_data data, float inertia);
+SPINE_FLUTTER_EXPORT float spine_physics_constraint_data_get_inertia(spine_physics_constraint_data data);
+SPINE_FLUTTER_EXPORT void spine_physics_constraint_data_set_strength(spine_physics_constraint_data data, float strength);
+SPINE_FLUTTER_EXPORT float spine_physics_constraint_data_get_strength(spine_physics_constraint_data data);
+SPINE_FLUTTER_EXPORT void spine_physics_constraint_data_set_damping(spine_physics_constraint_data data, float damping);
+SPINE_FLUTTER_EXPORT float spine_physics_constraint_data_get_damping(spine_physics_constraint_data data);
+SPINE_FLUTTER_EXPORT void spine_physics_constraint_data_set_mass_inverse(spine_physics_constraint_data data, float massInverse);
+SPINE_FLUTTER_EXPORT float spine_physics_constraint_data_get_mass_inverse(spine_physics_constraint_data data);
+SPINE_FLUTTER_EXPORT void spine_physics_constraint_data_set_wind(spine_physics_constraint_data data, float wind);
+SPINE_FLUTTER_EXPORT float spine_physics_constraint_data_get_wind(spine_physics_constraint_data data);
+SPINE_FLUTTER_EXPORT void spine_physics_constraint_data_set_gravity(spine_physics_constraint_data data, float gravity);
+SPINE_FLUTTER_EXPORT float spine_physics_constraint_data_get_gravity(spine_physics_constraint_data data);
+SPINE_FLUTTER_EXPORT void spine_physics_constraint_data_set_mix(spine_physics_constraint_data data, float mix);
+SPINE_FLUTTER_EXPORT float spine_physics_constraint_data_get_mix(spine_physics_constraint_data data);
+SPINE_FLUTTER_EXPORT void spine_physics_constraint_data_set_inertia_global(spine_physics_constraint_data data, int32_t inertiaGlobal);
+SPINE_FLUTTER_EXPORT int32_t spine_physics_constraint_data_is_inertia_global(spine_physics_constraint_data data);
+SPINE_FLUTTER_EXPORT void spine_physics_constraint_data_set_strength_global(spine_physics_constraint_data data, int32_t strengthGlobal);
+SPINE_FLUTTER_EXPORT int32_t spine_physics_constraint_data_is_strength_global(spine_physics_constraint_data data);
+SPINE_FLUTTER_EXPORT void spine_physics_constraint_data_set_damping_global(spine_physics_constraint_data data, int32_t dampingGlobal);
+SPINE_FLUTTER_EXPORT int32_t spine_physics_constraint_data_is_damping_global(spine_physics_constraint_data data);
+SPINE_FLUTTER_EXPORT void spine_physics_constraint_data_set_mass_global(spine_physics_constraint_data data, int32_t massGlobal);
+SPINE_FLUTTER_EXPORT int32_t spine_physics_constraint_data_is_mass_global(spine_physics_constraint_data data);
+SPINE_FLUTTER_EXPORT void spine_physics_constraint_data_set_wind_global(spine_physics_constraint_data data, int32_t windGlobal);
+SPINE_FLUTTER_EXPORT int32_t spine_physics_constraint_data_is_wind_global(spine_physics_constraint_data data);
+SPINE_FLUTTER_EXPORT void spine_physics_constraint_data_set_gravity_global(spine_physics_constraint_data data, int32_t gravityGlobal);
+SPINE_FLUTTER_EXPORT int32_t spine_physics_constraint_data_is_gravity_global(spine_physics_constraint_data data);
+SPINE_FLUTTER_EXPORT void spine_physics_constraint_data_set_mix_global(spine_physics_constraint_data data, int32_t mixGlobal);
+SPINE_FLUTTER_EXPORT int32_t spine_physics_constraint_data_is_mix_global(spine_physics_constraint_data data);
+
+SPINE_FLUTTER_EXPORT void spine_physics_constraint_set_bone(spine_physics_constraint constraint, spine_bone bone);
+SPINE_FLUTTER_EXPORT spine_bone spine_physics_constraint_get_bone(spine_physics_constraint constraint);
+SPINE_FLUTTER_EXPORT void spine_physics_constraint_set_inertia(spine_physics_constraint constraint, float value);
+SPINE_FLUTTER_EXPORT float spine_physics_constraint_get_inertia(spine_physics_constraint constraint);
+SPINE_FLUTTER_EXPORT void spine_physics_constraint_set_strength(spine_physics_constraint constraint, float value);
+SPINE_FLUTTER_EXPORT float spine_physics_constraint_get_strength(spine_physics_constraint constraint);
+SPINE_FLUTTER_EXPORT void spine_physics_constraint_set_damping(spine_physics_constraint constraint, float value);
+SPINE_FLUTTER_EXPORT float spine_physics_constraint_get_damping(spine_physics_constraint constraint);
+SPINE_FLUTTER_EXPORT void spine_physics_constraint_set_mass_inverse(spine_physics_constraint constraint, float value);
+SPINE_FLUTTER_EXPORT float spine_physics_constraint_get_mass_inverse(spine_physics_constraint constraint);
+SPINE_FLUTTER_EXPORT void spine_physics_constraint_set_wind(spine_physics_constraint constraint, float value);
+SPINE_FLUTTER_EXPORT float spine_physics_constraint_get_wind(spine_physics_constraint constraint);
+SPINE_FLUTTER_EXPORT void spine_physics_constraint_set_gravity(spine_physics_constraint constraint, float value);
+SPINE_FLUTTER_EXPORT float spine_physics_constraint_get_gravity(spine_physics_constraint constraint);
+SPINE_FLUTTER_EXPORT void spine_physics_constraint_set_mix(spine_physics_constraint constraint, float value);
+SPINE_FLUTTER_EXPORT float spine_physics_constraint_get_mix(spine_physics_constraint constraint);
+SPINE_FLUTTER_EXPORT void spine_physics_constraint_set_reset(spine_physics_constraint constraint, int32_t value);
+SPINE_FLUTTER_EXPORT int32_t spine_physics_constraint_get_reset(spine_physics_constraint constraint);
+SPINE_FLUTTER_EXPORT void spine_physics_constraint_set_ux(spine_physics_constraint constraint, float value);
+SPINE_FLUTTER_EXPORT float spine_physics_constraint_get_ux(spine_physics_constraint constraint);
+SPINE_FLUTTER_EXPORT void spine_physics_constraint_set_uy(spine_physics_constraint constraint, float value);
+SPINE_FLUTTER_EXPORT float spine_physics_constraint_get_uy(spine_physics_constraint constraint);
+SPINE_FLUTTER_EXPORT void spine_physics_constraint_set_cx(spine_physics_constraint constraint, float value);
+SPINE_FLUTTER_EXPORT float spine_physics_constraint_get_cx(spine_physics_constraint constraint);
+SPINE_FLUTTER_EXPORT void spine_physics_constraint_set_cy(spine_physics_constraint constraint, float value);
+SPINE_FLUTTER_EXPORT float spine_physics_constraint_get_cy(spine_physics_constraint constraint);
+SPINE_FLUTTER_EXPORT void spine_physics_constraint_set_tx(spine_physics_constraint constraint, float value);
+SPINE_FLUTTER_EXPORT float spine_physics_constraint_get_tx(spine_physics_constraint constraint);
+SPINE_FLUTTER_EXPORT void spine_physics_constraint_set_ty(spine_physics_constraint constraint, float value);
+SPINE_FLUTTER_EXPORT float spine_physics_constraint_get_ty(spine_physics_constraint constraint);
+SPINE_FLUTTER_EXPORT void spine_physics_constraint_set_x_offset(spine_physics_constraint constraint, float value);
+SPINE_FLUTTER_EXPORT float spine_physics_constraint_get_x_offset(spine_physics_constraint constraint);
+SPINE_FLUTTER_EXPORT void spine_physics_constraint_set_x_velocity(spine_physics_constraint constraint, float value);
+SPINE_FLUTTER_EXPORT float spine_physics_constraint_get_x_velocity(spine_physics_constraint constraint);
+SPINE_FLUTTER_EXPORT void spine_physics_constraint_set_y_offset(spine_physics_constraint constraint, float value);
+SPINE_FLUTTER_EXPORT float spine_physics_constraint_get_y_offset(spine_physics_constraint constraint);
+SPINE_FLUTTER_EXPORT void spine_physics_constraint_set_y_velocity(spine_physics_constraint constraint, float value);
+SPINE_FLUTTER_EXPORT float spine_physics_constraint_get_y_velocity(spine_physics_constraint constraint);
+SPINE_FLUTTER_EXPORT void spine_physics_constraint_set_rotate_offset(spine_physics_constraint constraint, float value);
+SPINE_FLUTTER_EXPORT float spine_physics_constraint_get_rotate_offset(spine_physics_constraint constraint);
+SPINE_FLUTTER_EXPORT void spine_physics_constraint_set_rotate_velocity(spine_physics_constraint constraint, float value);
+SPINE_FLUTTER_EXPORT float spine_physics_constraint_get_rotate_velocity(spine_physics_constraint constraint);
+SPINE_FLUTTER_EXPORT void spine_physics_constraint_set_scale_offset(spine_physics_constraint constraint, float value);
+SPINE_FLUTTER_EXPORT float spine_physics_constraint_get_scale_offset(spine_physics_constraint constraint);
+SPINE_FLUTTER_EXPORT void spine_physics_constraint_set_scale_velocity(spine_physics_constraint constraint, float value);
+SPINE_FLUTTER_EXPORT float spine_physics_constraint_get_scale_velocity(spine_physics_constraint constraint);
+SPINE_FLUTTER_EXPORT void spine_physics_constraint_set_active(spine_physics_constraint constraint, int32_t value);
+SPINE_FLUTTER_EXPORT int32_t spine_physics_constraint_is_active(spine_physics_constraint constraint);
+SPINE_FLUTTER_EXPORT void spine_physics_constraint_set_remaining(spine_physics_constraint constraint, float value);
+SPINE_FLUTTER_EXPORT float spine_physics_constraint_get_remaining(spine_physics_constraint constraint);
+SPINE_FLUTTER_EXPORT void spine_physics_constraint_set_last_time(spine_physics_constraint constraint, float value);
+SPINE_FLUTTER_EXPORT float spine_physics_constraint_get_last_time(spine_physics_constraint constraint);
+SPINE_FLUTTER_EXPORT void spine_physics_constraint_reset(spine_physics_constraint constraint);
+// Omitted setToSetupPose()
+SPINE_FLUTTER_EXPORT void spine_physics_constraint_update(spine_physics_constraint data, spine_physics physics);
+SPINE_FLUTTER_EXPORT void spine_physics_constraint_translate(spine_physics_constraint data, float x, float y);
+SPINE_FLUTTER_EXPORT void spine_physics_constraint_rotate(spine_physics_constraint data, float x, float y, float degrees);
+
 
 // OMITTED copy()
 SPINE_FLUTTER_EXPORT void spine_sequence_apply(spine_sequence sequence, spine_slot slot, spine_attachment attachment);