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

Merge branch '3.7' into 3.8-beta

Browse Source
This commit is contained in:
badlogic 2019-02-12 14:25:12 +01:00
commit 833f8551f4
21 changed files with 307 additions and 215 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
spine-as3/spine-as3-example/lib/spine-as3.swc
View File

Binary file not shown.

43
spine-as3/spine-as3/src/spine/animation/AnimationState.as
View File

@ -300,29 +300,36 @@ package spine.animation {
var rotateTimeline : RotateTimeline = RotateTimeline(timeline); var rotateTimeline : RotateTimeline = RotateTimeline(timeline);
var frames : Vector.<Number> = rotateTimeline.frames; var frames : Vector.<Number> = rotateTimeline.frames;
var bone : Bone = skeleton.bones[rotateTimeline.boneIndex]; var bone : Bone = skeleton.bones[rotateTimeline.boneIndex];
var r1 : Number, r2 : Number;
if (time < frames[0]) { if (time < frames[0]) {
if (blend == MixBlend.setup) bone.rotation = bone.data.rotation; switch (blend) {
return; case MixBlend.setup:
} bone.rotation = bone.data.rotation;
default:
return;
case MixBlend.first:
r1 = bone.rotation;
r2 = bone.data.rotation;
}
} else {
r1 = blend == MixBlend.setup ? bone.data.rotation : bone.rotation;
if (time >= frames[frames.length - RotateTimeline.ENTRIES]) // Time is after last frame.
r2 = bone.data.rotation + frames[frames.length + RotateTimeline.PREV_ROTATION];
else {
// Interpolate between the previous frame and the current frame.
var frame : int = Animation.binarySearch(frames, time, RotateTimeline.ENTRIES);
var prevRotation : Number = frames[frame + RotateTimeline.PREV_ROTATION];
var frameTime : Number = frames[frame];
var percent : Number = rotateTimeline.getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + RotateTimeline.PREV_TIME] - frameTime));
var r2 : Number; r2 = frames[frame + RotateTimeline.ROTATION] - prevRotation;
if (time >= frames[frames.length - RotateTimeline.ENTRIES]) // Time is after last frame. r2 -= (16384 - int((16384.499999999996 - r2 / 360))) * 360;
r2 = bone.data.rotation + frames[frames.length + RotateTimeline.PREV_ROTATION]; r2 = prevRotation + r2 * percent + bone.data.rotation;
else { r2 -= (16384 - int((16384.499999999996 - r2 / 360))) * 360;
// Interpolate between the previous frame and the current frame. }
var frame : int = Animation.binarySearch(frames, time, RotateTimeline.ENTRIES);
var prevRotation : Number = frames[frame + RotateTimeline.PREV_ROTATION];
var frameTime : Number = frames[frame];
var percent : Number = rotateTimeline.getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + RotateTimeline.PREV_TIME] - frameTime));
r2 = frames[frame + RotateTimeline.ROTATION] - prevRotation;
r2 -= (16384 - int((16384.499999999996 - r2 / 360))) * 360;
r2 = prevRotation + r2 * percent + bone.data.rotation;
r2 -= (16384 - int((16384.499999999996 - r2 / 360))) * 360;
} }
// Mix between rotations using the direction of the shortest route on the first frame while detecting crosses. // Mix between rotations using the direction of the shortest route on the first frame while detecting crosses.
var r1 : Number = blend == MixBlend.setup ? bone.data.rotation : bone.rotation;
var total : Number, diff : Number = r2 - r1; var total : Number, diff : Number = r2 - r1;
diff -= (16384 - int((16384.499999999996 - diff / 360))) * 360; diff -= (16384 - int((16384.499999999996 - diff / 360))) * 360;
if (diff == 0) { if (diff == 0) {

44
spine-c/spine-c/src/spine/AnimationState.c
View File

@ -538,30 +538,36 @@ void _spAnimationState_applyRotateTimeline (spAnimationState* self, spTimeline*
frames = rotateTimeline->frames; frames = rotateTimeline->frames;
bone = skeleton->bones[rotateTimeline->boneIndex]; bone = skeleton->bones[rotateTimeline->boneIndex];
if (time < frames[0]) { if (time < frames[0]) {
if (blend == SP_MIX_BLEND_SETUP) { switch (blend) {
bone->rotation = bone->data->rotation; case SP_MIX_BLEND_SETUP:
bone->rotation = bone->data->rotation;
default:
return;
case SP_MIX_BLEND_FIRST:
r1 = bone->rotation;
r2 = bone->data->rotation;
} }
return; /* Time is before first frame. */ } else {
} r1 = blend == SP_MIX_BLEND_SETUP ? bone->data->rotation : bone->rotation;
if (time >= frames[rotateTimeline->framesCount - ROTATE_ENTRIES]) /* Time is after last frame. */
r2 = bone->data->rotation + frames[rotateTimeline->framesCount + ROTATE_PREV_ROTATION];
else {
/* Interpolate between the previous frame and the current frame. */
frame = _spCurveTimeline_binarySearch(frames, rotateTimeline->framesCount, time, ROTATE_ENTRIES);
prevRotation = frames[frame + ROTATE_PREV_ROTATION];
frameTime = frames[frame];
percent = spCurveTimeline_getCurvePercent(SUPER(rotateTimeline), (frame >> 1) - 1,
1 - (time - frameTime) /
(frames[frame + ROTATE_PREV_TIME] - frameTime));
if (time >= frames[rotateTimeline->framesCount - ROTATE_ENTRIES]) /* Time is after last frame. */ r2 = frames[frame + ROTATE_ROTATION] - prevRotation;
r2 = bone->data->rotation + frames[rotateTimeline->framesCount + ROTATE_PREV_ROTATION]; r2 -= (16384 - (int) (16384.499999999996 - r2 / 360)) * 360;
else { r2 = prevRotation + r2 * percent + bone->data->rotation;
/* Interpolate between the previous frame and the current frame. */ r2 -= (16384 - (int) (16384.499999999996 - r2 / 360)) * 360;
frame = _spCurveTimeline_binarySearch(frames, rotateTimeline->framesCount, time, ROTATE_ENTRIES); }
prevRotation = frames[frame + ROTATE_PREV_ROTATION];
frameTime = frames[frame];
percent = spCurveTimeline_getCurvePercent(SUPER(rotateTimeline), (frame >> 1) - 1,
1 - (time - frameTime) / (frames[frame + ROTATE_PREV_TIME] - frameTime));
r2 = frames[frame + ROTATE_ROTATION] - prevRotation;
r2 -= (16384 - (int)(16384.499999999996 - r2 / 360)) * 360;
r2 = prevRotation + r2 * percent + bone->data->rotation;
r2 -= (16384 - (int)(16384.499999999996 - r2 / 360)) * 360;
} }
/* Mix between rotations using the direction of the shortest route on the first frame while detecting crosses. */ /* Mix between rotations using the direction of the shortest route on the first frame while detecting crosses. */
r1 = blend == SP_MIX_BLEND_SETUP ? bone->data->rotation : bone->rotation;
diff = r2 - r1; diff = r2 - r1;
diff -= (16384 - (int)(16384.499999999996 - diff / 360)) * 360; diff -= (16384 - (int)(16384.499999999996 - diff / 360)) * 360;
if (diff == 0) { if (diff == 0) {

47
spine-cpp/spine-cpp/src/spine/AnimationState.cpp
View File

@ -642,34 +642,39 @@ void AnimationState::applyRotateTimeline(RotateTimeline *rotateTimeline, Skeleto
Bone *bone = skeleton._bones[rotateTimeline->_boneIndex]; Bone *bone = skeleton._bones[rotateTimeline->_boneIndex];
Vector<float>& frames = rotateTimeline->_frames; Vector<float>& frames = rotateTimeline->_frames;
float r1, r2;
if (time < frames[0]) { if (time < frames[0]) {
if (blend == MixBlend_Setup) { switch (blend) {
bone->_rotation = bone->_data._rotation; case MixBlend_Setup:
bone->_rotation = bone->_data._rotation;
default:
return;
case MixBlend_First:
r1 = bone->_rotation;
r2 = bone->_data._rotation;
} }
return;
}
float r2;
if (time >= frames[frames.size() - RotateTimeline::ENTRIES]) {
// Time is after last frame.
r2 = bone->_data._rotation + frames[frames.size() + RotateTimeline::PREV_ROTATION];
} else { } else {
// Interpolate between the previous frame and the current frame. r1 = blend == MixBlend_Setup ? bone->_data._rotation : bone->_rotation;
int frame = Animation::binarySearch(frames, time, RotateTimeline::ENTRIES); if (time >= frames[frames.size() - RotateTimeline::ENTRIES]) {
float prevRotation = frames[frame + RotateTimeline::PREV_ROTATION]; // Time is after last frame.
float frameTime = frames[frame]; r2 = bone->_data._rotation + frames[frames.size() + RotateTimeline::PREV_ROTATION];
float percent = rotateTimeline->getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + } else {
RotateTimeline::PREV_TIME] - // Interpolate between the previous frame and the current frame.
frameTime)); int frame = Animation::binarySearch(frames, time, RotateTimeline::ENTRIES);
float prevRotation = frames[frame + RotateTimeline::PREV_ROTATION];
float frameTime = frames[frame];
float percent = rotateTimeline->getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame +
RotateTimeline::PREV_TIME] -
frameTime));
r2 = frames[frame + RotateTimeline::ROTATION] - prevRotation; r2 = frames[frame + RotateTimeline::ROTATION] - prevRotation;
r2 -= (16384 - (int) (16384.499999999996 - r2 / 360)) * 360; r2 -= (16384 - (int) (16384.499999999996 - r2 / 360)) * 360;
r2 = prevRotation + r2 * percent + bone->_data._rotation; r2 = prevRotation + r2 * percent + bone->_data._rotation;
r2 -= (16384 - (int) (16384.499999999996 - r2 / 360)) * 360; r2 -= (16384 - (int) (16384.499999999996 - r2 / 360)) * 360;
}
} }
// Mix between rotations using the direction of the shortest route on the first frame while detecting crosses. // Mix between rotations using the direction of the shortest route on the first frame while detecting crosses.
float r1 = blend == MixBlend_Setup ? bone->_data._rotation : bone->_rotation;
float total, diff = r2 - r1; float total, diff = r2 - r1;
diff -= (16384 - (int) (16384.499999999996 - diff / 360)) * 360; diff -= (16384 - (int) (16384.499999999996 - diff / 360)) * 360;
if (diff == 0) { if (diff == 0) {

46
spine-libgdx/spine-libgdx/src/com/esotericsoftware/spine/AnimationState.java
View File

@ -342,30 +342,38 @@ public class AnimationState {
RotateTimeline rotateTimeline = (RotateTimeline)timeline; RotateTimeline rotateTimeline = (RotateTimeline)timeline;
Bone bone = skeleton.bones.get(rotateTimeline.boneIndex); Bone bone = skeleton.bones.get(rotateTimeline.boneIndex);
float[] frames = rotateTimeline.frames; float[] frames = rotateTimeline.frames;
float r1, r2;
if (time < frames[0]) { // Time is before first frame. if (time < frames[0]) { // Time is before first frame.
if (blend == MixBlend.setup) bone.rotation = bone.data.rotation; switch (blend) {
return; case setup:
} bone.rotation = bone.data.rotation;
// Fall through.
default:
return;
case first:
r1 = bone.rotation;
r2 = bone.data.rotation;
}
} else {
r1 = blend == MixBlend.setup ? bone.data.rotation : bone.rotation;
if (time >= frames[frames.length - ENTRIES]) // Time is after last frame.
r2 = bone.data.rotation + frames[frames.length + PREV_ROTATION];
else {
// Interpolate between the previous frame and the current frame.
int frame = Animation.binarySearch(frames, time, ENTRIES);
float prevRotation = frames[frame + PREV_ROTATION];
float frameTime = frames[frame];
float percent = rotateTimeline.getCurvePercent((frame >> 1) - 1,
1 - (time - frameTime) / (frames[frame + PREV_TIME] - frameTime));
float r2; r2 = frames[frame + ROTATION] - prevRotation;
if (time >= frames[frames.length - ENTRIES]) // Time is after last frame. r2 -= (16384 - (int)(16384.499999999996 - r2 / 360)) * 360;
r2 = bone.data.rotation + frames[frames.length + PREV_ROTATION]; r2 = prevRotation + r2 * percent + bone.data.rotation;
else { r2 -= (16384 - (int)(16384.499999999996 - r2 / 360)) * 360;
// Interpolate between the previous frame and the current frame. }
int frame = Animation.binarySearch(frames, time, ENTRIES);
float prevRotation = frames[frame + PREV_ROTATION];
float frameTime = frames[frame];
float percent = rotateTimeline.getCurvePercent((frame >> 1) - 1,
1 - (time - frameTime) / (frames[frame + PREV_TIME] - frameTime));
r2 = frames[frame + ROTATION] - prevRotation;
r2 -= (16384 - (int)(16384.499999999996 - r2 / 360)) * 360;
r2 = prevRotation + r2 * percent + bone.data.rotation;
r2 -= (16384 - (int)(16384.499999999996 - r2 / 360)) * 360;
} }
// Mix between rotations using the direction of the shortest route on the first frame. // Mix between rotations using the direction of the shortest route on the first frame.
float r1 = blend == MixBlend.setup ? bone.data.rotation : bone.rotation;
float total, diff = r2 - r1; float total, diff = r2 - r1;
diff -= (16384 - (int)(16384.499999999996 - diff / 360)) * 360; diff -= (16384 - (int)(16384.499999999996 - diff / 360)) * 360;
if (diff == 0) if (diff == 0)

53
spine-lua/AnimationState.lua
View File

@ -475,31 +475,42 @@ function AnimationState:applyRotateTimeline (timeline, skeleton, time, alpha, bl
local rotateTimeline = timeline local rotateTimeline = timeline
local frames = rotateTimeline.frames local frames = rotateTimeline.frames
local bone = skeleton.bones[rotateTimeline.boneIndex] local bone = skeleton.bones[rotateTimeline.boneIndex]
local r1 = 0
local r2 = 0
if time < frames[0] then if time < frames[0] then
if blend == MixBlend.setup then bone.rotation = bone.data.rotation end if blend == MixBlend.setup then
return bone.rotation = bone.data.rotation
return
elseif blend == MixBlend.first then
r1 = bone.rotation
r2 = bone.data.rotation
else
return
end
else
if blend == MixBlend.setup then
r1 = bone.data.rotation
else
r1 = bone.rotation
end
if time >= frames[zlen(frames) - Animation.RotateTimeline.ENTRIES] then -- Time is after last frame.
r2 = bone.data.rotation + frames[zlen(frames) + Animation.RotateTimeline.PREV_ROTATION]
else
-- Interpolate between the previous frame and the current frame.
local frame = Animation.binarySearch(frames, time, Animation.RotateTimeline.ENTRIES)
local prevRotation = frames[frame + Animation.RotateTimeline.PREV_ROTATION]
local frameTime = frames[frame]
local percent = rotateTimeline:getCurvePercent(math_floor(frame / 2) - 1,
1 - (time - frameTime) / (frames[frame + Animation.RotateTimeline.PREV_TIME] - frameTime))
r2 = frames[frame + Animation.RotateTimeline.ROTATION] - prevRotation
r2 = r2 - (16384 - math_floor(16384.499999999996 - r2 / 360)) * 360
r2 = prevRotation + r2 * percent + bone.data.rotation
r2 = r2 - (16384 - math_floor(16384.499999999996 - r2 / 360)) * 360
end
end end
local r2 = 0
if time >= frames[zlen(frames) - Animation.RotateTimeline.ENTRIES] then -- Time is after last frame.
r2 = bone.data.rotation + frames[zlen(frames) + Animation.RotateTimeline.PREV_ROTATION]
else
-- Interpolate between the previous frame and the current frame.
local frame = Animation.binarySearch(frames, time, Animation.RotateTimeline.ENTRIES)
local prevRotation = frames[frame + Animation.RotateTimeline.PREV_ROTATION]
local frameTime = frames[frame]
local percent = rotateTimeline:getCurvePercent(math_floor(frame / 2) - 1,
1 - (time - frameTime) / (frames[frame + Animation.RotateTimeline.PREV_TIME] - frameTime))
r2 = frames[frame + Animation.RotateTimeline.ROTATION] - prevRotation
r2 = r2 - (16384 - math_floor(16384.499999999996 - r2 / 360)) * 360
r2 = prevRotation + r2 * percent + bone.data.rotation
r2 = r2 - (16384 - math_floor(16384.499999999996 - r2 / 360)) * 360
end
-- Mix between rotations using the direction of the shortest route on the first frame while detecting crosses. -- Mix between rotations using the direction of the shortest route on the first frame while detecting crosses.
local r1 = bone.rotation
if blend == MixBlend.setup then r1 = bone.data.rotation end
local total = 0 local total = 0
local diff = r2 - r1 local diff = r2 - r1
diff = diff - (16384 - math_floor(16384.499999999996 - diff / 360)) * 360 diff = diff - (16384 - math_floor(16384.499999999996 - diff / 360)) * 360

BIN
spine-starling/spine-starling-example/lib/spine-as3.swc
View File

Binary file not shown.

BIN
spine-starling/spine-starling/lib/spine-as3.swc
View File

Binary file not shown.

38
spine-ts/build/spine-all.js
View File

@ -1532,25 +1532,33 @@ var spine;
var rotateTimeline = timeline; var rotateTimeline = timeline;
var frames = rotateTimeline.frames; var frames = rotateTimeline.frames;
var bone = skeleton.bones[rotateTimeline.boneIndex]; var bone = skeleton.bones[rotateTimeline.boneIndex];
var r1 = 0, r2 = 0;
if (time < frames[0]) { if (time < frames[0]) {
if (blend == spine.MixBlend.setup) switch (blend) {
bone.rotation = bone.data.rotation; case spine.MixBlend.setup:
return; bone.rotation = bone.data.rotation;
default:
return;
case spine.MixBlend.first:
r1 = bone.rotation;
r2 = bone.data.rotation;
}
} }
var r2 = 0;
if (time >= frames[frames.length - spine.RotateTimeline.ENTRIES])
r2 = bone.data.rotation + frames[frames.length + spine.RotateTimeline.PREV_ROTATION];
else { else {
var frame = spine.Animation.binarySearch(frames, time, spine.RotateTimeline.ENTRIES); r1 = blend == spine.MixBlend.setup ? bone.data.rotation : bone.rotation;
var prevRotation = frames[frame + spine.RotateTimeline.PREV_ROTATION]; if (time >= frames[frames.length - spine.RotateTimeline.ENTRIES])
var frameTime = frames[frame]; r2 = bone.data.rotation + frames[frames.length + spine.RotateTimeline.PREV_ROTATION];
var percent = rotateTimeline.getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + spine.RotateTimeline.PREV_TIME] - frameTime)); else {
r2 = frames[frame + spine.RotateTimeline.ROTATION] - prevRotation; var frame = spine.Animation.binarySearch(frames, time, spine.RotateTimeline.ENTRIES);
r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360; var prevRotation = frames[frame + spine.RotateTimeline.PREV_ROTATION];
r2 = prevRotation + r2 * percent + bone.data.rotation; var frameTime = frames[frame];
r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360; var percent = rotateTimeline.getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + spine.RotateTimeline.PREV_TIME] - frameTime));
r2 = frames[frame + spine.RotateTimeline.ROTATION] - prevRotation;
r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360;
r2 = prevRotation + r2 * percent + bone.data.rotation;
r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360;
}
} }
var r1 = blend == spine.MixBlend.setup ? bone.data.rotation : bone.rotation;
var total = 0, diff = r2 - r1; var total = 0, diff = r2 - r1;
diff -= (16384 - ((16384.499999999996 - diff / 360) | 0)) * 360; diff -= (16384 - ((16384.499999999996 - diff / 360) | 0)) * 360;
if (diff == 0) { if (diff == 0) {

2
spine-ts/build/spine-all.js.map
View File

File diff suppressed because one or more lines are too long

38
spine-ts/build/spine-canvas.js
View File

@ -1532,25 +1532,33 @@ var spine;
var rotateTimeline = timeline; var rotateTimeline = timeline;
var frames = rotateTimeline.frames; var frames = rotateTimeline.frames;
var bone = skeleton.bones[rotateTimeline.boneIndex]; var bone = skeleton.bones[rotateTimeline.boneIndex];
var r1 = 0, r2 = 0;
if (time < frames[0]) { if (time < frames[0]) {
if (blend == spine.MixBlend.setup) switch (blend) {
bone.rotation = bone.data.rotation; case spine.MixBlend.setup:
return; bone.rotation = bone.data.rotation;
default:
return;
case spine.MixBlend.first:
r1 = bone.rotation;
r2 = bone.data.rotation;
}
} }
var r2 = 0;
if (time >= frames[frames.length - spine.RotateTimeline.ENTRIES])
r2 = bone.data.rotation + frames[frames.length + spine.RotateTimeline.PREV_ROTATION];
else { else {
var frame = spine.Animation.binarySearch(frames, time, spine.RotateTimeline.ENTRIES); r1 = blend == spine.MixBlend.setup ? bone.data.rotation : bone.rotation;
var prevRotation = frames[frame + spine.RotateTimeline.PREV_ROTATION]; if (time >= frames[frames.length - spine.RotateTimeline.ENTRIES])
var frameTime = frames[frame]; r2 = bone.data.rotation + frames[frames.length + spine.RotateTimeline.PREV_ROTATION];
var percent = rotateTimeline.getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + spine.RotateTimeline.PREV_TIME] - frameTime)); else {
r2 = frames[frame + spine.RotateTimeline.ROTATION] - prevRotation; var frame = spine.Animation.binarySearch(frames, time, spine.RotateTimeline.ENTRIES);
r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360; var prevRotation = frames[frame + spine.RotateTimeline.PREV_ROTATION];
r2 = prevRotation + r2 * percent + bone.data.rotation; var frameTime = frames[frame];
r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360; var percent = rotateTimeline.getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + spine.RotateTimeline.PREV_TIME] - frameTime));
r2 = frames[frame + spine.RotateTimeline.ROTATION] - prevRotation;
r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360;
r2 = prevRotation + r2 * percent + bone.data.rotation;
r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360;
}
} }
var r1 = blend == spine.MixBlend.setup ? bone.data.rotation : bone.rotation;
var total = 0, diff = r2 - r1; var total = 0, diff = r2 - r1;
diff -= (16384 - ((16384.499999999996 - diff / 360) | 0)) * 360; diff -= (16384 - ((16384.499999999996 - diff / 360) | 0)) * 360;
if (diff == 0) { if (diff == 0) {

2
spine-ts/build/spine-canvas.js.map
View File

File diff suppressed because one or more lines are too long

38
spine-ts/build/spine-core.js
View File

@ -1532,25 +1532,33 @@ var spine;
var rotateTimeline = timeline; var rotateTimeline = timeline;
var frames = rotateTimeline.frames; var frames = rotateTimeline.frames;
var bone = skeleton.bones[rotateTimeline.boneIndex]; var bone = skeleton.bones[rotateTimeline.boneIndex];
var r1 = 0, r2 = 0;
if (time < frames[0]) { if (time < frames[0]) {
if (blend == spine.MixBlend.setup) switch (blend) {
bone.rotation = bone.data.rotation; case spine.MixBlend.setup:
return; bone.rotation = bone.data.rotation;
default:
return;
case spine.MixBlend.first:
r1 = bone.rotation;
r2 = bone.data.rotation;
}
} }
var r2 = 0;
if (time >= frames[frames.length - spine.RotateTimeline.ENTRIES])
r2 = bone.data.rotation + frames[frames.length + spine.RotateTimeline.PREV_ROTATION];
else { else {
var frame = spine.Animation.binarySearch(frames, time, spine.RotateTimeline.ENTRIES); r1 = blend == spine.MixBlend.setup ? bone.data.rotation : bone.rotation;
var prevRotation = frames[frame + spine.RotateTimeline.PREV_ROTATION]; if (time >= frames[frames.length - spine.RotateTimeline.ENTRIES])
var frameTime = frames[frame]; r2 = bone.data.rotation + frames[frames.length + spine.RotateTimeline.PREV_ROTATION];
var percent = rotateTimeline.getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + spine.RotateTimeline.PREV_TIME] - frameTime)); else {
r2 = frames[frame + spine.RotateTimeline.ROTATION] - prevRotation; var frame = spine.Animation.binarySearch(frames, time, spine.RotateTimeline.ENTRIES);
r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360; var prevRotation = frames[frame + spine.RotateTimeline.PREV_ROTATION];
r2 = prevRotation + r2 * percent + bone.data.rotation; var frameTime = frames[frame];
r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360; var percent = rotateTimeline.getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + spine.RotateTimeline.PREV_TIME] - frameTime));
r2 = frames[frame + spine.RotateTimeline.ROTATION] - prevRotation;
r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360;
r2 = prevRotation + r2 * percent + bone.data.rotation;
r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360;
}
} }
var r1 = blend == spine.MixBlend.setup ? bone.data.rotation : bone.rotation;
var total = 0, diff = r2 - r1; var total = 0, diff = r2 - r1;
diff -= (16384 - ((16384.499999999996 - diff / 360) | 0)) * 360; diff -= (16384 - ((16384.499999999996 - diff / 360) | 0)) * 360;
if (diff == 0) { if (diff == 0) {

2
spine-ts/build/spine-core.js.map
View File

File diff suppressed because one or more lines are too long

38
spine-ts/build/spine-player.js
View File

@ -1532,25 +1532,33 @@ var spine;
var rotateTimeline = timeline; var rotateTimeline = timeline;
var frames = rotateTimeline.frames; var frames = rotateTimeline.frames;
var bone = skeleton.bones[rotateTimeline.boneIndex]; var bone = skeleton.bones[rotateTimeline.boneIndex];
var r1 = 0, r2 = 0;
if (time < frames[0]) { if (time < frames[0]) {
if (blend == spine.MixBlend.setup) switch (blend) {
bone.rotation = bone.data.rotation; case spine.MixBlend.setup:
return; bone.rotation = bone.data.rotation;
default:
return;
case spine.MixBlend.first:
r1 = bone.rotation;
r2 = bone.data.rotation;
}
} }
var r2 = 0;
if (time >= frames[frames.length - spine.RotateTimeline.ENTRIES])
r2 = bone.data.rotation + frames[frames.length + spine.RotateTimeline.PREV_ROTATION];
else { else {
var frame = spine.Animation.binarySearch(frames, time, spine.RotateTimeline.ENTRIES); r1 = blend == spine.MixBlend.setup ? bone.data.rotation : bone.rotation;
var prevRotation = frames[frame + spine.RotateTimeline.PREV_ROTATION]; if (time >= frames[frames.length - spine.RotateTimeline.ENTRIES])
var frameTime = frames[frame]; r2 = bone.data.rotation + frames[frames.length + spine.RotateTimeline.PREV_ROTATION];
var percent = rotateTimeline.getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + spine.RotateTimeline.PREV_TIME] - frameTime)); else {
r2 = frames[frame + spine.RotateTimeline.ROTATION] - prevRotation; var frame = spine.Animation.binarySearch(frames, time, spine.RotateTimeline.ENTRIES);
r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360; var prevRotation = frames[frame + spine.RotateTimeline.PREV_ROTATION];
r2 = prevRotation + r2 * percent + bone.data.rotation; var frameTime = frames[frame];
r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360; var percent = rotateTimeline.getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + spine.RotateTimeline.PREV_TIME] - frameTime));
r2 = frames[frame + spine.RotateTimeline.ROTATION] - prevRotation;
r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360;
r2 = prevRotation + r2 * percent + bone.data.rotation;
r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360;
}
} }
var r1 = blend == spine.MixBlend.setup ? bone.data.rotation : bone.rotation;
var total = 0, diff = r2 - r1; var total = 0, diff = r2 - r1;
diff -= (16384 - ((16384.499999999996 - diff / 360) | 0)) * 360; diff -= (16384 - ((16384.499999999996 - diff / 360) | 0)) * 360;
if (diff == 0) { if (diff == 0) {

2
spine-ts/build/spine-player.js.map
View File

File diff suppressed because one or more lines are too long

38
spine-ts/build/spine-threejs.js
View File

@ -1532,25 +1532,33 @@ var spine;
var rotateTimeline = timeline; var rotateTimeline = timeline;
var frames = rotateTimeline.frames; var frames = rotateTimeline.frames;
var bone = skeleton.bones[rotateTimeline.boneIndex]; var bone = skeleton.bones[rotateTimeline.boneIndex];
var r1 = 0, r2 = 0;
if (time < frames[0]) { if (time < frames[0]) {
if (blend == spine.MixBlend.setup) switch (blend) {
bone.rotation = bone.data.rotation; case spine.MixBlend.setup:
return; bone.rotation = bone.data.rotation;
default:
return;
case spine.MixBlend.first:
r1 = bone.rotation;
r2 = bone.data.rotation;
}
} }
var r2 = 0;
if (time >= frames[frames.length - spine.RotateTimeline.ENTRIES])
r2 = bone.data.rotation + frames[frames.length + spine.RotateTimeline.PREV_ROTATION];
else { else {
var frame = spine.Animation.binarySearch(frames, time, spine.RotateTimeline.ENTRIES); r1 = blend == spine.MixBlend.setup ? bone.data.rotation : bone.rotation;
var prevRotation = frames[frame + spine.RotateTimeline.PREV_ROTATION]; if (time >= frames[frames.length - spine.RotateTimeline.ENTRIES])
var frameTime = frames[frame]; r2 = bone.data.rotation + frames[frames.length + spine.RotateTimeline.PREV_ROTATION];
var percent = rotateTimeline.getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + spine.RotateTimeline.PREV_TIME] - frameTime)); else {
r2 = frames[frame + spine.RotateTimeline.ROTATION] - prevRotation; var frame = spine.Animation.binarySearch(frames, time, spine.RotateTimeline.ENTRIES);
r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360; var prevRotation = frames[frame + spine.RotateTimeline.PREV_ROTATION];
r2 = prevRotation + r2 * percent + bone.data.rotation; var frameTime = frames[frame];
r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360; var percent = rotateTimeline.getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + spine.RotateTimeline.PREV_TIME] - frameTime));
r2 = frames[frame + spine.RotateTimeline.ROTATION] - prevRotation;
r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360;
r2 = prevRotation + r2 * percent + bone.data.rotation;
r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360;
}
} }
var r1 = blend == spine.MixBlend.setup ? bone.data.rotation : bone.rotation;
var total = 0, diff = r2 - r1; var total = 0, diff = r2 - r1;
diff -= (16384 - ((16384.499999999996 - diff / 360) | 0)) * 360; diff -= (16384 - ((16384.499999999996 - diff / 360) | 0)) * 360;
if (diff == 0) { if (diff == 0) {

2
spine-ts/build/spine-threejs.js.map
View File

File diff suppressed because one or more lines are too long

38
spine-ts/build/spine-webgl.js
View File

@ -1532,25 +1532,33 @@ var spine;
var rotateTimeline = timeline; var rotateTimeline = timeline;
var frames = rotateTimeline.frames; var frames = rotateTimeline.frames;
var bone = skeleton.bones[rotateTimeline.boneIndex]; var bone = skeleton.bones[rotateTimeline.boneIndex];
var r1 = 0, r2 = 0;
if (time < frames[0]) { if (time < frames[0]) {
if (blend == spine.MixBlend.setup) switch (blend) {
bone.rotation = bone.data.rotation; case spine.MixBlend.setup:
return; bone.rotation = bone.data.rotation;
default:
return;
case spine.MixBlend.first:
r1 = bone.rotation;
r2 = bone.data.rotation;
}
} }
var r2 = 0;
if (time >= frames[frames.length - spine.RotateTimeline.ENTRIES])
r2 = bone.data.rotation + frames[frames.length + spine.RotateTimeline.PREV_ROTATION];
else { else {
var frame = spine.Animation.binarySearch(frames, time, spine.RotateTimeline.ENTRIES); r1 = blend == spine.MixBlend.setup ? bone.data.rotation : bone.rotation;
var prevRotation = frames[frame + spine.RotateTimeline.PREV_ROTATION]; if (time >= frames[frames.length - spine.RotateTimeline.ENTRIES])
var frameTime = frames[frame]; r2 = bone.data.rotation + frames[frames.length + spine.RotateTimeline.PREV_ROTATION];
var percent = rotateTimeline.getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + spine.RotateTimeline.PREV_TIME] - frameTime)); else {
r2 = frames[frame + spine.RotateTimeline.ROTATION] - prevRotation; var frame = spine.Animation.binarySearch(frames, time, spine.RotateTimeline.ENTRIES);
r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360; var prevRotation = frames[frame + spine.RotateTimeline.PREV_ROTATION];
r2 = prevRotation + r2 * percent + bone.data.rotation; var frameTime = frames[frame];
r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360; var percent = rotateTimeline.getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + spine.RotateTimeline.PREV_TIME] - frameTime));
r2 = frames[frame + spine.RotateTimeline.ROTATION] - prevRotation;
r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360;
r2 = prevRotation + r2 * percent + bone.data.rotation;
r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360;
}
} }
var r1 = blend == spine.MixBlend.setup ? bone.data.rotation : bone.rotation;
var total = 0, diff = r2 - r1; var total = 0, diff = r2 - r1;
diff -= (16384 - ((16384.499999999996 - diff / 360) | 0)) * 360; diff -= (16384 - ((16384.499999999996 - diff / 360) | 0)) * 360;
if (diff == 0) { if (diff == 0) {

2
spine-ts/build/spine-webgl.js.map
View File

File diff suppressed because one or more lines are too long

45
spine-ts/core/src/AnimationState.ts
View File

@ -288,30 +288,37 @@ module spine {
let rotateTimeline = timeline as RotateTimeline; let rotateTimeline = timeline as RotateTimeline;
let frames = rotateTimeline.frames; let frames = rotateTimeline.frames;
let bone = skeleton.bones[rotateTimeline.boneIndex]; let bone = skeleton.bones[rotateTimeline.boneIndex];
let r1 = 0, r2 = 0;
if (time < frames[0]) { if (time < frames[0]) {
if (blend == MixBlend.setup) bone.rotation = bone.data.rotation; switch (blend) {
return; case MixBlend.setup:
} bone.rotation = bone.data.rotation;
default:
return;
case MixBlend.first:
r1 = bone.rotation;
r2 = bone.data.rotation;
}
} else {
r1 = blend == MixBlend.setup ? bone.data.rotation : bone.rotation;
if (time >= frames[frames.length - RotateTimeline.ENTRIES]) // Time is after last frame.
r2 = bone.data.rotation + frames[frames.length + RotateTimeline.PREV_ROTATION];
else {
// Interpolate between the previous frame and the current frame.
let frame = Animation.binarySearch(frames, time, RotateTimeline.ENTRIES);
let prevRotation = frames[frame + RotateTimeline.PREV_ROTATION];
let frameTime = frames[frame];
let percent = rotateTimeline.getCurvePercent((frame >> 1) - 1,
1 - (time - frameTime) / (frames[frame + RotateTimeline.PREV_TIME] - frameTime));
let r2 = 0; r2 = frames[frame + RotateTimeline.ROTATION] - prevRotation;
if (time >= frames[frames.length - RotateTimeline.ENTRIES]) // Time is after last frame. r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360;
r2 = bone.data.rotation + frames[frames.length + RotateTimeline.PREV_ROTATION]; r2 = prevRotation + r2 * percent + bone.data.rotation;
else { r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360;
// Interpolate between the previous frame and the current frame. }
let frame = Animation.binarySearch(frames, time, RotateTimeline.ENTRIES);
let prevRotation = frames[frame + RotateTimeline.PREV_ROTATION];
let frameTime = frames[frame];
let percent = rotateTimeline.getCurvePercent((frame >> 1) - 1,
1 - (time - frameTime) / (frames[frame + RotateTimeline.PREV_TIME] - frameTime));
r2 = frames[frame + RotateTimeline.ROTATION] - prevRotation;
r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360;
r2 = prevRotation + r2 * percent + bone.data.rotation;
r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360;
} }
// Mix between rotations using the direction of the shortest route on the first frame while detecting crosses. // Mix between rotations using the direction of the shortest route on the first frame while detecting crosses.
let r1 = blend == MixBlend.setup ? bone.data.rotation : bone.rotation;
let total = 0, diff = r2 - r1; let total = 0, diff = r2 - r1;
diff -= (16384 - ((16384.499999999996 - diff / 360) | 0)) * 360; diff -= (16384 - ((16384.499999999996 - diff / 360) | 0)) * 360;
if (diff == 0) { if (diff == 0) {