UnityMirror/spine-runtimes
1
0
Fork 0
mirror of https://github.com/EsotericSoftware/spine-runtimes.git synced 2026-02-04 14:24:53 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/dev' into dev

Browse Source
This commit is contained in:
NathanSweet 2016-10-25 01:51:29 +02:00
commit 1c801a45fc
24 changed files with 364 additions and 322 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

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

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

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

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

File diff suppressed because one or more lines are too long

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

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

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

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

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

File diff suppressed because one or more lines are too long

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

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

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

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

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

File diff suppressed because one or more lines are too long

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

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

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

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

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

File diff suppressed because one or more lines are too long

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

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

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

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

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

File diff suppressed because one or more lines are too long

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

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

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

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

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

File diff suppressed because one or more lines are too long

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

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

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

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

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 canvas, gl, renderer, input, assetManager;
var skeleton, state, bounds;
var skeleton, state, bounds;
var timeKeeper, loadingScreen;
var target = null;
var target = null;
var hoverTargets = [];
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 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 () {
canvas = document.getElementById("hoverboard-canvas");
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);
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.loadText(DEMO_NAME, "atlas1.atlas");
assetManager.loadJson(DEMO_NAME, "demos.json");
assetManager.loadJson(DEMO_NAME, "demos.json");
input = new spine.webgl.Input(canvas);
timeKeeper = new spine.TimeKeeper();
timeKeeper = new spine.TimeKeeper();
loadingScreen = new spine.webgl.LoadingScreen(renderer);
requestAnimationFrame(load);
}
@ -38,7 +38,7 @@ var hoverboardDemo = function(loadingComplete, bgColor) {
timeKeeper.update();
if (assetManager.isLoadingComplete(DEMO_NAME)) {
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 skeletonJson = new spine.SkeletonJson(atlasLoader);
@ -51,7 +51,7 @@ var hoverboardDemo = function(loadingComplete, bgColor) {
var offset = new spine.Vector2();
bounds = new spine.Vector2();
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.y = offset.y + bounds.y / 2;
@ -69,14 +69,14 @@ var hoverboardDemo = function(loadingComplete, bgColor) {
}
}
function setupUI() {
function setupUI() {
var checkbox = $("#hoverboard-drawbones");
renderer.skeletonDebugRenderer.drawRegionAttachments = false;
renderer.skeletonDebugRenderer.drawPaths = false;
renderer.skeletonDebugRenderer.drawBones = false;
checkbox.change(function() {
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({
down: function(x, y) {
isPlaying = false;
for (var i = 0; i < controlBones.length; i++) {
var bone = skeleton.findBone(controlBones[i]);
renderer.camera.screenToWorld(coords.set(x, y, 0), canvas.width, canvas.height);
if (temp.set(skeleton.x + bone.worldX, skeleton.y + bone.worldY, 0).distance(coords) < 30) {
for (var i = 0; i < controlBones.length; i++) {
var bone = skeleton.findBone(controlBones[i]);
renderer.camera.screenToWorld(coords.set(x, y, 0), canvas.width, canvas.height);
if (temp.set(bone.worldX, bone.worldY, 0).distance(coords) < 30) {
target = bone;
}
}
}
},
up: function(x, y) {
@ -99,35 +99,35 @@ var hoverboardDemo = function(loadingComplete, bgColor) {
if (target != null) {
renderer.camera.screenToWorld(coords.set(x, y, 0), canvas.width, canvas.height);
if (target.parent !== null) {
target.parent.worldToLocal(temp2.set(coords.x - skeleton.x, coords.y - skeleton.y));
target.parent.worldToLocal(temp2.set(coords.x, coords.y));
target.x = temp2.x;
target.y = temp2.y;
} else {
target.x = coords.x - skeleton.x;
target.y = coords.y - skeleton.y;
target.x = coords.x;
target.y = coords.y;
}
}
},
moved: function (x, y) {
for (var i = 0; i < controlBones.length; i++) {
var bone = skeleton.findBone(controlBones[i]);
renderer.camera.screenToWorld(coords.set(x, y, 0), canvas.width, canvas.height);
if (temp.set(skeleton.x + bone.worldX, skeleton.y + bone.worldY, 0).distance(coords) < 30) {
moved: function (x, y) {
for (var i = 0; i < controlBones.length; i++) {
var bone = skeleton.findBone(controlBones[i]);
renderer.camera.screenToWorld(coords.set(x, y, 0), canvas.width, canvas.height);
if (temp.set(bone.worldX, bone.worldY, 0).distance(coords) < 30) {
hoverTargets[i] = bone;
} else {
hoverTargets[i] = null;
}
}
}
}
});
}
function render () {
timeKeeper.update();
var delta = timeKeeper.delta;
var delta = timeKeeper.delta;
state.update(delta);
state.apply(skeleton);
state.apply(skeleton);
skeleton.updateWorldTransform();
renderer.camera.viewportWidth = bounds.x * 1.2;
@ -135,18 +135,18 @@ var hoverboardDemo = function(loadingComplete, bgColor) {
renderer.resize(spine.webgl.ResizeMode.Fit);
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.drawSkeletonDebug(skeleton, false, ["root"]);
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 colorInner = hoverTargets[i] !== null ? spineDemos.HOVER_COLOR_INNER : spineDemos.NON_HOVER_COLOR_INNER;
var colorOuter = hoverTargets[i] !== null ? spineDemos.HOVER_COLOR_OUTER : spineDemos.NON_HOVER_COLOR_OUTER;
renderer.circle(true, skeleton.x + bone.worldX, skeleton.y + bone.worldY, 20, colorInner);
renderer.circle(false, skeleton.x + bone.worldX, skeleton.y + bone.worldY, 20, colorOuter);
renderer.circle(true, bone.worldX, bone.worldY, 20, colorInner);
renderer.circle(false, bone.worldX, bone.worldY, 20, colorOuter);
}
renderer.end();
gl.lineWidth(1);

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

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

@ -38,8 +38,8 @@ function init () {
canvas.width = window.innerWidth;
canvas.height = window.innerHeight;
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.
shader = spine.webgl.Shader.newColoredTextured(gl);
batcher = new spine.webgl.PolygonBatcher(gl);
@ -71,7 +71,7 @@ function init () {
assetManager.loadTexture("assets/goblins.png");
assetManager.loadText("assets/vine.json");
assetManager.loadText("assets/vine.atlas");
assetManager.loadTexture("assets/vine.png");
assetManager.loadTexture("assets/vine.png");
assetManager.loadText("assets/stretchyman.json");
assetManager.loadText("assets/stretchyman.atlas");
assetManager.loadTexture("assets/stretchyman.png");
@ -82,11 +82,11 @@ function load () {
// Wait until the AssetManager has loaded all resources, then load the skeletons.
if (assetManager.isLoadingComplete()) {
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["goblins"] = loadSkeleton("goblins-mesh", "walk", false, "goblin");
skeletons["vine"] = loadSkeleton("vine", "animation", false);
skeletons["stretchyman"] = loadSkeleton("stretchyman", "sneak", false);
skeletons["stretchyman"] = loadSkeleton("stretchyman", "sneak", false);
setupUI();
requestAnimationFrame(render);
} else {
@ -100,7 +100,7 @@ function loadSkeleton (name, initialAnimation, premultipliedAlpha, skin) {
// Load the texture atlas using name.atlas and name.png from the AssetManager.
// The function passed to TextureAtlas is used to resolve relative paths.
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
@ -108,28 +108,34 @@ function loadSkeleton (name, initialAnimation, premultipliedAlpha, skin) {
// Create a SkeletonJson instance for parsing the .json file.
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 skeleton = new spine.Skeleton(skeletonData);
skeleton.setSkinByName(skin);
var bounds = calculateBounds(skeleton);
var bounds = calculateBounds(skeleton);
// Create an AnimationState, and set the initial animation in looping mode.
var animationState = new spine.AnimationState(new spine.AnimationStateData(skeleton.data));
animationState.setAnimation(0, initialAnimation, true);
animationState.addListener({
event: function(trackIndex, event) {
// console.log("Event on track " + trackIndex + ": " + JSON.stringify(event));
start: function(track) {
console.log("Animation on track " + track.trackIndex + " started");
},
complete: function(trackIndex, loopCount) {
// console.log("Animation on track " + trackIndex + " completed, loop count: " + loopCount);
interrupt: function(track) {
console.log("Animation on track " + track.trackIndex + " interrupted");
},
start: function(trackIndex) {
// console.log("Animation on track " + trackIndex + " started");
end: function(track) {
console.log("Animation on track " + track.trackIndex + " ended");
},
end: function(trackIndex) {
// console.log("Animation on track " + trackIndex + " ended");
disposed: function(track) {
console.log("Animation on track " + track.trackIndex + " disposed");
},
complete: function(track) {
console.log("Animation on track " + track.trackIndex + " completed");
},
event: function(track, event) {
console.log("Event on track " + track.trackIndex + ": " + JSON.stringify(event));
}
})
@ -137,7 +143,7 @@ function loadSkeleton (name, initialAnimation, premultipliedAlpha, skin) {
return { skeleton: skeleton, state: animationState, bounds: bounds, premultipliedAlpha: premultipliedAlpha };
}
function calculateBounds(skeleton) {
function calculateBounds(skeleton) {
skeleton.setToSetupPose();
skeleton.updateWorldTransform();
var offset = new spine.Vector2();
@ -173,7 +179,7 @@ function setupUI () {
var skeleton = skeletons[activeSkeleton].skeleton;
var animationName = $("#animationList option:selected").text();
skeleton.setToSetupPose();
state.setAnimation(0, animationName, true);
state.setAnimation(0, animationName, true);
})
}
@ -190,7 +196,7 @@ function setupUI () {
skinList.append(option);
}
skinList.change(function() {
skinList.change(function() {
var skeleton = skeletons[activeSkeleton].skeleton;
var skinName = $("#skinList option:selected").text();
skeleton.setSkinByName(skinName);
@ -236,7 +242,7 @@ function render () {
skeletonRenderer.premultipliedAlpha = premultipliedAlpha;
skeletonRenderer.draw(batcher, skeleton);
batcher.end();
shader.unbind();
// draw debug information

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

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