mirror of
https://github.com/EsotericSoftware/spine-runtimes.git
synced 2025-12-22 02:06:03 +08:00
[ts] Ported latest AnimationState and Animation changes. See #1303.
This commit is contained in:
badlogic
parent
646d0e3106
commit
eecc0467b6
6
spine-ts/build/spine-all.d.ts
vendored
6
spine-ts/build/spine-all.d.ts
vendored
@ -246,6 +246,7 @@ declare module spine {
|
||||
static FIRST: number;
|
||||
static HOLD: number;
|
||||
static HOLD_MIX: number;
|
||||
static NOT_LAST: number;
|
||||
data: AnimationStateData;
|
||||
tracks: TrackEntry[];
|
||||
events: Event[];
|
||||
@ -276,7 +277,8 @@ declare module spine {
|
||||
trackEntry(trackIndex: number, animation: Animation, loop: boolean, last: TrackEntry): TrackEntry;
|
||||
disposeNext(entry: TrackEntry): void;
|
||||
_animationsChanged(): void;
|
||||
setTimelineModes(entry: TrackEntry): void;
|
||||
computeHold(entry: TrackEntry): void;
|
||||
computeNotLast(entry: TrackEntry): void;
|
||||
hasTimeline(entry: TrackEntry, id: number): boolean;
|
||||
getCurrent(trackIndex: number): TrackEntry;
|
||||
addListener(listener: AnimationStateListener2): void;
|
||||
@ -784,7 +786,7 @@ declare module spine {
|
||||
darkColor: Color;
|
||||
private attachment;
|
||||
private attachmentTime;
|
||||
attachmentVertices: number[];
|
||||
deform: number[];
|
||||
constructor(data: SlotData, bone: Bone);
|
||||
getAttachment(): Attachment;
|
||||
setAttachment(attachment: Attachment): void;
|
||||
|
||||
@ -700,8 +700,8 @@ var spine;
|
||||
var slotAttachment = slot.getAttachment();
|
||||
if (!(slotAttachment instanceof spine.VertexAttachment) || !slotAttachment.applyDeform(this.attachment))
|
||||
return;
|
||||
var verticesArray = slot.attachmentVertices;
|
||||
if (verticesArray.length == 0)
|
||||
var deformArray = slot.deform;
|
||||
if (deformArray.length == 0)
|
||||
blend = MixBlend.setup;
|
||||
var frameVertices = this.frameVertices;
|
||||
var vertexCount = frameVertices[0].length;
|
||||
@ -710,28 +710,28 @@ var spine;
|
||||
var vertexAttachment = slotAttachment;
|
||||
switch (blend) {
|
||||
case MixBlend.setup:
|
||||
verticesArray.length = 0;
|
||||
deformArray.length = 0;
|
||||
return;
|
||||
case MixBlend.first:
|
||||
if (alpha == 1) {
|
||||
verticesArray.length = 0;
|
||||
deformArray.length = 0;
|
||||
break;
|
||||
}
|
||||
var vertices_1 = spine.Utils.setArraySize(verticesArray, vertexCount);
|
||||
var deform_1 = spine.Utils.setArraySize(deformArray, vertexCount);
|
||||
if (vertexAttachment.bones == null) {
|
||||
var setupVertices = vertexAttachment.vertices;
|
||||
for (var i = 0; i < vertexCount; i++)
|
||||
vertices_1[i] += (setupVertices[i] - vertices_1[i]) * alpha;
|
||||
deform_1[i] += (setupVertices[i] - deform_1[i]) * alpha;
|
||||
}
|
||||
else {
|
||||
alpha = 1 - alpha;
|
||||
for (var i = 0; i < vertexCount; i++)
|
||||
vertices_1[i] *= alpha;
|
||||
deform_1[i] *= alpha;
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
var vertices = spine.Utils.setArraySize(verticesArray, vertexCount);
|
||||
var deform = spine.Utils.setArraySize(deformArray, vertexCount);
|
||||
if (time >= frames[frames.length - 1]) {
|
||||
var lastVertices = frameVertices[frames.length - 1];
|
||||
if (alpha == 1) {
|
||||
@ -740,16 +740,16 @@ var spine;
|
||||
if (vertexAttachment.bones == null) {
|
||||
var setupVertices = vertexAttachment.vertices;
|
||||
for (var i_1 = 0; i_1 < vertexCount; i_1++) {
|
||||
vertices[i_1] += lastVertices[i_1] - setupVertices[i_1];
|
||||
deform[i_1] += lastVertices[i_1] - setupVertices[i_1];
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (var i_2 = 0; i_2 < vertexCount; i_2++)
|
||||
vertices[i_2] += lastVertices[i_2];
|
||||
deform[i_2] += lastVertices[i_2];
|
||||
}
|
||||
}
|
||||
else {
|
||||
spine.Utils.arrayCopy(lastVertices, 0, vertices, 0, vertexCount);
|
||||
spine.Utils.arrayCopy(lastVertices, 0, deform, 0, vertexCount);
|
||||
}
|
||||
}
|
||||
else {
|
||||
@ -760,30 +760,30 @@ var spine;
|
||||
var setupVertices = vertexAttachment_1.vertices;
|
||||
for (var i_3 = 0; i_3 < vertexCount; i_3++) {
|
||||
var setup = setupVertices[i_3];
|
||||
vertices[i_3] = setup + (lastVertices[i_3] - setup) * alpha;
|
||||
deform[i_3] = setup + (lastVertices[i_3] - setup) * alpha;
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (var i_4 = 0; i_4 < vertexCount; i_4++)
|
||||
vertices[i_4] = lastVertices[i_4] * alpha;
|
||||
deform[i_4] = lastVertices[i_4] * alpha;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case MixBlend.first:
|
||||
case MixBlend.replace:
|
||||
for (var i_5 = 0; i_5 < vertexCount; i_5++)
|
||||
vertices[i_5] += (lastVertices[i_5] - vertices[i_5]) * alpha;
|
||||
deform[i_5] += (lastVertices[i_5] - deform[i_5]) * alpha;
|
||||
case MixBlend.add:
|
||||
var vertexAttachment = slotAttachment;
|
||||
if (vertexAttachment.bones == null) {
|
||||
var setupVertices = vertexAttachment.vertices;
|
||||
for (var i_6 = 0; i_6 < vertexCount; i_6++) {
|
||||
vertices[i_6] += (lastVertices[i_6] - setupVertices[i_6]) * alpha;
|
||||
deform[i_6] += (lastVertices[i_6] - setupVertices[i_6]) * alpha;
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (var i_7 = 0; i_7 < vertexCount; i_7++)
|
||||
vertices[i_7] += lastVertices[i_7] * alpha;
|
||||
deform[i_7] += lastVertices[i_7] * alpha;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -801,20 +801,20 @@ var spine;
|
||||
var setupVertices = vertexAttachment.vertices;
|
||||
for (var i_8 = 0; i_8 < vertexCount; i_8++) {
|
||||
var prev = prevVertices[i_8];
|
||||
vertices[i_8] += prev + (nextVertices[i_8] - prev) * percent - setupVertices[i_8];
|
||||
deform[i_8] += prev + (nextVertices[i_8] - prev) * percent - setupVertices[i_8];
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (var i_9 = 0; i_9 < vertexCount; i_9++) {
|
||||
var prev = prevVertices[i_9];
|
||||
vertices[i_9] += prev + (nextVertices[i_9] - prev) * percent;
|
||||
deform[i_9] += prev + (nextVertices[i_9] - prev) * percent;
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (var i_10 = 0; i_10 < vertexCount; i_10++) {
|
||||
var prev = prevVertices[i_10];
|
||||
vertices[i_10] = prev + (nextVertices[i_10] - prev) * percent;
|
||||
deform[i_10] = prev + (nextVertices[i_10] - prev) * percent;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -826,13 +826,13 @@ var spine;
|
||||
var setupVertices = vertexAttachment_2.vertices;
|
||||
for (var i_11 = 0; i_11 < vertexCount; i_11++) {
|
||||
var prev = prevVertices[i_11], setup = setupVertices[i_11];
|
||||
vertices[i_11] = setup + (prev + (nextVertices[i_11] - prev) * percent - setup) * alpha;
|
||||
deform[i_11] = setup + (prev + (nextVertices[i_11] - prev) * percent - setup) * alpha;
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (var i_12 = 0; i_12 < vertexCount; i_12++) {
|
||||
var prev = prevVertices[i_12];
|
||||
vertices[i_12] = (prev + (nextVertices[i_12] - prev) * percent) * alpha;
|
||||
deform[i_12] = (prev + (nextVertices[i_12] - prev) * percent) * alpha;
|
||||
}
|
||||
}
|
||||
break;
|
||||
@ -841,7 +841,7 @@ var spine;
|
||||
case MixBlend.replace:
|
||||
for (var i_13 = 0; i_13 < vertexCount; i_13++) {
|
||||
var prev = prevVertices[i_13];
|
||||
vertices[i_13] += (prev + (nextVertices[i_13] - prev) * percent - vertices[i_13]) * alpha;
|
||||
deform[i_13] += (prev + (nextVertices[i_13] - prev) * percent - deform[i_13]) * alpha;
|
||||
}
|
||||
break;
|
||||
case MixBlend.add:
|
||||
@ -850,13 +850,13 @@ var spine;
|
||||
var setupVertices = vertexAttachment.vertices;
|
||||
for (var i_14 = 0; i_14 < vertexCount; i_14++) {
|
||||
var prev = prevVertices[i_14];
|
||||
vertices[i_14] += (prev + (nextVertices[i_14] - prev) * percent - setupVertices[i_14]) * alpha;
|
||||
deform[i_14] += (prev + (nextVertices[i_14] - prev) * percent - setupVertices[i_14]) * alpha;
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (var i_15 = 0; i_15 < vertexCount; i_15++) {
|
||||
var prev = prevVertices[i_15];
|
||||
vertices[i_15] += (prev + (nextVertices[i_15] - prev) * percent) * alpha;
|
||||
deform[i_15] += (prev + (nextVertices[i_15] - prev) * percent) * alpha;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1415,7 +1415,7 @@ var spine;
|
||||
var timelinesRotation = current.timelinesRotation;
|
||||
for (var ii = 0; ii < timelineCount; ii++) {
|
||||
var timeline = timelines[ii];
|
||||
var timelineBlend = timelineMode[ii] == AnimationState.SUBSEQUENT ? blend : spine.MixBlend.setup;
|
||||
var timelineBlend = (timelineMode[ii] & (AnimationState.NOT_LAST - 1)) == AnimationState.SUBSEQUENT ? blend : spine.MixBlend.setup;
|
||||
if (timeline instanceof spine.RotateTimeline) {
|
||||
this.applyRotateTimeline(timeline, skeleton, animationTime, mix, timelineBlend, timelinesRotation, ii << 1, firstFrame);
|
||||
}
|
||||
@ -1473,7 +1473,7 @@ var spine;
|
||||
var direction = spine.MixDirection.out;
|
||||
var timelineBlend = void 0;
|
||||
var alpha = 0;
|
||||
switch (timelineMode[i]) {
|
||||
switch (timelineMode[i] & (AnimationState.NOT_LAST - 1)) {
|
||||
case AnimationState.SUBSEQUENT:
|
||||
if (!attachments && timeline instanceof spine.AttachmentTimeline)
|
||||
continue;
|
||||
@ -1503,12 +1503,12 @@ var spine;
|
||||
spine.Utils.webkit602BugfixHelper(alpha, blend);
|
||||
if (timelineBlend == spine.MixBlend.setup) {
|
||||
if (timeline instanceof spine.AttachmentTimeline) {
|
||||
if (attachments)
|
||||
direction = spine.MixDirection.out;
|
||||
if (attachments || (timelineMode[i] & AnimationState.NOT_LAST) == AnimationState.NOT_LAST)
|
||||
direction = spine.MixDirection["in"];
|
||||
}
|
||||
else if (timeline instanceof spine.DrawOrderTimeline) {
|
||||
if (drawOrder)
|
||||
direction = spine.MixDirection.out;
|
||||
direction = spine.MixDirection["in"];
|
||||
}
|
||||
}
|
||||
timeline.apply(skeleton, animationLast, animationTime, events, alpha, timelineBlend, direction);
|
||||
@ -1803,12 +1803,20 @@ var spine;
|
||||
entry = entry.mixingFrom;
|
||||
do {
|
||||
if (entry.mixingFrom == null || entry.mixBlend != spine.MixBlend.add)
|
||||
this.setTimelineModes(entry);
|
||||
this.computeHold(entry);
|
||||
entry = entry.mixingTo;
|
||||
} while (entry != null);
|
||||
}
|
||||
this.propertyIDs.clear();
|
||||
for (var i = this.tracks.length - 1; i >= 0; i--) {
|
||||
var entry = this.tracks[i];
|
||||
while (entry != null) {
|
||||
this.computeNotLast(entry);
|
||||
entry = entry.mixingFrom;
|
||||
}
|
||||
}
|
||||
};
|
||||
AnimationState.prototype.setTimelineModes = function (entry) {
|
||||
AnimationState.prototype.computeHold = function (entry) {
|
||||
var to = entry.mixingTo;
|
||||
var timelines = entry.animation.timelines;
|
||||
var timelinesCount = entry.animation.timelines.length;
|
||||
@ -1824,11 +1832,14 @@ var spine;
|
||||
return;
|
||||
}
|
||||
outer: for (var i = 0; i < timelinesCount; i++) {
|
||||
var id = timelines[i].getPropertyId();
|
||||
var timeline = timelines[i];
|
||||
var id = timeline.getPropertyId();
|
||||
if (!propertyIDs.add(id))
|
||||
timelineMode[i] = AnimationState.SUBSEQUENT;
|
||||
else if (to == null || !this.hasTimeline(to, id))
|
||||
else if (to == null || timeline instanceof spine.AttachmentTimeline || timeline instanceof spine.DrawOrderTimeline
|
||||
|| timeline instanceof spine.EventTimeline || !this.hasTimeline(to, id)) {
|
||||
timelineMode[i] = AnimationState.FIRST;
|
||||
}
|
||||
else {
|
||||
for (var next = to.mixingTo; next != null; next = next.mixingTo) {
|
||||
if (this.hasTimeline(next, id))
|
||||
@ -1844,6 +1855,19 @@ var spine;
|
||||
}
|
||||
}
|
||||
};
|
||||
AnimationState.prototype.computeNotLast = function (entry) {
|
||||
var timelines = entry.animation.timelines;
|
||||
var timelinesCount = entry.animation.timelines.length;
|
||||
var timelineMode = entry.timelineMode;
|
||||
var propertyIDs = this.propertyIDs;
|
||||
for (var i = 0; i < timelinesCount; i++) {
|
||||
if (timelines[i] instanceof spine.AttachmentTimeline) {
|
||||
var timeline = timelines[i];
|
||||
if (!propertyIDs.add(timeline.slotIndex))
|
||||
timelineMode[i] |= AnimationState.NOT_LAST;
|
||||
}
|
||||
}
|
||||
};
|
||||
AnimationState.prototype.hasTimeline = function (entry, id) {
|
||||
var timelines = entry.animation.timelines;
|
||||
for (var i = 0, n = timelines.length; i < n; i++)
|
||||
@ -1877,6 +1901,7 @@ var spine;
|
||||
AnimationState.FIRST = 1;
|
||||
AnimationState.HOLD = 2;
|
||||
AnimationState.HOLD_MIX = 3;
|
||||
AnimationState.NOT_LAST = 4;
|
||||
return AnimationState;
|
||||
}());
|
||||
spine.AnimationState = AnimationState;
|
||||
@ -5263,7 +5288,7 @@ var spine;
|
||||
(function (spine) {
|
||||
var Slot = (function () {
|
||||
function Slot(data, bone) {
|
||||
this.attachmentVertices = new Array();
|
||||
this.deform = new Array();
|
||||
if (data == null)
|
||||
throw new Error("data cannot be null.");
|
||||
if (bone == null)
|
||||
@ -5282,7 +5307,7 @@ var spine;
|
||||
return;
|
||||
this.attachment = attachment;
|
||||
this.attachmentTime = this.bone.skeleton.time;
|
||||
this.attachmentVertices.length = 0;
|
||||
this.deform.length = 0;
|
||||
};
|
||||
Slot.prototype.setAttachmentTime = function (time) {
|
||||
this.attachmentTime = this.bone.skeleton.time - time;
|
||||
@ -6437,7 +6462,7 @@ var spine;
|
||||
VertexAttachment.prototype.computeWorldVertices = function (slot, start, count, worldVertices, offset, stride) {
|
||||
count = offset + (count >> 1) * stride;
|
||||
var skeleton = slot.bone.skeleton;
|
||||
var deformArray = slot.attachmentVertices;
|
||||
var deformArray = slot.deform;
|
||||
var vertices = this.vertices;
|
||||
var bones = this.bones;
|
||||
if (bones == null) {
|
||||
|
||||
File diff suppressed because one or more lines are too long
6
spine-ts/build/spine-canvas.d.ts
vendored
6
spine-ts/build/spine-canvas.d.ts
vendored
@ -246,6 +246,7 @@ declare module spine {
|
||||
static FIRST: number;
|
||||
static HOLD: number;
|
||||
static HOLD_MIX: number;
|
||||
static NOT_LAST: number;
|
||||
data: AnimationStateData;
|
||||
tracks: TrackEntry[];
|
||||
events: Event[];
|
||||
@ -276,7 +277,8 @@ declare module spine {
|
||||
trackEntry(trackIndex: number, animation: Animation, loop: boolean, last: TrackEntry): TrackEntry;
|
||||
disposeNext(entry: TrackEntry): void;
|
||||
_animationsChanged(): void;
|
||||
setTimelineModes(entry: TrackEntry): void;
|
||||
computeHold(entry: TrackEntry): void;
|
||||
computeNotLast(entry: TrackEntry): void;
|
||||
hasTimeline(entry: TrackEntry, id: number): boolean;
|
||||
getCurrent(trackIndex: number): TrackEntry;
|
||||
addListener(listener: AnimationStateListener2): void;
|
||||
@ -784,7 +786,7 @@ declare module spine {
|
||||
darkColor: Color;
|
||||
private attachment;
|
||||
private attachmentTime;
|
||||
attachmentVertices: number[];
|
||||
deform: number[];
|
||||
constructor(data: SlotData, bone: Bone);
|
||||
getAttachment(): Attachment;
|
||||
setAttachment(attachment: Attachment): void;
|
||||
|
||||
@ -700,8 +700,8 @@ var spine;
|
||||
var slotAttachment = slot.getAttachment();
|
||||
if (!(slotAttachment instanceof spine.VertexAttachment) || !slotAttachment.applyDeform(this.attachment))
|
||||
return;
|
||||
var verticesArray = slot.attachmentVertices;
|
||||
if (verticesArray.length == 0)
|
||||
var deformArray = slot.deform;
|
||||
if (deformArray.length == 0)
|
||||
blend = MixBlend.setup;
|
||||
var frameVertices = this.frameVertices;
|
||||
var vertexCount = frameVertices[0].length;
|
||||
@ -710,28 +710,28 @@ var spine;
|
||||
var vertexAttachment = slotAttachment;
|
||||
switch (blend) {
|
||||
case MixBlend.setup:
|
||||
verticesArray.length = 0;
|
||||
deformArray.length = 0;
|
||||
return;
|
||||
case MixBlend.first:
|
||||
if (alpha == 1) {
|
||||
verticesArray.length = 0;
|
||||
deformArray.length = 0;
|
||||
break;
|
||||
}
|
||||
var vertices_1 = spine.Utils.setArraySize(verticesArray, vertexCount);
|
||||
var deform_1 = spine.Utils.setArraySize(deformArray, vertexCount);
|
||||
if (vertexAttachment.bones == null) {
|
||||
var setupVertices = vertexAttachment.vertices;
|
||||
for (var i = 0; i < vertexCount; i++)
|
||||
vertices_1[i] += (setupVertices[i] - vertices_1[i]) * alpha;
|
||||
deform_1[i] += (setupVertices[i] - deform_1[i]) * alpha;
|
||||
}
|
||||
else {
|
||||
alpha = 1 - alpha;
|
||||
for (var i = 0; i < vertexCount; i++)
|
||||
vertices_1[i] *= alpha;
|
||||
deform_1[i] *= alpha;
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
var vertices = spine.Utils.setArraySize(verticesArray, vertexCount);
|
||||
var deform = spine.Utils.setArraySize(deformArray, vertexCount);
|
||||
if (time >= frames[frames.length - 1]) {
|
||||
var lastVertices = frameVertices[frames.length - 1];
|
||||
if (alpha == 1) {
|
||||
@ -740,16 +740,16 @@ var spine;
|
||||
if (vertexAttachment.bones == null) {
|
||||
var setupVertices = vertexAttachment.vertices;
|
||||
for (var i_1 = 0; i_1 < vertexCount; i_1++) {
|
||||
vertices[i_1] += lastVertices[i_1] - setupVertices[i_1];
|
||||
deform[i_1] += lastVertices[i_1] - setupVertices[i_1];
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (var i_2 = 0; i_2 < vertexCount; i_2++)
|
||||
vertices[i_2] += lastVertices[i_2];
|
||||
deform[i_2] += lastVertices[i_2];
|
||||
}
|
||||
}
|
||||
else {
|
||||
spine.Utils.arrayCopy(lastVertices, 0, vertices, 0, vertexCount);
|
||||
spine.Utils.arrayCopy(lastVertices, 0, deform, 0, vertexCount);
|
||||
}
|
||||
}
|
||||
else {
|
||||
@ -760,30 +760,30 @@ var spine;
|
||||
var setupVertices = vertexAttachment_1.vertices;
|
||||
for (var i_3 = 0; i_3 < vertexCount; i_3++) {
|
||||
var setup = setupVertices[i_3];
|
||||
vertices[i_3] = setup + (lastVertices[i_3] - setup) * alpha;
|
||||
deform[i_3] = setup + (lastVertices[i_3] - setup) * alpha;
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (var i_4 = 0; i_4 < vertexCount; i_4++)
|
||||
vertices[i_4] = lastVertices[i_4] * alpha;
|
||||
deform[i_4] = lastVertices[i_4] * alpha;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case MixBlend.first:
|
||||
case MixBlend.replace:
|
||||
for (var i_5 = 0; i_5 < vertexCount; i_5++)
|
||||
vertices[i_5] += (lastVertices[i_5] - vertices[i_5]) * alpha;
|
||||
deform[i_5] += (lastVertices[i_5] - deform[i_5]) * alpha;
|
||||
case MixBlend.add:
|
||||
var vertexAttachment = slotAttachment;
|
||||
if (vertexAttachment.bones == null) {
|
||||
var setupVertices = vertexAttachment.vertices;
|
||||
for (var i_6 = 0; i_6 < vertexCount; i_6++) {
|
||||
vertices[i_6] += (lastVertices[i_6] - setupVertices[i_6]) * alpha;
|
||||
deform[i_6] += (lastVertices[i_6] - setupVertices[i_6]) * alpha;
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (var i_7 = 0; i_7 < vertexCount; i_7++)
|
||||
vertices[i_7] += lastVertices[i_7] * alpha;
|
||||
deform[i_7] += lastVertices[i_7] * alpha;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -801,20 +801,20 @@ var spine;
|
||||
var setupVertices = vertexAttachment.vertices;
|
||||
for (var i_8 = 0; i_8 < vertexCount; i_8++) {
|
||||
var prev = prevVertices[i_8];
|
||||
vertices[i_8] += prev + (nextVertices[i_8] - prev) * percent - setupVertices[i_8];
|
||||
deform[i_8] += prev + (nextVertices[i_8] - prev) * percent - setupVertices[i_8];
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (var i_9 = 0; i_9 < vertexCount; i_9++) {
|
||||
var prev = prevVertices[i_9];
|
||||
vertices[i_9] += prev + (nextVertices[i_9] - prev) * percent;
|
||||
deform[i_9] += prev + (nextVertices[i_9] - prev) * percent;
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (var i_10 = 0; i_10 < vertexCount; i_10++) {
|
||||
var prev = prevVertices[i_10];
|
||||
vertices[i_10] = prev + (nextVertices[i_10] - prev) * percent;
|
||||
deform[i_10] = prev + (nextVertices[i_10] - prev) * percent;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -826,13 +826,13 @@ var spine;
|
||||
var setupVertices = vertexAttachment_2.vertices;
|
||||
for (var i_11 = 0; i_11 < vertexCount; i_11++) {
|
||||
var prev = prevVertices[i_11], setup = setupVertices[i_11];
|
||||
vertices[i_11] = setup + (prev + (nextVertices[i_11] - prev) * percent - setup) * alpha;
|
||||
deform[i_11] = setup + (prev + (nextVertices[i_11] - prev) * percent - setup) * alpha;
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (var i_12 = 0; i_12 < vertexCount; i_12++) {
|
||||
var prev = prevVertices[i_12];
|
||||
vertices[i_12] = (prev + (nextVertices[i_12] - prev) * percent) * alpha;
|
||||
deform[i_12] = (prev + (nextVertices[i_12] - prev) * percent) * alpha;
|
||||
}
|
||||
}
|
||||
break;
|
||||
@ -841,7 +841,7 @@ var spine;
|
||||
case MixBlend.replace:
|
||||
for (var i_13 = 0; i_13 < vertexCount; i_13++) {
|
||||
var prev = prevVertices[i_13];
|
||||
vertices[i_13] += (prev + (nextVertices[i_13] - prev) * percent - vertices[i_13]) * alpha;
|
||||
deform[i_13] += (prev + (nextVertices[i_13] - prev) * percent - deform[i_13]) * alpha;
|
||||
}
|
||||
break;
|
||||
case MixBlend.add:
|
||||
@ -850,13 +850,13 @@ var spine;
|
||||
var setupVertices = vertexAttachment.vertices;
|
||||
for (var i_14 = 0; i_14 < vertexCount; i_14++) {
|
||||
var prev = prevVertices[i_14];
|
||||
vertices[i_14] += (prev + (nextVertices[i_14] - prev) * percent - setupVertices[i_14]) * alpha;
|
||||
deform[i_14] += (prev + (nextVertices[i_14] - prev) * percent - setupVertices[i_14]) * alpha;
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (var i_15 = 0; i_15 < vertexCount; i_15++) {
|
||||
var prev = prevVertices[i_15];
|
||||
vertices[i_15] += (prev + (nextVertices[i_15] - prev) * percent) * alpha;
|
||||
deform[i_15] += (prev + (nextVertices[i_15] - prev) * percent) * alpha;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1415,7 +1415,7 @@ var spine;
|
||||
var timelinesRotation = current.timelinesRotation;
|
||||
for (var ii = 0; ii < timelineCount; ii++) {
|
||||
var timeline = timelines[ii];
|
||||
var timelineBlend = timelineMode[ii] == AnimationState.SUBSEQUENT ? blend : spine.MixBlend.setup;
|
||||
var timelineBlend = (timelineMode[ii] & (AnimationState.NOT_LAST - 1)) == AnimationState.SUBSEQUENT ? blend : spine.MixBlend.setup;
|
||||
if (timeline instanceof spine.RotateTimeline) {
|
||||
this.applyRotateTimeline(timeline, skeleton, animationTime, mix, timelineBlend, timelinesRotation, ii << 1, firstFrame);
|
||||
}
|
||||
@ -1473,7 +1473,7 @@ var spine;
|
||||
var direction = spine.MixDirection.out;
|
||||
var timelineBlend = void 0;
|
||||
var alpha = 0;
|
||||
switch (timelineMode[i]) {
|
||||
switch (timelineMode[i] & (AnimationState.NOT_LAST - 1)) {
|
||||
case AnimationState.SUBSEQUENT:
|
||||
if (!attachments && timeline instanceof spine.AttachmentTimeline)
|
||||
continue;
|
||||
@ -1503,12 +1503,12 @@ var spine;
|
||||
spine.Utils.webkit602BugfixHelper(alpha, blend);
|
||||
if (timelineBlend == spine.MixBlend.setup) {
|
||||
if (timeline instanceof spine.AttachmentTimeline) {
|
||||
if (attachments)
|
||||
direction = spine.MixDirection.out;
|
||||
if (attachments || (timelineMode[i] & AnimationState.NOT_LAST) == AnimationState.NOT_LAST)
|
||||
direction = spine.MixDirection["in"];
|
||||
}
|
||||
else if (timeline instanceof spine.DrawOrderTimeline) {
|
||||
if (drawOrder)
|
||||
direction = spine.MixDirection.out;
|
||||
direction = spine.MixDirection["in"];
|
||||
}
|
||||
}
|
||||
timeline.apply(skeleton, animationLast, animationTime, events, alpha, timelineBlend, direction);
|
||||
@ -1803,12 +1803,20 @@ var spine;
|
||||
entry = entry.mixingFrom;
|
||||
do {
|
||||
if (entry.mixingFrom == null || entry.mixBlend != spine.MixBlend.add)
|
||||
this.setTimelineModes(entry);
|
||||
this.computeHold(entry);
|
||||
entry = entry.mixingTo;
|
||||
} while (entry != null);
|
||||
}
|
||||
this.propertyIDs.clear();
|
||||
for (var i = this.tracks.length - 1; i >= 0; i--) {
|
||||
var entry = this.tracks[i];
|
||||
while (entry != null) {
|
||||
this.computeNotLast(entry);
|
||||
entry = entry.mixingFrom;
|
||||
}
|
||||
}
|
||||
};
|
||||
AnimationState.prototype.setTimelineModes = function (entry) {
|
||||
AnimationState.prototype.computeHold = function (entry) {
|
||||
var to = entry.mixingTo;
|
||||
var timelines = entry.animation.timelines;
|
||||
var timelinesCount = entry.animation.timelines.length;
|
||||
@ -1824,11 +1832,14 @@ var spine;
|
||||
return;
|
||||
}
|
||||
outer: for (var i = 0; i < timelinesCount; i++) {
|
||||
var id = timelines[i].getPropertyId();
|
||||
var timeline = timelines[i];
|
||||
var id = timeline.getPropertyId();
|
||||
if (!propertyIDs.add(id))
|
||||
timelineMode[i] = AnimationState.SUBSEQUENT;
|
||||
else if (to == null || !this.hasTimeline(to, id))
|
||||
else if (to == null || timeline instanceof spine.AttachmentTimeline || timeline instanceof spine.DrawOrderTimeline
|
||||
|| timeline instanceof spine.EventTimeline || !this.hasTimeline(to, id)) {
|
||||
timelineMode[i] = AnimationState.FIRST;
|
||||
}
|
||||
else {
|
||||
for (var next = to.mixingTo; next != null; next = next.mixingTo) {
|
||||
if (this.hasTimeline(next, id))
|
||||
@ -1844,6 +1855,19 @@ var spine;
|
||||
}
|
||||
}
|
||||
};
|
||||
AnimationState.prototype.computeNotLast = function (entry) {
|
||||
var timelines = entry.animation.timelines;
|
||||
var timelinesCount = entry.animation.timelines.length;
|
||||
var timelineMode = entry.timelineMode;
|
||||
var propertyIDs = this.propertyIDs;
|
||||
for (var i = 0; i < timelinesCount; i++) {
|
||||
if (timelines[i] instanceof spine.AttachmentTimeline) {
|
||||
var timeline = timelines[i];
|
||||
if (!propertyIDs.add(timeline.slotIndex))
|
||||
timelineMode[i] |= AnimationState.NOT_LAST;
|
||||
}
|
||||
}
|
||||
};
|
||||
AnimationState.prototype.hasTimeline = function (entry, id) {
|
||||
var timelines = entry.animation.timelines;
|
||||
for (var i = 0, n = timelines.length; i < n; i++)
|
||||
@ -1877,6 +1901,7 @@ var spine;
|
||||
AnimationState.FIRST = 1;
|
||||
AnimationState.HOLD = 2;
|
||||
AnimationState.HOLD_MIX = 3;
|
||||
AnimationState.NOT_LAST = 4;
|
||||
return AnimationState;
|
||||
}());
|
||||
spine.AnimationState = AnimationState;
|
||||
@ -5263,7 +5288,7 @@ var spine;
|
||||
(function (spine) {
|
||||
var Slot = (function () {
|
||||
function Slot(data, bone) {
|
||||
this.attachmentVertices = new Array();
|
||||
this.deform = new Array();
|
||||
if (data == null)
|
||||
throw new Error("data cannot be null.");
|
||||
if (bone == null)
|
||||
@ -5282,7 +5307,7 @@ var spine;
|
||||
return;
|
||||
this.attachment = attachment;
|
||||
this.attachmentTime = this.bone.skeleton.time;
|
||||
this.attachmentVertices.length = 0;
|
||||
this.deform.length = 0;
|
||||
};
|
||||
Slot.prototype.setAttachmentTime = function (time) {
|
||||
this.attachmentTime = this.bone.skeleton.time - time;
|
||||
@ -6437,7 +6462,7 @@ var spine;
|
||||
VertexAttachment.prototype.computeWorldVertices = function (slot, start, count, worldVertices, offset, stride) {
|
||||
count = offset + (count >> 1) * stride;
|
||||
var skeleton = slot.bone.skeleton;
|
||||
var deformArray = slot.attachmentVertices;
|
||||
var deformArray = slot.deform;
|
||||
var vertices = this.vertices;
|
||||
var bones = this.bones;
|
||||
if (bones == null) {
|
||||
|
||||
File diff suppressed because one or more lines are too long
6
spine-ts/build/spine-core.d.ts
vendored
6
spine-ts/build/spine-core.d.ts
vendored
@ -246,6 +246,7 @@ declare module spine {
|
||||
static FIRST: number;
|
||||
static HOLD: number;
|
||||
static HOLD_MIX: number;
|
||||
static NOT_LAST: number;
|
||||
data: AnimationStateData;
|
||||
tracks: TrackEntry[];
|
||||
events: Event[];
|
||||
@ -276,7 +277,8 @@ declare module spine {
|
||||
trackEntry(trackIndex: number, animation: Animation, loop: boolean, last: TrackEntry): TrackEntry;
|
||||
disposeNext(entry: TrackEntry): void;
|
||||
_animationsChanged(): void;
|
||||
setTimelineModes(entry: TrackEntry): void;
|
||||
computeHold(entry: TrackEntry): void;
|
||||
computeNotLast(entry: TrackEntry): void;
|
||||
hasTimeline(entry: TrackEntry, id: number): boolean;
|
||||
getCurrent(trackIndex: number): TrackEntry;
|
||||
addListener(listener: AnimationStateListener2): void;
|
||||
@ -784,7 +786,7 @@ declare module spine {
|
||||
darkColor: Color;
|
||||
private attachment;
|
||||
private attachmentTime;
|
||||
attachmentVertices: number[];
|
||||
deform: number[];
|
||||
constructor(data: SlotData, bone: Bone);
|
||||
getAttachment(): Attachment;
|
||||
setAttachment(attachment: Attachment): void;
|
||||
|
||||
@ -700,8 +700,8 @@ var spine;
|
||||
var slotAttachment = slot.getAttachment();
|
||||
if (!(slotAttachment instanceof spine.VertexAttachment) || !slotAttachment.applyDeform(this.attachment))
|
||||
return;
|
||||
var verticesArray = slot.attachmentVertices;
|
||||
if (verticesArray.length == 0)
|
||||
var deformArray = slot.deform;
|
||||
if (deformArray.length == 0)
|
||||
blend = MixBlend.setup;
|
||||
var frameVertices = this.frameVertices;
|
||||
var vertexCount = frameVertices[0].length;
|
||||
@ -710,28 +710,28 @@ var spine;
|
||||
var vertexAttachment = slotAttachment;
|
||||
switch (blend) {
|
||||
case MixBlend.setup:
|
||||
verticesArray.length = 0;
|
||||
deformArray.length = 0;
|
||||
return;
|
||||
case MixBlend.first:
|
||||
if (alpha == 1) {
|
||||
verticesArray.length = 0;
|
||||
deformArray.length = 0;
|
||||
break;
|
||||
}
|
||||
var vertices_1 = spine.Utils.setArraySize(verticesArray, vertexCount);
|
||||
var deform_1 = spine.Utils.setArraySize(deformArray, vertexCount);
|
||||
if (vertexAttachment.bones == null) {
|
||||
var setupVertices = vertexAttachment.vertices;
|
||||
for (var i = 0; i < vertexCount; i++)
|
||||
vertices_1[i] += (setupVertices[i] - vertices_1[i]) * alpha;
|
||||
deform_1[i] += (setupVertices[i] - deform_1[i]) * alpha;
|
||||
}
|
||||
else {
|
||||
alpha = 1 - alpha;
|
||||
for (var i = 0; i < vertexCount; i++)
|
||||
vertices_1[i] *= alpha;
|
||||
deform_1[i] *= alpha;
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
var vertices = spine.Utils.setArraySize(verticesArray, vertexCount);
|
||||
var deform = spine.Utils.setArraySize(deformArray, vertexCount);
|
||||
if (time >= frames[frames.length - 1]) {
|
||||
var lastVertices = frameVertices[frames.length - 1];
|
||||
if (alpha == 1) {
|
||||
@ -740,16 +740,16 @@ var spine;
|
||||
if (vertexAttachment.bones == null) {
|
||||
var setupVertices = vertexAttachment.vertices;
|
||||
for (var i_1 = 0; i_1 < vertexCount; i_1++) {
|
||||
vertices[i_1] += lastVertices[i_1] - setupVertices[i_1];
|
||||
deform[i_1] += lastVertices[i_1] - setupVertices[i_1];
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (var i_2 = 0; i_2 < vertexCount; i_2++)
|
||||
vertices[i_2] += lastVertices[i_2];
|
||||
deform[i_2] += lastVertices[i_2];
|
||||
}
|
||||
}
|
||||
else {
|
||||
spine.Utils.arrayCopy(lastVertices, 0, vertices, 0, vertexCount);
|
||||
spine.Utils.arrayCopy(lastVertices, 0, deform, 0, vertexCount);
|
||||
}
|
||||
}
|
||||
else {
|
||||
@ -760,30 +760,30 @@ var spine;
|
||||
var setupVertices = vertexAttachment_1.vertices;
|
||||
for (var i_3 = 0; i_3 < vertexCount; i_3++) {
|
||||
var setup = setupVertices[i_3];
|
||||
vertices[i_3] = setup + (lastVertices[i_3] - setup) * alpha;
|
||||
deform[i_3] = setup + (lastVertices[i_3] - setup) * alpha;
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (var i_4 = 0; i_4 < vertexCount; i_4++)
|
||||
vertices[i_4] = lastVertices[i_4] * alpha;
|
||||
deform[i_4] = lastVertices[i_4] * alpha;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case MixBlend.first:
|
||||
case MixBlend.replace:
|
||||
for (var i_5 = 0; i_5 < vertexCount; i_5++)
|
||||
vertices[i_5] += (lastVertices[i_5] - vertices[i_5]) * alpha;
|
||||
deform[i_5] += (lastVertices[i_5] - deform[i_5]) * alpha;
|
||||
case MixBlend.add:
|
||||
var vertexAttachment = slotAttachment;
|
||||
if (vertexAttachment.bones == null) {
|
||||
var setupVertices = vertexAttachment.vertices;
|
||||
for (var i_6 = 0; i_6 < vertexCount; i_6++) {
|
||||
vertices[i_6] += (lastVertices[i_6] - setupVertices[i_6]) * alpha;
|
||||
deform[i_6] += (lastVertices[i_6] - setupVertices[i_6]) * alpha;
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (var i_7 = 0; i_7 < vertexCount; i_7++)
|
||||
vertices[i_7] += lastVertices[i_7] * alpha;
|
||||
deform[i_7] += lastVertices[i_7] * alpha;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -801,20 +801,20 @@ var spine;
|
||||
var setupVertices = vertexAttachment.vertices;
|
||||
for (var i_8 = 0; i_8 < vertexCount; i_8++) {
|
||||
var prev = prevVertices[i_8];
|
||||
vertices[i_8] += prev + (nextVertices[i_8] - prev) * percent - setupVertices[i_8];
|
||||
deform[i_8] += prev + (nextVertices[i_8] - prev) * percent - setupVertices[i_8];
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (var i_9 = 0; i_9 < vertexCount; i_9++) {
|
||||
var prev = prevVertices[i_9];
|
||||
vertices[i_9] += prev + (nextVertices[i_9] - prev) * percent;
|
||||
deform[i_9] += prev + (nextVertices[i_9] - prev) * percent;
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (var i_10 = 0; i_10 < vertexCount; i_10++) {
|
||||
var prev = prevVertices[i_10];
|
||||
vertices[i_10] = prev + (nextVertices[i_10] - prev) * percent;
|
||||
deform[i_10] = prev + (nextVertices[i_10] - prev) * percent;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -826,13 +826,13 @@ var spine;
|
||||
var setupVertices = vertexAttachment_2.vertices;
|
||||
for (var i_11 = 0; i_11 < vertexCount; i_11++) {
|
||||
var prev = prevVertices[i_11], setup = setupVertices[i_11];
|
||||
vertices[i_11] = setup + (prev + (nextVertices[i_11] - prev) * percent - setup) * alpha;
|
||||
deform[i_11] = setup + (prev + (nextVertices[i_11] - prev) * percent - setup) * alpha;
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (var i_12 = 0; i_12 < vertexCount; i_12++) {
|
||||
var prev = prevVertices[i_12];
|
||||
vertices[i_12] = (prev + (nextVertices[i_12] - prev) * percent) * alpha;
|
||||
deform[i_12] = (prev + (nextVertices[i_12] - prev) * percent) * alpha;
|
||||
}
|
||||
}
|
||||
break;
|
||||
@ -841,7 +841,7 @@ var spine;
|
||||
case MixBlend.replace:
|
||||
for (var i_13 = 0; i_13 < vertexCount; i_13++) {
|
||||
var prev = prevVertices[i_13];
|
||||
vertices[i_13] += (prev + (nextVertices[i_13] - prev) * percent - vertices[i_13]) * alpha;
|
||||
deform[i_13] += (prev + (nextVertices[i_13] - prev) * percent - deform[i_13]) * alpha;
|
||||
}
|
||||
break;
|
||||
case MixBlend.add:
|
||||
@ -850,13 +850,13 @@ var spine;
|
||||
var setupVertices = vertexAttachment.vertices;
|
||||
for (var i_14 = 0; i_14 < vertexCount; i_14++) {
|
||||
var prev = prevVertices[i_14];
|
||||
vertices[i_14] += (prev + (nextVertices[i_14] - prev) * percent - setupVertices[i_14]) * alpha;
|
||||
deform[i_14] += (prev + (nextVertices[i_14] - prev) * percent - setupVertices[i_14]) * alpha;
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (var i_15 = 0; i_15 < vertexCount; i_15++) {
|
||||
var prev = prevVertices[i_15];
|
||||
vertices[i_15] += (prev + (nextVertices[i_15] - prev) * percent) * alpha;
|
||||
deform[i_15] += (prev + (nextVertices[i_15] - prev) * percent) * alpha;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1415,7 +1415,7 @@ var spine;
|
||||
var timelinesRotation = current.timelinesRotation;
|
||||
for (var ii = 0; ii < timelineCount; ii++) {
|
||||
var timeline = timelines[ii];
|
||||
var timelineBlend = timelineMode[ii] == AnimationState.SUBSEQUENT ? blend : spine.MixBlend.setup;
|
||||
var timelineBlend = (timelineMode[ii] & (AnimationState.NOT_LAST - 1)) == AnimationState.SUBSEQUENT ? blend : spine.MixBlend.setup;
|
||||
if (timeline instanceof spine.RotateTimeline) {
|
||||
this.applyRotateTimeline(timeline, skeleton, animationTime, mix, timelineBlend, timelinesRotation, ii << 1, firstFrame);
|
||||
}
|
||||
@ -1473,7 +1473,7 @@ var spine;
|
||||
var direction = spine.MixDirection.out;
|
||||
var timelineBlend = void 0;
|
||||
var alpha = 0;
|
||||
switch (timelineMode[i]) {
|
||||
switch (timelineMode[i] & (AnimationState.NOT_LAST - 1)) {
|
||||
case AnimationState.SUBSEQUENT:
|
||||
if (!attachments && timeline instanceof spine.AttachmentTimeline)
|
||||
continue;
|
||||
@ -1503,12 +1503,12 @@ var spine;
|
||||
spine.Utils.webkit602BugfixHelper(alpha, blend);
|
||||
if (timelineBlend == spine.MixBlend.setup) {
|
||||
if (timeline instanceof spine.AttachmentTimeline) {
|
||||
if (attachments)
|
||||
direction = spine.MixDirection.out;
|
||||
if (attachments || (timelineMode[i] & AnimationState.NOT_LAST) == AnimationState.NOT_LAST)
|
||||
direction = spine.MixDirection["in"];
|
||||
}
|
||||
else if (timeline instanceof spine.DrawOrderTimeline) {
|
||||
if (drawOrder)
|
||||
direction = spine.MixDirection.out;
|
||||
direction = spine.MixDirection["in"];
|
||||
}
|
||||
}
|
||||
timeline.apply(skeleton, animationLast, animationTime, events, alpha, timelineBlend, direction);
|
||||
@ -1803,12 +1803,20 @@ var spine;
|
||||
entry = entry.mixingFrom;
|
||||
do {
|
||||
if (entry.mixingFrom == null || entry.mixBlend != spine.MixBlend.add)
|
||||
this.setTimelineModes(entry);
|
||||
this.computeHold(entry);
|
||||
entry = entry.mixingTo;
|
||||
} while (entry != null);
|
||||
}
|
||||
this.propertyIDs.clear();
|
||||
for (var i = this.tracks.length - 1; i >= 0; i--) {
|
||||
var entry = this.tracks[i];
|
||||
while (entry != null) {
|
||||
this.computeNotLast(entry);
|
||||
entry = entry.mixingFrom;
|
||||
}
|
||||
}
|
||||
};
|
||||
AnimationState.prototype.setTimelineModes = function (entry) {
|
||||
AnimationState.prototype.computeHold = function (entry) {
|
||||
var to = entry.mixingTo;
|
||||
var timelines = entry.animation.timelines;
|
||||
var timelinesCount = entry.animation.timelines.length;
|
||||
@ -1824,11 +1832,14 @@ var spine;
|
||||
return;
|
||||
}
|
||||
outer: for (var i = 0; i < timelinesCount; i++) {
|
||||
var id = timelines[i].getPropertyId();
|
||||
var timeline = timelines[i];
|
||||
var id = timeline.getPropertyId();
|
||||
if (!propertyIDs.add(id))
|
||||
timelineMode[i] = AnimationState.SUBSEQUENT;
|
||||
else if (to == null || !this.hasTimeline(to, id))
|
||||
else if (to == null || timeline instanceof spine.AttachmentTimeline || timeline instanceof spine.DrawOrderTimeline
|
||||
|| timeline instanceof spine.EventTimeline || !this.hasTimeline(to, id)) {
|
||||
timelineMode[i] = AnimationState.FIRST;
|
||||
}
|
||||
else {
|
||||
for (var next = to.mixingTo; next != null; next = next.mixingTo) {
|
||||
if (this.hasTimeline(next, id))
|
||||
@ -1844,6 +1855,19 @@ var spine;
|
||||
}
|
||||
}
|
||||
};
|
||||
AnimationState.prototype.computeNotLast = function (entry) {
|
||||
var timelines = entry.animation.timelines;
|
||||
var timelinesCount = entry.animation.timelines.length;
|
||||
var timelineMode = entry.timelineMode;
|
||||
var propertyIDs = this.propertyIDs;
|
||||
for (var i = 0; i < timelinesCount; i++) {
|
||||
if (timelines[i] instanceof spine.AttachmentTimeline) {
|
||||
var timeline = timelines[i];
|
||||
if (!propertyIDs.add(timeline.slotIndex))
|
||||
timelineMode[i] |= AnimationState.NOT_LAST;
|
||||
}
|
||||
}
|
||||
};
|
||||
AnimationState.prototype.hasTimeline = function (entry, id) {
|
||||
var timelines = entry.animation.timelines;
|
||||
for (var i = 0, n = timelines.length; i < n; i++)
|
||||
@ -1877,6 +1901,7 @@ var spine;
|
||||
AnimationState.FIRST = 1;
|
||||
AnimationState.HOLD = 2;
|
||||
AnimationState.HOLD_MIX = 3;
|
||||
AnimationState.NOT_LAST = 4;
|
||||
return AnimationState;
|
||||
}());
|
||||
spine.AnimationState = AnimationState;
|
||||
@ -5263,7 +5288,7 @@ var spine;
|
||||
(function (spine) {
|
||||
var Slot = (function () {
|
||||
function Slot(data, bone) {
|
||||
this.attachmentVertices = new Array();
|
||||
this.deform = new Array();
|
||||
if (data == null)
|
||||
throw new Error("data cannot be null.");
|
||||
if (bone == null)
|
||||
@ -5282,7 +5307,7 @@ var spine;
|
||||
return;
|
||||
this.attachment = attachment;
|
||||
this.attachmentTime = this.bone.skeleton.time;
|
||||
this.attachmentVertices.length = 0;
|
||||
this.deform.length = 0;
|
||||
};
|
||||
Slot.prototype.setAttachmentTime = function (time) {
|
||||
this.attachmentTime = this.bone.skeleton.time - time;
|
||||
@ -6437,7 +6462,7 @@ var spine;
|
||||
VertexAttachment.prototype.computeWorldVertices = function (slot, start, count, worldVertices, offset, stride) {
|
||||
count = offset + (count >> 1) * stride;
|
||||
var skeleton = slot.bone.skeleton;
|
||||
var deformArray = slot.attachmentVertices;
|
||||
var deformArray = slot.deform;
|
||||
var vertices = this.vertices;
|
||||
var bones = this.bones;
|
||||
if (bones == null) {
|
||||
|
||||
File diff suppressed because one or more lines are too long
6
spine-ts/build/spine-player.d.ts
vendored
6
spine-ts/build/spine-player.d.ts
vendored
@ -246,6 +246,7 @@ declare module spine {
|
||||
static FIRST: number;
|
||||
static HOLD: number;
|
||||
static HOLD_MIX: number;
|
||||
static NOT_LAST: number;
|
||||
data: AnimationStateData;
|
||||
tracks: TrackEntry[];
|
||||
events: Event[];
|
||||
@ -276,7 +277,8 @@ declare module spine {
|
||||
trackEntry(trackIndex: number, animation: Animation, loop: boolean, last: TrackEntry): TrackEntry;
|
||||
disposeNext(entry: TrackEntry): void;
|
||||
_animationsChanged(): void;
|
||||
setTimelineModes(entry: TrackEntry): void;
|
||||
computeHold(entry: TrackEntry): void;
|
||||
computeNotLast(entry: TrackEntry): void;
|
||||
hasTimeline(entry: TrackEntry, id: number): boolean;
|
||||
getCurrent(trackIndex: number): TrackEntry;
|
||||
addListener(listener: AnimationStateListener2): void;
|
||||
@ -784,7 +786,7 @@ declare module spine {
|
||||
darkColor: Color;
|
||||
private attachment;
|
||||
private attachmentTime;
|
||||
attachmentVertices: number[];
|
||||
deform: number[];
|
||||
constructor(data: SlotData, bone: Bone);
|
||||
getAttachment(): Attachment;
|
||||
setAttachment(attachment: Attachment): void;
|
||||
|
||||
@ -700,8 +700,8 @@ var spine;
|
||||
var slotAttachment = slot.getAttachment();
|
||||
if (!(slotAttachment instanceof spine.VertexAttachment) || !slotAttachment.applyDeform(this.attachment))
|
||||
return;
|
||||
var verticesArray = slot.attachmentVertices;
|
||||
if (verticesArray.length == 0)
|
||||
var deformArray = slot.deform;
|
||||
if (deformArray.length == 0)
|
||||
blend = MixBlend.setup;
|
||||
var frameVertices = this.frameVertices;
|
||||
var vertexCount = frameVertices[0].length;
|
||||
@ -710,28 +710,28 @@ var spine;
|
||||
var vertexAttachment = slotAttachment;
|
||||
switch (blend) {
|
||||
case MixBlend.setup:
|
||||
verticesArray.length = 0;
|
||||
deformArray.length = 0;
|
||||
return;
|
||||
case MixBlend.first:
|
||||
if (alpha == 1) {
|
||||
verticesArray.length = 0;
|
||||
deformArray.length = 0;
|
||||
break;
|
||||
}
|
||||
var vertices_1 = spine.Utils.setArraySize(verticesArray, vertexCount);
|
||||
var deform_1 = spine.Utils.setArraySize(deformArray, vertexCount);
|
||||
if (vertexAttachment.bones == null) {
|
||||
var setupVertices = vertexAttachment.vertices;
|
||||
for (var i = 0; i < vertexCount; i++)
|
||||
vertices_1[i] += (setupVertices[i] - vertices_1[i]) * alpha;
|
||||
deform_1[i] += (setupVertices[i] - deform_1[i]) * alpha;
|
||||
}
|
||||
else {
|
||||
alpha = 1 - alpha;
|
||||
for (var i = 0; i < vertexCount; i++)
|
||||
vertices_1[i] *= alpha;
|
||||
deform_1[i] *= alpha;
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
var vertices = spine.Utils.setArraySize(verticesArray, vertexCount);
|
||||
var deform = spine.Utils.setArraySize(deformArray, vertexCount);
|
||||
if (time >= frames[frames.length - 1]) {
|
||||
var lastVertices = frameVertices[frames.length - 1];
|
||||
if (alpha == 1) {
|
||||
@ -740,16 +740,16 @@ var spine;
|
||||
if (vertexAttachment.bones == null) {
|
||||
var setupVertices = vertexAttachment.vertices;
|
||||
for (var i_1 = 0; i_1 < vertexCount; i_1++) {
|
||||
vertices[i_1] += lastVertices[i_1] - setupVertices[i_1];
|
||||
deform[i_1] += lastVertices[i_1] - setupVertices[i_1];
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (var i_2 = 0; i_2 < vertexCount; i_2++)
|
||||
vertices[i_2] += lastVertices[i_2];
|
||||
deform[i_2] += lastVertices[i_2];
|
||||
}
|
||||
}
|
||||
else {
|
||||
spine.Utils.arrayCopy(lastVertices, 0, vertices, 0, vertexCount);
|
||||
spine.Utils.arrayCopy(lastVertices, 0, deform, 0, vertexCount);
|
||||
}
|
||||
}
|
||||
else {
|
||||
@ -760,30 +760,30 @@ var spine;
|
||||
var setupVertices = vertexAttachment_1.vertices;
|
||||
for (var i_3 = 0; i_3 < vertexCount; i_3++) {
|
||||
var setup = setupVertices[i_3];
|
||||
vertices[i_3] = setup + (lastVertices[i_3] - setup) * alpha;
|
||||
deform[i_3] = setup + (lastVertices[i_3] - setup) * alpha;
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (var i_4 = 0; i_4 < vertexCount; i_4++)
|
||||
vertices[i_4] = lastVertices[i_4] * alpha;
|
||||
deform[i_4] = lastVertices[i_4] * alpha;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case MixBlend.first:
|
||||
case MixBlend.replace:
|
||||
for (var i_5 = 0; i_5 < vertexCount; i_5++)
|
||||
vertices[i_5] += (lastVertices[i_5] - vertices[i_5]) * alpha;
|
||||
deform[i_5] += (lastVertices[i_5] - deform[i_5]) * alpha;
|
||||
case MixBlend.add:
|
||||
var vertexAttachment = slotAttachment;
|
||||
if (vertexAttachment.bones == null) {
|
||||
var setupVertices = vertexAttachment.vertices;
|
||||
for (var i_6 = 0; i_6 < vertexCount; i_6++) {
|
||||
vertices[i_6] += (lastVertices[i_6] - setupVertices[i_6]) * alpha;
|
||||
deform[i_6] += (lastVertices[i_6] - setupVertices[i_6]) * alpha;
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (var i_7 = 0; i_7 < vertexCount; i_7++)
|
||||
vertices[i_7] += lastVertices[i_7] * alpha;
|
||||
deform[i_7] += lastVertices[i_7] * alpha;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -801,20 +801,20 @@ var spine;
|
||||
var setupVertices = vertexAttachment.vertices;
|
||||
for (var i_8 = 0; i_8 < vertexCount; i_8++) {
|
||||
var prev = prevVertices[i_8];
|
||||
vertices[i_8] += prev + (nextVertices[i_8] - prev) * percent - setupVertices[i_8];
|
||||
deform[i_8] += prev + (nextVertices[i_8] - prev) * percent - setupVertices[i_8];
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (var i_9 = 0; i_9 < vertexCount; i_9++) {
|
||||
var prev = prevVertices[i_9];
|
||||
vertices[i_9] += prev + (nextVertices[i_9] - prev) * percent;
|
||||
deform[i_9] += prev + (nextVertices[i_9] - prev) * percent;
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (var i_10 = 0; i_10 < vertexCount; i_10++) {
|
||||
var prev = prevVertices[i_10];
|
||||
vertices[i_10] = prev + (nextVertices[i_10] - prev) * percent;
|
||||
deform[i_10] = prev + (nextVertices[i_10] - prev) * percent;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -826,13 +826,13 @@ var spine;
|
||||
var setupVertices = vertexAttachment_2.vertices;
|
||||
for (var i_11 = 0; i_11 < vertexCount; i_11++) {
|
||||
var prev = prevVertices[i_11], setup = setupVertices[i_11];
|
||||
vertices[i_11] = setup + (prev + (nextVertices[i_11] - prev) * percent - setup) * alpha;
|
||||
deform[i_11] = setup + (prev + (nextVertices[i_11] - prev) * percent - setup) * alpha;
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (var i_12 = 0; i_12 < vertexCount; i_12++) {
|
||||
var prev = prevVertices[i_12];
|
||||
vertices[i_12] = (prev + (nextVertices[i_12] - prev) * percent) * alpha;
|
||||
deform[i_12] = (prev + (nextVertices[i_12] - prev) * percent) * alpha;
|
||||
}
|
||||
}
|
||||
break;
|
||||
@ -841,7 +841,7 @@ var spine;
|
||||
case MixBlend.replace:
|
||||
for (var i_13 = 0; i_13 < vertexCount; i_13++) {
|
||||
var prev = prevVertices[i_13];
|
||||
vertices[i_13] += (prev + (nextVertices[i_13] - prev) * percent - vertices[i_13]) * alpha;
|
||||
deform[i_13] += (prev + (nextVertices[i_13] - prev) * percent - deform[i_13]) * alpha;
|
||||
}
|
||||
break;
|
||||
case MixBlend.add:
|
||||
@ -850,13 +850,13 @@ var spine;
|
||||
var setupVertices = vertexAttachment.vertices;
|
||||
for (var i_14 = 0; i_14 < vertexCount; i_14++) {
|
||||
var prev = prevVertices[i_14];
|
||||
vertices[i_14] += (prev + (nextVertices[i_14] - prev) * percent - setupVertices[i_14]) * alpha;
|
||||
deform[i_14] += (prev + (nextVertices[i_14] - prev) * percent - setupVertices[i_14]) * alpha;
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (var i_15 = 0; i_15 < vertexCount; i_15++) {
|
||||
var prev = prevVertices[i_15];
|
||||
vertices[i_15] += (prev + (nextVertices[i_15] - prev) * percent) * alpha;
|
||||
deform[i_15] += (prev + (nextVertices[i_15] - prev) * percent) * alpha;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1415,7 +1415,7 @@ var spine;
|
||||
var timelinesRotation = current.timelinesRotation;
|
||||
for (var ii = 0; ii < timelineCount; ii++) {
|
||||
var timeline = timelines[ii];
|
||||
var timelineBlend = timelineMode[ii] == AnimationState.SUBSEQUENT ? blend : spine.MixBlend.setup;
|
||||
var timelineBlend = (timelineMode[ii] & (AnimationState.NOT_LAST - 1)) == AnimationState.SUBSEQUENT ? blend : spine.MixBlend.setup;
|
||||
if (timeline instanceof spine.RotateTimeline) {
|
||||
this.applyRotateTimeline(timeline, skeleton, animationTime, mix, timelineBlend, timelinesRotation, ii << 1, firstFrame);
|
||||
}
|
||||
@ -1473,7 +1473,7 @@ var spine;
|
||||
var direction = spine.MixDirection.out;
|
||||
var timelineBlend = void 0;
|
||||
var alpha = 0;
|
||||
switch (timelineMode[i]) {
|
||||
switch (timelineMode[i] & (AnimationState.NOT_LAST - 1)) {
|
||||
case AnimationState.SUBSEQUENT:
|
||||
if (!attachments && timeline instanceof spine.AttachmentTimeline)
|
||||
continue;
|
||||
@ -1503,12 +1503,12 @@ var spine;
|
||||
spine.Utils.webkit602BugfixHelper(alpha, blend);
|
||||
if (timelineBlend == spine.MixBlend.setup) {
|
||||
if (timeline instanceof spine.AttachmentTimeline) {
|
||||
if (attachments)
|
||||
direction = spine.MixDirection.out;
|
||||
if (attachments || (timelineMode[i] & AnimationState.NOT_LAST) == AnimationState.NOT_LAST)
|
||||
direction = spine.MixDirection["in"];
|
||||
}
|
||||
else if (timeline instanceof spine.DrawOrderTimeline) {
|
||||
if (drawOrder)
|
||||
direction = spine.MixDirection.out;
|
||||
direction = spine.MixDirection["in"];
|
||||
}
|
||||
}
|
||||
timeline.apply(skeleton, animationLast, animationTime, events, alpha, timelineBlend, direction);
|
||||
@ -1803,12 +1803,20 @@ var spine;
|
||||
entry = entry.mixingFrom;
|
||||
do {
|
||||
if (entry.mixingFrom == null || entry.mixBlend != spine.MixBlend.add)
|
||||
this.setTimelineModes(entry);
|
||||
this.computeHold(entry);
|
||||
entry = entry.mixingTo;
|
||||
} while (entry != null);
|
||||
}
|
||||
this.propertyIDs.clear();
|
||||
for (var i = this.tracks.length - 1; i >= 0; i--) {
|
||||
var entry = this.tracks[i];
|
||||
while (entry != null) {
|
||||
this.computeNotLast(entry);
|
||||
entry = entry.mixingFrom;
|
||||
}
|
||||
}
|
||||
};
|
||||
AnimationState.prototype.setTimelineModes = function (entry) {
|
||||
AnimationState.prototype.computeHold = function (entry) {
|
||||
var to = entry.mixingTo;
|
||||
var timelines = entry.animation.timelines;
|
||||
var timelinesCount = entry.animation.timelines.length;
|
||||
@ -1824,11 +1832,14 @@ var spine;
|
||||
return;
|
||||
}
|
||||
outer: for (var i = 0; i < timelinesCount; i++) {
|
||||
var id = timelines[i].getPropertyId();
|
||||
var timeline = timelines[i];
|
||||
var id = timeline.getPropertyId();
|
||||
if (!propertyIDs.add(id))
|
||||
timelineMode[i] = AnimationState.SUBSEQUENT;
|
||||
else if (to == null || !this.hasTimeline(to, id))
|
||||
else if (to == null || timeline instanceof spine.AttachmentTimeline || timeline instanceof spine.DrawOrderTimeline
|
||||
|| timeline instanceof spine.EventTimeline || !this.hasTimeline(to, id)) {
|
||||
timelineMode[i] = AnimationState.FIRST;
|
||||
}
|
||||
else {
|
||||
for (var next = to.mixingTo; next != null; next = next.mixingTo) {
|
||||
if (this.hasTimeline(next, id))
|
||||
@ -1844,6 +1855,19 @@ var spine;
|
||||
}
|
||||
}
|
||||
};
|
||||
AnimationState.prototype.computeNotLast = function (entry) {
|
||||
var timelines = entry.animation.timelines;
|
||||
var timelinesCount = entry.animation.timelines.length;
|
||||
var timelineMode = entry.timelineMode;
|
||||
var propertyIDs = this.propertyIDs;
|
||||
for (var i = 0; i < timelinesCount; i++) {
|
||||
if (timelines[i] instanceof spine.AttachmentTimeline) {
|
||||
var timeline = timelines[i];
|
||||
if (!propertyIDs.add(timeline.slotIndex))
|
||||
timelineMode[i] |= AnimationState.NOT_LAST;
|
||||
}
|
||||
}
|
||||
};
|
||||
AnimationState.prototype.hasTimeline = function (entry, id) {
|
||||
var timelines = entry.animation.timelines;
|
||||
for (var i = 0, n = timelines.length; i < n; i++)
|
||||
@ -1877,6 +1901,7 @@ var spine;
|
||||
AnimationState.FIRST = 1;
|
||||
AnimationState.HOLD = 2;
|
||||
AnimationState.HOLD_MIX = 3;
|
||||
AnimationState.NOT_LAST = 4;
|
||||
return AnimationState;
|
||||
}());
|
||||
spine.AnimationState = AnimationState;
|
||||
@ -5263,7 +5288,7 @@ var spine;
|
||||
(function (spine) {
|
||||
var Slot = (function () {
|
||||
function Slot(data, bone) {
|
||||
this.attachmentVertices = new Array();
|
||||
this.deform = new Array();
|
||||
if (data == null)
|
||||
throw new Error("data cannot be null.");
|
||||
if (bone == null)
|
||||
@ -5282,7 +5307,7 @@ var spine;
|
||||
return;
|
||||
this.attachment = attachment;
|
||||
this.attachmentTime = this.bone.skeleton.time;
|
||||
this.attachmentVertices.length = 0;
|
||||
this.deform.length = 0;
|
||||
};
|
||||
Slot.prototype.setAttachmentTime = function (time) {
|
||||
this.attachmentTime = this.bone.skeleton.time - time;
|
||||
@ -6437,7 +6462,7 @@ var spine;
|
||||
VertexAttachment.prototype.computeWorldVertices = function (slot, start, count, worldVertices, offset, stride) {
|
||||
count = offset + (count >> 1) * stride;
|
||||
var skeleton = slot.bone.skeleton;
|
||||
var deformArray = slot.attachmentVertices;
|
||||
var deformArray = slot.deform;
|
||||
var vertices = this.vertices;
|
||||
var bones = this.bones;
|
||||
if (bones == null) {
|
||||
|
||||
File diff suppressed because one or more lines are too long
6
spine-ts/build/spine-threejs.d.ts
vendored
6
spine-ts/build/spine-threejs.d.ts
vendored
@ -246,6 +246,7 @@ declare module spine {
|
||||
static FIRST: number;
|
||||
static HOLD: number;
|
||||
static HOLD_MIX: number;
|
||||
static NOT_LAST: number;
|
||||
data: AnimationStateData;
|
||||
tracks: TrackEntry[];
|
||||
events: Event[];
|
||||
@ -276,7 +277,8 @@ declare module spine {
|
||||
trackEntry(trackIndex: number, animation: Animation, loop: boolean, last: TrackEntry): TrackEntry;
|
||||
disposeNext(entry: TrackEntry): void;
|
||||
_animationsChanged(): void;
|
||||
setTimelineModes(entry: TrackEntry): void;
|
||||
computeHold(entry: TrackEntry): void;
|
||||
computeNotLast(entry: TrackEntry): void;
|
||||
hasTimeline(entry: TrackEntry, id: number): boolean;
|
||||
getCurrent(trackIndex: number): TrackEntry;
|
||||
addListener(listener: AnimationStateListener2): void;
|
||||
@ -784,7 +786,7 @@ declare module spine {
|
||||
darkColor: Color;
|
||||
private attachment;
|
||||
private attachmentTime;
|
||||
attachmentVertices: number[];
|
||||
deform: number[];
|
||||
constructor(data: SlotData, bone: Bone);
|
||||
getAttachment(): Attachment;
|
||||
setAttachment(attachment: Attachment): void;
|
||||
|
||||
@ -700,8 +700,8 @@ var spine;
|
||||
var slotAttachment = slot.getAttachment();
|
||||
if (!(slotAttachment instanceof spine.VertexAttachment) || !slotAttachment.applyDeform(this.attachment))
|
||||
return;
|
||||
var verticesArray = slot.attachmentVertices;
|
||||
if (verticesArray.length == 0)
|
||||
var deformArray = slot.deform;
|
||||
if (deformArray.length == 0)
|
||||
blend = MixBlend.setup;
|
||||
var frameVertices = this.frameVertices;
|
||||
var vertexCount = frameVertices[0].length;
|
||||
@ -710,28 +710,28 @@ var spine;
|
||||
var vertexAttachment = slotAttachment;
|
||||
switch (blend) {
|
||||
case MixBlend.setup:
|
||||
verticesArray.length = 0;
|
||||
deformArray.length = 0;
|
||||
return;
|
||||
case MixBlend.first:
|
||||
if (alpha == 1) {
|
||||
verticesArray.length = 0;
|
||||
deformArray.length = 0;
|
||||
break;
|
||||
}
|
||||
var vertices_1 = spine.Utils.setArraySize(verticesArray, vertexCount);
|
||||
var deform_1 = spine.Utils.setArraySize(deformArray, vertexCount);
|
||||
if (vertexAttachment.bones == null) {
|
||||
var setupVertices = vertexAttachment.vertices;
|
||||
for (var i = 0; i < vertexCount; i++)
|
||||
vertices_1[i] += (setupVertices[i] - vertices_1[i]) * alpha;
|
||||
deform_1[i] += (setupVertices[i] - deform_1[i]) * alpha;
|
||||
}
|
||||
else {
|
||||
alpha = 1 - alpha;
|
||||
for (var i = 0; i < vertexCount; i++)
|
||||
vertices_1[i] *= alpha;
|
||||
deform_1[i] *= alpha;
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
var vertices = spine.Utils.setArraySize(verticesArray, vertexCount);
|
||||
var deform = spine.Utils.setArraySize(deformArray, vertexCount);
|
||||
if (time >= frames[frames.length - 1]) {
|
||||
var lastVertices = frameVertices[frames.length - 1];
|
||||
if (alpha == 1) {
|
||||
@ -740,16 +740,16 @@ var spine;
|
||||
if (vertexAttachment.bones == null) {
|
||||
var setupVertices = vertexAttachment.vertices;
|
||||
for (var i_1 = 0; i_1 < vertexCount; i_1++) {
|
||||
vertices[i_1] += lastVertices[i_1] - setupVertices[i_1];
|
||||
deform[i_1] += lastVertices[i_1] - setupVertices[i_1];
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (var i_2 = 0; i_2 < vertexCount; i_2++)
|
||||
vertices[i_2] += lastVertices[i_2];
|
||||
deform[i_2] += lastVertices[i_2];
|
||||
}
|
||||
}
|
||||
else {
|
||||
spine.Utils.arrayCopy(lastVertices, 0, vertices, 0, vertexCount);
|
||||
spine.Utils.arrayCopy(lastVertices, 0, deform, 0, vertexCount);
|
||||
}
|
||||
}
|
||||
else {
|
||||
@ -760,30 +760,30 @@ var spine;
|
||||
var setupVertices = vertexAttachment_1.vertices;
|
||||
for (var i_3 = 0; i_3 < vertexCount; i_3++) {
|
||||
var setup = setupVertices[i_3];
|
||||
vertices[i_3] = setup + (lastVertices[i_3] - setup) * alpha;
|
||||
deform[i_3] = setup + (lastVertices[i_3] - setup) * alpha;
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (var i_4 = 0; i_4 < vertexCount; i_4++)
|
||||
vertices[i_4] = lastVertices[i_4] * alpha;
|
||||
deform[i_4] = lastVertices[i_4] * alpha;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case MixBlend.first:
|
||||
case MixBlend.replace:
|
||||
for (var i_5 = 0; i_5 < vertexCount; i_5++)
|
||||
vertices[i_5] += (lastVertices[i_5] - vertices[i_5]) * alpha;
|
||||
deform[i_5] += (lastVertices[i_5] - deform[i_5]) * alpha;
|
||||
case MixBlend.add:
|
||||
var vertexAttachment = slotAttachment;
|
||||
if (vertexAttachment.bones == null) {
|
||||
var setupVertices = vertexAttachment.vertices;
|
||||
for (var i_6 = 0; i_6 < vertexCount; i_6++) {
|
||||
vertices[i_6] += (lastVertices[i_6] - setupVertices[i_6]) * alpha;
|
||||
deform[i_6] += (lastVertices[i_6] - setupVertices[i_6]) * alpha;
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (var i_7 = 0; i_7 < vertexCount; i_7++)
|
||||
vertices[i_7] += lastVertices[i_7] * alpha;
|
||||
deform[i_7] += lastVertices[i_7] * alpha;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -801,20 +801,20 @@ var spine;
|
||||
var setupVertices = vertexAttachment.vertices;
|
||||
for (var i_8 = 0; i_8 < vertexCount; i_8++) {
|
||||
var prev = prevVertices[i_8];
|
||||
vertices[i_8] += prev + (nextVertices[i_8] - prev) * percent - setupVertices[i_8];
|
||||
deform[i_8] += prev + (nextVertices[i_8] - prev) * percent - setupVertices[i_8];
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (var i_9 = 0; i_9 < vertexCount; i_9++) {
|
||||
var prev = prevVertices[i_9];
|
||||
vertices[i_9] += prev + (nextVertices[i_9] - prev) * percent;
|
||||
deform[i_9] += prev + (nextVertices[i_9] - prev) * percent;
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (var i_10 = 0; i_10 < vertexCount; i_10++) {
|
||||
var prev = prevVertices[i_10];
|
||||
vertices[i_10] = prev + (nextVertices[i_10] - prev) * percent;
|
||||
deform[i_10] = prev + (nextVertices[i_10] - prev) * percent;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -826,13 +826,13 @@ var spine;
|
||||
var setupVertices = vertexAttachment_2.vertices;
|
||||
for (var i_11 = 0; i_11 < vertexCount; i_11++) {
|
||||
var prev = prevVertices[i_11], setup = setupVertices[i_11];
|
||||
vertices[i_11] = setup + (prev + (nextVertices[i_11] - prev) * percent - setup) * alpha;
|
||||
deform[i_11] = setup + (prev + (nextVertices[i_11] - prev) * percent - setup) * alpha;
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (var i_12 = 0; i_12 < vertexCount; i_12++) {
|
||||
var prev = prevVertices[i_12];
|
||||
vertices[i_12] = (prev + (nextVertices[i_12] - prev) * percent) * alpha;
|
||||
deform[i_12] = (prev + (nextVertices[i_12] - prev) * percent) * alpha;
|
||||
}
|
||||
}
|
||||
break;
|
||||
@ -841,7 +841,7 @@ var spine;
|
||||
case MixBlend.replace:
|
||||
for (var i_13 = 0; i_13 < vertexCount; i_13++) {
|
||||
var prev = prevVertices[i_13];
|
||||
vertices[i_13] += (prev + (nextVertices[i_13] - prev) * percent - vertices[i_13]) * alpha;
|
||||
deform[i_13] += (prev + (nextVertices[i_13] - prev) * percent - deform[i_13]) * alpha;
|
||||
}
|
||||
break;
|
||||
case MixBlend.add:
|
||||
@ -850,13 +850,13 @@ var spine;
|
||||
var setupVertices = vertexAttachment.vertices;
|
||||
for (var i_14 = 0; i_14 < vertexCount; i_14++) {
|
||||
var prev = prevVertices[i_14];
|
||||
vertices[i_14] += (prev + (nextVertices[i_14] - prev) * percent - setupVertices[i_14]) * alpha;
|
||||
deform[i_14] += (prev + (nextVertices[i_14] - prev) * percent - setupVertices[i_14]) * alpha;
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (var i_15 = 0; i_15 < vertexCount; i_15++) {
|
||||
var prev = prevVertices[i_15];
|
||||
vertices[i_15] += (prev + (nextVertices[i_15] - prev) * percent) * alpha;
|
||||
deform[i_15] += (prev + (nextVertices[i_15] - prev) * percent) * alpha;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1415,7 +1415,7 @@ var spine;
|
||||
var timelinesRotation = current.timelinesRotation;
|
||||
for (var ii = 0; ii < timelineCount; ii++) {
|
||||
var timeline = timelines[ii];
|
||||
var timelineBlend = timelineMode[ii] == AnimationState.SUBSEQUENT ? blend : spine.MixBlend.setup;
|
||||
var timelineBlend = (timelineMode[ii] & (AnimationState.NOT_LAST - 1)) == AnimationState.SUBSEQUENT ? blend : spine.MixBlend.setup;
|
||||
if (timeline instanceof spine.RotateTimeline) {
|
||||
this.applyRotateTimeline(timeline, skeleton, animationTime, mix, timelineBlend, timelinesRotation, ii << 1, firstFrame);
|
||||
}
|
||||
@ -1473,7 +1473,7 @@ var spine;
|
||||
var direction = spine.MixDirection.out;
|
||||
var timelineBlend = void 0;
|
||||
var alpha = 0;
|
||||
switch (timelineMode[i]) {
|
||||
switch (timelineMode[i] & (AnimationState.NOT_LAST - 1)) {
|
||||
case AnimationState.SUBSEQUENT:
|
||||
if (!attachments && timeline instanceof spine.AttachmentTimeline)
|
||||
continue;
|
||||
@ -1503,12 +1503,12 @@ var spine;
|
||||
spine.Utils.webkit602BugfixHelper(alpha, blend);
|
||||
if (timelineBlend == spine.MixBlend.setup) {
|
||||
if (timeline instanceof spine.AttachmentTimeline) {
|
||||
if (attachments)
|
||||
direction = spine.MixDirection.out;
|
||||
if (attachments || (timelineMode[i] & AnimationState.NOT_LAST) == AnimationState.NOT_LAST)
|
||||
direction = spine.MixDirection["in"];
|
||||
}
|
||||
else if (timeline instanceof spine.DrawOrderTimeline) {
|
||||
if (drawOrder)
|
||||
direction = spine.MixDirection.out;
|
||||
direction = spine.MixDirection["in"];
|
||||
}
|
||||
}
|
||||
timeline.apply(skeleton, animationLast, animationTime, events, alpha, timelineBlend, direction);
|
||||
@ -1803,12 +1803,20 @@ var spine;
|
||||
entry = entry.mixingFrom;
|
||||
do {
|
||||
if (entry.mixingFrom == null || entry.mixBlend != spine.MixBlend.add)
|
||||
this.setTimelineModes(entry);
|
||||
this.computeHold(entry);
|
||||
entry = entry.mixingTo;
|
||||
} while (entry != null);
|
||||
}
|
||||
this.propertyIDs.clear();
|
||||
for (var i = this.tracks.length - 1; i >= 0; i--) {
|
||||
var entry = this.tracks[i];
|
||||
while (entry != null) {
|
||||
this.computeNotLast(entry);
|
||||
entry = entry.mixingFrom;
|
||||
}
|
||||
}
|
||||
};
|
||||
AnimationState.prototype.setTimelineModes = function (entry) {
|
||||
AnimationState.prototype.computeHold = function (entry) {
|
||||
var to = entry.mixingTo;
|
||||
var timelines = entry.animation.timelines;
|
||||
var timelinesCount = entry.animation.timelines.length;
|
||||
@ -1824,11 +1832,14 @@ var spine;
|
||||
return;
|
||||
}
|
||||
outer: for (var i = 0; i < timelinesCount; i++) {
|
||||
var id = timelines[i].getPropertyId();
|
||||
var timeline = timelines[i];
|
||||
var id = timeline.getPropertyId();
|
||||
if (!propertyIDs.add(id))
|
||||
timelineMode[i] = AnimationState.SUBSEQUENT;
|
||||
else if (to == null || !this.hasTimeline(to, id))
|
||||
else if (to == null || timeline instanceof spine.AttachmentTimeline || timeline instanceof spine.DrawOrderTimeline
|
||||
|| timeline instanceof spine.EventTimeline || !this.hasTimeline(to, id)) {
|
||||
timelineMode[i] = AnimationState.FIRST;
|
||||
}
|
||||
else {
|
||||
for (var next = to.mixingTo; next != null; next = next.mixingTo) {
|
||||
if (this.hasTimeline(next, id))
|
||||
@ -1844,6 +1855,19 @@ var spine;
|
||||
}
|
||||
}
|
||||
};
|
||||
AnimationState.prototype.computeNotLast = function (entry) {
|
||||
var timelines = entry.animation.timelines;
|
||||
var timelinesCount = entry.animation.timelines.length;
|
||||
var timelineMode = entry.timelineMode;
|
||||
var propertyIDs = this.propertyIDs;
|
||||
for (var i = 0; i < timelinesCount; i++) {
|
||||
if (timelines[i] instanceof spine.AttachmentTimeline) {
|
||||
var timeline = timelines[i];
|
||||
if (!propertyIDs.add(timeline.slotIndex))
|
||||
timelineMode[i] |= AnimationState.NOT_LAST;
|
||||
}
|
||||
}
|
||||
};
|
||||
AnimationState.prototype.hasTimeline = function (entry, id) {
|
||||
var timelines = entry.animation.timelines;
|
||||
for (var i = 0, n = timelines.length; i < n; i++)
|
||||
@ -1877,6 +1901,7 @@ var spine;
|
||||
AnimationState.FIRST = 1;
|
||||
AnimationState.HOLD = 2;
|
||||
AnimationState.HOLD_MIX = 3;
|
||||
AnimationState.NOT_LAST = 4;
|
||||
return AnimationState;
|
||||
}());
|
||||
spine.AnimationState = AnimationState;
|
||||
@ -5263,7 +5288,7 @@ var spine;
|
||||
(function (spine) {
|
||||
var Slot = (function () {
|
||||
function Slot(data, bone) {
|
||||
this.attachmentVertices = new Array();
|
||||
this.deform = new Array();
|
||||
if (data == null)
|
||||
throw new Error("data cannot be null.");
|
||||
if (bone == null)
|
||||
@ -5282,7 +5307,7 @@ var spine;
|
||||
return;
|
||||
this.attachment = attachment;
|
||||
this.attachmentTime = this.bone.skeleton.time;
|
||||
this.attachmentVertices.length = 0;
|
||||
this.deform.length = 0;
|
||||
};
|
||||
Slot.prototype.setAttachmentTime = function (time) {
|
||||
this.attachmentTime = this.bone.skeleton.time - time;
|
||||
@ -6437,7 +6462,7 @@ var spine;
|
||||
VertexAttachment.prototype.computeWorldVertices = function (slot, start, count, worldVertices, offset, stride) {
|
||||
count = offset + (count >> 1) * stride;
|
||||
var skeleton = slot.bone.skeleton;
|
||||
var deformArray = slot.attachmentVertices;
|
||||
var deformArray = slot.deform;
|
||||
var vertices = this.vertices;
|
||||
var bones = this.bones;
|
||||
if (bones == null) {
|
||||
|
||||
File diff suppressed because one or more lines are too long
6
spine-ts/build/spine-webgl.d.ts
vendored
6
spine-ts/build/spine-webgl.d.ts
vendored
@ -246,6 +246,7 @@ declare module spine {
|
||||
static FIRST: number;
|
||||
static HOLD: number;
|
||||
static HOLD_MIX: number;
|
||||
static NOT_LAST: number;
|
||||
data: AnimationStateData;
|
||||
tracks: TrackEntry[];
|
||||
events: Event[];
|
||||
@ -276,7 +277,8 @@ declare module spine {
|
||||
trackEntry(trackIndex: number, animation: Animation, loop: boolean, last: TrackEntry): TrackEntry;
|
||||
disposeNext(entry: TrackEntry): void;
|
||||
_animationsChanged(): void;
|
||||
setTimelineModes(entry: TrackEntry): void;
|
||||
computeHold(entry: TrackEntry): void;
|
||||
computeNotLast(entry: TrackEntry): void;
|
||||
hasTimeline(entry: TrackEntry, id: number): boolean;
|
||||
getCurrent(trackIndex: number): TrackEntry;
|
||||
addListener(listener: AnimationStateListener2): void;
|
||||
@ -784,7 +786,7 @@ declare module spine {
|
||||
darkColor: Color;
|
||||
private attachment;
|
||||
private attachmentTime;
|
||||
attachmentVertices: number[];
|
||||
deform: number[];
|
||||
constructor(data: SlotData, bone: Bone);
|
||||
getAttachment(): Attachment;
|
||||
setAttachment(attachment: Attachment): void;
|
||||
|
||||
@ -700,8 +700,8 @@ var spine;
|
||||
var slotAttachment = slot.getAttachment();
|
||||
if (!(slotAttachment instanceof spine.VertexAttachment) || !slotAttachment.applyDeform(this.attachment))
|
||||
return;
|
||||
var verticesArray = slot.attachmentVertices;
|
||||
if (verticesArray.length == 0)
|
||||
var deformArray = slot.deform;
|
||||
if (deformArray.length == 0)
|
||||
blend = MixBlend.setup;
|
||||
var frameVertices = this.frameVertices;
|
||||
var vertexCount = frameVertices[0].length;
|
||||
@ -710,28 +710,28 @@ var spine;
|
||||
var vertexAttachment = slotAttachment;
|
||||
switch (blend) {
|
||||
case MixBlend.setup:
|
||||
verticesArray.length = 0;
|
||||
deformArray.length = 0;
|
||||
return;
|
||||
case MixBlend.first:
|
||||
if (alpha == 1) {
|
||||
verticesArray.length = 0;
|
||||
deformArray.length = 0;
|
||||
break;
|
||||
}
|
||||
var vertices_1 = spine.Utils.setArraySize(verticesArray, vertexCount);
|
||||
var deform_1 = spine.Utils.setArraySize(deformArray, vertexCount);
|
||||
if (vertexAttachment.bones == null) {
|
||||
var setupVertices = vertexAttachment.vertices;
|
||||
for (var i = 0; i < vertexCount; i++)
|
||||
vertices_1[i] += (setupVertices[i] - vertices_1[i]) * alpha;
|
||||
deform_1[i] += (setupVertices[i] - deform_1[i]) * alpha;
|
||||
}
|
||||
else {
|
||||
alpha = 1 - alpha;
|
||||
for (var i = 0; i < vertexCount; i++)
|
||||
vertices_1[i] *= alpha;
|
||||
deform_1[i] *= alpha;
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
var vertices = spine.Utils.setArraySize(verticesArray, vertexCount);
|
||||
var deform = spine.Utils.setArraySize(deformArray, vertexCount);
|
||||
if (time >= frames[frames.length - 1]) {
|
||||
var lastVertices = frameVertices[frames.length - 1];
|
||||
if (alpha == 1) {
|
||||
@ -740,16 +740,16 @@ var spine;
|
||||
if (vertexAttachment.bones == null) {
|
||||
var setupVertices = vertexAttachment.vertices;
|
||||
for (var i_1 = 0; i_1 < vertexCount; i_1++) {
|
||||
vertices[i_1] += lastVertices[i_1] - setupVertices[i_1];
|
||||
deform[i_1] += lastVertices[i_1] - setupVertices[i_1];
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (var i_2 = 0; i_2 < vertexCount; i_2++)
|
||||
vertices[i_2] += lastVertices[i_2];
|
||||
deform[i_2] += lastVertices[i_2];
|
||||
}
|
||||
}
|
||||
else {
|
||||
spine.Utils.arrayCopy(lastVertices, 0, vertices, 0, vertexCount);
|
||||
spine.Utils.arrayCopy(lastVertices, 0, deform, 0, vertexCount);
|
||||
}
|
||||
}
|
||||
else {
|
||||
@ -760,30 +760,30 @@ var spine;
|
||||
var setupVertices = vertexAttachment_1.vertices;
|
||||
for (var i_3 = 0; i_3 < vertexCount; i_3++) {
|
||||
var setup = setupVertices[i_3];
|
||||
vertices[i_3] = setup + (lastVertices[i_3] - setup) * alpha;
|
||||
deform[i_3] = setup + (lastVertices[i_3] - setup) * alpha;
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (var i_4 = 0; i_4 < vertexCount; i_4++)
|
||||
vertices[i_4] = lastVertices[i_4] * alpha;
|
||||
deform[i_4] = lastVertices[i_4] * alpha;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case MixBlend.first:
|
||||
case MixBlend.replace:
|
||||
for (var i_5 = 0; i_5 < vertexCount; i_5++)
|
||||
vertices[i_5] += (lastVertices[i_5] - vertices[i_5]) * alpha;
|
||||
deform[i_5] += (lastVertices[i_5] - deform[i_5]) * alpha;
|
||||
case MixBlend.add:
|
||||
var vertexAttachment = slotAttachment;
|
||||
if (vertexAttachment.bones == null) {
|
||||
var setupVertices = vertexAttachment.vertices;
|
||||
for (var i_6 = 0; i_6 < vertexCount; i_6++) {
|
||||
vertices[i_6] += (lastVertices[i_6] - setupVertices[i_6]) * alpha;
|
||||
deform[i_6] += (lastVertices[i_6] - setupVertices[i_6]) * alpha;
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (var i_7 = 0; i_7 < vertexCount; i_7++)
|
||||
vertices[i_7] += lastVertices[i_7] * alpha;
|
||||
deform[i_7] += lastVertices[i_7] * alpha;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -801,20 +801,20 @@ var spine;
|
||||
var setupVertices = vertexAttachment.vertices;
|
||||
for (var i_8 = 0; i_8 < vertexCount; i_8++) {
|
||||
var prev = prevVertices[i_8];
|
||||
vertices[i_8] += prev + (nextVertices[i_8] - prev) * percent - setupVertices[i_8];
|
||||
deform[i_8] += prev + (nextVertices[i_8] - prev) * percent - setupVertices[i_8];
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (var i_9 = 0; i_9 < vertexCount; i_9++) {
|
||||
var prev = prevVertices[i_9];
|
||||
vertices[i_9] += prev + (nextVertices[i_9] - prev) * percent;
|
||||
deform[i_9] += prev + (nextVertices[i_9] - prev) * percent;
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (var i_10 = 0; i_10 < vertexCount; i_10++) {
|
||||
var prev = prevVertices[i_10];
|
||||
vertices[i_10] = prev + (nextVertices[i_10] - prev) * percent;
|
||||
deform[i_10] = prev + (nextVertices[i_10] - prev) * percent;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -826,13 +826,13 @@ var spine;
|
||||
var setupVertices = vertexAttachment_2.vertices;
|
||||
for (var i_11 = 0; i_11 < vertexCount; i_11++) {
|
||||
var prev = prevVertices[i_11], setup = setupVertices[i_11];
|
||||
vertices[i_11] = setup + (prev + (nextVertices[i_11] - prev) * percent - setup) * alpha;
|
||||
deform[i_11] = setup + (prev + (nextVertices[i_11] - prev) * percent - setup) * alpha;
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (var i_12 = 0; i_12 < vertexCount; i_12++) {
|
||||
var prev = prevVertices[i_12];
|
||||
vertices[i_12] = (prev + (nextVertices[i_12] - prev) * percent) * alpha;
|
||||
deform[i_12] = (prev + (nextVertices[i_12] - prev) * percent) * alpha;
|
||||
}
|
||||
}
|
||||
break;
|
||||
@ -841,7 +841,7 @@ var spine;
|
||||
case MixBlend.replace:
|
||||
for (var i_13 = 0; i_13 < vertexCount; i_13++) {
|
||||
var prev = prevVertices[i_13];
|
||||
vertices[i_13] += (prev + (nextVertices[i_13] - prev) * percent - vertices[i_13]) * alpha;
|
||||
deform[i_13] += (prev + (nextVertices[i_13] - prev) * percent - deform[i_13]) * alpha;
|
||||
}
|
||||
break;
|
||||
case MixBlend.add:
|
||||
@ -850,13 +850,13 @@ var spine;
|
||||
var setupVertices = vertexAttachment.vertices;
|
||||
for (var i_14 = 0; i_14 < vertexCount; i_14++) {
|
||||
var prev = prevVertices[i_14];
|
||||
vertices[i_14] += (prev + (nextVertices[i_14] - prev) * percent - setupVertices[i_14]) * alpha;
|
||||
deform[i_14] += (prev + (nextVertices[i_14] - prev) * percent - setupVertices[i_14]) * alpha;
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (var i_15 = 0; i_15 < vertexCount; i_15++) {
|
||||
var prev = prevVertices[i_15];
|
||||
vertices[i_15] += (prev + (nextVertices[i_15] - prev) * percent) * alpha;
|
||||
deform[i_15] += (prev + (nextVertices[i_15] - prev) * percent) * alpha;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -1415,7 +1415,7 @@ var spine;
|
||||
var timelinesRotation = current.timelinesRotation;
|
||||
for (var ii = 0; ii < timelineCount; ii++) {
|
||||
var timeline = timelines[ii];
|
||||
var timelineBlend = timelineMode[ii] == AnimationState.SUBSEQUENT ? blend : spine.MixBlend.setup;
|
||||
var timelineBlend = (timelineMode[ii] & (AnimationState.NOT_LAST - 1)) == AnimationState.SUBSEQUENT ? blend : spine.MixBlend.setup;
|
||||
if (timeline instanceof spine.RotateTimeline) {
|
||||
this.applyRotateTimeline(timeline, skeleton, animationTime, mix, timelineBlend, timelinesRotation, ii << 1, firstFrame);
|
||||
}
|
||||
@ -1473,7 +1473,7 @@ var spine;
|
||||
var direction = spine.MixDirection.out;
|
||||
var timelineBlend = void 0;
|
||||
var alpha = 0;
|
||||
switch (timelineMode[i]) {
|
||||
switch (timelineMode[i] & (AnimationState.NOT_LAST - 1)) {
|
||||
case AnimationState.SUBSEQUENT:
|
||||
if (!attachments && timeline instanceof spine.AttachmentTimeline)
|
||||
continue;
|
||||
@ -1503,12 +1503,12 @@ var spine;
|
||||
spine.Utils.webkit602BugfixHelper(alpha, blend);
|
||||
if (timelineBlend == spine.MixBlend.setup) {
|
||||
if (timeline instanceof spine.AttachmentTimeline) {
|
||||
if (attachments)
|
||||
direction = spine.MixDirection.out;
|
||||
if (attachments || (timelineMode[i] & AnimationState.NOT_LAST) == AnimationState.NOT_LAST)
|
||||
direction = spine.MixDirection["in"];
|
||||
}
|
||||
else if (timeline instanceof spine.DrawOrderTimeline) {
|
||||
if (drawOrder)
|
||||
direction = spine.MixDirection.out;
|
||||
direction = spine.MixDirection["in"];
|
||||
}
|
||||
}
|
||||
timeline.apply(skeleton, animationLast, animationTime, events, alpha, timelineBlend, direction);
|
||||
@ -1803,12 +1803,20 @@ var spine;
|
||||
entry = entry.mixingFrom;
|
||||
do {
|
||||
if (entry.mixingFrom == null || entry.mixBlend != spine.MixBlend.add)
|
||||
this.setTimelineModes(entry);
|
||||
this.computeHold(entry);
|
||||
entry = entry.mixingTo;
|
||||
} while (entry != null);
|
||||
}
|
||||
this.propertyIDs.clear();
|
||||
for (var i = this.tracks.length - 1; i >= 0; i--) {
|
||||
var entry = this.tracks[i];
|
||||
while (entry != null) {
|
||||
this.computeNotLast(entry);
|
||||
entry = entry.mixingFrom;
|
||||
}
|
||||
}
|
||||
};
|
||||
AnimationState.prototype.setTimelineModes = function (entry) {
|
||||
AnimationState.prototype.computeHold = function (entry) {
|
||||
var to = entry.mixingTo;
|
||||
var timelines = entry.animation.timelines;
|
||||
var timelinesCount = entry.animation.timelines.length;
|
||||
@ -1824,11 +1832,14 @@ var spine;
|
||||
return;
|
||||
}
|
||||
outer: for (var i = 0; i < timelinesCount; i++) {
|
||||
var id = timelines[i].getPropertyId();
|
||||
var timeline = timelines[i];
|
||||
var id = timeline.getPropertyId();
|
||||
if (!propertyIDs.add(id))
|
||||
timelineMode[i] = AnimationState.SUBSEQUENT;
|
||||
else if (to == null || !this.hasTimeline(to, id))
|
||||
else if (to == null || timeline instanceof spine.AttachmentTimeline || timeline instanceof spine.DrawOrderTimeline
|
||||
|| timeline instanceof spine.EventTimeline || !this.hasTimeline(to, id)) {
|
||||
timelineMode[i] = AnimationState.FIRST;
|
||||
}
|
||||
else {
|
||||
for (var next = to.mixingTo; next != null; next = next.mixingTo) {
|
||||
if (this.hasTimeline(next, id))
|
||||
@ -1844,6 +1855,19 @@ var spine;
|
||||
}
|
||||
}
|
||||
};
|
||||
AnimationState.prototype.computeNotLast = function (entry) {
|
||||
var timelines = entry.animation.timelines;
|
||||
var timelinesCount = entry.animation.timelines.length;
|
||||
var timelineMode = entry.timelineMode;
|
||||
var propertyIDs = this.propertyIDs;
|
||||
for (var i = 0; i < timelinesCount; i++) {
|
||||
if (timelines[i] instanceof spine.AttachmentTimeline) {
|
||||
var timeline = timelines[i];
|
||||
if (!propertyIDs.add(timeline.slotIndex))
|
||||
timelineMode[i] |= AnimationState.NOT_LAST;
|
||||
}
|
||||
}
|
||||
};
|
||||
AnimationState.prototype.hasTimeline = function (entry, id) {
|
||||
var timelines = entry.animation.timelines;
|
||||
for (var i = 0, n = timelines.length; i < n; i++)
|
||||
@ -1877,6 +1901,7 @@ var spine;
|
||||
AnimationState.FIRST = 1;
|
||||
AnimationState.HOLD = 2;
|
||||
AnimationState.HOLD_MIX = 3;
|
||||
AnimationState.NOT_LAST = 4;
|
||||
return AnimationState;
|
||||
}());
|
||||
spine.AnimationState = AnimationState;
|
||||
@ -5263,7 +5288,7 @@ var spine;
|
||||
(function (spine) {
|
||||
var Slot = (function () {
|
||||
function Slot(data, bone) {
|
||||
this.attachmentVertices = new Array();
|
||||
this.deform = new Array();
|
||||
if (data == null)
|
||||
throw new Error("data cannot be null.");
|
||||
if (bone == null)
|
||||
@ -5282,7 +5307,7 @@ var spine;
|
||||
return;
|
||||
this.attachment = attachment;
|
||||
this.attachmentTime = this.bone.skeleton.time;
|
||||
this.attachmentVertices.length = 0;
|
||||
this.deform.length = 0;
|
||||
};
|
||||
Slot.prototype.setAttachmentTime = function (time) {
|
||||
this.attachmentTime = this.bone.skeleton.time - time;
|
||||
@ -6437,7 +6462,7 @@ var spine;
|
||||
VertexAttachment.prototype.computeWorldVertices = function (slot, start, count, worldVertices, offset, stride) {
|
||||
count = offset + (count >> 1) * stride;
|
||||
var skeleton = slot.bone.skeleton;
|
||||
var deformArray = slot.attachmentVertices;
|
||||
var deformArray = slot.deform;
|
||||
var vertices = this.vertices;
|
||||
var bones = this.bones;
|
||||
if (bones == null) {
|
||||
|
||||
File diff suppressed because one or more lines are too long
@ -758,8 +758,8 @@ module spine {
|
||||
let slotAttachment: Attachment = slot.getAttachment();
|
||||
if (!(slotAttachment instanceof VertexAttachment) || !(<VertexAttachment>slotAttachment).applyDeform(this.attachment)) return;
|
||||
|
||||
let verticesArray: Array<number> = slot.attachmentVertices;
|
||||
if (verticesArray.length == 0) blend = MixBlend.setup;
|
||||
let deformArray: Array<number> = slot.deform;
|
||||
if (deformArray.length == 0) blend = MixBlend.setup;
|
||||
|
||||
let frameVertices = this.frameVertices;
|
||||
let vertexCount = frameVertices[0].length;
|
||||
@ -769,30 +769,30 @@ module spine {
|
||||
let vertexAttachment = <VertexAttachment>slotAttachment;
|
||||
switch (blend) {
|
||||
case MixBlend.setup:
|
||||
verticesArray.length = 0;
|
||||
deformArray.length = 0;
|
||||
return;
|
||||
case MixBlend.first:
|
||||
if (alpha == 1) {
|
||||
verticesArray.length = 0;
|
||||
deformArray.length = 0;
|
||||
break;
|
||||
}
|
||||
let vertices: Array<number> = Utils.setArraySize(verticesArray, vertexCount);
|
||||
let deform: Array<number> = Utils.setArraySize(deformArray, vertexCount);
|
||||
if (vertexAttachment.bones == null) {
|
||||
// Unweighted vertex positions.
|
||||
let setupVertices = vertexAttachment.vertices;
|
||||
for (var i = 0; i < vertexCount; i++)
|
||||
vertices[i] += (setupVertices[i] - vertices[i]) * alpha;
|
||||
deform[i] += (setupVertices[i] - deform[i]) * alpha;
|
||||
} else {
|
||||
// Weighted deform offsets.
|
||||
alpha = 1 - alpha;
|
||||
for (var i = 0; i < vertexCount; i++)
|
||||
vertices[i] *= alpha;
|
||||
deform[i] *= alpha;
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
let vertices: Array<number> = Utils.setArraySize(verticesArray, vertexCount);
|
||||
let deform: Array<number> = Utils.setArraySize(deformArray, vertexCount);
|
||||
if (time >= frames[frames.length - 1]) { // Time is after last frame.
|
||||
let lastVertices = frameVertices[frames.length - 1];
|
||||
if (alpha == 1) {
|
||||
@ -802,15 +802,15 @@ module spine {
|
||||
// Unweighted vertex positions, with alpha.
|
||||
let setupVertices = vertexAttachment.vertices;
|
||||
for (let i = 0; i < vertexCount; i++) {
|
||||
vertices[i] += lastVertices[i] - setupVertices[i];
|
||||
deform[i] += lastVertices[i] - setupVertices[i];
|
||||
}
|
||||
} else {
|
||||
// Weighted deform offsets, with alpha.
|
||||
for (let i = 0; i < vertexCount; i++)
|
||||
vertices[i] += lastVertices[i];
|
||||
deform[i] += lastVertices[i];
|
||||
}
|
||||
} else {
|
||||
Utils.arrayCopy(lastVertices, 0, vertices, 0, vertexCount);
|
||||
Utils.arrayCopy(lastVertices, 0, deform, 0, vertexCount);
|
||||
}
|
||||
} else {
|
||||
switch (blend) {
|
||||
@ -821,31 +821,31 @@ module spine {
|
||||
let setupVertices = vertexAttachment.vertices;
|
||||
for (let i = 0; i < vertexCount; i++) {
|
||||
let setup = setupVertices[i];
|
||||
vertices[i] = setup + (lastVertices[i] - setup) * alpha;
|
||||
deform[i] = setup + (lastVertices[i] - setup) * alpha;
|
||||
}
|
||||
} else {
|
||||
// Weighted deform offsets, with alpha.
|
||||
for (let i = 0; i < vertexCount; i++)
|
||||
vertices[i] = lastVertices[i] * alpha;
|
||||
deform[i] = lastVertices[i] * alpha;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case MixBlend.first:
|
||||
case MixBlend.replace:
|
||||
for (let i = 0; i < vertexCount; i++)
|
||||
vertices[i] += (lastVertices[i] - vertices[i]) * alpha;
|
||||
deform[i] += (lastVertices[i] - deform[i]) * alpha;
|
||||
case MixBlend.add:
|
||||
let vertexAttachment = slotAttachment as VertexAttachment;
|
||||
if (vertexAttachment.bones == null) {
|
||||
// Unweighted vertex positions, with alpha.
|
||||
let setupVertices = vertexAttachment.vertices;
|
||||
for (let i = 0; i < vertexCount; i++) {
|
||||
vertices[i] += (lastVertices[i] - setupVertices[i]) * alpha;
|
||||
deform[i] += (lastVertices[i] - setupVertices[i]) * alpha;
|
||||
}
|
||||
} else {
|
||||
// Weighted deform offsets, with alpha.
|
||||
for (let i = 0; i < vertexCount; i++)
|
||||
vertices[i] += lastVertices[i] * alpha;
|
||||
deform[i] += lastVertices[i] * alpha;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -867,19 +867,19 @@ module spine {
|
||||
let setupVertices = vertexAttachment.vertices;
|
||||
for (let i = 0; i < vertexCount; i++) {
|
||||
let prev = prevVertices[i];
|
||||
vertices[i] += prev + (nextVertices[i] - prev) * percent - setupVertices[i];
|
||||
deform[i] += prev + (nextVertices[i] - prev) * percent - setupVertices[i];
|
||||
}
|
||||
} else {
|
||||
// Weighted deform offsets, with alpha.
|
||||
for (let i = 0; i < vertexCount; i++) {
|
||||
let prev = prevVertices[i];
|
||||
vertices[i] += prev + (nextVertices[i] - prev) * percent;
|
||||
deform[i] += prev + (nextVertices[i] - prev) * percent;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
for (let i = 0; i < vertexCount; i++) {
|
||||
let prev = prevVertices[i];
|
||||
vertices[i] = prev + (nextVertices[i] - prev) * percent;
|
||||
deform[i] = prev + (nextVertices[i] - prev) * percent;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
@ -891,13 +891,13 @@ module spine {
|
||||
let setupVertices = vertexAttachment.vertices;
|
||||
for (let i = 0; i < vertexCount; i++) {
|
||||
let prev = prevVertices[i], setup = setupVertices[i];
|
||||
vertices[i] = setup + (prev + (nextVertices[i] - prev) * percent - setup) * alpha;
|
||||
deform[i] = setup + (prev + (nextVertices[i] - prev) * percent - setup) * alpha;
|
||||
}
|
||||
} else {
|
||||
// Weighted deform offsets, with alpha.
|
||||
for (let i = 0; i < vertexCount; i++) {
|
||||
let prev = prevVertices[i];
|
||||
vertices[i] = (prev + (nextVertices[i] - prev) * percent) * alpha;
|
||||
deform[i] = (prev + (nextVertices[i] - prev) * percent) * alpha;
|
||||
}
|
||||
}
|
||||
break;
|
||||
@ -906,7 +906,7 @@ module spine {
|
||||
case MixBlend.replace:
|
||||
for (let i = 0; i < vertexCount; i++) {
|
||||
let prev = prevVertices[i];
|
||||
vertices[i] += (prev + (nextVertices[i] - prev) * percent - vertices[i]) * alpha;
|
||||
deform[i] += (prev + (nextVertices[i] - prev) * percent - deform[i]) * alpha;
|
||||
}
|
||||
break;
|
||||
case MixBlend.add:
|
||||
@ -916,13 +916,13 @@ module spine {
|
||||
let setupVertices = vertexAttachment.vertices;
|
||||
for (let i = 0; i < vertexCount; i++) {
|
||||
let prev = prevVertices[i];
|
||||
vertices[i] += (prev + (nextVertices[i] - prev) * percent - setupVertices[i]) * alpha;
|
||||
deform[i] += (prev + (nextVertices[i] - prev) * percent - setupVertices[i]) * alpha;
|
||||
}
|
||||
} else {
|
||||
// Weighted deform offsets, with alpha.
|
||||
for (let i = 0; i < vertexCount; i++) {
|
||||
let prev = prevVertices[i];
|
||||
vertices[i] += (prev + (nextVertices[i] - prev) * percent) * alpha;
|
||||
deform[i] += (prev + (nextVertices[i] - prev) * percent) * alpha;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -35,6 +35,7 @@ module spine {
|
||||
static FIRST = 1;
|
||||
static HOLD = 2;
|
||||
static HOLD_MIX = 3;
|
||||
static NOT_LAST = 4;
|
||||
|
||||
data: AnimationStateData;
|
||||
tracks = new Array<TrackEntry>();
|
||||
@ -171,7 +172,7 @@ module spine {
|
||||
|
||||
for (let ii = 0; ii < timelineCount; ii++) {
|
||||
let timeline = timelines[ii];
|
||||
let timelineBlend = timelineMode[ii] == AnimationState.SUBSEQUENT ? blend : MixBlend.setup;
|
||||
let timelineBlend = (timelineMode[ii] & (AnimationState.NOT_LAST - 1)) == AnimationState.SUBSEQUENT ? blend : MixBlend.setup;
|
||||
if (timeline instanceof RotateTimeline) {
|
||||
this.applyRotateTimeline(timeline, skeleton, animationTime, mix, timelineBlend, timelinesRotation, ii << 1, firstFrame);
|
||||
} else {
|
||||
@ -228,7 +229,7 @@ module spine {
|
||||
let direction = MixDirection.out;
|
||||
let timelineBlend: MixBlend;
|
||||
let alpha = 0;
|
||||
switch (timelineMode[i]) {
|
||||
switch (timelineMode[i] & (AnimationState.NOT_LAST - 1)) {
|
||||
case AnimationState.SUBSEQUENT:
|
||||
if (!attachments && timeline instanceof AttachmentTimeline) continue;
|
||||
if (!drawOrder && timeline instanceof DrawOrderTimeline) continue;
|
||||
@ -257,9 +258,9 @@ module spine {
|
||||
Utils.webkit602BugfixHelper(alpha, blend);
|
||||
if (timelineBlend == MixBlend.setup) {
|
||||
if (timeline instanceof AttachmentTimeline) {
|
||||
if (attachments) direction = MixDirection.out;
|
||||
if (attachments || (timelineMode[i] & AnimationState.NOT_LAST) == AnimationState.NOT_LAST) direction = MixDirection.in;
|
||||
} else if (timeline instanceof DrawOrderTimeline) {
|
||||
if (drawOrder) direction = MixDirection.out;
|
||||
if (drawOrder) direction = MixDirection.in;
|
||||
}
|
||||
}
|
||||
timeline.apply(skeleton, animationLast, animationTime, events, alpha, timelineBlend, direction);
|
||||
@ -584,13 +585,22 @@ module spine {
|
||||
entry = entry.mixingFrom;
|
||||
|
||||
do {
|
||||
if (entry.mixingFrom == null || entry.mixBlend != MixBlend.add) this.setTimelineModes(entry);
|
||||
if (entry.mixingFrom == null || entry.mixBlend != MixBlend.add) this.computeHold(entry);
|
||||
entry = entry.mixingTo;
|
||||
} while (entry != null)
|
||||
}
|
||||
|
||||
this.propertyIDs.clear();
|
||||
for (let i = this.tracks.length - 1; i >= 0; i--) {
|
||||
let entry = this.tracks[i];
|
||||
while (entry != null) {
|
||||
this.computeNotLast(entry);
|
||||
entry = entry.mixingFrom;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
setTimelineModes (entry: TrackEntry) {
|
||||
computeHold (entry: TrackEntry) {
|
||||
let to = entry.mixingTo;
|
||||
let timelines = entry.animation.timelines;
|
||||
let timelinesCount = entry.animation.timelines.length;
|
||||
@ -609,12 +619,14 @@ module spine {
|
||||
|
||||
outer:
|
||||
for (let i = 0; i < timelinesCount; i++) {
|
||||
let id = timelines[i].getPropertyId();
|
||||
let timeline = timelines[i];
|
||||
let id = timeline.getPropertyId();
|
||||
if (!propertyIDs.add(id))
|
||||
timelineMode[i] = AnimationState.SUBSEQUENT;
|
||||
else if (to == null || !this.hasTimeline(to, id))
|
||||
else if (to == null || timeline instanceof AttachmentTimeline || timeline instanceof DrawOrderTimeline
|
||||
|| timeline instanceof EventTimeline || !this.hasTimeline(to, id)) {
|
||||
timelineMode[i] = AnimationState.FIRST;
|
||||
else {
|
||||
} else {
|
||||
for (let next = to.mixingTo; next != null; next = next.mixingTo) {
|
||||
if (this.hasTimeline(next, id)) continue;
|
||||
if (entry.mixDuration > 0) {
|
||||
@ -629,6 +641,20 @@ module spine {
|
||||
}
|
||||
}
|
||||
|
||||
computeNotLast (entry: TrackEntry) {
|
||||
let timelines = entry.animation.timelines;
|
||||
let timelinesCount = entry.animation.timelines.length;
|
||||
let timelineMode = entry.timelineMode;
|
||||
let propertyIDs = this.propertyIDs;
|
||||
|
||||
for (let i = 0; i < timelinesCount; i++) {
|
||||
if (timelines[i] instanceof AttachmentTimeline) {
|
||||
let timeline = timelines[i] as AttachmentTimeline;
|
||||
if (!propertyIDs.add(timeline.slotIndex)) timelineMode[i] |= AnimationState.NOT_LAST;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
hasTimeline (entry: TrackEntry, id: number) : boolean {
|
||||
let timelines = entry.animation.timelines;
|
||||
for (let i = 0, n = timelines.length; i < n; i++)
|
||||
|
||||
@ -36,7 +36,7 @@ module spine {
|
||||
darkColor: Color;
|
||||
private attachment: Attachment;
|
||||
private attachmentTime: number;
|
||||
attachmentVertices = new Array<number>();
|
||||
deform = new Array<number>();
|
||||
|
||||
constructor (data: SlotData, bone: Bone) {
|
||||
if (data == null) throw new Error("data cannot be null.");
|
||||
@ -59,7 +59,7 @@ module spine {
|
||||
if (this.attachment == attachment) return;
|
||||
this.attachment = attachment;
|
||||
this.attachmentTime = this.bone.skeleton.time;
|
||||
this.attachmentVertices.length = 0;
|
||||
this.deform.length = 0;
|
||||
}
|
||||
|
||||
setAttachmentTime (time: number) {
|
||||
|
||||
@ -58,7 +58,7 @@ module spine {
|
||||
computeWorldVertices (slot: Slot, start: number, count: number, worldVertices: ArrayLike<number>, offset: number, stride: number) {
|
||||
count = offset + (count >> 1) * stride;
|
||||
let skeleton = slot.bone.skeleton;
|
||||
let deformArray = slot.attachmentVertices;
|
||||
let deformArray = slot.deform;
|
||||
let vertices = this.vertices;
|
||||
let bones = this.bones;
|
||||
if (bones == null) {
|
||||
|
||||
@ -40,8 +40,6 @@ function init() {
|
||||
requestAnimationFrame(load);
|
||||
}
|
||||
|
||||
alert("blah");
|
||||
|
||||
var run = true;
|
||||
|
||||
function switchAnimation() {
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user