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;
} }
} }

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

@ -5,31 +5,31 @@ var hoverboardDemo = function(loadingComplete, bgColor) {
var COLOR_OUTER_SELECTED = new spine.Color(0.0, 0, 0.8, 0.8); var COLOR_OUTER_SELECTED = new spine.Color(0.0, 0, 0.8, 0.8);
var canvas, gl, renderer, input, assetManager; var canvas, gl, renderer, input, assetManager;
var skeleton, state, bounds; var skeleton, state, bounds;
var timeKeeper, loadingScreen; var timeKeeper, loadingScreen;
var target = null; var target = null;
var hoverTargets = []; var hoverTargets = [];
var controlBones = ["hoverboard controller", "hip controller", "board target"]; var controlBones = ["hoverboard controller", "hip controller", "board target"];
var coords = new spine.webgl.Vector3(), temp = new spine.webgl.Vector3(), temp2 = new spine.Vector2(), temp3 = new spine.webgl.Vector3(); var coords = new spine.webgl.Vector3(), temp = new spine.webgl.Vector3(), temp2 = new spine.Vector2(), temp3 = new spine.webgl.Vector3();
var isPlaying = true; var isPlaying = true;
var DEMO_NAME = "HoverboardDemo"; var DEMO_NAME = "HoverboardDemo";
if (!bgColor) bgColor = new spine.Color(235 / 255, 239 / 255, 244 / 255, 1); if (!bgColor) bgColor = new spine.Color(235 / 255, 239 / 255, 244 / 255, 1);
function init () { function init () {
canvas = document.getElementById("hoverboard-canvas"); canvas = document.getElementById("hoverboard-canvas");
canvas.width = canvas.clientWidth; canvas.height = canvas.clientHeight; canvas.width = canvas.clientWidth; canvas.height = canvas.clientHeight;
gl = canvas.getContext("webgl", { alpha: false }) || canvas.getContext("experimental-webgl", { alpha: false }); gl = canvas.getContext("webgl", { alpha: false }) || canvas.getContext("experimental-webgl", { alpha: false });
renderer = new spine.webgl.SceneRenderer(canvas, gl); renderer = new spine.webgl.SceneRenderer(canvas, gl);
assetManager = spineDemos.assetManager; assetManager = spineDemos.assetManager;
var textureLoader = function(img) { return new spine.webgl.GLTexture(gl, img); }; var textureLoader = function(img) { return new spine.webgl.GLTexture(gl, img); };
assetManager.loadTexture(DEMO_NAME, textureLoader, "atlas1.png"); assetManager.loadTexture(DEMO_NAME, textureLoader, "atlas1.png");
assetManager.loadText(DEMO_NAME, "atlas1.atlas"); assetManager.loadText(DEMO_NAME, "atlas1.atlas");
assetManager.loadJson(DEMO_NAME, "demos.json"); assetManager.loadJson(DEMO_NAME, "demos.json");
input = new spine.webgl.Input(canvas); input = new spine.webgl.Input(canvas);
timeKeeper = new spine.TimeKeeper(); timeKeeper = new spine.TimeKeeper();
loadingScreen = new spine.webgl.LoadingScreen(renderer); loadingScreen = new spine.webgl.LoadingScreen(renderer);
requestAnimationFrame(load); requestAnimationFrame(load);
} }
@ -38,7 +38,7 @@ var hoverboardDemo = function(loadingComplete, bgColor) {
timeKeeper.update(); timeKeeper.update();
if (assetManager.isLoadingComplete(DEMO_NAME)) { if (assetManager.isLoadingComplete(DEMO_NAME)) {
var atlas = new spine.TextureAtlas(assetManager.get(DEMO_NAME, "atlas1.atlas"), function(path) { var atlas = new spine.TextureAtlas(assetManager.get(DEMO_NAME, "atlas1.atlas"), function(path) {
return assetManager.get(DEMO_NAME, path); return assetManager.get(DEMO_NAME, path);
}); });
var atlasLoader = new spine.AtlasAttachmentLoader(atlas); var atlasLoader = new spine.AtlasAttachmentLoader(atlas);
var skeletonJson = new spine.SkeletonJson(atlasLoader); var skeletonJson = new spine.SkeletonJson(atlasLoader);
@ -51,7 +51,7 @@ var hoverboardDemo = function(loadingComplete, bgColor) {
var offset = new spine.Vector2(); var offset = new spine.Vector2();
bounds = new spine.Vector2(); bounds = new spine.Vector2();
skeleton.getBounds(offset, bounds); skeleton.getBounds(offset, bounds);
for (var i = 0; i < controlBones.length; i++) hoverTargets.push(null); for (var i = 0; i < controlBones.length; i++) hoverTargets.push(null);
renderer.camera.position.x = offset.x + bounds.x / 2; renderer.camera.position.x = offset.x + bounds.x / 2;
renderer.camera.position.y = offset.y + bounds.y / 2; renderer.camera.position.y = offset.y + bounds.y / 2;
@ -69,14 +69,14 @@ var hoverboardDemo = function(loadingComplete, bgColor) {
} }
} }
function setupUI() { function setupUI() {
var checkbox = $("#hoverboard-drawbones"); var checkbox = $("#hoverboard-drawbones");
renderer.skeletonDebugRenderer.drawRegionAttachments = false; renderer.skeletonDebugRenderer.drawRegionAttachments = false;
renderer.skeletonDebugRenderer.drawPaths = false; renderer.skeletonDebugRenderer.drawPaths = false;
renderer.skeletonDebugRenderer.drawBones = false; renderer.skeletonDebugRenderer.drawBones = false;
checkbox.change(function() { checkbox.change(function() {
renderer.skeletonDebugRenderer.drawPaths = this.checked; renderer.skeletonDebugRenderer.drawPaths = this.checked;
renderer.skeletonDebugRenderer.drawBones = this.checked; renderer.skeletonDebugRenderer.drawBones = this.checked;
}); });
} }
@ -84,12 +84,12 @@ var hoverboardDemo = function(loadingComplete, bgColor) {
input.addListener({ input.addListener({
down: function(x, y) { down: function(x, y) {
isPlaying = false; isPlaying = false;
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;
} }
} }
}, },
up: function(x, y) { up: function(x, y) {
@ -99,35 +99,35 @@ 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;
} }
} }
}, },
moved: function (x, y) { moved: function (x, y) {
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;
} }
} }
} }
}); });
} }
function render () { function render () {
timeKeeper.update(); timeKeeper.update();
var delta = timeKeeper.delta; var delta = timeKeeper.delta;
state.update(delta); state.update(delta);
state.apply(skeleton); state.apply(skeleton);
skeleton.updateWorldTransform(); skeleton.updateWorldTransform();
renderer.camera.viewportWidth = bounds.x * 1.2; renderer.camera.viewportWidth = bounds.x * 1.2;
@ -135,18 +135,18 @@ var hoverboardDemo = function(loadingComplete, bgColor) {
renderer.resize(spine.webgl.ResizeMode.Fit); renderer.resize(spine.webgl.ResizeMode.Fit);
gl.clearColor(bgColor.r, bgColor.g, bgColor.b, bgColor.a); gl.clearColor(bgColor.r, bgColor.g, bgColor.b, bgColor.a);
gl.clear(gl.COLOR_BUFFER_BIT); gl.clear(gl.COLOR_BUFFER_BIT);
renderer.begin(); renderer.begin();
renderer.drawSkeleton(skeleton, true); renderer.drawSkeleton(skeleton, true);
renderer.drawSkeletonDebug(skeleton, false, ["root"]); renderer.drawSkeletonDebug(skeleton, false, ["root"]);
gl.lineWidth(2); gl.lineWidth(2);
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]);
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);

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

@ -5,7 +5,7 @@ var spritesheetsDemo = function(loadingComplete, bgColor) {
var canvas, gl, renderer, input, assetManager; var canvas, gl, renderer, input, assetManager;
var skeleton, animationState, offset, bounds; var skeleton, animationState, offset, bounds;
var skeletonSeq, walkAnim, walkLastTime = 0, walkLastTimePrecise = 0; var skeletonSeq, walkAnim, walkLastTime = 0, walkLastTimePrecise = 0;
var skeletonAtlas; var skeletonAtlas;
var viewportWidth, viewportHeight; var viewportWidth, viewportHeight;
var frames = [], currFrame = 0, frameTime = 0, frameScale = 0, FPS = 30; var frames = [], currFrame = 0, frameTime = 0, frameScale = 0, FPS = 30;
var timeKeeper, loadingScreen, input; var timeKeeper, loadingScreen, input;
@ -17,17 +17,17 @@ var spritesheetsDemo = function(loadingComplete, bgColor) {
function init () { function init () {
canvas = document.getElementById("spritesheets-canvas"); canvas = document.getElementById("spritesheets-canvas");
canvas.width = canvas.clientWidth; canvas.height = canvas.clientHeight; canvas.width = canvas.clientWidth; canvas.height = canvas.clientHeight;
gl = canvas.getContext("webgl", { alpha: false }) || canvas.getContext("experimental-webgl", { alpha: false }); gl = canvas.getContext("webgl", { alpha: false }) || canvas.getContext("experimental-webgl", { alpha: false });
renderer = new spine.webgl.SceneRenderer(canvas, gl); renderer = new spine.webgl.SceneRenderer(canvas, gl);
assetManager = spineDemos.assetManager; assetManager = spineDemos.assetManager;
var textureLoader = function(img) { return new spine.webgl.GLTexture(gl, img); }; var textureLoader = function(img) { return new spine.webgl.GLTexture(gl, img); };
assetManager.loadTexture(DEMO_NAME, textureLoader, "atlas1.png"); assetManager.loadTexture(DEMO_NAME, textureLoader, "atlas1.png");
assetManager.loadText(DEMO_NAME, "atlas1.atlas"); assetManager.loadText(DEMO_NAME, "atlas1.atlas");
assetManager.loadJson(DEMO_NAME, "demos.json"); assetManager.loadJson(DEMO_NAME, "demos.json");
timeKeeper = new spine.TimeKeeper(); timeKeeper = new spine.TimeKeeper();
input = new spine.webgl.Input(canvas); input = new spine.webgl.Input(canvas);
loadingScreen = new spine.webgl.LoadingScreen(renderer); loadingScreen = new spine.webgl.LoadingScreen(renderer);
requestAnimationFrame(load); requestAnimationFrame(load);
} }
@ -36,8 +36,8 @@ var spritesheetsDemo = function(loadingComplete, bgColor) {
timeKeeper.update(); timeKeeper.update();
if (assetManager.isLoadingComplete(DEMO_NAME)) { if (assetManager.isLoadingComplete(DEMO_NAME)) {
skeletonAtlas = new spine.TextureAtlas(assetManager.get(DEMO_NAME, "atlas1.atlas"), function(path) { skeletonAtlas = new spine.TextureAtlas(assetManager.get(DEMO_NAME, "atlas1.atlas"), function(path) {
return assetManager.get(DEMO_NAME, path); return assetManager.get(DEMO_NAME, path);
}); });
var atlasLoader = new spine.AtlasAttachmentLoader(skeletonAtlas); var atlasLoader = new spine.AtlasAttachmentLoader(skeletonAtlas);
var skeletonJson = new spine.SkeletonJson(atlasLoader); var skeletonJson = new spine.SkeletonJson(atlasLoader);
var skeletonData = skeletonJson.readSkeletonData(assetManager.get(DEMO_NAME, "demos.json").raptor); var skeletonData = skeletonJson.readSkeletonData(assetManager.get(DEMO_NAME, "demos.json").raptor);
@ -55,9 +55,9 @@ 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);
viewportHeight = ((0 + bounds.y) - offset.y); viewportHeight = ((0 + bounds.y) - offset.y);
resize(); resize();
@ -71,7 +71,7 @@ var spritesheetsDemo = function(loadingComplete, bgColor) {
loadingScreen.draw(); loadingScreen.draw();
requestAnimationFrame(load); requestAnimationFrame(load);
} }
} }
function setupUI () { function setupUI () {
timeSlider = $("#spritesheets-timeslider").data("slider"); timeSlider = $("#spritesheets-timeslider").data("slider");
@ -95,7 +95,7 @@ var spritesheetsDemo = function(loadingComplete, bgColor) {
setAnimation("jump"); setAnimation("jump");
}); });
} }
function setAnimation (name) { function setAnimation (name) {
animationState.setAnimation(0, name, false); animationState.setAnimation(0, name, false);
animationState.addAnimation(0, "walk", true, 0); animationState.addAnimation(0, "walk", true, 0);
@ -103,7 +103,7 @@ var spritesheetsDemo = function(loadingComplete, bgColor) {
function resize () { function resize () {
renderer.camera.position.x = offset.x + viewportWidth / 2 - 25; renderer.camera.position.x = offset.x + viewportWidth / 2 - 25;
renderer.camera.position.y = offset.y + viewportHeight / 2 - 160; renderer.camera.position.y = offset.y + viewportHeight / 2 - 160;
renderer.camera.viewportWidth = viewportWidth * 1.2; renderer.camera.viewportWidth = viewportWidth * 1.2;
renderer.camera.viewportHeight = viewportHeight * 1.2; renderer.camera.viewportHeight = viewportHeight * 1.2;
renderer.resize(spine.webgl.ResizeMode.Fit); renderer.resize(spine.webgl.ResizeMode.Fit);
@ -120,21 +120,21 @@ var spritesheetsDemo = function(loadingComplete, bgColor) {
var oldValue = timeSliderLabel.textContent; var oldValue = timeSliderLabel.textContent;
var newValue = Math.round(timeSlider.get() * 100) + "%"; var newValue = Math.round(timeSlider.get() * 100) + "%";
if (oldValue !== newValue) timeSliderLabel.textContent = newValue; if (oldValue !== newValue) timeSliderLabel.textContent = newValue;
} }
var animationDuration = animationState.getCurrent(0).animation.duration; var animationDuration = animationState.getCurrent(0).animation.duration;
playTime += delta; playTime += delta;
while (playTime >= animationDuration) { while (playTime >= animationDuration) {
playTime -= animationDuration; playTime -= animationDuration;
} }
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();
animationState.update(delta); animationState.update(delta);
var current = animationState.getCurrent(0); var current = animationState.getCurrent(0);
@ -143,12 +143,12 @@ var spritesheetsDemo = function(loadingComplete, bgColor) {
skeleton.updateWorldTransform(); skeleton.updateWorldTransform();
gl.clearColor(bgColor.r, bgColor.g, bgColor.b, bgColor.a); gl.clearColor(bgColor.r, bgColor.g, bgColor.b, bgColor.a);
gl.clear(gl.COLOR_BUFFER_BIT); gl.clear(gl.COLOR_BUFFER_BIT);
renderer.begin(); renderer.begin();
var frame = frames[currFrame]; var frame = frames[currFrame];
renderer.drawSkeleton(skeleton, true); renderer.drawSkeleton(skeleton, true);
renderer.drawSkeleton(skeletonSeq, true); renderer.drawSkeleton(skeletonSeq, true);
renderer.end(); renderer.end();
loadingScreen.draw(true); loadingScreen.draw(true);

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

@ -38,8 +38,8 @@ function init () {
canvas.width = window.innerWidth; canvas.width = window.innerWidth;
canvas.height = window.innerHeight; canvas.height = window.innerHeight;
var config = { alpha: false }; var config = { alpha: false };
gl = canvas.getContext("webgl", config) || canvas.getContext("experimental-webgl", config); gl = canvas.getContext("webgl", config) || canvas.getContext("experimental-webgl", config);
// Create a simple shader, mesh, model-view-projection matrix and SkeletonRenderer. // Create a simple shader, mesh, model-view-projection matrix and SkeletonRenderer.
shader = spine.webgl.Shader.newColoredTextured(gl); shader = spine.webgl.Shader.newColoredTextured(gl);
batcher = new spine.webgl.PolygonBatcher(gl); batcher = new spine.webgl.PolygonBatcher(gl);
@ -71,7 +71,7 @@ function init () {
assetManager.loadTexture("assets/goblins.png"); assetManager.loadTexture("assets/goblins.png");
assetManager.loadText("assets/vine.json"); assetManager.loadText("assets/vine.json");
assetManager.loadText("assets/vine.atlas"); assetManager.loadText("assets/vine.atlas");
assetManager.loadTexture("assets/vine.png"); assetManager.loadTexture("assets/vine.png");
assetManager.loadText("assets/stretchyman.json"); assetManager.loadText("assets/stretchyman.json");
assetManager.loadText("assets/stretchyman.atlas"); assetManager.loadText("assets/stretchyman.atlas");
assetManager.loadTexture("assets/stretchyman.png"); assetManager.loadTexture("assets/stretchyman.png");
@ -82,11 +82,11 @@ function load () {
// Wait until the AssetManager has loaded all resources, then load the skeletons. // Wait until the AssetManager has loaded all resources, then load the skeletons.
if (assetManager.isLoadingComplete()) { if (assetManager.isLoadingComplete()) {
skeletons["raptor"] = loadSkeleton("raptor", "walk", false); skeletons["raptor"] = loadSkeleton("raptor", "walk", false);
skeletons["spineboy"] = loadSkeleton("spineboy", "run", false); skeletons["spineboy"] = loadSkeleton("spineboy", "run", false);
skeletons["tank"] = loadSkeleton("tank", "drive", false); skeletons["tank"] = loadSkeleton("tank", "drive", false);
skeletons["goblins"] = loadSkeleton("goblins-mesh", "walk", false, "goblin"); skeletons["goblins"] = loadSkeleton("goblins-mesh", "walk", false, "goblin");
skeletons["vine"] = loadSkeleton("vine", "animation", false); skeletons["vine"] = loadSkeleton("vine", "animation", false);
skeletons["stretchyman"] = loadSkeleton("stretchyman", "sneak", false); skeletons["stretchyman"] = loadSkeleton("stretchyman", "sneak", false);
setupUI(); setupUI();
requestAnimationFrame(render); requestAnimationFrame(render);
} else { } else {
@ -100,7 +100,7 @@ function loadSkeleton (name, initialAnimation, premultipliedAlpha, skin) {
// Load the texture atlas using name.atlas and name.png from the AssetManager. // Load the texture atlas using name.atlas and name.png from the AssetManager.
// The function passed to TextureAtlas is used to resolve relative paths. // The function passed to TextureAtlas is used to resolve relative paths.
atlas = new spine.TextureAtlas(assetManager.get("assets/" + name + ".atlas"), function(path) { atlas = new spine.TextureAtlas(assetManager.get("assets/" + name + ".atlas"), function(path) {
return assetManager.get("assets/" + path); return assetManager.get("assets/" + path);
}); });
// Create a AtlasAttachmentLoader that resolves region, mesh, boundingbox and path attachments // Create a AtlasAttachmentLoader that resolves region, mesh, boundingbox and path attachments
@ -108,28 +108,34 @@ function loadSkeleton (name, initialAnimation, premultipliedAlpha, skin) {
// Create a SkeletonJson instance for parsing the .json file. // Create a SkeletonJson instance for parsing the .json file.
var skeletonJson = new spine.SkeletonJson(atlasLoader); var skeletonJson = new spine.SkeletonJson(atlasLoader);
// Set the scale to apply during parsing, parse the file, and create a new skeleton. // Set the scale to apply during parsing, parse the file, and create a new skeleton.
var skeletonData = skeletonJson.readSkeletonData(assetManager.get("assets/" + name + ".json")); var skeletonData = skeletonJson.readSkeletonData(assetManager.get("assets/" + name + ".json"));
var skeleton = new spine.Skeleton(skeletonData); var skeleton = new spine.Skeleton(skeletonData);
skeleton.setSkinByName(skin); skeleton.setSkinByName(skin);
var bounds = calculateBounds(skeleton); var bounds = calculateBounds(skeleton);
// Create an AnimationState, and set the initial animation in looping mode. // Create an AnimationState, and set the initial animation in looping mode.
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));
} }
}) })
@ -137,7 +143,7 @@ function loadSkeleton (name, initialAnimation, premultipliedAlpha, skin) {
return { skeleton: skeleton, state: animationState, bounds: bounds, premultipliedAlpha: premultipliedAlpha }; return { skeleton: skeleton, state: animationState, bounds: bounds, premultipliedAlpha: premultipliedAlpha };
} }
function calculateBounds(skeleton) { function calculateBounds(skeleton) {
skeleton.setToSetupPose(); skeleton.setToSetupPose();
skeleton.updateWorldTransform(); skeleton.updateWorldTransform();
var offset = new spine.Vector2(); var offset = new spine.Vector2();
@ -173,7 +179,7 @@ function setupUI () {
var skeleton = skeletons[activeSkeleton].skeleton; var skeleton = skeletons[activeSkeleton].skeleton;
var animationName = $("#animationList option:selected").text(); var animationName = $("#animationList option:selected").text();
skeleton.setToSetupPose(); skeleton.setToSetupPose();
state.setAnimation(0, animationName, true); state.setAnimation(0, animationName, true);
}) })
} }
@ -190,7 +196,7 @@ function setupUI () {
skinList.append(option); skinList.append(option);
} }
skinList.change(function() { skinList.change(function() {
var skeleton = skeletons[activeSkeleton].skeleton; var skeleton = skeletons[activeSkeleton].skeleton;
var skinName = $("#skinList option:selected").text(); var skinName = $("#skinList option:selected").text();
skeleton.setSkinByName(skinName); skeleton.setSkinByName(skinName);
@ -236,7 +242,7 @@ function render () {
skeletonRenderer.premultipliedAlpha = premultipliedAlpha; skeletonRenderer.premultipliedAlpha = premultipliedAlpha;
skeletonRenderer.draw(batcher, skeleton); skeletonRenderer.draw(batcher, skeleton);
batcher.end(); batcher.end();
shader.unbind(); shader.unbind();
// draw debug information // draw debug information