diff --git a/spine-c/src/extensions.cpp b/spine-c/src/extensions.cpp index 3cb76d63c..11ea012c2 100644 --- a/spine-c/src/extensions.cpp +++ b/spine-c/src/extensions.cpp @@ -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++; } diff --git a/spine-c/src/generated/alpha_timeline.cpp b/spine-c/src/generated/alpha_timeline.cpp index 355bb3313..b63357c7c 100644 --- a/spine-c/src/generated/alpha_timeline.cpp +++ b/spine-c/src/generated/alpha_timeline.cpp @@ -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 *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose); + _self->apply(*((Skeleton *) skeleton), lastTime, time, (Array *) 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(); diff --git a/spine-c/src/generated/alpha_timeline.h b/spine-c/src/generated/alpha_timeline.h index 719ae3de4..cad1724c3 100644 --- a/spine-c/src/generated/alpha_timeline.h +++ b/spine-c/src/generated/alpha_timeline.h @@ -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); diff --git a/spine-c/src/generated/animation.cpp b/spine-c/src/generated/animation.cpp index d70550e01..3f5c189af 100644 --- a/spine-c/src/generated/animation.cpp +++ b/spine-c/src/generated/animation.cpp @@ -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 *) events, alpha, (MixBlend) blend, (MixDirection) direction, - appliedPose); + _self->apply(*((Skeleton *) skeleton), lastTime, time, loop, (Array *) events, alpha, fromSetup, add, out, appliedPose); } const char *spine_animation_get_name(spine_animation self) { diff --git a/spine-c/src/generated/animation.h b/spine-c/src/generated/animation.h index f215835c1..8a69b6b86 100644 --- a/spine-c/src/generated/animation.h +++ b/spine-c/src/generated/animation.h @@ -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. */ diff --git a/spine-c/src/generated/animation_state_data.h b/spine-c/src/generated/animation_state_data.h index cd199f576..04470e5f9 100644 --- a/spine-c/src/generated/animation_state_data.h +++ b/spine-c/src/generated/animation_state_data.h @@ -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); /** diff --git a/spine-c/src/generated/attachment_timeline.cpp b/spine-c/src/generated/attachment_timeline.cpp index 11954e93a..d9adece86 100644 --- a/spine-c/src/generated/attachment_timeline.cpp +++ b/spine-c/src/generated/attachment_timeline.cpp @@ -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 *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose); + _self->apply(*((Skeleton *) skeleton), lastTime, time, (Array *) 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(); diff --git a/spine-c/src/generated/attachment_timeline.h b/spine-c/src/generated/attachment_timeline.h index aba12cf18..27fcabb38 100644 --- a/spine-c/src/generated/attachment_timeline.h +++ b/spine-c/src/generated/attachment_timeline.h @@ -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); diff --git a/spine-c/src/generated/bone.h b/spine-c/src/generated/bone.h index d99bc537c..3ae84aee1 100644 --- a/spine-c/src/generated/bone.h +++ b/spine-c/src/generated/bone.h @@ -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); diff --git a/spine-c/src/generated/bone_data.h b/spine-c/src/generated/bone_data.h index 3eda98a2e..7690159d1 100644 --- a/spine-c/src/generated/bone_data.h +++ b/spine-c/src/generated/bone_data.h @@ -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 diff --git a/spine-c/src/generated/bone_pose.h b/spine-c/src/generated/bone_pose.h index 9358b8924..e635e8be8 100644 --- a/spine-c/src/generated/bone_pose.h +++ b/spine-c/src/generated/bone_pose.h @@ -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); diff --git a/spine-c/src/generated/bone_timeline1.cpp b/spine-c/src/generated/bone_timeline1.cpp index 44ce66112..80bc93841 100644 --- a/spine-c/src/generated/bone_timeline1.cpp +++ b/spine-c/src/generated/bone_timeline1.cpp @@ -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 *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose); + _self->apply(*((Skeleton *) skeleton), lastTime, time, (Array *) 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(); diff --git a/spine-c/src/generated/bone_timeline1.h b/spine-c/src/generated/bone_timeline1.h index 2db959a12..98ca8c2bf 100644 --- a/spine-c/src/generated/bone_timeline1.h +++ b/spine-c/src/generated/bone_timeline1.h @@ -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); diff --git a/spine-c/src/generated/bone_timeline2.cpp b/spine-c/src/generated/bone_timeline2.cpp index dd202b914..24a93d81f 100644 --- a/spine-c/src/generated/bone_timeline2.cpp +++ b/spine-c/src/generated/bone_timeline2.cpp @@ -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 *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose); + _self->apply(*((Skeleton *) skeleton), lastTime, time, (Array *) 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(); diff --git a/spine-c/src/generated/bone_timeline2.h b/spine-c/src/generated/bone_timeline2.h index df5cd08b3..a5ac47893 100644 --- a/spine-c/src/generated/bone_timeline2.h +++ b/spine-c/src/generated/bone_timeline2.h @@ -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); diff --git a/spine-c/src/generated/bounding_box_attachment.h b/spine-c/src/generated/bounding_box_attachment.h index 5331e92a6..8e8410d30 100644 --- a/spine-c/src/generated/bounding_box_attachment.h +++ b/spine-c/src/generated/bounding_box_attachment.h @@ -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); diff --git a/spine-c/src/generated/clipping_attachment.h b/spine-c/src/generated/clipping_attachment.h index 5f46f92a5..0fc9eebad 100644 --- a/spine-c/src/generated/clipping_attachment.h +++ b/spine-c/src/generated/clipping_attachment.h @@ -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); diff --git a/spine-c/src/generated/constraint_timeline1.cpp b/spine-c/src/generated/constraint_timeline1.cpp index d8ae2f214..016cf958d 100644 --- a/spine-c/src/generated/constraint_timeline1.cpp +++ b/spine-c/src/generated/constraint_timeline1.cpp @@ -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 *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose); + _self->apply(*((Skeleton *) skeleton), lastTime, time, (Array *) 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) { diff --git a/spine-c/src/generated/constraint_timeline1.h b/spine-c/src/generated/constraint_timeline1.h index e558594e0..79d2697fd 100644 --- a/spine-c/src/generated/constraint_timeline1.h +++ b/spine-c/src/generated/constraint_timeline1.h @@ -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); diff --git a/spine-c/src/generated/curve_timeline.cpp b/spine-c/src/generated/curve_timeline.cpp index 057656949..f656e49a9 100644 --- a/spine-c/src/generated/curve_timeline.cpp +++ b/spine-c/src/generated/curve_timeline.cpp @@ -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 *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose); + _self->apply(*((Skeleton *) skeleton), lastTime, time, (Array *) 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) { diff --git a/spine-c/src/generated/curve_timeline.h b/spine-c/src/generated/curve_timeline.h index 5d93a9e40..f5f13eea5 100644 --- a/spine-c/src/generated/curve_timeline.h +++ b/spine-c/src/generated/curve_timeline.h @@ -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); diff --git a/spine-c/src/generated/curve_timeline1.cpp b/spine-c/src/generated/curve_timeline1.cpp index e9c39cbb8..cb826baab 100644 --- a/spine-c/src/generated/curve_timeline1.cpp +++ b/spine-c/src/generated/curve_timeline1.cpp @@ -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 *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose); + _self->apply(*((Skeleton *) skeleton), lastTime, time, (Array *) 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) { diff --git a/spine-c/src/generated/curve_timeline1.h b/spine-c/src/generated/curve_timeline1.h index a563f86fc..24ae2e2b2 100644 --- a/spine-c/src/generated/curve_timeline1.h +++ b/spine-c/src/generated/curve_timeline1.h @@ -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); diff --git a/spine-c/src/generated/deform_timeline.cpp b/spine-c/src/generated/deform_timeline.cpp index 0a1db2b3d..ba57dd5f2 100644 --- a/spine-c/src/generated/deform_timeline.cpp +++ b/spine-c/src/generated/deform_timeline.cpp @@ -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 *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose); + _self->apply(*((Skeleton *) skeleton), lastTime, time, (Array *) 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(); diff --git a/spine-c/src/generated/deform_timeline.h b/spine-c/src/generated/deform_timeline.h index b5051eb6e..f0601bf63 100644 --- a/spine-c/src/generated/deform_timeline.h +++ b/spine-c/src/generated/deform_timeline.h @@ -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); diff --git a/spine-c/src/generated/draw_order_folder_timeline.cpp b/spine-c/src/generated/draw_order_folder_timeline.cpp index b7809be55..5c39f882b 100644 --- a/spine-c/src/generated/draw_order_folder_timeline.cpp +++ b/spine-c/src/generated/draw_order_folder_timeline.cpp @@ -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 *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose); + _self->apply(*((Skeleton *) skeleton), lastTime, time, (Array *) 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 *) 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(); diff --git a/spine-c/src/generated/draw_order_folder_timeline.h b/spine-c/src/generated/draw_order_folder_timeline.h index 7913e0b5d..69a494be6 100644 --- a/spine-c/src/generated/draw_order_folder_timeline.h +++ b/spine-c/src/generated/draw_order_folder_timeline.h @@ -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); diff --git a/spine-c/src/generated/draw_order_timeline.cpp b/spine-c/src/generated/draw_order_timeline.cpp index cc42fbf16..651732ae4 100644 --- a/spine-c/src/generated/draw_order_timeline.cpp +++ b/spine-c/src/generated/draw_order_timeline.cpp @@ -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 *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose); + _self->apply(*((Skeleton *) skeleton), lastTime, time, (Array *) 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 *) 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(); diff --git a/spine-c/src/generated/draw_order_timeline.h b/spine-c/src/generated/draw_order_timeline.h index b366bf777..c5a9fba0f 100644 --- a/spine-c/src/generated/draw_order_timeline.h +++ b/spine-c/src/generated/draw_order_timeline.h @@ -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); diff --git a/spine-c/src/generated/event_data.h b/spine-c/src/generated/event_data.h index 47d165ef1..e53df8861 100644 --- a/spine-c/src/generated/event_data.h +++ b/spine-c/src/generated/event_data.h @@ -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); diff --git a/spine-c/src/generated/event_timeline.cpp b/spine-c/src/generated/event_timeline.cpp index 7aa61592d..90814fdff 100644 --- a/spine-c/src/generated/event_timeline.cpp +++ b/spine-c/src/generated/event_timeline.cpp @@ -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 *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose); + _self->apply(*((Skeleton *) skeleton), lastTime, time, (Array *) 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(); diff --git a/spine-c/src/generated/event_timeline.h b/spine-c/src/generated/event_timeline.h index d3d18ecc8..7a230fcdd 100644 --- a/spine-c/src/generated/event_timeline.h +++ b/spine-c/src/generated/event_timeline.h @@ -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); diff --git a/spine-c/src/generated/ik_constraint.h b/spine-c/src/generated/ik_constraint.h index 1f19ed771..d58393270 100644 --- a/spine-c/src/generated/ik_constraint.h +++ b/spine-c/src/generated/ik_constraint.h @@ -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); diff --git a/spine-c/src/generated/ik_constraint_base.h b/spine-c/src/generated/ik_constraint_base.h index 4ad7ec4b9..f32505b88 100644 --- a/spine-c/src/generated/ik_constraint_base.h +++ b/spine-c/src/generated/ik_constraint_base.h @@ -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); diff --git a/spine-c/src/generated/ik_constraint_timeline.cpp b/spine-c/src/generated/ik_constraint_timeline.cpp index dcc42d7d4..815d41291 100644 --- a/spine-c/src/generated/ik_constraint_timeline.cpp +++ b/spine-c/src/generated/ik_constraint_timeline.cpp @@ -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 *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose); + _self->apply(*((Skeleton *) skeleton), lastTime, time, (Array *) 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(); diff --git a/spine-c/src/generated/ik_constraint_timeline.h b/spine-c/src/generated/ik_constraint_timeline.h index 87bccf75a..2e086f2ce 100644 --- a/spine-c/src/generated/ik_constraint_timeline.h +++ b/spine-c/src/generated/ik_constraint_timeline.h @@ -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); diff --git a/spine-c/src/generated/inherit_timeline.cpp b/spine-c/src/generated/inherit_timeline.cpp index 8f03ceb1a..299701078 100644 --- a/spine-c/src/generated/inherit_timeline.cpp +++ b/spine-c/src/generated/inherit_timeline.cpp @@ -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 *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose); + _self->apply(*((Skeleton *) skeleton), lastTime, time, (Array *) 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(); diff --git a/spine-c/src/generated/inherit_timeline.h b/spine-c/src/generated/inherit_timeline.h index 911dc1180..a72b7525d 100644 --- a/spine-c/src/generated/inherit_timeline.h +++ b/spine-c/src/generated/inherit_timeline.h @@ -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); diff --git a/spine-c/src/generated/mesh_attachment.h b/spine-c/src/generated/mesh_attachment.h index 394b37acf..f43fa8100 100644 --- a/spine-c/src/generated/mesh_attachment.h +++ b/spine-c/src/generated/mesh_attachment.h @@ -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); diff --git a/spine-c/src/generated/mix_blend.h b/spine-c/src/generated/mix_blend.h deleted file mode 100644 index c42c03528..000000000 --- a/spine-c/src/generated/mix_blend.h +++ /dev/null @@ -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 */ diff --git a/spine-c/src/generated/mix_direction.h b/spine-c/src/generated/mix_direction.h deleted file mode 100644 index f4fbb3e28..000000000 --- a/spine-c/src/generated/mix_direction.h +++ /dev/null @@ -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 */ diff --git a/spine-c/src/generated/path_attachment.h b/spine-c/src/generated/path_attachment.h index 2da9d1238..0761a5bf3 100644 --- a/spine-c/src/generated/path_attachment.h +++ b/spine-c/src/generated/path_attachment.h @@ -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); diff --git a/spine-c/src/generated/path_constraint.h b/spine-c/src/generated/path_constraint.h index 41589d39f..68d52ae80 100644 --- a/spine-c/src/generated/path_constraint.h +++ b/spine-c/src/generated/path_constraint.h @@ -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); diff --git a/spine-c/src/generated/path_constraint_base.h b/spine-c/src/generated/path_constraint_base.h index 44333dcfb..e84e8b813 100644 --- a/spine-c/src/generated/path_constraint_base.h +++ b/spine-c/src/generated/path_constraint_base.h @@ -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); diff --git a/spine-c/src/generated/path_constraint_mix_timeline.cpp b/spine-c/src/generated/path_constraint_mix_timeline.cpp index e6b00db68..37c4701f2 100644 --- a/spine-c/src/generated/path_constraint_mix_timeline.cpp +++ b/spine-c/src/generated/path_constraint_mix_timeline.cpp @@ -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 *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose); + _self->apply(*((Skeleton *) skeleton), lastTime, time, (Array *) 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(); diff --git a/spine-c/src/generated/path_constraint_mix_timeline.h b/spine-c/src/generated/path_constraint_mix_timeline.h index 710cce734..ed4c109fc 100644 --- a/spine-c/src/generated/path_constraint_mix_timeline.h +++ b/spine-c/src/generated/path_constraint_mix_timeline.h @@ -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); diff --git a/spine-c/src/generated/path_constraint_position_timeline.cpp b/spine-c/src/generated/path_constraint_position_timeline.cpp index b1a357305..f166aedc7 100644 --- a/spine-c/src/generated/path_constraint_position_timeline.cpp +++ b/spine-c/src/generated/path_constraint_position_timeline.cpp @@ -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 *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose); + _self->apply(*((Skeleton *) skeleton), lastTime, time, (Array *) 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(); diff --git a/spine-c/src/generated/path_constraint_position_timeline.h b/spine-c/src/generated/path_constraint_position_timeline.h index 0d7f7c2d8..0fc79baab 100644 --- a/spine-c/src/generated/path_constraint_position_timeline.h +++ b/spine-c/src/generated/path_constraint_position_timeline.h @@ -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); diff --git a/spine-c/src/generated/path_constraint_spacing_timeline.cpp b/spine-c/src/generated/path_constraint_spacing_timeline.cpp index af7f85d89..cc4187d32 100644 --- a/spine-c/src/generated/path_constraint_spacing_timeline.cpp +++ b/spine-c/src/generated/path_constraint_spacing_timeline.cpp @@ -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 *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose); + _self->apply(*((Skeleton *) skeleton), lastTime, time, (Array *) 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(); diff --git a/spine-c/src/generated/path_constraint_spacing_timeline.h b/spine-c/src/generated/path_constraint_spacing_timeline.h index c211e28fe..5b34cd011 100644 --- a/spine-c/src/generated/path_constraint_spacing_timeline.h +++ b/spine-c/src/generated/path_constraint_spacing_timeline.h @@ -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); diff --git a/spine-c/src/generated/physics_constraint.h b/spine-c/src/generated/physics_constraint.h index 7d50edec1..8f52a1433 100644 --- a/spine-c/src/generated/physics_constraint.h +++ b/spine-c/src/generated/physics_constraint.h @@ -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); diff --git a/spine-c/src/generated/physics_constraint_base.h b/spine-c/src/generated/physics_constraint_base.h index e01f5b521..3318efb7a 100644 --- a/spine-c/src/generated/physics_constraint_base.h +++ b/spine-c/src/generated/physics_constraint_base.h @@ -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); diff --git a/spine-c/src/generated/physics_constraint_damping_timeline.cpp b/spine-c/src/generated/physics_constraint_damping_timeline.cpp index a79d7343f..db039b8d3 100644 --- a/spine-c/src/generated/physics_constraint_damping_timeline.cpp +++ b/spine-c/src/generated/physics_constraint_damping_timeline.cpp @@ -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 *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose); + _self->apply(*((Skeleton *) skeleton), lastTime, time, (Array *) 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(); diff --git a/spine-c/src/generated/physics_constraint_damping_timeline.h b/spine-c/src/generated/physics_constraint_damping_timeline.h index 0ccaf4b47..a84194a95 100644 --- a/spine-c/src/generated/physics_constraint_damping_timeline.h +++ b/spine-c/src/generated/physics_constraint_damping_timeline.h @@ -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); diff --git a/spine-c/src/generated/physics_constraint_gravity_timeline.cpp b/spine-c/src/generated/physics_constraint_gravity_timeline.cpp index 358015873..8959df9ad 100644 --- a/spine-c/src/generated/physics_constraint_gravity_timeline.cpp +++ b/spine-c/src/generated/physics_constraint_gravity_timeline.cpp @@ -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 *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose); + _self->apply(*((Skeleton *) skeleton), lastTime, time, (Array *) 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(); diff --git a/spine-c/src/generated/physics_constraint_gravity_timeline.h b/spine-c/src/generated/physics_constraint_gravity_timeline.h index c7d8aedf5..47173527e 100644 --- a/spine-c/src/generated/physics_constraint_gravity_timeline.h +++ b/spine-c/src/generated/physics_constraint_gravity_timeline.h @@ -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); diff --git a/spine-c/src/generated/physics_constraint_inertia_timeline.cpp b/spine-c/src/generated/physics_constraint_inertia_timeline.cpp index b42f82faf..dc0c266f5 100644 --- a/spine-c/src/generated/physics_constraint_inertia_timeline.cpp +++ b/spine-c/src/generated/physics_constraint_inertia_timeline.cpp @@ -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 *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose); + _self->apply(*((Skeleton *) skeleton), lastTime, time, (Array *) 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(); diff --git a/spine-c/src/generated/physics_constraint_inertia_timeline.h b/spine-c/src/generated/physics_constraint_inertia_timeline.h index 06a1fbeba..266b30cf6 100644 --- a/spine-c/src/generated/physics_constraint_inertia_timeline.h +++ b/spine-c/src/generated/physics_constraint_inertia_timeline.h @@ -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); diff --git a/spine-c/src/generated/physics_constraint_mass_timeline.cpp b/spine-c/src/generated/physics_constraint_mass_timeline.cpp index b392e9ef0..14ac0ac41 100644 --- a/spine-c/src/generated/physics_constraint_mass_timeline.cpp +++ b/spine-c/src/generated/physics_constraint_mass_timeline.cpp @@ -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 *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose); + _self->apply(*((Skeleton *) skeleton), lastTime, time, (Array *) 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(); diff --git a/spine-c/src/generated/physics_constraint_mass_timeline.h b/spine-c/src/generated/physics_constraint_mass_timeline.h index f5546bc8e..dd1de1c82 100644 --- a/spine-c/src/generated/physics_constraint_mass_timeline.h +++ b/spine-c/src/generated/physics_constraint_mass_timeline.h @@ -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); diff --git a/spine-c/src/generated/physics_constraint_mix_timeline.cpp b/spine-c/src/generated/physics_constraint_mix_timeline.cpp index c8dedc629..889644674 100644 --- a/spine-c/src/generated/physics_constraint_mix_timeline.cpp +++ b/spine-c/src/generated/physics_constraint_mix_timeline.cpp @@ -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 *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose); + _self->apply(*((Skeleton *) skeleton), lastTime, time, (Array *) 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(); diff --git a/spine-c/src/generated/physics_constraint_mix_timeline.h b/spine-c/src/generated/physics_constraint_mix_timeline.h index 80628910e..0bcf240c6 100644 --- a/spine-c/src/generated/physics_constraint_mix_timeline.h +++ b/spine-c/src/generated/physics_constraint_mix_timeline.h @@ -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); diff --git a/spine-c/src/generated/physics_constraint_reset_timeline.cpp b/spine-c/src/generated/physics_constraint_reset_timeline.cpp index 6fb5a45ae..9177c3503 100644 --- a/spine-c/src/generated/physics_constraint_reset_timeline.cpp +++ b/spine-c/src/generated/physics_constraint_reset_timeline.cpp @@ -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 *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose); + _self->apply(*((Skeleton *) skeleton), lastTime, time, (Array *) 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(); diff --git a/spine-c/src/generated/physics_constraint_reset_timeline.h b/spine-c/src/generated/physics_constraint_reset_timeline.h index 83f46c15f..10c335807 100644 --- a/spine-c/src/generated/physics_constraint_reset_timeline.h +++ b/spine-c/src/generated/physics_constraint_reset_timeline.h @@ -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); diff --git a/spine-c/src/generated/physics_constraint_strength_timeline.cpp b/spine-c/src/generated/physics_constraint_strength_timeline.cpp index c139fb1bd..712624d0e 100644 --- a/spine-c/src/generated/physics_constraint_strength_timeline.cpp +++ b/spine-c/src/generated/physics_constraint_strength_timeline.cpp @@ -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 *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose); + _self->apply(*((Skeleton *) skeleton), lastTime, time, (Array *) 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(); diff --git a/spine-c/src/generated/physics_constraint_strength_timeline.h b/spine-c/src/generated/physics_constraint_strength_timeline.h index b587a14dc..90d7645b5 100644 --- a/spine-c/src/generated/physics_constraint_strength_timeline.h +++ b/spine-c/src/generated/physics_constraint_strength_timeline.h @@ -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); diff --git a/spine-c/src/generated/physics_constraint_timeline.cpp b/spine-c/src/generated/physics_constraint_timeline.cpp index dcad4cb73..48308cf7d 100644 --- a/spine-c/src/generated/physics_constraint_timeline.cpp +++ b/spine-c/src/generated/physics_constraint_timeline.cpp @@ -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 *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose); + _self->apply(*((Skeleton *) skeleton), lastTime, time, (Array *) 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(); diff --git a/spine-c/src/generated/physics_constraint_timeline.h b/spine-c/src/generated/physics_constraint_timeline.h index dd05a99fd..e180a16a3 100644 --- a/spine-c/src/generated/physics_constraint_timeline.h +++ b/spine-c/src/generated/physics_constraint_timeline.h @@ -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); diff --git a/spine-c/src/generated/physics_constraint_wind_timeline.cpp b/spine-c/src/generated/physics_constraint_wind_timeline.cpp index faab05df0..0a7976b7a 100644 --- a/spine-c/src/generated/physics_constraint_wind_timeline.cpp +++ b/spine-c/src/generated/physics_constraint_wind_timeline.cpp @@ -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 *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose); + _self->apply(*((Skeleton *) skeleton), lastTime, time, (Array *) 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(); diff --git a/spine-c/src/generated/physics_constraint_wind_timeline.h b/spine-c/src/generated/physics_constraint_wind_timeline.h index d1323f586..135512043 100644 --- a/spine-c/src/generated/physics_constraint_wind_timeline.h +++ b/spine-c/src/generated/physics_constraint_wind_timeline.h @@ -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); diff --git a/spine-c/src/generated/point_attachment.h b/spine-c/src/generated/point_attachment.h index 8750c0f69..4545ea009 100644 --- a/spine-c/src/generated/point_attachment.h +++ b/spine-c/src/generated/point_attachment.h @@ -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); diff --git a/spine-c/src/generated/posed_active.h b/spine-c/src/generated/posed_active.h index 73b985c0b..1493f94c9 100644 --- a/spine-c/src/generated/posed_active.h +++ b/spine-c/src/generated/posed_active.h @@ -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); diff --git a/spine-c/src/generated/posed_data.h b/spine-c/src/generated/posed_data.h index b337f0a90..e36bad087 100644 --- a/spine-c/src/generated/posed_data.h +++ b/spine-c/src/generated/posed_data.h @@ -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 diff --git a/spine-c/src/generated/region_attachment.h b/spine-c/src/generated/region_attachment.h index 95b4a5394..fd3e06c1e 100644 --- a/spine-c/src/generated/region_attachment.h +++ b/spine-c/src/generated/region_attachment.h @@ -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); diff --git a/spine-c/src/generated/rgb2_timeline.cpp b/spine-c/src/generated/rgb2_timeline.cpp index f2b706bd3..aecc28b1b 100644 --- a/spine-c/src/generated/rgb2_timeline.cpp +++ b/spine-c/src/generated/rgb2_timeline.cpp @@ -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 *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose); + _self->apply(*((Skeleton *) skeleton), lastTime, time, (Array *) 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(); diff --git a/spine-c/src/generated/rgb2_timeline.h b/spine-c/src/generated/rgb2_timeline.h index 944afde5b..e1b3bd3fd 100644 --- a/spine-c/src/generated/rgb2_timeline.h +++ b/spine-c/src/generated/rgb2_timeline.h @@ -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); diff --git a/spine-c/src/generated/rgb_timeline.cpp b/spine-c/src/generated/rgb_timeline.cpp index 4d90b6b53..8cd686430 100644 --- a/spine-c/src/generated/rgb_timeline.cpp +++ b/spine-c/src/generated/rgb_timeline.cpp @@ -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 *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose); + _self->apply(*((Skeleton *) skeleton), lastTime, time, (Array *) 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(); diff --git a/spine-c/src/generated/rgb_timeline.h b/spine-c/src/generated/rgb_timeline.h index d93d2bdd3..0195859b4 100644 --- a/spine-c/src/generated/rgb_timeline.h +++ b/spine-c/src/generated/rgb_timeline.h @@ -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); diff --git a/spine-c/src/generated/rgba2_timeline.cpp b/spine-c/src/generated/rgba2_timeline.cpp index eacfbf47a..a4759ba67 100644 --- a/spine-c/src/generated/rgba2_timeline.cpp +++ b/spine-c/src/generated/rgba2_timeline.cpp @@ -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 *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose); + _self->apply(*((Skeleton *) skeleton), lastTime, time, (Array *) 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(); diff --git a/spine-c/src/generated/rgba2_timeline.h b/spine-c/src/generated/rgba2_timeline.h index c9be81aa8..f04f24590 100644 --- a/spine-c/src/generated/rgba2_timeline.h +++ b/spine-c/src/generated/rgba2_timeline.h @@ -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); diff --git a/spine-c/src/generated/rgba_timeline.cpp b/spine-c/src/generated/rgba_timeline.cpp index 5a7fa5033..4870e9afe 100644 --- a/spine-c/src/generated/rgba_timeline.cpp +++ b/spine-c/src/generated/rgba_timeline.cpp @@ -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 *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose); + _self->apply(*((Skeleton *) skeleton), lastTime, time, (Array *) 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(); diff --git a/spine-c/src/generated/rgba_timeline.h b/spine-c/src/generated/rgba_timeline.h index c7fef8f7e..ba24eae9d 100644 --- a/spine-c/src/generated/rgba_timeline.h +++ b/spine-c/src/generated/rgba_timeline.h @@ -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); diff --git a/spine-c/src/generated/rotate_timeline.cpp b/spine-c/src/generated/rotate_timeline.cpp index 4408dbd6e..5b2343e19 100644 --- a/spine-c/src/generated/rotate_timeline.cpp +++ b/spine-c/src/generated/rotate_timeline.cpp @@ -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 *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose); + _self->apply(*((Skeleton *) skeleton), lastTime, time, (Array *) 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(); diff --git a/spine-c/src/generated/rotate_timeline.h b/spine-c/src/generated/rotate_timeline.h index a2daa19ff..ec61f8b52 100644 --- a/spine-c/src/generated/rotate_timeline.h +++ b/spine-c/src/generated/rotate_timeline.h @@ -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); diff --git a/spine-c/src/generated/scale_timeline.cpp b/spine-c/src/generated/scale_timeline.cpp index dbef1f539..66cc2e282 100644 --- a/spine-c/src/generated/scale_timeline.cpp +++ b/spine-c/src/generated/scale_timeline.cpp @@ -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 *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose); + _self->apply(*((Skeleton *) skeleton), lastTime, time, (Array *) 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(); diff --git a/spine-c/src/generated/scale_timeline.h b/spine-c/src/generated/scale_timeline.h index 3db83f2a6..a520dd253 100644 --- a/spine-c/src/generated/scale_timeline.h +++ b/spine-c/src/generated/scale_timeline.h @@ -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); diff --git a/spine-c/src/generated/scale_x_timeline.cpp b/spine-c/src/generated/scale_x_timeline.cpp index 322e89680..92cff9ec4 100644 --- a/spine-c/src/generated/scale_x_timeline.cpp +++ b/spine-c/src/generated/scale_x_timeline.cpp @@ -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 *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose); + _self->apply(*((Skeleton *) skeleton), lastTime, time, (Array *) 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(); diff --git a/spine-c/src/generated/scale_x_timeline.h b/spine-c/src/generated/scale_x_timeline.h index 37e77a54f..be00e3a44 100644 --- a/spine-c/src/generated/scale_x_timeline.h +++ b/spine-c/src/generated/scale_x_timeline.h @@ -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); diff --git a/spine-c/src/generated/scale_y_timeline.cpp b/spine-c/src/generated/scale_y_timeline.cpp index 1111e46f4..2ac94a5d0 100644 --- a/spine-c/src/generated/scale_y_timeline.cpp +++ b/spine-c/src/generated/scale_y_timeline.cpp @@ -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 *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose); + _self->apply(*((Skeleton *) skeleton), lastTime, time, (Array *) 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(); diff --git a/spine-c/src/generated/scale_y_timeline.h b/spine-c/src/generated/scale_y_timeline.h index dd6b1d02c..b55c30e2e 100644 --- a/spine-c/src/generated/scale_y_timeline.h +++ b/spine-c/src/generated/scale_y_timeline.h @@ -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); diff --git a/spine-c/src/generated/sequence_timeline.cpp b/spine-c/src/generated/sequence_timeline.cpp index d9ce5bc11..f786b3e99 100644 --- a/spine-c/src/generated/sequence_timeline.cpp +++ b/spine-c/src/generated/sequence_timeline.cpp @@ -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 *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose); + _self->apply(*((Skeleton *) skeleton), lastTime, time, (Array *) 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(); diff --git a/spine-c/src/generated/sequence_timeline.h b/spine-c/src/generated/sequence_timeline.h index 7a3d9b1b5..5f35fd7fc 100644 --- a/spine-c/src/generated/sequence_timeline.h +++ b/spine-c/src/generated/sequence_timeline.h @@ -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); diff --git a/spine-c/src/generated/shear_timeline.cpp b/spine-c/src/generated/shear_timeline.cpp index 1a34af5cd..948027e35 100644 --- a/spine-c/src/generated/shear_timeline.cpp +++ b/spine-c/src/generated/shear_timeline.cpp @@ -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 *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose); + _self->apply(*((Skeleton *) skeleton), lastTime, time, (Array *) 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(); diff --git a/spine-c/src/generated/shear_timeline.h b/spine-c/src/generated/shear_timeline.h index 3c435c2b7..642c00573 100644 --- a/spine-c/src/generated/shear_timeline.h +++ b/spine-c/src/generated/shear_timeline.h @@ -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); diff --git a/spine-c/src/generated/shear_x_timeline.cpp b/spine-c/src/generated/shear_x_timeline.cpp index 51514d96a..acf4bfeb2 100644 --- a/spine-c/src/generated/shear_x_timeline.cpp +++ b/spine-c/src/generated/shear_x_timeline.cpp @@ -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 *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose); + _self->apply(*((Skeleton *) skeleton), lastTime, time, (Array *) 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(); diff --git a/spine-c/src/generated/shear_x_timeline.h b/spine-c/src/generated/shear_x_timeline.h index 225ae86d0..b8333f9f8 100644 --- a/spine-c/src/generated/shear_x_timeline.h +++ b/spine-c/src/generated/shear_x_timeline.h @@ -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); diff --git a/spine-c/src/generated/shear_y_timeline.cpp b/spine-c/src/generated/shear_y_timeline.cpp index 71771177f..43555561f 100644 --- a/spine-c/src/generated/shear_y_timeline.cpp +++ b/spine-c/src/generated/shear_y_timeline.cpp @@ -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 *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose); + _self->apply(*((Skeleton *) skeleton), lastTime, time, (Array *) 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(); diff --git a/spine-c/src/generated/shear_y_timeline.h b/spine-c/src/generated/shear_y_timeline.h index 7c91384bb..7dc408142 100644 --- a/spine-c/src/generated/shear_y_timeline.h +++ b/spine-c/src/generated/shear_y_timeline.h @@ -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); diff --git a/spine-c/src/generated/skeleton.h b/spine-c/src/generated/skeleton.h index d928991ba..487d64988 100644 --- a/spine-c/src/generated/skeleton.h +++ b/spine-c/src/generated/skeleton.h @@ -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); diff --git a/spine-c/src/generated/skin.cpp b/spine-c/src/generated/skin.cpp index fb785f710..8fa41282e 100644 --- a/spine-c/src/generated/skin.cpp +++ b/spine-c/src/generated/skin.cpp @@ -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) { diff --git a/spine-c/src/generated/skin.h b/spine-c/src/generated/skin.h index ca9ffd2df..bfb9ddf25 100644 --- a/spine-c/src/generated/skin.h +++ b/spine-c/src/generated/skin.h @@ -14,18 +14,20 @@ SPINE_C_API spine_skin spine_skin_create(const char *name); SPINE_C_API void spine_skin_dispose(spine_skin self); /** - * Adds an attachment to the skin for the specified slot index and name. If the - * name already exists for the slot, the previous value is replaced. + * Adds an attachment to the skin for the specified slot index and placeholder + * name. If the placeholder name already exists for the slot, the previous value + * is replaced. */ -SPINE_C_API void spine_skin_set_attachment(spine_skin self, size_t slotIndex, const char *name, /*@null*/ spine_attachment attachment); +SPINE_C_API void spine_skin_set_attachment(spine_skin self, size_t slotIndex, const char *placeholderName, /*@null*/ spine_attachment attachment); /** - * Returns the attachment for the specified slot index and name, or NULL. + * Returns the attachment for the specified slot index and placeholder name, or + * NULL. */ -SPINE_C_API /*@null*/ spine_attachment spine_skin_get_attachment(spine_skin self, size_t slotIndex, const char *name); +SPINE_C_API /*@null*/ spine_attachment spine_skin_get_attachment(spine_skin self, size_t slotIndex, const char *placeholderName); /** * Removes the attachment from the skin. */ -SPINE_C_API void spine_skin_remove_attachment(spine_skin self, size_t slotIndex, const char *name); +SPINE_C_API void spine_skin_remove_attachment(spine_skin self, size_t slotIndex, const char *placeholderName); /** * Finds the attachments for a given slot. The results are added to the passed * array of Attachments. diff --git a/spine-c/src/generated/slider.h b/spine-c/src/generated/slider.h index 4f4806591..5fd12a767 100644 --- a/spine-c/src/generated/slider.h +++ b/spine-c/src/generated/slider.h @@ -26,6 +26,13 @@ SPINE_C_API spine_slider_pose spine_slider_get_applied_pose(spine_slider self); SPINE_C_API void spine_slider_reset_constrained(spine_slider self); SPINE_C_API void spine_slider_constrained(spine_slider self); SPINE_C_API bool spine_slider_is_pose_equal_to_applied(spine_slider 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_slider_is_active(spine_slider self); SPINE_C_API void spine_slider_set_active(spine_slider self, bool active); SPINE_C_API spine_rtti spine_slider_rtti(void); diff --git a/spine-c/src/generated/slider_base.h b/spine-c/src/generated/slider_base.h index 3dd9dd083..881fa6e38 100644 --- a/spine-c/src/generated/slider_base.h +++ b/spine-c/src/generated/slider_base.h @@ -17,6 +17,13 @@ SPINE_C_API spine_slider_pose spine_slider_base_get_applied_pose(spine_slider_ba SPINE_C_API void spine_slider_base_reset_constrained(spine_slider_base self); SPINE_C_API void spine_slider_base_constrained(spine_slider_base self); SPINE_C_API bool spine_slider_base_is_pose_equal_to_applied(spine_slider_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_slider_base_is_active(spine_slider_base self); SPINE_C_API void spine_slider_base_set_active(spine_slider_base self, bool active); SPINE_C_API spine_rtti spine_slider_base_get_rtti(spine_slider_base self); diff --git a/spine-c/src/generated/slider_mix_timeline.cpp b/spine-c/src/generated/slider_mix_timeline.cpp index fe924b341..270f02638 100644 --- a/spine-c/src/generated/slider_mix_timeline.cpp +++ b/spine-c/src/generated/slider_mix_timeline.cpp @@ -17,10 +17,9 @@ spine_rtti spine_slider_mix_timeline_get_rtti(spine_slider_mix_timeline self) { } void spine_slider_mix_timeline_apply(spine_slider_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) { SliderMixTimeline *_self = (SliderMixTimeline *) self; - _self->apply(*((Skeleton *) skeleton), lastTime, time, (Array *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose); + _self->apply(*((Skeleton *) skeleton), lastTime, time, (Array *) events, alpha, fromSetup, add, out, appliedPose); } int spine_slider_mix_timeline_get_constraint_index(spine_slider_mix_timeline self) { @@ -43,28 +42,28 @@ float spine_slider_mix_timeline_get_curve_value(spine_slider_mix_timeline self, return _self->getCurveValue(time); } -float spine_slider_mix_timeline_get_relative_value(spine_slider_mix_timeline self, float time, float alpha, spine_mix_blend blend, float current, +float spine_slider_mix_timeline_get_relative_value(spine_slider_mix_timeline self, float time, float alpha, bool fromSetup, bool add, float current, float setup) { SliderMixTimeline *_self = (SliderMixTimeline *) self; - return _self->getRelativeValue(time, alpha, (MixBlend) blend, current, setup); + return _self->getRelativeValue(time, alpha, fromSetup, add, current, setup); } -float spine_slider_mix_timeline_get_absolute_value_1(spine_slider_mix_timeline self, float time, float alpha, spine_mix_blend blend, float current, +float spine_slider_mix_timeline_get_absolute_value_1(spine_slider_mix_timeline self, float time, float alpha, bool fromSetup, bool add, float current, float setup) { SliderMixTimeline *_self = (SliderMixTimeline *) self; - return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup); + return _self->getAbsoluteValue(time, alpha, fromSetup, add, current, setup); } -float spine_slider_mix_timeline_get_absolute_value_2(spine_slider_mix_timeline self, float time, float alpha, spine_mix_blend blend, float current, +float spine_slider_mix_timeline_get_absolute_value_2(spine_slider_mix_timeline self, float time, float alpha, bool fromSetup, bool add, float current, float setup, float value) { SliderMixTimeline *_self = (SliderMixTimeline *) self; - return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup, value); + return _self->getAbsoluteValue(time, alpha, fromSetup, add, current, setup, value); } -float spine_slider_mix_timeline_get_scale_value(spine_slider_mix_timeline self, float time, float alpha, spine_mix_blend blend, - spine_mix_direction direction, float current, float setup) { +float spine_slider_mix_timeline_get_scale_value(spine_slider_mix_timeline self, float time, float alpha, bool fromSetup, bool add, bool out, + float current, float setup) { SliderMixTimeline *_self = (SliderMixTimeline *) self; - return _self->getScaleValue(time, alpha, (MixBlend) blend, (MixDirection) direction, current, setup); + return _self->getScaleValue(time, alpha, fromSetup, add, out, current, setup); } void spine_slider_mix_timeline_set_linear(spine_slider_mix_timeline self, size_t frame) { @@ -93,6 +92,16 @@ spine_array_float spine_slider_mix_timeline_get_curves(spine_slider_mix_timeline return (spine_array_float) &_self->getCurves(); } +bool spine_slider_mix_timeline_get_additive(spine_slider_mix_timeline self) { + SliderMixTimeline *_self = (SliderMixTimeline *) self; + return _self->getAdditive(); +} + +bool spine_slider_mix_timeline_get_instant(spine_slider_mix_timeline self) { + SliderMixTimeline *_self = (SliderMixTimeline *) self; + return _self->getInstant(); +} + size_t spine_slider_mix_timeline_get_frame_entries(spine_slider_mix_timeline self) { SliderMixTimeline *_self = (SliderMixTimeline *) self; return _self->getFrameEntries(); diff --git a/spine-c/src/generated/slider_mix_timeline.h b/spine-c/src/generated/slider_mix_timeline.h index adca33d7f..5451e776b 100644 --- a/spine-c/src/generated/slider_mix_timeline.h +++ b/spine-c/src/generated/slider_mix_timeline.h @@ -15,8 +15,8 @@ SPINE_C_API void spine_slider_mix_timeline_dispose(spine_slider_mix_timeline sel SPINE_C_API spine_rtti spine_slider_mix_timeline_get_rtti(spine_slider_mix_timeline self); SPINE_C_API void spine_slider_mix_timeline_apply(spine_slider_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); SPINE_C_API int spine_slider_mix_timeline_get_constraint_index(spine_slider_mix_timeline self); SPINE_C_API void spine_slider_mix_timeline_set_constraint_index(spine_slider_mix_timeline self, int inValue); /** @@ -30,20 +30,29 @@ SPINE_C_API void spine_slider_mix_timeline_set_frame(spine_slider_mix_timeline s * Returns the interpolated value for the specified time. */ SPINE_C_API float spine_slider_mix_timeline_get_curve_value(spine_slider_mix_timeline self, float time); -SPINE_C_API float spine_slider_mix_timeline_get_relative_value(spine_slider_mix_timeline self, float time, float alpha, spine_mix_blend blend, +SPINE_C_API float spine_slider_mix_timeline_get_relative_value(spine_slider_mix_timeline self, float time, float alpha, bool fromSetup, bool add, float current, float setup); -SPINE_C_API float spine_slider_mix_timeline_get_absolute_value_1(spine_slider_mix_timeline self, float time, float alpha, spine_mix_blend blend, +SPINE_C_API float spine_slider_mix_timeline_get_absolute_value_1(spine_slider_mix_timeline self, float time, float alpha, bool fromSetup, bool add, float current, float setup); -SPINE_C_API float spine_slider_mix_timeline_get_absolute_value_2(spine_slider_mix_timeline self, float time, float alpha, spine_mix_blend blend, +SPINE_C_API float spine_slider_mix_timeline_get_absolute_value_2(spine_slider_mix_timeline self, float time, float alpha, bool fromSetup, bool add, float current, float setup, float value); -SPINE_C_API float spine_slider_mix_timeline_get_scale_value(spine_slider_mix_timeline self, float time, float alpha, spine_mix_blend blend, - spine_mix_direction direction, float current, float setup); +SPINE_C_API float spine_slider_mix_timeline_get_scale_value(spine_slider_mix_timeline self, float time, float alpha, bool fromSetup, bool add, + bool out, float current, float setup); SPINE_C_API void spine_slider_mix_timeline_set_linear(spine_slider_mix_timeline self, size_t frame); SPINE_C_API void spine_slider_mix_timeline_set_stepped(spine_slider_mix_timeline self, size_t frame); SPINE_C_API void spine_slider_mix_timeline_set_bezier(spine_slider_mix_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_slider_mix_timeline_get_bezier_value(spine_slider_mix_timeline self, float time, size_t frame, size_t valueOffset, size_t i); SPINE_C_API spine_array_float spine_slider_mix_timeline_get_curves(spine_slider_mix_timeline self); +/** + * True if this timeline supports additive blending. + */ +SPINE_C_API bool spine_slider_mix_timeline_get_additive(spine_slider_mix_timeline self); +/** + * True if this timeline sets values instantaneously and does not support + * interpolation between frames. + */ +SPINE_C_API bool spine_slider_mix_timeline_get_instant(spine_slider_mix_timeline self); SPINE_C_API size_t spine_slider_mix_timeline_get_frame_entries(spine_slider_mix_timeline self); SPINE_C_API size_t spine_slider_mix_timeline_get_frame_count(spine_slider_mix_timeline self); SPINE_C_API spine_array_float spine_slider_mix_timeline_get_frames(spine_slider_mix_timeline self); diff --git a/spine-c/src/generated/slider_timeline.cpp b/spine-c/src/generated/slider_timeline.cpp index 828da720c..32b01a0d9 100644 --- a/spine-c/src/generated/slider_timeline.cpp +++ b/spine-c/src/generated/slider_timeline.cpp @@ -17,9 +17,9 @@ spine_rtti spine_slider_timeline_get_rtti(spine_slider_timeline self) { } void spine_slider_timeline_apply(spine_slider_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) { SliderTimeline *_self = (SliderTimeline *) self; - _self->apply(*((Skeleton *) skeleton), lastTime, time, (Array *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose); + _self->apply(*((Skeleton *) skeleton), lastTime, time, (Array *) events, alpha, fromSetup, add, out, appliedPose); } int spine_slider_timeline_get_constraint_index(spine_slider_timeline self) { @@ -42,28 +42,28 @@ float spine_slider_timeline_get_curve_value(spine_slider_timeline self, float ti return _self->getCurveValue(time); } -float spine_slider_timeline_get_relative_value(spine_slider_timeline self, float time, float alpha, spine_mix_blend blend, float current, +float spine_slider_timeline_get_relative_value(spine_slider_timeline self, float time, float alpha, bool fromSetup, bool add, float current, float setup) { SliderTimeline *_self = (SliderTimeline *) self; - return _self->getRelativeValue(time, alpha, (MixBlend) blend, current, setup); + return _self->getRelativeValue(time, alpha, fromSetup, add, current, setup); } -float spine_slider_timeline_get_absolute_value_1(spine_slider_timeline self, float time, float alpha, spine_mix_blend blend, float current, +float spine_slider_timeline_get_absolute_value_1(spine_slider_timeline self, float time, float alpha, bool fromSetup, bool add, float current, float setup) { SliderTimeline *_self = (SliderTimeline *) self; - return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup); + return _self->getAbsoluteValue(time, alpha, fromSetup, add, current, setup); } -float spine_slider_timeline_get_absolute_value_2(spine_slider_timeline self, float time, float alpha, spine_mix_blend blend, float current, +float spine_slider_timeline_get_absolute_value_2(spine_slider_timeline self, float time, float alpha, bool fromSetup, bool add, float current, float setup, float value) { SliderTimeline *_self = (SliderTimeline *) self; - return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup, value); + return _self->getAbsoluteValue(time, alpha, fromSetup, add, current, setup, value); } -float spine_slider_timeline_get_scale_value(spine_slider_timeline self, float time, float alpha, spine_mix_blend blend, spine_mix_direction direction, - float current, float setup) { +float spine_slider_timeline_get_scale_value(spine_slider_timeline self, float time, float alpha, bool fromSetup, bool add, bool out, float current, + float setup) { SliderTimeline *_self = (SliderTimeline *) self; - return _self->getScaleValue(time, alpha, (MixBlend) blend, (MixDirection) direction, current, setup); + return _self->getScaleValue(time, alpha, fromSetup, add, out, current, setup); } void spine_slider_timeline_set_linear(spine_slider_timeline self, size_t frame) { @@ -92,6 +92,16 @@ spine_array_float spine_slider_timeline_get_curves(spine_slider_timeline self) { return (spine_array_float) &_self->getCurves(); } +bool spine_slider_timeline_get_additive(spine_slider_timeline self) { + SliderTimeline *_self = (SliderTimeline *) self; + return _self->getAdditive(); +} + +bool spine_slider_timeline_get_instant(spine_slider_timeline self) { + SliderTimeline *_self = (SliderTimeline *) self; + return _self->getInstant(); +} + size_t spine_slider_timeline_get_frame_entries(spine_slider_timeline self) { SliderTimeline *_self = (SliderTimeline *) self; return _self->getFrameEntries(); diff --git a/spine-c/src/generated/slider_timeline.h b/spine-c/src/generated/slider_timeline.h index 682a92bf4..24320f253 100644 --- a/spine-c/src/generated/slider_timeline.h +++ b/spine-c/src/generated/slider_timeline.h @@ -15,8 +15,7 @@ SPINE_C_API void spine_slider_timeline_dispose(spine_slider_timeline self); SPINE_C_API spine_rtti spine_slider_timeline_get_rtti(spine_slider_timeline self); SPINE_C_API void spine_slider_timeline_apply(spine_slider_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_slider_timeline_get_constraint_index(spine_slider_timeline self); SPINE_C_API void spine_slider_timeline_set_constraint_index(spine_slider_timeline self, int inValue); /** @@ -30,20 +29,29 @@ SPINE_C_API void spine_slider_timeline_set_frame(spine_slider_timeline self, siz * Returns the interpolated value for the specified time. */ SPINE_C_API float spine_slider_timeline_get_curve_value(spine_slider_timeline self, float time); -SPINE_C_API float spine_slider_timeline_get_relative_value(spine_slider_timeline self, float time, float alpha, spine_mix_blend blend, float current, - float setup); -SPINE_C_API float spine_slider_timeline_get_absolute_value_1(spine_slider_timeline self, float time, float alpha, spine_mix_blend blend, +SPINE_C_API float spine_slider_timeline_get_relative_value(spine_slider_timeline self, float time, float alpha, bool fromSetup, bool add, + float current, float setup); +SPINE_C_API float spine_slider_timeline_get_absolute_value_1(spine_slider_timeline self, float time, float alpha, bool fromSetup, bool add, float current, float setup); -SPINE_C_API float spine_slider_timeline_get_absolute_value_2(spine_slider_timeline self, float time, float alpha, spine_mix_blend blend, +SPINE_C_API float spine_slider_timeline_get_absolute_value_2(spine_slider_timeline self, float time, float alpha, bool fromSetup, bool add, float current, float setup, float value); -SPINE_C_API float spine_slider_timeline_get_scale_value(spine_slider_timeline self, float time, float alpha, spine_mix_blend blend, - spine_mix_direction direction, float current, float setup); +SPINE_C_API float spine_slider_timeline_get_scale_value(spine_slider_timeline self, float time, float alpha, bool fromSetup, bool add, bool out, + float current, float setup); SPINE_C_API void spine_slider_timeline_set_linear(spine_slider_timeline self, size_t frame); SPINE_C_API void spine_slider_timeline_set_stepped(spine_slider_timeline self, size_t frame); SPINE_C_API void spine_slider_timeline_set_bezier(spine_slider_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_slider_timeline_get_bezier_value(spine_slider_timeline self, float time, size_t frame, size_t valueOffset, size_t i); SPINE_C_API spine_array_float spine_slider_timeline_get_curves(spine_slider_timeline self); +/** + * True if this timeline supports additive blending. + */ +SPINE_C_API bool spine_slider_timeline_get_additive(spine_slider_timeline self); +/** + * True if this timeline sets values instantaneously and does not support + * interpolation between frames. + */ +SPINE_C_API bool spine_slider_timeline_get_instant(spine_slider_timeline self); SPINE_C_API size_t spine_slider_timeline_get_frame_entries(spine_slider_timeline self); SPINE_C_API size_t spine_slider_timeline_get_frame_count(spine_slider_timeline self); SPINE_C_API spine_array_float spine_slider_timeline_get_frames(spine_slider_timeline self); diff --git a/spine-c/src/generated/slot_curve_timeline.cpp b/spine-c/src/generated/slot_curve_timeline.cpp index 4c4dbc522..901ba65c9 100644 --- a/spine-c/src/generated/slot_curve_timeline.cpp +++ b/spine-c/src/generated/slot_curve_timeline.cpp @@ -13,10 +13,9 @@ spine_rtti spine_slot_curve_timeline_get_rtti(spine_slot_curve_timeline self) { } void spine_slot_curve_timeline_apply(spine_slot_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) { SlotCurveTimeline *_self = (SlotCurveTimeline *) self; - _self->apply(*((Skeleton *) skeleton), lastTime, time, (Array *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose); + _self->apply(*((Skeleton *) skeleton), lastTime, time, (Array *) events, alpha, fromSetup, add, out, appliedPose); } int spine_slot_curve_timeline_get_slot_index(spine_slot_curve_timeline self) { @@ -55,6 +54,16 @@ spine_array_float spine_slot_curve_timeline_get_curves(spine_slot_curve_timeline return (spine_array_float) &_self->getCurves(); } +bool spine_slot_curve_timeline_get_additive(spine_slot_curve_timeline self) { + SlotCurveTimeline *_self = (SlotCurveTimeline *) self; + return _self->getAdditive(); +} + +bool spine_slot_curve_timeline_get_instant(spine_slot_curve_timeline self) { + SlotCurveTimeline *_self = (SlotCurveTimeline *) self; + return _self->getInstant(); +} + size_t spine_slot_curve_timeline_get_frame_entries(spine_slot_curve_timeline self) { SlotCurveTimeline *_self = (SlotCurveTimeline *) self; return _self->getFrameEntries(); diff --git a/spine-c/src/generated/slot_curve_timeline.h b/spine-c/src/generated/slot_curve_timeline.h index d80a76f3f..d3998a35f 100644 --- a/spine-c/src/generated/slot_curve_timeline.h +++ b/spine-c/src/generated/slot_curve_timeline.h @@ -13,8 +13,8 @@ SPINE_C_API void spine_slot_curve_timeline_dispose(spine_slot_curve_timeline sel SPINE_C_API spine_rtti spine_slot_curve_timeline_get_rtti(spine_slot_curve_timeline self); SPINE_C_API void spine_slot_curve_timeline_apply(spine_slot_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); SPINE_C_API int spine_slot_curve_timeline_get_slot_index(spine_slot_curve_timeline self); SPINE_C_API void spine_slot_curve_timeline_set_slot_index(spine_slot_curve_timeline self, int inValue); SPINE_C_API void spine_slot_curve_timeline_set_linear(spine_slot_curve_timeline self, size_t frame); @@ -23,6 +23,15 @@ SPINE_C_API void spine_slot_curve_timeline_set_bezier(spine_slot_curve_timeline float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2); SPINE_C_API float spine_slot_curve_timeline_get_bezier_value(spine_slot_curve_timeline self, float time, size_t frame, size_t valueOffset, size_t i); SPINE_C_API spine_array_float spine_slot_curve_timeline_get_curves(spine_slot_curve_timeline self); +/** + * True if this timeline supports additive blending. + */ +SPINE_C_API bool spine_slot_curve_timeline_get_additive(spine_slot_curve_timeline self); +/** + * True if this timeline sets values instantaneously and does not support + * interpolation between frames. + */ +SPINE_C_API bool spine_slot_curve_timeline_get_instant(spine_slot_curve_timeline self); SPINE_C_API size_t spine_slot_curve_timeline_get_frame_entries(spine_slot_curve_timeline self); SPINE_C_API size_t spine_slot_curve_timeline_get_frame_count(spine_slot_curve_timeline self); SPINE_C_API spine_array_float spine_slot_curve_timeline_get_frames(spine_slot_curve_timeline self); diff --git a/spine-c/src/generated/slot_data.h b/spine-c/src/generated/slot_data.h index 81052dd9f..1917d1fcd 100644 --- a/spine-c/src/generated/slot_data.h +++ b/spine-c/src/generated/slot_data.h @@ -14,7 +14,7 @@ SPINE_C_API spine_slot_data spine_slot_data_create(int index, const char *name, SPINE_C_API void spine_slot_data_dispose(spine_slot_data self); /** - * The index of the slot in Skeleton::getSlots(). + * The Skeleton::getSlots() index. */ SPINE_C_API int spine_slot_data_get_index(spine_slot_data self); /** @@ -39,10 +39,6 @@ SPINE_C_API void spine_slot_data_set_blend_mode(spine_slot_data self, spine_blen SPINE_C_API bool spine_slot_data_get_visible(spine_slot_data self); SPINE_C_API void spine_slot_data_set_visible(spine_slot_data self, bool visible); SPINE_C_API spine_slot_pose spine_slot_data_get_setup_pose(spine_slot_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_slot_data_get_name(spine_slot_data self); /** * When true, Skeleton::updateWorldTransform(Physics) only updates this diff --git a/spine-c/src/generated/timeline.cpp b/spine-c/src/generated/timeline.cpp index c43ccb502..9391012e1 100644 --- a/spine-c/src/generated/timeline.cpp +++ b/spine-c/src/generated/timeline.cpp @@ -13,9 +13,19 @@ spine_rtti spine_timeline_get_rtti(spine_timeline self) { } void spine_timeline_apply(spine_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) { Timeline *_self = (Timeline *) self; - _self->apply(*((Skeleton *) skeleton), lastTime, time, (Array *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose); + _self->apply(*((Skeleton *) skeleton), lastTime, time, (Array *) events, alpha, fromSetup, add, out, appliedPose); +} + +bool spine_timeline_get_additive(spine_timeline self) { + Timeline *_self = (Timeline *) self; + return _self->getAdditive(); +} + +bool spine_timeline_get_instant(spine_timeline self) { + Timeline *_self = (Timeline *) self; + return _self->getInstant(); } size_t spine_timeline_get_frame_entries(spine_timeline self) { diff --git a/spine-c/src/generated/timeline.h b/spine-c/src/generated/timeline.h index d8298a154..263b5059c 100644 --- a/spine-c/src/generated/timeline.h +++ b/spine-c/src/generated/timeline.h @@ -13,19 +13,29 @@ SPINE_C_API void spine_timeline_dispose(spine_timeline self); SPINE_C_API spine_rtti spine_timeline_get_rtti(spine_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_timeline_apply(spine_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); +/** + * True if this timeline supports additive blending. + */ +SPINE_C_API bool spine_timeline_get_additive(spine_timeline self); +/** + * True if this timeline sets values instantaneously and does not support + * interpolation between frames. + */ +SPINE_C_API bool spine_timeline_get_instant(spine_timeline self); SPINE_C_API size_t spine_timeline_get_frame_entries(spine_timeline self); SPINE_C_API size_t spine_timeline_get_frame_count(spine_timeline self); SPINE_C_API spine_array_float spine_timeline_get_frames(spine_timeline self); diff --git a/spine-c/src/generated/track_entry.cpp b/spine-c/src/generated/track_entry.cpp index 014b5ddfc..563074923 100644 --- a/spine-c/src/generated/track_entry.cpp +++ b/spine-c/src/generated/track_entry.cpp @@ -41,14 +41,14 @@ void spine_track_entry_set_loop(spine_track_entry self, bool inValue) { _self->setLoop(inValue); } -bool spine_track_entry_get_hold_previous(spine_track_entry self) { +bool spine_track_entry_get_additive(spine_track_entry self) { TrackEntry *_self = (TrackEntry *) self; - return _self->getHoldPrevious(); + return _self->getAdditive(); } -void spine_track_entry_set_hold_previous(spine_track_entry self, bool inValue) { +void spine_track_entry_set_additive(spine_track_entry self, bool inValue) { TrackEntry *_self = (TrackEntry *) self; - _self->setHoldPrevious(inValue); + _self->setAdditive(inValue); } bool spine_track_entry_get_reverse(spine_track_entry self) { @@ -231,16 +231,6 @@ void spine_track_entry_set_mix_duration_2(spine_track_entry self, float mixDurat _self->setMixDuration(mixDuration, delay); } -spine_mix_blend spine_track_entry_get_mix_blend(spine_track_entry self) { - TrackEntry *_self = (TrackEntry *) self; - return (spine_mix_blend) _self->getMixBlend(); -} - -void spine_track_entry_set_mix_blend(spine_track_entry self, spine_mix_blend blend) { - TrackEntry *_self = (TrackEntry *) self; - _self->setMixBlend((MixBlend) blend); -} - /*@null*/ spine_track_entry spine_track_entry_get_mixing_from(spine_track_entry self) { TrackEntry *_self = (TrackEntry *) self; return (spine_track_entry) _self->getMixingFrom(); diff --git a/spine-c/src/generated/track_entry.h b/spine-c/src/generated/track_entry.h index 38e6804f3..f439a94f9 100644 --- a/spine-c/src/generated/track_entry.h +++ b/spine-c/src/generated/track_entry.h @@ -33,23 +33,13 @@ SPINE_C_API /*@null*/ spine_track_entry spine_track_entry_get_previous(spine_tra SPINE_C_API bool spine_track_entry_get_loop(spine_track_entry self); SPINE_C_API void spine_track_entry_set_loop(spine_track_entry self, bool inValue); /** - * If true, when mixing from the previous animation to this animation, the - * previous animation is applied as normal instead of being mixed out. - * - * When mixing between animations that key the same property, if a lower track - * also keys that property then the value will briefly dip toward the lower - * track value during the mix. This happens because the first animation mixes - * from 100% to 0% while the second animation mixes from 0% to 100%. Setting - * holdPrevious to true applies the first animation at 100% during the mix so - * the lower track value is overwritten. Such dipping does not occur on the - * lowest track which keys the property, only when a higher track also keys the - * property. - * - * Snapping will occur if holdPrevious is true and this animation does not key - * all the same properties as the previous animation. + * When true, timelines in this animation that support additive have their + * values added to the setup or current pose values instead of replacing them. + * Additive can be set for a new track entry only before AnimationState::apply() + * is next called. */ -SPINE_C_API bool spine_track_entry_get_hold_previous(spine_track_entry self); -SPINE_C_API void spine_track_entry_set_hold_previous(spine_track_entry self, bool inValue); +SPINE_C_API bool spine_track_entry_get_additive(spine_track_entry self); +SPINE_C_API void spine_track_entry_set_additive(spine_track_entry self, bool inValue); SPINE_C_API bool spine_track_entry_get_reverse(spine_track_entry self); SPINE_C_API void spine_track_entry_set_reverse(spine_track_entry self, bool inValue); SPINE_C_API bool spine_track_entry_get_shortest_rotation(spine_track_entry self); @@ -223,19 +213,16 @@ SPINE_C_API void spine_track_entry_set_mix_duration_1(spine_track_entry self, fl * @param delay If > 0, sets TrackEntry::getDelay(). If < = 0, the delay set is the duration of the previous track entry minus the specified mix duration plus the specified delay (ie the mix ends at (delay = 0) or before (delay < 0) the previous track entry duration). If the previous entry is looping, its next loop completion is used instead of its duration. */ SPINE_C_API void spine_track_entry_set_mix_duration_2(spine_track_entry self, float mixDuration, float delay); -SPINE_C_API spine_mix_blend spine_track_entry_get_mix_blend(spine_track_entry self); -SPINE_C_API void spine_track_entry_set_mix_blend(spine_track_entry self, spine_mix_blend blend); /** - * The track entry for the previous animation when mixing from the previous - * animation to this animation, or NULL if no mixing is currently occuring. When - * mixing from multiple animations, MixingFrom makes up a double linked list - * with MixingTo. + * The track entry for the previous animation when mixing to this animation, or + * NULL if no mixing is currently occurring. When mixing from multiple + * animations, MixingFrom makes up a doubly linked list with MixingTo. */ SPINE_C_API /*@null*/ spine_track_entry spine_track_entry_get_mixing_from(spine_track_entry self); /** * The track entry for the next animation when mixing from this animation, or - * NULL if no mixing is currently occuring. When mixing from multiple - * animations, MixingTo makes up a double linked list with MixingFrom. + * NULL if no mixing is currently occurring. When mixing to multiple animations, + * MixingTo makes up a doubly linked list with MixingFrom. */ SPINE_C_API /*@null*/ spine_track_entry spine_track_entry_get_mixing_to(spine_track_entry self); /** diff --git a/spine-c/src/generated/transform_constraint.h b/spine-c/src/generated/transform_constraint.h index 3bae04d4d..d5e0aad54 100644 --- a/spine-c/src/generated/transform_constraint.h +++ b/spine-c/src/generated/transform_constraint.h @@ -36,6 +36,13 @@ SPINE_C_API spine_transform_constraint_pose spine_transform_constraint_get_appli SPINE_C_API void spine_transform_constraint_reset_constrained(spine_transform_constraint self); SPINE_C_API void spine_transform_constraint_constrained(spine_transform_constraint self); SPINE_C_API bool spine_transform_constraint_is_pose_equal_to_applied(spine_transform_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_transform_constraint_is_active(spine_transform_constraint self); SPINE_C_API void spine_transform_constraint_set_active(spine_transform_constraint self, bool active); SPINE_C_API spine_rtti spine_transform_constraint_rtti(void); diff --git a/spine-c/src/generated/transform_constraint_base.h b/spine-c/src/generated/transform_constraint_base.h index 8738430e4..2fa47dc8a 100644 --- a/spine-c/src/generated/transform_constraint_base.h +++ b/spine-c/src/generated/transform_constraint_base.h @@ -17,6 +17,13 @@ SPINE_C_API spine_transform_constraint_pose spine_transform_constraint_base_get_ SPINE_C_API void spine_transform_constraint_base_reset_constrained(spine_transform_constraint_base self); SPINE_C_API void spine_transform_constraint_base_constrained(spine_transform_constraint_base self); SPINE_C_API bool spine_transform_constraint_base_is_pose_equal_to_applied(spine_transform_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_transform_constraint_base_is_active(spine_transform_constraint_base self); SPINE_C_API void spine_transform_constraint_base_set_active(spine_transform_constraint_base self, bool active); SPINE_C_API spine_rtti spine_transform_constraint_base_get_rtti(spine_transform_constraint_base self); diff --git a/spine-c/src/generated/transform_constraint_timeline.cpp b/spine-c/src/generated/transform_constraint_timeline.cpp index 1e4a4daa1..e4636feda 100644 --- a/spine-c/src/generated/transform_constraint_timeline.cpp +++ b/spine-c/src/generated/transform_constraint_timeline.cpp @@ -18,10 +18,10 @@ spine_rtti spine_transform_constraint_timeline_get_rtti(spine_transform_constrai } void spine_transform_constraint_timeline_apply(spine_transform_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, + /*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add, bool out, bool appliedPose) { TransformConstraintTimeline *_self = (TransformConstraintTimeline *) self; - _self->apply(*((Skeleton *) skeleton), lastTime, time, (Array *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose); + _self->apply(*((Skeleton *) skeleton), lastTime, time, (Array *) events, alpha, fromSetup, add, out, appliedPose); } void spine_transform_constraint_timeline_set_frame(spine_transform_constraint_timeline self, int frame, float time, float mixRotate, float mixX, @@ -67,6 +67,16 @@ spine_array_float spine_transform_constraint_timeline_get_curves(spine_transform return (spine_array_float) &_self->getCurves(); } +bool spine_transform_constraint_timeline_get_additive(spine_transform_constraint_timeline self) { + TransformConstraintTimeline *_self = (TransformConstraintTimeline *) self; + return _self->getAdditive(); +} + +bool spine_transform_constraint_timeline_get_instant(spine_transform_constraint_timeline self) { + TransformConstraintTimeline *_self = (TransformConstraintTimeline *) self; + return _self->getInstant(); +} + size_t spine_transform_constraint_timeline_get_frame_entries(spine_transform_constraint_timeline self) { TransformConstraintTimeline *_self = (TransformConstraintTimeline *) self; return _self->getFrameEntries(); diff --git a/spine-c/src/generated/transform_constraint_timeline.h b/spine-c/src/generated/transform_constraint_timeline.h index 3bc218331..fd3891e0e 100644 --- a/spine-c/src/generated/transform_constraint_timeline.h +++ b/spine-c/src/generated/transform_constraint_timeline.h @@ -16,8 +16,8 @@ SPINE_C_API void spine_transform_constraint_timeline_dispose(spine_transform_con SPINE_C_API spine_rtti spine_transform_constraint_timeline_get_rtti(spine_transform_constraint_timeline self); SPINE_C_API void spine_transform_constraint_timeline_apply(spine_transform_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); + float time, /*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add, + bool out, bool appliedPose); /** * Sets the time, rotate mix, translate mix, scale mix, and shear mix for the * specified frame. @@ -37,6 +37,15 @@ SPINE_C_API void spine_transform_constraint_timeline_set_bezier(spine_transform_ SPINE_C_API float spine_transform_constraint_timeline_get_bezier_value(spine_transform_constraint_timeline self, float time, size_t frame, size_t valueOffset, size_t i); SPINE_C_API spine_array_float spine_transform_constraint_timeline_get_curves(spine_transform_constraint_timeline self); +/** + * True if this timeline supports additive blending. + */ +SPINE_C_API bool spine_transform_constraint_timeline_get_additive(spine_transform_constraint_timeline self); +/** + * True if this timeline sets values instantaneously and does not support + * interpolation between frames. + */ +SPINE_C_API bool spine_transform_constraint_timeline_get_instant(spine_transform_constraint_timeline self); SPINE_C_API size_t spine_transform_constraint_timeline_get_frame_entries(spine_transform_constraint_timeline self); SPINE_C_API size_t spine_transform_constraint_timeline_get_frame_count(spine_transform_constraint_timeline self); SPINE_C_API spine_array_float spine_transform_constraint_timeline_get_frames(spine_transform_constraint_timeline self); diff --git a/spine-c/src/generated/translate_timeline.cpp b/spine-c/src/generated/translate_timeline.cpp index 8fcd2c36a..cc82df5d1 100644 --- a/spine-c/src/generated/translate_timeline.cpp +++ b/spine-c/src/generated/translate_timeline.cpp @@ -17,10 +17,9 @@ spine_rtti spine_translate_timeline_get_rtti(spine_translate_timeline self) { } void spine_translate_timeline_apply(spine_translate_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) { TranslateTimeline *_self = (TranslateTimeline *) self; - _self->apply(*((Skeleton *) skeleton), lastTime, time, (Array *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose); + _self->apply(*((Skeleton *) skeleton), lastTime, time, (Array *) events, alpha, fromSetup, add, out, appliedPose); } int spine_translate_timeline_get_bone_index(spine_translate_timeline self) { @@ -64,6 +63,16 @@ spine_array_float spine_translate_timeline_get_curves(spine_translate_timeline s return (spine_array_float) &_self->getCurves(); } +bool spine_translate_timeline_get_additive(spine_translate_timeline self) { + TranslateTimeline *_self = (TranslateTimeline *) self; + return _self->getAdditive(); +} + +bool spine_translate_timeline_get_instant(spine_translate_timeline self) { + TranslateTimeline *_self = (TranslateTimeline *) self; + return _self->getInstant(); +} + size_t spine_translate_timeline_get_frame_entries(spine_translate_timeline self) { TranslateTimeline *_self = (TranslateTimeline *) self; return _self->getFrameEntries(); diff --git a/spine-c/src/generated/translate_timeline.h b/spine-c/src/generated/translate_timeline.h index 4124d4541..a0316f827 100644 --- a/spine-c/src/generated/translate_timeline.h +++ b/spine-c/src/generated/translate_timeline.h @@ -15,7 +15,7 @@ SPINE_C_API void spine_translate_timeline_dispose(spine_translate_timeline self) SPINE_C_API spine_rtti spine_translate_timeline_get_rtti(spine_translate_timeline self); SPINE_C_API void spine_translate_timeline_apply(spine_translate_timeline self, spine_skeleton skeleton, float lastTime, float time, - /*@null*/ spine_array_event events, float alpha, spine_mix_blend blend, spine_mix_direction direction, + /*@null*/ spine_array_event events, float alpha, bool fromSetup, bool add, bool out, bool appliedPose); SPINE_C_API int spine_translate_timeline_get_bone_index(spine_translate_timeline self); SPINE_C_API void spine_translate_timeline_set_bone_index(spine_translate_timeline self, int inValue); @@ -26,6 +26,15 @@ SPINE_C_API void spine_translate_timeline_set_bezier(spine_translate_timeline se float value1, float cx1, float cy1, float cx2, float cy2, float time2, float value2); SPINE_C_API float spine_translate_timeline_get_bezier_value(spine_translate_timeline self, float time, size_t frame, size_t valueOffset, size_t i); SPINE_C_API spine_array_float spine_translate_timeline_get_curves(spine_translate_timeline self); +/** + * True if this timeline supports additive blending. + */ +SPINE_C_API bool spine_translate_timeline_get_additive(spine_translate_timeline self); +/** + * True if this timeline sets values instantaneously and does not support + * interpolation between frames. + */ +SPINE_C_API bool spine_translate_timeline_get_instant(spine_translate_timeline self); SPINE_C_API size_t spine_translate_timeline_get_frame_entries(spine_translate_timeline self); SPINE_C_API size_t spine_translate_timeline_get_frame_count(spine_translate_timeline self); SPINE_C_API spine_array_float spine_translate_timeline_get_frames(spine_translate_timeline self); diff --git a/spine-c/src/generated/translate_x_timeline.cpp b/spine-c/src/generated/translate_x_timeline.cpp index 35e9fa2b9..377f48ccd 100644 --- a/spine-c/src/generated/translate_x_timeline.cpp +++ b/spine-c/src/generated/translate_x_timeline.cpp @@ -17,10 +17,9 @@ spine_rtti spine_translate_x_timeline_get_rtti(spine_translate_x_timeline self) } void spine_translate_x_timeline_apply(spine_translate_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) { TranslateXTimeline *_self = (TranslateXTimeline *) self; - _self->apply(*((Skeleton *) skeleton), lastTime, time, (Array *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose); + _self->apply(*((Skeleton *) skeleton), lastTime, time, (Array *) events, alpha, fromSetup, add, out, appliedPose); } int spine_translate_x_timeline_get_bone_index(spine_translate_x_timeline self) { @@ -43,28 +42,28 @@ float spine_translate_x_timeline_get_curve_value(spine_translate_x_timeline self return _self->getCurveValue(time); } -float spine_translate_x_timeline_get_relative_value(spine_translate_x_timeline self, float time, float alpha, spine_mix_blend blend, float current, +float spine_translate_x_timeline_get_relative_value(spine_translate_x_timeline self, float time, float alpha, bool fromSetup, bool add, float current, float setup) { TranslateXTimeline *_self = (TranslateXTimeline *) self; - return _self->getRelativeValue(time, alpha, (MixBlend) blend, current, setup); + return _self->getRelativeValue(time, alpha, fromSetup, add, current, setup); } -float spine_translate_x_timeline_get_absolute_value_1(spine_translate_x_timeline self, float time, float alpha, spine_mix_blend blend, float current, - float setup) { +float spine_translate_x_timeline_get_absolute_value_1(spine_translate_x_timeline self, float time, float alpha, bool fromSetup, bool add, + float current, float setup) { TranslateXTimeline *_self = (TranslateXTimeline *) self; - return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup); + return _self->getAbsoluteValue(time, alpha, fromSetup, add, current, setup); } -float spine_translate_x_timeline_get_absolute_value_2(spine_translate_x_timeline self, float time, float alpha, spine_mix_blend blend, float current, - float setup, float value) { +float spine_translate_x_timeline_get_absolute_value_2(spine_translate_x_timeline self, float time, float alpha, bool fromSetup, bool add, + float current, float setup, float value) { TranslateXTimeline *_self = (TranslateXTimeline *) self; - return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup, value); + return _self->getAbsoluteValue(time, alpha, fromSetup, add, current, setup, value); } -float spine_translate_x_timeline_get_scale_value(spine_translate_x_timeline self, float time, float alpha, spine_mix_blend blend, - spine_mix_direction direction, float current, float setup) { +float spine_translate_x_timeline_get_scale_value(spine_translate_x_timeline self, float time, float alpha, bool fromSetup, bool add, bool out, + float current, float setup) { TranslateXTimeline *_self = (TranslateXTimeline *) self; - return _self->getScaleValue(time, alpha, (MixBlend) blend, (MixDirection) direction, current, setup); + return _self->getScaleValue(time, alpha, fromSetup, add, out, current, setup); } void spine_translate_x_timeline_set_linear(spine_translate_x_timeline self, size_t frame) { @@ -93,6 +92,16 @@ spine_array_float spine_translate_x_timeline_get_curves(spine_translate_x_timeli return (spine_array_float) &_self->getCurves(); } +bool spine_translate_x_timeline_get_additive(spine_translate_x_timeline self) { + TranslateXTimeline *_self = (TranslateXTimeline *) self; + return _self->getAdditive(); +} + +bool spine_translate_x_timeline_get_instant(spine_translate_x_timeline self) { + TranslateXTimeline *_self = (TranslateXTimeline *) self; + return _self->getInstant(); +} + size_t spine_translate_x_timeline_get_frame_entries(spine_translate_x_timeline self) { TranslateXTimeline *_self = (TranslateXTimeline *) self; return _self->getFrameEntries(); diff --git a/spine-c/src/generated/translate_x_timeline.h b/spine-c/src/generated/translate_x_timeline.h index 5bd97fba5..75bf1ddd9 100644 --- a/spine-c/src/generated/translate_x_timeline.h +++ b/spine-c/src/generated/translate_x_timeline.h @@ -15,8 +15,8 @@ SPINE_C_API void spine_translate_x_timeline_dispose(spine_translate_x_timeline s SPINE_C_API spine_rtti spine_translate_x_timeline_get_rtti(spine_translate_x_timeline self); SPINE_C_API void spine_translate_x_timeline_apply(spine_translate_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_translate_x_timeline_get_bone_index(spine_translate_x_timeline self); SPINE_C_API void spine_translate_x_timeline_set_bone_index(spine_translate_x_timeline self, int inValue); /** @@ -30,14 +30,14 @@ SPINE_C_API void spine_translate_x_timeline_set_frame(spine_translate_x_timeline * Returns the interpolated value for the specified time. */ SPINE_C_API float spine_translate_x_timeline_get_curve_value(spine_translate_x_timeline self, float time); -SPINE_C_API float spine_translate_x_timeline_get_relative_value(spine_translate_x_timeline self, float time, float alpha, spine_mix_blend blend, +SPINE_C_API float spine_translate_x_timeline_get_relative_value(spine_translate_x_timeline self, float time, float alpha, bool fromSetup, bool add, float current, float setup); -SPINE_C_API float spine_translate_x_timeline_get_absolute_value_1(spine_translate_x_timeline self, float time, float alpha, spine_mix_blend blend, +SPINE_C_API float spine_translate_x_timeline_get_absolute_value_1(spine_translate_x_timeline self, float time, float alpha, bool fromSetup, bool add, float current, float setup); -SPINE_C_API float spine_translate_x_timeline_get_absolute_value_2(spine_translate_x_timeline self, float time, float alpha, spine_mix_blend blend, +SPINE_C_API float spine_translate_x_timeline_get_absolute_value_2(spine_translate_x_timeline self, float time, float alpha, bool fromSetup, bool add, float current, float setup, float value); -SPINE_C_API float spine_translate_x_timeline_get_scale_value(spine_translate_x_timeline self, float time, float alpha, spine_mix_blend blend, - spine_mix_direction direction, float current, float setup); +SPINE_C_API float spine_translate_x_timeline_get_scale_value(spine_translate_x_timeline self, float time, float alpha, bool fromSetup, bool add, + bool out, float current, float setup); SPINE_C_API void spine_translate_x_timeline_set_linear(spine_translate_x_timeline self, size_t frame); SPINE_C_API void spine_translate_x_timeline_set_stepped(spine_translate_x_timeline self, size_t frame); SPINE_C_API void spine_translate_x_timeline_set_bezier(spine_translate_x_timeline self, size_t bezier, size_t frame, float value, float time1, @@ -45,6 +45,15 @@ SPINE_C_API void spine_translate_x_timeline_set_bezier(spine_translate_x_timelin SPINE_C_API float spine_translate_x_timeline_get_bezier_value(spine_translate_x_timeline self, float time, size_t frame, size_t valueOffset, size_t i); SPINE_C_API spine_array_float spine_translate_x_timeline_get_curves(spine_translate_x_timeline self); +/** + * True if this timeline supports additive blending. + */ +SPINE_C_API bool spine_translate_x_timeline_get_additive(spine_translate_x_timeline self); +/** + * True if this timeline sets values instantaneously and does not support + * interpolation between frames. + */ +SPINE_C_API bool spine_translate_x_timeline_get_instant(spine_translate_x_timeline self); SPINE_C_API size_t spine_translate_x_timeline_get_frame_entries(spine_translate_x_timeline self); SPINE_C_API size_t spine_translate_x_timeline_get_frame_count(spine_translate_x_timeline self); SPINE_C_API spine_array_float spine_translate_x_timeline_get_frames(spine_translate_x_timeline self); diff --git a/spine-c/src/generated/translate_y_timeline.cpp b/spine-c/src/generated/translate_y_timeline.cpp index 8c51ee11e..9e0663ff9 100644 --- a/spine-c/src/generated/translate_y_timeline.cpp +++ b/spine-c/src/generated/translate_y_timeline.cpp @@ -17,10 +17,9 @@ spine_rtti spine_translate_y_timeline_get_rtti(spine_translate_y_timeline self) } void spine_translate_y_timeline_apply(spine_translate_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) { TranslateYTimeline *_self = (TranslateYTimeline *) self; - _self->apply(*((Skeleton *) skeleton), lastTime, time, (Array *) events, alpha, (MixBlend) blend, (MixDirection) direction, appliedPose); + _self->apply(*((Skeleton *) skeleton), lastTime, time, (Array *) events, alpha, fromSetup, add, out, appliedPose); } int spine_translate_y_timeline_get_bone_index(spine_translate_y_timeline self) { @@ -43,28 +42,28 @@ float spine_translate_y_timeline_get_curve_value(spine_translate_y_timeline self return _self->getCurveValue(time); } -float spine_translate_y_timeline_get_relative_value(spine_translate_y_timeline self, float time, float alpha, spine_mix_blend blend, float current, +float spine_translate_y_timeline_get_relative_value(spine_translate_y_timeline self, float time, float alpha, bool fromSetup, bool add, float current, float setup) { TranslateYTimeline *_self = (TranslateYTimeline *) self; - return _self->getRelativeValue(time, alpha, (MixBlend) blend, current, setup); + return _self->getRelativeValue(time, alpha, fromSetup, add, current, setup); } -float spine_translate_y_timeline_get_absolute_value_1(spine_translate_y_timeline self, float time, float alpha, spine_mix_blend blend, float current, - float setup) { +float spine_translate_y_timeline_get_absolute_value_1(spine_translate_y_timeline self, float time, float alpha, bool fromSetup, bool add, + float current, float setup) { TranslateYTimeline *_self = (TranslateYTimeline *) self; - return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup); + return _self->getAbsoluteValue(time, alpha, fromSetup, add, current, setup); } -float spine_translate_y_timeline_get_absolute_value_2(spine_translate_y_timeline self, float time, float alpha, spine_mix_blend blend, float current, - float setup, float value) { +float spine_translate_y_timeline_get_absolute_value_2(spine_translate_y_timeline self, float time, float alpha, bool fromSetup, bool add, + float current, float setup, float value) { TranslateYTimeline *_self = (TranslateYTimeline *) self; - return _self->getAbsoluteValue(time, alpha, (MixBlend) blend, current, setup, value); + return _self->getAbsoluteValue(time, alpha, fromSetup, add, current, setup, value); } -float spine_translate_y_timeline_get_scale_value(spine_translate_y_timeline self, float time, float alpha, spine_mix_blend blend, - spine_mix_direction direction, float current, float setup) { +float spine_translate_y_timeline_get_scale_value(spine_translate_y_timeline self, float time, float alpha, bool fromSetup, bool add, bool out, + float current, float setup) { TranslateYTimeline *_self = (TranslateYTimeline *) self; - return _self->getScaleValue(time, alpha, (MixBlend) blend, (MixDirection) direction, current, setup); + return _self->getScaleValue(time, alpha, fromSetup, add, out, current, setup); } void spine_translate_y_timeline_set_linear(spine_translate_y_timeline self, size_t frame) { @@ -93,6 +92,16 @@ spine_array_float spine_translate_y_timeline_get_curves(spine_translate_y_timeli return (spine_array_float) &_self->getCurves(); } +bool spine_translate_y_timeline_get_additive(spine_translate_y_timeline self) { + TranslateYTimeline *_self = (TranslateYTimeline *) self; + return _self->getAdditive(); +} + +bool spine_translate_y_timeline_get_instant(spine_translate_y_timeline self) { + TranslateYTimeline *_self = (TranslateYTimeline *) self; + return _self->getInstant(); +} + size_t spine_translate_y_timeline_get_frame_entries(spine_translate_y_timeline self) { TranslateYTimeline *_self = (TranslateYTimeline *) self; return _self->getFrameEntries(); diff --git a/spine-c/src/generated/translate_y_timeline.h b/spine-c/src/generated/translate_y_timeline.h index 49d46aa92..4be0a79b1 100644 --- a/spine-c/src/generated/translate_y_timeline.h +++ b/spine-c/src/generated/translate_y_timeline.h @@ -15,8 +15,8 @@ SPINE_C_API void spine_translate_y_timeline_dispose(spine_translate_y_timeline s SPINE_C_API spine_rtti spine_translate_y_timeline_get_rtti(spine_translate_y_timeline self); SPINE_C_API void spine_translate_y_timeline_apply(spine_translate_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_translate_y_timeline_get_bone_index(spine_translate_y_timeline self); SPINE_C_API void spine_translate_y_timeline_set_bone_index(spine_translate_y_timeline self, int inValue); /** @@ -30,14 +30,14 @@ SPINE_C_API void spine_translate_y_timeline_set_frame(spine_translate_y_timeline * Returns the interpolated value for the specified time. */ SPINE_C_API float spine_translate_y_timeline_get_curve_value(spine_translate_y_timeline self, float time); -SPINE_C_API float spine_translate_y_timeline_get_relative_value(spine_translate_y_timeline self, float time, float alpha, spine_mix_blend blend, +SPINE_C_API float spine_translate_y_timeline_get_relative_value(spine_translate_y_timeline self, float time, float alpha, bool fromSetup, bool add, float current, float setup); -SPINE_C_API float spine_translate_y_timeline_get_absolute_value_1(spine_translate_y_timeline self, float time, float alpha, spine_mix_blend blend, +SPINE_C_API float spine_translate_y_timeline_get_absolute_value_1(spine_translate_y_timeline self, float time, float alpha, bool fromSetup, bool add, float current, float setup); -SPINE_C_API float spine_translate_y_timeline_get_absolute_value_2(spine_translate_y_timeline self, float time, float alpha, spine_mix_blend blend, +SPINE_C_API float spine_translate_y_timeline_get_absolute_value_2(spine_translate_y_timeline self, float time, float alpha, bool fromSetup, bool add, float current, float setup, float value); -SPINE_C_API float spine_translate_y_timeline_get_scale_value(spine_translate_y_timeline self, float time, float alpha, spine_mix_blend blend, - spine_mix_direction direction, float current, float setup); +SPINE_C_API float spine_translate_y_timeline_get_scale_value(spine_translate_y_timeline self, float time, float alpha, bool fromSetup, bool add, + bool out, float current, float setup); SPINE_C_API void spine_translate_y_timeline_set_linear(spine_translate_y_timeline self, size_t frame); SPINE_C_API void spine_translate_y_timeline_set_stepped(spine_translate_y_timeline self, size_t frame); SPINE_C_API void spine_translate_y_timeline_set_bezier(spine_translate_y_timeline self, size_t bezier, size_t frame, float value, float time1, @@ -45,6 +45,15 @@ SPINE_C_API void spine_translate_y_timeline_set_bezier(spine_translate_y_timelin SPINE_C_API float spine_translate_y_timeline_get_bezier_value(spine_translate_y_timeline self, float time, size_t frame, size_t valueOffset, size_t i); SPINE_C_API spine_array_float spine_translate_y_timeline_get_curves(spine_translate_y_timeline self); +/** + * True if this timeline supports additive blending. + */ +SPINE_C_API bool spine_translate_y_timeline_get_additive(spine_translate_y_timeline self); +/** + * True if this timeline sets values instantaneously and does not support + * interpolation between frames. + */ +SPINE_C_API bool spine_translate_y_timeline_get_instant(spine_translate_y_timeline self); SPINE_C_API size_t spine_translate_y_timeline_get_frame_entries(spine_translate_y_timeline self); SPINE_C_API size_t spine_translate_y_timeline_get_frame_count(spine_translate_y_timeline self); SPINE_C_API spine_array_float spine_translate_y_timeline_get_frames(spine_translate_y_timeline self); diff --git a/spine-c/src/generated/types.h b/spine-c/src/generated/types.h index 22f3d5752..2c7b4661e 100644 --- a/spine-c/src/generated/types.h +++ b/spine-c/src/generated/types.h @@ -174,8 +174,6 @@ SPINE_OPAQUE_TYPE(spine_vertex_attachment) #include "event_type.h" #include "format.h" #include "inherit.h" -#include "mix_blend.h" -#include "mix_direction.h" #include "physics.h" #include "position_mode.h" #include "property.h" diff --git a/spine-c/src/generated/vertex_attachment.h b/spine-c/src/generated/vertex_attachment.h index 0933cf166..7407ea2e3 100644 --- a/spine-c/src/generated/vertex_attachment.h +++ b/spine-c/src/generated/vertex_attachment.h @@ -14,7 +14,7 @@ SPINE_C_API void spine_vertex_attachment_dispose(spine_vertex_attachment self); SPINE_C_API spine_rtti spine_vertex_attachment_get_rtti(spine_vertex_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. @@ -35,8 +35,20 @@ SPINE_C_API void spine_vertex_attachment_compute_world_vertices_2(spine_vertex_a * Gets a unique ID for this attachment. */ SPINE_C_API int spine_vertex_attachment_get_id(spine_vertex_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_vertex_attachment_get_bones(spine_vertex_attachment self); SPINE_C_API void spine_vertex_attachment_set_bones(spine_vertex_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_vertex_attachment_get_vertices(spine_vertex_attachment self); SPINE_C_API void spine_vertex_attachment_set_vertices(spine_vertex_attachment self, spine_array_float vertices); SPINE_C_API size_t spine_vertex_attachment_get_world_vertices_length(spine_vertex_attachment self);