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 remote-tracking branch 'origin/dev' into dev

Browse Source
This commit is contained in:
NathanSweet 2016-10-25 01:51:29 +02:00
commit 1c801a45fc
24 changed files with 364 additions and 322 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;
clearTrack(trackIndex: number): void;
setCurrent(index: number, current: TrackEntry): void;
setAnimationByName(trackIndex: number, animationName: string, loop: boolean): TrackEntry;
setAnimation(trackIndex: number, animation: Animation, loop: boolean): TrackEntry;
addAnimationByName(trackIndex: number, animationName: string, loop: boolean, delay: number): TrackEntry;
addAnimation(trackIndex: number, animation: Animation, loop: boolean, delay: number): TrackEntry;
setAnimation(trackIndex: number, animationName: string, loop: boolean): TrackEntry;
setAnimationWith(trackIndex: number, animation: Animation, loop: boolean): TrackEntry;
addAnimation(trackIndex: number, animationName: string, loop: boolean, delay: number): TrackEntry;
addAnimationWith(trackIndex: number, animation: Animation, loop: boolean, delay: number): TrackEntry;
setEmptyAnimation(trackIndex: number, mixDuration: number): TrackEntry;
addEmptyAnimation(trackIndex: number, mixDuration: number, delay: number): TrackEntry;
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;
else {
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;
}
return;
@ -533,15 +533,15 @@ var spine;
var frameTime = frames[frame];
var percent = this.getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + RotateTimeline.PREV_TIME] - frameTime));
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;
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;
}
else {
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;
}
};
@ -1415,9 +1415,9 @@ var spine;
var frameTime = frames[frame];
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 - Math.floor((16384.499999999996 - r2 / 360))) * 360;
r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360;
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 total = 0, diff = r2 - r1;
@ -1430,7 +1430,7 @@ var spine;
total = timelinesRotation[i];
}
else {
diff -= (16384 - Math.floor((16384.499999999996 - diff / 360))) * 360;
diff -= (16384 - ((16384.499999999996 - diff / 360) | 0)) * 360;
var lastTotal = 0, lastDiff = 0;
if (firstFrame) {
lastTotal = 0;
@ -1453,7 +1453,7 @@ var spine;
}
timelinesRotation[i + 1] = diff;
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) {
var animationStart = entry.animationStart, animationEnd = entry.animationEnd;
@ -1522,13 +1522,13 @@ var spine;
}
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);
if (animation == null)
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)
throw new Error("animation cannot be null.");
var current = this.expandToIndex(trackIndex);
@ -1548,13 +1548,13 @@ var spine;
this.queue.drain();
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);
if (animation == null)
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)
throw new Error("animation cannot be null.");
var last = this.expandToIndex(trackIndex);
@ -1572,7 +1572,7 @@ var spine;
if (delay <= 0) {
var duration = last.animationEnd - last.animationStart;
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
delay = 0;
}
@ -1581,7 +1581,7 @@ var spine;
return entry;
};
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.trackEnd = mixDuration;
return entry;
@ -1589,7 +1589,7 @@ var spine;
AnimationState.prototype.addEmptyAnimation = function (trackIndex, mixDuration, delay) {
if (delay <= 0)
delay -= mixDuration;
var entry = this.addAnimation(trackIndex, AnimationState.emptyAnimation, false, delay);
var entry = this.addAnimationWith(trackIndex, AnimationState.emptyAnimation, false, delay);
entry.mixDuration = mixDuration;
entry.trackEnd = mixDuration;
return entry;
@ -1607,7 +1607,7 @@ var spine;
AnimationState.prototype.expandToIndex = function (index) {
if (index < this.tracks.length)
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;
return null;
};
@ -1790,41 +1790,47 @@ var spine;
var entry = objects[i + 1];
switch (type) {
case EventType.start:
if (entry.listener != null)
if (entry.listener != null && entry.listener.end)
entry.listener.end(entry);
for (var ii = 0; ii < listeners.length; ii++)
listeners[ii].start(entry);
if (listeners[ii].start)
listeners[ii].start(entry);
break;
case EventType.interrupt:
if (entry.listener != null)
if (entry.listener != null && entry.listener.end)
entry.listener.end(entry);
for (var ii = 0; ii < listeners.length; ii++)
listeners[ii].interrupt(entry);
if (listeners[ii].interrupt)
listeners[ii].interrupt(entry);
break;
case EventType.end:
if (entry.listener != null)
if (entry.listener != null && entry.listener.end)
entry.listener.end(entry);
for (var ii = 0; ii < listeners.length; ii++)
listeners[ii].end(entry);
if (listeners[ii].end)
listeners[ii].end(entry);
case EventType.dispose:
if (entry.listener != null)
if (entry.listener != null && entry.listener.end)
entry.listener.end(entry);
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);
break;
case EventType.complete:
if (entry.listener != null)
if (entry.listener != null && entry.listener.complete)
entry.listener.complete(entry);
for (var ii = 0; ii < listeners.length; ii++)
listeners[ii].complete(entry);
if (listeners[ii].complete)
listeners[ii].complete(entry);
break;
case EventType.event:
var event_3 = objects[i++ + 2];
if (entry.listener != null)
if (entry.listener != null && entry.listener.event)
entry.listener.event(entry, event_3);
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;
}
}
@ -7887,7 +7893,7 @@ var spine;
skeleton.y = config.y;
}
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)
config.success(this);
this.loaded = true;
@ -7982,7 +7988,7 @@ var spine;
if (!this.loaded)
throw new Error("Widget isn't loaded yet");
this.skeleton.setToSetupPose();
this.state.setAnimationByName(0, animationName, this.config.loop);
this.state.setAnimation(0, animationName, this.config.loop);
};
SpineWidget.loadWidgets = function () {
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;
clearTrack(trackIndex: number): void;
setCurrent(index: number, current: TrackEntry): void;
setAnimationByName(trackIndex: number, animationName: string, loop: boolean): TrackEntry;
setAnimation(trackIndex: number, animation: Animation, loop: boolean): TrackEntry;
addAnimationByName(trackIndex: number, animationName: string, loop: boolean, delay: number): TrackEntry;
addAnimation(trackIndex: number, animation: Animation, loop: boolean, delay: number): TrackEntry;
setAnimation(trackIndex: number, animationName: string, loop: boolean): TrackEntry;
setAnimationWith(trackIndex: number, animation: Animation, loop: boolean): TrackEntry;
addAnimation(trackIndex: number, animationName: string, loop: boolean, delay: number): TrackEntry;
addAnimationWith(trackIndex: number, animation: Animation, loop: boolean, delay: number): TrackEntry;
setEmptyAnimation(trackIndex: number, mixDuration: number): TrackEntry;
addEmptyAnimation(trackIndex: number, mixDuration: number, delay: number): TrackEntry;
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;
else {
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;
}
return;
@ -533,15 +533,15 @@ var spine;
var frameTime = frames[frame];
var percent = this.getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + RotateTimeline.PREV_TIME] - frameTime));
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;
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;
}
else {
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;
}
};
@ -1415,9 +1415,9 @@ var spine;
var frameTime = frames[frame];
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 - Math.floor((16384.499999999996 - r2 / 360))) * 360;
r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360;
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 total = 0, diff = r2 - r1;
@ -1430,7 +1430,7 @@ var spine;
total = timelinesRotation[i];
}
else {
diff -= (16384 - Math.floor((16384.499999999996 - diff / 360))) * 360;
diff -= (16384 - ((16384.499999999996 - diff / 360) | 0)) * 360;
var lastTotal = 0, lastDiff = 0;
if (firstFrame) {
lastTotal = 0;
@ -1453,7 +1453,7 @@ var spine;
}
timelinesRotation[i + 1] = diff;
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) {
var animationStart = entry.animationStart, animationEnd = entry.animationEnd;
@ -1522,13 +1522,13 @@ var spine;
}
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);
if (animation == null)
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)
throw new Error("animation cannot be null.");
var current = this.expandToIndex(trackIndex);
@ -1548,13 +1548,13 @@ var spine;
this.queue.drain();
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);
if (animation == null)
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)
throw new Error("animation cannot be null.");
var last = this.expandToIndex(trackIndex);
@ -1572,7 +1572,7 @@ var spine;
if (delay <= 0) {
var duration = last.animationEnd - last.animationStart;
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
delay = 0;
}
@ -1581,7 +1581,7 @@ var spine;
return entry;
};
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.trackEnd = mixDuration;
return entry;
@ -1589,7 +1589,7 @@ var spine;
AnimationState.prototype.addEmptyAnimation = function (trackIndex, mixDuration, delay) {
if (delay <= 0)
delay -= mixDuration;
var entry = this.addAnimation(trackIndex, AnimationState.emptyAnimation, false, delay);
var entry = this.addAnimationWith(trackIndex, AnimationState.emptyAnimation, false, delay);
entry.mixDuration = mixDuration;
entry.trackEnd = mixDuration;
return entry;
@ -1607,7 +1607,7 @@ var spine;
AnimationState.prototype.expandToIndex = function (index) {
if (index < this.tracks.length)
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;
return null;
};
@ -1790,41 +1790,47 @@ var spine;
var entry = objects[i + 1];
switch (type) {
case EventType.start:
if (entry.listener != null)
if (entry.listener != null && entry.listener.end)
entry.listener.end(entry);
for (var ii = 0; ii < listeners.length; ii++)
listeners[ii].start(entry);
if (listeners[ii].start)
listeners[ii].start(entry);
break;
case EventType.interrupt:
if (entry.listener != null)
if (entry.listener != null && entry.listener.end)
entry.listener.end(entry);
for (var ii = 0; ii < listeners.length; ii++)
listeners[ii].interrupt(entry);
if (listeners[ii].interrupt)
listeners[ii].interrupt(entry);
break;
case EventType.end:
if (entry.listener != null)
if (entry.listener != null && entry.listener.end)
entry.listener.end(entry);
for (var ii = 0; ii < listeners.length; ii++)
listeners[ii].end(entry);
if (listeners[ii].end)
listeners[ii].end(entry);
case EventType.dispose:
if (entry.listener != null)
if (entry.listener != null && entry.listener.end)
entry.listener.end(entry);
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);
break;
case EventType.complete:
if (entry.listener != null)
if (entry.listener != null && entry.listener.complete)
entry.listener.complete(entry);
for (var ii = 0; ii < listeners.length; ii++)
listeners[ii].complete(entry);
if (listeners[ii].complete)
listeners[ii].complete(entry);
break;
case EventType.event:
var event_3 = objects[i++ + 2];
if (entry.listener != null)
if (entry.listener != null && entry.listener.event)
entry.listener.event(entry, event_3);
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;
}
}

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;
clearTrack(trackIndex: number): void;
setCurrent(index: number, current: TrackEntry): void;
setAnimationByName(trackIndex: number, animationName: string, loop: boolean): TrackEntry;
setAnimation(trackIndex: number, animation: Animation, loop: boolean): TrackEntry;
addAnimationByName(trackIndex: number, animationName: string, loop: boolean, delay: number): TrackEntry;
addAnimation(trackIndex: number, animation: Animation, loop: boolean, delay: number): TrackEntry;
setAnimation(trackIndex: number, animationName: string, loop: boolean): TrackEntry;
setAnimationWith(trackIndex: number, animation: Animation, loop: boolean): TrackEntry;
addAnimation(trackIndex: number, animationName: string, loop: boolean, delay: number): TrackEntry;
addAnimationWith(trackIndex: number, animation: Animation, loop: boolean, delay: number): TrackEntry;
setEmptyAnimation(trackIndex: number, mixDuration: number): TrackEntry;
addEmptyAnimation(trackIndex: number, mixDuration: number, delay: number): TrackEntry;
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;
else {
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;
}
return;
@ -186,15 +186,15 @@ var spine;
var frameTime = frames[frame];
var percent = this.getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + RotateTimeline.PREV_TIME] - frameTime));
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;
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;
}
else {
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;
}
};
@ -1068,9 +1068,9 @@ var spine;
var frameTime = frames[frame];
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 - Math.floor((16384.499999999996 - r2 / 360))) * 360;
r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360;
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 total = 0, diff = r2 - r1;
@ -1083,7 +1083,7 @@ var spine;
total = timelinesRotation[i];
}
else {
diff -= (16384 - Math.floor((16384.499999999996 - diff / 360))) * 360;
diff -= (16384 - ((16384.499999999996 - diff / 360) | 0)) * 360;
var lastTotal = 0, lastDiff = 0;
if (firstFrame) {
lastTotal = 0;
@ -1106,7 +1106,7 @@ var spine;
}
timelinesRotation[i + 1] = diff;
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) {
var animationStart = entry.animationStart, animationEnd = entry.animationEnd;
@ -1175,13 +1175,13 @@ var spine;
}
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);
if (animation == null)
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)
throw new Error("animation cannot be null.");
var current = this.expandToIndex(trackIndex);
@ -1201,13 +1201,13 @@ var spine;
this.queue.drain();
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);
if (animation == null)
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)
throw new Error("animation cannot be null.");
var last = this.expandToIndex(trackIndex);
@ -1225,7 +1225,7 @@ var spine;
if (delay <= 0) {
var duration = last.animationEnd - last.animationStart;
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
delay = 0;
}
@ -1234,7 +1234,7 @@ var spine;
return entry;
};
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.trackEnd = mixDuration;
return entry;
@ -1242,7 +1242,7 @@ var spine;
AnimationState.prototype.addEmptyAnimation = function (trackIndex, mixDuration, delay) {
if (delay <= 0)
delay -= mixDuration;
var entry = this.addAnimation(trackIndex, AnimationState.emptyAnimation, false, delay);
var entry = this.addAnimationWith(trackIndex, AnimationState.emptyAnimation, false, delay);
entry.mixDuration = mixDuration;
entry.trackEnd = mixDuration;
return entry;
@ -1260,7 +1260,7 @@ var spine;
AnimationState.prototype.expandToIndex = function (index) {
if (index < this.tracks.length)
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;
return null;
};
@ -1443,41 +1443,47 @@ var spine;
var entry = objects[i + 1];
switch (type) {
case EventType.start:
if (entry.listener != null)
if (entry.listener != null && entry.listener.end)
entry.listener.end(entry);
for (var ii = 0; ii < listeners.length; ii++)
listeners[ii].start(entry);
if (listeners[ii].start)
listeners[ii].start(entry);
break;
case EventType.interrupt:
if (entry.listener != null)
if (entry.listener != null && entry.listener.end)
entry.listener.end(entry);
for (var ii = 0; ii < listeners.length; ii++)
listeners[ii].interrupt(entry);
if (listeners[ii].interrupt)
listeners[ii].interrupt(entry);
break;
case EventType.end:
if (entry.listener != null)
if (entry.listener != null && entry.listener.end)
entry.listener.end(entry);
for (var ii = 0; ii < listeners.length; ii++)
listeners[ii].end(entry);
if (listeners[ii].end)
listeners[ii].end(entry);
case EventType.dispose:
if (entry.listener != null)
if (entry.listener != null && entry.listener.end)
entry.listener.end(entry);
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);
break;
case EventType.complete:
if (entry.listener != null)
if (entry.listener != null && entry.listener.complete)
entry.listener.complete(entry);
for (var ii = 0; ii < listeners.length; ii++)
listeners[ii].complete(entry);
if (listeners[ii].complete)
listeners[ii].complete(entry);
break;
case EventType.event:
var event_3 = objects[i++ + 2];
if (entry.listener != null)
if (entry.listener != null && entry.listener.event)
entry.listener.event(entry, event_3);
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;
}
}

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;
clearTrack(trackIndex: number): void;
setCurrent(index: number, current: TrackEntry): void;
setAnimationByName(trackIndex: number, animationName: string, loop: boolean): TrackEntry;
setAnimation(trackIndex: number, animation: Animation, loop: boolean): TrackEntry;
addAnimationByName(trackIndex: number, animationName: string, loop: boolean, delay: number): TrackEntry;
addAnimation(trackIndex: number, animation: Animation, loop: boolean, delay: number): TrackEntry;
setAnimation(trackIndex: number, animationName: string, loop: boolean): TrackEntry;
setAnimationWith(trackIndex: number, animation: Animation, loop: boolean): TrackEntry;
addAnimation(trackIndex: number, animationName: string, loop: boolean, delay: number): TrackEntry;
addAnimationWith(trackIndex: number, animation: Animation, loop: boolean, delay: number): TrackEntry;
setEmptyAnimation(trackIndex: number, mixDuration: number): TrackEntry;
addEmptyAnimation(trackIndex: number, mixDuration: number, delay: number): TrackEntry;
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;
else {
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;
}
return;
@ -186,15 +186,15 @@ var spine;
var frameTime = frames[frame];
var percent = this.getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + RotateTimeline.PREV_TIME] - frameTime));
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;
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;
}
else {
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;
}
};
@ -1068,9 +1068,9 @@ var spine;
var frameTime = frames[frame];
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 - Math.floor((16384.499999999996 - r2 / 360))) * 360;
r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360;
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 total = 0, diff = r2 - r1;
@ -1083,7 +1083,7 @@ var spine;
total = timelinesRotation[i];
}
else {
diff -= (16384 - Math.floor((16384.499999999996 - diff / 360))) * 360;
diff -= (16384 - ((16384.499999999996 - diff / 360) | 0)) * 360;
var lastTotal = 0, lastDiff = 0;
if (firstFrame) {
lastTotal = 0;
@ -1106,7 +1106,7 @@ var spine;
}
timelinesRotation[i + 1] = diff;
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) {
var animationStart = entry.animationStart, animationEnd = entry.animationEnd;
@ -1175,13 +1175,13 @@ var spine;
}
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);
if (animation == null)
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)
throw new Error("animation cannot be null.");
var current = this.expandToIndex(trackIndex);
@ -1201,13 +1201,13 @@ var spine;
this.queue.drain();
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);
if (animation == null)
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)
throw new Error("animation cannot be null.");
var last = this.expandToIndex(trackIndex);
@ -1225,7 +1225,7 @@ var spine;
if (delay <= 0) {
var duration = last.animationEnd - last.animationStart;
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
delay = 0;
}
@ -1234,7 +1234,7 @@ var spine;
return entry;
};
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.trackEnd = mixDuration;
return entry;
@ -1242,7 +1242,7 @@ var spine;
AnimationState.prototype.addEmptyAnimation = function (trackIndex, mixDuration, delay) {
if (delay <= 0)
delay -= mixDuration;
var entry = this.addAnimation(trackIndex, AnimationState.emptyAnimation, false, delay);
var entry = this.addAnimationWith(trackIndex, AnimationState.emptyAnimation, false, delay);
entry.mixDuration = mixDuration;
entry.trackEnd = mixDuration;
return entry;
@ -1260,7 +1260,7 @@ var spine;
AnimationState.prototype.expandToIndex = function (index) {
if (index < this.tracks.length)
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;
return null;
};
@ -1443,41 +1443,47 @@ var spine;
var entry = objects[i + 1];
switch (type) {
case EventType.start:
if (entry.listener != null)
if (entry.listener != null && entry.listener.end)
entry.listener.end(entry);
for (var ii = 0; ii < listeners.length; ii++)
listeners[ii].start(entry);
if (listeners[ii].start)
listeners[ii].start(entry);
break;
case EventType.interrupt:
if (entry.listener != null)
if (entry.listener != null && entry.listener.end)
entry.listener.end(entry);
for (var ii = 0; ii < listeners.length; ii++)
listeners[ii].interrupt(entry);
if (listeners[ii].interrupt)
listeners[ii].interrupt(entry);
break;
case EventType.end:
if (entry.listener != null)
if (entry.listener != null && entry.listener.end)
entry.listener.end(entry);
for (var ii = 0; ii < listeners.length; ii++)
listeners[ii].end(entry);
if (listeners[ii].end)
listeners[ii].end(entry);
case EventType.dispose:
if (entry.listener != null)
if (entry.listener != null && entry.listener.end)
entry.listener.end(entry);
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);
break;
case EventType.complete:
if (entry.listener != null)
if (entry.listener != null && entry.listener.complete)
entry.listener.complete(entry);
for (var ii = 0; ii < listeners.length; ii++)
listeners[ii].complete(entry);
if (listeners[ii].complete)
listeners[ii].complete(entry);
break;
case EventType.event:
var event_3 = objects[i++ + 2];
if (entry.listener != null)
if (entry.listener != null && entry.listener.event)
entry.listener.event(entry, event_3);
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;
}
}

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

File diff suppressed because one or more lines are too long

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

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

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

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

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;
clearTrack(trackIndex: number): void;
setCurrent(index: number, current: TrackEntry): void;
setAnimationByName(trackIndex: number, animationName: string, loop: boolean): TrackEntry;
setAnimation(trackIndex: number, animation: Animation, loop: boolean): TrackEntry;
addAnimationByName(trackIndex: number, animationName: string, loop: boolean, delay: number): TrackEntry;
addAnimation(trackIndex: number, animation: Animation, loop: boolean, delay: number): TrackEntry;
setAnimation(trackIndex: number, animationName: string, loop: boolean): TrackEntry;
setAnimationWith(trackIndex: number, animation: Animation, loop: boolean): TrackEntry;
addAnimation(trackIndex: number, animationName: string, loop: boolean, delay: number): TrackEntry;
addAnimationWith(trackIndex: number, animation: Animation, loop: boolean, delay: number): TrackEntry;
setEmptyAnimation(trackIndex: number, mixDuration: number): TrackEntry;
addEmptyAnimation(trackIndex: number, mixDuration: number, delay: number): TrackEntry;
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;
else {
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;
}
return;
@ -186,15 +186,15 @@ var spine;
var frameTime = frames[frame];
var percent = this.getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + RotateTimeline.PREV_TIME] - frameTime));
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;
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;
}
else {
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;
}
};
@ -1068,9 +1068,9 @@ var spine;
var frameTime = frames[frame];
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 - Math.floor((16384.499999999996 - r2 / 360))) * 360;
r2 -= (16384 - ((16384.499999999996 - r2 / 360) | 0)) * 360;
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 total = 0, diff = r2 - r1;
@ -1083,7 +1083,7 @@ var spine;
total = timelinesRotation[i];
}
else {
diff -= (16384 - Math.floor((16384.499999999996 - diff / 360))) * 360;
diff -= (16384 - ((16384.499999999996 - diff / 360) | 0)) * 360;
var lastTotal = 0, lastDiff = 0;
if (firstFrame) {
lastTotal = 0;
@ -1106,7 +1106,7 @@ var spine;
}
timelinesRotation[i + 1] = diff;
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) {
var animationStart = entry.animationStart, animationEnd = entry.animationEnd;
@ -1175,13 +1175,13 @@ var spine;
}
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);
if (animation == null)
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)
throw new Error("animation cannot be null.");
var current = this.expandToIndex(trackIndex);
@ -1201,13 +1201,13 @@ var spine;
this.queue.drain();
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);
if (animation == null)
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)
throw new Error("animation cannot be null.");
var last = this.expandToIndex(trackIndex);
@ -1225,7 +1225,7 @@ var spine;
if (delay <= 0) {
var duration = last.animationEnd - last.animationStart;
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
delay = 0;
}
@ -1234,7 +1234,7 @@ var spine;
return entry;
};
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.trackEnd = mixDuration;
return entry;
@ -1242,7 +1242,7 @@ var spine;
AnimationState.prototype.addEmptyAnimation = function (trackIndex, mixDuration, delay) {
if (delay <= 0)
delay -= mixDuration;
var entry = this.addAnimation(trackIndex, AnimationState.emptyAnimation, false, delay);
var entry = this.addAnimationWith(trackIndex, AnimationState.emptyAnimation, false, delay);
entry.mixDuration = mixDuration;
entry.trackEnd = mixDuration;
return entry;
@ -1260,7 +1260,7 @@ var spine;
AnimationState.prototype.expandToIndex = function (index) {
if (index < this.tracks.length)
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;
return null;
};
@ -1443,41 +1443,47 @@ var spine;
var entry = objects[i + 1];
switch (type) {
case EventType.start:
if (entry.listener != null)
if (entry.listener != null && entry.listener.end)
entry.listener.end(entry);
for (var ii = 0; ii < listeners.length; ii++)
listeners[ii].start(entry);
if (listeners[ii].start)
listeners[ii].start(entry);
break;
case EventType.interrupt:
if (entry.listener != null)
if (entry.listener != null && entry.listener.end)
entry.listener.end(entry);
for (var ii = 0; ii < listeners.length; ii++)
listeners[ii].interrupt(entry);
if (listeners[ii].interrupt)
listeners[ii].interrupt(entry);
break;
case EventType.end:
if (entry.listener != null)
if (entry.listener != null && entry.listener.end)
entry.listener.end(entry);
for (var ii = 0; ii < listeners.length; ii++)
listeners[ii].end(entry);
if (listeners[ii].end)
listeners[ii].end(entry);
case EventType.dispose:
if (entry.listener != null)
if (entry.listener != null && entry.listener.end)
entry.listener.end(entry);
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);
break;
case EventType.complete:
if (entry.listener != null)
if (entry.listener != null && entry.listener.complete)
entry.listener.complete(entry);
for (var ii = 0; ii < listeners.length; ii++)
listeners[ii].complete(entry);
if (listeners[ii].complete)
listeners[ii].complete(entry);
break;
case EventType.event:
var event_3 = objects[i++ + 2];
if (entry.listener != null)
if (entry.listener != null && entry.listener.event)
entry.listener.event(entry, event_3);
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;
}
}
@ -7466,7 +7472,7 @@ var spine;
skeleton.y = config.y;
}
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)
config.success(this);
this.loaded = true;
@ -7561,7 +7567,7 @@ var spine;
if (!this.loaded)
throw new Error("Widget isn't loaded yet");
this.skeleton.setToSetupPose();
this.state.setAnimationByName(0, animationName, this.config.loop);
this.state.setAnimation(0, animationName, this.config.loop);
};
SpineWidget.loadWidgets = function () {
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;
else {
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;
}
return;
@ -229,14 +229,14 @@ module spine {
1 - (time - frameTime) / (frames[frame + RotateTimeline.PREV_TIME] - frameTime));
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;
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;
} else {
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;
}
}

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

@ -238,9 +238,9 @@ module spine {
1 - (time - frameTime) / (frames[frame + RotateTimeline.PREV_TIME] - frameTime));
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 -= (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.
@ -253,7 +253,7 @@ module spine {
} else
total = timelinesRotation[i];
} else {
diff -= (16384 - Math.floor((16384.499999999996 - diff / 360))) * 360;
diff -= (16384 - ((16384.499999999996 - diff / 360) | 0)) * 360;
let lastTotal = 0, lastDiff = 0;
if (firstFrame) {
lastTotal = 0;
@ -275,7 +275,7 @@ module spine {
}
timelinesRotation[i + 1] = diff;
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) {
@ -358,13 +358,13 @@ module spine {
this.queue.start(current);
}
setAnimationByName (trackIndex: number, animationName: string, loop: boolean) {
setAnimation (trackIndex: number, animationName: string, loop: boolean) {
let animation = this.data.skeletonData.findAnimation(animationName);
if (animation == null) throw new Error("Animation not found: " + animationName);
return this.setAnimation(trackIndex, animation, loop);
return this.setAnimationWith(trackIndex, animation, loop);
}
setAnimation (trackIndex: number, animation: Animation, loop: boolean) {
setAnimationWith (trackIndex: number, animation: Animation, loop: boolean) {
if (animation == null) throw new Error("animation cannot be null.");
let current = this.expandToIndex(trackIndex);
if (current != null) {
@ -384,13 +384,13 @@ module spine {
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);
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.");
let last = this.expandToIndex(trackIndex);
@ -409,7 +409,7 @@ module spine {
if (delay <= 0) {
let duration = last.animationEnd - last.animationStart;
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
delay = 0;
}
@ -420,7 +420,7 @@ module spine {
}
setEmptyAnimation (trackIndex: number, mixDuration: number) {
let entry = this.setAnimation(trackIndex, AnimationState.emptyAnimation, false);
let entry = this.setAnimationWith(trackIndex, AnimationState.emptyAnimation, false);
entry.mixDuration = mixDuration;
entry.trackEnd = mixDuration;
return entry;
@ -428,7 +428,7 @@ module spine {
addEmptyAnimation (trackIndex: number, mixDuration: number, delay: number) {
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.trackEnd = mixDuration;
return entry;
@ -446,7 +446,7 @@ module spine {
expandToIndex (index: number) {
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;
return null;
}
@ -659,36 +659,36 @@ module spine {
let entry = objects[i + 1] as TrackEntry;
switch (type) {
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++)
listeners[ii].start(entry);
if (listeners[ii].start) listeners[ii].start(entry);
break;
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++)
listeners[ii].interrupt(entry);
if (listeners[ii].interrupt)listeners[ii].interrupt(entry);
break;
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++)
listeners[ii].end(entry);
if (listeners[ii].end) listeners[ii].end(entry);
// Fall through.
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++)
listeners[ii].dispose(entry);
if (listeners[ii].dispose) listeners[ii].dispose(entry);
this.animState.trackEntryPool.free(entry);
break;
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++)
listeners[ii].complete(entry);
if (listeners[ii].complete) listeners[ii].complete(entry);
break;
case EventType.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++)
listeners[ii].event(entry, event);
if (listeners[ii].event) listeners[ii].event(entry, event);
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++) {
var bone = skeleton.findBone(controlBones[i]);
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;
}
}
@ -99,12 +99,12 @@ var hoverboardDemo = function(loadingComplete, bgColor) {
if (target != null) {
renderer.camera.screenToWorld(coords.set(x, y, 0), canvas.width, canvas.height);
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.y = temp2.y;
} else {
target.x = coords.x - skeleton.x;
target.y = coords.y - skeleton.y;
target.x = coords.x;
target.y = coords.y;
}
}
},
@ -112,7 +112,7 @@ var hoverboardDemo = function(loadingComplete, bgColor) {
for (var i = 0; i < controlBones.length; i++) {
var bone = skeleton.findBone(controlBones[i]);
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;
} else {
hoverTargets[i] = null;
@ -145,8 +145,8 @@ var hoverboardDemo = function(loadingComplete, bgColor) {
var bone = skeleton.findBone(controlBones[i]);
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;
renderer.circle(true, skeleton.x + bone.worldX, skeleton.y + bone.worldY, 20, colorInner);
renderer.circle(false, skeleton.x + bone.worldX, skeleton.y + bone.worldY, 20, colorOuter);
renderer.circle(true, bone.worldX, bone.worldY, 20, colorInner);
renderer.circle(false, bone.worldX, bone.worldY, 20, colorOuter);
}
renderer.end();
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);
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;
viewportWidth = ((700 + bounds.x) - offset.x);
@ -131,7 +131,7 @@ var spritesheetsDemo = function(loadingComplete, bgColor) {
walkLastTimePrecise += delta;
while (walkLastTimePrecise - 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;
}
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));
animationState.setAnimation(0, initialAnimation, true);
animationState.addListener({
event: function(trackIndex, event) {
// console.log("Event on track " + trackIndex + ": " + JSON.stringify(event));
start: function(track) {
console.log("Animation on track " + track.trackIndex + " started");
},
complete: function(trackIndex, loopCount) {
// console.log("Animation on track " + trackIndex + " completed, loop count: " + loopCount);
interrupt: function(track) {
console.log("Animation on track " + track.trackIndex + " interrupted");
},
start: function(trackIndex) {
// console.log("Animation on track " + trackIndex + " started");
end: function(track) {
console.log("Animation on track " + track.trackIndex + " ended");
},
end: function(trackIndex) {
// console.log("Animation on track " + trackIndex + " ended");
disposed: function(track) {
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));
}
})

4
spine-ts/widget/src/Widget.ts
View File

@ -143,7 +143,7 @@ module spine {
}
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) config.success(this);
this.loaded = true;
requestAnimationFrame(() => { this.render(); });
@ -246,7 +246,7 @@ module spine {
setAnimation (animationName: string) {
if (!this.loaded) throw new Error("Widget isn't loaded yet");
this.skeleton.setToSetupPose();
this.state.setAnimationByName(0, animationName, this.config.loop);
this.state.setAnimation(0, animationName, this.config.loop);
}