mirror of
https://github.com/EsotericSoftware/spine-runtimes.git
synced 2025-12-20 01:06:00 +08:00
[flutter] Ported 4.2 changes in native code. PhysicsConstraint(Data) missing on Flutter side.
This commit is contained in:
Mario Zechner
parent
eecca2bdfa
commit
3b4e6eff65
@ -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;
|
||||
}
|
||||
|
||||
@ -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,
|
||||
|
||||
@ -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"),
|
||||
),
|
||||
|
||||
@ -169,7 +169,7 @@ packages:
|
||||
path: ".."
|
||||
relative: true
|
||||
source: path
|
||||
version: "4.2.18"
|
||||
version: "4.1.14"
|
||||
string_scanner:
|
||||
dependency: transitive
|
||||
description:
|
||||
|
||||
@ -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
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -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->getAttachmentThreshold();
|
||||
return _entry->getAlphaAttachmentThreshold();
|
||||
}
|
||||
|
||||
void spine_track_entry_set_attachment_threshold(spine_track_entry entry, float attachmentThreshold) {
|
||||
void spine_track_entry_set_alpha_attachment_threshold(spine_track_entry entry, float attachmentThreshold) {
|
||||
if (entry == nullptr) return;
|
||||
TrackEntry *_entry = (TrackEntry *) entry;
|
||||
_entry->setAttachmentThreshold(attachmentThreshold);
|
||||
_entry->setAlphaAttachmentThreshold(attachmentThreshold);
|
||||
}
|
||||
|
||||
float spine_track_entry_get_draw_order_threshold(spine_track_entry entry) {
|
||||
float spine_track_entry_get_mix_attachment_threshold(spine_track_entry entry) {
|
||||
if (entry == nullptr) return 0;
|
||||
TrackEntry *_entry = (TrackEntry *) entry;
|
||||
return _entry->getDrawOrderThreshold();
|
||||
return _entry->getMixAttachmentThreshold();
|
||||
}
|
||||
|
||||
void spine_track_entry_set_draw_order_threshold(spine_track_entry entry, float drawOrderThreshold) {
|
||||
void spine_track_entry_set_mix_attachment_threshold(spine_track_entry entry, float attachmentThreshold) {
|
||||
if (entry == nullptr) return;
|
||||
TrackEntry *_entry = (TrackEntry *) entry;
|
||||
_entry->setDrawOrderThreshold(drawOrderThreshold);
|
||||
_entry->setMixAttachmentThreshold(attachmentThreshold);
|
||||
}
|
||||
|
||||
float spine_track_entry_get_mix_draw_order_threshold(spine_track_entry entry) {
|
||||
if (entry == nullptr) return 0;
|
||||
TrackEntry *_entry = (TrackEntry *) entry;
|
||||
return _entry->getMixDrawOrderThreshold();
|
||||
}
|
||||
|
||||
void spine_track_entry_set_mix_draw_order_threshold(spine_track_entry entry, float drawOrderThreshold) {
|
||||
if (entry == nullptr) return;
|
||||
TrackEntry *_entry = (TrackEntry *) entry;
|
||||
_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;
|
||||
|
||||
@ -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);
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user