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

[ts] Fixes to demos, rotation special cases are a bit wonky still :D

Browse Source
This commit is contained in:
badlogic 2016-10-24 17:04:03 +02:00
parent a4fcc0cdbf
commit 42bb22d3c0
23 changed files with 8868 additions and 8826 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
spine-ts/build/spine-all.d.ts vendored
View File

@ -310,10 +310,10 @@ declare module spine {
clearTracks(): void; clearTracks(): void;
clearTrack(trackIndex: number): void; clearTrack(trackIndex: number): void;
setCurrent(index: number, current: TrackEntry): void; setCurrent(index: number, current: TrackEntry): void;
setAnimationByName(trackIndex: number, animationName: string, loop: boolean): TrackEntry; setAnimation(trackIndex: number, animationName: string, loop: boolean): TrackEntry;
setAnimation(trackIndex: number, animation: Animation, loop: boolean): TrackEntry; setAnimationWith(trackIndex: number, animation: Animation, loop: boolean): TrackEntry;
addAnimationByName(trackIndex: number, animationName: string, loop: boolean, delay: number): TrackEntry; addAnimation(trackIndex: number, animationName: string, loop: boolean, delay: number): TrackEntry;
addAnimation(trackIndex: number, animation: Animation, loop: boolean, delay: number): TrackEntry; addAnimationWith(trackIndex: number, animation: Animation, loop: boolean, delay: number): TrackEntry;
setEmptyAnimation(trackIndex: number, mixDuration: number): TrackEntry; setEmptyAnimation(trackIndex: number, mixDuration: number): TrackEntry;
addEmptyAnimation(trackIndex: number, mixDuration: number, delay: number): TrackEntry; addEmptyAnimation(trackIndex: number, mixDuration: number, delay: number): TrackEntry;
setEmptyAnimations(mixDuration: number): void; setEmptyAnimations(mixDuration: number): void;

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

@ -523,7 +523,7 @@ var spine;
bone.rotation = bone.data.rotation + frames[frames.length + RotateTimeline.PREV_ROTATION] * alpha; bone.rotation = bone.data.rotation + frames[frames.length + RotateTimeline.PREV_ROTATION] * alpha;
else { else {
var r_1 = bone.data.rotation + frames[frames.length + RotateTimeline.PREV_ROTATION] - bone.rotation; var r_1 = bone.data.rotation + frames[frames.length + RotateTimeline.PREV_ROTATION] - bone.rotation;
r_1 -= (16384 - Math.floor(16384.499999999996 - r_1 / 360)) * 360; r_1 -= (16384 - ((16384.499999999996 - r_1 / 360) | 0)) * 360;
bone.rotation += r_1 * alpha; bone.rotation += r_1 * alpha;
} }
return; return;
@ -533,15 +533,15 @@ var spine;
var frameTime = frames[frame]; var frameTime = frames[frame];
var percent = this.getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + RotateTimeline.PREV_TIME] - frameTime)); var percent = this.getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + RotateTimeline.PREV_TIME] - frameTime));
var r = frames[frame + RotateTimeline.ROTATION] - prevRotation; var r = frames[frame + RotateTimeline.ROTATION] - prevRotation;
r -= (16384 - Math.floor(16384.499999999996 - r / 360)) * 360; r -= (16384 - ((16384.499999999996 - r / 360) | 0)) * 360;
r = prevRotation + r * percent; r = prevRotation + r * percent;
if (setupPose) { if (setupPose) {
r -= (16384 - Math.floor(16384.499999999996 - r / 360)) * 360; r -= (16384 - ((16384.499999999996 - r / 360) | 0)) * 360;
bone.rotation = bone.data.rotation + r * alpha; bone.rotation = bone.data.rotation + r * alpha;
} }
else { else {
r = bone.data.rotation + r - bone.rotation; r = bone.data.rotation + r - bone.rotation;
r -= (16384 - Math.floor(16384.499999999996 - r / 360)) * 360; r -= (16384 - ((16384.499999999996 - r / 360) | 0)) * 360;
bone.rotation += r * alpha; bone.rotation += r * alpha;
} }
}; };
@ -1415,9 +1415,9 @@ var spine;
var frameTime = frames[frame]; var frameTime = frames[frame];
var percent = rotateTimeline.getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + spine.RotateTimeline.PREV_TIME] - frameTime)); 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 = frames[frame + spine.RotateTimeline.ROTATION] - prevRotation;
r2 -= (16384 - Math.floor((16384.499999999996 - r2 / 360))) * 360; r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360;
r2 = prevRotation + r2 * percent + bone.data.rotation; r2 = prevRotation + r2 * percent + bone.data.rotation;
r2 -= (16384 - Math.floor((16384.499999999996 - r2 / 360))) * 360; r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360;
} }
var r1 = setupPose ? bone.data.rotation : bone.rotation; var r1 = setupPose ? bone.data.rotation : bone.rotation;
var total = 0, diff = r2 - r1; var total = 0, diff = r2 - r1;
@ -1430,7 +1430,7 @@ var spine;
total = timelinesRotation[i]; total = timelinesRotation[i];
} }
else { else {
diff -= (16384 - Math.floor((16384.499999999996 - diff / 360))) * 360; diff -= (16384 - ((16384.499999999996 - diff / 360) | 0)) * 360;
var lastTotal = 0, lastDiff = 0; var lastTotal = 0, lastDiff = 0;
if (firstFrame) { if (firstFrame) {
lastTotal = 0; lastTotal = 0;
@ -1453,7 +1453,7 @@ var spine;
} }
timelinesRotation[i + 1] = diff; timelinesRotation[i + 1] = diff;
r1 += total * alpha; r1 += total * alpha;
bone.rotation = r1 - (16384 - Math.floor((16384.499999999996 - r1 / 360))) * 360; bone.rotation = r1 - (16384 - ((16384.499999999996 - r1 / 360) | 0)) * 360;
}; };
AnimationState.prototype.queueEvents = function (entry, animationTime) { AnimationState.prototype.queueEvents = function (entry, animationTime) {
var animationStart = entry.animationStart, animationEnd = entry.animationEnd; var animationStart = entry.animationStart, animationEnd = entry.animationEnd;
@ -1522,13 +1522,13 @@ var spine;
} }
this.queue.start(current); this.queue.start(current);
}; };
AnimationState.prototype.setAnimationByName = function (trackIndex, animationName, loop) { AnimationState.prototype.setAnimation = function (trackIndex, animationName, loop) {
var animation = this.data.skeletonData.findAnimation(animationName); var animation = this.data.skeletonData.findAnimation(animationName);
if (animation == null) if (animation == null)
throw new Error("Animation not found: " + animationName); throw new Error("Animation not found: " + animationName);
return this.setAnimation(trackIndex, animation, loop); return this.setAnimationWith(trackIndex, animation, loop);
}; };
AnimationState.prototype.setAnimation = function (trackIndex, animation, loop) { AnimationState.prototype.setAnimationWith = function (trackIndex, animation, loop) {
if (animation == null) if (animation == null)
throw new Error("animation cannot be null."); throw new Error("animation cannot be null.");
var current = this.expandToIndex(trackIndex); var current = this.expandToIndex(trackIndex);
@ -1548,13 +1548,13 @@ var spine;
this.queue.drain(); this.queue.drain();
return entry; return entry;
}; };
AnimationState.prototype.addAnimationByName = function (trackIndex, animationName, loop, delay) { AnimationState.prototype.addAnimation = function (trackIndex, animationName, loop, delay) {
var animation = this.data.skeletonData.findAnimation(animationName); var animation = this.data.skeletonData.findAnimation(animationName);
if (animation == null) if (animation == null)
throw new Error("Animation not found: " + animationName); throw new Error("Animation not found: " + animationName);
return this.addAnimation(trackIndex, animation, loop, delay); return this.addAnimationWith(trackIndex, animation, loop, delay);
}; };
AnimationState.prototype.addAnimation = function (trackIndex, animation, loop, delay) { AnimationState.prototype.addAnimationWith = function (trackIndex, animation, loop, delay) {
if (animation == null) if (animation == null)
throw new Error("animation cannot be null."); throw new Error("animation cannot be null.");
var last = this.expandToIndex(trackIndex); var last = this.expandToIndex(trackIndex);
@ -1572,7 +1572,7 @@ var spine;
if (delay <= 0) { if (delay <= 0) {
var duration = last.animationEnd - last.animationStart; var duration = last.animationEnd - last.animationStart;
if (duration != 0) if (duration != 0)
delay += duration * (1 + Math.floor(last.trackTime / duration)) - this.data.getMix(last.animation, animation); delay += duration * (1 + ((last.trackTime / duration) | 0)) - this.data.getMix(last.animation, animation);
else else
delay = 0; delay = 0;
} }
@ -1581,7 +1581,7 @@ var spine;
return entry; return entry;
}; };
AnimationState.prototype.setEmptyAnimation = function (trackIndex, mixDuration) { AnimationState.prototype.setEmptyAnimation = function (trackIndex, mixDuration) {
var entry = this.setAnimation(trackIndex, AnimationState.emptyAnimation, false); var entry = this.setAnimationWith(trackIndex, AnimationState.emptyAnimation, false);
entry.mixDuration = mixDuration; entry.mixDuration = mixDuration;
entry.trackEnd = mixDuration; entry.trackEnd = mixDuration;
return entry; return entry;
@ -1589,7 +1589,7 @@ var spine;
AnimationState.prototype.addEmptyAnimation = function (trackIndex, mixDuration, delay) { AnimationState.prototype.addEmptyAnimation = function (trackIndex, mixDuration, delay) {
if (delay <= 0) if (delay <= 0)
delay -= mixDuration; delay -= mixDuration;
var entry = this.addAnimation(trackIndex, AnimationState.emptyAnimation, false, delay); var entry = this.addAnimationWith(trackIndex, AnimationState.emptyAnimation, false, delay);
entry.mixDuration = mixDuration; entry.mixDuration = mixDuration;
entry.trackEnd = mixDuration; entry.trackEnd = mixDuration;
return entry; return entry;
@ -1607,7 +1607,7 @@ var spine;
AnimationState.prototype.expandToIndex = function (index) { AnimationState.prototype.expandToIndex = function (index) {
if (index < this.tracks.length) if (index < this.tracks.length)
return this.tracks[index]; return this.tracks[index];
spine.Utils.ensureArrayCapacity(this.tracks, index - this.tracks.length + 1); spine.Utils.ensureArrayCapacity(this.tracks, index - this.tracks.length + 1, null);
this.tracks.length = index + 1; this.tracks.length = index + 1;
return null; return null;
}; };
@ -1790,41 +1790,47 @@ var spine;
var entry = objects[i + 1]; var entry = objects[i + 1];
switch (type) { switch (type) {
case EventType.start: case EventType.start:
if (entry.listener != null) if (entry.listener != null && entry.listener.end)
entry.listener.end(entry); entry.listener.end(entry);
for (var ii = 0; ii < listeners.length; ii++) for (var ii = 0; ii < listeners.length; ii++)
listeners[ii].start(entry); if (listeners[ii].start)
listeners[ii].start(entry);
break; break;
case EventType.interrupt: case EventType.interrupt:
if (entry.listener != null) if (entry.listener != null && entry.listener.end)
entry.listener.end(entry); entry.listener.end(entry);
for (var ii = 0; ii < listeners.length; ii++) for (var ii = 0; ii < listeners.length; ii++)
listeners[ii].interrupt(entry); if (listeners[ii].interrupt)
listeners[ii].interrupt(entry);
break; break;
case EventType.end: case EventType.end:
if (entry.listener != null) if (entry.listener != null && entry.listener.end)
entry.listener.end(entry); entry.listener.end(entry);
for (var ii = 0; ii < listeners.length; ii++) for (var ii = 0; ii < listeners.length; ii++)
listeners[ii].end(entry); if (listeners[ii].end)
listeners[ii].end(entry);
case EventType.dispose: case EventType.dispose:
if (entry.listener != null) if (entry.listener != null && entry.listener.end)
entry.listener.end(entry); entry.listener.end(entry);
for (var ii = 0; ii < listeners.length; ii++) for (var ii = 0; ii < listeners.length; ii++)
listeners[ii].dispose(entry); if (listeners[ii].dispose)
listeners[ii].dispose(entry);
this.animState.trackEntryPool.free(entry); this.animState.trackEntryPool.free(entry);
break; break;
case EventType.complete: case EventType.complete:
if (entry.listener != null) if (entry.listener != null && entry.listener.complete)
entry.listener.complete(entry); entry.listener.complete(entry);
for (var ii = 0; ii < listeners.length; ii++) for (var ii = 0; ii < listeners.length; ii++)
listeners[ii].complete(entry); if (listeners[ii].complete)
listeners[ii].complete(entry);
break; break;
case EventType.event: case EventType.event:
var event_3 = objects[i++ + 2]; var event_3 = objects[i++ + 2];
if (entry.listener != null) if (entry.listener != null && entry.listener.event)
entry.listener.event(entry, event_3); entry.listener.event(entry, event_3);
for (var ii = 0; ii < listeners.length; ii++) for (var ii = 0; ii < listeners.length; ii++)
listeners[ii].event(entry, event_3); if (listeners[ii].event)
listeners[ii].event(entry, event_3);
break; break;
} }
} }
@ -7887,7 +7893,7 @@ var spine;
skeleton.y = config.y; skeleton.y = config.y;
} }
var animationState = this.state = new spine.AnimationState(new spine.AnimationStateData(skeleton.data)); var animationState = this.state = new spine.AnimationState(new spine.AnimationStateData(skeleton.data));
animationState.setAnimationByName(0, config.animation, true); animationState.setAnimation(0, config.animation, true);
if (config.success) if (config.success)
config.success(this); config.success(this);
this.loaded = true; this.loaded = true;
@ -7982,7 +7988,7 @@ var spine;
if (!this.loaded) if (!this.loaded)
throw new Error("Widget isn't loaded yet"); throw new Error("Widget isn't loaded yet");
this.skeleton.setToSetupPose(); this.skeleton.setToSetupPose();
this.state.setAnimationByName(0, animationName, this.config.loop); this.state.setAnimation(0, animationName, this.config.loop);
}; };
SpineWidget.loadWidgets = function () { SpineWidget.loadWidgets = function () {
var widgets = document.getElementsByClassName("spine-widget"); var widgets = document.getElementsByClassName("spine-widget");

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

File diff suppressed because one or more lines are too long

8
spine-ts/build/spine-canvas.d.ts vendored
View File

@ -310,10 +310,10 @@ declare module spine {
clearTracks(): void; clearTracks(): void;
clearTrack(trackIndex: number): void; clearTrack(trackIndex: number): void;
setCurrent(index: number, current: TrackEntry): void; setCurrent(index: number, current: TrackEntry): void;
setAnimationByName(trackIndex: number, animationName: string, loop: boolean): TrackEntry; setAnimation(trackIndex: number, animationName: string, loop: boolean): TrackEntry;
setAnimation(trackIndex: number, animation: Animation, loop: boolean): TrackEntry; setAnimationWith(trackIndex: number, animation: Animation, loop: boolean): TrackEntry;
addAnimationByName(trackIndex: number, animationName: string, loop: boolean, delay: number): TrackEntry; addAnimation(trackIndex: number, animationName: string, loop: boolean, delay: number): TrackEntry;
addAnimation(trackIndex: number, animation: Animation, loop: boolean, delay: number): TrackEntry; addAnimationWith(trackIndex: number, animation: Animation, loop: boolean, delay: number): TrackEntry;
setEmptyAnimation(trackIndex: number, mixDuration: number): TrackEntry; setEmptyAnimation(trackIndex: number, mixDuration: number): TrackEntry;
addEmptyAnimation(trackIndex: number, mixDuration: number, delay: number): TrackEntry; addEmptyAnimation(trackIndex: number, mixDuration: number, delay: number): TrackEntry;
setEmptyAnimations(mixDuration: number): void; setEmptyAnimations(mixDuration: number): void;

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

@ -523,7 +523,7 @@ var spine;
bone.rotation = bone.data.rotation + frames[frames.length + RotateTimeline.PREV_ROTATION] * alpha; bone.rotation = bone.data.rotation + frames[frames.length + RotateTimeline.PREV_ROTATION] * alpha;
else { else {
var r_1 = bone.data.rotation + frames[frames.length + RotateTimeline.PREV_ROTATION] - bone.rotation; var r_1 = bone.data.rotation + frames[frames.length + RotateTimeline.PREV_ROTATION] - bone.rotation;
r_1 -= (16384 - Math.floor(16384.499999999996 - r_1 / 360)) * 360; r_1 -= (16384 - ((16384.499999999996 - r_1 / 360) | 0)) * 360;
bone.rotation += r_1 * alpha; bone.rotation += r_1 * alpha;
} }
return; return;
@ -533,15 +533,15 @@ var spine;
var frameTime = frames[frame]; var frameTime = frames[frame];
var percent = this.getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + RotateTimeline.PREV_TIME] - frameTime)); var percent = this.getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + RotateTimeline.PREV_TIME] - frameTime));
var r = frames[frame + RotateTimeline.ROTATION] - prevRotation; var r = frames[frame + RotateTimeline.ROTATION] - prevRotation;
r -= (16384 - Math.floor(16384.499999999996 - r / 360)) * 360; r -= (16384 - ((16384.499999999996 - r / 360) | 0)) * 360;
r = prevRotation + r * percent; r = prevRotation + r * percent;
if (setupPose) { if (setupPose) {
r -= (16384 - Math.floor(16384.499999999996 - r / 360)) * 360; r -= (16384 - ((16384.499999999996 - r / 360) | 0)) * 360;
bone.rotation = bone.data.rotation + r * alpha; bone.rotation = bone.data.rotation + r * alpha;
} }
else { else {
r = bone.data.rotation + r - bone.rotation; r = bone.data.rotation + r - bone.rotation;
r -= (16384 - Math.floor(16384.499999999996 - r / 360)) * 360; r -= (16384 - ((16384.499999999996 - r / 360) | 0)) * 360;
bone.rotation += r * alpha; bone.rotation += r * alpha;
} }
}; };
@ -1415,9 +1415,9 @@ var spine;
var frameTime = frames[frame]; var frameTime = frames[frame];
var percent = rotateTimeline.getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + spine.RotateTimeline.PREV_TIME] - frameTime)); 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 = frames[frame + spine.RotateTimeline.ROTATION] - prevRotation;
r2 -= (16384 - Math.floor((16384.499999999996 - r2 / 360))) * 360; r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360;
r2 = prevRotation + r2 * percent + bone.data.rotation; r2 = prevRotation + r2 * percent + bone.data.rotation;
r2 -= (16384 - Math.floor((16384.499999999996 - r2 / 360))) * 360; r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360;
} }
var r1 = setupPose ? bone.data.rotation : bone.rotation; var r1 = setupPose ? bone.data.rotation : bone.rotation;
var total = 0, diff = r2 - r1; var total = 0, diff = r2 - r1;
@ -1430,7 +1430,7 @@ var spine;
total = timelinesRotation[i]; total = timelinesRotation[i];
} }
else { else {
diff -= (16384 - Math.floor((16384.499999999996 - diff / 360))) * 360; diff -= (16384 - ((16384.499999999996 - diff / 360) | 0)) * 360;
var lastTotal = 0, lastDiff = 0; var lastTotal = 0, lastDiff = 0;
if (firstFrame) { if (firstFrame) {
lastTotal = 0; lastTotal = 0;
@ -1453,7 +1453,7 @@ var spine;
} }
timelinesRotation[i + 1] = diff; timelinesRotation[i + 1] = diff;
r1 += total * alpha; r1 += total * alpha;
bone.rotation = r1 - (16384 - Math.floor((16384.499999999996 - r1 / 360))) * 360; bone.rotation = r1 - (16384 - ((16384.499999999996 - r1 / 360) | 0)) * 360;
}; };
AnimationState.prototype.queueEvents = function (entry, animationTime) { AnimationState.prototype.queueEvents = function (entry, animationTime) {
var animationStart = entry.animationStart, animationEnd = entry.animationEnd; var animationStart = entry.animationStart, animationEnd = entry.animationEnd;
@ -1522,13 +1522,13 @@ var spine;
} }
this.queue.start(current); this.queue.start(current);
}; };
AnimationState.prototype.setAnimationByName = function (trackIndex, animationName, loop) { AnimationState.prototype.setAnimation = function (trackIndex, animationName, loop) {
var animation = this.data.skeletonData.findAnimation(animationName); var animation = this.data.skeletonData.findAnimation(animationName);
if (animation == null) if (animation == null)
throw new Error("Animation not found: " + animationName); throw new Error("Animation not found: " + animationName);
return this.setAnimation(trackIndex, animation, loop); return this.setAnimationWith(trackIndex, animation, loop);
}; };
AnimationState.prototype.setAnimation = function (trackIndex, animation, loop) { AnimationState.prototype.setAnimationWith = function (trackIndex, animation, loop) {
if (animation == null) if (animation == null)
throw new Error("animation cannot be null."); throw new Error("animation cannot be null.");
var current = this.expandToIndex(trackIndex); var current = this.expandToIndex(trackIndex);
@ -1548,13 +1548,13 @@ var spine;
this.queue.drain(); this.queue.drain();
return entry; return entry;
}; };
AnimationState.prototype.addAnimationByName = function (trackIndex, animationName, loop, delay) { AnimationState.prototype.addAnimation = function (trackIndex, animationName, loop, delay) {
var animation = this.data.skeletonData.findAnimation(animationName); var animation = this.data.skeletonData.findAnimation(animationName);
if (animation == null) if (animation == null)
throw new Error("Animation not found: " + animationName); throw new Error("Animation not found: " + animationName);
return this.addAnimation(trackIndex, animation, loop, delay); return this.addAnimationWith(trackIndex, animation, loop, delay);
}; };
AnimationState.prototype.addAnimation = function (trackIndex, animation, loop, delay) { AnimationState.prototype.addAnimationWith = function (trackIndex, animation, loop, delay) {
if (animation == null) if (animation == null)
throw new Error("animation cannot be null."); throw new Error("animation cannot be null.");
var last = this.expandToIndex(trackIndex); var last = this.expandToIndex(trackIndex);
@ -1572,7 +1572,7 @@ var spine;
if (delay <= 0) { if (delay <= 0) {
var duration = last.animationEnd - last.animationStart; var duration = last.animationEnd - last.animationStart;
if (duration != 0) if (duration != 0)
delay += duration * (1 + Math.floor(last.trackTime / duration)) - this.data.getMix(last.animation, animation); delay += duration * (1 + ((last.trackTime / duration) | 0)) - this.data.getMix(last.animation, animation);
else else
delay = 0; delay = 0;
} }
@ -1581,7 +1581,7 @@ var spine;
return entry; return entry;
}; };
AnimationState.prototype.setEmptyAnimation = function (trackIndex, mixDuration) { AnimationState.prototype.setEmptyAnimation = function (trackIndex, mixDuration) {
var entry = this.setAnimation(trackIndex, AnimationState.emptyAnimation, false); var entry = this.setAnimationWith(trackIndex, AnimationState.emptyAnimation, false);
entry.mixDuration = mixDuration; entry.mixDuration = mixDuration;
entry.trackEnd = mixDuration; entry.trackEnd = mixDuration;
return entry; return entry;
@ -1589,7 +1589,7 @@ var spine;
AnimationState.prototype.addEmptyAnimation = function (trackIndex, mixDuration, delay) { AnimationState.prototype.addEmptyAnimation = function (trackIndex, mixDuration, delay) {
if (delay <= 0) if (delay <= 0)
delay -= mixDuration; delay -= mixDuration;
var entry = this.addAnimation(trackIndex, AnimationState.emptyAnimation, false, delay); var entry = this.addAnimationWith(trackIndex, AnimationState.emptyAnimation, false, delay);
entry.mixDuration = mixDuration; entry.mixDuration = mixDuration;
entry.trackEnd = mixDuration; entry.trackEnd = mixDuration;
return entry; return entry;
@ -1607,7 +1607,7 @@ var spine;
AnimationState.prototype.expandToIndex = function (index) { AnimationState.prototype.expandToIndex = function (index) {
if (index < this.tracks.length) if (index < this.tracks.length)
return this.tracks[index]; return this.tracks[index];
spine.Utils.ensureArrayCapacity(this.tracks, index - this.tracks.length + 1); spine.Utils.ensureArrayCapacity(this.tracks, index - this.tracks.length + 1, null);
this.tracks.length = index + 1; this.tracks.length = index + 1;
return null; return null;
}; };
@ -1790,41 +1790,47 @@ var spine;
var entry = objects[i + 1]; var entry = objects[i + 1];
switch (type) { switch (type) {
case EventType.start: case EventType.start:
if (entry.listener != null) if (entry.listener != null && entry.listener.end)
entry.listener.end(entry); entry.listener.end(entry);
for (var ii = 0; ii < listeners.length; ii++) for (var ii = 0; ii < listeners.length; ii++)
listeners[ii].start(entry); if (listeners[ii].start)
listeners[ii].start(entry);
break; break;
case EventType.interrupt: case EventType.interrupt:
if (entry.listener != null) if (entry.listener != null && entry.listener.end)
entry.listener.end(entry); entry.listener.end(entry);
for (var ii = 0; ii < listeners.length; ii++) for (var ii = 0; ii < listeners.length; ii++)
listeners[ii].interrupt(entry); if (listeners[ii].interrupt)
listeners[ii].interrupt(entry);
break; break;
case EventType.end: case EventType.end:
if (entry.listener != null) if (entry.listener != null && entry.listener.end)
entry.listener.end(entry); entry.listener.end(entry);
for (var ii = 0; ii < listeners.length; ii++) for (var ii = 0; ii < listeners.length; ii++)
listeners[ii].end(entry); if (listeners[ii].end)
listeners[ii].end(entry);
case EventType.dispose: case EventType.dispose:
if (entry.listener != null) if (entry.listener != null && entry.listener.end)
entry.listener.end(entry); entry.listener.end(entry);
for (var ii = 0; ii < listeners.length; ii++) for (var ii = 0; ii < listeners.length; ii++)
listeners[ii].dispose(entry); if (listeners[ii].dispose)
listeners[ii].dispose(entry);
this.animState.trackEntryPool.free(entry); this.animState.trackEntryPool.free(entry);
break; break;
case EventType.complete: case EventType.complete:
if (entry.listener != null) if (entry.listener != null && entry.listener.complete)
entry.listener.complete(entry); entry.listener.complete(entry);
for (var ii = 0; ii < listeners.length; ii++) for (var ii = 0; ii < listeners.length; ii++)
listeners[ii].complete(entry); if (listeners[ii].complete)
listeners[ii].complete(entry);
break; break;
case EventType.event: case EventType.event:
var event_3 = objects[i++ + 2]; var event_3 = objects[i++ + 2];
if (entry.listener != null) if (entry.listener != null && entry.listener.event)
entry.listener.event(entry, event_3); entry.listener.event(entry, event_3);
for (var ii = 0; ii < listeners.length; ii++) for (var ii = 0; ii < listeners.length; ii++)
listeners[ii].event(entry, event_3); if (listeners[ii].event)
listeners[ii].event(entry, event_3);
break; break;
} }
} }

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

File diff suppressed because one or more lines are too long

8
spine-ts/build/spine-core.d.ts vendored
View File

@ -222,10 +222,10 @@ declare module spine {
clearTracks(): void; clearTracks(): void;
clearTrack(trackIndex: number): void; clearTrack(trackIndex: number): void;
setCurrent(index: number, current: TrackEntry): void; setCurrent(index: number, current: TrackEntry): void;
setAnimationByName(trackIndex: number, animationName: string, loop: boolean): TrackEntry; setAnimation(trackIndex: number, animationName: string, loop: boolean): TrackEntry;
setAnimation(trackIndex: number, animation: Animation, loop: boolean): TrackEntry; setAnimationWith(trackIndex: number, animation: Animation, loop: boolean): TrackEntry;
addAnimationByName(trackIndex: number, animationName: string, loop: boolean, delay: number): TrackEntry; addAnimation(trackIndex: number, animationName: string, loop: boolean, delay: number): TrackEntry;
addAnimation(trackIndex: number, animation: Animation, loop: boolean, delay: number): TrackEntry; addAnimationWith(trackIndex: number, animation: Animation, loop: boolean, delay: number): TrackEntry;
setEmptyAnimation(trackIndex: number, mixDuration: number): TrackEntry; setEmptyAnimation(trackIndex: number, mixDuration: number): TrackEntry;
addEmptyAnimation(trackIndex: number, mixDuration: number, delay: number): TrackEntry; addEmptyAnimation(trackIndex: number, mixDuration: number, delay: number): TrackEntry;
setEmptyAnimations(mixDuration: number): void; setEmptyAnimations(mixDuration: number): void;

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

@ -176,7 +176,7 @@ var spine;
bone.rotation = bone.data.rotation + frames[frames.length + RotateTimeline.PREV_ROTATION] * alpha; bone.rotation = bone.data.rotation + frames[frames.length + RotateTimeline.PREV_ROTATION] * alpha;
else { else {
var r_1 = bone.data.rotation + frames[frames.length + RotateTimeline.PREV_ROTATION] - bone.rotation; var r_1 = bone.data.rotation + frames[frames.length + RotateTimeline.PREV_ROTATION] - bone.rotation;
r_1 -= (16384 - Math.floor(16384.499999999996 - r_1 / 360)) * 360; r_1 -= (16384 - ((16384.499999999996 - r_1 / 360) | 0)) * 360;
bone.rotation += r_1 * alpha; bone.rotation += r_1 * alpha;
} }
return; return;
@ -186,15 +186,15 @@ var spine;
var frameTime = frames[frame]; var frameTime = frames[frame];
var percent = this.getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + RotateTimeline.PREV_TIME] - frameTime)); var percent = this.getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + RotateTimeline.PREV_TIME] - frameTime));
var r = frames[frame + RotateTimeline.ROTATION] - prevRotation; var r = frames[frame + RotateTimeline.ROTATION] - prevRotation;
r -= (16384 - Math.floor(16384.499999999996 - r / 360)) * 360; r -= (16384 - ((16384.499999999996 - r / 360) | 0)) * 360;
r = prevRotation + r * percent; r = prevRotation + r * percent;
if (setupPose) { if (setupPose) {
r -= (16384 - Math.floor(16384.499999999996 - r / 360)) * 360; r -= (16384 - ((16384.499999999996 - r / 360) | 0)) * 360;
bone.rotation = bone.data.rotation + r * alpha; bone.rotation = bone.data.rotation + r * alpha;
} }
else { else {
r = bone.data.rotation + r - bone.rotation; r = bone.data.rotation + r - bone.rotation;
r -= (16384 - Math.floor(16384.499999999996 - r / 360)) * 360; r -= (16384 - ((16384.499999999996 - r / 360) | 0)) * 360;
bone.rotation += r * alpha; bone.rotation += r * alpha;
} }
}; };
@ -1068,9 +1068,9 @@ var spine;
var frameTime = frames[frame]; var frameTime = frames[frame];
var percent = rotateTimeline.getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + spine.RotateTimeline.PREV_TIME] - frameTime)); 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 = frames[frame + spine.RotateTimeline.ROTATION] - prevRotation;
r2 -= (16384 - Math.floor((16384.499999999996 - r2 / 360))) * 360; r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360;
r2 = prevRotation + r2 * percent + bone.data.rotation; r2 = prevRotation + r2 * percent + bone.data.rotation;
r2 -= (16384 - Math.floor((16384.499999999996 - r2 / 360))) * 360; r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360;
} }
var r1 = setupPose ? bone.data.rotation : bone.rotation; var r1 = setupPose ? bone.data.rotation : bone.rotation;
var total = 0, diff = r2 - r1; var total = 0, diff = r2 - r1;
@ -1083,7 +1083,7 @@ var spine;
total = timelinesRotation[i]; total = timelinesRotation[i];
} }
else { else {
diff -= (16384 - Math.floor((16384.499999999996 - diff / 360))) * 360; diff -= (16384 - ((16384.499999999996 - diff / 360) | 0)) * 360;
var lastTotal = 0, lastDiff = 0; var lastTotal = 0, lastDiff = 0;
if (firstFrame) { if (firstFrame) {
lastTotal = 0; lastTotal = 0;
@ -1106,7 +1106,7 @@ var spine;
} }
timelinesRotation[i + 1] = diff; timelinesRotation[i + 1] = diff;
r1 += total * alpha; r1 += total * alpha;
bone.rotation = r1 - (16384 - Math.floor((16384.499999999996 - r1 / 360))) * 360; bone.rotation = r1 - (16384 - ((16384.499999999996 - r1 / 360) | 0)) * 360;
}; };
AnimationState.prototype.queueEvents = function (entry, animationTime) { AnimationState.prototype.queueEvents = function (entry, animationTime) {
var animationStart = entry.animationStart, animationEnd = entry.animationEnd; var animationStart = entry.animationStart, animationEnd = entry.animationEnd;
@ -1175,13 +1175,13 @@ var spine;
} }
this.queue.start(current); this.queue.start(current);
}; };
AnimationState.prototype.setAnimationByName = function (trackIndex, animationName, loop) { AnimationState.prototype.setAnimation = function (trackIndex, animationName, loop) {
var animation = this.data.skeletonData.findAnimation(animationName); var animation = this.data.skeletonData.findAnimation(animationName);
if (animation == null) if (animation == null)
throw new Error("Animation not found: " + animationName); throw new Error("Animation not found: " + animationName);
return this.setAnimation(trackIndex, animation, loop); return this.setAnimationWith(trackIndex, animation, loop);
}; };
AnimationState.prototype.setAnimation = function (trackIndex, animation, loop) { AnimationState.prototype.setAnimationWith = function (trackIndex, animation, loop) {
if (animation == null) if (animation == null)
throw new Error("animation cannot be null."); throw new Error("animation cannot be null.");
var current = this.expandToIndex(trackIndex); var current = this.expandToIndex(trackIndex);
@ -1201,13 +1201,13 @@ var spine;
this.queue.drain(); this.queue.drain();
return entry; return entry;
}; };
AnimationState.prototype.addAnimationByName = function (trackIndex, animationName, loop, delay) { AnimationState.prototype.addAnimation = function (trackIndex, animationName, loop, delay) {
var animation = this.data.skeletonData.findAnimation(animationName); var animation = this.data.skeletonData.findAnimation(animationName);
if (animation == null) if (animation == null)
throw new Error("Animation not found: " + animationName); throw new Error("Animation not found: " + animationName);
return this.addAnimation(trackIndex, animation, loop, delay); return this.addAnimationWith(trackIndex, animation, loop, delay);
}; };
AnimationState.prototype.addAnimation = function (trackIndex, animation, loop, delay) { AnimationState.prototype.addAnimationWith = function (trackIndex, animation, loop, delay) {
if (animation == null) if (animation == null)
throw new Error("animation cannot be null."); throw new Error("animation cannot be null.");
var last = this.expandToIndex(trackIndex); var last = this.expandToIndex(trackIndex);
@ -1225,7 +1225,7 @@ var spine;
if (delay <= 0) { if (delay <= 0) {
var duration = last.animationEnd - last.animationStart; var duration = last.animationEnd - last.animationStart;
if (duration != 0) if (duration != 0)
delay += duration * (1 + Math.floor(last.trackTime / duration)) - this.data.getMix(last.animation, animation); delay += duration * (1 + ((last.trackTime / duration) | 0)) - this.data.getMix(last.animation, animation);
else else
delay = 0; delay = 0;
} }
@ -1234,7 +1234,7 @@ var spine;
return entry; return entry;
}; };
AnimationState.prototype.setEmptyAnimation = function (trackIndex, mixDuration) { AnimationState.prototype.setEmptyAnimation = function (trackIndex, mixDuration) {
var entry = this.setAnimation(trackIndex, AnimationState.emptyAnimation, false); var entry = this.setAnimationWith(trackIndex, AnimationState.emptyAnimation, false);
entry.mixDuration = mixDuration; entry.mixDuration = mixDuration;
entry.trackEnd = mixDuration; entry.trackEnd = mixDuration;
return entry; return entry;
@ -1242,7 +1242,7 @@ var spine;
AnimationState.prototype.addEmptyAnimation = function (trackIndex, mixDuration, delay) { AnimationState.prototype.addEmptyAnimation = function (trackIndex, mixDuration, delay) {
if (delay <= 0) if (delay <= 0)
delay -= mixDuration; delay -= mixDuration;
var entry = this.addAnimation(trackIndex, AnimationState.emptyAnimation, false, delay); var entry = this.addAnimationWith(trackIndex, AnimationState.emptyAnimation, false, delay);
entry.mixDuration = mixDuration; entry.mixDuration = mixDuration;
entry.trackEnd = mixDuration; entry.trackEnd = mixDuration;
return entry; return entry;
@ -1260,7 +1260,7 @@ var spine;
AnimationState.prototype.expandToIndex = function (index) { AnimationState.prototype.expandToIndex = function (index) {
if (index < this.tracks.length) if (index < this.tracks.length)
return this.tracks[index]; return this.tracks[index];
spine.Utils.ensureArrayCapacity(this.tracks, index - this.tracks.length + 1); spine.Utils.ensureArrayCapacity(this.tracks, index - this.tracks.length + 1, null);
this.tracks.length = index + 1; this.tracks.length = index + 1;
return null; return null;
}; };
@ -1443,41 +1443,47 @@ var spine;
var entry = objects[i + 1]; var entry = objects[i + 1];
switch (type) { switch (type) {
case EventType.start: case EventType.start:
if (entry.listener != null) if (entry.listener != null && entry.listener.end)
entry.listener.end(entry); entry.listener.end(entry);
for (var ii = 0; ii < listeners.length; ii++) for (var ii = 0; ii < listeners.length; ii++)
listeners[ii].start(entry); if (listeners[ii].start)
listeners[ii].start(entry);
break; break;
case EventType.interrupt: case EventType.interrupt:
if (entry.listener != null) if (entry.listener != null && entry.listener.end)
entry.listener.end(entry); entry.listener.end(entry);
for (var ii = 0; ii < listeners.length; ii++) for (var ii = 0; ii < listeners.length; ii++)
listeners[ii].interrupt(entry); if (listeners[ii].interrupt)
listeners[ii].interrupt(entry);
break; break;
case EventType.end: case EventType.end:
if (entry.listener != null) if (entry.listener != null && entry.listener.end)
entry.listener.end(entry); entry.listener.end(entry);
for (var ii = 0; ii < listeners.length; ii++) for (var ii = 0; ii < listeners.length; ii++)
listeners[ii].end(entry); if (listeners[ii].end)
listeners[ii].end(entry);
case EventType.dispose: case EventType.dispose:
if (entry.listener != null) if (entry.listener != null && entry.listener.end)
entry.listener.end(entry); entry.listener.end(entry);
for (var ii = 0; ii < listeners.length; ii++) for (var ii = 0; ii < listeners.length; ii++)
listeners[ii].dispose(entry); if (listeners[ii].dispose)
listeners[ii].dispose(entry);
this.animState.trackEntryPool.free(entry); this.animState.trackEntryPool.free(entry);
break; break;
case EventType.complete: case EventType.complete:
if (entry.listener != null) if (entry.listener != null && entry.listener.complete)
entry.listener.complete(entry); entry.listener.complete(entry);
for (var ii = 0; ii < listeners.length; ii++) for (var ii = 0; ii < listeners.length; ii++)
listeners[ii].complete(entry); if (listeners[ii].complete)
listeners[ii].complete(entry);
break; break;
case EventType.event: case EventType.event:
var event_3 = objects[i++ + 2]; var event_3 = objects[i++ + 2];
if (entry.listener != null) if (entry.listener != null && entry.listener.event)
entry.listener.event(entry, event_3); entry.listener.event(entry, event_3);
for (var ii = 0; ii < listeners.length; ii++) for (var ii = 0; ii < listeners.length; ii++)
listeners[ii].event(entry, event_3); if (listeners[ii].event)
listeners[ii].event(entry, event_3);
break; break;
} }
} }

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

File diff suppressed because one or more lines are too long

8
spine-ts/build/spine-threejs.d.ts vendored
View File

@ -222,10 +222,10 @@ declare module spine {
clearTracks(): void; clearTracks(): void;
clearTrack(trackIndex: number): void; clearTrack(trackIndex: number): void;
setCurrent(index: number, current: TrackEntry): void; setCurrent(index: number, current: TrackEntry): void;
setAnimationByName(trackIndex: number, animationName: string, loop: boolean): TrackEntry; setAnimation(trackIndex: number, animationName: string, loop: boolean): TrackEntry;
setAnimation(trackIndex: number, animation: Animation, loop: boolean): TrackEntry; setAnimationWith(trackIndex: number, animation: Animation, loop: boolean): TrackEntry;
addAnimationByName(trackIndex: number, animationName: string, loop: boolean, delay: number): TrackEntry; addAnimation(trackIndex: number, animationName: string, loop: boolean, delay: number): TrackEntry;
addAnimation(trackIndex: number, animation: Animation, loop: boolean, delay: number): TrackEntry; addAnimationWith(trackIndex: number, animation: Animation, loop: boolean, delay: number): TrackEntry;
setEmptyAnimation(trackIndex: number, mixDuration: number): TrackEntry; setEmptyAnimation(trackIndex: number, mixDuration: number): TrackEntry;
addEmptyAnimation(trackIndex: number, mixDuration: number, delay: number): TrackEntry; addEmptyAnimation(trackIndex: number, mixDuration: number, delay: number): TrackEntry;
setEmptyAnimations(mixDuration: number): void; setEmptyAnimations(mixDuration: number): void;

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

@ -176,7 +176,7 @@ var spine;
bone.rotation = bone.data.rotation + frames[frames.length + RotateTimeline.PREV_ROTATION] * alpha; bone.rotation = bone.data.rotation + frames[frames.length + RotateTimeline.PREV_ROTATION] * alpha;
else { else {
var r_1 = bone.data.rotation + frames[frames.length + RotateTimeline.PREV_ROTATION] - bone.rotation; var r_1 = bone.data.rotation + frames[frames.length + RotateTimeline.PREV_ROTATION] - bone.rotation;
r_1 -= (16384 - Math.floor(16384.499999999996 - r_1 / 360)) * 360; r_1 -= (16384 - ((16384.499999999996 - r_1 / 360) | 0)) * 360;
bone.rotation += r_1 * alpha; bone.rotation += r_1 * alpha;
} }
return; return;
@ -186,15 +186,15 @@ var spine;
var frameTime = frames[frame]; var frameTime = frames[frame];
var percent = this.getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + RotateTimeline.PREV_TIME] - frameTime)); var percent = this.getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + RotateTimeline.PREV_TIME] - frameTime));
var r = frames[frame + RotateTimeline.ROTATION] - prevRotation; var r = frames[frame + RotateTimeline.ROTATION] - prevRotation;
r -= (16384 - Math.floor(16384.499999999996 - r / 360)) * 360; r -= (16384 - ((16384.499999999996 - r / 360) | 0)) * 360;
r = prevRotation + r * percent; r = prevRotation + r * percent;
if (setupPose) { if (setupPose) {
r -= (16384 - Math.floor(16384.499999999996 - r / 360)) * 360; r -= (16384 - ((16384.499999999996 - r / 360) | 0)) * 360;
bone.rotation = bone.data.rotation + r * alpha; bone.rotation = bone.data.rotation + r * alpha;
} }
else { else {
r = bone.data.rotation + r - bone.rotation; r = bone.data.rotation + r - bone.rotation;
r -= (16384 - Math.floor(16384.499999999996 - r / 360)) * 360; r -= (16384 - ((16384.499999999996 - r / 360) | 0)) * 360;
bone.rotation += r * alpha; bone.rotation += r * alpha;
} }
}; };
@ -1068,9 +1068,9 @@ var spine;
var frameTime = frames[frame]; var frameTime = frames[frame];
var percent = rotateTimeline.getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + spine.RotateTimeline.PREV_TIME] - frameTime)); 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 = frames[frame + spine.RotateTimeline.ROTATION] - prevRotation;
r2 -= (16384 - Math.floor((16384.499999999996 - r2 / 360))) * 360; r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360;
r2 = prevRotation + r2 * percent + bone.data.rotation; r2 = prevRotation + r2 * percent + bone.data.rotation;
r2 -= (16384 - Math.floor((16384.499999999996 - r2 / 360))) * 360; r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360;
} }
var r1 = setupPose ? bone.data.rotation : bone.rotation; var r1 = setupPose ? bone.data.rotation : bone.rotation;
var total = 0, diff = r2 - r1; var total = 0, diff = r2 - r1;
@ -1083,7 +1083,7 @@ var spine;
total = timelinesRotation[i]; total = timelinesRotation[i];
} }
else { else {
diff -= (16384 - Math.floor((16384.499999999996 - diff / 360))) * 360; diff -= (16384 - ((16384.499999999996 - diff / 360) | 0)) * 360;
var lastTotal = 0, lastDiff = 0; var lastTotal = 0, lastDiff = 0;
if (firstFrame) { if (firstFrame) {
lastTotal = 0; lastTotal = 0;
@ -1106,7 +1106,7 @@ var spine;
} }
timelinesRotation[i + 1] = diff; timelinesRotation[i + 1] = diff;
r1 += total * alpha; r1 += total * alpha;
bone.rotation = r1 - (16384 - Math.floor((16384.499999999996 - r1 / 360))) * 360; bone.rotation = r1 - (16384 - ((16384.499999999996 - r1 / 360) | 0)) * 360;
}; };
AnimationState.prototype.queueEvents = function (entry, animationTime) { AnimationState.prototype.queueEvents = function (entry, animationTime) {
var animationStart = entry.animationStart, animationEnd = entry.animationEnd; var animationStart = entry.animationStart, animationEnd = entry.animationEnd;
@ -1175,13 +1175,13 @@ var spine;
} }
this.queue.start(current); this.queue.start(current);
}; };
AnimationState.prototype.setAnimationByName = function (trackIndex, animationName, loop) { AnimationState.prototype.setAnimation = function (trackIndex, animationName, loop) {
var animation = this.data.skeletonData.findAnimation(animationName); var animation = this.data.skeletonData.findAnimation(animationName);
if (animation == null) if (animation == null)
throw new Error("Animation not found: " + animationName); throw new Error("Animation not found: " + animationName);
return this.setAnimation(trackIndex, animation, loop); return this.setAnimationWith(trackIndex, animation, loop);
}; };
AnimationState.prototype.setAnimation = function (trackIndex, animation, loop) { AnimationState.prototype.setAnimationWith = function (trackIndex, animation, loop) {
if (animation == null) if (animation == null)
throw new Error("animation cannot be null."); throw new Error("animation cannot be null.");
var current = this.expandToIndex(trackIndex); var current = this.expandToIndex(trackIndex);
@ -1201,13 +1201,13 @@ var spine;
this.queue.drain(); this.queue.drain();
return entry; return entry;
}; };
AnimationState.prototype.addAnimationByName = function (trackIndex, animationName, loop, delay) { AnimationState.prototype.addAnimation = function (trackIndex, animationName, loop, delay) {
var animation = this.data.skeletonData.findAnimation(animationName); var animation = this.data.skeletonData.findAnimation(animationName);
if (animation == null) if (animation == null)
throw new Error("Animation not found: " + animationName); throw new Error("Animation not found: " + animationName);
return this.addAnimation(trackIndex, animation, loop, delay); return this.addAnimationWith(trackIndex, animation, loop, delay);
}; };
AnimationState.prototype.addAnimation = function (trackIndex, animation, loop, delay) { AnimationState.prototype.addAnimationWith = function (trackIndex, animation, loop, delay) {
if (animation == null) if (animation == null)
throw new Error("animation cannot be null."); throw new Error("animation cannot be null.");
var last = this.expandToIndex(trackIndex); var last = this.expandToIndex(trackIndex);
@ -1225,7 +1225,7 @@ var spine;
if (delay <= 0) { if (delay <= 0) {
var duration = last.animationEnd - last.animationStart; var duration = last.animationEnd - last.animationStart;
if (duration != 0) if (duration != 0)
delay += duration * (1 + Math.floor(last.trackTime / duration)) - this.data.getMix(last.animation, animation); delay += duration * (1 + ((last.trackTime / duration) | 0)) - this.data.getMix(last.animation, animation);
else else
delay = 0; delay = 0;
} }
@ -1234,7 +1234,7 @@ var spine;
return entry; return entry;
}; };
AnimationState.prototype.setEmptyAnimation = function (trackIndex, mixDuration) { AnimationState.prototype.setEmptyAnimation = function (trackIndex, mixDuration) {
var entry = this.setAnimation(trackIndex, AnimationState.emptyAnimation, false); var entry = this.setAnimationWith(trackIndex, AnimationState.emptyAnimation, false);
entry.mixDuration = mixDuration; entry.mixDuration = mixDuration;
entry.trackEnd = mixDuration; entry.trackEnd = mixDuration;
return entry; return entry;
@ -1242,7 +1242,7 @@ var spine;
AnimationState.prototype.addEmptyAnimation = function (trackIndex, mixDuration, delay) { AnimationState.prototype.addEmptyAnimation = function (trackIndex, mixDuration, delay) {
if (delay <= 0) if (delay <= 0)
delay -= mixDuration; delay -= mixDuration;
var entry = this.addAnimation(trackIndex, AnimationState.emptyAnimation, false, delay); var entry = this.addAnimationWith(trackIndex, AnimationState.emptyAnimation, false, delay);
entry.mixDuration = mixDuration; entry.mixDuration = mixDuration;
entry.trackEnd = mixDuration; entry.trackEnd = mixDuration;
return entry; return entry;
@ -1260,7 +1260,7 @@ var spine;
AnimationState.prototype.expandToIndex = function (index) { AnimationState.prototype.expandToIndex = function (index) {
if (index < this.tracks.length) if (index < this.tracks.length)
return this.tracks[index]; return this.tracks[index];
spine.Utils.ensureArrayCapacity(this.tracks, index - this.tracks.length + 1); spine.Utils.ensureArrayCapacity(this.tracks, index - this.tracks.length + 1, null);
this.tracks.length = index + 1; this.tracks.length = index + 1;
return null; return null;
}; };
@ -1443,41 +1443,47 @@ var spine;
var entry = objects[i + 1]; var entry = objects[i + 1];
switch (type) { switch (type) {
case EventType.start: case EventType.start:
if (entry.listener != null) if (entry.listener != null && entry.listener.end)
entry.listener.end(entry); entry.listener.end(entry);
for (var ii = 0; ii < listeners.length; ii++) for (var ii = 0; ii < listeners.length; ii++)
listeners[ii].start(entry); if (listeners[ii].start)
listeners[ii].start(entry);
break; break;
case EventType.interrupt: case EventType.interrupt:
if (entry.listener != null) if (entry.listener != null && entry.listener.end)
entry.listener.end(entry); entry.listener.end(entry);
for (var ii = 0; ii < listeners.length; ii++) for (var ii = 0; ii < listeners.length; ii++)
listeners[ii].interrupt(entry); if (listeners[ii].interrupt)
listeners[ii].interrupt(entry);
break; break;
case EventType.end: case EventType.end:
if (entry.listener != null) if (entry.listener != null && entry.listener.end)
entry.listener.end(entry); entry.listener.end(entry);
for (var ii = 0; ii < listeners.length; ii++) for (var ii = 0; ii < listeners.length; ii++)
listeners[ii].end(entry); if (listeners[ii].end)
listeners[ii].end(entry);
case EventType.dispose: case EventType.dispose:
if (entry.listener != null) if (entry.listener != null && entry.listener.end)
entry.listener.end(entry); entry.listener.end(entry);
for (var ii = 0; ii < listeners.length; ii++) for (var ii = 0; ii < listeners.length; ii++)
listeners[ii].dispose(entry); if (listeners[ii].dispose)
listeners[ii].dispose(entry);
this.animState.trackEntryPool.free(entry); this.animState.trackEntryPool.free(entry);
break; break;
case EventType.complete: case EventType.complete:
if (entry.listener != null) if (entry.listener != null && entry.listener.complete)
entry.listener.complete(entry); entry.listener.complete(entry);
for (var ii = 0; ii < listeners.length; ii++) for (var ii = 0; ii < listeners.length; ii++)
listeners[ii].complete(entry); if (listeners[ii].complete)
listeners[ii].complete(entry);
break; break;
case EventType.event: case EventType.event:
var event_3 = objects[i++ + 2]; var event_3 = objects[i++ + 2];
if (entry.listener != null) if (entry.listener != null && entry.listener.event)
entry.listener.event(entry, event_3); entry.listener.event(entry, event_3);
for (var ii = 0; ii < listeners.length; ii++) for (var ii = 0; ii < listeners.length; ii++)
listeners[ii].event(entry, event_3); if (listeners[ii].event)
listeners[ii].event(entry, event_3);
break; break;
} }
} }

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

File diff suppressed because one or more lines are too long

2664
spine-ts/build/spine-webgl.d.ts vendored
View File

File diff suppressed because it is too large Load Diff

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

File diff suppressed because it is too large Load Diff

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

File diff suppressed because one or more lines are too long

8
spine-ts/build/spine-widget.d.ts vendored
View File

@ -222,10 +222,10 @@ declare module spine {
clearTracks(): void; clearTracks(): void;
clearTrack(trackIndex: number): void; clearTrack(trackIndex: number): void;
setCurrent(index: number, current: TrackEntry): void; setCurrent(index: number, current: TrackEntry): void;
setAnimationByName(trackIndex: number, animationName: string, loop: boolean): TrackEntry; setAnimation(trackIndex: number, animationName: string, loop: boolean): TrackEntry;
setAnimation(trackIndex: number, animation: Animation, loop: boolean): TrackEntry; setAnimationWith(trackIndex: number, animation: Animation, loop: boolean): TrackEntry;
addAnimationByName(trackIndex: number, animationName: string, loop: boolean, delay: number): TrackEntry; addAnimation(trackIndex: number, animationName: string, loop: boolean, delay: number): TrackEntry;
addAnimation(trackIndex: number, animation: Animation, loop: boolean, delay: number): TrackEntry; addAnimationWith(trackIndex: number, animation: Animation, loop: boolean, delay: number): TrackEntry;
setEmptyAnimation(trackIndex: number, mixDuration: number): TrackEntry; setEmptyAnimation(trackIndex: number, mixDuration: number): TrackEntry;
addEmptyAnimation(trackIndex: number, mixDuration: number, delay: number): TrackEntry; addEmptyAnimation(trackIndex: number, mixDuration: number, delay: number): TrackEntry;
setEmptyAnimations(mixDuration: number): void; setEmptyAnimations(mixDuration: number): void;

70
spine-ts/build/spine-widget.js
View File

@ -176,7 +176,7 @@ var spine;
bone.rotation = bone.data.rotation + frames[frames.length + RotateTimeline.PREV_ROTATION] * alpha; bone.rotation = bone.data.rotation + frames[frames.length + RotateTimeline.PREV_ROTATION] * alpha;
else { else {
var r_1 = bone.data.rotation + frames[frames.length + RotateTimeline.PREV_ROTATION] - bone.rotation; var r_1 = bone.data.rotation + frames[frames.length + RotateTimeline.PREV_ROTATION] - bone.rotation;
r_1 -= (16384 - Math.floor(16384.499999999996 - r_1 / 360)) * 360; r_1 -= (16384 - ((16384.499999999996 - r_1 / 360) | 0)) * 360;
bone.rotation += r_1 * alpha; bone.rotation += r_1 * alpha;
} }
return; return;
@ -186,15 +186,15 @@ var spine;
var frameTime = frames[frame]; var frameTime = frames[frame];
var percent = this.getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + RotateTimeline.PREV_TIME] - frameTime)); var percent = this.getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + RotateTimeline.PREV_TIME] - frameTime));
var r = frames[frame + RotateTimeline.ROTATION] - prevRotation; var r = frames[frame + RotateTimeline.ROTATION] - prevRotation;
r -= (16384 - Math.floor(16384.499999999996 - r / 360)) * 360; r -= (16384 - ((16384.499999999996 - r / 360) | 0)) * 360;
r = prevRotation + r * percent; r = prevRotation + r * percent;
if (setupPose) { if (setupPose) {
r -= (16384 - Math.floor(16384.499999999996 - r / 360)) * 360; r -= (16384 - ((16384.499999999996 - r / 360) | 0)) * 360;
bone.rotation = bone.data.rotation + r * alpha; bone.rotation = bone.data.rotation + r * alpha;
} }
else { else {
r = bone.data.rotation + r - bone.rotation; r = bone.data.rotation + r - bone.rotation;
r -= (16384 - Math.floor(16384.499999999996 - r / 360)) * 360; r -= (16384 - ((16384.499999999996 - r / 360) | 0)) * 360;
bone.rotation += r * alpha; bone.rotation += r * alpha;
} }
}; };
@ -1068,9 +1068,9 @@ var spine;
var frameTime = frames[frame]; var frameTime = frames[frame];
var percent = rotateTimeline.getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + spine.RotateTimeline.PREV_TIME] - frameTime)); 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 = frames[frame + spine.RotateTimeline.ROTATION] - prevRotation;
r2 -= (16384 - Math.floor((16384.499999999996 - r2 / 360))) * 360; r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360;
r2 = prevRotation + r2 * percent + bone.data.rotation; r2 = prevRotation + r2 * percent + bone.data.rotation;
r2 -= (16384 - Math.floor((16384.499999999996 - r2 / 360))) * 360; r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360;
} }
var r1 = setupPose ? bone.data.rotation : bone.rotation; var r1 = setupPose ? bone.data.rotation : bone.rotation;
var total = 0, diff = r2 - r1; var total = 0, diff = r2 - r1;
@ -1083,7 +1083,7 @@ var spine;
total = timelinesRotation[i]; total = timelinesRotation[i];
} }
else { else {
diff -= (16384 - Math.floor((16384.499999999996 - diff / 360))) * 360; diff -= (16384 - ((16384.499999999996 - diff / 360) | 0)) * 360;
var lastTotal = 0, lastDiff = 0; var lastTotal = 0, lastDiff = 0;
if (firstFrame) { if (firstFrame) {
lastTotal = 0; lastTotal = 0;
@ -1106,7 +1106,7 @@ var spine;
} }
timelinesRotation[i + 1] = diff; timelinesRotation[i + 1] = diff;
r1 += total * alpha; r1 += total * alpha;
bone.rotation = r1 - (16384 - Math.floor((16384.499999999996 - r1 / 360))) * 360; bone.rotation = r1 - (16384 - ((16384.499999999996 - r1 / 360) | 0)) * 360;
}; };
AnimationState.prototype.queueEvents = function (entry, animationTime) { AnimationState.prototype.queueEvents = function (entry, animationTime) {
var animationStart = entry.animationStart, animationEnd = entry.animationEnd; var animationStart = entry.animationStart, animationEnd = entry.animationEnd;
@ -1175,13 +1175,13 @@ var spine;
} }
this.queue.start(current); this.queue.start(current);
}; };
AnimationState.prototype.setAnimationByName = function (trackIndex, animationName, loop) { AnimationState.prototype.setAnimation = function (trackIndex, animationName, loop) {
var animation = this.data.skeletonData.findAnimation(animationName); var animation = this.data.skeletonData.findAnimation(animationName);
if (animation == null) if (animation == null)
throw new Error("Animation not found: " + animationName); throw new Error("Animation not found: " + animationName);
return this.setAnimation(trackIndex, animation, loop); return this.setAnimationWith(trackIndex, animation, loop);
}; };
AnimationState.prototype.setAnimation = function (trackIndex, animation, loop) { AnimationState.prototype.setAnimationWith = function (trackIndex, animation, loop) {
if (animation == null) if (animation == null)
throw new Error("animation cannot be null."); throw new Error("animation cannot be null.");
var current = this.expandToIndex(trackIndex); var current = this.expandToIndex(trackIndex);
@ -1201,13 +1201,13 @@ var spine;
this.queue.drain(); this.queue.drain();
return entry; return entry;
}; };
AnimationState.prototype.addAnimationByName = function (trackIndex, animationName, loop, delay) { AnimationState.prototype.addAnimation = function (trackIndex, animationName, loop, delay) {
var animation = this.data.skeletonData.findAnimation(animationName); var animation = this.data.skeletonData.findAnimation(animationName);
if (animation == null) if (animation == null)
throw new Error("Animation not found: " + animationName); throw new Error("Animation not found: " + animationName);
return this.addAnimation(trackIndex, animation, loop, delay); return this.addAnimationWith(trackIndex, animation, loop, delay);
}; };
AnimationState.prototype.addAnimation = function (trackIndex, animation, loop, delay) { AnimationState.prototype.addAnimationWith = function (trackIndex, animation, loop, delay) {
if (animation == null) if (animation == null)
throw new Error("animation cannot be null."); throw new Error("animation cannot be null.");
var last = this.expandToIndex(trackIndex); var last = this.expandToIndex(trackIndex);
@ -1225,7 +1225,7 @@ var spine;
if (delay <= 0) { if (delay <= 0) {
var duration = last.animationEnd - last.animationStart; var duration = last.animationEnd - last.animationStart;
if (duration != 0) if (duration != 0)
delay += duration * (1 + Math.floor(last.trackTime / duration)) - this.data.getMix(last.animation, animation); delay += duration * (1 + ((last.trackTime / duration) | 0)) - this.data.getMix(last.animation, animation);
else else
delay = 0; delay = 0;
} }
@ -1234,7 +1234,7 @@ var spine;
return entry; return entry;
}; };
AnimationState.prototype.setEmptyAnimation = function (trackIndex, mixDuration) { AnimationState.prototype.setEmptyAnimation = function (trackIndex, mixDuration) {
var entry = this.setAnimation(trackIndex, AnimationState.emptyAnimation, false); var entry = this.setAnimationWith(trackIndex, AnimationState.emptyAnimation, false);
entry.mixDuration = mixDuration; entry.mixDuration = mixDuration;
entry.trackEnd = mixDuration; entry.trackEnd = mixDuration;
return entry; return entry;
@ -1242,7 +1242,7 @@ var spine;
AnimationState.prototype.addEmptyAnimation = function (trackIndex, mixDuration, delay) { AnimationState.prototype.addEmptyAnimation = function (trackIndex, mixDuration, delay) {
if (delay <= 0) if (delay <= 0)
delay -= mixDuration; delay -= mixDuration;
var entry = this.addAnimation(trackIndex, AnimationState.emptyAnimation, false, delay); var entry = this.addAnimationWith(trackIndex, AnimationState.emptyAnimation, false, delay);
entry.mixDuration = mixDuration; entry.mixDuration = mixDuration;
entry.trackEnd = mixDuration; entry.trackEnd = mixDuration;
return entry; return entry;
@ -1260,7 +1260,7 @@ var spine;
AnimationState.prototype.expandToIndex = function (index) { AnimationState.prototype.expandToIndex = function (index) {
if (index < this.tracks.length) if (index < this.tracks.length)
return this.tracks[index]; return this.tracks[index];
spine.Utils.ensureArrayCapacity(this.tracks, index - this.tracks.length + 1); spine.Utils.ensureArrayCapacity(this.tracks, index - this.tracks.length + 1, null);
this.tracks.length = index + 1; this.tracks.length = index + 1;
return null; return null;
}; };
@ -1443,41 +1443,47 @@ var spine;
var entry = objects[i + 1]; var entry = objects[i + 1];
switch (type) { switch (type) {
case EventType.start: case EventType.start:
if (entry.listener != null) if (entry.listener != null && entry.listener.end)
entry.listener.end(entry); entry.listener.end(entry);
for (var ii = 0; ii < listeners.length; ii++) for (var ii = 0; ii < listeners.length; ii++)
listeners[ii].start(entry); if (listeners[ii].start)
listeners[ii].start(entry);
break; break;
case EventType.interrupt: case EventType.interrupt:
if (entry.listener != null) if (entry.listener != null && entry.listener.end)
entry.listener.end(entry); entry.listener.end(entry);
for (var ii = 0; ii < listeners.length; ii++) for (var ii = 0; ii < listeners.length; ii++)
listeners[ii].interrupt(entry); if (listeners[ii].interrupt)
listeners[ii].interrupt(entry);
break; break;
case EventType.end: case EventType.end:
if (entry.listener != null) if (entry.listener != null && entry.listener.end)
entry.listener.end(entry); entry.listener.end(entry);
for (var ii = 0; ii < listeners.length; ii++) for (var ii = 0; ii < listeners.length; ii++)
listeners[ii].end(entry); if (listeners[ii].end)
listeners[ii].end(entry);
case EventType.dispose: case EventType.dispose:
if (entry.listener != null) if (entry.listener != null && entry.listener.end)
entry.listener.end(entry); entry.listener.end(entry);
for (var ii = 0; ii < listeners.length; ii++) for (var ii = 0; ii < listeners.length; ii++)
listeners[ii].dispose(entry); if (listeners[ii].dispose)
listeners[ii].dispose(entry);
this.animState.trackEntryPool.free(entry); this.animState.trackEntryPool.free(entry);
break; break;
case EventType.complete: case EventType.complete:
if (entry.listener != null) if (entry.listener != null && entry.listener.complete)
entry.listener.complete(entry); entry.listener.complete(entry);
for (var ii = 0; ii < listeners.length; ii++) for (var ii = 0; ii < listeners.length; ii++)
listeners[ii].complete(entry); if (listeners[ii].complete)
listeners[ii].complete(entry);
break; break;
case EventType.event: case EventType.event:
var event_3 = objects[i++ + 2]; var event_3 = objects[i++ + 2];
if (entry.listener != null) if (entry.listener != null && entry.listener.event)
entry.listener.event(entry, event_3); entry.listener.event(entry, event_3);
for (var ii = 0; ii < listeners.length; ii++) for (var ii = 0; ii < listeners.length; ii++)
listeners[ii].event(entry, event_3); if (listeners[ii].event)
listeners[ii].event(entry, event_3);
break; break;
} }
} }
@ -7466,7 +7472,7 @@ var spine;
skeleton.y = config.y; skeleton.y = config.y;
} }
var animationState = this.state = new spine.AnimationState(new spine.AnimationStateData(skeleton.data)); var animationState = this.state = new spine.AnimationState(new spine.AnimationStateData(skeleton.data));
animationState.setAnimationByName(0, config.animation, true); animationState.setAnimation(0, config.animation, true);
if (config.success) if (config.success)
config.success(this); config.success(this);
this.loaded = true; this.loaded = true;
@ -7561,7 +7567,7 @@ var spine;
if (!this.loaded) if (!this.loaded)
throw new Error("Widget isn't loaded yet"); throw new Error("Widget isn't loaded yet");
this.skeleton.setToSetupPose(); this.skeleton.setToSetupPose();
this.state.setAnimationByName(0, animationName, this.config.loop); this.state.setAnimation(0, animationName, this.config.loop);
}; };
SpineWidget.loadWidgets = function () { SpineWidget.loadWidgets = function () {
var widgets = document.getElementsByClassName("spine-widget"); var widgets = document.getElementsByClassName("spine-widget");

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

File diff suppressed because one or more lines are too long

8
spine-ts/core/src/Animation.ts
View File

@ -215,7 +215,7 @@ module spine {
bone.rotation = bone.data.rotation + frames[frames.length + RotateTimeline.PREV_ROTATION] * alpha; bone.rotation = bone.data.rotation + frames[frames.length + RotateTimeline.PREV_ROTATION] * alpha;
else { else {
let r = bone.data.rotation + frames[frames.length + RotateTimeline.PREV_ROTATION] - bone.rotation; let r = bone.data.rotation + frames[frames.length + RotateTimeline.PREV_ROTATION] - bone.rotation;
r -= (16384 - Math.floor(16384.499999999996 - r / 360)) * 360; // Wrap within -180 and 180. r -= (16384 - ((16384.499999999996 - r / 360) | 0)) * 360; // Wrap within -180 and 180.
bone.rotation += r * alpha; bone.rotation += r * alpha;
} }
return; return;
@ -229,14 +229,14 @@ module spine {
1 - (time - frameTime) / (frames[frame + RotateTimeline.PREV_TIME] - frameTime)); 1 - (time - frameTime) / (frames[frame + RotateTimeline.PREV_TIME] - frameTime));
let r = frames[frame + RotateTimeline.ROTATION] - prevRotation; let r = frames[frame + RotateTimeline.ROTATION] - prevRotation;
r -= (16384 - Math.floor(16384.499999999996 - r / 360)) * 360; r -= (16384 - ((16384.499999999996 - r / 360) | 0)) * 360;
r = prevRotation + r * percent; r = prevRotation + r * percent;
if (setupPose) { if (setupPose) {
r -= (16384 - Math.floor(16384.499999999996 - r / 360)) * 360; r -= (16384 - ((16384.499999999996 - r / 360) | 0)) * 360;
bone.rotation = bone.data.rotation + r * alpha; bone.rotation = bone.data.rotation + r * alpha;
} else { } else {
r = bone.data.rotation + r - bone.rotation; r = bone.data.rotation + r - bone.rotation;
r -= (16384 - Math.floor(16384.499999999996 - r / 360)) * 360; r -= (16384 - ((16384.499999999996 - r / 360) |0)) * 360;
bone.rotation += r * alpha; bone.rotation += r * alpha;
} }
} }

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

@ -238,9 +238,9 @@ module spine {
1 - (time - frameTime) / (frames[frame + RotateTimeline.PREV_TIME] - frameTime)); 1 - (time - frameTime) / (frames[frame + RotateTimeline.PREV_TIME] - frameTime));
r2 = frames[frame + RotateTimeline.ROTATION] - prevRotation; r2 = frames[frame + RotateTimeline.ROTATION] - prevRotation;
r2 -= (16384 - Math.floor((16384.499999999996 - r2 / 360))) * 360; r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360;
r2 = prevRotation + r2 * percent + bone.data.rotation; r2 = prevRotation + r2 * percent + bone.data.rotation;
r2 -= (16384 - Math.floor((16384.499999999996 - r2 / 360))) * 360; 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.
@ -253,7 +253,7 @@ module spine {
} else } else
total = timelinesRotation[i]; total = timelinesRotation[i];
} else { } else {
diff -= (16384 - Math.floor((16384.499999999996 - diff / 360))) * 360; diff -= (16384 - ((16384.499999999996 - diff / 360) | 0)) * 360;
let lastTotal = 0, lastDiff = 0; let lastTotal = 0, lastDiff = 0;
if (firstFrame) { if (firstFrame) {
lastTotal = 0; lastTotal = 0;
@ -275,7 +275,7 @@ module spine {
} }
timelinesRotation[i + 1] = diff; timelinesRotation[i + 1] = diff;
r1 += total * alpha; r1 += total * alpha;
bone.rotation = r1 - (16384 - Math.floor((16384.499999999996 - r1 / 360))) * 360; bone.rotation = r1 - (16384 - ((16384.499999999996 - r1 / 360) | 0)) * 360;
} }
queueEvents (entry: TrackEntry, animationTime: number) { queueEvents (entry: TrackEntry, animationTime: number) {
@ -384,13 +384,13 @@ module spine {
return entry; return entry;
} }
addAnimationByName (trackIndex: number, animationName: string, loop: boolean, delay: number) { addAnimation (trackIndex: number, animationName: string, loop: boolean, delay: number) {
let animation = this.data.skeletonData.findAnimation(animationName); let animation = this.data.skeletonData.findAnimation(animationName);
if (animation == null) throw new Error("Animation not found: " + animationName); if (animation == null) throw new Error("Animation not found: " + animationName);
return this.addAnimation(trackIndex, animation, loop, delay); return this.addAnimationWith(trackIndex, animation, loop, delay);
} }
addAnimation (trackIndex: number, animation: Animation, loop: boolean, delay: number) { addAnimationWith (trackIndex: number, animation: Animation, loop: boolean, delay: number) {
if (animation == null) throw new Error("animation cannot be null."); if (animation == null) throw new Error("animation cannot be null.");
let last = this.expandToIndex(trackIndex); let last = this.expandToIndex(trackIndex);
@ -409,7 +409,7 @@ module spine {
if (delay <= 0) { if (delay <= 0) {
let duration = last.animationEnd - last.animationStart; let duration = last.animationEnd - last.animationStart;
if (duration != 0) if (duration != 0)
delay += duration * (1 + Math.floor(last.trackTime / duration)) - this.data.getMix(last.animation, animation); delay += duration * (1 + ((last.trackTime / duration) | 0)) - this.data.getMix(last.animation, animation);
else else
delay = 0; delay = 0;
} }
@ -428,7 +428,7 @@ module spine {
addEmptyAnimation (trackIndex: number, mixDuration: number, delay: number) { addEmptyAnimation (trackIndex: number, mixDuration: number, delay: number) {
if (delay <= 0) delay -= mixDuration; if (delay <= 0) delay -= mixDuration;
let entry = this.addAnimation(trackIndex, AnimationState.emptyAnimation, false, delay); let entry = this.addAnimationWith(trackIndex, AnimationState.emptyAnimation, false, delay);
entry.mixDuration = mixDuration; entry.mixDuration = mixDuration;
entry.trackEnd = mixDuration; entry.trackEnd = mixDuration;
return entry; return entry;
@ -446,7 +446,7 @@ module spine {
expandToIndex (index: number) { expandToIndex (index: number) {
if (index < this.tracks.length) return this.tracks[index]; if (index < this.tracks.length) return this.tracks[index];
Utils.ensureArrayCapacity(this.tracks, index - this.tracks.length + 1); Utils.ensureArrayCapacity(this.tracks, index - this.tracks.length + 1, null);
this.tracks.length = index + 1; this.tracks.length = index + 1;
return null; return null;
} }
@ -659,36 +659,36 @@ module spine {
let entry = objects[i + 1] as TrackEntry; let entry = objects[i + 1] as TrackEntry;
switch (type) { switch (type) {
case EventType.start: case EventType.start:
if (entry.listener != null) entry.listener.end(entry); if (entry.listener != null && entry.listener.end) entry.listener.end(entry);
for (let ii = 0; ii < listeners.length; ii++) for (let ii = 0; ii < listeners.length; ii++)
listeners[ii].start(entry); if (listeners[ii].start) listeners[ii].start(entry);
break; break;
case EventType.interrupt: case EventType.interrupt:
if (entry.listener != null) entry.listener.end(entry); if (entry.listener != null && entry.listener.end) entry.listener.end(entry);
for (let ii = 0; ii < listeners.length; ii++) for (let ii = 0; ii < listeners.length; ii++)
listeners[ii].interrupt(entry); if (listeners[ii].interrupt)listeners[ii].interrupt(entry);
break; break;
case EventType.end: case EventType.end:
if (entry.listener != null) entry.listener.end(entry); if (entry.listener != null && entry.listener.end) entry.listener.end(entry);
for (let ii = 0; ii < listeners.length; ii++) for (let ii = 0; ii < listeners.length; ii++)
listeners[ii].end(entry); if (listeners[ii].end) listeners[ii].end(entry);
// Fall through. // Fall through.
case EventType.dispose: case EventType.dispose:
if (entry.listener != null) entry.listener.end(entry); if (entry.listener != null && entry.listener.end) entry.listener.end(entry);
for (let ii = 0; ii < listeners.length; ii++) for (let ii = 0; ii < listeners.length; ii++)
listeners[ii].dispose(entry); if (listeners[ii].dispose) listeners[ii].dispose(entry);
this.animState.trackEntryPool.free(entry); this.animState.trackEntryPool.free(entry);
break; break;
case EventType.complete: case EventType.complete:
if (entry.listener != null) entry.listener.complete(entry); if (entry.listener != null && entry.listener.complete) entry.listener.complete(entry);
for (let ii = 0; ii < listeners.length; ii++) for (let ii = 0; ii < listeners.length; ii++)
listeners[ii].complete(entry); if (listeners[ii].complete) listeners[ii].complete(entry);
break; break;
case EventType.event: case EventType.event:
let event = objects[i++ + 2] as Event; let event = objects[i++ + 2] as Event;
if (entry.listener != null) entry.listener.event(entry, event); if (entry.listener != null && entry.listener.event) entry.listener.event(entry, event);
for (let ii = 0; ii < listeners.length; ii++) for (let ii = 0; ii < listeners.length; ii++)
listeners[ii].event(entry, event); if (listeners[ii].event) listeners[ii].event(entry, event);
break; break;
} }
} }

14
spine-ts/webgl/demos/hoverboard.js
View File

@ -87,7 +87,7 @@ var hoverboardDemo = function(loadingComplete, bgColor) {
for (var i = 0; i < controlBones.length; i++) { for (var i = 0; i < controlBones.length; i++) {
var bone = skeleton.findBone(controlBones[i]); var bone = skeleton.findBone(controlBones[i]);
renderer.camera.screenToWorld(coords.set(x, y, 0), canvas.width, canvas.height); renderer.camera.screenToWorld(coords.set(x, y, 0), canvas.width, canvas.height);
if (temp.set(skeleton.x + bone.worldX, skeleton.y + bone.worldY, 0).distance(coords) < 30) { if (temp.set(bone.worldX, bone.worldY, 0).distance(coords) < 30) {
target = bone; target = bone;
} }
} }
@ -99,12 +99,12 @@ var hoverboardDemo = function(loadingComplete, bgColor) {
if (target != null) { if (target != null) {
renderer.camera.screenToWorld(coords.set(x, y, 0), canvas.width, canvas.height); renderer.camera.screenToWorld(coords.set(x, y, 0), canvas.width, canvas.height);
if (target.parent !== null) { if (target.parent !== null) {
target.parent.worldToLocal(temp2.set(coords.x - skeleton.x, coords.y - skeleton.y)); target.parent.worldToLocal(temp2.set(coords.x, coords.y));
target.x = temp2.x; target.x = temp2.x;
target.y = temp2.y; target.y = temp2.y;
} else { } else {
target.x = coords.x - skeleton.x; target.x = coords.x;
target.y = coords.y - skeleton.y; target.y = coords.y;
} }
} }
}, },
@ -112,7 +112,7 @@ var hoverboardDemo = function(loadingComplete, bgColor) {
for (var i = 0; i < controlBones.length; i++) { for (var i = 0; i < controlBones.length; i++) {
var bone = skeleton.findBone(controlBones[i]); var bone = skeleton.findBone(controlBones[i]);
renderer.camera.screenToWorld(coords.set(x, y, 0), canvas.width, canvas.height); renderer.camera.screenToWorld(coords.set(x, y, 0), canvas.width, canvas.height);
if (temp.set(skeleton.x + bone.worldX, skeleton.y + bone.worldY, 0).distance(coords) < 30) { if (temp.set(bone.worldX, bone.worldY, 0).distance(coords) < 30) {
hoverTargets[i] = bone; hoverTargets[i] = bone;
} else { } else {
hoverTargets[i] = null; hoverTargets[i] = null;
@ -145,8 +145,8 @@ var hoverboardDemo = function(loadingComplete, bgColor) {
var bone = skeleton.findBone(controlBones[i]); var bone = skeleton.findBone(controlBones[i]);
var colorInner = hoverTargets[i] !== null ? spineDemos.HOVER_COLOR_INNER : spineDemos.NON_HOVER_COLOR_INNER; var colorInner = hoverTargets[i] !== null ? spineDemos.HOVER_COLOR_INNER : spineDemos.NON_HOVER_COLOR_INNER;
var colorOuter = hoverTargets[i] !== null ? spineDemos.HOVER_COLOR_OUTER : spineDemos.NON_HOVER_COLOR_OUTER; var colorOuter = hoverTargets[i] !== null ? spineDemos.HOVER_COLOR_OUTER : spineDemos.NON_HOVER_COLOR_OUTER;
renderer.circle(true, skeleton.x + bone.worldX, skeleton.y + bone.worldY, 20, colorInner); renderer.circle(true, bone.worldX, bone.worldY, 20, colorInner);
renderer.circle(false, skeleton.x + bone.worldX, skeleton.y + bone.worldY, 20, colorOuter); renderer.circle(false, bone.worldX, bone.worldY, 20, colorOuter);
} }
renderer.end(); renderer.end();
gl.lineWidth(1); gl.lineWidth(1);

4
spine-ts/webgl/demos/spritesheets.js
View File

@ -55,7 +55,7 @@ var spritesheetsDemo = function(loadingComplete, bgColor) {
skeletonSeq = new spine.Skeleton(skeletonData); skeletonSeq = new spine.Skeleton(skeletonData);
walkAnim = skeletonSeq.data.findAnimation("walk"); walkAnim = skeletonSeq.data.findAnimation("walk");
walkAnim.apply(skeletonSeq, 0, 0, true, null); walkAnim.apply(skeletonSeq, 0, 0, true, null, 1, true, false);
skeletonSeq.x += bounds.x + 150; skeletonSeq.x += bounds.x + 150;
viewportWidth = ((700 + bounds.x) - offset.x); viewportWidth = ((700 + bounds.x) - offset.x);
@ -131,7 +131,7 @@ var spritesheetsDemo = function(loadingComplete, bgColor) {
walkLastTimePrecise += delta; walkLastTimePrecise += delta;
while (walkLastTimePrecise - walkLastTime > 1 / FPS) { while (walkLastTimePrecise - walkLastTime > 1 / FPS) {
var newWalkTime = walkLastTime + 1 / FPS; var newWalkTime = walkLastTime + 1 / FPS;
walkAnim.apply(skeletonSeq, walkLastTime, newWalkTime, true, null); walkAnim.apply(skeletonSeq, walkLastTime, newWalkTime, true, null, 1, true, false);
walkLastTime = newWalkTime; walkLastTime = newWalkTime;
} }
skeletonSeq.updateWorldTransform(); skeletonSeq.updateWorldTransform();

22
spine-ts/webgl/example/index.html
View File

@ -119,17 +119,23 @@ function loadSkeleton (name, initialAnimation, premultipliedAlpha, skin) {
var animationState = new spine.AnimationState(new spine.AnimationStateData(skeleton.data)); var animationState = new spine.AnimationState(new spine.AnimationStateData(skeleton.data));
animationState.setAnimation(0, initialAnimation, true); animationState.setAnimation(0, initialAnimation, true);
animationState.addListener({ animationState.addListener({
event: function(trackIndex, event) { start: function(track) {
// console.log("Event on track " + trackIndex + ": " + JSON.stringify(event)); console.log("Animation on track " + track.trackIndex + " started");
}, },
complete: function(trackIndex, loopCount) { interrupt: function(track) {
// console.log("Animation on track " + trackIndex + " completed, loop count: " + loopCount); console.log("Animation on track " + track.trackIndex + " interrupted");
}, },
start: function(trackIndex) { end: function(track) {
// console.log("Animation on track " + trackIndex + " started"); console.log("Animation on track " + track.trackIndex + " ended");
}, },
end: function(trackIndex) { disposed: function(track) {
// console.log("Animation on track " + trackIndex + " ended"); console.log("Animation on track " + track.trackIndex + " disposed");
},
complete: function(track) {
console.log("Animation on track " + track.trackIndex + " completed");
},
event: function(track, event) {
console.log("Event on track " + track.trackIndex + ": " + JSON.stringify(event));
} }
}) })