UnityMirror/spine-runtimes
1
0
Fork 0
mirror of https://github.com/EsotericSoftware/spine-runtimes.git synced 2026-03-26 22:49:01 +08:00
Code Issues Packages Projects Releases Wiki Activity

[c] Regenerate C bindings for AnimationState/timeline API changes and Skin placeholder rename

Browse Source
This commit is contained in:
Mario Zechner 2026-03-24 21:09:56 +01:00
parent 7b0bf128ff
commit 3322e6c876
126 changed files with 1653 additions and 725 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
spine-c/src/extensions.cpp
View File

@ -497,7 +497,7 @@ spine_skin_entries spine_skin_get_entries(spine_skin skin) {
while (entries.hasNext()) {
Skin::AttachmentMap::Entry &entry = entries.next();
result->entries[index].slotIndex = (int32_t) entry._slotIndex;
result->entries[index].name = SpineExtension::strdup(entry._name.buffer(), __FILE__, __LINE__);
result->entries[index].name = SpineExtension::strdup(entry._placeholderName.buffer(), __FILE__, __LINE__);
result->entries[index].attachment = (spine_attachment) entry._attachment;
index++;
}

35
spine-c/src/generated/alpha_timeline.cpp
View File

@ -17,9 +17,9 @@ spine_rtti spine_alpha_timeline_get_rtti(spine_alpha_timeline self) {
}
void spine_alpha_timeline_apply(spine_alpha_timeline self, spine_skeleton skeleton, float lastTime, float time, /*@null*/ spine_array_event events,
float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
float alpha, bool fromSetup, bool add, bool out, bool appliedPose) {
AlphaTimeline *_self = (AlphaTimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, fromSetup, add, out, appliedPose);
}
int spine_alpha_timeline_get_slot_index(spine_alpha_timeline self) {
@ -42,27 +42,28 @@ float spine_alpha_timeline_get_curve_value(spine_alpha_timeline self, float time
return _self->getCurveValue(time);
}
float spine_alpha_timeline_get_relative_value(spine_alpha_timeline self, float time, float alpha, spine_mix_blend blend, float current, float setup) {
float spine_alpha_timeline_get_relative_value(spine_alpha_timeline self, float time, float alpha, bool fromSetup, bool add, float current,
float setup) {
AlphaTimeline *_self = (AlphaTimeline *) self;
return _self->getRelativeValue(time, alpha, (MixBlend) blend, current, setup);
return _self->getRelativeValue(time, alpha, fromSetup, add, current, setup);
}
float spine_alpha_timeline_get_absolute_value_1(spine_alpha_timeline self, float time, float alpha, spine_mix_blend blend, float current,
float spine_alpha_timeline_get_absolute_value_1(spine_alpha_timeline self, float time, float alpha, bool fromSetup, bool add, float current,
float setup) {
AlphaTimeline *_self = (AlphaTimeline *) self;
return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup);
return _self->getAbsoluteValue(time, alpha, fromSetup, add, current, setup);
}
float spine_alpha_timeline_get_absolute_value_2(spine_alpha_timeline self, float time, float alpha, spine_mix_blend blend, float current, float setup,
float value) {
float spine_alpha_timeline_get_absolute_value_2(spine_alpha_timeline self, float time, float alpha, bool fromSetup, bool add, float current,
float setup, float value) {
AlphaTimeline *_self = (AlphaTimeline *) self;
return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup, value);
return _self->getAbsoluteValue(time, alpha, fromSetup, add, current, setup, value);
}
float spine_alpha_timeline_get_scale_value(spine_alpha_timeline self, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction,
float current, float setup) {
float spine_alpha_timeline_get_scale_value(spine_alpha_timeline self, float time, float alpha, bool fromSetup, bool add, bool out, float current,
float setup) {
AlphaTimeline *_self = (AlphaTimeline *) self;
return _self->getScaleValue(time, alpha, (MixBlend) blend, (MixDirection) direction, current, setup);
return _self->getScaleValue(time, alpha, fromSetup, add, out, current, setup);
}
void spine_alpha_timeline_set_linear(spine_alpha_timeline self, size_t frame) {
@ -91,6 +92,16 @@ spine_array_float spine_alpha_timeline_get_curves(spine_alpha_timeline self) {
return (spine_array_float) &_self->getCurves();
}
bool spine_alpha_timeline_get_additive(spine_alpha_timeline self) {
AlphaTimeline *_self = (AlphaTimeline *) self;
return _self->getAdditive();
}
bool spine_alpha_timeline_get_instant(spine_alpha_timeline self) {
AlphaTimeline *_self = (AlphaTimeline *) self;
return _self->getInstant();
}
size_t spine_alpha_timeline_get_frame_entries(spine_alpha_timeline self) {
AlphaTimeline *_self = (AlphaTimeline *) self;
return _self->getFrameEntries();

26
spine-c/src/generated/alpha_timeline.h
View File

@ -15,8 +15,7 @@ SPINE_C_API void spine_alpha_timeline_dispose(spine_alpha_timeline self);
SPINE_C_API spine_rtti spine_alpha_timeline_get_rtti(spine_alpha_timeline self);
SPINE_C_API void spine_alpha_timeline_apply(spine_alpha_timeline self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ spine_array_event events, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose);
/*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add, bool out, bool appliedPose);
SPINE_C_API int spine_alpha_timeline_get_slot_index(spine_alpha_timeline self);
SPINE_C_API void spine_alpha_timeline_set_slot_index(spine_alpha_timeline self, int inValue);
/**
@ -30,20 +29,29 @@ SPINE_C_API void spine_alpha_timeline_set_frame(spine_alpha_timeline self, size_
* Returns the interpolated value for the specified time.
*/
SPINE_C_API float spine_alpha_timeline_get_curve_value(spine_alpha_timeline self, float time);
SPINE_C_API float spine_alpha_timeline_get_relative_value(spine_alpha_timeline self, float time, float alpha, spine_mix_blend blend, float current,
SPINE_C_API float spine_alpha_timeline_get_relative_value(spine_alpha_timeline self, float time, float alpha, bool fromSetup, bool add, float current,
float setup);
SPINE_C_API float spine_alpha_timeline_get_absolute_value_1(spine_alpha_timeline self, float time, float alpha, spine_mix_blend blend, float current,
float setup);
SPINE_C_API float spine_alpha_timeline_get_absolute_value_2(spine_alpha_timeline self, float time, float alpha, spine_mix_blend blend, float current,
float setup, float value);
SPINE_C_API float spine_alpha_timeline_get_scale_value(spine_alpha_timeline self, float time, float alpha, spine_mix_blend blend,
spine_mix_direction direction, float current, float setup);
SPINE_C_API float spine_alpha_timeline_get_absolute_value_1(spine_alpha_timeline self, float time, float alpha, bool fromSetup, bool add,
float current, float setup);
SPINE_C_API float spine_alpha_timeline_get_absolute_value_2(spine_alpha_timeline self, float time, float alpha, bool fromSetup, bool add,
float current, float setup, float value);
SPINE_C_API float spine_alpha_timeline_get_scale_value(spine_alpha_timeline self, float time, float alpha, bool fromSetup, bool add, bool out,
float current, float setup);
SPINE_C_API void spine_alpha_timeline_set_linear(spine_alpha_timeline self, size_t frame);
SPINE_C_API void spine_alpha_timeline_set_stepped(spine_alpha_timeline self, size_t frame);
SPINE_C_API void spine_alpha_timeline_set_bezier(spine_alpha_timeline self, size_t bezier, size_t frame, float value, float time1, float value1,
float cx1, float cy1, float cx2, float cy2, float time2, float value2);
SPINE_C_API float spine_alpha_timeline_get_bezier_value(spine_alpha_timeline self, float time, size_t frame, size_t valueOffset, size_t i);
SPINE_C_API spine_array_float spine_alpha_timeline_get_curves(spine_alpha_timeline self);
/**
* True if this timeline supports additive blending.
*/
SPINE_C_API bool spine_alpha_timeline_get_additive(spine_alpha_timeline self);
/**
* True if this timeline sets values instantaneously and does not support
* interpolation between frames.
*/
SPINE_C_API bool spine_alpha_timeline_get_instant(spine_alpha_timeline self);
SPINE_C_API size_t spine_alpha_timeline_get_frame_entries(spine_alpha_timeline self);
SPINE_C_API size_t spine_alpha_timeline_get_frame_count(spine_alpha_timeline self);
SPINE_C_API spine_array_float spine_alpha_timeline_get_frames(spine_alpha_timeline self);

5
spine-c/src/generated/animation.cpp
View File

@ -37,10 +37,9 @@ void spine_animation_set_duration(spine_animation self, float inValue) {
}
void spine_animation_apply(spine_animation self, spine_skeleton skeleton, float lastTime, float time, bool loop, /*@null*/ spine_array_event events,
float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
float alpha, bool fromSetup, bool add, bool out, bool appliedPose) {
Animation *_self = (Animation *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, loop, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction,
appliedPose);
_self->apply(*((Skeleton *) skeleton), lastTime, time, loop, (Array<Event *> *) events, alpha, fromSetup, add, out, appliedPose);
}
const char *spine_animation_get_name(spine_animation self) {

21
spine-c/src/generated/animation.h
View File

@ -36,18 +36,19 @@ SPINE_C_API void spine_animation_set_duration(spine_animation self, float inValu
*
* See Timeline::apply().
*
* @param skeleton The skeleton the animation is being applied to. This provides access to the bones, slots, and other skeleton components the timelines may change.
* @param lastTime The last time in seconds this animation was applied. Some timelines trigger only at specific times rather than every frame. Pass -1 the first time an animation is applied to ensure frame 0 is triggered.
* @param time The time in seconds the skeleton is being posed for. Most timelines find the frame before and the frame after this time and interpolate between the frame values. If beyond the getDuration() and loop is true then the animation will repeat, else the last frame will be applied.
* @param loop If true, the animation repeats after the getDuration().
* @param events If any events are fired, they are added to this list. Can be null to ignore fired events or if no timelines fire events.
* @param alpha 0 applies the current or setup values (depending on blend). 1 applies the timeline values. Between 0 and 1 applies values between the current or setup values and the timeline values. By adjusting alpha over time, an animation can be mixed in or out. alpha can also be useful to apply animations on top of each other (layering).
* @param blend Controls how mixing is applied when alpha < 1.
* @param direction Indicates whether the timelines are mixing in or out. Used by timelines which perform instant transitions, such as DrawOrderTimeline or AttachmentTimeline.
* @param skeleton The skeleton the animation is applied to. This provides access to the bones, slots, and other skeleton components the timelines may change.
* @param lastTime The last time in seconds this animation was applied. Some timelines trigger only at discrete times, in which case all keys are triggered between lastTime (exclusive) and time (inclusive). Pass -1 the first time an animation is applied to ensure frame 0 is triggered.
* @param time The time in seconds the skeleton is being posed for. Timelines find the frame before and after this time and interpolate between the frame values.
* @param loop True if time beyond the getDuration() repeats the animation, else the last frame is used.
* @param events If any events are fired, they are added to this list. Can be NULL to ignore fired events or if no timelines fire events.
* @param alpha 0 applies setup or current values (depending on fromSetup), 1 uses timeline values, and intermediate values interpolate between them. Adjusting alpha over time can mix an animation in or out.
* @param fromSetup If true, alpha transitions between setup and timeline values, setup values are used before the first frame (current values are not used). If false, alpha transitions between current and timeline values, no change is made before the first frame.
* @param add If true, for timelines that support it, their values are added to the setup or current values (depending on fromSetup).
* @param out True when the animation is mixing out, else it is mixing in. Used by timelines that perform instant transitions.
* @param appliedPose True to modify the applied pose, else the pose is modified.
*/
SPINE_C_API void spine_animation_apply(spine_animation self, spine_skeleton skeleton, float lastTime, float time, bool loop,
/*@null*/ spine_array_event events, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose);
/*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add, bool out, bool appliedPose);
/**
* The animation's name, which is unique across all animations in the skeleton.
*/

5
spine-c/src/generated/animation_state_data.h
View File

@ -33,8 +33,9 @@ SPINE_C_API void spine_animation_state_data_set_mix_1(spine_animation_state_data
*/
SPINE_C_API void spine_animation_state_data_set_mix_2(spine_animation_state_data self, spine_animation from, spine_animation to, float duration);
/**
* The mix duration to use when changing from the specified animation to the
* other, or the DefaultMix if no mix duration has been set.
* Returns the mix duration to use when changing from the specified animation to
* the other on the same track, or the DefaultMix if no mix duration has been
* set.
*/
SPINE_C_API float spine_animation_state_data_get_mix(spine_animation_state_data self, spine_animation from, spine_animation to);
/**

15
spine-c/src/generated/attachment_timeline.cpp
View File

@ -17,10 +17,9 @@ spine_rtti spine_attachment_timeline_get_rtti(spine_attachment_timeline self) {
}
void spine_attachment_timeline_apply(spine_attachment_timeline self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ spine_array_event events, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose) {
/*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add, bool out, bool appliedPose) {
AttachmentTimeline *_self = (AttachmentTimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, fromSetup, add, out, appliedPose);
}
void spine_attachment_timeline_set_frame(spine_attachment_timeline self, int frame, float time, const char *attachmentName) {
@ -38,6 +37,16 @@ void spine_attachment_timeline_set_slot_index(spine_attachment_timeline self, in
_self->setSlotIndex(inValue);
}
bool spine_attachment_timeline_get_additive(spine_attachment_timeline self) {
AttachmentTimeline *_self = (AttachmentTimeline *) self;
return _self->getAdditive();
}
bool spine_attachment_timeline_get_instant(spine_attachment_timeline self) {
AttachmentTimeline *_self = (AttachmentTimeline *) self;
return _self->getInstant();
}
size_t spine_attachment_timeline_get_frame_entries(spine_attachment_timeline self) {
AttachmentTimeline *_self = (AttachmentTimeline *) self;
return _self->getFrameEntries();

13
spine-c/src/generated/attachment_timeline.h
View File

@ -15,8 +15,8 @@ SPINE_C_API void spine_attachment_timeline_dispose(spine_attachment_timeline sel
SPINE_C_API spine_rtti spine_attachment_timeline_get_rtti(spine_attachment_timeline self);
SPINE_C_API void spine_attachment_timeline_apply(spine_attachment_timeline self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ spine_array_event events, float alpha, spine_mix_blend blend,
spine_mix_direction direction, bool appliedPose);
/*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add, bool out,
bool appliedPose);
/**
* Sets the time and attachment name for the specified frame.
*
@ -26,6 +26,15 @@ SPINE_C_API void spine_attachment_timeline_apply(spine_attachment_timeline self,
SPINE_C_API void spine_attachment_timeline_set_frame(spine_attachment_timeline self, int frame, float time, const char *attachmentName);
SPINE_C_API int spine_attachment_timeline_get_slot_index(spine_attachment_timeline self);
SPINE_C_API void spine_attachment_timeline_set_slot_index(spine_attachment_timeline self, int inValue);
/**
* True if this timeline supports additive blending.
*/
SPINE_C_API bool spine_attachment_timeline_get_additive(spine_attachment_timeline self);
/**
* True if this timeline sets values instantaneously and does not support
* interpolation between frames.
*/
SPINE_C_API bool spine_attachment_timeline_get_instant(spine_attachment_timeline self);
SPINE_C_API size_t spine_attachment_timeline_get_frame_entries(spine_attachment_timeline self);
SPINE_C_API size_t spine_attachment_timeline_get_frame_count(spine_attachment_timeline self);
SPINE_C_API spine_array_float spine_attachment_timeline_get_frames(spine_attachment_timeline self);

7
spine-c/src/generated/bone.h
View File

@ -42,6 +42,13 @@ SPINE_C_API spine_bone_pose spine_bone_get_applied_pose(spine_bone self);
SPINE_C_API void spine_bone_reset_constrained(spine_bone self);
SPINE_C_API void spine_bone_constrained(spine_bone self);
SPINE_C_API bool spine_bone_is_pose_equal_to_applied(spine_bone self);
/**
* Returns false when this won't be updated by
* Skeleton::updateWorldTransform(Physics) because a skin is required and the
* active skin does not contain this item. See Skin::getBones(),
* Skin::getConstraints(), PosedData::getSkinRequired(), and
* Skeleton::updateCache().
*/
SPINE_C_API bool spine_bone_is_active(spine_bone self);
SPINE_C_API void spine_bone_set_active(spine_bone self, bool active);
SPINE_C_API spine_rtti spine_bone_rtti(void);

12
spine-c/src/generated/bone_data.h
View File

@ -14,25 +14,25 @@ SPINE_C_API spine_bone_data spine_bone_data_create(int index, const char *name,
SPINE_C_API void spine_bone_data_dispose(spine_bone_data self);
/**
* The index of the bone in Skeleton.Bones
* The Skeleton::getBones() index.
*/
SPINE_C_API int spine_bone_data_get_index(spine_bone_data self);
/**
* May be NULL.
* The parent bone, or NULL if this bone is the root.
*/
SPINE_C_API /*@null*/ spine_bone_data spine_bone_data_get_parent(spine_bone_data self);
SPINE_C_API float spine_bone_data_get_length(spine_bone_data self);
SPINE_C_API void spine_bone_data_set_length(spine_bone_data self, float inValue);
SPINE_C_API spine_color spine_bone_data_get_color(spine_bone_data self);
/**
* The bone icon name as it was in Spine, or empty if nonessential data was not
* exported.
*/
SPINE_C_API const char *spine_bone_data_get_icon(spine_bone_data self);
SPINE_C_API void spine_bone_data_set_icon(spine_bone_data self, const char *icon);
SPINE_C_API bool spine_bone_data_get_visible(spine_bone_data self);
SPINE_C_API void spine_bone_data_set_visible(spine_bone_data self, bool inValue);
SPINE_C_API spine_bone_local spine_bone_data_get_setup_pose(spine_bone_data self);
/**
* The constraint's name, which is unique across all constraints in the skeleton
* of the same type.
*/
SPINE_C_API const char *spine_bone_data_get_name(spine_bone_data self);
/**
* When true, Skeleton::updateWorldTransform(Physics) only updates this

34
spine-c/src/generated/bone_pose.h
View File

@ -19,8 +19,8 @@ SPINE_C_API spine_rtti spine_bone_pose_get_rtti(spine_bone_pose self);
*/
SPINE_C_API void spine_bone_pose_update(spine_bone_pose self, spine_skeleton skeleton, spine_physics physics);
/**
* Computes the world transform using the parent bone's applied pose and this
* pose. Child bones are not updated.
* Computes the world transform using the parent bone's world transform and this
* applied local pose. Child bones are not updated.
*
* See World transforms in the Spine Runtimes Guide.
*/
@ -28,11 +28,6 @@ SPINE_C_API void spine_bone_pose_update_world_transform(spine_bone_pose self, sp
/**
* Computes the local transform values from the world transform.
*
* If the world transform is modified (by a constraint, rotateWorld(), etc) then
* this method should be called so the local transform matches the world
* transform. The local transform may be needed by other code (eg to apply
* another constraint).
*
* Some information is ambiguous in the world transform, such as -1,-1 scale
* versus 180 rotation. The local transform after calling this method is
* equivalent to the local transform used to compute the world transform, but
@ -40,44 +35,42 @@ SPINE_C_API void spine_bone_pose_update_world_transform(spine_bone_pose self, sp
*/
SPINE_C_API void spine_bone_pose_update_local_transform(spine_bone_pose self, spine_skeleton skeleton);
/**
* If the world transform has been modified and the local transform no longer
* matches, updateLocalTransform() is called.
* If the world transform has been modified by constraints and the local
* transform no longer matches, updateLocalTransform() is called. Call this
* after Skeleton::updateWorldTransform(Physics) before using the applied local
* transform.
*/
SPINE_C_API void spine_bone_pose_validate_local_transform(spine_bone_pose self, spine_skeleton skeleton);
SPINE_C_API void spine_bone_pose_modify_local(spine_bone_pose self, spine_skeleton skeleton);
SPINE_C_API void spine_bone_pose_modify_world(spine_bone_pose self, int update);
SPINE_C_API void spine_bone_pose_reset_world(spine_bone_pose self, int update);
/**
* Part of the world transform matrix for the X axis. If changed,
* updateLocalTransform() should be called.
* Part of the world transform matrix for the X axis.
*/
SPINE_C_API float spine_bone_pose_get_a(spine_bone_pose self);
SPINE_C_API void spine_bone_pose_set_a(spine_bone_pose self, float a);
/**
* Part of the world transform matrix for the Y axis. If changed,
* updateLocalTransform() should be called.
* Part of the world transform matrix for the Y axis.
*/
SPINE_C_API float spine_bone_pose_get_b(spine_bone_pose self);
SPINE_C_API void spine_bone_pose_set_b(spine_bone_pose self, float b);
/**
* Part of the world transform matrix for the X axis. If changed,
* updateLocalTransform() should be called.
* Part of the world transform matrix for the X axis.
*/
SPINE_C_API float spine_bone_pose_get_c(spine_bone_pose self);
SPINE_C_API void spine_bone_pose_set_c(spine_bone_pose self, float c);
/**
* Part of the world transform matrix for the Y axis. If changed,
* updateLocalTransform() should be called.
* Part of the world transform matrix for the Y axis.
*/
SPINE_C_API float spine_bone_pose_get_d(spine_bone_pose self);
SPINE_C_API void spine_bone_pose_set_d(spine_bone_pose self, float d);
/**
* The world X position. If changed, updateLocalTransform() should be called.
* The world X position.
*/
SPINE_C_API float spine_bone_pose_get_world_x(spine_bone_pose self);
SPINE_C_API void spine_bone_pose_set_world_x(spine_bone_pose self, float worldX);
/**
* The world Y position. If changed, updateLocalTransform() should be called.
* The world Y position.
*/
SPINE_C_API float spine_bone_pose_get_world_y(spine_bone_pose self);
SPINE_C_API void spine_bone_pose_set_world_y(spine_bone_pose self, float worldY);
@ -126,9 +119,6 @@ SPINE_C_API float spine_bone_pose_world_to_local_rotation(spine_bone_pose self,
SPINE_C_API float spine_bone_pose_local_to_world_rotation(spine_bone_pose self, float localRotation);
/**
* Rotates the world transform the specified amount.
*
* After changes are made to the world transform, updateLocalTransform() should
* be called on this bone and any child bones, recursively.
*/
SPINE_C_API void spine_bone_pose_rotate_world(spine_bone_pose self, float degrees);
SPINE_C_API void spine_bone_pose_set(spine_bone_pose self, spine_bone_local pose);

35
spine-c/src/generated/bone_timeline1.cpp
View File

@ -13,9 +13,9 @@ spine_rtti spine_bone_timeline1_get_rtti(spine_bone_timeline1 self) {
}
void spine_bone_timeline1_apply(spine_bone_timeline1 self, spine_skeleton skeleton, float lastTime, float time, /*@null*/ spine_array_event events,
float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
float alpha, bool fromSetup, bool add, bool out, bool appliedPose) {
BoneTimeline1 *_self = (BoneTimeline1 *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, fromSetup, add, out, appliedPose);
}
int spine_bone_timeline1_get_bone_index(spine_bone_timeline1 self) {
@ -38,27 +38,28 @@ float spine_bone_timeline1_get_curve_value(spine_bone_timeline1 self, float time
return _self->getCurveValue(time);
}
float spine_bone_timeline1_get_relative_value(spine_bone_timeline1 self, float time, float alpha, spine_mix_blend blend, float current, float setup) {
float spine_bone_timeline1_get_relative_value(spine_bone_timeline1 self, float time, float alpha, bool fromSetup, bool add, float current,
float setup) {
BoneTimeline1 *_self = (BoneTimeline1 *) self;
return _self->getRelativeValue(time, alpha, (MixBlend) blend, current, setup);
return _self->getRelativeValue(time, alpha, fromSetup, add, current, setup);
}
float spine_bone_timeline1_get_absolute_value_1(spine_bone_timeline1 self, float time, float alpha, spine_mix_blend blend, float current,
float spine_bone_timeline1_get_absolute_value_1(spine_bone_timeline1 self, float time, float alpha, bool fromSetup, bool add, float current,
float setup) {
BoneTimeline1 *_self = (BoneTimeline1 *) self;
return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup);
return _self->getAbsoluteValue(time, alpha, fromSetup, add, current, setup);
}
float spine_bone_timeline1_get_absolute_value_2(spine_bone_timeline1 self, float time, float alpha, spine_mix_blend blend, float current, float setup,
float value) {
float spine_bone_timeline1_get_absolute_value_2(spine_bone_timeline1 self, float time, float alpha, bool fromSetup, bool add, float current,
float setup, float value) {
BoneTimeline1 *_self = (BoneTimeline1 *) self;
return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup, value);
return _self->getAbsoluteValue(time, alpha, fromSetup, add, current, setup, value);
}
float spine_bone_timeline1_get_scale_value(spine_bone_timeline1 self, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction,
float current, float setup) {
float spine_bone_timeline1_get_scale_value(spine_bone_timeline1 self, float time, float alpha, bool fromSetup, bool add, bool out, float current,
float setup) {
BoneTimeline1 *_self = (BoneTimeline1 *) self;
return _self->getScaleValue(time, alpha, (MixBlend) blend, (MixDirection) direction, current, setup);
return _self->getScaleValue(time, alpha, fromSetup, add, out, current, setup);
}
void spine_bone_timeline1_set_linear(spine_bone_timeline1 self, size_t frame) {
@ -87,6 +88,16 @@ spine_array_float spine_bone_timeline1_get_curves(spine_bone_timeline1 self) {
return (spine_array_float) &_self->getCurves();
}
bool spine_bone_timeline1_get_additive(spine_bone_timeline1 self) {
BoneTimeline1 *_self = (BoneTimeline1 *) self;
return _self->getAdditive();
}
bool spine_bone_timeline1_get_instant(spine_bone_timeline1 self) {
BoneTimeline1 *_self = (BoneTimeline1 *) self;
return _self->getInstant();
}
size_t spine_bone_timeline1_get_frame_entries(spine_bone_timeline1 self) {
BoneTimeline1 *_self = (BoneTimeline1 *) self;
return _self->getFrameEntries();

26
spine-c/src/generated/bone_timeline1.h
View File

@ -13,8 +13,7 @@ SPINE_C_API void spine_bone_timeline1_dispose(spine_bone_timeline1 self);
SPINE_C_API spine_rtti spine_bone_timeline1_get_rtti(spine_bone_timeline1 self);
SPINE_C_API void spine_bone_timeline1_apply(spine_bone_timeline1 self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ spine_array_event events, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose);
/*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add, bool out, bool appliedPose);
SPINE_C_API int spine_bone_timeline1_get_bone_index(spine_bone_timeline1 self);
SPINE_C_API void spine_bone_timeline1_set_bone_index(spine_bone_timeline1 self, int inValue);
/**
@ -28,20 +27,29 @@ SPINE_C_API void spine_bone_timeline1_set_frame(spine_bone_timeline1 self, size_
* Returns the interpolated value for the specified time.
*/
SPINE_C_API float spine_bone_timeline1_get_curve_value(spine_bone_timeline1 self, float time);
SPINE_C_API float spine_bone_timeline1_get_relative_value(spine_bone_timeline1 self, float time, float alpha, spine_mix_blend blend, float current,
SPINE_C_API float spine_bone_timeline1_get_relative_value(spine_bone_timeline1 self, float time, float alpha, bool fromSetup, bool add, float current,
float setup);
SPINE_C_API float spine_bone_timeline1_get_absolute_value_1(spine_bone_timeline1 self, float time, float alpha, spine_mix_blend blend, float current,
float setup);
SPINE_C_API float spine_bone_timeline1_get_absolute_value_2(spine_bone_timeline1 self, float time, float alpha, spine_mix_blend blend, float current,
float setup, float value);
SPINE_C_API float spine_bone_timeline1_get_scale_value(spine_bone_timeline1 self, float time, float alpha, spine_mix_blend blend,
spine_mix_direction direction, float current, float setup);
SPINE_C_API float spine_bone_timeline1_get_absolute_value_1(spine_bone_timeline1 self, float time, float alpha, bool fromSetup, bool add,
float current, float setup);
SPINE_C_API float spine_bone_timeline1_get_absolute_value_2(spine_bone_timeline1 self, float time, float alpha, bool fromSetup, bool add,
float current, float setup, float value);
SPINE_C_API float spine_bone_timeline1_get_scale_value(spine_bone_timeline1 self, float time, float alpha, bool fromSetup, bool add, bool out,
float current, float setup);
SPINE_C_API void spine_bone_timeline1_set_linear(spine_bone_timeline1 self, size_t frame);
SPINE_C_API void spine_bone_timeline1_set_stepped(spine_bone_timeline1 self, size_t frame);
SPINE_C_API void spine_bone_timeline1_set_bezier(spine_bone_timeline1 self, size_t bezier, size_t frame, float value, float time1, float value1,
float cx1, float cy1, float cx2, float cy2, float time2, float value2);
SPINE_C_API float spine_bone_timeline1_get_bezier_value(spine_bone_timeline1 self, float time, size_t frame, size_t valueOffset, size_t i);
SPINE_C_API spine_array_float spine_bone_timeline1_get_curves(spine_bone_timeline1 self);
/**
* True if this timeline supports additive blending.
*/
SPINE_C_API bool spine_bone_timeline1_get_additive(spine_bone_timeline1 self);
/**
* True if this timeline sets values instantaneously and does not support
* interpolation between frames.
*/
SPINE_C_API bool spine_bone_timeline1_get_instant(spine_bone_timeline1 self);
SPINE_C_API size_t spine_bone_timeline1_get_frame_entries(spine_bone_timeline1 self);
SPINE_C_API size_t spine_bone_timeline1_get_frame_count(spine_bone_timeline1 self);
SPINE_C_API spine_array_float spine_bone_timeline1_get_frames(spine_bone_timeline1 self);

14
spine-c/src/generated/bone_timeline2.cpp
View File

@ -13,9 +13,9 @@ spine_rtti spine_bone_timeline2_get_rtti(spine_bone_timeline2 self) {
}
void spine_bone_timeline2_apply(spine_bone_timeline2 self, spine_skeleton skeleton, float lastTime, float time, /*@null*/ spine_array_event events,
float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
float alpha, bool fromSetup, bool add, bool out, bool appliedPose) {
BoneTimeline2 *_self = (BoneTimeline2 *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, fromSetup, add, out, appliedPose);
}
int spine_bone_timeline2_get_bone_index(spine_bone_timeline2 self) {
@ -59,6 +59,16 @@ spine_array_float spine_bone_timeline2_get_curves(spine_bone_timeline2 self) {
return (spine_array_float) &_self->getCurves();
}
bool spine_bone_timeline2_get_additive(spine_bone_timeline2 self) {
BoneTimeline2 *_self = (BoneTimeline2 *) self;
return _self->getAdditive();
}
bool spine_bone_timeline2_get_instant(spine_bone_timeline2 self) {
BoneTimeline2 *_self = (BoneTimeline2 *) self;
return _self->getInstant();
}
size_t spine_bone_timeline2_get_frame_entries(spine_bone_timeline2 self) {
BoneTimeline2 *_self = (BoneTimeline2 *) self;
return _self->getFrameEntries();

12
spine-c/src/generated/bone_timeline2.h
View File

@ -13,8 +13,7 @@ SPINE_C_API void spine_bone_timeline2_dispose(spine_bone_timeline2 self);
SPINE_C_API spine_rtti spine_bone_timeline2_get_rtti(spine_bone_timeline2 self);
SPINE_C_API void spine_bone_timeline2_apply(spine_bone_timeline2 self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ spine_array_event events, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose);
/*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add, bool out, bool appliedPose);
SPINE_C_API int spine_bone_timeline2_get_bone_index(spine_bone_timeline2 self);
SPINE_C_API void spine_bone_timeline2_set_bone_index(spine_bone_timeline2 self, int inValue);
SPINE_C_API void spine_bone_timeline2_set_frame(spine_bone_timeline2 self, size_t frame, float time, float value1, float value2);
@ -24,6 +23,15 @@ SPINE_C_API void spine_bone_timeline2_set_bezier(spine_bone_timeline2 self, size
float cx1, float cy1, float cx2, float cy2, float time2, float value2);
SPINE_C_API float spine_bone_timeline2_get_bezier_value(spine_bone_timeline2 self, float time, size_t frame, size_t valueOffset, size_t i);
SPINE_C_API spine_array_float spine_bone_timeline2_get_curves(spine_bone_timeline2 self);
/**
* True if this timeline supports additive blending.
*/
SPINE_C_API bool spine_bone_timeline2_get_additive(spine_bone_timeline2 self);
/**
* True if this timeline sets values instantaneously and does not support
* interpolation between frames.
*/
SPINE_C_API bool spine_bone_timeline2_get_instant(spine_bone_timeline2 self);
SPINE_C_API size_t spine_bone_timeline2_get_frame_entries(spine_bone_timeline2 self);
SPINE_C_API size_t spine_bone_timeline2_get_frame_count(spine_bone_timeline2 self);
SPINE_C_API spine_array_float spine_bone_timeline2_get_frames(spine_bone_timeline2 self);

14
spine-c/src/generated/bounding_box_attachment.h
View File

@ -18,7 +18,7 @@ SPINE_C_API spine_color spine_bounding_box_attachment_get_color(spine_bounding_b
SPINE_C_API spine_attachment spine_bounding_box_attachment_copy(spine_bounding_box_attachment self);
/**
* Transforms the attachment's local vertices to world coordinates. If the
* slot's SlotPose::getDeform() is not empty, it is used to deform the vertices.
* SlotPose::getDeform() is not empty, it is used to deform the vertices.
*
* See https://esotericsoftware.com/spine-runtime-skeletons#World-transforms
* World transforms in the Spine Runtimes Guide.
@ -39,8 +39,20 @@ SPINE_C_API void spine_bounding_box_attachment_compute_world_vertices_2(spine_bo
* Gets a unique ID for this attachment.
*/
SPINE_C_API int spine_bounding_box_attachment_get_id(spine_bounding_box_attachment self);
/**
* The bones that affect the vertices. The entries are, for each vertex, the
* number of bones affecting the vertex followed by that many bone indices,
* which is the Skeleton::getBones() index. Empty if this attachment has no
* weights.
*/
SPINE_C_API spine_array_int spine_bounding_box_attachment_get_bones(spine_bounding_box_attachment self);
SPINE_C_API void spine_bounding_box_attachment_set_bones(spine_bounding_box_attachment self, spine_array_int bones);
/**
* The vertex positions in the bone's coordinate system. For a non-weighted
* attachment, the values are x,y pairs for each vertex. For a weighted
* attachment, the values are x,y,weight triplets for each bone affecting each
* vertex.
*/
SPINE_C_API spine_array_float spine_bounding_box_attachment_get_vertices(spine_bounding_box_attachment self);
SPINE_C_API void spine_bounding_box_attachment_set_vertices(spine_bounding_box_attachment self, spine_array_float vertices);
SPINE_C_API size_t spine_bounding_box_attachment_get_world_vertices_length(spine_bounding_box_attachment self);

18
spine-c/src/generated/clipping_attachment.h
View File

@ -14,13 +14,17 @@ SPINE_C_API spine_clipping_attachment spine_clipping_attachment_create(const cha
SPINE_C_API void spine_clipping_attachment_dispose(spine_clipping_attachment self);
SPINE_C_API spine_rtti spine_clipping_attachment_get_rtti(spine_clipping_attachment self);
/**
* Clipping is performed between the clipping attachment's slot and the end
* slot. If NULL, clipping is done until the end of the skeleton's rendering.
*/
SPINE_C_API /*@null*/ spine_slot_data spine_clipping_attachment_get_end_slot(spine_clipping_attachment self);
SPINE_C_API void spine_clipping_attachment_set_end_slot(spine_clipping_attachment self, /*@null*/ spine_slot_data inValue);
SPINE_C_API spine_color spine_clipping_attachment_get_color(spine_clipping_attachment self);
SPINE_C_API spine_attachment spine_clipping_attachment_copy(spine_clipping_attachment self);
/**
* Transforms the attachment's local vertices to world coordinates. If the
* slot's SlotPose::getDeform() is not empty, it is used to deform the vertices.
* SlotPose::getDeform() is not empty, it is used to deform the vertices.
*
* See https://esotericsoftware.com/spine-runtime-skeletons#World-transforms
* World transforms in the Spine Runtimes Guide.
@ -41,8 +45,20 @@ SPINE_C_API void spine_clipping_attachment_compute_world_vertices_2(spine_clippi
* Gets a unique ID for this attachment.
*/
SPINE_C_API int spine_clipping_attachment_get_id(spine_clipping_attachment self);
/**
* The bones that affect the vertices. The entries are, for each vertex, the
* number of bones affecting the vertex followed by that many bone indices,
* which is the Skeleton::getBones() index. Empty if this attachment has no
* weights.
*/
SPINE_C_API spine_array_int spine_clipping_attachment_get_bones(spine_clipping_attachment self);
SPINE_C_API void spine_clipping_attachment_set_bones(spine_clipping_attachment self, spine_array_int bones);
/**
* The vertex positions in the bone's coordinate system. For a non-weighted
* attachment, the values are x,y pairs for each vertex. For a weighted
* attachment, the values are x,y,weight triplets for each bone affecting each
* vertex.
*/
SPINE_C_API spine_array_float spine_clipping_attachment_get_vertices(spine_clipping_attachment self);
SPINE_C_API void spine_clipping_attachment_set_vertices(spine_clipping_attachment self, spine_array_float vertices);
SPINE_C_API size_t spine_clipping_attachment_get_world_vertices_length(spine_clipping_attachment self);

37
spine-c/src/generated/constraint_timeline1.cpp
View File

@ -32,28 +32,28 @@ float spine_constraint_timeline1_get_curve_value(spine_constraint_timeline1 self
return _self->getCurveValue(time);
}
float spine_constraint_timeline1_get_relative_value(spine_constraint_timeline1 self, float time, float alpha, spine_mix_blend blend, float current,
float spine_constraint_timeline1_get_relative_value(spine_constraint_timeline1 self, float time, float alpha, bool fromSetup, bool add, float current,
float setup) {
ConstraintTimeline1 *_self = (ConstraintTimeline1 *) self;
return _self->getRelativeValue(time, alpha, (MixBlend) blend, current, setup);
return _self->getRelativeValue(time, alpha, fromSetup, add, current, setup);
}
float spine_constraint_timeline1_get_absolute_value_1(spine_constraint_timeline1 self, float time, float alpha, spine_mix_blend blend, float current,
float setup) {
float spine_constraint_timeline1_get_absolute_value_1(spine_constraint_timeline1 self, float time, float alpha, bool fromSetup, bool add,
float current, float setup) {
ConstraintTimeline1 *_self = (ConstraintTimeline1 *) self;
return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup);
return _self->getAbsoluteValue(time, alpha, fromSetup, add, current, setup);
}
float spine_constraint_timeline1_get_absolute_value_2(spine_constraint_timeline1 self, float time, float alpha, spine_mix_blend blend, float current,
float setup, float value) {
float spine_constraint_timeline1_get_absolute_value_2(spine_constraint_timeline1 self, float time, float alpha, bool fromSetup, bool add,
float current, float setup, float value) {
ConstraintTimeline1 *_self = (ConstraintTimeline1 *) self;
return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup, value);
return _self->getAbsoluteValue(time, alpha, fromSetup, add, current, setup, value);
}
float spine_constraint_timeline1_get_scale_value(spine_constraint_timeline1 self, float time, float alpha, spine_mix_blend blend,
spine_mix_direction direction, float current, float setup) {
float spine_constraint_timeline1_get_scale_value(spine_constraint_timeline1 self, float time, float alpha, bool fromSetup, bool add, bool out,
float current, float setup) {
ConstraintTimeline1 *_self = (ConstraintTimeline1 *) self;
return _self->getScaleValue(time, alpha, (MixBlend) blend, (MixDirection) direction, current, setup);
return _self->getScaleValue(time, alpha, fromSetup, add, out, current, setup);
}
void spine_constraint_timeline1_set_linear(spine_constraint_timeline1 self, size_t frame) {
@ -83,10 +83,19 @@ spine_array_float spine_constraint_timeline1_get_curves(spine_constraint_timelin
}
void spine_constraint_timeline1_apply(spine_constraint_timeline1 self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ spine_array_event events, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose) {
/*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add, bool out, bool appliedPose) {
ConstraintTimeline1 *_self = (ConstraintTimeline1 *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, fromSetup, add, out, appliedPose);
}
bool spine_constraint_timeline1_get_additive(spine_constraint_timeline1 self) {
ConstraintTimeline1 *_self = (ConstraintTimeline1 *) self;
return _self->getAdditive();
}
bool spine_constraint_timeline1_get_instant(spine_constraint_timeline1 self) {
ConstraintTimeline1 *_self = (ConstraintTimeline1 *) self;
return _self->getInstant();
}
size_t spine_constraint_timeline1_get_frame_entries(spine_constraint_timeline1 self) {

42
spine-c/src/generated/constraint_timeline1.h
View File

@ -25,14 +25,14 @@ SPINE_C_API void spine_constraint_timeline1_set_frame(spine_constraint_timeline1
* Returns the interpolated value for the specified time.
*/
SPINE_C_API float spine_constraint_timeline1_get_curve_value(spine_constraint_timeline1 self, float time);
SPINE_C_API float spine_constraint_timeline1_get_relative_value(spine_constraint_timeline1 self, float time, float alpha, spine_mix_blend blend,
SPINE_C_API float spine_constraint_timeline1_get_relative_value(spine_constraint_timeline1 self, float time, float alpha, bool fromSetup, bool add,
float current, float setup);
SPINE_C_API float spine_constraint_timeline1_get_absolute_value_1(spine_constraint_timeline1 self, float time, float alpha, spine_mix_blend blend,
SPINE_C_API float spine_constraint_timeline1_get_absolute_value_1(spine_constraint_timeline1 self, float time, float alpha, bool fromSetup, bool add,
float current, float setup);
SPINE_C_API float spine_constraint_timeline1_get_absolute_value_2(spine_constraint_timeline1 self, float time, float alpha, spine_mix_blend blend,
SPINE_C_API float spine_constraint_timeline1_get_absolute_value_2(spine_constraint_timeline1 self, float time, float alpha, bool fromSetup, bool add,
float current, float setup, float value);
SPINE_C_API float spine_constraint_timeline1_get_scale_value(spine_constraint_timeline1 self, float time, float alpha, spine_mix_blend blend,
spine_mix_direction direction, float current, float setup);
SPINE_C_API float spine_constraint_timeline1_get_scale_value(spine_constraint_timeline1 self, float time, float alpha, bool fromSetup, bool add,
bool out, float current, float setup);
SPINE_C_API void spine_constraint_timeline1_set_linear(spine_constraint_timeline1 self, size_t frame);
SPINE_C_API void spine_constraint_timeline1_set_stepped(spine_constraint_timeline1 self, size_t frame);
SPINE_C_API void spine_constraint_timeline1_set_bezier(spine_constraint_timeline1 self, size_t bezier, size_t frame, float value, float time1,
@ -41,20 +41,30 @@ SPINE_C_API float spine_constraint_timeline1_get_bezier_value(spine_constraint_t
size_t i);
SPINE_C_API spine_array_float spine_constraint_timeline1_get_curves(spine_constraint_timeline1 self);
/**
* Sets the value(s) for the specified time.
* Applies this timeline to the skeleton.
*
* @param skeleton The skeleton the timeline is being applied to. This provides access to the bones, slots, and other skeleton components the timeline may change.
* @param lastTime lastTime The time this timeline was last applied. Timelines such as EventTimeline trigger only at specific times rather than every frame. In that case, the timeline triggers everything between lastTime (exclusive) and time (inclusive).
* @param time The time within the animation. Most timelines find the key before and the key after this time so they can interpolate between the keys.
* @param events If any events are fired, they are added to this array. Can be NULL to ignore firing events or if the timeline does not fire events. May be NULL.
* @param alpha alpha 0 applies the current or setup pose value (depending on pose parameter). 1 applies the timeline value. Between 0 and 1 applies a value between the current or setup pose and the timeline value. By adjusting alpha over time, an animation can be mixed in or out. alpha can also be useful to apply animations on top of each other (layered).
* @param blend Controls how mixing is applied when alpha is than 1.
* @param direction Indicates whether the timeline is mixing in or out. Used by timelines which perform instant transitions such as DrawOrderTimeline and AttachmentTimeline.
* @param appliedPose True to modify the applied pose.
* @param skeleton The skeleton the timeline is applied to. This provides access to the bones, slots, and other skeleton components the timelines may change.
* @param lastTime The last time in seconds this timeline was applied. Some timelines trigger only at discrete times, in which case all keys are triggered between lastTime (exclusive) and time (inclusive). Pass -1 the first time a timeline is applied to ensure frame 0 is triggered.
* @param time The time in seconds the skeleton is being posed for. Timelines find the frame before and after this time and interpolate between the frame values.
* @param events If any events are fired, they are added to this list. Can be NULL to ignore fired events or if no timelines fire events.
* @param alpha 0 applies setup or current values (depending on fromSetup), 1 uses timeline values, and intermediate values interpolate between them. Adjusting alpha over time can mix a timeline in or out.
* @param fromSetup If true, alpha transitions between setup and timeline values, setup values are used before the first frame (current values are not used). If false, alpha transitions between current and timeline values, no change is made before the first frame.
* @param add If true, for timelines that support it, their values are added to the setup or current values (depending on fromSetup).
* @param out True when the animation is mixing out, else it is mixing in. Used by timelines that perform instant transitions.
* @param appliedPose True to modify the applied pose, else the pose is modified.
*/
SPINE_C_API void spine_constraint_timeline1_apply(spine_constraint_timeline1 self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ spine_array_event events, float alpha, spine_mix_blend blend,
spine_mix_direction direction, bool appliedPose);
/*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add, bool out,
bool appliedPose);
/**
* True if this timeline supports additive blending.
*/
SPINE_C_API bool spine_constraint_timeline1_get_additive(spine_constraint_timeline1 self);
/**
* True if this timeline sets values instantaneously and does not support
* interpolation between frames.
*/
SPINE_C_API bool spine_constraint_timeline1_get_instant(spine_constraint_timeline1 self);
SPINE_C_API size_t spine_constraint_timeline1_get_frame_entries(spine_constraint_timeline1 self);
SPINE_C_API size_t spine_constraint_timeline1_get_frame_count(spine_constraint_timeline1 self);
SPINE_C_API spine_array_float spine_constraint_timeline1_get_frames(spine_constraint_timeline1 self);

14
spine-c/src/generated/curve_timeline.cpp
View File

@ -39,9 +39,19 @@ spine_array_float spine_curve_timeline_get_curves(spine_curve_timeline self) {
}
void spine_curve_timeline_apply(spine_curve_timeline self, spine_skeleton skeleton, float lastTime, float time, /*@null*/ spine_array_event events,
float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
float alpha, bool fromSetup, bool add, bool out, bool appliedPose) {
CurveTimeline *_self = (CurveTimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, fromSetup, add, out, appliedPose);
}
bool spine_curve_timeline_get_additive(spine_curve_timeline self) {
CurveTimeline *_self = (CurveTimeline *) self;
return _self->getAdditive();
}
bool spine_curve_timeline_get_instant(spine_curve_timeline self) {
CurveTimeline *_self = (CurveTimeline *) self;
return _self->getInstant();
}
size_t spine_curve_timeline_get_frame_entries(spine_curve_timeline self) {

31
spine-c/src/generated/curve_timeline.h
View File

@ -19,20 +19,29 @@ SPINE_C_API void spine_curve_timeline_set_bezier(spine_curve_timeline self, size
SPINE_C_API float spine_curve_timeline_get_bezier_value(spine_curve_timeline self, float time, size_t frame, size_t valueOffset, size_t i);
SPINE_C_API spine_array_float spine_curve_timeline_get_curves(spine_curve_timeline self);
/**
* Sets the value(s) for the specified time.
* Applies this timeline to the skeleton.
*
* @param skeleton The skeleton the timeline is being applied to. This provides access to the bones, slots, and other skeleton components the timeline may change.
* @param lastTime lastTime The time this timeline was last applied. Timelines such as EventTimeline trigger only at specific times rather than every frame. In that case, the timeline triggers everything between lastTime (exclusive) and time (inclusive).
* @param time The time within the animation. Most timelines find the key before and the key after this time so they can interpolate between the keys.
* @param events If any events are fired, they are added to this array. Can be NULL to ignore firing events or if the timeline does not fire events. May be NULL.
* @param alpha alpha 0 applies the current or setup pose value (depending on pose parameter). 1 applies the timeline value. Between 0 and 1 applies a value between the current or setup pose and the timeline value. By adjusting alpha over time, an animation can be mixed in or out. alpha can also be useful to apply animations on top of each other (layered).
* @param blend Controls how mixing is applied when alpha is than 1.
* @param direction Indicates whether the timeline is mixing in or out. Used by timelines which perform instant transitions such as DrawOrderTimeline and AttachmentTimeline.
* @param appliedPose True to modify the applied pose.
* @param skeleton The skeleton the timeline is applied to. This provides access to the bones, slots, and other skeleton components the timelines may change.
* @param lastTime The last time in seconds this timeline was applied. Some timelines trigger only at discrete times, in which case all keys are triggered between lastTime (exclusive) and time (inclusive). Pass -1 the first time a timeline is applied to ensure frame 0 is triggered.
* @param time The time in seconds the skeleton is being posed for. Timelines find the frame before and after this time and interpolate between the frame values.
* @param events If any events are fired, they are added to this list. Can be NULL to ignore fired events or if no timelines fire events.
* @param alpha 0 applies setup or current values (depending on fromSetup), 1 uses timeline values, and intermediate values interpolate between them. Adjusting alpha over time can mix a timeline in or out.
* @param fromSetup If true, alpha transitions between setup and timeline values, setup values are used before the first frame (current values are not used). If false, alpha transitions between current and timeline values, no change is made before the first frame.
* @param add If true, for timelines that support it, their values are added to the setup or current values (depending on fromSetup).
* @param out True when the animation is mixing out, else it is mixing in. Used by timelines that perform instant transitions.
* @param appliedPose True to modify the applied pose, else the pose is modified.
*/
SPINE_C_API void spine_curve_timeline_apply(spine_curve_timeline self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ spine_array_event events, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose);
/*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add, bool out, bool appliedPose);
/**
* True if this timeline supports additive blending.
*/
SPINE_C_API bool spine_curve_timeline_get_additive(spine_curve_timeline self);
/**
* True if this timeline sets values instantaneously and does not support
* interpolation between frames.
*/
SPINE_C_API bool spine_curve_timeline_get_instant(spine_curve_timeline self);
SPINE_C_API size_t spine_curve_timeline_get_frame_entries(spine_curve_timeline self);
SPINE_C_API size_t spine_curve_timeline_get_frame_count(spine_curve_timeline self);
SPINE_C_API spine_array_float spine_curve_timeline_get_frames(spine_curve_timeline self);

32
spine-c/src/generated/curve_timeline1.cpp
View File

@ -22,28 +22,28 @@ float spine_curve_timeline1_get_curve_value(spine_curve_timeline1 self, float ti
return _self->getCurveValue(time);
}
float spine_curve_timeline1_get_relative_value(spine_curve_timeline1 self, float time, float alpha, spine_mix_blend blend, float current,
float spine_curve_timeline1_get_relative_value(spine_curve_timeline1 self, float time, float alpha, bool fromSetup, bool add, float current,
float setup) {
CurveTimeline1 *_self = (CurveTimeline1 *) self;
return _self->getRelativeValue(time, alpha, (MixBlend) blend, current, setup);
return _self->getRelativeValue(time, alpha, fromSetup, add, current, setup);
}
float spine_curve_timeline1_get_absolute_value_1(spine_curve_timeline1 self, float time, float alpha, spine_mix_blend blend, float current,
float spine_curve_timeline1_get_absolute_value_1(spine_curve_timeline1 self, float time, float alpha, bool fromSetup, bool add, float current,
float setup) {
CurveTimeline1 *_self = (CurveTimeline1 *) self;
return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup);
return _self->getAbsoluteValue(time, alpha, fromSetup, add, current, setup);
}
float spine_curve_timeline1_get_absolute_value_2(spine_curve_timeline1 self, float time, float alpha, spine_mix_blend blend, float current,
float spine_curve_timeline1_get_absolute_value_2(spine_curve_timeline1 self, float time, float alpha, bool fromSetup, bool add, float current,
float setup, float value) {
CurveTimeline1 *_self = (CurveTimeline1 *) self;
return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup, value);
return _self->getAbsoluteValue(time, alpha, fromSetup, add, current, setup, value);
}
float spine_curve_timeline1_get_scale_value(spine_curve_timeline1 self, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction,
float current, float setup) {
float spine_curve_timeline1_get_scale_value(spine_curve_timeline1 self, float time, float alpha, bool fromSetup, bool add, bool out, float current,
float setup) {
CurveTimeline1 *_self = (CurveTimeline1 *) self;
return _self->getScaleValue(time, alpha, (MixBlend) blend, (MixDirection) direction, current, setup);
return _self->getScaleValue(time, alpha, fromSetup, add, out, current, setup);
}
void spine_curve_timeline1_set_linear(spine_curve_timeline1 self, size_t frame) {
@ -73,9 +73,19 @@ spine_array_float spine_curve_timeline1_get_curves(spine_curve_timeline1 self) {
}
void spine_curve_timeline1_apply(spine_curve_timeline1 self, spine_skeleton skeleton, float lastTime, float time, /*@null*/ spine_array_event events,
float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
float alpha, bool fromSetup, bool add, bool out, bool appliedPose) {
CurveTimeline1 *_self = (CurveTimeline1 *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, fromSetup, add, out, appliedPose);
}
bool spine_curve_timeline1_get_additive(spine_curve_timeline1 self) {
CurveTimeline1 *_self = (CurveTimeline1 *) self;
return _self->getAdditive();
}
bool spine_curve_timeline1_get_instant(spine_curve_timeline1 self) {
CurveTimeline1 *_self = (CurveTimeline1 *) self;
return _self->getInstant();
}
size_t spine_curve_timeline1_get_frame_entries(spine_curve_timeline1 self) {

43
spine-c/src/generated/curve_timeline1.h
View File

@ -23,14 +23,14 @@ SPINE_C_API void spine_curve_timeline1_set_frame(spine_curve_timeline1 self, siz
* Returns the interpolated value for the specified time.
*/
SPINE_C_API float spine_curve_timeline1_get_curve_value(spine_curve_timeline1 self, float time);
SPINE_C_API float spine_curve_timeline1_get_relative_value(spine_curve_timeline1 self, float time, float alpha, spine_mix_blend blend, float current,
float setup);
SPINE_C_API float spine_curve_timeline1_get_absolute_value_1(spine_curve_timeline1 self, float time, float alpha, spine_mix_blend blend,
SPINE_C_API float spine_curve_timeline1_get_relative_value(spine_curve_timeline1 self, float time, float alpha, bool fromSetup, bool add,
float current, float setup);
SPINE_C_API float spine_curve_timeline1_get_absolute_value_1(spine_curve_timeline1 self, float time, float alpha, bool fromSetup, bool add,
float current, float setup);
SPINE_C_API float spine_curve_timeline1_get_absolute_value_2(spine_curve_timeline1 self, float time, float alpha, spine_mix_blend blend,
SPINE_C_API float spine_curve_timeline1_get_absolute_value_2(spine_curve_timeline1 self, float time, float alpha, bool fromSetup, bool add,
float current, float setup, float value);
SPINE_C_API float spine_curve_timeline1_get_scale_value(spine_curve_timeline1 self, float time, float alpha, spine_mix_blend blend,
spine_mix_direction direction, float current, float setup);
SPINE_C_API float spine_curve_timeline1_get_scale_value(spine_curve_timeline1 self, float time, float alpha, bool fromSetup, bool add, bool out,
float current, float setup);
SPINE_C_API void spine_curve_timeline1_set_linear(spine_curve_timeline1 self, size_t frame);
SPINE_C_API void spine_curve_timeline1_set_stepped(spine_curve_timeline1 self, size_t frame);
SPINE_C_API void spine_curve_timeline1_set_bezier(spine_curve_timeline1 self, size_t bezier, size_t frame, float value, float time1, float value1,
@ -38,20 +38,29 @@ SPINE_C_API void spine_curve_timeline1_set_bezier(spine_curve_timeline1 self, si
SPINE_C_API float spine_curve_timeline1_get_bezier_value(spine_curve_timeline1 self, float time, size_t frame, size_t valueOffset, size_t i);
SPINE_C_API spine_array_float spine_curve_timeline1_get_curves(spine_curve_timeline1 self);
/**
* Sets the value(s) for the specified time.
* Applies this timeline to the skeleton.
*
* @param skeleton The skeleton the timeline is being applied to. This provides access to the bones, slots, and other skeleton components the timeline may change.
* @param lastTime lastTime The time this timeline was last applied. Timelines such as EventTimeline trigger only at specific times rather than every frame. In that case, the timeline triggers everything between lastTime (exclusive) and time (inclusive).
* @param time The time within the animation. Most timelines find the key before and the key after this time so they can interpolate between the keys.
* @param events If any events are fired, they are added to this array. Can be NULL to ignore firing events or if the timeline does not fire events. May be NULL.
* @param alpha alpha 0 applies the current or setup pose value (depending on pose parameter). 1 applies the timeline value. Between 0 and 1 applies a value between the current or setup pose and the timeline value. By adjusting alpha over time, an animation can be mixed in or out. alpha can also be useful to apply animations on top of each other (layered).
* @param blend Controls how mixing is applied when alpha is than 1.
* @param direction Indicates whether the timeline is mixing in or out. Used by timelines which perform instant transitions such as DrawOrderTimeline and AttachmentTimeline.
* @param appliedPose True to modify the applied pose.
* @param skeleton The skeleton the timeline is applied to. This provides access to the bones, slots, and other skeleton components the timelines may change.
* @param lastTime The last time in seconds this timeline was applied. Some timelines trigger only at discrete times, in which case all keys are triggered between lastTime (exclusive) and time (inclusive). Pass -1 the first time a timeline is applied to ensure frame 0 is triggered.
* @param time The time in seconds the skeleton is being posed for. Timelines find the frame before and after this time and interpolate between the frame values.
* @param events If any events are fired, they are added to this list. Can be NULL to ignore fired events or if no timelines fire events.
* @param alpha 0 applies setup or current values (depending on fromSetup), 1 uses timeline values, and intermediate values interpolate between them. Adjusting alpha over time can mix a timeline in or out.
* @param fromSetup If true, alpha transitions between setup and timeline values, setup values are used before the first frame (current values are not used). If false, alpha transitions between current and timeline values, no change is made before the first frame.
* @param add If true, for timelines that support it, their values are added to the setup or current values (depending on fromSetup).
* @param out True when the animation is mixing out, else it is mixing in. Used by timelines that perform instant transitions.
* @param appliedPose True to modify the applied pose, else the pose is modified.
*/
SPINE_C_API void spine_curve_timeline1_apply(spine_curve_timeline1 self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ spine_array_event events, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose);
/*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add, bool out, bool appliedPose);
/**
* True if this timeline supports additive blending.
*/
SPINE_C_API bool spine_curve_timeline1_get_additive(spine_curve_timeline1 self);
/**
* True if this timeline sets values instantaneously and does not support
* interpolation between frames.
*/
SPINE_C_API bool spine_curve_timeline1_get_instant(spine_curve_timeline1 self);
SPINE_C_API size_t spine_curve_timeline1_get_frame_entries(spine_curve_timeline1 self);
SPINE_C_API size_t spine_curve_timeline1_get_frame_count(spine_curve_timeline1 self);
SPINE_C_API spine_array_float spine_curve_timeline1_get_frames(spine_curve_timeline1 self);

14
spine-c/src/generated/deform_timeline.cpp
View File

@ -48,9 +48,9 @@ size_t spine_deform_timeline_get_frame_count(spine_deform_timeline self) {
}
void spine_deform_timeline_apply(spine_deform_timeline self, spine_skeleton skeleton, float lastTime, float time, /*@null*/ spine_array_event events,
float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
float alpha, bool fromSetup, bool add, bool out, bool appliedPose) {
DeformTimeline *_self = (DeformTimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, fromSetup, add, out, appliedPose);
}
int spine_deform_timeline_get_slot_index(spine_deform_timeline self) {
@ -83,6 +83,16 @@ spine_array_float spine_deform_timeline_get_curves(spine_deform_timeline self) {
return (spine_array_float) &_self->getCurves();
}
bool spine_deform_timeline_get_additive(spine_deform_timeline self) {
DeformTimeline *_self = (DeformTimeline *) self;
return _self->getAdditive();
}
bool spine_deform_timeline_get_instant(spine_deform_timeline self) {
DeformTimeline *_self = (DeformTimeline *) self;
return _self->getInstant();
}
size_t spine_deform_timeline_get_frame_entries(spine_deform_timeline self) {
DeformTimeline *_self = (DeformTimeline *) self;
return _self->getFrameEntries();

12
spine-c/src/generated/deform_timeline.h
View File

@ -29,14 +29,22 @@ SPINE_C_API void spine_deform_timeline_set_bezier(spine_deform_timeline self, si
SPINE_C_API float spine_deform_timeline_get_curve_percent(spine_deform_timeline self, float time, int frame);
SPINE_C_API size_t spine_deform_timeline_get_frame_count(spine_deform_timeline self);
SPINE_C_API void spine_deform_timeline_apply(spine_deform_timeline self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ spine_array_event events, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose);
/*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add, bool out, bool appliedPose);
SPINE_C_API int spine_deform_timeline_get_slot_index(spine_deform_timeline self);
SPINE_C_API void spine_deform_timeline_set_slot_index(spine_deform_timeline self, int inValue);
SPINE_C_API void spine_deform_timeline_set_linear(spine_deform_timeline self, size_t frame);
SPINE_C_API void spine_deform_timeline_set_stepped(spine_deform_timeline self, size_t frame);
SPINE_C_API float spine_deform_timeline_get_bezier_value(spine_deform_timeline self, float time, size_t frame, size_t valueOffset, size_t i);
SPINE_C_API spine_array_float spine_deform_timeline_get_curves(spine_deform_timeline self);
/**
* True if this timeline supports additive blending.
*/
SPINE_C_API bool spine_deform_timeline_get_additive(spine_deform_timeline self);
/**
* True if this timeline sets values instantaneously and does not support
* interpolation between frames.
*/
SPINE_C_API bool spine_deform_timeline_get_instant(spine_deform_timeline self);
SPINE_C_API size_t spine_deform_timeline_get_frame_entries(spine_deform_timeline self);
SPINE_C_API spine_array_float spine_deform_timeline_get_frames(spine_deform_timeline self);
SPINE_C_API float spine_deform_timeline_get_duration(spine_deform_timeline self);

15
spine-c/src/generated/draw_order_folder_timeline.cpp
View File

@ -17,10 +17,9 @@ spine_rtti spine_draw_order_folder_timeline_get_rtti(spine_draw_order_folder_tim
}
void spine_draw_order_folder_timeline_apply(spine_draw_order_folder_timeline self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ spine_array_event events, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose) {
/*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add, bool out, bool appliedPose) {
DrawOrderFolderTimeline *_self = (DrawOrderFolderTimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, fromSetup, add, out, appliedPose);
}
size_t spine_draw_order_folder_timeline_get_frame_count(spine_draw_order_folder_timeline self) {
@ -39,6 +38,16 @@ void spine_draw_order_folder_timeline_set_frame(spine_draw_order_folder_timeline
_self->setFrame(frame, time, (Array<int> *) drawOrder);
}
bool spine_draw_order_folder_timeline_get_additive(spine_draw_order_folder_timeline self) {
DrawOrderFolderTimeline *_self = (DrawOrderFolderTimeline *) self;
return _self->getAdditive();
}
bool spine_draw_order_folder_timeline_get_instant(spine_draw_order_folder_timeline self) {
DrawOrderFolderTimeline *_self = (DrawOrderFolderTimeline *) self;
return _self->getInstant();
}
size_t spine_draw_order_folder_timeline_get_frame_entries(spine_draw_order_folder_timeline self) {
DrawOrderFolderTimeline *_self = (DrawOrderFolderTimeline *) self;
return _self->getFrameEntries();

13
spine-c/src/generated/draw_order_folder_timeline.h
View File

@ -15,8 +15,8 @@ SPINE_C_API void spine_draw_order_folder_timeline_dispose(spine_draw_order_folde
SPINE_C_API spine_rtti spine_draw_order_folder_timeline_get_rtti(spine_draw_order_folder_timeline self);
SPINE_C_API void spine_draw_order_folder_timeline_apply(spine_draw_order_folder_timeline self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ spine_array_event events, float alpha, spine_mix_blend blend,
spine_mix_direction direction, bool appliedPose);
/*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add, bool out,
bool appliedPose);
SPINE_C_API size_t spine_draw_order_folder_timeline_get_frame_count(spine_draw_order_folder_timeline self);
/**
* The Skeleton::getSlots() indices that this timeline affects, in setup order.
@ -31,6 +31,15 @@ SPINE_C_API spine_array_int spine_draw_order_folder_timeline_get_slots(spine_dra
*/
SPINE_C_API void spine_draw_order_folder_timeline_set_frame(spine_draw_order_folder_timeline self, size_t frame, float time,
/*@null*/ spine_array_int drawOrder);
/**
* True if this timeline supports additive blending.
*/
SPINE_C_API bool spine_draw_order_folder_timeline_get_additive(spine_draw_order_folder_timeline self);
/**
* True if this timeline sets values instantaneously and does not support
* interpolation between frames.
*/
SPINE_C_API bool spine_draw_order_folder_timeline_get_instant(spine_draw_order_folder_timeline self);
SPINE_C_API size_t spine_draw_order_folder_timeline_get_frame_entries(spine_draw_order_folder_timeline self);
SPINE_C_API spine_array_float spine_draw_order_folder_timeline_get_frames(spine_draw_order_folder_timeline self);
SPINE_C_API float spine_draw_order_folder_timeline_get_duration(spine_draw_order_folder_timeline self);

15
spine-c/src/generated/draw_order_timeline.cpp
View File

@ -17,10 +17,9 @@ spine_rtti spine_draw_order_timeline_get_rtti(spine_draw_order_timeline self) {
}
void spine_draw_order_timeline_apply(spine_draw_order_timeline self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ spine_array_event events, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose) {
/*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add, bool out, bool appliedPose) {
DrawOrderTimeline *_self = (DrawOrderTimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, fromSetup, add, out, appliedPose);
}
size_t spine_draw_order_timeline_get_frame_count(spine_draw_order_timeline self) {
@ -33,6 +32,16 @@ void spine_draw_order_timeline_set_frame(spine_draw_order_timeline self, size_t
_self->setFrame(frame, time, (Array<int> *) drawOrder);
}
bool spine_draw_order_timeline_get_additive(spine_draw_order_timeline self) {
DrawOrderTimeline *_self = (DrawOrderTimeline *) self;
return _self->getAdditive();
}
bool spine_draw_order_timeline_get_instant(spine_draw_order_timeline self) {
DrawOrderTimeline *_self = (DrawOrderTimeline *) self;
return _self->getInstant();
}
size_t spine_draw_order_timeline_get_frame_entries(spine_draw_order_timeline self) {
DrawOrderTimeline *_self = (DrawOrderTimeline *) self;
return _self->getFrameEntries();

13
spine-c/src/generated/draw_order_timeline.h
View File

@ -15,8 +15,8 @@ SPINE_C_API void spine_draw_order_timeline_dispose(spine_draw_order_timeline sel
SPINE_C_API spine_rtti spine_draw_order_timeline_get_rtti(spine_draw_order_timeline self);
SPINE_C_API void spine_draw_order_timeline_apply(spine_draw_order_timeline self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ spine_array_event events, float alpha, spine_mix_blend blend,
spine_mix_direction direction, bool appliedPose);
/*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add, bool out,
bool appliedPose);
SPINE_C_API size_t spine_draw_order_timeline_get_frame_count(spine_draw_order_timeline self);
/**
* Sets the time and draw order for the specified frame.
@ -26,6 +26,15 @@ SPINE_C_API size_t spine_draw_order_timeline_get_frame_count(spine_draw_order_ti
* @param drawOrder For each slot in Skeleton::slots, the index of the slot in the new draw order. May be null to use setup pose draw order.
*/
SPINE_C_API void spine_draw_order_timeline_set_frame(spine_draw_order_timeline self, size_t frame, float time, /*@null*/ spine_array_int drawOrder);
/**
* True if this timeline supports additive blending.
*/
SPINE_C_API bool spine_draw_order_timeline_get_additive(spine_draw_order_timeline self);
/**
* True if this timeline sets values instantaneously and does not support
* interpolation between frames.
*/
SPINE_C_API bool spine_draw_order_timeline_get_instant(spine_draw_order_timeline self);
SPINE_C_API size_t spine_draw_order_timeline_get_frame_entries(spine_draw_order_timeline self);
SPINE_C_API spine_array_float spine_draw_order_timeline_get_frames(spine_draw_order_timeline self);
SPINE_C_API float spine_draw_order_timeline_get_duration(spine_draw_order_timeline self);

2
spine-c/src/generated/event_data.h
View File

@ -14,7 +14,7 @@ SPINE_C_API spine_event_data spine_event_data_create(const char *name);
SPINE_C_API void spine_event_data_dispose(spine_event_data self);
/**
* The name of the event, which is unique within the skeleton.
* The name of the event, unique across all events in the skeleton.
*/
SPINE_C_API const char *spine_event_data_get_name(spine_event_data self);
SPINE_C_API int spine_event_data_get_int(spine_event_data self);

14
spine-c/src/generated/event_timeline.cpp
View File

@ -17,9 +17,9 @@ spine_rtti spine_event_timeline_get_rtti(spine_event_timeline self) {
}
void spine_event_timeline_apply(spine_event_timeline self, spine_skeleton skeleton, float lastTime, float time, /*@null*/ spine_array_event events,
float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
float alpha, bool fromSetup, bool add, bool out, bool appliedPose) {
EventTimeline *_self = (EventTimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, fromSetup, add, out, appliedPose);
}
size_t spine_event_timeline_get_frame_count(spine_event_timeline self) {
@ -37,6 +37,16 @@ void spine_event_timeline_set_frame(spine_event_timeline self, size_t frame, spi
_self->setFrame(frame, *((Event *) event));
}
bool spine_event_timeline_get_additive(spine_event_timeline self) {
EventTimeline *_self = (EventTimeline *) self;
return _self->getAdditive();
}
bool spine_event_timeline_get_instant(spine_event_timeline self) {
EventTimeline *_self = (EventTimeline *) self;
return _self->getInstant();
}
size_t spine_event_timeline_get_frame_entries(spine_event_timeline self) {
EventTimeline *_self = (EventTimeline *) self;
return _self->getFrameEntries();

12
spine-c/src/generated/event_timeline.h
View File

@ -18,8 +18,7 @@ SPINE_C_API spine_rtti spine_event_timeline_get_rtti(spine_event_timeline self);
* Fires events for frames > lastTime and < = time.
*/
SPINE_C_API void spine_event_timeline_apply(spine_event_timeline self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ spine_array_event events, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose);
/*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add, bool out, bool appliedPose);
SPINE_C_API size_t spine_event_timeline_get_frame_count(spine_event_timeline self);
/**
* The event for each frame.
@ -31,6 +30,15 @@ SPINE_C_API spine_array_event spine_event_timeline_get_events(spine_event_timeli
* @param frame Between 0 and frameCount, inclusive.
*/
SPINE_C_API void spine_event_timeline_set_frame(spine_event_timeline self, size_t frame, spine_event event);
/**
* True if this timeline supports additive blending.
*/
SPINE_C_API bool spine_event_timeline_get_additive(spine_event_timeline self);
/**
* True if this timeline sets values instantaneously and does not support
* interpolation between frames.
*/
SPINE_C_API bool spine_event_timeline_get_instant(spine_event_timeline self);
SPINE_C_API size_t spine_event_timeline_get_frame_entries(spine_event_timeline self);
SPINE_C_API spine_array_float spine_event_timeline_get_frames(spine_event_timeline self);
SPINE_C_API float spine_event_timeline_get_duration(spine_event_timeline self);

7
spine-c/src/generated/ik_constraint.h
View File

@ -42,6 +42,13 @@ SPINE_C_API spine_ik_constraint_pose spine_ik_constraint_get_applied_pose(spine_
SPINE_C_API void spine_ik_constraint_reset_constrained(spine_ik_constraint self);
SPINE_C_API void spine_ik_constraint_constrained(spine_ik_constraint self);
SPINE_C_API bool spine_ik_constraint_is_pose_equal_to_applied(spine_ik_constraint self);
/**
* Returns false when this won't be updated by
* Skeleton::updateWorldTransform(Physics) because a skin is required and the
* active skin does not contain this item. See Skin::getBones(),
* Skin::getConstraints(), PosedData::getSkinRequired(), and
* Skeleton::updateCache().
*/
SPINE_C_API bool spine_ik_constraint_is_active(spine_ik_constraint self);
SPINE_C_API void spine_ik_constraint_set_active(spine_ik_constraint self, bool active);
SPINE_C_API spine_rtti spine_ik_constraint_rtti(void);

7
spine-c/src/generated/ik_constraint_base.h
View File

@ -17,6 +17,13 @@ SPINE_C_API spine_ik_constraint_pose spine_ik_constraint_base_get_applied_pose(s
SPINE_C_API void spine_ik_constraint_base_reset_constrained(spine_ik_constraint_base self);
SPINE_C_API void spine_ik_constraint_base_constrained(spine_ik_constraint_base self);
SPINE_C_API bool spine_ik_constraint_base_is_pose_equal_to_applied(spine_ik_constraint_base self);
/**
* Returns false when this won't be updated by
* Skeleton::updateWorldTransform(Physics) because a skin is required and the
* active skin does not contain this item. See Skin::getBones(),
* Skin::getConstraints(), PosedData::getSkinRequired(), and
* Skeleton::updateCache().
*/
SPINE_C_API bool spine_ik_constraint_base_is_active(spine_ik_constraint_base self);
SPINE_C_API void spine_ik_constraint_base_set_active(spine_ik_constraint_base self, bool active);
SPINE_C_API spine_rtti spine_ik_constraint_base_get_rtti(spine_ik_constraint_base self);

15
spine-c/src/generated/ik_constraint_timeline.cpp
View File

@ -17,10 +17,9 @@ spine_rtti spine_ik_constraint_timeline_get_rtti(spine_ik_constraint_timeline se
}
void spine_ik_constraint_timeline_apply(spine_ik_constraint_timeline self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ spine_array_event events, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose) {
/*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add, bool out, bool appliedPose) {
IkConstraintTimeline *_self = (IkConstraintTimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, fromSetup, add, out, appliedPose);
}
void spine_ik_constraint_timeline_set_frame(spine_ik_constraint_timeline self, int frame, float time, float mix, float softness, int bendDirection,
@ -65,6 +64,16 @@ spine_array_float spine_ik_constraint_timeline_get_curves(spine_ik_constraint_ti
return (spine_array_float) &_self->getCurves();
}
bool spine_ik_constraint_timeline_get_additive(spine_ik_constraint_timeline self) {
IkConstraintTimeline *_self = (IkConstraintTimeline *) self;
return _self->getAdditive();
}
bool spine_ik_constraint_timeline_get_instant(spine_ik_constraint_timeline self) {
IkConstraintTimeline *_self = (IkConstraintTimeline *) self;
return _self->getInstant();
}
size_t spine_ik_constraint_timeline_get_frame_entries(spine_ik_constraint_timeline self) {
IkConstraintTimeline *_self = (IkConstraintTimeline *) self;
return _self->getFrameEntries();

13
spine-c/src/generated/ik_constraint_timeline.h
View File

@ -15,8 +15,8 @@ SPINE_C_API void spine_ik_constraint_timeline_dispose(spine_ik_constraint_timeli
SPINE_C_API spine_rtti spine_ik_constraint_timeline_get_rtti(spine_ik_constraint_timeline self);
SPINE_C_API void spine_ik_constraint_timeline_apply(spine_ik_constraint_timeline self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ spine_array_event events, float alpha, spine_mix_blend blend,
spine_mix_direction direction, bool appliedPose);
/*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add, bool out,
bool appliedPose);
/**
* Sets the time, mix, softness, bend direction, compress, and stretch for the
* specified frame.
@ -36,6 +36,15 @@ SPINE_C_API void spine_ik_constraint_timeline_set_bezier(spine_ik_constraint_tim
SPINE_C_API float spine_ik_constraint_timeline_get_bezier_value(spine_ik_constraint_timeline self, float time, size_t frame, size_t valueOffset,
size_t i);
SPINE_C_API spine_array_float spine_ik_constraint_timeline_get_curves(spine_ik_constraint_timeline self);
/**
* True if this timeline supports additive blending.
*/
SPINE_C_API bool spine_ik_constraint_timeline_get_additive(spine_ik_constraint_timeline self);
/**
* True if this timeline sets values instantaneously and does not support
* interpolation between frames.
*/
SPINE_C_API bool spine_ik_constraint_timeline_get_instant(spine_ik_constraint_timeline self);
SPINE_C_API size_t spine_ik_constraint_timeline_get_frame_entries(spine_ik_constraint_timeline self);
SPINE_C_API size_t spine_ik_constraint_timeline_get_frame_count(spine_ik_constraint_timeline self);
SPINE_C_API spine_array_float spine_ik_constraint_timeline_get_frames(spine_ik_constraint_timeline self);

15
spine-c/src/generated/inherit_timeline.cpp
View File

@ -22,10 +22,9 @@ void spine_inherit_timeline_set_frame(spine_inherit_timeline self, int frame, fl
}
void spine_inherit_timeline_apply(spine_inherit_timeline self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ spine_array_event events, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose) {
/*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add, bool out, bool appliedPose) {
InheritTimeline *_self = (InheritTimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, fromSetup, add, out, appliedPose);
}
int spine_inherit_timeline_get_bone_index(spine_inherit_timeline self) {
@ -38,6 +37,16 @@ void spine_inherit_timeline_set_bone_index(spine_inherit_timeline self, int inVa
_self->setBoneIndex(inValue);
}
bool spine_inherit_timeline_get_additive(spine_inherit_timeline self) {
InheritTimeline *_self = (InheritTimeline *) self;
return _self->getAdditive();
}
bool spine_inherit_timeline_get_instant(spine_inherit_timeline self) {
InheritTimeline *_self = (InheritTimeline *) self;
return _self->getInstant();
}
size_t spine_inherit_timeline_get_frame_entries(spine_inherit_timeline self) {
InheritTimeline *_self = (InheritTimeline *) self;
return _self->getFrameEntries();

12
spine-c/src/generated/inherit_timeline.h
View File

@ -22,10 +22,18 @@ SPINE_C_API spine_rtti spine_inherit_timeline_get_rtti(spine_inherit_timeline se
*/
SPINE_C_API void spine_inherit_timeline_set_frame(spine_inherit_timeline self, int frame, float time, spine_inherit inherit);
SPINE_C_API void spine_inherit_timeline_apply(spine_inherit_timeline self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ spine_array_event events, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose);
/*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add, bool out, bool appliedPose);
SPINE_C_API int spine_inherit_timeline_get_bone_index(spine_inherit_timeline self);
SPINE_C_API void spine_inherit_timeline_set_bone_index(spine_inherit_timeline self, int inValue);
/**
* True if this timeline supports additive blending.
*/
SPINE_C_API bool spine_inherit_timeline_get_additive(spine_inherit_timeline self);
/**
* True if this timeline sets values instantaneously and does not support
* interpolation between frames.
*/
SPINE_C_API bool spine_inherit_timeline_get_instant(spine_inherit_timeline self);
SPINE_C_API size_t spine_inherit_timeline_get_frame_entries(spine_inherit_timeline self);
SPINE_C_API size_t spine_inherit_timeline_get_frame_count(spine_inherit_timeline self);
SPINE_C_API spine_array_float spine_inherit_timeline_get_frames(spine_inherit_timeline self);

23
spine-c/src/generated/mesh_attachment.h
View File

@ -29,8 +29,19 @@ SPINE_C_API void spine_mesh_attachment_update_sequence(spine_mesh_attachment sel
SPINE_C_API const char *spine_mesh_attachment_get_path(spine_mesh_attachment self);
SPINE_C_API void spine_mesh_attachment_set_path(spine_mesh_attachment self, const char *inValue);
SPINE_C_API spine_color spine_mesh_attachment_get_color(spine_mesh_attachment self);
/**
* The parent mesh if this is a linked mesh, else NULL. A linked mesh shares the
* bones, vertices, regionUVs, triangles, hullLength, edges, width, and height
* with the parent mesh, but may have a different name or path, and therefore a
* different texture region.
*/
SPINE_C_API /*@null*/ spine_mesh_attachment spine_mesh_attachment_get_parent_mesh(spine_mesh_attachment self);
SPINE_C_API void spine_mesh_attachment_set_parent_mesh(spine_mesh_attachment self, /*@null*/ spine_mesh_attachment inValue);
/**
* Vertex index pairs describing edges for controlling triangulation, or empty
* if nonessential data was not exported. Mesh triangles do not cross edges.
* Triangulation is not performed at runtime.
*/
SPINE_C_API spine_array_unsigned_short spine_mesh_attachment_get_edges(spine_mesh_attachment self);
SPINE_C_API void spine_mesh_attachment_set_edges(spine_mesh_attachment self, spine_array_unsigned_short inValue);
SPINE_C_API float spine_mesh_attachment_get_width(spine_mesh_attachment self);
@ -49,8 +60,20 @@ SPINE_C_API void spine_mesh_attachment_compute_u_vs(/*@null*/ spine_texture_regi
* Gets a unique ID for this attachment.
*/
SPINE_C_API int spine_mesh_attachment_get_id(spine_mesh_attachment self);
/**
* The bones that affect the vertices. The entries are, for each vertex, the
* number of bones affecting the vertex followed by that many bone indices,
* which is the Skeleton::getBones() index. Empty if this attachment has no
* weights.
*/
SPINE_C_API spine_array_int spine_mesh_attachment_get_bones(spine_mesh_attachment self);
SPINE_C_API void spine_mesh_attachment_set_bones(spine_mesh_attachment self, spine_array_int bones);
/**
* The vertex positions in the bone's coordinate system. For a non-weighted
* attachment, the values are x,y pairs for each vertex. For a weighted
* attachment, the values are x,y,weight triplets for each bone affecting each
* vertex.
*/
SPINE_C_API spine_array_float spine_mesh_attachment_get_vertices(spine_mesh_attachment self);
SPINE_C_API void spine_mesh_attachment_set_vertices(spine_mesh_attachment self, spine_array_float vertices);
SPINE_C_API size_t spine_mesh_attachment_get_world_vertices_length(spine_mesh_attachment self);

19
spine-c/src/generated/mix_blend.h
View File

@ -1,19 +0,0 @@
#ifndef SPINE_SPINE_MIX_BLEND_H
#define SPINE_SPINE_MIX_BLEND_H
#ifdef __cplusplus
extern "C" {
#endif
typedef enum spine_mix_blend {
SPINE_MIX_BLEND_SETUP = 0,
SPINE_MIX_BLEND_FIRST,
SPINE_MIX_BLEND_REPLACE,
SPINE_MIX_BLEND_ADD
} spine_mix_blend;
#ifdef __cplusplus
}
#endif
#endif /* SPINE_SPINE_MIX_BLEND_H */

17
spine-c/src/generated/mix_direction.h
View File

@ -1,17 +0,0 @@
#ifndef SPINE_SPINE_MIX_DIRECTION_H
#define SPINE_SPINE_MIX_DIRECTION_H
#ifdef __cplusplus
extern "C" {
#endif
typedef enum spine_mix_direction {
SPINE_MIX_DIRECTION_IN = 0,
SPINE_MIX_DIRECTION_OUT
} spine_mix_direction;
#ifdef __cplusplus
}
#endif
#endif /* SPINE_SPINE_MIX_DIRECTION_H */

18
spine-c/src/generated/path_attachment.h
View File

@ -22,13 +22,17 @@ SPINE_C_API spine_array_float spine_path_attachment_get_lengths(spine_path_attac
SPINE_C_API void spine_path_attachment_set_lengths(spine_path_attachment self, spine_array_float inValue);
SPINE_C_API bool spine_path_attachment_get_closed(spine_path_attachment self);
SPINE_C_API void spine_path_attachment_set_closed(spine_path_attachment self, bool inValue);
/**
* If true, additional calculations are performed to make computing positions
* along the path more accurate so movement along the path has a constant speed.
*/
SPINE_C_API bool spine_path_attachment_get_constant_speed(spine_path_attachment self);
SPINE_C_API void spine_path_attachment_set_constant_speed(spine_path_attachment self, bool inValue);
SPINE_C_API spine_color spine_path_attachment_get_color(spine_path_attachment self);
SPINE_C_API spine_attachment spine_path_attachment_copy(spine_path_attachment self);
/**
* Transforms the attachment's local vertices to world coordinates. If the
* slot's SlotPose::getDeform() is not empty, it is used to deform the vertices.
* SlotPose::getDeform() is not empty, it is used to deform the vertices.
*
* See https://esotericsoftware.com/spine-runtime-skeletons#World-transforms
* World transforms in the Spine Runtimes Guide.
@ -47,8 +51,20 @@ SPINE_C_API void spine_path_attachment_compute_world_vertices_2(spine_path_attac
* Gets a unique ID for this attachment.
*/
SPINE_C_API int spine_path_attachment_get_id(spine_path_attachment self);
/**
* The bones that affect the vertices. The entries are, for each vertex, the
* number of bones affecting the vertex followed by that many bone indices,
* which is the Skeleton::getBones() index. Empty if this attachment has no
* weights.
*/
SPINE_C_API spine_array_int spine_path_attachment_get_bones(spine_path_attachment self);
SPINE_C_API void spine_path_attachment_set_bones(spine_path_attachment self, spine_array_int bones);
/**
* The vertex positions in the bone's coordinate system. For a non-weighted
* attachment, the values are x,y pairs for each vertex. For a weighted
* attachment, the values are x,y,weight triplets for each bone affecting each
* vertex.
*/
SPINE_C_API spine_array_float spine_path_attachment_get_vertices(spine_path_attachment self);
SPINE_C_API void spine_path_attachment_set_vertices(spine_path_attachment self, spine_array_float vertices);
SPINE_C_API size_t spine_path_attachment_get_world_vertices_length(spine_path_attachment self);

7
spine-c/src/generated/path_constraint.h
View File

@ -36,6 +36,13 @@ SPINE_C_API spine_path_constraint_pose spine_path_constraint_get_applied_pose(sp
SPINE_C_API void spine_path_constraint_reset_constrained(spine_path_constraint self);
SPINE_C_API void spine_path_constraint_constrained(spine_path_constraint self);
SPINE_C_API bool spine_path_constraint_is_pose_equal_to_applied(spine_path_constraint self);
/**
* Returns false when this won't be updated by
* Skeleton::updateWorldTransform(Physics) because a skin is required and the
* active skin does not contain this item. See Skin::getBones(),
* Skin::getConstraints(), PosedData::getSkinRequired(), and
* Skeleton::updateCache().
*/
SPINE_C_API bool spine_path_constraint_is_active(spine_path_constraint self);
SPINE_C_API void spine_path_constraint_set_active(spine_path_constraint self, bool active);
SPINE_C_API spine_rtti spine_path_constraint_rtti(void);

7
spine-c/src/generated/path_constraint_base.h
View File

@ -17,6 +17,13 @@ SPINE_C_API spine_path_constraint_pose spine_path_constraint_base_get_applied_po
SPINE_C_API void spine_path_constraint_base_reset_constrained(spine_path_constraint_base self);
SPINE_C_API void spine_path_constraint_base_constrained(spine_path_constraint_base self);
SPINE_C_API bool spine_path_constraint_base_is_pose_equal_to_applied(spine_path_constraint_base self);
/**
* Returns false when this won't be updated by
* Skeleton::updateWorldTransform(Physics) because a skin is required and the
* active skin does not contain this item. See Skin::getBones(),
* Skin::getConstraints(), PosedData::getSkinRequired(), and
* Skeleton::updateCache().
*/
SPINE_C_API bool spine_path_constraint_base_is_active(spine_path_constraint_base self);
SPINE_C_API void spine_path_constraint_base_set_active(spine_path_constraint_base self, bool active);
SPINE_C_API spine_rtti spine_path_constraint_base_get_rtti(spine_path_constraint_base self);

15
spine-c/src/generated/path_constraint_mix_timeline.cpp
View File

@ -17,10 +17,9 @@ spine_rtti spine_path_constraint_mix_timeline_get_rtti(spine_path_constraint_mix
}
void spine_path_constraint_mix_timeline_apply(spine_path_constraint_mix_timeline self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ spine_array_event events, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose) {
/*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add, bool out, bool appliedPose) {
PathConstraintMixTimeline *_self = (PathConstraintMixTimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, fromSetup, add, out, appliedPose);
}
void spine_path_constraint_mix_timeline_set_frame(spine_path_constraint_mix_timeline self, int frame, float time, float mixRotate, float mixX,
@ -66,6 +65,16 @@ spine_array_float spine_path_constraint_mix_timeline_get_curves(spine_path_const
return (spine_array_float) &_self->getCurves();
}
bool spine_path_constraint_mix_timeline_get_additive(spine_path_constraint_mix_timeline self) {
PathConstraintMixTimeline *_self = (PathConstraintMixTimeline *) self;
return _self->getAdditive();
}
bool spine_path_constraint_mix_timeline_get_instant(spine_path_constraint_mix_timeline self) {
PathConstraintMixTimeline *_self = (PathConstraintMixTimeline *) self;
return _self->getInstant();
}
size_t spine_path_constraint_mix_timeline_get_frame_entries(spine_path_constraint_mix_timeline self) {
PathConstraintMixTimeline *_self = (PathConstraintMixTimeline *) self;
return _self->getFrameEntries();

13
spine-c/src/generated/path_constraint_mix_timeline.h
View File

@ -15,8 +15,8 @@ SPINE_C_API void spine_path_constraint_mix_timeline_dispose(spine_path_constrain
SPINE_C_API spine_rtti spine_path_constraint_mix_timeline_get_rtti(spine_path_constraint_mix_timeline self);
SPINE_C_API void spine_path_constraint_mix_timeline_apply(spine_path_constraint_mix_timeline self, spine_skeleton skeleton, float lastTime,
float time, /*@null*/ spine_array_event events, float alpha, spine_mix_blend blend,
spine_mix_direction direction, bool appliedPose);
float time, /*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add,
bool out, bool appliedPose);
/**
* Sets the time and color for the specified frame.
*
@ -35,6 +35,15 @@ SPINE_C_API void spine_path_constraint_mix_timeline_set_bezier(spine_path_constr
SPINE_C_API float spine_path_constraint_mix_timeline_get_bezier_value(spine_path_constraint_mix_timeline self, float time, size_t frame,
size_t valueOffset, size_t i);
SPINE_C_API spine_array_float spine_path_constraint_mix_timeline_get_curves(spine_path_constraint_mix_timeline self);
/**
* True if this timeline supports additive blending.
*/
SPINE_C_API bool spine_path_constraint_mix_timeline_get_additive(spine_path_constraint_mix_timeline self);
/**
* True if this timeline sets values instantaneously and does not support
* interpolation between frames.
*/
SPINE_C_API bool spine_path_constraint_mix_timeline_get_instant(spine_path_constraint_mix_timeline self);
SPINE_C_API size_t spine_path_constraint_mix_timeline_get_frame_entries(spine_path_constraint_mix_timeline self);
SPINE_C_API size_t spine_path_constraint_mix_timeline_get_frame_count(spine_path_constraint_mix_timeline self);
SPINE_C_API spine_array_float spine_path_constraint_mix_timeline_get_frames(spine_path_constraint_mix_timeline self);

34
spine-c/src/generated/path_constraint_position_timeline.cpp
View File

@ -18,10 +18,10 @@ spine_rtti spine_path_constraint_position_timeline_get_rtti(spine_path_constrain
}
void spine_path_constraint_position_timeline_apply(spine_path_constraint_position_timeline self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ spine_array_event events, float alpha, spine_mix_blend blend,
spine_mix_direction direction, bool appliedPose) {
/*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add, bool out,
bool appliedPose) {
PathConstraintPositionTimeline *_self = (PathConstraintPositionTimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, fromSetup, add, out, appliedPose);
}
int spine_path_constraint_position_timeline_get_constraint_index(spine_path_constraint_position_timeline self) {
@ -45,27 +45,27 @@ float spine_path_constraint_position_timeline_get_curve_value(spine_path_constra
}
float spine_path_constraint_position_timeline_get_relative_value(spine_path_constraint_position_timeline self, float time, float alpha,
spine_mix_blend blend, float current, float setup) {
bool fromSetup, bool add, float current, float setup) {
PathConstraintPositionTimeline *_self = (PathConstraintPositionTimeline *) self;
return _self->getRelativeValue(time, alpha, (MixBlend) blend, current, setup);
return _self->getRelativeValue(time, alpha, fromSetup, add, current, setup);
}
float spine_path_constraint_position_timeline_get_absolute_value_1(spine_path_constraint_position_timeline self, float time, float alpha,
spine_mix_blend blend, float current, float setup) {
bool fromSetup, bool add, float current, float setup) {
PathConstraintPositionTimeline *_self = (PathConstraintPositionTimeline *) self;
return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup);
return _self->getAbsoluteValue(time, alpha, fromSetup, add, current, setup);
}
float spine_path_constraint_position_timeline_get_absolute_value_2(spine_path_constraint_position_timeline self, float time, float alpha,
spine_mix_blend blend, float current, float setup, float value) {
bool fromSetup, bool add, float current, float setup, float value) {
PathConstraintPositionTimeline *_self = (PathConstraintPositionTimeline *) self;
return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup, value);
return _self->getAbsoluteValue(time, alpha, fromSetup, add, current, setup, value);
}
float spine_path_constraint_position_timeline_get_scale_value(spine_path_constraint_position_timeline self, float time, float alpha,
spine_mix_blend blend, spine_mix_direction direction, float current, float setup) {
float spine_path_constraint_position_timeline_get_scale_value(spine_path_constraint_position_timeline self, float time, float alpha, bool fromSetup,
bool add, bool out, float current, float setup) {
PathConstraintPositionTimeline *_self = (PathConstraintPositionTimeline *) self;
return _self->getScaleValue(time, alpha, (MixBlend) blend, (MixDirection) direction, current, setup);
return _self->getScaleValue(time, alpha, fromSetup, add, out, current, setup);
}
void spine_path_constraint_position_timeline_set_linear(spine_path_constraint_position_timeline self, size_t frame) {
@ -96,6 +96,16 @@ spine_array_float spine_path_constraint_position_timeline_get_curves(spine_path_
return (spine_array_float) &_self->getCurves();
}
bool spine_path_constraint_position_timeline_get_additive(spine_path_constraint_position_timeline self) {
PathConstraintPositionTimeline *_self = (PathConstraintPositionTimeline *) self;
return _self->getAdditive();
}
bool spine_path_constraint_position_timeline_get_instant(spine_path_constraint_position_timeline self) {
PathConstraintPositionTimeline *_self = (PathConstraintPositionTimeline *) self;
return _self->getInstant();
}
size_t spine_path_constraint_position_timeline_get_frame_entries(spine_path_constraint_position_timeline self) {
PathConstraintPositionTimeline *_self = (PathConstraintPositionTimeline *) self;
return _self->getFrameEntries();

22
spine-c/src/generated/path_constraint_position_timeline.h
View File

@ -16,8 +16,8 @@ SPINE_C_API void spine_path_constraint_position_timeline_dispose(spine_path_cons
SPINE_C_API spine_rtti spine_path_constraint_position_timeline_get_rtti(spine_path_constraint_position_timeline self);
SPINE_C_API void spine_path_constraint_position_timeline_apply(spine_path_constraint_position_timeline self, spine_skeleton skeleton, float lastTime,
float time, /*@null*/ spine_array_event events, float alpha, spine_mix_blend blend,
spine_mix_direction direction, bool appliedPose);
float time, /*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add,
bool out, bool appliedPose);
SPINE_C_API int spine_path_constraint_position_timeline_get_constraint_index(spine_path_constraint_position_timeline self);
SPINE_C_API void spine_path_constraint_position_timeline_set_constraint_index(spine_path_constraint_position_timeline self, int inValue);
/**
@ -33,14 +33,13 @@ SPINE_C_API void spine_path_constraint_position_timeline_set_frame(spine_path_co
*/
SPINE_C_API float spine_path_constraint_position_timeline_get_curve_value(spine_path_constraint_position_timeline self, float time);
SPINE_C_API float spine_path_constraint_position_timeline_get_relative_value(spine_path_constraint_position_timeline self, float time, float alpha,
spine_mix_blend blend, float current, float setup);
bool fromSetup, bool add, float current, float setup);
SPINE_C_API float spine_path_constraint_position_timeline_get_absolute_value_1(spine_path_constraint_position_timeline self, float time, float alpha,
spine_mix_blend blend, float current, float setup);
bool fromSetup, bool add, float current, float setup);
SPINE_C_API float spine_path_constraint_position_timeline_get_absolute_value_2(spine_path_constraint_position_timeline self, float time, float alpha,
spine_mix_blend blend, float current, float setup, float value);
bool fromSetup, bool add, float current, float setup, float value);
SPINE_C_API float spine_path_constraint_position_timeline_get_scale_value(spine_path_constraint_position_timeline self, float time, float alpha,
spine_mix_blend blend, spine_mix_direction direction, float current,
float setup);
bool fromSetup, bool add, bool out, float current, float setup);
SPINE_C_API void spine_path_constraint_position_timeline_set_linear(spine_path_constraint_position_timeline self, size_t frame);
SPINE_C_API void spine_path_constraint_position_timeline_set_stepped(spine_path_constraint_position_timeline self, size_t frame);
SPINE_C_API void spine_path_constraint_position_timeline_set_bezier(spine_path_constraint_position_timeline self, size_t bezier, size_t frame,
@ -49,6 +48,15 @@ SPINE_C_API void spine_path_constraint_position_timeline_set_bezier(spine_path_c
SPINE_C_API float spine_path_constraint_position_timeline_get_bezier_value(spine_path_constraint_position_timeline self, float time, size_t frame,
size_t valueOffset, size_t i);
SPINE_C_API spine_array_float spine_path_constraint_position_timeline_get_curves(spine_path_constraint_position_timeline self);
/**
* True if this timeline supports additive blending.
*/
SPINE_C_API bool spine_path_constraint_position_timeline_get_additive(spine_path_constraint_position_timeline self);
/**
* True if this timeline sets values instantaneously and does not support
* interpolation between frames.
*/
SPINE_C_API bool spine_path_constraint_position_timeline_get_instant(spine_path_constraint_position_timeline self);
SPINE_C_API size_t spine_path_constraint_position_timeline_get_frame_entries(spine_path_constraint_position_timeline self);
SPINE_C_API size_t spine_path_constraint_position_timeline_get_frame_count(spine_path_constraint_position_timeline self);
SPINE_C_API spine_array_float spine_path_constraint_position_timeline_get_frames(spine_path_constraint_position_timeline self);

36
spine-c/src/generated/path_constraint_spacing_timeline.cpp
View File

@ -17,10 +17,10 @@ spine_rtti spine_path_constraint_spacing_timeline_get_rtti(spine_path_constraint
}
void spine_path_constraint_spacing_timeline_apply(spine_path_constraint_spacing_timeline self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ spine_array_event events, float alpha, spine_mix_blend blend,
spine_mix_direction direction, bool appliedPose) {
/*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add, bool out,
bool appliedPose) {
PathConstraintSpacingTimeline *_self = (PathConstraintSpacingTimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, fromSetup, add, out, appliedPose);
}
int spine_path_constraint_spacing_timeline_get_constraint_index(spine_path_constraint_spacing_timeline self) {
@ -43,28 +43,28 @@ float spine_path_constraint_spacing_timeline_get_curve_value(spine_path_constrai
return _self->getCurveValue(time);
}
float spine_path_constraint_spacing_timeline_get_relative_value(spine_path_constraint_spacing_timeline self, float time, float alpha,
spine_mix_blend blend, float current, float setup) {
float spine_path_constraint_spacing_timeline_get_relative_value(spine_path_constraint_spacing_timeline self, float time, float alpha, bool fromSetup,
bool add, float current, float setup) {
PathConstraintSpacingTimeline *_self = (PathConstraintSpacingTimeline *) self;
return _self->getRelativeValue(time, alpha, (MixBlend) blend, current, setup);
return _self->getRelativeValue(time, alpha, fromSetup, add, current, setup);
}
float spine_path_constraint_spacing_timeline_get_absolute_value_1(spine_path_constraint_spacing_timeline self, float time, float alpha,
spine_mix_blend blend, float current, float setup) {
bool fromSetup, bool add, float current, float setup) {
PathConstraintSpacingTimeline *_self = (PathConstraintSpacingTimeline *) self;
return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup);
return _self->getAbsoluteValue(time, alpha, fromSetup, add, current, setup);
}
float spine_path_constraint_spacing_timeline_get_absolute_value_2(spine_path_constraint_spacing_timeline self, float time, float alpha,
spine_mix_blend blend, float current, float setup, float value) {
bool fromSetup, bool add, float current, float setup, float value) {
PathConstraintSpacingTimeline *_self = (PathConstraintSpacingTimeline *) self;
return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup, value);
return _self->getAbsoluteValue(time, alpha, fromSetup, add, current, setup, value);
}
float spine_path_constraint_spacing_timeline_get_scale_value(spine_path_constraint_spacing_timeline self, float time, float alpha,
spine_mix_blend blend, spine_mix_direction direction, float current, float setup) {
float spine_path_constraint_spacing_timeline_get_scale_value(spine_path_constraint_spacing_timeline self, float time, float alpha, bool fromSetup,
bool add, bool out, float current, float setup) {
PathConstraintSpacingTimeline *_self = (PathConstraintSpacingTimeline *) self;
return _self->getScaleValue(time, alpha, (MixBlend) blend, (MixDirection) direction, current, setup);
return _self->getScaleValue(time, alpha, fromSetup, add, out, current, setup);
}
void spine_path_constraint_spacing_timeline_set_linear(spine_path_constraint_spacing_timeline self, size_t frame) {
@ -95,6 +95,16 @@ spine_array_float spine_path_constraint_spacing_timeline_get_curves(spine_path_c
return (spine_array_float) &_self->getCurves();
}
bool spine_path_constraint_spacing_timeline_get_additive(spine_path_constraint_spacing_timeline self) {
PathConstraintSpacingTimeline *_self = (PathConstraintSpacingTimeline *) self;
return _self->getAdditive();
}
bool spine_path_constraint_spacing_timeline_get_instant(spine_path_constraint_spacing_timeline self) {
PathConstraintSpacingTimeline *_self = (PathConstraintSpacingTimeline *) self;
return _self->getInstant();
}
size_t spine_path_constraint_spacing_timeline_get_frame_entries(spine_path_constraint_spacing_timeline self) {
PathConstraintSpacingTimeline *_self = (PathConstraintSpacingTimeline *) self;
return _self->getFrameEntries();

22
spine-c/src/generated/path_constraint_spacing_timeline.h
View File

@ -16,8 +16,8 @@ SPINE_C_API void spine_path_constraint_spacing_timeline_dispose(spine_path_const
SPINE_C_API spine_rtti spine_path_constraint_spacing_timeline_get_rtti(spine_path_constraint_spacing_timeline self);
SPINE_C_API void spine_path_constraint_spacing_timeline_apply(spine_path_constraint_spacing_timeline self, spine_skeleton skeleton, float lastTime,
float time, /*@null*/ spine_array_event events, float alpha, spine_mix_blend blend,
spine_mix_direction direction, bool appliedPose);
float time, /*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add,
bool out, bool appliedPose);
SPINE_C_API int spine_path_constraint_spacing_timeline_get_constraint_index(spine_path_constraint_spacing_timeline self);
SPINE_C_API void spine_path_constraint_spacing_timeline_set_constraint_index(spine_path_constraint_spacing_timeline self, int inValue);
/**
@ -32,14 +32,13 @@ SPINE_C_API void spine_path_constraint_spacing_timeline_set_frame(spine_path_con
*/
SPINE_C_API float spine_path_constraint_spacing_timeline_get_curve_value(spine_path_constraint_spacing_timeline self, float time);
SPINE_C_API float spine_path_constraint_spacing_timeline_get_relative_value(spine_path_constraint_spacing_timeline self, float time, float alpha,
spine_mix_blend blend, float current, float setup);
bool fromSetup, bool add, float current, float setup);
SPINE_C_API float spine_path_constraint_spacing_timeline_get_absolute_value_1(spine_path_constraint_spacing_timeline self, float time, float alpha,
spine_mix_blend blend, float current, float setup);
bool fromSetup, bool add, float current, float setup);
SPINE_C_API float spine_path_constraint_spacing_timeline_get_absolute_value_2(spine_path_constraint_spacing_timeline self, float time, float alpha,
spine_mix_blend blend, float current, float setup, float value);
bool fromSetup, bool add, float current, float setup, float value);
SPINE_C_API float spine_path_constraint_spacing_timeline_get_scale_value(spine_path_constraint_spacing_timeline self, float time, float alpha,
spine_mix_blend blend, spine_mix_direction direction, float current,
float setup);
bool fromSetup, bool add, bool out, float current, float setup);
SPINE_C_API void spine_path_constraint_spacing_timeline_set_linear(spine_path_constraint_spacing_timeline self, size_t frame);
SPINE_C_API void spine_path_constraint_spacing_timeline_set_stepped(spine_path_constraint_spacing_timeline self, size_t frame);
SPINE_C_API void spine_path_constraint_spacing_timeline_set_bezier(spine_path_constraint_spacing_timeline self, size_t bezier, size_t frame,
@ -48,6 +47,15 @@ SPINE_C_API void spine_path_constraint_spacing_timeline_set_bezier(spine_path_co
SPINE_C_API float spine_path_constraint_spacing_timeline_get_bezier_value(spine_path_constraint_spacing_timeline self, float time, size_t frame,
size_t valueOffset, size_t i);
SPINE_C_API spine_array_float spine_path_constraint_spacing_timeline_get_curves(spine_path_constraint_spacing_timeline self);
/**
* True if this timeline supports additive blending.
*/
SPINE_C_API bool spine_path_constraint_spacing_timeline_get_additive(spine_path_constraint_spacing_timeline self);
/**
* True if this timeline sets values instantaneously and does not support
* interpolation between frames.
*/
SPINE_C_API bool spine_path_constraint_spacing_timeline_get_instant(spine_path_constraint_spacing_timeline self);
SPINE_C_API size_t spine_path_constraint_spacing_timeline_get_frame_entries(spine_path_constraint_spacing_timeline self);
SPINE_C_API size_t spine_path_constraint_spacing_timeline_get_frame_count(spine_path_constraint_spacing_timeline self);
SPINE_C_API spine_array_float spine_path_constraint_spacing_timeline_get_frames(spine_path_constraint_spacing_timeline self);

7
spine-c/src/generated/physics_constraint.h
View File

@ -40,6 +40,13 @@ SPINE_C_API spine_physics_constraint_pose spine_physics_constraint_get_applied_p
SPINE_C_API void spine_physics_constraint_reset_constrained(spine_physics_constraint self);
SPINE_C_API void spine_physics_constraint_constrained(spine_physics_constraint self);
SPINE_C_API bool spine_physics_constraint_is_pose_equal_to_applied(spine_physics_constraint self);
/**
* Returns false when this won't be updated by
* Skeleton::updateWorldTransform(Physics) because a skin is required and the
* active skin does not contain this item. See Skin::getBones(),
* Skin::getConstraints(), PosedData::getSkinRequired(), and
* Skeleton::updateCache().
*/
SPINE_C_API bool spine_physics_constraint_is_active(spine_physics_constraint self);
SPINE_C_API void spine_physics_constraint_set_active(spine_physics_constraint self, bool active);
SPINE_C_API spine_rtti spine_physics_constraint_rtti(void);

7
spine-c/src/generated/physics_constraint_base.h
View File

@ -17,6 +17,13 @@ SPINE_C_API spine_physics_constraint_pose spine_physics_constraint_base_get_appl
SPINE_C_API void spine_physics_constraint_base_reset_constrained(spine_physics_constraint_base self);
SPINE_C_API void spine_physics_constraint_base_constrained(spine_physics_constraint_base self);
SPINE_C_API bool spine_physics_constraint_base_is_pose_equal_to_applied(spine_physics_constraint_base self);
/**
* Returns false when this won't be updated by
* Skeleton::updateWorldTransform(Physics) because a skin is required and the
* active skin does not contain this item. See Skin::getBones(),
* Skin::getConstraints(), PosedData::getSkinRequired(), and
* Skeleton::updateCache().
*/
SPINE_C_API bool spine_physics_constraint_base_is_active(spine_physics_constraint_base self);
SPINE_C_API void spine_physics_constraint_base_set_active(spine_physics_constraint_base self, bool active);
SPINE_C_API spine_rtti spine_physics_constraint_base_get_rtti(spine_physics_constraint_base self);

32
spine-c/src/generated/physics_constraint_damping_timeline.cpp
View File

@ -19,10 +19,10 @@ spine_rtti spine_physics_constraint_damping_timeline_get_rtti(spine_physics_cons
}
void spine_physics_constraint_damping_timeline_apply(spine_physics_constraint_damping_timeline self, spine_skeleton skeleton, float lastTime,
float time, /*@null*/ spine_array_event events, float alpha, spine_mix_blend blend,
spine_mix_direction direction, bool appliedPose) {
float time, /*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add, bool out,
bool appliedPose) {
PhysicsConstraintDampingTimeline *_self = (PhysicsConstraintDampingTimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, fromSetup, add, out, appliedPose);
}
int spine_physics_constraint_damping_timeline_get_constraint_index(spine_physics_constraint_damping_timeline self) {
@ -46,27 +46,27 @@ float spine_physics_constraint_damping_timeline_get_curve_value(spine_physics_co
}
float spine_physics_constraint_damping_timeline_get_relative_value(spine_physics_constraint_damping_timeline self, float time, float alpha,
spine_mix_blend blend, float current, float setup) {
bool fromSetup, bool add, float current, float setup) {
PhysicsConstraintDampingTimeline *_self = (PhysicsConstraintDampingTimeline *) self;
return _self->getRelativeValue(time, alpha, (MixBlend) blend, current, setup);
return _self->getRelativeValue(time, alpha, fromSetup, add, current, setup);
}
float spine_physics_constraint_damping_timeline_get_absolute_value_1(spine_physics_constraint_damping_timeline self, float time, float alpha,
spine_mix_blend blend, float current, float setup) {
bool fromSetup, bool add, float current, float setup) {
PhysicsConstraintDampingTimeline *_self = (PhysicsConstraintDampingTimeline *) self;
return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup);
return _self->getAbsoluteValue(time, alpha, fromSetup, add, current, setup);
}
float spine_physics_constraint_damping_timeline_get_absolute_value_2(spine_physics_constraint_damping_timeline self, float time, float alpha,
spine_mix_blend blend, float current, float setup, float value) {
bool fromSetup, bool add, float current, float setup, float value) {
PhysicsConstraintDampingTimeline *_self = (PhysicsConstraintDampingTimeline *) self;
return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup, value);
return _self->getAbsoluteValue(time, alpha, fromSetup, add, current, setup, value);
}
float spine_physics_constraint_damping_timeline_get_scale_value(spine_physics_constraint_damping_timeline self, float time, float alpha,
spine_mix_blend blend, spine_mix_direction direction, float current, float setup) {
bool fromSetup, bool add, bool out, float current, float setup) {
PhysicsConstraintDampingTimeline *_self = (PhysicsConstraintDampingTimeline *) self;
return _self->getScaleValue(time, alpha, (MixBlend) blend, (MixDirection) direction, current, setup);
return _self->getScaleValue(time, alpha, fromSetup, add, out, current, setup);
}
void spine_physics_constraint_damping_timeline_set_linear(spine_physics_constraint_damping_timeline self, size_t frame) {
@ -97,6 +97,16 @@ spine_array_float spine_physics_constraint_damping_timeline_get_curves(spine_phy
return (spine_array_float) &_self->getCurves();
}
bool spine_physics_constraint_damping_timeline_get_additive(spine_physics_constraint_damping_timeline self) {
PhysicsConstraintDampingTimeline *_self = (PhysicsConstraintDampingTimeline *) self;
return _self->getAdditive();
}
bool spine_physics_constraint_damping_timeline_get_instant(spine_physics_constraint_damping_timeline self) {
PhysicsConstraintDampingTimeline *_self = (PhysicsConstraintDampingTimeline *) self;
return _self->getInstant();
}
size_t spine_physics_constraint_damping_timeline_get_frame_entries(spine_physics_constraint_damping_timeline self) {
PhysicsConstraintDampingTimeline *_self = (PhysicsConstraintDampingTimeline *) self;
return _self->getFrameEntries();

20
spine-c/src/generated/physics_constraint_damping_timeline.h
View File

@ -17,7 +17,7 @@ SPINE_C_API void spine_physics_constraint_damping_timeline_dispose(spine_physics
SPINE_C_API spine_rtti spine_physics_constraint_damping_timeline_get_rtti(spine_physics_constraint_damping_timeline self);
SPINE_C_API void spine_physics_constraint_damping_timeline_apply(spine_physics_constraint_damping_timeline self, spine_skeleton skeleton,
float lastTime, float time, /*@null*/ spine_array_event events, float alpha,
spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
bool fromSetup, bool add, bool out, bool appliedPose);
SPINE_C_API int spine_physics_constraint_damping_timeline_get_constraint_index(spine_physics_constraint_damping_timeline self);
SPINE_C_API void spine_physics_constraint_damping_timeline_set_constraint_index(spine_physics_constraint_damping_timeline self, int inValue);
/**
@ -33,15 +33,14 @@ SPINE_C_API void spine_physics_constraint_damping_timeline_set_frame(spine_physi
*/
SPINE_C_API float spine_physics_constraint_damping_timeline_get_curve_value(spine_physics_constraint_damping_timeline self, float time);
SPINE_C_API float spine_physics_constraint_damping_timeline_get_relative_value(spine_physics_constraint_damping_timeline self, float time,
float alpha, spine_mix_blend blend, float current, float setup);
float alpha, bool fromSetup, bool add, float current, float setup);
SPINE_C_API float spine_physics_constraint_damping_timeline_get_absolute_value_1(spine_physics_constraint_damping_timeline self, float time,
float alpha, spine_mix_blend blend, float current, float setup);
float alpha, bool fromSetup, bool add, float current, float setup);
SPINE_C_API float spine_physics_constraint_damping_timeline_get_absolute_value_2(spine_physics_constraint_damping_timeline self, float time,
float alpha, spine_mix_blend blend, float current, float setup,
float alpha, bool fromSetup, bool add, float current, float setup,
float value);
SPINE_C_API float spine_physics_constraint_damping_timeline_get_scale_value(spine_physics_constraint_damping_timeline self, float time, float alpha,
spine_mix_blend blend, spine_mix_direction direction, float current,
float setup);
bool fromSetup, bool add, bool out, float current, float setup);
SPINE_C_API void spine_physics_constraint_damping_timeline_set_linear(spine_physics_constraint_damping_timeline self, size_t frame);
SPINE_C_API void spine_physics_constraint_damping_timeline_set_stepped(spine_physics_constraint_damping_timeline self, size_t frame);
SPINE_C_API void spine_physics_constraint_damping_timeline_set_bezier(spine_physics_constraint_damping_timeline self, size_t bezier, size_t frame,
@ -50,6 +49,15 @@ SPINE_C_API void spine_physics_constraint_damping_timeline_set_bezier(spine_phys
SPINE_C_API float spine_physics_constraint_damping_timeline_get_bezier_value(spine_physics_constraint_damping_timeline self, float time, size_t frame,
size_t valueOffset, size_t i);
SPINE_C_API spine_array_float spine_physics_constraint_damping_timeline_get_curves(spine_physics_constraint_damping_timeline self);
/**
* True if this timeline supports additive blending.
*/
SPINE_C_API bool spine_physics_constraint_damping_timeline_get_additive(spine_physics_constraint_damping_timeline self);
/**
* True if this timeline sets values instantaneously and does not support
* interpolation between frames.
*/
SPINE_C_API bool spine_physics_constraint_damping_timeline_get_instant(spine_physics_constraint_damping_timeline self);
SPINE_C_API size_t spine_physics_constraint_damping_timeline_get_frame_entries(spine_physics_constraint_damping_timeline self);
SPINE_C_API size_t spine_physics_constraint_damping_timeline_get_frame_count(spine_physics_constraint_damping_timeline self);
SPINE_C_API spine_array_float spine_physics_constraint_damping_timeline_get_frames(spine_physics_constraint_damping_timeline self);

32
spine-c/src/generated/physics_constraint_gravity_timeline.cpp
View File

@ -19,10 +19,10 @@ spine_rtti spine_physics_constraint_gravity_timeline_get_rtti(spine_physics_cons
}
void spine_physics_constraint_gravity_timeline_apply(spine_physics_constraint_gravity_timeline self, spine_skeleton skeleton, float lastTime,
float time, /*@null*/ spine_array_event events, float alpha, spine_mix_blend blend,
spine_mix_direction direction, bool appliedPose) {
float time, /*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add, bool out,
bool appliedPose) {
PhysicsConstraintGravityTimeline *_self = (PhysicsConstraintGravityTimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, fromSetup, add, out, appliedPose);
}
int spine_physics_constraint_gravity_timeline_get_constraint_index(spine_physics_constraint_gravity_timeline self) {
@ -46,27 +46,27 @@ float spine_physics_constraint_gravity_timeline_get_curve_value(spine_physics_co
}
float spine_physics_constraint_gravity_timeline_get_relative_value(spine_physics_constraint_gravity_timeline self, float time, float alpha,
spine_mix_blend blend, float current, float setup) {
bool fromSetup, bool add, float current, float setup) {
PhysicsConstraintGravityTimeline *_self = (PhysicsConstraintGravityTimeline *) self;
return _self->getRelativeValue(time, alpha, (MixBlend) blend, current, setup);
return _self->getRelativeValue(time, alpha, fromSetup, add, current, setup);
}
float spine_physics_constraint_gravity_timeline_get_absolute_value_1(spine_physics_constraint_gravity_timeline self, float time, float alpha,
spine_mix_blend blend, float current, float setup) {
bool fromSetup, bool add, float current, float setup) {
PhysicsConstraintGravityTimeline *_self = (PhysicsConstraintGravityTimeline *) self;
return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup);
return _self->getAbsoluteValue(time, alpha, fromSetup, add, current, setup);
}
float spine_physics_constraint_gravity_timeline_get_absolute_value_2(spine_physics_constraint_gravity_timeline self, float time, float alpha,
spine_mix_blend blend, float current, float setup, float value) {
bool fromSetup, bool add, float current, float setup, float value) {
PhysicsConstraintGravityTimeline *_self = (PhysicsConstraintGravityTimeline *) self;
return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup, value);
return _self->getAbsoluteValue(time, alpha, fromSetup, add, current, setup, value);
}
float spine_physics_constraint_gravity_timeline_get_scale_value(spine_physics_constraint_gravity_timeline self, float time, float alpha,
spine_mix_blend blend, spine_mix_direction direction, float current, float setup) {
bool fromSetup, bool add, bool out, float current, float setup) {
PhysicsConstraintGravityTimeline *_self = (PhysicsConstraintGravityTimeline *) self;
return _self->getScaleValue(time, alpha, (MixBlend) blend, (MixDirection) direction, current, setup);
return _self->getScaleValue(time, alpha, fromSetup, add, out, current, setup);
}
void spine_physics_constraint_gravity_timeline_set_linear(spine_physics_constraint_gravity_timeline self, size_t frame) {
@ -97,6 +97,16 @@ spine_array_float spine_physics_constraint_gravity_timeline_get_curves(spine_phy
return (spine_array_float) &_self->getCurves();
}
bool spine_physics_constraint_gravity_timeline_get_additive(spine_physics_constraint_gravity_timeline self) {
PhysicsConstraintGravityTimeline *_self = (PhysicsConstraintGravityTimeline *) self;
return _self->getAdditive();
}
bool spine_physics_constraint_gravity_timeline_get_instant(spine_physics_constraint_gravity_timeline self) {
PhysicsConstraintGravityTimeline *_self = (PhysicsConstraintGravityTimeline *) self;
return _self->getInstant();
}
size_t spine_physics_constraint_gravity_timeline_get_frame_entries(spine_physics_constraint_gravity_timeline self) {
PhysicsConstraintGravityTimeline *_self = (PhysicsConstraintGravityTimeline *) self;
return _self->getFrameEntries();

20
spine-c/src/generated/physics_constraint_gravity_timeline.h
View File

@ -17,7 +17,7 @@ SPINE_C_API void spine_physics_constraint_gravity_timeline_dispose(spine_physics
SPINE_C_API spine_rtti spine_physics_constraint_gravity_timeline_get_rtti(spine_physics_constraint_gravity_timeline self);
SPINE_C_API void spine_physics_constraint_gravity_timeline_apply(spine_physics_constraint_gravity_timeline self, spine_skeleton skeleton,
float lastTime, float time, /*@null*/ spine_array_event events, float alpha,
spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
bool fromSetup, bool add, bool out, bool appliedPose);
SPINE_C_API int spine_physics_constraint_gravity_timeline_get_constraint_index(spine_physics_constraint_gravity_timeline self);
SPINE_C_API void spine_physics_constraint_gravity_timeline_set_constraint_index(spine_physics_constraint_gravity_timeline self, int inValue);
/**
@ -33,15 +33,14 @@ SPINE_C_API void spine_physics_constraint_gravity_timeline_set_frame(spine_physi
*/
SPINE_C_API float spine_physics_constraint_gravity_timeline_get_curve_value(spine_physics_constraint_gravity_timeline self, float time);
SPINE_C_API float spine_physics_constraint_gravity_timeline_get_relative_value(spine_physics_constraint_gravity_timeline self, float time,
float alpha, spine_mix_blend blend, float current, float setup);
float alpha, bool fromSetup, bool add, float current, float setup);
SPINE_C_API float spine_physics_constraint_gravity_timeline_get_absolute_value_1(spine_physics_constraint_gravity_timeline self, float time,
float alpha, spine_mix_blend blend, float current, float setup);
float alpha, bool fromSetup, bool add, float current, float setup);
SPINE_C_API float spine_physics_constraint_gravity_timeline_get_absolute_value_2(spine_physics_constraint_gravity_timeline self, float time,
float alpha, spine_mix_blend blend, float current, float setup,
float alpha, bool fromSetup, bool add, float current, float setup,
float value);
SPINE_C_API float spine_physics_constraint_gravity_timeline_get_scale_value(spine_physics_constraint_gravity_timeline self, float time, float alpha,
spine_mix_blend blend, spine_mix_direction direction, float current,
float setup);
bool fromSetup, bool add, bool out, float current, float setup);
SPINE_C_API void spine_physics_constraint_gravity_timeline_set_linear(spine_physics_constraint_gravity_timeline self, size_t frame);
SPINE_C_API void spine_physics_constraint_gravity_timeline_set_stepped(spine_physics_constraint_gravity_timeline self, size_t frame);
SPINE_C_API void spine_physics_constraint_gravity_timeline_set_bezier(spine_physics_constraint_gravity_timeline self, size_t bezier, size_t frame,
@ -50,6 +49,15 @@ SPINE_C_API void spine_physics_constraint_gravity_timeline_set_bezier(spine_phys
SPINE_C_API float spine_physics_constraint_gravity_timeline_get_bezier_value(spine_physics_constraint_gravity_timeline self, float time, size_t frame,
size_t valueOffset, size_t i);
SPINE_C_API spine_array_float spine_physics_constraint_gravity_timeline_get_curves(spine_physics_constraint_gravity_timeline self);
/**
* True if this timeline supports additive blending.
*/
SPINE_C_API bool spine_physics_constraint_gravity_timeline_get_additive(spine_physics_constraint_gravity_timeline self);
/**
* True if this timeline sets values instantaneously and does not support
* interpolation between frames.
*/
SPINE_C_API bool spine_physics_constraint_gravity_timeline_get_instant(spine_physics_constraint_gravity_timeline self);
SPINE_C_API size_t spine_physics_constraint_gravity_timeline_get_frame_entries(spine_physics_constraint_gravity_timeline self);
SPINE_C_API size_t spine_physics_constraint_gravity_timeline_get_frame_count(spine_physics_constraint_gravity_timeline self);
SPINE_C_API spine_array_float spine_physics_constraint_gravity_timeline_get_frames(spine_physics_constraint_gravity_timeline self);

32
spine-c/src/generated/physics_constraint_inertia_timeline.cpp
View File

@ -19,10 +19,10 @@ spine_rtti spine_physics_constraint_inertia_timeline_get_rtti(spine_physics_cons
}
void spine_physics_constraint_inertia_timeline_apply(spine_physics_constraint_inertia_timeline self, spine_skeleton skeleton, float lastTime,
float time, /*@null*/ spine_array_event events, float alpha, spine_mix_blend blend,
spine_mix_direction direction, bool appliedPose) {
float time, /*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add, bool out,
bool appliedPose) {
PhysicsConstraintInertiaTimeline *_self = (PhysicsConstraintInertiaTimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, fromSetup, add, out, appliedPose);
}
int spine_physics_constraint_inertia_timeline_get_constraint_index(spine_physics_constraint_inertia_timeline self) {
@ -46,27 +46,27 @@ float spine_physics_constraint_inertia_timeline_get_curve_value(spine_physics_co
}
float spine_physics_constraint_inertia_timeline_get_relative_value(spine_physics_constraint_inertia_timeline self, float time, float alpha,
spine_mix_blend blend, float current, float setup) {
bool fromSetup, bool add, float current, float setup) {
PhysicsConstraintInertiaTimeline *_self = (PhysicsConstraintInertiaTimeline *) self;
return _self->getRelativeValue(time, alpha, (MixBlend) blend, current, setup);
return _self->getRelativeValue(time, alpha, fromSetup, add, current, setup);
}
float spine_physics_constraint_inertia_timeline_get_absolute_value_1(spine_physics_constraint_inertia_timeline self, float time, float alpha,
spine_mix_blend blend, float current, float setup) {
bool fromSetup, bool add, float current, float setup) {
PhysicsConstraintInertiaTimeline *_self = (PhysicsConstraintInertiaTimeline *) self;
return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup);
return _self->getAbsoluteValue(time, alpha, fromSetup, add, current, setup);
}
float spine_physics_constraint_inertia_timeline_get_absolute_value_2(spine_physics_constraint_inertia_timeline self, float time, float alpha,
spine_mix_blend blend, float current, float setup, float value) {
bool fromSetup, bool add, float current, float setup, float value) {
PhysicsConstraintInertiaTimeline *_self = (PhysicsConstraintInertiaTimeline *) self;
return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup, value);
return _self->getAbsoluteValue(time, alpha, fromSetup, add, current, setup, value);
}
float spine_physics_constraint_inertia_timeline_get_scale_value(spine_physics_constraint_inertia_timeline self, float time, float alpha,
spine_mix_blend blend, spine_mix_direction direction, float current, float setup) {
bool fromSetup, bool add, bool out, float current, float setup) {
PhysicsConstraintInertiaTimeline *_self = (PhysicsConstraintInertiaTimeline *) self;
return _self->getScaleValue(time, alpha, (MixBlend) blend, (MixDirection) direction, current, setup);
return _self->getScaleValue(time, alpha, fromSetup, add, out, current, setup);
}
void spine_physics_constraint_inertia_timeline_set_linear(spine_physics_constraint_inertia_timeline self, size_t frame) {
@ -97,6 +97,16 @@ spine_array_float spine_physics_constraint_inertia_timeline_get_curves(spine_phy
return (spine_array_float) &_self->getCurves();
}
bool spine_physics_constraint_inertia_timeline_get_additive(spine_physics_constraint_inertia_timeline self) {
PhysicsConstraintInertiaTimeline *_self = (PhysicsConstraintInertiaTimeline *) self;
return _self->getAdditive();
}
bool spine_physics_constraint_inertia_timeline_get_instant(spine_physics_constraint_inertia_timeline self) {
PhysicsConstraintInertiaTimeline *_self = (PhysicsConstraintInertiaTimeline *) self;
return _self->getInstant();
}
size_t spine_physics_constraint_inertia_timeline_get_frame_entries(spine_physics_constraint_inertia_timeline self) {
PhysicsConstraintInertiaTimeline *_self = (PhysicsConstraintInertiaTimeline *) self;
return _self->getFrameEntries();

20
spine-c/src/generated/physics_constraint_inertia_timeline.h
View File

@ -17,7 +17,7 @@ SPINE_C_API void spine_physics_constraint_inertia_timeline_dispose(spine_physics
SPINE_C_API spine_rtti spine_physics_constraint_inertia_timeline_get_rtti(spine_physics_constraint_inertia_timeline self);
SPINE_C_API void spine_physics_constraint_inertia_timeline_apply(spine_physics_constraint_inertia_timeline self, spine_skeleton skeleton,
float lastTime, float time, /*@null*/ spine_array_event events, float alpha,
spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
bool fromSetup, bool add, bool out, bool appliedPose);
SPINE_C_API int spine_physics_constraint_inertia_timeline_get_constraint_index(spine_physics_constraint_inertia_timeline self);
SPINE_C_API void spine_physics_constraint_inertia_timeline_set_constraint_index(spine_physics_constraint_inertia_timeline self, int inValue);
/**
@ -33,15 +33,14 @@ SPINE_C_API void spine_physics_constraint_inertia_timeline_set_frame(spine_physi
*/
SPINE_C_API float spine_physics_constraint_inertia_timeline_get_curve_value(spine_physics_constraint_inertia_timeline self, float time);
SPINE_C_API float spine_physics_constraint_inertia_timeline_get_relative_value(spine_physics_constraint_inertia_timeline self, float time,
float alpha, spine_mix_blend blend, float current, float setup);
float alpha, bool fromSetup, bool add, float current, float setup);
SPINE_C_API float spine_physics_constraint_inertia_timeline_get_absolute_value_1(spine_physics_constraint_inertia_timeline self, float time,
float alpha, spine_mix_blend blend, float current, float setup);
float alpha, bool fromSetup, bool add, float current, float setup);
SPINE_C_API float spine_physics_constraint_inertia_timeline_get_absolute_value_2(spine_physics_constraint_inertia_timeline self, float time,
float alpha, spine_mix_blend blend, float current, float setup,
float alpha, bool fromSetup, bool add, float current, float setup,
float value);
SPINE_C_API float spine_physics_constraint_inertia_timeline_get_scale_value(spine_physics_constraint_inertia_timeline self, float time, float alpha,
spine_mix_blend blend, spine_mix_direction direction, float current,
float setup);
bool fromSetup, bool add, bool out, float current, float setup);
SPINE_C_API void spine_physics_constraint_inertia_timeline_set_linear(spine_physics_constraint_inertia_timeline self, size_t frame);
SPINE_C_API void spine_physics_constraint_inertia_timeline_set_stepped(spine_physics_constraint_inertia_timeline self, size_t frame);
SPINE_C_API void spine_physics_constraint_inertia_timeline_set_bezier(spine_physics_constraint_inertia_timeline self, size_t bezier, size_t frame,
@ -50,6 +49,15 @@ SPINE_C_API void spine_physics_constraint_inertia_timeline_set_bezier(spine_phys
SPINE_C_API float spine_physics_constraint_inertia_timeline_get_bezier_value(spine_physics_constraint_inertia_timeline self, float time, size_t frame,
size_t valueOffset, size_t i);
SPINE_C_API spine_array_float spine_physics_constraint_inertia_timeline_get_curves(spine_physics_constraint_inertia_timeline self);
/**
* True if this timeline supports additive blending.
*/
SPINE_C_API bool spine_physics_constraint_inertia_timeline_get_additive(spine_physics_constraint_inertia_timeline self);
/**
* True if this timeline sets values instantaneously and does not support
* interpolation between frames.
*/
SPINE_C_API bool spine_physics_constraint_inertia_timeline_get_instant(spine_physics_constraint_inertia_timeline self);
SPINE_C_API size_t spine_physics_constraint_inertia_timeline_get_frame_entries(spine_physics_constraint_inertia_timeline self);
SPINE_C_API size_t spine_physics_constraint_inertia_timeline_get_frame_count(spine_physics_constraint_inertia_timeline self);
SPINE_C_API spine_array_float spine_physics_constraint_inertia_timeline_get_frames(spine_physics_constraint_inertia_timeline self);

36
spine-c/src/generated/physics_constraint_mass_timeline.cpp
View File

@ -19,10 +19,10 @@ spine_rtti spine_physics_constraint_mass_timeline_get_rtti(spine_physics_constra
}
void spine_physics_constraint_mass_timeline_apply(spine_physics_constraint_mass_timeline self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ spine_array_event events, float alpha, spine_mix_blend blend,
spine_mix_direction direction, bool appliedPose) {
/*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add, bool out,
bool appliedPose) {
PhysicsConstraintMassTimeline *_self = (PhysicsConstraintMassTimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, fromSetup, add, out, appliedPose);
}
int spine_physics_constraint_mass_timeline_get_constraint_index(spine_physics_constraint_mass_timeline self) {
@ -45,28 +45,28 @@ float spine_physics_constraint_mass_timeline_get_curve_value(spine_physics_const
return _self->getCurveValue(time);
}
float spine_physics_constraint_mass_timeline_get_relative_value(spine_physics_constraint_mass_timeline self, float time, float alpha,
spine_mix_blend blend, float current, float setup) {
float spine_physics_constraint_mass_timeline_get_relative_value(spine_physics_constraint_mass_timeline self, float time, float alpha, bool fromSetup,
bool add, float current, float setup) {
PhysicsConstraintMassTimeline *_self = (PhysicsConstraintMassTimeline *) self;
return _self->getRelativeValue(time, alpha, (MixBlend) blend, current, setup);
return _self->getRelativeValue(time, alpha, fromSetup, add, current, setup);
}
float spine_physics_constraint_mass_timeline_get_absolute_value_1(spine_physics_constraint_mass_timeline self, float time, float alpha,
spine_mix_blend blend, float current, float setup) {
bool fromSetup, bool add, float current, float setup) {
PhysicsConstraintMassTimeline *_self = (PhysicsConstraintMassTimeline *) self;
return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup);
return _self->getAbsoluteValue(time, alpha, fromSetup, add, current, setup);
}
float spine_physics_constraint_mass_timeline_get_absolute_value_2(spine_physics_constraint_mass_timeline self, float time, float alpha,
spine_mix_blend blend, float current, float setup, float value) {
bool fromSetup, bool add, float current, float setup, float value) {
PhysicsConstraintMassTimeline *_self = (PhysicsConstraintMassTimeline *) self;
return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup, value);
return _self->getAbsoluteValue(time, alpha, fromSetup, add, current, setup, value);
}
float spine_physics_constraint_mass_timeline_get_scale_value(spine_physics_constraint_mass_timeline self, float time, float alpha,
spine_mix_blend blend, spine_mix_direction direction, float current, float setup) {
float spine_physics_constraint_mass_timeline_get_scale_value(spine_physics_constraint_mass_timeline self, float time, float alpha, bool fromSetup,
bool add, bool out, float current, float setup) {
PhysicsConstraintMassTimeline *_self = (PhysicsConstraintMassTimeline *) self;
return _self->getScaleValue(time, alpha, (MixBlend) blend, (MixDirection) direction, current, setup);
return _self->getScaleValue(time, alpha, fromSetup, add, out, current, setup);
}
void spine_physics_constraint_mass_timeline_set_linear(spine_physics_constraint_mass_timeline self, size_t frame) {
@ -97,6 +97,16 @@ spine_array_float spine_physics_constraint_mass_timeline_get_curves(spine_physic
return (spine_array_float) &_self->getCurves();
}
bool spine_physics_constraint_mass_timeline_get_additive(spine_physics_constraint_mass_timeline self) {
PhysicsConstraintMassTimeline *_self = (PhysicsConstraintMassTimeline *) self;
return _self->getAdditive();
}
bool spine_physics_constraint_mass_timeline_get_instant(spine_physics_constraint_mass_timeline self) {
PhysicsConstraintMassTimeline *_self = (PhysicsConstraintMassTimeline *) self;
return _self->getInstant();
}
size_t spine_physics_constraint_mass_timeline_get_frame_entries(spine_physics_constraint_mass_timeline self) {
PhysicsConstraintMassTimeline *_self = (PhysicsConstraintMassTimeline *) self;
return _self->getFrameEntries();

22
spine-c/src/generated/physics_constraint_mass_timeline.h
View File

@ -16,8 +16,8 @@ SPINE_C_API void spine_physics_constraint_mass_timeline_dispose(spine_physics_co
SPINE_C_API spine_rtti spine_physics_constraint_mass_timeline_get_rtti(spine_physics_constraint_mass_timeline self);
SPINE_C_API void spine_physics_constraint_mass_timeline_apply(spine_physics_constraint_mass_timeline self, spine_skeleton skeleton, float lastTime,
float time, /*@null*/ spine_array_event events, float alpha, spine_mix_blend blend,
spine_mix_direction direction, bool appliedPose);
float time, /*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add,
bool out, bool appliedPose);
SPINE_C_API int spine_physics_constraint_mass_timeline_get_constraint_index(spine_physics_constraint_mass_timeline self);
SPINE_C_API void spine_physics_constraint_mass_timeline_set_constraint_index(spine_physics_constraint_mass_timeline self, int inValue);
/**
@ -32,14 +32,13 @@ SPINE_C_API void spine_physics_constraint_mass_timeline_set_frame(spine_physics_
*/
SPINE_C_API float spine_physics_constraint_mass_timeline_get_curve_value(spine_physics_constraint_mass_timeline self, float time);
SPINE_C_API float spine_physics_constraint_mass_timeline_get_relative_value(spine_physics_constraint_mass_timeline self, float time, float alpha,
spine_mix_blend blend, float current, float setup);
bool fromSetup, bool add, float current, float setup);
SPINE_C_API float spine_physics_constraint_mass_timeline_get_absolute_value_1(spine_physics_constraint_mass_timeline self, float time, float alpha,
spine_mix_blend blend, float current, float setup);
bool fromSetup, bool add, float current, float setup);
SPINE_C_API float spine_physics_constraint_mass_timeline_get_absolute_value_2(spine_physics_constraint_mass_timeline self, float time, float alpha,
spine_mix_blend blend, float current, float setup, float value);
bool fromSetup, bool add, float current, float setup, float value);
SPINE_C_API float spine_physics_constraint_mass_timeline_get_scale_value(spine_physics_constraint_mass_timeline self, float time, float alpha,
spine_mix_blend blend, spine_mix_direction direction, float current,
float setup);
bool fromSetup, bool add, bool out, float current, float setup);
SPINE_C_API void spine_physics_constraint_mass_timeline_set_linear(spine_physics_constraint_mass_timeline self, size_t frame);
SPINE_C_API void spine_physics_constraint_mass_timeline_set_stepped(spine_physics_constraint_mass_timeline self, size_t frame);
SPINE_C_API void spine_physics_constraint_mass_timeline_set_bezier(spine_physics_constraint_mass_timeline self, size_t bezier, size_t frame,
@ -48,6 +47,15 @@ SPINE_C_API void spine_physics_constraint_mass_timeline_set_bezier(spine_physics
SPINE_C_API float spine_physics_constraint_mass_timeline_get_bezier_value(spine_physics_constraint_mass_timeline self, float time, size_t frame,
size_t valueOffset, size_t i);
SPINE_C_API spine_array_float spine_physics_constraint_mass_timeline_get_curves(spine_physics_constraint_mass_timeline self);
/**
* True if this timeline supports additive blending.
*/
SPINE_C_API bool spine_physics_constraint_mass_timeline_get_additive(spine_physics_constraint_mass_timeline self);
/**
* True if this timeline sets values instantaneously and does not support
* interpolation between frames.
*/
SPINE_C_API bool spine_physics_constraint_mass_timeline_get_instant(spine_physics_constraint_mass_timeline self);
SPINE_C_API size_t spine_physics_constraint_mass_timeline_get_frame_entries(spine_physics_constraint_mass_timeline self);
SPINE_C_API size_t spine_physics_constraint_mass_timeline_get_frame_count(spine_physics_constraint_mass_timeline self);
SPINE_C_API spine_array_float spine_physics_constraint_mass_timeline_get_frames(spine_physics_constraint_mass_timeline self);

40
spine-c/src/generated/physics_constraint_mix_timeline.cpp
View File

@ -19,10 +19,10 @@ spine_rtti spine_physics_constraint_mix_timeline_get_rtti(spine_physics_constrai
}
void spine_physics_constraint_mix_timeline_apply(spine_physics_constraint_mix_timeline self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ spine_array_event events, float alpha, spine_mix_blend blend,
spine_mix_direction direction, bool appliedPose) {
/*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add, bool out,
bool appliedPose) {
PhysicsConstraintMixTimeline *_self = (PhysicsConstraintMixTimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, fromSetup, add, out, appliedPose);
}
int spine_physics_constraint_mix_timeline_get_constraint_index(spine_physics_constraint_mix_timeline self) {
@ -45,28 +45,28 @@ float spine_physics_constraint_mix_timeline_get_curve_value(spine_physics_constr
return _self->getCurveValue(time);
}
float spine_physics_constraint_mix_timeline_get_relative_value(spine_physics_constraint_mix_timeline self, float time, float alpha,
spine_mix_blend blend, float current, float setup) {
float spine_physics_constraint_mix_timeline_get_relative_value(spine_physics_constraint_mix_timeline self, float time, float alpha, bool fromSetup,
bool add, float current, float setup) {
PhysicsConstraintMixTimeline *_self = (PhysicsConstraintMixTimeline *) self;
return _self->getRelativeValue(time, alpha, (MixBlend) blend, current, setup);
return _self->getRelativeValue(time, alpha, fromSetup, add, current, setup);
}
float spine_physics_constraint_mix_timeline_get_absolute_value_1(spine_physics_constraint_mix_timeline self, float time, float alpha,
spine_mix_blend blend, float current, float setup) {
float spine_physics_constraint_mix_timeline_get_absolute_value_1(spine_physics_constraint_mix_timeline self, float time, float alpha, bool fromSetup,
bool add, float current, float setup) {
PhysicsConstraintMixTimeline *_self = (PhysicsConstraintMixTimeline *) self;
return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup);
return _self->getAbsoluteValue(time, alpha, fromSetup, add, current, setup);
}
float spine_physics_constraint_mix_timeline_get_absolute_value_2(spine_physics_constraint_mix_timeline self, float time, float alpha,
spine_mix_blend blend, float current, float setup, float value) {
float spine_physics_constraint_mix_timeline_get_absolute_value_2(spine_physics_constraint_mix_timeline self, float time, float alpha, bool fromSetup,
bool add, float current, float setup, float value) {
PhysicsConstraintMixTimeline *_self = (PhysicsConstraintMixTimeline *) self;
return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup, value);
return _self->getAbsoluteValue(time, alpha, fromSetup, add, current, setup, value);
}
float spine_physics_constraint_mix_timeline_get_scale_value(spine_physics_constraint_mix_timeline self, float time, float alpha,
spine_mix_blend blend, spine_mix_direction direction, float current, float setup) {
float spine_physics_constraint_mix_timeline_get_scale_value(spine_physics_constraint_mix_timeline self, float time, float alpha, bool fromSetup,
bool add, bool out, float current, float setup) {
PhysicsConstraintMixTimeline *_self = (PhysicsConstraintMixTimeline *) self;
return _self->getScaleValue(time, alpha, (MixBlend) blend, (MixDirection) direction, current, setup);
return _self->getScaleValue(time, alpha, fromSetup, add, out, current, setup);
}
void spine_physics_constraint_mix_timeline_set_linear(spine_physics_constraint_mix_timeline self, size_t frame) {
@ -97,6 +97,16 @@ spine_array_float spine_physics_constraint_mix_timeline_get_curves(spine_physics
return (spine_array_float) &_self->getCurves();
}
bool spine_physics_constraint_mix_timeline_get_additive(spine_physics_constraint_mix_timeline self) {
PhysicsConstraintMixTimeline *_self = (PhysicsConstraintMixTimeline *) self;
return _self->getAdditive();
}
bool spine_physics_constraint_mix_timeline_get_instant(spine_physics_constraint_mix_timeline self) {
PhysicsConstraintMixTimeline *_self = (PhysicsConstraintMixTimeline *) self;
return _self->getInstant();
}
size_t spine_physics_constraint_mix_timeline_get_frame_entries(spine_physics_constraint_mix_timeline self) {
PhysicsConstraintMixTimeline *_self = (PhysicsConstraintMixTimeline *) self;
return _self->getFrameEntries();

22
spine-c/src/generated/physics_constraint_mix_timeline.h
View File

@ -16,8 +16,8 @@ SPINE_C_API void spine_physics_constraint_mix_timeline_dispose(spine_physics_con
SPINE_C_API spine_rtti spine_physics_constraint_mix_timeline_get_rtti(spine_physics_constraint_mix_timeline self);
SPINE_C_API void spine_physics_constraint_mix_timeline_apply(spine_physics_constraint_mix_timeline self, spine_skeleton skeleton, float lastTime,
float time, /*@null*/ spine_array_event events, float alpha, spine_mix_blend blend,
spine_mix_direction direction, bool appliedPose);
float time, /*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add,
bool out, bool appliedPose);
SPINE_C_API int spine_physics_constraint_mix_timeline_get_constraint_index(spine_physics_constraint_mix_timeline self);
SPINE_C_API void spine_physics_constraint_mix_timeline_set_constraint_index(spine_physics_constraint_mix_timeline self, int inValue);
/**
@ -32,14 +32,13 @@ SPINE_C_API void spine_physics_constraint_mix_timeline_set_frame(spine_physics_c
*/
SPINE_C_API float spine_physics_constraint_mix_timeline_get_curve_value(spine_physics_constraint_mix_timeline self, float time);
SPINE_C_API float spine_physics_constraint_mix_timeline_get_relative_value(spine_physics_constraint_mix_timeline self, float time, float alpha,
spine_mix_blend blend, float current, float setup);
bool fromSetup, bool add, float current, float setup);
SPINE_C_API float spine_physics_constraint_mix_timeline_get_absolute_value_1(spine_physics_constraint_mix_timeline self, float time, float alpha,
spine_mix_blend blend, float current, float setup);
bool fromSetup, bool add, float current, float setup);
SPINE_C_API float spine_physics_constraint_mix_timeline_get_absolute_value_2(spine_physics_constraint_mix_timeline self, float time, float alpha,
spine_mix_blend blend, float current, float setup, float value);
bool fromSetup, bool add, float current, float setup, float value);
SPINE_C_API float spine_physics_constraint_mix_timeline_get_scale_value(spine_physics_constraint_mix_timeline self, float time, float alpha,
spine_mix_blend blend, spine_mix_direction direction, float current,
float setup);
bool fromSetup, bool add, bool out, float current, float setup);
SPINE_C_API void spine_physics_constraint_mix_timeline_set_linear(spine_physics_constraint_mix_timeline self, size_t frame);
SPINE_C_API void spine_physics_constraint_mix_timeline_set_stepped(spine_physics_constraint_mix_timeline self, size_t frame);
SPINE_C_API void spine_physics_constraint_mix_timeline_set_bezier(spine_physics_constraint_mix_timeline self, size_t bezier, size_t frame,
@ -48,6 +47,15 @@ SPINE_C_API void spine_physics_constraint_mix_timeline_set_bezier(spine_physics_
SPINE_C_API float spine_physics_constraint_mix_timeline_get_bezier_value(spine_physics_constraint_mix_timeline self, float time, size_t frame,
size_t valueOffset, size_t i);
SPINE_C_API spine_array_float spine_physics_constraint_mix_timeline_get_curves(spine_physics_constraint_mix_timeline self);
/**
* True if this timeline supports additive blending.
*/
SPINE_C_API bool spine_physics_constraint_mix_timeline_get_additive(spine_physics_constraint_mix_timeline self);
/**
* True if this timeline sets values instantaneously and does not support
* interpolation between frames.
*/
SPINE_C_API bool spine_physics_constraint_mix_timeline_get_instant(spine_physics_constraint_mix_timeline self);
SPINE_C_API size_t spine_physics_constraint_mix_timeline_get_frame_entries(spine_physics_constraint_mix_timeline self);
SPINE_C_API size_t spine_physics_constraint_mix_timeline_get_frame_count(spine_physics_constraint_mix_timeline self);
SPINE_C_API spine_array_float spine_physics_constraint_mix_timeline_get_frames(spine_physics_constraint_mix_timeline self);

16
spine-c/src/generated/physics_constraint_reset_timeline.cpp
View File

@ -17,10 +17,10 @@ spine_rtti spine_physics_constraint_reset_timeline_get_rtti(spine_physics_constr
}
void spine_physics_constraint_reset_timeline_apply(spine_physics_constraint_reset_timeline self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ spine_array_event events, float alpha, spine_mix_blend blend,
spine_mix_direction direction, bool appliedPose) {
/*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add, bool out,
bool appliedPose) {
PhysicsConstraintResetTimeline *_self = (PhysicsConstraintResetTimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, fromSetup, add, out, appliedPose);
}
int spine_physics_constraint_reset_timeline_get_frame_count(spine_physics_constraint_reset_timeline self) {
@ -43,6 +43,16 @@ void spine_physics_constraint_reset_timeline_set_frame(spine_physics_constraint_
_self->setFrame(frame, time);
}
bool spine_physics_constraint_reset_timeline_get_additive(spine_physics_constraint_reset_timeline self) {
PhysicsConstraintResetTimeline *_self = (PhysicsConstraintResetTimeline *) self;
return _self->getAdditive();
}
bool spine_physics_constraint_reset_timeline_get_instant(spine_physics_constraint_reset_timeline self) {
PhysicsConstraintResetTimeline *_self = (PhysicsConstraintResetTimeline *) self;
return _self->getInstant();
}
size_t spine_physics_constraint_reset_timeline_get_frame_entries(spine_physics_constraint_reset_timeline self) {
PhysicsConstraintResetTimeline *_self = (PhysicsConstraintResetTimeline *) self;
return _self->getFrameEntries();

13
spine-c/src/generated/physics_constraint_reset_timeline.h
View File

@ -19,8 +19,8 @@ SPINE_C_API void spine_physics_constraint_reset_timeline_dispose(spine_physics_c
SPINE_C_API spine_rtti spine_physics_constraint_reset_timeline_get_rtti(spine_physics_constraint_reset_timeline self);
SPINE_C_API void spine_physics_constraint_reset_timeline_apply(spine_physics_constraint_reset_timeline self, spine_skeleton skeleton, float lastTime,
float time, /*@null*/ spine_array_event events, float alpha, spine_mix_blend blend,
spine_mix_direction direction, bool appliedPose);
float time, /*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add,
bool out, bool appliedPose);
SPINE_C_API int spine_physics_constraint_reset_timeline_get_frame_count(spine_physics_constraint_reset_timeline self);
SPINE_C_API int spine_physics_constraint_reset_timeline_get_constraint_index(spine_physics_constraint_reset_timeline self);
SPINE_C_API void spine_physics_constraint_reset_timeline_set_constraint_index(spine_physics_constraint_reset_timeline self, int inValue);
@ -28,6 +28,15 @@ SPINE_C_API void spine_physics_constraint_reset_timeline_set_constraint_index(sp
* Sets the time for the specified frame.
*/
SPINE_C_API void spine_physics_constraint_reset_timeline_set_frame(spine_physics_constraint_reset_timeline self, int frame, float time);
/**
* True if this timeline supports additive blending.
*/
SPINE_C_API bool spine_physics_constraint_reset_timeline_get_additive(spine_physics_constraint_reset_timeline self);
/**
* True if this timeline sets values instantaneously and does not support
* interpolation between frames.
*/
SPINE_C_API bool spine_physics_constraint_reset_timeline_get_instant(spine_physics_constraint_reset_timeline self);
SPINE_C_API size_t spine_physics_constraint_reset_timeline_get_frame_entries(spine_physics_constraint_reset_timeline self);
SPINE_C_API spine_array_float spine_physics_constraint_reset_timeline_get_frames(spine_physics_constraint_reset_timeline self);
SPINE_C_API float spine_physics_constraint_reset_timeline_get_duration(spine_physics_constraint_reset_timeline self);

32
spine-c/src/generated/physics_constraint_strength_timeline.cpp
View File

@ -19,10 +19,10 @@ spine_rtti spine_physics_constraint_strength_timeline_get_rtti(spine_physics_con
}
void spine_physics_constraint_strength_timeline_apply(spine_physics_constraint_strength_timeline self, spine_skeleton skeleton, float lastTime,
float time, /*@null*/ spine_array_event events, float alpha, spine_mix_blend blend,
spine_mix_direction direction, bool appliedPose) {
float time, /*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add, bool out,
bool appliedPose) {
PhysicsConstraintStrengthTimeline *_self = (PhysicsConstraintStrengthTimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, fromSetup, add, out, appliedPose);
}
int spine_physics_constraint_strength_timeline_get_constraint_index(spine_physics_constraint_strength_timeline self) {
@ -46,27 +46,27 @@ float spine_physics_constraint_strength_timeline_get_curve_value(spine_physics_c
}
float spine_physics_constraint_strength_timeline_get_relative_value(spine_physics_constraint_strength_timeline self, float time, float alpha,
spine_mix_blend blend, float current, float setup) {
bool fromSetup, bool add, float current, float setup) {
PhysicsConstraintStrengthTimeline *_self = (PhysicsConstraintStrengthTimeline *) self;
return _self->getRelativeValue(time, alpha, (MixBlend) blend, current, setup);
return _self->getRelativeValue(time, alpha, fromSetup, add, current, setup);
}
float spine_physics_constraint_strength_timeline_get_absolute_value_1(spine_physics_constraint_strength_timeline self, float time, float alpha,
spine_mix_blend blend, float current, float setup) {
bool fromSetup, bool add, float current, float setup) {
PhysicsConstraintStrengthTimeline *_self = (PhysicsConstraintStrengthTimeline *) self;
return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup);
return _self->getAbsoluteValue(time, alpha, fromSetup, add, current, setup);
}
float spine_physics_constraint_strength_timeline_get_absolute_value_2(spine_physics_constraint_strength_timeline self, float time, float alpha,
spine_mix_blend blend, float current, float setup, float value) {
bool fromSetup, bool add, float current, float setup, float value) {
PhysicsConstraintStrengthTimeline *_self = (PhysicsConstraintStrengthTimeline *) self;
return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup, value);
return _self->getAbsoluteValue(time, alpha, fromSetup, add, current, setup, value);
}
float spine_physics_constraint_strength_timeline_get_scale_value(spine_physics_constraint_strength_timeline self, float time, float alpha,
spine_mix_blend blend, spine_mix_direction direction, float current, float setup) {
bool fromSetup, bool add, bool out, float current, float setup) {
PhysicsConstraintStrengthTimeline *_self = (PhysicsConstraintStrengthTimeline *) self;
return _self->getScaleValue(time, alpha, (MixBlend) blend, (MixDirection) direction, current, setup);
return _self->getScaleValue(time, alpha, fromSetup, add, out, current, setup);
}
void spine_physics_constraint_strength_timeline_set_linear(spine_physics_constraint_strength_timeline self, size_t frame) {
@ -97,6 +97,16 @@ spine_array_float spine_physics_constraint_strength_timeline_get_curves(spine_ph
return (spine_array_float) &_self->getCurves();
}
bool spine_physics_constraint_strength_timeline_get_additive(spine_physics_constraint_strength_timeline self) {
PhysicsConstraintStrengthTimeline *_self = (PhysicsConstraintStrengthTimeline *) self;
return _self->getAdditive();
}
bool spine_physics_constraint_strength_timeline_get_instant(spine_physics_constraint_strength_timeline self) {
PhysicsConstraintStrengthTimeline *_self = (PhysicsConstraintStrengthTimeline *) self;
return _self->getInstant();
}
size_t spine_physics_constraint_strength_timeline_get_frame_entries(spine_physics_constraint_strength_timeline self) {
PhysicsConstraintStrengthTimeline *_self = (PhysicsConstraintStrengthTimeline *) self;
return _self->getFrameEntries();

20
spine-c/src/generated/physics_constraint_strength_timeline.h
View File

@ -17,7 +17,7 @@ SPINE_C_API void spine_physics_constraint_strength_timeline_dispose(spine_physic
SPINE_C_API spine_rtti spine_physics_constraint_strength_timeline_get_rtti(spine_physics_constraint_strength_timeline self);
SPINE_C_API void spine_physics_constraint_strength_timeline_apply(spine_physics_constraint_strength_timeline self, spine_skeleton skeleton,
float lastTime, float time, /*@null*/ spine_array_event events, float alpha,
spine_mix_blend blend, spine_mix_direction direction, bool appliedPose);
bool fromSetup, bool add, bool out, bool appliedPose);
SPINE_C_API int spine_physics_constraint_strength_timeline_get_constraint_index(spine_physics_constraint_strength_timeline self);
SPINE_C_API void spine_physics_constraint_strength_timeline_set_constraint_index(spine_physics_constraint_strength_timeline self, int inValue);
/**
@ -33,15 +33,14 @@ SPINE_C_API void spine_physics_constraint_strength_timeline_set_frame(spine_phys
*/
SPINE_C_API float spine_physics_constraint_strength_timeline_get_curve_value(spine_physics_constraint_strength_timeline self, float time);
SPINE_C_API float spine_physics_constraint_strength_timeline_get_relative_value(spine_physics_constraint_strength_timeline self, float time,
float alpha, spine_mix_blend blend, float current, float setup);
float alpha, bool fromSetup, bool add, float current, float setup);
SPINE_C_API float spine_physics_constraint_strength_timeline_get_absolute_value_1(spine_physics_constraint_strength_timeline self, float time,
float alpha, spine_mix_blend blend, float current, float setup);
float alpha, bool fromSetup, bool add, float current, float setup);
SPINE_C_API float spine_physics_constraint_strength_timeline_get_absolute_value_2(spine_physics_constraint_strength_timeline self, float time,
float alpha, spine_mix_blend blend, float current, float setup,
float alpha, bool fromSetup, bool add, float current, float setup,
float value);
SPINE_C_API float spine_physics_constraint_strength_timeline_get_scale_value(spine_physics_constraint_strength_timeline self, float time, float alpha,
spine_mix_blend blend, spine_mix_direction direction, float current,
float setup);
bool fromSetup, bool add, bool out, float current, float setup);
SPINE_C_API void spine_physics_constraint_strength_timeline_set_linear(spine_physics_constraint_strength_timeline self, size_t frame);
SPINE_C_API void spine_physics_constraint_strength_timeline_set_stepped(spine_physics_constraint_strength_timeline self, size_t frame);
SPINE_C_API void spine_physics_constraint_strength_timeline_set_bezier(spine_physics_constraint_strength_timeline self, size_t bezier, size_t frame,
@ -50,6 +49,15 @@ SPINE_C_API void spine_physics_constraint_strength_timeline_set_bezier(spine_phy
SPINE_C_API float spine_physics_constraint_strength_timeline_get_bezier_value(spine_physics_constraint_strength_timeline self, float time,
size_t frame, size_t valueOffset, size_t i);
SPINE_C_API spine_array_float spine_physics_constraint_strength_timeline_get_curves(spine_physics_constraint_strength_timeline self);
/**
* True if this timeline supports additive blending.
*/
SPINE_C_API bool spine_physics_constraint_strength_timeline_get_additive(spine_physics_constraint_strength_timeline self);
/**
* True if this timeline sets values instantaneously and does not support
* interpolation between frames.
*/
SPINE_C_API bool spine_physics_constraint_strength_timeline_get_instant(spine_physics_constraint_strength_timeline self);
SPINE_C_API size_t spine_physics_constraint_strength_timeline_get_frame_entries(spine_physics_constraint_strength_timeline self);
SPINE_C_API size_t spine_physics_constraint_strength_timeline_get_frame_count(spine_physics_constraint_strength_timeline self);
SPINE_C_API spine_array_float spine_physics_constraint_strength_timeline_get_frames(spine_physics_constraint_strength_timeline self);

37
spine-c/src/generated/physics_constraint_timeline.cpp
View File

@ -13,10 +13,9 @@ spine_rtti spine_physics_constraint_timeline_get_rtti(spine_physics_constraint_t
}
void spine_physics_constraint_timeline_apply(spine_physics_constraint_timeline self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ spine_array_event events, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose) {
/*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add, bool out, bool appliedPose) {
PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, fromSetup, add, out, appliedPose);
}
int spine_physics_constraint_timeline_get_constraint_index(spine_physics_constraint_timeline self) {
@ -39,28 +38,28 @@ float spine_physics_constraint_timeline_get_curve_value(spine_physics_constraint
return _self->getCurveValue(time);
}
float spine_physics_constraint_timeline_get_relative_value(spine_physics_constraint_timeline self, float time, float alpha, spine_mix_blend blend,
float spine_physics_constraint_timeline_get_relative_value(spine_physics_constraint_timeline self, float time, float alpha, bool fromSetup, bool add,
float current, float setup) {
PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) self;
return _self->getRelativeValue(time, alpha, (MixBlend) blend, current, setup);
return _self->getRelativeValue(time, alpha, fromSetup, add, current, setup);
}
float spine_physics_constraint_timeline_get_absolute_value_1(spine_physics_constraint_timeline self, float time, float alpha, spine_mix_blend blend,
float current, float setup) {
float spine_physics_constraint_timeline_get_absolute_value_1(spine_physics_constraint_timeline self, float time, float alpha, bool fromSetup,
bool add, float current, float setup) {
PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) self;
return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup);
return _self->getAbsoluteValue(time, alpha, fromSetup, add, current, setup);
}
float spine_physics_constraint_timeline_get_absolute_value_2(spine_physics_constraint_timeline self, float time, float alpha, spine_mix_blend blend,
float current, float setup, float value) {
float spine_physics_constraint_timeline_get_absolute_value_2(spine_physics_constraint_timeline self, float time, float alpha, bool fromSetup,
bool add, float current, float setup, float value) {
PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) self;
return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup, value);
return _self->getAbsoluteValue(time, alpha, fromSetup, add, current, setup, value);
}
float spine_physics_constraint_timeline_get_scale_value(spine_physics_constraint_timeline self, float time, float alpha, spine_mix_blend blend,
spine_mix_direction direction, float current, float setup) {
float spine_physics_constraint_timeline_get_scale_value(spine_physics_constraint_timeline self, float time, float alpha, bool fromSetup, bool add,
bool out, float current, float setup) {
PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) self;
return _self->getScaleValue(time, alpha, (MixBlend) blend, (MixDirection) direction, current, setup);
return _self->getScaleValue(time, alpha, fromSetup, add, out, current, setup);
}
void spine_physics_constraint_timeline_set_linear(spine_physics_constraint_timeline self, size_t frame) {
@ -90,6 +89,16 @@ spine_array_float spine_physics_constraint_timeline_get_curves(spine_physics_con
return (spine_array_float) &_self->getCurves();
}
bool spine_physics_constraint_timeline_get_additive(spine_physics_constraint_timeline self) {
PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) self;
return _self->getAdditive();
}
bool spine_physics_constraint_timeline_get_instant(spine_physics_constraint_timeline self) {
PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) self;
return _self->getInstant();
}
size_t spine_physics_constraint_timeline_get_frame_entries(spine_physics_constraint_timeline self) {
PhysicsConstraintTimeline *_self = (PhysicsConstraintTimeline *) self;
return _self->getFrameEntries();

23
spine-c/src/generated/physics_constraint_timeline.h
View File

@ -13,8 +13,8 @@ SPINE_C_API void spine_physics_constraint_timeline_dispose(spine_physics_constra
SPINE_C_API spine_rtti spine_physics_constraint_timeline_get_rtti(spine_physics_constraint_timeline self);
SPINE_C_API void spine_physics_constraint_timeline_apply(spine_physics_constraint_timeline self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ spine_array_event events, float alpha, spine_mix_blend blend,
spine_mix_direction direction, bool appliedPose);
/*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add, bool out,
bool appliedPose);
SPINE_C_API int spine_physics_constraint_timeline_get_constraint_index(spine_physics_constraint_timeline self);
SPINE_C_API void spine_physics_constraint_timeline_set_constraint_index(spine_physics_constraint_timeline self, int inValue);
/**
@ -29,13 +29,13 @@ SPINE_C_API void spine_physics_constraint_timeline_set_frame(spine_physics_const
*/
SPINE_C_API float spine_physics_constraint_timeline_get_curve_value(spine_physics_constraint_timeline self, float time);
SPINE_C_API float spine_physics_constraint_timeline_get_relative_value(spine_physics_constraint_timeline self, float time, float alpha,
spine_mix_blend blend, float current, float setup);
bool fromSetup, bool add, float current, float setup);
SPINE_C_API float spine_physics_constraint_timeline_get_absolute_value_1(spine_physics_constraint_timeline self, float time, float alpha,
spine_mix_blend blend, float current, float setup);
bool fromSetup, bool add, float current, float setup);
SPINE_C_API float spine_physics_constraint_timeline_get_absolute_value_2(spine_physics_constraint_timeline self, float time, float alpha,
spine_mix_blend blend, float current, float setup, float value);
SPINE_C_API float spine_physics_constraint_timeline_get_scale_value(spine_physics_constraint_timeline self, float time, float alpha,
spine_mix_blend blend, spine_mix_direction direction, float current, float setup);
bool fromSetup, bool add, float current, float setup, float value);
SPINE_C_API float spine_physics_constraint_timeline_get_scale_value(spine_physics_constraint_timeline self, float time, float alpha, bool fromSetup,
bool add, bool out, float current, float setup);
SPINE_C_API void spine_physics_constraint_timeline_set_linear(spine_physics_constraint_timeline self, size_t frame);
SPINE_C_API void spine_physics_constraint_timeline_set_stepped(spine_physics_constraint_timeline self, size_t frame);
SPINE_C_API void spine_physics_constraint_timeline_set_bezier(spine_physics_constraint_timeline self, size_t bezier, size_t frame, float value,
@ -44,6 +44,15 @@ SPINE_C_API void spine_physics_constraint_timeline_set_bezier(spine_physics_cons
SPINE_C_API float spine_physics_constraint_timeline_get_bezier_value(spine_physics_constraint_timeline self, float time, size_t frame,
size_t valueOffset, size_t i);
SPINE_C_API spine_array_float spine_physics_constraint_timeline_get_curves(spine_physics_constraint_timeline self);
/**
* True if this timeline supports additive blending.
*/
SPINE_C_API bool spine_physics_constraint_timeline_get_additive(spine_physics_constraint_timeline self);
/**
* True if this timeline sets values instantaneously and does not support
* interpolation between frames.
*/
SPINE_C_API bool spine_physics_constraint_timeline_get_instant(spine_physics_constraint_timeline self);
SPINE_C_API size_t spine_physics_constraint_timeline_get_frame_entries(spine_physics_constraint_timeline self);
SPINE_C_API size_t spine_physics_constraint_timeline_get_frame_count(spine_physics_constraint_timeline self);
SPINE_C_API spine_array_float spine_physics_constraint_timeline_get_frames(spine_physics_constraint_timeline self);

36
spine-c/src/generated/physics_constraint_wind_timeline.cpp
View File

@ -19,10 +19,10 @@ spine_rtti spine_physics_constraint_wind_timeline_get_rtti(spine_physics_constra
}
void spine_physics_constraint_wind_timeline_apply(spine_physics_constraint_wind_timeline self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ spine_array_event events, float alpha, spine_mix_blend blend,
spine_mix_direction direction, bool appliedPose) {
/*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add, bool out,
bool appliedPose) {
PhysicsConstraintWindTimeline *_self = (PhysicsConstraintWindTimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, fromSetup, add, out, appliedPose);
}
int spine_physics_constraint_wind_timeline_get_constraint_index(spine_physics_constraint_wind_timeline self) {
@ -45,28 +45,28 @@ float spine_physics_constraint_wind_timeline_get_curve_value(spine_physics_const
return _self->getCurveValue(time);
}
float spine_physics_constraint_wind_timeline_get_relative_value(spine_physics_constraint_wind_timeline self, float time, float alpha,
spine_mix_blend blend, float current, float setup) {
float spine_physics_constraint_wind_timeline_get_relative_value(spine_physics_constraint_wind_timeline self, float time, float alpha, bool fromSetup,
bool add, float current, float setup) {
PhysicsConstraintWindTimeline *_self = (PhysicsConstraintWindTimeline *) self;
return _self->getRelativeValue(time, alpha, (MixBlend) blend, current, setup);
return _self->getRelativeValue(time, alpha, fromSetup, add, current, setup);
}
float spine_physics_constraint_wind_timeline_get_absolute_value_1(spine_physics_constraint_wind_timeline self, float time, float alpha,
spine_mix_blend blend, float current, float setup) {
bool fromSetup, bool add, float current, float setup) {
PhysicsConstraintWindTimeline *_self = (PhysicsConstraintWindTimeline *) self;
return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup);
return _self->getAbsoluteValue(time, alpha, fromSetup, add, current, setup);
}
float spine_physics_constraint_wind_timeline_get_absolute_value_2(spine_physics_constraint_wind_timeline self, float time, float alpha,
spine_mix_blend blend, float current, float setup, float value) {
bool fromSetup, bool add, float current, float setup, float value) {
PhysicsConstraintWindTimeline *_self = (PhysicsConstraintWindTimeline *) self;
return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup, value);
return _self->getAbsoluteValue(time, alpha, fromSetup, add, current, setup, value);
}
float spine_physics_constraint_wind_timeline_get_scale_value(spine_physics_constraint_wind_timeline self, float time, float alpha,
spine_mix_blend blend, spine_mix_direction direction, float current, float setup) {
float spine_physics_constraint_wind_timeline_get_scale_value(spine_physics_constraint_wind_timeline self, float time, float alpha, bool fromSetup,
bool add, bool out, float current, float setup) {
PhysicsConstraintWindTimeline *_self = (PhysicsConstraintWindTimeline *) self;
return _self->getScaleValue(time, alpha, (MixBlend) blend, (MixDirection) direction, current, setup);
return _self->getScaleValue(time, alpha, fromSetup, add, out, current, setup);
}
void spine_physics_constraint_wind_timeline_set_linear(spine_physics_constraint_wind_timeline self, size_t frame) {
@ -97,6 +97,16 @@ spine_array_float spine_physics_constraint_wind_timeline_get_curves(spine_physic
return (spine_array_float) &_self->getCurves();
}
bool spine_physics_constraint_wind_timeline_get_additive(spine_physics_constraint_wind_timeline self) {
PhysicsConstraintWindTimeline *_self = (PhysicsConstraintWindTimeline *) self;
return _self->getAdditive();
}
bool spine_physics_constraint_wind_timeline_get_instant(spine_physics_constraint_wind_timeline self) {
PhysicsConstraintWindTimeline *_self = (PhysicsConstraintWindTimeline *) self;
return _self->getInstant();
}
size_t spine_physics_constraint_wind_timeline_get_frame_entries(spine_physics_constraint_wind_timeline self) {
PhysicsConstraintWindTimeline *_self = (PhysicsConstraintWindTimeline *) self;
return _self->getFrameEntries();

22
spine-c/src/generated/physics_constraint_wind_timeline.h
View File

@ -16,8 +16,8 @@ SPINE_C_API void spine_physics_constraint_wind_timeline_dispose(spine_physics_co
SPINE_C_API spine_rtti spine_physics_constraint_wind_timeline_get_rtti(spine_physics_constraint_wind_timeline self);
SPINE_C_API void spine_physics_constraint_wind_timeline_apply(spine_physics_constraint_wind_timeline self, spine_skeleton skeleton, float lastTime,
float time, /*@null*/ spine_array_event events, float alpha, spine_mix_blend blend,
spine_mix_direction direction, bool appliedPose);
float time, /*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add,
bool out, bool appliedPose);
SPINE_C_API int spine_physics_constraint_wind_timeline_get_constraint_index(spine_physics_constraint_wind_timeline self);
SPINE_C_API void spine_physics_constraint_wind_timeline_set_constraint_index(spine_physics_constraint_wind_timeline self, int inValue);
/**
@ -32,14 +32,13 @@ SPINE_C_API void spine_physics_constraint_wind_timeline_set_frame(spine_physics_
*/
SPINE_C_API float spine_physics_constraint_wind_timeline_get_curve_value(spine_physics_constraint_wind_timeline self, float time);
SPINE_C_API float spine_physics_constraint_wind_timeline_get_relative_value(spine_physics_constraint_wind_timeline self, float time, float alpha,
spine_mix_blend blend, float current, float setup);
bool fromSetup, bool add, float current, float setup);
SPINE_C_API float spine_physics_constraint_wind_timeline_get_absolute_value_1(spine_physics_constraint_wind_timeline self, float time, float alpha,
spine_mix_blend blend, float current, float setup);
bool fromSetup, bool add, float current, float setup);
SPINE_C_API float spine_physics_constraint_wind_timeline_get_absolute_value_2(spine_physics_constraint_wind_timeline self, float time, float alpha,
spine_mix_blend blend, float current, float setup, float value);
bool fromSetup, bool add, float current, float setup, float value);
SPINE_C_API float spine_physics_constraint_wind_timeline_get_scale_value(spine_physics_constraint_wind_timeline self, float time, float alpha,
spine_mix_blend blend, spine_mix_direction direction, float current,
float setup);
bool fromSetup, bool add, bool out, float current, float setup);
SPINE_C_API void spine_physics_constraint_wind_timeline_set_linear(spine_physics_constraint_wind_timeline self, size_t frame);
SPINE_C_API void spine_physics_constraint_wind_timeline_set_stepped(spine_physics_constraint_wind_timeline self, size_t frame);
SPINE_C_API void spine_physics_constraint_wind_timeline_set_bezier(spine_physics_constraint_wind_timeline self, size_t bezier, size_t frame,
@ -48,6 +47,15 @@ SPINE_C_API void spine_physics_constraint_wind_timeline_set_bezier(spine_physics
SPINE_C_API float spine_physics_constraint_wind_timeline_get_bezier_value(spine_physics_constraint_wind_timeline self, float time, size_t frame,
size_t valueOffset, size_t i);
SPINE_C_API spine_array_float spine_physics_constraint_wind_timeline_get_curves(spine_physics_constraint_wind_timeline self);
/**
* True if this timeline supports additive blending.
*/
SPINE_C_API bool spine_physics_constraint_wind_timeline_get_additive(spine_physics_constraint_wind_timeline self);
/**
* True if this timeline sets values instantaneously and does not support
* interpolation between frames.
*/
SPINE_C_API bool spine_physics_constraint_wind_timeline_get_instant(spine_physics_constraint_wind_timeline self);
SPINE_C_API size_t spine_physics_constraint_wind_timeline_get_frame_entries(spine_physics_constraint_wind_timeline self);
SPINE_C_API size_t spine_physics_constraint_wind_timeline_get_frame_count(spine_physics_constraint_wind_timeline self);
SPINE_C_API spine_array_float spine_physics_constraint_wind_timeline_get_frames(spine_physics_constraint_wind_timeline self);

15
spine-c/src/generated/point_attachment.h
View File

@ -14,14 +14,29 @@ SPINE_C_API spine_point_attachment spine_point_attachment_create(const char *nam
SPINE_C_API void spine_point_attachment_dispose(spine_point_attachment self);
SPINE_C_API spine_rtti spine_point_attachment_get_rtti(spine_point_attachment self);
/**
* The local X position.
*/
SPINE_C_API float spine_point_attachment_get_x(spine_point_attachment self);
SPINE_C_API void spine_point_attachment_set_x(spine_point_attachment self, float inValue);
/**
* The local Y position.
*/
SPINE_C_API float spine_point_attachment_get_y(spine_point_attachment self);
SPINE_C_API void spine_point_attachment_set_y(spine_point_attachment self, float inValue);
/**
* The local rotation in degrees, counter clockwise.
*/
SPINE_C_API float spine_point_attachment_get_rotation(spine_point_attachment self);
SPINE_C_API void spine_point_attachment_set_rotation(spine_point_attachment self, float inValue);
SPINE_C_API spine_color spine_point_attachment_get_color(spine_point_attachment self);
/**
* Computes the world position from the local position.
*/
SPINE_C_API void spine_point_attachment_compute_world_position(spine_point_attachment self, spine_bone_pose bone, float *ox, float *oy);
/**
* Computes the world rotation from the local rotation.
*/
SPINE_C_API float spine_point_attachment_compute_world_rotation(spine_point_attachment self, spine_bone_pose bone);
SPINE_C_API spine_attachment spine_point_attachment_copy(spine_point_attachment self);
SPINE_C_API const char *spine_point_attachment_get_name(spine_point_attachment self);

7
spine-c/src/generated/posed_active.h
View File

@ -11,6 +11,13 @@ extern "C" {
SPINE_C_API void spine_posed_active_dispose(spine_posed_active self);
/**
* Returns false when this won't be updated by
* Skeleton::updateWorldTransform(Physics) because a skin is required and the
* active skin does not contain this item. See Skin::getBones(),
* Skin::getConstraints(), PosedData::getSkinRequired(), and
* Skeleton::updateCache().
*/
SPINE_C_API bool spine_posed_active_is_active(spine_posed_active self);
SPINE_C_API void spine_posed_active_set_active(spine_posed_active self, bool active);

4
spine-c/src/generated/posed_data.h
View File

@ -13,10 +13,6 @@ SPINE_C_API spine_posed_data spine_posed_data_create(const char *name);
SPINE_C_API void spine_posed_data_dispose(spine_posed_data self);
/**
* The constraint's name, which is unique across all constraints in the skeleton
* of the same type.
*/
SPINE_C_API const char *spine_posed_data_get_name(spine_posed_data self);
/**
* When true, Skeleton::updateWorldTransform(Physics) only updates this

3
spine-c/src/generated/region_attachment.h
View File

@ -39,6 +39,9 @@ SPINE_C_API float spine_region_attachment_get_scale_x(spine_region_attachment se
SPINE_C_API void spine_region_attachment_set_scale_x(spine_region_attachment self, float inValue);
SPINE_C_API float spine_region_attachment_get_scale_y(spine_region_attachment self);
SPINE_C_API void spine_region_attachment_set_scale_y(spine_region_attachment self, float inValue);
/**
* The local rotation in degrees, counter clockwise.
*/
SPINE_C_API float spine_region_attachment_get_rotation(spine_region_attachment self);
SPINE_C_API void spine_region_attachment_set_rotation(spine_region_attachment self, float inValue);
SPINE_C_API float spine_region_attachment_get_width(spine_region_attachment self);

14
spine-c/src/generated/rgb2_timeline.cpp
View File

@ -22,9 +22,9 @@ void spine_rgb2_timeline_set_frame(spine_rgb2_timeline self, int frame, float ti
}
void spine_rgb2_timeline_apply(spine_rgb2_timeline self, spine_skeleton skeleton, float lastTime, float time, /*@null*/ spine_array_event events,
float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
float alpha, bool fromSetup, bool add, bool out, bool appliedPose) {
RGB2Timeline *_self = (RGB2Timeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, fromSetup, add, out, appliedPose);
}
int spine_rgb2_timeline_get_slot_index(spine_rgb2_timeline self) {
@ -63,6 +63,16 @@ spine_array_float spine_rgb2_timeline_get_curves(spine_rgb2_timeline self) {
return (spine_array_float) &_self->getCurves();
}
bool spine_rgb2_timeline_get_additive(spine_rgb2_timeline self) {
RGB2Timeline *_self = (RGB2Timeline *) self;
return _self->getAdditive();
}
bool spine_rgb2_timeline_get_instant(spine_rgb2_timeline self) {
RGB2Timeline *_self = (RGB2Timeline *) self;
return _self->getInstant();
}
size_t spine_rgb2_timeline_get_frame_entries(spine_rgb2_timeline self) {
RGB2Timeline *_self = (RGB2Timeline *) self;
return _self->getFrameEntries();

12
spine-c/src/generated/rgb2_timeline.h
View File

@ -23,8 +23,7 @@ SPINE_C_API spine_rtti spine_rgb2_timeline_get_rtti(spine_rgb2_timeline self);
SPINE_C_API void spine_rgb2_timeline_set_frame(spine_rgb2_timeline self, int frame, float time, float r, float g, float b, float r2, float g2,
float b2);
SPINE_C_API void spine_rgb2_timeline_apply(spine_rgb2_timeline self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ spine_array_event events, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose);
/*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add, bool out, bool appliedPose);
SPINE_C_API int spine_rgb2_timeline_get_slot_index(spine_rgb2_timeline self);
SPINE_C_API void spine_rgb2_timeline_set_slot_index(spine_rgb2_timeline self, int inValue);
SPINE_C_API void spine_rgb2_timeline_set_linear(spine_rgb2_timeline self, size_t frame);
@ -33,6 +32,15 @@ SPINE_C_API void spine_rgb2_timeline_set_bezier(spine_rgb2_timeline self, size_t
float cx1, float cy1, float cx2, float cy2, float time2, float value2);
SPINE_C_API float spine_rgb2_timeline_get_bezier_value(spine_rgb2_timeline self, float time, size_t frame, size_t valueOffset, size_t i);
SPINE_C_API spine_array_float spine_rgb2_timeline_get_curves(spine_rgb2_timeline self);
/**
* True if this timeline supports additive blending.
*/
SPINE_C_API bool spine_rgb2_timeline_get_additive(spine_rgb2_timeline self);
/**
* True if this timeline sets values instantaneously and does not support
* interpolation between frames.
*/
SPINE_C_API bool spine_rgb2_timeline_get_instant(spine_rgb2_timeline self);
SPINE_C_API size_t spine_rgb2_timeline_get_frame_entries(spine_rgb2_timeline self);
SPINE_C_API size_t spine_rgb2_timeline_get_frame_count(spine_rgb2_timeline self);
SPINE_C_API spine_array_float spine_rgb2_timeline_get_frames(spine_rgb2_timeline self);

14
spine-c/src/generated/rgb_timeline.cpp
View File

@ -22,9 +22,9 @@ void spine_rgb_timeline_set_frame(spine_rgb_timeline self, int frame, float time
}
void spine_rgb_timeline_apply(spine_rgb_timeline self, spine_skeleton skeleton, float lastTime, float time, /*@null*/ spine_array_event events,
float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
float alpha, bool fromSetup, bool add, bool out, bool appliedPose) {
RGBTimeline *_self = (RGBTimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, fromSetup, add, out, appliedPose);
}
int spine_rgb_timeline_get_slot_index(spine_rgb_timeline self) {
@ -63,6 +63,16 @@ spine_array_float spine_rgb_timeline_get_curves(spine_rgb_timeline self) {
return (spine_array_float) &_self->getCurves();
}
bool spine_rgb_timeline_get_additive(spine_rgb_timeline self) {
RGBTimeline *_self = (RGBTimeline *) self;
return _self->getAdditive();
}
bool spine_rgb_timeline_get_instant(spine_rgb_timeline self) {
RGBTimeline *_self = (RGBTimeline *) self;
return _self->getInstant();
}
size_t spine_rgb_timeline_get_frame_entries(spine_rgb_timeline self) {
RGBTimeline *_self = (RGBTimeline *) self;
return _self->getFrameEntries();

12
spine-c/src/generated/rgb_timeline.h
View File

@ -22,8 +22,7 @@ SPINE_C_API spine_rtti spine_rgb_timeline_get_rtti(spine_rgb_timeline self);
*/
SPINE_C_API void spine_rgb_timeline_set_frame(spine_rgb_timeline self, int frame, float time, float r, float g, float b);
SPINE_C_API void spine_rgb_timeline_apply(spine_rgb_timeline self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ spine_array_event events, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose);
/*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add, bool out, bool appliedPose);
SPINE_C_API int spine_rgb_timeline_get_slot_index(spine_rgb_timeline self);
SPINE_C_API void spine_rgb_timeline_set_slot_index(spine_rgb_timeline self, int inValue);
SPINE_C_API void spine_rgb_timeline_set_linear(spine_rgb_timeline self, size_t frame);
@ -32,6 +31,15 @@ SPINE_C_API void spine_rgb_timeline_set_bezier(spine_rgb_timeline self, size_t b
float cx1, float cy1, float cx2, float cy2, float time2, float value2);
SPINE_C_API float spine_rgb_timeline_get_bezier_value(spine_rgb_timeline self, float time, size_t frame, size_t valueOffset, size_t i);
SPINE_C_API spine_array_float spine_rgb_timeline_get_curves(spine_rgb_timeline self);
/**
* True if this timeline supports additive blending.
*/
SPINE_C_API bool spine_rgb_timeline_get_additive(spine_rgb_timeline self);
/**
* True if this timeline sets values instantaneously and does not support
* interpolation between frames.
*/
SPINE_C_API bool spine_rgb_timeline_get_instant(spine_rgb_timeline self);
SPINE_C_API size_t spine_rgb_timeline_get_frame_entries(spine_rgb_timeline self);
SPINE_C_API size_t spine_rgb_timeline_get_frame_count(spine_rgb_timeline self);
SPINE_C_API spine_array_float spine_rgb_timeline_get_frames(spine_rgb_timeline self);

14
spine-c/src/generated/rgba2_timeline.cpp
View File

@ -23,9 +23,9 @@ void spine_rgba2_timeline_set_frame(spine_rgba2_timeline self, int frame, float
}
void spine_rgba2_timeline_apply(spine_rgba2_timeline self, spine_skeleton skeleton, float lastTime, float time, /*@null*/ spine_array_event events,
float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
float alpha, bool fromSetup, bool add, bool out, bool appliedPose) {
RGBA2Timeline *_self = (RGBA2Timeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, fromSetup, add, out, appliedPose);
}
int spine_rgba2_timeline_get_slot_index(spine_rgba2_timeline self) {
@ -64,6 +64,16 @@ spine_array_float spine_rgba2_timeline_get_curves(spine_rgba2_timeline self) {
return (spine_array_float) &_self->getCurves();
}
bool spine_rgba2_timeline_get_additive(spine_rgba2_timeline self) {
RGBA2Timeline *_self = (RGBA2Timeline *) self;
return _self->getAdditive();
}
bool spine_rgba2_timeline_get_instant(spine_rgba2_timeline self) {
RGBA2Timeline *_self = (RGBA2Timeline *) self;
return _self->getInstant();
}
size_t spine_rgba2_timeline_get_frame_entries(spine_rgba2_timeline self) {
RGBA2Timeline *_self = (RGBA2Timeline *) self;
return _self->getFrameEntries();

12
spine-c/src/generated/rgba2_timeline.h
View File

@ -23,8 +23,7 @@ SPINE_C_API spine_rtti spine_rgba2_timeline_get_rtti(spine_rgba2_timeline self);
SPINE_C_API void spine_rgba2_timeline_set_frame(spine_rgba2_timeline self, int frame, float time, float r, float g, float b, float a, float r2,
float g2, float b2);
SPINE_C_API void spine_rgba2_timeline_apply(spine_rgba2_timeline self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ spine_array_event events, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose);
/*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add, bool out, bool appliedPose);
SPINE_C_API int spine_rgba2_timeline_get_slot_index(spine_rgba2_timeline self);
SPINE_C_API void spine_rgba2_timeline_set_slot_index(spine_rgba2_timeline self, int inValue);
SPINE_C_API void spine_rgba2_timeline_set_linear(spine_rgba2_timeline self, size_t frame);
@ -33,6 +32,15 @@ SPINE_C_API void spine_rgba2_timeline_set_bezier(spine_rgba2_timeline self, size
float cx1, float cy1, float cx2, float cy2, float time2, float value2);
SPINE_C_API float spine_rgba2_timeline_get_bezier_value(spine_rgba2_timeline self, float time, size_t frame, size_t valueOffset, size_t i);
SPINE_C_API spine_array_float spine_rgba2_timeline_get_curves(spine_rgba2_timeline self);
/**
* True if this timeline supports additive blending.
*/
SPINE_C_API bool spine_rgba2_timeline_get_additive(spine_rgba2_timeline self);
/**
* True if this timeline sets values instantaneously and does not support
* interpolation between frames.
*/
SPINE_C_API bool spine_rgba2_timeline_get_instant(spine_rgba2_timeline self);
SPINE_C_API size_t spine_rgba2_timeline_get_frame_entries(spine_rgba2_timeline self);
SPINE_C_API size_t spine_rgba2_timeline_get_frame_count(spine_rgba2_timeline self);
SPINE_C_API spine_array_float spine_rgba2_timeline_get_frames(spine_rgba2_timeline self);

14
spine-c/src/generated/rgba_timeline.cpp
View File

@ -22,9 +22,9 @@ void spine_rgba_timeline_set_frame(spine_rgba_timeline self, int frame, float ti
}
void spine_rgba_timeline_apply(spine_rgba_timeline self, spine_skeleton skeleton, float lastTime, float time, /*@null*/ spine_array_event events,
float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
float alpha, bool fromSetup, bool add, bool out, bool appliedPose) {
RGBATimeline *_self = (RGBATimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, fromSetup, add, out, appliedPose);
}
int spine_rgba_timeline_get_slot_index(spine_rgba_timeline self) {
@ -63,6 +63,16 @@ spine_array_float spine_rgba_timeline_get_curves(spine_rgba_timeline self) {
return (spine_array_float) &_self->getCurves();
}
bool spine_rgba_timeline_get_additive(spine_rgba_timeline self) {
RGBATimeline *_self = (RGBATimeline *) self;
return _self->getAdditive();
}
bool spine_rgba_timeline_get_instant(spine_rgba_timeline self) {
RGBATimeline *_self = (RGBATimeline *) self;
return _self->getInstant();
}
size_t spine_rgba_timeline_get_frame_entries(spine_rgba_timeline self) {
RGBATimeline *_self = (RGBATimeline *) self;
return _self->getFrameEntries();

12
spine-c/src/generated/rgba_timeline.h
View File

@ -22,8 +22,7 @@ SPINE_C_API spine_rtti spine_rgba_timeline_get_rtti(spine_rgba_timeline self);
*/
SPINE_C_API void spine_rgba_timeline_set_frame(spine_rgba_timeline self, int frame, float time, float r, float g, float b, float a);
SPINE_C_API void spine_rgba_timeline_apply(spine_rgba_timeline self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ spine_array_event events, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose);
/*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add, bool out, bool appliedPose);
SPINE_C_API int spine_rgba_timeline_get_slot_index(spine_rgba_timeline self);
SPINE_C_API void spine_rgba_timeline_set_slot_index(spine_rgba_timeline self, int inValue);
SPINE_C_API void spine_rgba_timeline_set_linear(spine_rgba_timeline self, size_t frame);
@ -32,6 +31,15 @@ SPINE_C_API void spine_rgba_timeline_set_bezier(spine_rgba_timeline self, size_t
float cx1, float cy1, float cx2, float cy2, float time2, float value2);
SPINE_C_API float spine_rgba_timeline_get_bezier_value(spine_rgba_timeline self, float time, size_t frame, size_t valueOffset, size_t i);
SPINE_C_API spine_array_float spine_rgba_timeline_get_curves(spine_rgba_timeline self);
/**
* True if this timeline supports additive blending.
*/
SPINE_C_API bool spine_rgba_timeline_get_additive(spine_rgba_timeline self);
/**
* True if this timeline sets values instantaneously and does not support
* interpolation between frames.
*/
SPINE_C_API bool spine_rgba_timeline_get_instant(spine_rgba_timeline self);
SPINE_C_API size_t spine_rgba_timeline_get_frame_entries(spine_rgba_timeline self);
SPINE_C_API size_t spine_rgba_timeline_get_frame_count(spine_rgba_timeline self);
SPINE_C_API spine_array_float spine_rgba_timeline_get_frames(spine_rgba_timeline self);

32
spine-c/src/generated/rotate_timeline.cpp
View File

@ -17,9 +17,9 @@ spine_rtti spine_rotate_timeline_get_rtti(spine_rotate_timeline self) {
}
void spine_rotate_timeline_apply(spine_rotate_timeline self, spine_skeleton skeleton, float lastTime, float time, /*@null*/ spine_array_event events,
float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
float alpha, bool fromSetup, bool add, bool out, bool appliedPose) {
RotateTimeline *_self = (RotateTimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, fromSetup, add, out, appliedPose);
}
int spine_rotate_timeline_get_bone_index(spine_rotate_timeline self) {
@ -42,28 +42,28 @@ float spine_rotate_timeline_get_curve_value(spine_rotate_timeline self, float ti
return _self->getCurveValue(time);
}
float spine_rotate_timeline_get_relative_value(spine_rotate_timeline self, float time, float alpha, spine_mix_blend blend, float current,
float spine_rotate_timeline_get_relative_value(spine_rotate_timeline self, float time, float alpha, bool fromSetup, bool add, float current,
float setup) {
RotateTimeline *_self = (RotateTimeline *) self;
return _self->getRelativeValue(time, alpha, (MixBlend) blend, current, setup);
return _self->getRelativeValue(time, alpha, fromSetup, add, current, setup);
}
float spine_rotate_timeline_get_absolute_value_1(spine_rotate_timeline self, float time, float alpha, spine_mix_blend blend, float current,
float spine_rotate_timeline_get_absolute_value_1(spine_rotate_timeline self, float time, float alpha, bool fromSetup, bool add, float current,
float setup) {
RotateTimeline *_self = (RotateTimeline *) self;
return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup);
return _self->getAbsoluteValue(time, alpha, fromSetup, add, current, setup);
}
float spine_rotate_timeline_get_absolute_value_2(spine_rotate_timeline self, float time, float alpha, spine_mix_blend blend, float current,
float spine_rotate_timeline_get_absolute_value_2(spine_rotate_timeline self, float time, float alpha, bool fromSetup, bool add, float current,
float setup, float value) {
RotateTimeline *_self = (RotateTimeline *) self;
return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup, value);
return _self->getAbsoluteValue(time, alpha, fromSetup, add, current, setup, value);
}
float spine_rotate_timeline_get_scale_value(spine_rotate_timeline self, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction,
float current, float setup) {
float spine_rotate_timeline_get_scale_value(spine_rotate_timeline self, float time, float alpha, bool fromSetup, bool add, bool out, float current,
float setup) {
RotateTimeline *_self = (RotateTimeline *) self;
return _self->getScaleValue(time, alpha, (MixBlend) blend, (MixDirection) direction, current, setup);
return _self->getScaleValue(time, alpha, fromSetup, add, out, current, setup);
}
void spine_rotate_timeline_set_linear(spine_rotate_timeline self, size_t frame) {
@ -92,6 +92,16 @@ spine_array_float spine_rotate_timeline_get_curves(spine_rotate_timeline self) {
return (spine_array_float) &_self->getCurves();
}
bool spine_rotate_timeline_get_additive(spine_rotate_timeline self) {
RotateTimeline *_self = (RotateTimeline *) self;
return _self->getAdditive();
}
bool spine_rotate_timeline_get_instant(spine_rotate_timeline self) {
RotateTimeline *_self = (RotateTimeline *) self;
return _self->getInstant();
}
size_t spine_rotate_timeline_get_frame_entries(spine_rotate_timeline self) {
RotateTimeline *_self = (RotateTimeline *) self;
return _self->getFrameEntries();

24
spine-c/src/generated/rotate_timeline.h
View File

@ -15,8 +15,7 @@ SPINE_C_API void spine_rotate_timeline_dispose(spine_rotate_timeline self);
SPINE_C_API spine_rtti spine_rotate_timeline_get_rtti(spine_rotate_timeline self);
SPINE_C_API void spine_rotate_timeline_apply(spine_rotate_timeline self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ spine_array_event events, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose);
/*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add, bool out, bool appliedPose);
SPINE_C_API int spine_rotate_timeline_get_bone_index(spine_rotate_timeline self);
SPINE_C_API void spine_rotate_timeline_set_bone_index(spine_rotate_timeline self, int inValue);
/**
@ -30,20 +29,29 @@ SPINE_C_API void spine_rotate_timeline_set_frame(spine_rotate_timeline self, siz
* Returns the interpolated value for the specified time.
*/
SPINE_C_API float spine_rotate_timeline_get_curve_value(spine_rotate_timeline self, float time);
SPINE_C_API float spine_rotate_timeline_get_relative_value(spine_rotate_timeline self, float time, float alpha, spine_mix_blend blend, float current,
float setup);
SPINE_C_API float spine_rotate_timeline_get_absolute_value_1(spine_rotate_timeline self, float time, float alpha, spine_mix_blend blend,
SPINE_C_API float spine_rotate_timeline_get_relative_value(spine_rotate_timeline self, float time, float alpha, bool fromSetup, bool add,
float current, float setup);
SPINE_C_API float spine_rotate_timeline_get_absolute_value_1(spine_rotate_timeline self, float time, float alpha, bool fromSetup, bool add,
float current, float setup);
SPINE_C_API float spine_rotate_timeline_get_absolute_value_2(spine_rotate_timeline self, float time, float alpha, spine_mix_blend blend,
SPINE_C_API float spine_rotate_timeline_get_absolute_value_2(spine_rotate_timeline self, float time, float alpha, bool fromSetup, bool add,
float current, float setup, float value);
SPINE_C_API float spine_rotate_timeline_get_scale_value(spine_rotate_timeline self, float time, float alpha, spine_mix_blend blend,
spine_mix_direction direction, float current, float setup);
SPINE_C_API float spine_rotate_timeline_get_scale_value(spine_rotate_timeline self, float time, float alpha, bool fromSetup, bool add, bool out,
float current, float setup);
SPINE_C_API void spine_rotate_timeline_set_linear(spine_rotate_timeline self, size_t frame);
SPINE_C_API void spine_rotate_timeline_set_stepped(spine_rotate_timeline self, size_t frame);
SPINE_C_API void spine_rotate_timeline_set_bezier(spine_rotate_timeline self, size_t bezier, size_t frame, float value, float time1, float value1,
float cx1, float cy1, float cx2, float cy2, float time2, float value2);
SPINE_C_API float spine_rotate_timeline_get_bezier_value(spine_rotate_timeline self, float time, size_t frame, size_t valueOffset, size_t i);
SPINE_C_API spine_array_float spine_rotate_timeline_get_curves(spine_rotate_timeline self);
/**
* True if this timeline supports additive blending.
*/
SPINE_C_API bool spine_rotate_timeline_get_additive(spine_rotate_timeline self);
/**
* True if this timeline sets values instantaneously and does not support
* interpolation between frames.
*/
SPINE_C_API bool spine_rotate_timeline_get_instant(spine_rotate_timeline self);
SPINE_C_API size_t spine_rotate_timeline_get_frame_entries(spine_rotate_timeline self);
SPINE_C_API size_t spine_rotate_timeline_get_frame_count(spine_rotate_timeline self);
SPINE_C_API spine_array_float spine_rotate_timeline_get_frames(spine_rotate_timeline self);

14
spine-c/src/generated/scale_timeline.cpp
View File

@ -17,9 +17,9 @@ spine_rtti spine_scale_timeline_get_rtti(spine_scale_timeline self) {
}
void spine_scale_timeline_apply(spine_scale_timeline self, spine_skeleton skeleton, float lastTime, float time, /*@null*/ spine_array_event events,
float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
float alpha, bool fromSetup, bool add, bool out, bool appliedPose) {
ScaleTimeline *_self = (ScaleTimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, fromSetup, add, out, appliedPose);
}
int spine_scale_timeline_get_bone_index(spine_scale_timeline self) {
@ -63,6 +63,16 @@ spine_array_float spine_scale_timeline_get_curves(spine_scale_timeline self) {
return (spine_array_float) &_self->getCurves();
}
bool spine_scale_timeline_get_additive(spine_scale_timeline self) {
ScaleTimeline *_self = (ScaleTimeline *) self;
return _self->getAdditive();
}
bool spine_scale_timeline_get_instant(spine_scale_timeline self) {
ScaleTimeline *_self = (ScaleTimeline *) self;
return _self->getInstant();
}
size_t spine_scale_timeline_get_frame_entries(spine_scale_timeline self) {
ScaleTimeline *_self = (ScaleTimeline *) self;
return _self->getFrameEntries();

12
spine-c/src/generated/scale_timeline.h
View File

@ -15,8 +15,7 @@ SPINE_C_API void spine_scale_timeline_dispose(spine_scale_timeline self);
SPINE_C_API spine_rtti spine_scale_timeline_get_rtti(spine_scale_timeline self);
SPINE_C_API void spine_scale_timeline_apply(spine_scale_timeline self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ spine_array_event events, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose);
/*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add, bool out, bool appliedPose);
SPINE_C_API int spine_scale_timeline_get_bone_index(spine_scale_timeline self);
SPINE_C_API void spine_scale_timeline_set_bone_index(spine_scale_timeline self, int inValue);
SPINE_C_API void spine_scale_timeline_set_frame(spine_scale_timeline self, size_t frame, float time, float value1, float value2);
@ -26,6 +25,15 @@ SPINE_C_API void spine_scale_timeline_set_bezier(spine_scale_timeline self, size
float cx1, float cy1, float cx2, float cy2, float time2, float value2);
SPINE_C_API float spine_scale_timeline_get_bezier_value(spine_scale_timeline self, float time, size_t frame, size_t valueOffset, size_t i);
SPINE_C_API spine_array_float spine_scale_timeline_get_curves(spine_scale_timeline self);
/**
* True if this timeline supports additive blending.
*/
SPINE_C_API bool spine_scale_timeline_get_additive(spine_scale_timeline self);
/**
* True if this timeline sets values instantaneously and does not support
* interpolation between frames.
*/
SPINE_C_API bool spine_scale_timeline_get_instant(spine_scale_timeline self);
SPINE_C_API size_t spine_scale_timeline_get_frame_entries(spine_scale_timeline self);
SPINE_C_API size_t spine_scale_timeline_get_frame_count(spine_scale_timeline self);
SPINE_C_API spine_array_float spine_scale_timeline_get_frames(spine_scale_timeline self);

33
spine-c/src/generated/scale_x_timeline.cpp
View File

@ -17,10 +17,9 @@ spine_rtti spine_scale_x_timeline_get_rtti(spine_scale_x_timeline self) {
}
void spine_scale_x_timeline_apply(spine_scale_x_timeline self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ spine_array_event events, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose) {
/*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add, bool out, bool appliedPose) {
ScaleXTimeline *_self = (ScaleXTimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, fromSetup, add, out, appliedPose);
}
int spine_scale_x_timeline_get_bone_index(spine_scale_x_timeline self) {
@ -43,28 +42,28 @@ float spine_scale_x_timeline_get_curve_value(spine_scale_x_timeline self, float
return _self->getCurveValue(time);
}
float spine_scale_x_timeline_get_relative_value(spine_scale_x_timeline self, float time, float alpha, spine_mix_blend blend, float current,
float spine_scale_x_timeline_get_relative_value(spine_scale_x_timeline self, float time, float alpha, bool fromSetup, bool add, float current,
float setup) {
ScaleXTimeline *_self = (ScaleXTimeline *) self;
return _self->getRelativeValue(time, alpha, (MixBlend) blend, current, setup);
return _self->getRelativeValue(time, alpha, fromSetup, add, current, setup);
}
float spine_scale_x_timeline_get_absolute_value_1(spine_scale_x_timeline self, float time, float alpha, spine_mix_blend blend, float current,
float spine_scale_x_timeline_get_absolute_value_1(spine_scale_x_timeline self, float time, float alpha, bool fromSetup, bool add, float current,
float setup) {
ScaleXTimeline *_self = (ScaleXTimeline *) self;
return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup);
return _self->getAbsoluteValue(time, alpha, fromSetup, add, current, setup);
}
float spine_scale_x_timeline_get_absolute_value_2(spine_scale_x_timeline self, float time, float alpha, spine_mix_blend blend, float current,
float spine_scale_x_timeline_get_absolute_value_2(spine_scale_x_timeline self, float time, float alpha, bool fromSetup, bool add, float current,
float setup, float value) {
ScaleXTimeline *_self = (ScaleXTimeline *) self;
return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup, value);
return _self->getAbsoluteValue(time, alpha, fromSetup, add, current, setup, value);
}
float spine_scale_x_timeline_get_scale_value(spine_scale_x_timeline self, float time, float alpha, spine_mix_blend blend,
spine_mix_direction direction, float current, float setup) {
float spine_scale_x_timeline_get_scale_value(spine_scale_x_timeline self, float time, float alpha, bool fromSetup, bool add, bool out, float current,
float setup) {
ScaleXTimeline *_self = (ScaleXTimeline *) self;
return _self->getScaleValue(time, alpha, (MixBlend) blend, (MixDirection) direction, current, setup);
return _self->getScaleValue(time, alpha, fromSetup, add, out, current, setup);
}
void spine_scale_x_timeline_set_linear(spine_scale_x_timeline self, size_t frame) {
@ -93,6 +92,16 @@ spine_array_float spine_scale_x_timeline_get_curves(spine_scale_x_timeline self)
return (spine_array_float) &_self->getCurves();
}
bool spine_scale_x_timeline_get_additive(spine_scale_x_timeline self) {
ScaleXTimeline *_self = (ScaleXTimeline *) self;
return _self->getAdditive();
}
bool spine_scale_x_timeline_get_instant(spine_scale_x_timeline self) {
ScaleXTimeline *_self = (ScaleXTimeline *) self;
return _self->getInstant();
}
size_t spine_scale_x_timeline_get_frame_entries(spine_scale_x_timeline self) {
ScaleXTimeline *_self = (ScaleXTimeline *) self;
return _self->getFrameEntries();

22
spine-c/src/generated/scale_x_timeline.h
View File

@ -15,8 +15,7 @@ SPINE_C_API void spine_scale_x_timeline_dispose(spine_scale_x_timeline self);
SPINE_C_API spine_rtti spine_scale_x_timeline_get_rtti(spine_scale_x_timeline self);
SPINE_C_API void spine_scale_x_timeline_apply(spine_scale_x_timeline self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ spine_array_event events, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose);
/*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add, bool out, bool appliedPose);
SPINE_C_API int spine_scale_x_timeline_get_bone_index(spine_scale_x_timeline self);
SPINE_C_API void spine_scale_x_timeline_set_bone_index(spine_scale_x_timeline self, int inValue);
/**
@ -30,20 +29,29 @@ SPINE_C_API void spine_scale_x_timeline_set_frame(spine_scale_x_timeline self, s
* Returns the interpolated value for the specified time.
*/
SPINE_C_API float spine_scale_x_timeline_get_curve_value(spine_scale_x_timeline self, float time);
SPINE_C_API float spine_scale_x_timeline_get_relative_value(spine_scale_x_timeline self, float time, float alpha, spine_mix_blend blend,
SPINE_C_API float spine_scale_x_timeline_get_relative_value(spine_scale_x_timeline self, float time, float alpha, bool fromSetup, bool add,
float current, float setup);
SPINE_C_API float spine_scale_x_timeline_get_absolute_value_1(spine_scale_x_timeline self, float time, float alpha, spine_mix_blend blend,
SPINE_C_API float spine_scale_x_timeline_get_absolute_value_1(spine_scale_x_timeline self, float time, float alpha, bool fromSetup, bool add,
float current, float setup);
SPINE_C_API float spine_scale_x_timeline_get_absolute_value_2(spine_scale_x_timeline self, float time, float alpha, spine_mix_blend blend,
SPINE_C_API float spine_scale_x_timeline_get_absolute_value_2(spine_scale_x_timeline self, float time, float alpha, bool fromSetup, bool add,
float current, float setup, float value);
SPINE_C_API float spine_scale_x_timeline_get_scale_value(spine_scale_x_timeline self, float time, float alpha, spine_mix_blend blend,
spine_mix_direction direction, float current, float setup);
SPINE_C_API float spine_scale_x_timeline_get_scale_value(spine_scale_x_timeline self, float time, float alpha, bool fromSetup, bool add, bool out,
float current, float setup);
SPINE_C_API void spine_scale_x_timeline_set_linear(spine_scale_x_timeline self, size_t frame);
SPINE_C_API void spine_scale_x_timeline_set_stepped(spine_scale_x_timeline self, size_t frame);
SPINE_C_API void spine_scale_x_timeline_set_bezier(spine_scale_x_timeline self, size_t bezier, size_t frame, float value, float time1, float value1,
float cx1, float cy1, float cx2, float cy2, float time2, float value2);
SPINE_C_API float spine_scale_x_timeline_get_bezier_value(spine_scale_x_timeline self, float time, size_t frame, size_t valueOffset, size_t i);
SPINE_C_API spine_array_float spine_scale_x_timeline_get_curves(spine_scale_x_timeline self);
/**
* True if this timeline supports additive blending.
*/
SPINE_C_API bool spine_scale_x_timeline_get_additive(spine_scale_x_timeline self);
/**
* True if this timeline sets values instantaneously and does not support
* interpolation between frames.
*/
SPINE_C_API bool spine_scale_x_timeline_get_instant(spine_scale_x_timeline self);
SPINE_C_API size_t spine_scale_x_timeline_get_frame_entries(spine_scale_x_timeline self);
SPINE_C_API size_t spine_scale_x_timeline_get_frame_count(spine_scale_x_timeline self);
SPINE_C_API spine_array_float spine_scale_x_timeline_get_frames(spine_scale_x_timeline self);

33
spine-c/src/generated/scale_y_timeline.cpp
View File

@ -17,10 +17,9 @@ spine_rtti spine_scale_y_timeline_get_rtti(spine_scale_y_timeline self) {
}
void spine_scale_y_timeline_apply(spine_scale_y_timeline self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ spine_array_event events, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose) {
/*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add, bool out, bool appliedPose) {
ScaleYTimeline *_self = (ScaleYTimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, fromSetup, add, out, appliedPose);
}
int spine_scale_y_timeline_get_bone_index(spine_scale_y_timeline self) {
@ -43,28 +42,28 @@ float spine_scale_y_timeline_get_curve_value(spine_scale_y_timeline self, float
return _self->getCurveValue(time);
}
float spine_scale_y_timeline_get_relative_value(spine_scale_y_timeline self, float time, float alpha, spine_mix_blend blend, float current,
float spine_scale_y_timeline_get_relative_value(spine_scale_y_timeline self, float time, float alpha, bool fromSetup, bool add, float current,
float setup) {
ScaleYTimeline *_self = (ScaleYTimeline *) self;
return _self->getRelativeValue(time, alpha, (MixBlend) blend, current, setup);
return _self->getRelativeValue(time, alpha, fromSetup, add, current, setup);
}
float spine_scale_y_timeline_get_absolute_value_1(spine_scale_y_timeline self, float time, float alpha, spine_mix_blend blend, float current,
float spine_scale_y_timeline_get_absolute_value_1(spine_scale_y_timeline self, float time, float alpha, bool fromSetup, bool add, float current,
float setup) {
ScaleYTimeline *_self = (ScaleYTimeline *) self;
return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup);
return _self->getAbsoluteValue(time, alpha, fromSetup, add, current, setup);
}
float spine_scale_y_timeline_get_absolute_value_2(spine_scale_y_timeline self, float time, float alpha, spine_mix_blend blend, float current,
float spine_scale_y_timeline_get_absolute_value_2(spine_scale_y_timeline self, float time, float alpha, bool fromSetup, bool add, float current,
float setup, float value) {
ScaleYTimeline *_self = (ScaleYTimeline *) self;
return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup, value);
return _self->getAbsoluteValue(time, alpha, fromSetup, add, current, setup, value);
}
float spine_scale_y_timeline_get_scale_value(spine_scale_y_timeline self, float time, float alpha, spine_mix_blend blend,
spine_mix_direction direction, float current, float setup) {
float spine_scale_y_timeline_get_scale_value(spine_scale_y_timeline self, float time, float alpha, bool fromSetup, bool add, bool out, float current,
float setup) {
ScaleYTimeline *_self = (ScaleYTimeline *) self;
return _self->getScaleValue(time, alpha, (MixBlend) blend, (MixDirection) direction, current, setup);
return _self->getScaleValue(time, alpha, fromSetup, add, out, current, setup);
}
void spine_scale_y_timeline_set_linear(spine_scale_y_timeline self, size_t frame) {
@ -93,6 +92,16 @@ spine_array_float spine_scale_y_timeline_get_curves(spine_scale_y_timeline self)
return (spine_array_float) &_self->getCurves();
}
bool spine_scale_y_timeline_get_additive(spine_scale_y_timeline self) {
ScaleYTimeline *_self = (ScaleYTimeline *) self;
return _self->getAdditive();
}
bool spine_scale_y_timeline_get_instant(spine_scale_y_timeline self) {
ScaleYTimeline *_self = (ScaleYTimeline *) self;
return _self->getInstant();
}
size_t spine_scale_y_timeline_get_frame_entries(spine_scale_y_timeline self) {
ScaleYTimeline *_self = (ScaleYTimeline *) self;
return _self->getFrameEntries();

22
spine-c/src/generated/scale_y_timeline.h
View File

@ -15,8 +15,7 @@ SPINE_C_API void spine_scale_y_timeline_dispose(spine_scale_y_timeline self);
SPINE_C_API spine_rtti spine_scale_y_timeline_get_rtti(spine_scale_y_timeline self);
SPINE_C_API void spine_scale_y_timeline_apply(spine_scale_y_timeline self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ spine_array_event events, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose);
/*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add, bool out, bool appliedPose);
SPINE_C_API int spine_scale_y_timeline_get_bone_index(spine_scale_y_timeline self);
SPINE_C_API void spine_scale_y_timeline_set_bone_index(spine_scale_y_timeline self, int inValue);
/**
@ -30,20 +29,29 @@ SPINE_C_API void spine_scale_y_timeline_set_frame(spine_scale_y_timeline self, s
* Returns the interpolated value for the specified time.
*/
SPINE_C_API float spine_scale_y_timeline_get_curve_value(spine_scale_y_timeline self, float time);
SPINE_C_API float spine_scale_y_timeline_get_relative_value(spine_scale_y_timeline self, float time, float alpha, spine_mix_blend blend,
SPINE_C_API float spine_scale_y_timeline_get_relative_value(spine_scale_y_timeline self, float time, float alpha, bool fromSetup, bool add,
float current, float setup);
SPINE_C_API float spine_scale_y_timeline_get_absolute_value_1(spine_scale_y_timeline self, float time, float alpha, spine_mix_blend blend,
SPINE_C_API float spine_scale_y_timeline_get_absolute_value_1(spine_scale_y_timeline self, float time, float alpha, bool fromSetup, bool add,
float current, float setup);
SPINE_C_API float spine_scale_y_timeline_get_absolute_value_2(spine_scale_y_timeline self, float time, float alpha, spine_mix_blend blend,
SPINE_C_API float spine_scale_y_timeline_get_absolute_value_2(spine_scale_y_timeline self, float time, float alpha, bool fromSetup, bool add,
float current, float setup, float value);
SPINE_C_API float spine_scale_y_timeline_get_scale_value(spine_scale_y_timeline self, float time, float alpha, spine_mix_blend blend,
spine_mix_direction direction, float current, float setup);
SPINE_C_API float spine_scale_y_timeline_get_scale_value(spine_scale_y_timeline self, float time, float alpha, bool fromSetup, bool add, bool out,
float current, float setup);
SPINE_C_API void spine_scale_y_timeline_set_linear(spine_scale_y_timeline self, size_t frame);
SPINE_C_API void spine_scale_y_timeline_set_stepped(spine_scale_y_timeline self, size_t frame);
SPINE_C_API void spine_scale_y_timeline_set_bezier(spine_scale_y_timeline self, size_t bezier, size_t frame, float value, float time1, float value1,
float cx1, float cy1, float cx2, float cy2, float time2, float value2);
SPINE_C_API float spine_scale_y_timeline_get_bezier_value(spine_scale_y_timeline self, float time, size_t frame, size_t valueOffset, size_t i);
SPINE_C_API spine_array_float spine_scale_y_timeline_get_curves(spine_scale_y_timeline self);
/**
* True if this timeline supports additive blending.
*/
SPINE_C_API bool spine_scale_y_timeline_get_additive(spine_scale_y_timeline self);
/**
* True if this timeline sets values instantaneously and does not support
* interpolation between frames.
*/
SPINE_C_API bool spine_scale_y_timeline_get_instant(spine_scale_y_timeline self);
SPINE_C_API size_t spine_scale_y_timeline_get_frame_entries(spine_scale_y_timeline self);
SPINE_C_API size_t spine_scale_y_timeline_get_frame_count(spine_scale_y_timeline self);
SPINE_C_API spine_array_float spine_scale_y_timeline_get_frames(spine_scale_y_timeline self);

15
spine-c/src/generated/sequence_timeline.cpp
View File

@ -17,10 +17,9 @@ spine_rtti spine_sequence_timeline_get_rtti(spine_sequence_timeline self) {
}
void spine_sequence_timeline_apply(spine_sequence_timeline self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ spine_array_event events, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose) {
/*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add, bool out, bool appliedPose) {
SequenceTimeline *_self = (SequenceTimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, fromSetup, add, out, appliedPose);
}
void spine_sequence_timeline_set_frame(spine_sequence_timeline self, int frame, float time, spine_sequence_mode mode, int index, float delay) {
@ -43,6 +42,16 @@ void spine_sequence_timeline_set_slot_index(spine_sequence_timeline self, int in
_self->setSlotIndex(inValue);
}
bool spine_sequence_timeline_get_additive(spine_sequence_timeline self) {
SequenceTimeline *_self = (SequenceTimeline *) self;
return _self->getAdditive();
}
bool spine_sequence_timeline_get_instant(spine_sequence_timeline self) {
SequenceTimeline *_self = (SequenceTimeline *) self;
return _self->getInstant();
}
size_t spine_sequence_timeline_get_frame_entries(spine_sequence_timeline self) {
SequenceTimeline *_self = (SequenceTimeline *) self;
return _self->getFrameEntries();

12
spine-c/src/generated/sequence_timeline.h
View File

@ -15,8 +15,7 @@ SPINE_C_API void spine_sequence_timeline_dispose(spine_sequence_timeline self);
SPINE_C_API spine_rtti spine_sequence_timeline_get_rtti(spine_sequence_timeline self);
SPINE_C_API void spine_sequence_timeline_apply(spine_sequence_timeline self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ spine_array_event events, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose);
/*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add, bool out, bool appliedPose);
/**
* Sets the time, mode, index, and frame time for the specified frame.
*
@ -28,6 +27,15 @@ SPINE_C_API void spine_sequence_timeline_set_frame(spine_sequence_timeline self,
SPINE_C_API spine_attachment spine_sequence_timeline_get_attachment(spine_sequence_timeline self);
SPINE_C_API int spine_sequence_timeline_get_slot_index(spine_sequence_timeline self);
SPINE_C_API void spine_sequence_timeline_set_slot_index(spine_sequence_timeline self, int inValue);
/**
* True if this timeline supports additive blending.
*/
SPINE_C_API bool spine_sequence_timeline_get_additive(spine_sequence_timeline self);
/**
* True if this timeline sets values instantaneously and does not support
* interpolation between frames.
*/
SPINE_C_API bool spine_sequence_timeline_get_instant(spine_sequence_timeline self);
SPINE_C_API size_t spine_sequence_timeline_get_frame_entries(spine_sequence_timeline self);
SPINE_C_API size_t spine_sequence_timeline_get_frame_count(spine_sequence_timeline self);
SPINE_C_API spine_array_float spine_sequence_timeline_get_frames(spine_sequence_timeline self);

14
spine-c/src/generated/shear_timeline.cpp
View File

@ -17,9 +17,9 @@ spine_rtti spine_shear_timeline_get_rtti(spine_shear_timeline self) {
}
void spine_shear_timeline_apply(spine_shear_timeline self, spine_skeleton skeleton, float lastTime, float time, /*@null*/ spine_array_event events,
float alpha, spine_mix_blend blend, spine_mix_direction direction, bool appliedPose) {
float alpha, bool fromSetup, bool add, bool out, bool appliedPose) {
ShearTimeline *_self = (ShearTimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, fromSetup, add, out, appliedPose);
}
int spine_shear_timeline_get_bone_index(spine_shear_timeline self) {
@ -63,6 +63,16 @@ spine_array_float spine_shear_timeline_get_curves(spine_shear_timeline self) {
return (spine_array_float) &_self->getCurves();
}
bool spine_shear_timeline_get_additive(spine_shear_timeline self) {
ShearTimeline *_self = (ShearTimeline *) self;
return _self->getAdditive();
}
bool spine_shear_timeline_get_instant(spine_shear_timeline self) {
ShearTimeline *_self = (ShearTimeline *) self;
return _self->getInstant();
}
size_t spine_shear_timeline_get_frame_entries(spine_shear_timeline self) {
ShearTimeline *_self = (ShearTimeline *) self;
return _self->getFrameEntries();

12
spine-c/src/generated/shear_timeline.h
View File

@ -15,8 +15,7 @@ SPINE_C_API void spine_shear_timeline_dispose(spine_shear_timeline self);
SPINE_C_API spine_rtti spine_shear_timeline_get_rtti(spine_shear_timeline self);
SPINE_C_API void spine_shear_timeline_apply(spine_shear_timeline self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ spine_array_event events, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose);
/*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add, bool out, bool appliedPose);
SPINE_C_API int spine_shear_timeline_get_bone_index(spine_shear_timeline self);
SPINE_C_API void spine_shear_timeline_set_bone_index(spine_shear_timeline self, int inValue);
SPINE_C_API void spine_shear_timeline_set_frame(spine_shear_timeline self, size_t frame, float time, float value1, float value2);
@ -26,6 +25,15 @@ SPINE_C_API void spine_shear_timeline_set_bezier(spine_shear_timeline self, size
float cx1, float cy1, float cx2, float cy2, float time2, float value2);
SPINE_C_API float spine_shear_timeline_get_bezier_value(spine_shear_timeline self, float time, size_t frame, size_t valueOffset, size_t i);
SPINE_C_API spine_array_float spine_shear_timeline_get_curves(spine_shear_timeline self);
/**
* True if this timeline supports additive blending.
*/
SPINE_C_API bool spine_shear_timeline_get_additive(spine_shear_timeline self);
/**
* True if this timeline sets values instantaneously and does not support
* interpolation between frames.
*/
SPINE_C_API bool spine_shear_timeline_get_instant(spine_shear_timeline self);
SPINE_C_API size_t spine_shear_timeline_get_frame_entries(spine_shear_timeline self);
SPINE_C_API size_t spine_shear_timeline_get_frame_count(spine_shear_timeline self);
SPINE_C_API spine_array_float spine_shear_timeline_get_frames(spine_shear_timeline self);

33
spine-c/src/generated/shear_x_timeline.cpp
View File

@ -17,10 +17,9 @@ spine_rtti spine_shear_x_timeline_get_rtti(spine_shear_x_timeline self) {
}
void spine_shear_x_timeline_apply(spine_shear_x_timeline self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ spine_array_event events, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose) {
/*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add, bool out, bool appliedPose) {
ShearXTimeline *_self = (ShearXTimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, fromSetup, add, out, appliedPose);
}
int spine_shear_x_timeline_get_bone_index(spine_shear_x_timeline self) {
@ -43,28 +42,28 @@ float spine_shear_x_timeline_get_curve_value(spine_shear_x_timeline self, float
return _self->getCurveValue(time);
}
float spine_shear_x_timeline_get_relative_value(spine_shear_x_timeline self, float time, float alpha, spine_mix_blend blend, float current,
float spine_shear_x_timeline_get_relative_value(spine_shear_x_timeline self, float time, float alpha, bool fromSetup, bool add, float current,
float setup) {
ShearXTimeline *_self = (ShearXTimeline *) self;
return _self->getRelativeValue(time, alpha, (MixBlend) blend, current, setup);
return _self->getRelativeValue(time, alpha, fromSetup, add, current, setup);
}
float spine_shear_x_timeline_get_absolute_value_1(spine_shear_x_timeline self, float time, float alpha, spine_mix_blend blend, float current,
float spine_shear_x_timeline_get_absolute_value_1(spine_shear_x_timeline self, float time, float alpha, bool fromSetup, bool add, float current,
float setup) {
ShearXTimeline *_self = (ShearXTimeline *) self;
return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup);
return _self->getAbsoluteValue(time, alpha, fromSetup, add, current, setup);
}
float spine_shear_x_timeline_get_absolute_value_2(spine_shear_x_timeline self, float time, float alpha, spine_mix_blend blend, float current,
float spine_shear_x_timeline_get_absolute_value_2(spine_shear_x_timeline self, float time, float alpha, bool fromSetup, bool add, float current,
float setup, float value) {
ShearXTimeline *_self = (ShearXTimeline *) self;
return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup, value);
return _self->getAbsoluteValue(time, alpha, fromSetup, add, current, setup, value);
}
float spine_shear_x_timeline_get_scale_value(spine_shear_x_timeline self, float time, float alpha, spine_mix_blend blend,
spine_mix_direction direction, float current, float setup) {
float spine_shear_x_timeline_get_scale_value(spine_shear_x_timeline self, float time, float alpha, bool fromSetup, bool add, bool out, float current,
float setup) {
ShearXTimeline *_self = (ShearXTimeline *) self;
return _self->getScaleValue(time, alpha, (MixBlend) blend, (MixDirection) direction, current, setup);
return _self->getScaleValue(time, alpha, fromSetup, add, out, current, setup);
}
void spine_shear_x_timeline_set_linear(spine_shear_x_timeline self, size_t frame) {
@ -93,6 +92,16 @@ spine_array_float spine_shear_x_timeline_get_curves(spine_shear_x_timeline self)
return (spine_array_float) &_self->getCurves();
}
bool spine_shear_x_timeline_get_additive(spine_shear_x_timeline self) {
ShearXTimeline *_self = (ShearXTimeline *) self;
return _self->getAdditive();
}
bool spine_shear_x_timeline_get_instant(spine_shear_x_timeline self) {
ShearXTimeline *_self = (ShearXTimeline *) self;
return _self->getInstant();
}
size_t spine_shear_x_timeline_get_frame_entries(spine_shear_x_timeline self) {
ShearXTimeline *_self = (ShearXTimeline *) self;
return _self->getFrameEntries();

22
spine-c/src/generated/shear_x_timeline.h
View File

@ -15,8 +15,7 @@ SPINE_C_API void spine_shear_x_timeline_dispose(spine_shear_x_timeline self);
SPINE_C_API spine_rtti spine_shear_x_timeline_get_rtti(spine_shear_x_timeline self);
SPINE_C_API void spine_shear_x_timeline_apply(spine_shear_x_timeline self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ spine_array_event events, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose);
/*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add, bool out, bool appliedPose);
SPINE_C_API int spine_shear_x_timeline_get_bone_index(spine_shear_x_timeline self);
SPINE_C_API void spine_shear_x_timeline_set_bone_index(spine_shear_x_timeline self, int inValue);
/**
@ -30,20 +29,29 @@ SPINE_C_API void spine_shear_x_timeline_set_frame(spine_shear_x_timeline self, s
* Returns the interpolated value for the specified time.
*/
SPINE_C_API float spine_shear_x_timeline_get_curve_value(spine_shear_x_timeline self, float time);
SPINE_C_API float spine_shear_x_timeline_get_relative_value(spine_shear_x_timeline self, float time, float alpha, spine_mix_blend blend,
SPINE_C_API float spine_shear_x_timeline_get_relative_value(spine_shear_x_timeline self, float time, float alpha, bool fromSetup, bool add,
float current, float setup);
SPINE_C_API float spine_shear_x_timeline_get_absolute_value_1(spine_shear_x_timeline self, float time, float alpha, spine_mix_blend blend,
SPINE_C_API float spine_shear_x_timeline_get_absolute_value_1(spine_shear_x_timeline self, float time, float alpha, bool fromSetup, bool add,
float current, float setup);
SPINE_C_API float spine_shear_x_timeline_get_absolute_value_2(spine_shear_x_timeline self, float time, float alpha, spine_mix_blend blend,
SPINE_C_API float spine_shear_x_timeline_get_absolute_value_2(spine_shear_x_timeline self, float time, float alpha, bool fromSetup, bool add,
float current, float setup, float value);
SPINE_C_API float spine_shear_x_timeline_get_scale_value(spine_shear_x_timeline self, float time, float alpha, spine_mix_blend blend,
spine_mix_direction direction, float current, float setup);
SPINE_C_API float spine_shear_x_timeline_get_scale_value(spine_shear_x_timeline self, float time, float alpha, bool fromSetup, bool add, bool out,
float current, float setup);
SPINE_C_API void spine_shear_x_timeline_set_linear(spine_shear_x_timeline self, size_t frame);
SPINE_C_API void spine_shear_x_timeline_set_stepped(spine_shear_x_timeline self, size_t frame);
SPINE_C_API void spine_shear_x_timeline_set_bezier(spine_shear_x_timeline self, size_t bezier, size_t frame, float value, float time1, float value1,
float cx1, float cy1, float cx2, float cy2, float time2, float value2);
SPINE_C_API float spine_shear_x_timeline_get_bezier_value(spine_shear_x_timeline self, float time, size_t frame, size_t valueOffset, size_t i);
SPINE_C_API spine_array_float spine_shear_x_timeline_get_curves(spine_shear_x_timeline self);
/**
* True if this timeline supports additive blending.
*/
SPINE_C_API bool spine_shear_x_timeline_get_additive(spine_shear_x_timeline self);
/**
* True if this timeline sets values instantaneously and does not support
* interpolation between frames.
*/
SPINE_C_API bool spine_shear_x_timeline_get_instant(spine_shear_x_timeline self);
SPINE_C_API size_t spine_shear_x_timeline_get_frame_entries(spine_shear_x_timeline self);
SPINE_C_API size_t spine_shear_x_timeline_get_frame_count(spine_shear_x_timeline self);
SPINE_C_API spine_array_float spine_shear_x_timeline_get_frames(spine_shear_x_timeline self);

33
spine-c/src/generated/shear_y_timeline.cpp
View File

@ -17,10 +17,9 @@ spine_rtti spine_shear_y_timeline_get_rtti(spine_shear_y_timeline self) {
}
void spine_shear_y_timeline_apply(spine_shear_y_timeline self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ spine_array_event events, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose) {
/*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add, bool out, bool appliedPose) {
ShearYTimeline *_self = (ShearYTimeline *) self;
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose);
_self->apply(*((Skeleton *) skeleton), lastTime, time, (Array<Event *> *) events, alpha, fromSetup, add, out, appliedPose);
}
int spine_shear_y_timeline_get_bone_index(spine_shear_y_timeline self) {
@ -43,28 +42,28 @@ float spine_shear_y_timeline_get_curve_value(spine_shear_y_timeline self, float
return _self->getCurveValue(time);
}
float spine_shear_y_timeline_get_relative_value(spine_shear_y_timeline self, float time, float alpha, spine_mix_blend blend, float current,
float spine_shear_y_timeline_get_relative_value(spine_shear_y_timeline self, float time, float alpha, bool fromSetup, bool add, float current,
float setup) {
ShearYTimeline *_self = (ShearYTimeline *) self;
return _self->getRelativeValue(time, alpha, (MixBlend) blend, current, setup);
return _self->getRelativeValue(time, alpha, fromSetup, add, current, setup);
}
float spine_shear_y_timeline_get_absolute_value_1(spine_shear_y_timeline self, float time, float alpha, spine_mix_blend blend, float current,
float spine_shear_y_timeline_get_absolute_value_1(spine_shear_y_timeline self, float time, float alpha, bool fromSetup, bool add, float current,
float setup) {
ShearYTimeline *_self = (ShearYTimeline *) self;
return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup);
return _self->getAbsoluteValue(time, alpha, fromSetup, add, current, setup);
}
float spine_shear_y_timeline_get_absolute_value_2(spine_shear_y_timeline self, float time, float alpha, spine_mix_blend blend, float current,
float spine_shear_y_timeline_get_absolute_value_2(spine_shear_y_timeline self, float time, float alpha, bool fromSetup, bool add, float current,
float setup, float value) {
ShearYTimeline *_self = (ShearYTimeline *) self;
return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup, value);
return _self->getAbsoluteValue(time, alpha, fromSetup, add, current, setup, value);
}
float spine_shear_y_timeline_get_scale_value(spine_shear_y_timeline self, float time, float alpha, spine_mix_blend blend,
spine_mix_direction direction, float current, float setup) {
float spine_shear_y_timeline_get_scale_value(spine_shear_y_timeline self, float time, float alpha, bool fromSetup, bool add, bool out, float current,
float setup) {
ShearYTimeline *_self = (ShearYTimeline *) self;
return _self->getScaleValue(time, alpha, (MixBlend) blend, (MixDirection) direction, current, setup);
return _self->getScaleValue(time, alpha, fromSetup, add, out, current, setup);
}
void spine_shear_y_timeline_set_linear(spine_shear_y_timeline self, size_t frame) {
@ -93,6 +92,16 @@ spine_array_float spine_shear_y_timeline_get_curves(spine_shear_y_timeline self)
return (spine_array_float) &_self->getCurves();
}
bool spine_shear_y_timeline_get_additive(spine_shear_y_timeline self) {
ShearYTimeline *_self = (ShearYTimeline *) self;
return _self->getAdditive();
}
bool spine_shear_y_timeline_get_instant(spine_shear_y_timeline self) {
ShearYTimeline *_self = (ShearYTimeline *) self;
return _self->getInstant();
}
size_t spine_shear_y_timeline_get_frame_entries(spine_shear_y_timeline self) {
ShearYTimeline *_self = (ShearYTimeline *) self;
return _self->getFrameEntries();

22
spine-c/src/generated/shear_y_timeline.h
View File

@ -15,8 +15,7 @@ SPINE_C_API void spine_shear_y_timeline_dispose(spine_shear_y_timeline self);
SPINE_C_API spine_rtti spine_shear_y_timeline_get_rtti(spine_shear_y_timeline self);
SPINE_C_API void spine_shear_y_timeline_apply(spine_shear_y_timeline self, spine_skeleton skeleton, float lastTime, float time,
/*@null*/ spine_array_event events, float alpha, spine_mix_blend blend, spine_mix_direction direction,
bool appliedPose);
/*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add, bool out, bool appliedPose);
SPINE_C_API int spine_shear_y_timeline_get_bone_index(spine_shear_y_timeline self);
SPINE_C_API void spine_shear_y_timeline_set_bone_index(spine_shear_y_timeline self, int inValue);
/**
@ -30,20 +29,29 @@ SPINE_C_API void spine_shear_y_timeline_set_frame(spine_shear_y_timeline self, s
* Returns the interpolated value for the specified time.
*/
SPINE_C_API float spine_shear_y_timeline_get_curve_value(spine_shear_y_timeline self, float time);
SPINE_C_API float spine_shear_y_timeline_get_relative_value(spine_shear_y_timeline self, float time, float alpha, spine_mix_blend blend,
SPINE_C_API float spine_shear_y_timeline_get_relative_value(spine_shear_y_timeline self, float time, float alpha, bool fromSetup, bool add,
float current, float setup);
SPINE_C_API float spine_shear_y_timeline_get_absolute_value_1(spine_shear_y_timeline self, float time, float alpha, spine_mix_blend blend,
SPINE_C_API float spine_shear_y_timeline_get_absolute_value_1(spine_shear_y_timeline self, float time, float alpha, bool fromSetup, bool add,
float current, float setup);
SPINE_C_API float spine_shear_y_timeline_get_absolute_value_2(spine_shear_y_timeline self, float time, float alpha, spine_mix_blend blend,
SPINE_C_API float spine_shear_y_timeline_get_absolute_value_2(spine_shear_y_timeline self, float time, float alpha, bool fromSetup, bool add,
float current, float setup, float value);
SPINE_C_API float spine_shear_y_timeline_get_scale_value(spine_shear_y_timeline self, float time, float alpha, spine_mix_blend blend,
spine_mix_direction direction, float current, float setup);
SPINE_C_API float spine_shear_y_timeline_get_scale_value(spine_shear_y_timeline self, float time, float alpha, bool fromSetup, bool add, bool out,
float current, float setup);
SPINE_C_API void spine_shear_y_timeline_set_linear(spine_shear_y_timeline self, size_t frame);
SPINE_C_API void spine_shear_y_timeline_set_stepped(spine_shear_y_timeline self, size_t frame);
SPINE_C_API void spine_shear_y_timeline_set_bezier(spine_shear_y_timeline self, size_t bezier, size_t frame, float value, float time1, float value1,
float cx1, float cy1, float cx2, float cy2, float time2, float value2);
SPINE_C_API float spine_shear_y_timeline_get_bezier_value(spine_shear_y_timeline self, float time, size_t frame, size_t valueOffset, size_t i);
SPINE_C_API spine_array_float spine_shear_y_timeline_get_curves(spine_shear_y_timeline self);
/**
* True if this timeline supports additive blending.
*/
SPINE_C_API bool spine_shear_y_timeline_get_additive(spine_shear_y_timeline self);
/**
* True if this timeline sets values instantaneously and does not support
* interpolation between frames.
*/
SPINE_C_API bool spine_shear_y_timeline_get_instant(spine_shear_y_timeline self);
SPINE_C_API size_t spine_shear_y_timeline_get_frame_entries(spine_shear_y_timeline self);
SPINE_C_API size_t spine_shear_y_timeline_get_frame_count(spine_shear_y_timeline self);
SPINE_C_API spine_array_float spine_shear_y_timeline_get_frames(spine_shear_y_timeline self);

10
spine-c/src/generated/skeleton.h
View File

@ -54,6 +54,10 @@ SPINE_C_API spine_array_slot spine_skeleton_get_slots(spine_skeleton self);
* @return May be NULL.
*/
SPINE_C_API /*@null*/ spine_slot spine_skeleton_find_slot(spine_skeleton self, const char *slotName);
/**
* The skeleton's slots in the order they should be drawn. The returned array
* may be modified to change the draw order.
*/
SPINE_C_API spine_array_slot spine_skeleton_get_draw_order(spine_skeleton self);
SPINE_C_API /*@null*/ spine_skin spine_skeleton_get_skin(spine_skeleton self);
/**
@ -143,6 +147,12 @@ SPINE_C_API void spine_skeleton_physics_translate(spine_skeleton self, float x,
* Calls {
*/
SPINE_C_API void spine_skeleton_physics_rotate(spine_skeleton self, float x, float y, float degrees);
/**
* Returns the skeleton's time, used for time-based manipulations, such as
* PhysicsConstraint.
*
* See update().
*/
SPINE_C_API float spine_skeleton_get_time(spine_skeleton self);
SPINE_C_API void spine_skeleton_set_time(spine_skeleton self, float time);
SPINE_C_API void spine_skeleton_update(spine_skeleton self, float delta);

12
spine-c/src/generated/skin.cpp
View File

@ -11,19 +11,19 @@ void spine_skin_dispose(spine_skin self) {
delete (Skin *) self;
}
void spine_skin_set_attachment(spine_skin self, size_t slotIndex, const char *name, /*@null*/ spine_attachment attachment) {
void spine_skin_set_attachment(spine_skin self, size_t slotIndex, const char *placeholderName, /*@null*/ spine_attachment attachment) {
Skin *_self = (Skin *) self;
_self->setAttachment(slotIndex, String(name), (Attachment *) attachment);
_self->setAttachment(slotIndex, String(placeholderName), (Attachment *) attachment);
}
/*@null*/ spine_attachment spine_skin_get_attachment(spine_skin self, size_t slotIndex, const char *name) {
/*@null*/ spine_attachment spine_skin_get_attachment(spine_skin self, size_t slotIndex, const char *placeholderName) {
Skin *_self = (Skin *) self;
return (spine_attachment) _self->getAttachment(slotIndex, String(name));
return (spine_attachment) _self->getAttachment(slotIndex, String(placeholderName));
}
void spine_skin_remove_attachment(spine_skin self, size_t slotIndex, const char *name) {
void spine_skin_remove_attachment(spine_skin self, size_t slotIndex, const char *placeholderName) {
Skin *_self = (Skin *) self;
_self->removeAttachment(slotIndex, String(name));
_self->removeAttachment(slotIndex, String(placeholderName));
}
void spine_skin_find_attachments_for_slot(spine_skin self, size_t slotIndex, spine_array_attachment attachments) {

Some files were not shown because too many files have changed in this diff Show More