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

[as3] Ported additive blending. See #1029, #1060

Browse Source
This commit is contained in:
badlogic 2018-01-23 15:45:33 +01:00
parent b7e712d3ca
commit 6a556de014
29 changed files with 456 additions and 222 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
spine-as3/spine-as3-example/lib/spine-as3.swc
View File

Binary file not shown.

26
spine-as3/spine-as3/.settings/org.eclipse.core.resources.prefs
View File

@ -6,8 +6,32 @@ encoding//src/spine/SkeletonJson.as=UTF-8
encoding//src/spine/Triangulator.as=UTF-8
encoding//src/spine/Vertex.as=UTF-8
encoding//src/spine/VertexEffect.as=UTF-8
encoding//src/spine/animation/Animation.as=UTF-8
encoding//src/spine/animation/AnimationState.as=UTF-8
encoding//src/spine/animation/AnimationStateData.as=UTF-8
encoding//src/spine/animation/AttachmentTimeline.as=UTF-8
encoding//src/spine/animation/ColorTimeline.as=UTF-8
encoding//src/spine/animation/CurveTimeline.as=UTF-8
encoding//src/spine/animation/DeformTimeline.as=UTF-8
encoding//src/spine/animation/DrawOrderTimeline.as=UTF-8
encoding//src/spine/animation/EventQueue.as=UTF-8
encoding//src/spine/animation/EventTimeline.as=UTF-8
encoding//src/spine/animation/EventType.as=UTF-8
encoding//src/spine/animation/IkConstraintTimeline.as=UTF-8
encoding//src/spine/animation/Listeners.as=UTF-8
encoding//src/spine/animation/MixBlend.as=UTF-8
encoding//src/spine/animation/MixDirection.as=UTF-8
encoding//src/spine/animation/MixPose.as=UTF-8
encoding//src/spine/animation/PathConstraintMixTimeline.as=UTF-8
encoding//src/spine/animation/PathConstraintPositionTimeline.as=UTF-8
encoding//src/spine/animation/PathConstraintSpacingTimeline.as=UTF-8
encoding//src/spine/animation/RotateTimeline.as=UTF-8
encoding//src/spine/animation/ScaleTimeline.as=UTF-8
encoding//src/spine/animation/ShearTimeline.as=UTF-8
encoding//src/spine/animation/Timeline.as=UTF-8
encoding//src/spine/animation/TimelineType.as=UTF-8
encoding//src/spine/animation/TrackEntry.as=UTF-8
encoding//src/spine/animation/TransformConstraintTimeline.as=UTF-8
encoding//src/spine/animation/TranslateTimeline.as=UTF-8
encoding//src/spine/animation/TwoColorTimeline.as=UTF-8
encoding//src/spine/attachments/ClippingAttachment.as=UTF-8
encoding//src/spine/attachments/PointAttachment.as=UTF-8

4
spine-as3/spine-as3/src/spine/animation/Animation.as
View File

@ -50,7 +50,7 @@ package spine.animation {
}
/** Poses the skeleton at the specified time for this animation. */
public function apply(skeleton : Skeleton, lastTime : Number, time : Number, loop : Boolean, events : Vector.<Event>, alpha : Number, pose : MixPose, direction : MixDirection) : void {
public function apply(skeleton : Skeleton, lastTime : Number, time : Number, loop : Boolean, events : Vector.<Event>, alpha : Number, blend : MixBlend, direction : MixDirection) : void {
if (skeleton == null) throw new ArgumentError("skeleton cannot be null.");
if (loop && duration != 0) {
@ -59,7 +59,7 @@ package spine.animation {
}
for (var i : int = 0, n : int = timelines.length; i < n; i++)
timelines[i].apply(skeleton, lastTime, time, events, alpha, pose, direction);
timelines[i].apply(skeleton, lastTime, time, events, alpha, blend, direction);
}
public function get name() : String {

119
spine-as3/spine-as3/src/spine/animation/AnimationState.as
View File

@ -159,12 +159,12 @@ package spine.animation {
var current : TrackEntry = tracks[i];
if (current == null || current.delay > 0) continue;
applied = true;
var currentPose : MixPose = i == 0 ? MixPose.current : MixPose.currentLayered;
var blend : MixBlend = i == 0 ? MixBlend.first : current.mixBlend;
// Apply mixing from entries first.
var mix : Number = current.alpha;
if (current.mixingFrom != null)
mix *= applyMixingFrom(current, skeleton, currentPose);
mix *= applyMixingFrom(current, skeleton, blend);
else if (current.trackTime >= current.trackEnd && current.next == null)
mix = 0;
@ -173,9 +173,9 @@ package spine.animation {
var timelineCount : int = current.animation.timelines.length;
var timelines : Vector.<Timeline> = current.animation.timelines;
var ii : int = 0;
if (mix == 1) {
if (mix == 1 || blend == MixBlend.add) {
for (ii = 0; ii < timelineCount; ii++)
Timeline(timelines[ii]).apply(skeleton, animationLast, animationTime, events, 1, MixPose.setup, MixDirection.In);
Timeline(timelines[ii]).apply(skeleton, animationLast, animationTime, events, mix, blend, MixDirection.In);
} else {
var timelineData : Vector.<int> = current.timelineData;
@ -185,11 +185,11 @@ package spine.animation {
for (ii = 0; ii < timelineCount; ii++) {
var timeline : Timeline = timelines[ii];
var pose : MixPose = timelineData[ii] >= AnimationState.FIRST ? MixPose.setup : currentPose;
var timelineBlend : MixBlend = timelineData[ii] == AnimationState.SUBSEQUENT ? blend : MixBlend.setup;
if (timeline is RotateTimeline) {
applyRotateTimeline(timeline, skeleton, animationTime, mix, pose, timelinesRotation, ii << 1, firstFrame);
applyRotateTimeline(timeline, skeleton, animationTime, mix, timelineBlend, timelinesRotation, ii << 1, firstFrame);
} else
timeline.apply(skeleton, animationLast, animationTime, events, mix, pose, MixDirection.In);
timeline.apply(skeleton, animationLast, animationTime, events, mix, timelineBlend, MixDirection.In);
}
}
queueEvents(current, animationTime);
@ -202,17 +202,18 @@ package spine.animation {
return applied;
}
private function applyMixingFrom(to : TrackEntry, skeleton : Skeleton, currentPose : MixPose) : Number {
private function applyMixingFrom(to : TrackEntry, skeleton : Skeleton, blend : MixBlend) : Number {
var from : TrackEntry = to.mixingFrom;
if (from.mixingFrom != null) applyMixingFrom(from, skeleton, currentPose);
if (from.mixingFrom != null) applyMixingFrom(from, skeleton, blend);
var mix : Number = 0;
if (to.mixDuration == 0) { // Single frame mix to undo mixingFrom changes.
mix = 1;
currentPose = MixPose.setup;
if (blend == MixBlend.first) blend = MixBlend.setup;
} else {
mix = to.mixTime / to.mixDuration;
if (mix > 1) mix = 1;
if (blend != MixBlend.first) blend = from.mixBlend;
}
var events : Vector.<Event> = mix < from.eventThreshold ? this.events : null;
@ -220,49 +221,54 @@ package spine.animation {
var animationLast : Number = from.animationLast, animationTime : Number = from.getAnimationTime();
var timelineCount : int = from.animation.timelines.length;
var timelines : Vector.<Timeline> = from.animation.timelines;
var timelineData : Vector.<int> = from.timelineData;
var timelineDipMix : Vector.<TrackEntry> = from.timelineDipMix;
var firstFrame : Boolean = from.timelinesRotation.length == 0;
if (firstFrame) from.timelinesRotation.length = timelineCount << 1;
var timelinesRotation : Vector.<Number> = from.timelinesRotation;
var pose : MixPose;
var alphaDip : Number = from.alpha * to.interruptAlpha;
var alphaMix : Number = alphaDip * (1 - mix);
var alpha : Number = 0;
from.totalAlpha = 0;
for (var i : int = 0; i < timelineCount; i++) {
var timeline : Timeline = timelines[i];
switch (timelineData[i]) {
case SUBSEQUENT:
if (!attachments && timeline is AttachmentTimeline) continue;
if (!drawOrder && timeline is DrawOrderTimeline) continue;
pose = currentPose;
alpha = alphaMix;
break;
case FIRST:
pose = MixPose.setup;
alpha = alphaMix;
break;
case DIP:
pose = MixPose.setup;
alpha = alphaDip;
break;
default:
pose = MixPose.setup;
alpha = alphaDip;
var dipMix : TrackEntry = timelineDipMix[i];
alpha *= Math.max(0, 1 - dipMix.mixTime / dipMix.mixDuration);
break;
}
from.totalAlpha += alpha;
if (timeline is RotateTimeline)
applyRotateTimeline(timeline, skeleton, animationTime, alpha, pose, timelinesRotation, i << 1, firstFrame);
else {
timeline.apply(skeleton, animationLast, animationTime, events, alpha, pose, MixDirection.Out);
}
}
var i : int = 0;
if (blend == MixBlend.add) {
for (i = 0; i < timelineCount; i++)
timelines[i].apply(skeleton, animationLast, animationTime, events, alphaMix, blend, MixDirection.Out);
} else {
var timelineData : Vector.<int> = from.timelineData;
var timelineDipMix : Vector.<TrackEntry> = from.timelineDipMix;
var firstFrame : Boolean = from.timelinesRotation.length == 0;
if (firstFrame) from.timelinesRotation.length = timelineCount << 1;
var timelinesRotation : Vector.<Number> = from.timelinesRotation;
from.totalAlpha = 0;
for (i = 0; i < timelineCount; i++) {
var timeline : Timeline = timelines[i];
var timelineBlend: MixBlend;
var alpha : Number = 0;
switch (timelineData[i]) {
case SUBSEQUENT:
if (!attachments && timeline is AttachmentTimeline) continue;
if (!drawOrder && timeline is DrawOrderTimeline) continue;
timelineBlend = blend;
alpha = alphaMix;
break;
case FIRST:
timelineBlend = MixBlend.setup;
alpha = alphaMix;
break;
case DIP:
timelineBlend = MixBlend.setup;
alpha = alphaDip;
break;
default:
timelineBlend = MixBlend.setup;
var dipMix : TrackEntry = timelineDipMix[i];
alpha = alphaDip * Math.max(0, 1 - dipMix.mixTime / dipMix.mixDuration);
break;
}
from.totalAlpha += alpha;
if (timeline is RotateTimeline)
applyRotateTimeline(timeline, skeleton, animationTime, alpha, timelineBlend, timelinesRotation, i << 1, firstFrame);
else {
timeline.apply(skeleton, animationLast, animationTime, events, alpha, timelineBlend, MixDirection.Out);
}
}
}
if (to.mixDuration > 0) queueEvents(from, animationTime);
this.events.length = 0;
@ -272,11 +278,11 @@ package spine.animation {
return mix;
}
private function applyRotateTimeline(timeline : Timeline, skeleton : Skeleton, time : Number, alpha : Number, pose : MixPose, timelinesRotation : Vector.<Number>, i : int, firstFrame : Boolean) : void {
private function applyRotateTimeline(timeline : Timeline, skeleton : Skeleton, time : Number, alpha : Number, blend : MixBlend, timelinesRotation : Vector.<Number>, i : int, firstFrame : Boolean) : void {
if (firstFrame) timelinesRotation[i] = 0;
if (alpha == 1) {
timeline.apply(skeleton, 0, time, null, 1, pose, MixDirection.In);
timeline.apply(skeleton, 0, time, null, 1, blend, MixDirection.In);
return;
}
@ -284,7 +290,7 @@ package spine.animation {
var frames : Vector.<Number> = rotateTimeline.frames;
var bone : Bone = skeleton.bones[rotateTimeline.boneIndex];
if (time < frames[0]) {
if (pose == MixPose.setup) bone.rotation = bone.data.rotation;
if (blend == MixBlend.setup) bone.rotation = bone.data.rotation;
return;
}
@ -305,7 +311,7 @@ package spine.animation {
}
// Mix between rotations using the direction of the shortest route on the first frame while detecting crosses.
var r1 : Number = pose == MixPose.setup ? bone.data.rotation : bone.rotation;
var r1 : Number = blend == MixBlend.setup ? bone.data.rotation : bone.rotation;
var total : Number, diff : Number = r2 - r1;
if (diff == 0) {
total = timelinesRotation[i];
@ -559,7 +565,8 @@ package spine.animation {
var mixingTo : Vector.<TrackEntry> = this.mixingTo;
for (var i : int = 0, n : int = tracks.length; i < n; i++) {
var entry : TrackEntry = tracks[i];
if (entry != null) entry.setTimelineData(null, mixingTo, propertyIDs);
if (entry != null && (i == 0 || entry.mixBlend != MixBlend.add))
entry.setTimelineData(null, mixingTo, propertyIDs);
}
}

6
spine-as3/spine-as3/src/spine/animation/AttachmentTimeline.as
View File

@ -57,17 +57,17 @@ package spine.animation {
attachmentNames[frameIndex] = attachmentName;
}
public function apply(skeleton : Skeleton, lastTime : Number, time : Number, firedEvents : Vector.<Event>, alpha : Number, pose : MixPose, direction : MixDirection) : void {
public function apply(skeleton : Skeleton, lastTime : Number, time : Number, firedEvents : Vector.<Event>, alpha : Number, blend : MixBlend, direction : MixDirection) : void {
var attachmentName : String;
var slot : Slot = skeleton.slots[slotIndex];
if (direction == MixDirection.Out && pose == MixPose.setup) {
if (direction == MixDirection.Out && blend == MixBlend.setup) {
attachmentName = slot.data.attachmentName;
slot.attachment = attachmentName == null ? null : skeleton.getAttachmentForSlotIndex(slotIndex, attachmentName);
return;
}
var frames : Vector.<Number> = this.frames;
if (time < frames[0]) {
if (pose == MixPose.setup) {
if (blend == MixBlend.setup || blend == MixBlend.first) {
attachmentName = slot.data.attachmentName;
slot.attachment = attachmentName == null ? null : skeleton.getAttachmentForSlotIndex(slotIndex, attachmentName);
}

10
spine-as3/spine-as3/src/spine/animation/ColorTimeline.as
View File

@ -60,16 +60,16 @@ package spine.animation {
frames[int(frameIndex + A)] = a;
}
override public function apply(skeleton : Skeleton, lastTime : Number, time : Number, firedEvents : Vector.<Event>, alpha : Number, pose : MixPose, direction : MixDirection) : void {
override public function apply(skeleton : Skeleton, lastTime : Number, time : Number, firedEvents : Vector.<Event>, alpha : Number, blend : MixBlend, direction : MixDirection) : void {
var frames : Vector.<Number> = this.frames;
var slot : Slot = skeleton.slots[slotIndex];
if (time < frames[0]) {
switch (pose) {
case MixPose.setup:
switch (blend) {
case MixBlend.setup:
slot.color.setFromColor(slot.data.color);
return;
case MixPose.current:
case MixBlend.first:
var color : Color = slot.color, setup : Color = slot.data.color;
color.add((setup.r - color.r) * alpha, (setup.g - color.g) * alpha, (setup.b - color.b) * alpha,
(setup.a - color.a) * alpha);
@ -102,7 +102,7 @@ package spine.animation {
if (alpha == 1) {
slot.color.setFrom(r, g, b, a);
} else {
if (pose == MixPose.setup) {
if (blend == MixBlend.setup) {
slot.color.setFromColor(slot.data.color);
}
slot.color.r += (r - slot.color.r) * alpha;

2
spine-as3/spine-as3/src/spine/animation/CurveTimeline.as
View File

@ -45,7 +45,7 @@ package spine.animation {
curves = new Vector.<Number>((frameCount - 1) * BEZIER_SIZE, true);
}
public function apply(skeleton : Skeleton, lastTime : Number, time : Number, firedEvents : Vector.<Event>, alpha : Number, pose : MixPose, direction : MixDirection) : void {
public function apply(skeleton : Skeleton, lastTime : Number, time : Number, firedEvents : Vector.<Event>, alpha : Number, blend : MixBlend, direction : MixDirection) : void {
}
public function getPropertyId() : int {

152
spine-as3/spine-as3/src/spine/animation/DeformTimeline.as
View File

@ -57,7 +57,7 @@ package spine.animation {
frameVertices[frameIndex] = vertices;
}
override public function apply(skeleton : Skeleton, lastTime : Number, time : Number, firedEvents : Vector.<Event>, alpha : Number, pose : MixPose, direction : MixDirection) : void {
override public function apply(skeleton : Skeleton, lastTime : Number, time : Number, firedEvents : Vector.<Event>, alpha : Number, blend : MixBlend, direction : MixDirection) : void {
var vertexAttachment : VertexAttachment;
var setupVertices : Vector.<Number>;
var slot : Slot = skeleton.slots[slotIndex];
@ -65,7 +65,7 @@ package spine.animation {
if (!(slotAttachment is VertexAttachment) || !(VertexAttachment(slotAttachment)).applyDeform(attachment)) return;
var verticesArray : Vector.<Number> = slot.attachmentVertices;
if (verticesArray.length == 0) alpha = 1;
if (verticesArray.length == 0) blend = MixBlend.setup;
var frameVertices : Vector.<Vector.<Number>> = this.frameVertices;
var vertexCount : int = frameVertices[0].length;
@ -75,11 +75,11 @@ package spine.animation {
var i : int;
if (time < frames[0]) {
vertexAttachment = VertexAttachment(slotAttachment);
switch (pose) {
case MixPose.setup:
switch (blend) {
case MixBlend.setup:
verticesArray.length = 0;
return;
case MixPose.current:
case MixBlend.first:
if (alpha == 1) {
verticesArray.length = 0;
return;
@ -108,27 +108,54 @@ package spine.animation {
if (time >= frames[frames.length - 1]) { // Time is after last frame.
var lastVertices : Vector.<Number> = frameVertices[frames.length - 1];
if (alpha == 1) {
// Vertex positions or deform offsets, no alpha.
for (i = 0, n = vertexCount; i < n; i++)
vertices[i] = lastVertices[i];
} else if (pose == MixPose.setup) {
vertexAttachment = VertexAttachment(slotAttachment);
if (vertexAttachment.bones == null) {
// Unweighted vertex positions, with alpha.
setupVertices = vertexAttachment.vertices;
for (i = 0; i < vertexCount; i++) {
setup = setupVertices[i];
vertices[i] = setup + (lastVertices[i] - setup) * alpha;
if (blend == MixBlend.add) {
vertexAttachment = VertexAttachment(slotAttachment);
if (vertexAttachment.bones == null) {
setupVertices = vertexAttachment.vertices;
for (i = 0; i < vertexCount; i++) {
vertices[i] += lastVertices[i] - setupVertices[i];
}
} else {
for (i = 0; i < vertexCount; i++)
vertices[i] += lastVertices[i];
}
} else {
// Weighted deform offsets, with alpha.
for (i = 0; i < vertexCount; i++)
vertices[i] = lastVertices[i] * alpha;
} else {
for (i = 0, n = vertexCount; i < n; i++)
vertices[i] = lastVertices[i];
}
} else {
// Vertex positions or deform offsets, with alpha.
for (i = 0; i < vertexCount; i++)
vertices[i] += (lastVertices[i] - vertices[i]) * alpha;
switch (blend) {
case MixBlend.setup:
vertexAttachment = VertexAttachment(slotAttachment);
if (vertexAttachment.bones == null) {
// Unweighted vertex positions, with alpha.
setupVertices = vertexAttachment.vertices;
for (i = 0; i < vertexCount; i++) {
setup = setupVertices[i];
vertices[i] = setup + (lastVertices[i] - setup) * alpha;
}
} else {
// Weighted deform offsets, with alpha.
for (i = 0; i < vertexCount; i++)
vertices[i] = lastVertices[i] * alpha;
}
break;
case MixBlend.first:
case MixBlend.replace:
for (i = 0; i < vertexCount; i++)
vertices[i] += (lastVertices[i] - vertices[i]) * alpha;
case MixBlend.add:
vertexAttachment = VertexAttachment(slotAttachment);
if (vertexAttachment.bones == null) {
setupVertices = vertexAttachment.vertices;
for (i = 0; i < vertexCount; i++) {
vertices[i] += (lastVertices[i] - setupVertices[i]) * alpha;
}
} else {
for (i = 0; i < vertexCount; i++)
vertices[i] += lastVertices[i] * alpha;
}
}
}
return;
}
@ -141,34 +168,67 @@ package spine.animation {
var percent : Number = getCurvePercent(frame - 1, 1 - (time - frameTime) / (frames[frame - 1] - frameTime));
if (alpha == 1) {
// Vertex positions or deform offsets, no alpha.
for (i = 0; i < vertexCount; i++) {
prev = prevVertices[i];
vertices[i] = prev + (nextVertices[i] - prev) * percent;
}
} else if (pose == MixPose.setup) {
vertexAttachment = VertexAttachment(slotAttachment);
if (vertexAttachment.bones == null) {
// Unweighted vertex positions, with alpha.
setupVertices = vertexAttachment.vertices;
for (i = 0; i < vertexCount; i++) {
prev = prevVertices[i];
setup = setupVertices[i];
vertices[i] = setup + (prev + (nextVertices[i] - prev) * percent - setup) * alpha;
if (blend == MixBlend.add) {
vertexAttachment = VertexAttachment(slotAttachment);
if (vertexAttachment.bones == null) {
setupVertices = vertexAttachment.vertices;
for (i = 0; i < vertexCount; i++) {
prev = prevVertices[i];
vertices[i] += prev + (nextVertices[i] - prev) * percent - setupVertices[i];
}
} else {
for (i = 0; i < vertexCount; i++) {
prev = prevVertices[i];
vertices[i] += prev + (nextVertices[i] - prev) * percent;
}
}
} else {
// Weighted deform offsets, with alpha.
for (i = 0; i < vertexCount; i++) {
} else {
for (i = 0; i < vertexCount; i++) {
prev = prevVertices[i];
vertices[i] = (prev + (nextVertices[i] - prev) * percent) * alpha;
vertices[i] = prev + (nextVertices[i] - prev) * percent;
}
}
} else {
// Vertex positions or deform offsets, with alpha.
for (i = 0; i < vertexCount; i++) {
prev = prevVertices[i];
vertices[i] += (prev + (nextVertices[i] - prev) * percent - vertices[i]) * alpha;
}
switch (blend) {
case MixBlend.setup:
vertexAttachment = VertexAttachment(slotAttachment);
if (vertexAttachment.bones == null) {
// Unweighted vertex positions, with alpha.
setupVertices = vertexAttachment.vertices;
for (i = 0; i < vertexCount; i++) {
prev = prevVertices[i], setup = setupVertices[i];
vertices[i] = setup + (prev + (nextVertices[i] - prev) * percent - setup) * alpha;
}
} else {
// Weighted deform offsets, with alpha.
for (i = 0; i < vertexCount; i++) {
prev = prevVertices[i];
vertices[i] = (prev + (nextVertices[i] - prev) * percent) * alpha;
}
}
break;
case MixBlend.first:
case MixBlend.replace:
for (i = 0; i < vertexCount; i++) {
prev = prevVertices[i];
vertices[i] += (prev + (nextVertices[i] - prev) * percent - vertices[i]) * alpha;
}
break;
case MixBlend.add:
vertexAttachment = VertexAttachment(slotAttachment);
if (vertexAttachment.bones == null) {
setupVertices = vertexAttachment.vertices;
for (i = 0; i < vertexCount; i++) {
prev = prevVertices[i], setup = setupVertices[i];
vertices[i] += (prev + (nextVertices[i] - prev) * percent - setupVertices[i]) * alpha;
}
} else {
for (i = 0; i < vertexCount; i++) {
prev = prevVertices[i];
vertices[i] += (prev + (nextVertices[i] - prev) * percent) * alpha;
}
}
}
}
}
}

6
spine-as3/spine-as3/src/spine/animation/DrawOrderTimeline.as
View File

@ -56,8 +56,8 @@ package spine.animation {
drawOrders[frameIndex] = drawOrder;
}
public function apply(skeleton : Skeleton, lastTime : Number, time : Number, firedEvents : Vector.<Event>, alpha : Number, pose : MixPose, direction : MixDirection) : void {
if (direction == MixDirection.Out && pose == MixPose.setup) {
public function apply(skeleton : Skeleton, lastTime : Number, time : Number, firedEvents : Vector.<Event>, alpha : Number, blend : MixBlend, direction : MixDirection) : void {
if (direction == MixDirection.Out && blend == MixBlend.setup) {
for (var ii : int = 0, n : int = skeleton.slots.length; ii < n; ii++)
skeleton.drawOrder[ii] = skeleton.slots[ii];
return;
@ -68,7 +68,7 @@ package spine.animation {
var slot : Slot;
var i : int = 0;
if (time < frames[0]) {
if (pose == MixPose.setup) {
if (blend == MixBlend.setup || blend == MixBlend.first) {
for each (slot in slots)
drawOrder[i++] = slot;
}

4
spine-as3/spine-as3/src/spine/animation/EventTimeline.as
View File

@ -56,11 +56,11 @@ package spine.animation {
}
/** Fires events for frames > lastTime and <= time. */
public function apply(skeleton : Skeleton, lastTime : Number, time : Number, firedEvents : Vector.<Event>, alpha : Number, pose : MixPose, direction : MixDirection) : void {
public function apply(skeleton : Skeleton, lastTime : Number, time : Number, firedEvents : Vector.<Event>, alpha : Number, blend : MixBlend, direction : MixDirection) : void {
if (!firedEvents) return;
if (lastTime > time) { // Fire events after last time for looped animations.
apply(skeleton, lastTime, int.MAX_VALUE, firedEvents, alpha, pose, direction);
apply(skeleton, lastTime, int.MAX_VALUE, firedEvents, alpha, blend, direction);
lastTime = -1;
} else if (lastTime >= frames[int(frameCount - 1)]) // Last time is after last frame.
return;

12
spine-as3/spine-as3/src/spine/animation/IkConstraintTimeline.as
View File

@ -57,15 +57,15 @@ package spine.animation {
frames[int(frameIndex + BEND_DIRECTION)] = bendDirection;
}
override public function apply(skeleton : Skeleton, lastTime : Number, time : Number, firedEvents : Vector.<Event>, alpha : Number, pose : MixPose, direction : MixDirection) : void {
override public function apply(skeleton : Skeleton, lastTime : Number, time : Number, firedEvents : Vector.<Event>, alpha : Number, blend : MixBlend, direction : MixDirection) : void {
var constraint : IkConstraint = skeleton.ikConstraints[ikConstraintIndex];
if (time < frames[0]) {
switch (pose) {
case MixPose.setup:
switch (blend) {
case MixBlend.setup:
constraint.mix = constraint.data.mix;
constraint.bendDirection = constraint.data.bendDirection;
return;
case MixPose.current:
case MixBlend.first:
constraint.mix += (constraint.data.mix - constraint.mix) * alpha;
constraint.bendDirection = constraint.data.bendDirection;
}
@ -73,7 +73,7 @@ package spine.animation {
}
if (time >= frames[int(frames.length - ENTRIES)]) { // Time is after last frame.
if (pose == MixPose.setup) {
if (blend == MixBlend.setup) {
constraint.mix = constraint.data.mix + (frames[frames.length + PREV_MIX] - constraint.data.mix) * alpha;
constraint.bendDirection = direction == MixDirection.Out ? constraint.data.bendDirection : int(frames[frames.length + PREV_BEND_DIRECTION]);
} else {
@ -89,7 +89,7 @@ package spine.animation {
var frameTime : Number = frames[frame];
var percent : Number = getCurvePercent(frame / ENTRIES - 1, 1 - (time - frameTime) / (frames[frame + PREV_TIME] - frameTime));
if (pose == MixPose.setup) {
if (blend == MixBlend.setup) {
constraint.mix = constraint.data.mix + (mix + (frames[frame + MIX] - mix) * percent - constraint.data.mix) * alpha;
constraint.bendDirection = direction == MixDirection.Out ? constraint.data.bendDirection : int(frames[frame + PREV_BEND_DIRECTION]);
} else {

11
spine-as3/spine-as3/src/spine/animation/MixPose.as → spine-as3/spine-as3/src/spine/animation/MixBlend.as
View File

@ -29,15 +29,16 @@
*****************************************************************************/
package spine.animation {
public class MixPose {
public class MixBlend {
public var ordinal : int;
public function MixPose(order : int) {
public function MixBlend(order : int) {
this.ordinal = order;
}
public static const setup : MixPose = new MixPose(0);
public static const current : MixPose = new MixPose(1);
public static const currentLayered : MixPose = new MixPose(2);
public static const setup : MixBlend = new MixBlend(0);
public static const first : MixBlend = new MixBlend(1);
public static const replace : MixBlend = new MixBlend(2);
public static const add : MixBlend = new MixBlend(3);
}
}

10
spine-as3/spine-as3/src/spine/animation/PathConstraintMixTimeline.as
View File

@ -57,15 +57,15 @@ package spine.animation {
frames[frameIndex + TRANSLATE] = translateMix;
}
override public function apply(skeleton : Skeleton, lastTime : Number, time : Number, firedEvents : Vector.<Event>, alpha : Number, pose : MixPose, direction : MixDirection) : void {
override public function apply(skeleton : Skeleton, lastTime : Number, time : Number, firedEvents : Vector.<Event>, alpha : Number, blend : MixBlend, direction : MixDirection) : void {
var constraint : PathConstraint = skeleton.pathConstraints[pathConstraintIndex];
if (time < frames[0]) {
switch (pose) {
case MixPose.setup:
switch (blend) {
case MixBlend.setup:
constraint.rotateMix = constraint.data.rotateMix;
constraint.translateMix = constraint.data.translateMix;
return;
case MixPose.current:
case MixBlend.first:
constraint.rotateMix += (constraint.data.rotateMix - constraint.rotateMix) * alpha;
constraint.translateMix += (constraint.data.translateMix - constraint.translateMix) * alpha;
}
@ -88,7 +88,7 @@ package spine.animation {
translate += (frames[frame + TRANSLATE] - translate) * percent;
}
if (pose == MixPose.setup) {
if (blend == MixBlend.setup) {
constraint.rotateMix = constraint.data.rotateMix + (rotate - constraint.data.rotateMix) * alpha;
constraint.translateMix = constraint.data.translateMix + (translate - constraint.data.translateMix) * alpha;
} else {

10
spine-as3/spine-as3/src/spine/animation/PathConstraintPositionTimeline.as
View File

@ -56,14 +56,14 @@ package spine.animation {
frames[frameIndex + VALUE] = value;
}
override public function apply(skeleton : Skeleton, lastTime : Number, time : Number, firedEvents : Vector.<Event>, alpha : Number, pose : MixPose, direction : MixDirection) : void {
override public function apply(skeleton : Skeleton, lastTime : Number, time : Number, firedEvents : Vector.<Event>, alpha : Number, blend : MixBlend, direction : MixDirection) : void {
var constraint : PathConstraint = skeleton.pathConstraints[pathConstraintIndex];
if (time < frames[0]) {
switch (pose) {
case MixPose.setup:
switch (blend) {
case MixBlend.setup:
constraint.position = constraint.data.position;
return;
case MixPose.current:
case MixBlend.first:
constraint.position += (constraint.data.position - constraint.position) * alpha;
}
return;
@ -81,7 +81,7 @@ package spine.animation {
position += (frames[frame + VALUE] - position) * percent;
}
if (pose == MixPose.setup)
if (blend == MixBlend.setup)
constraint.position = constraint.data.position + (position - constraint.data.position) * alpha;
else
constraint.position += (position - constraint.position) * alpha;

10
spine-as3/spine-as3/src/spine/animation/PathConstraintSpacingTimeline.as
View File

@ -42,14 +42,14 @@ package spine.animation {
return (TimelineType.pathConstraintSpacing.ordinal << 24) + pathConstraintIndex;
}
override public function apply(skeleton : Skeleton, lastTime : Number, time : Number, firedEvents : Vector.<Event>, alpha : Number, pose : MixPose, direction : MixDirection) : void {
override public function apply(skeleton : Skeleton, lastTime : Number, time : Number, firedEvents : Vector.<Event>, alpha : Number, blend : MixBlend, direction : MixDirection) : void {
var constraint : PathConstraint = skeleton.pathConstraints[pathConstraintIndex];
if (time < frames[0]) {
switch (pose) {
case MixPose.setup:
switch (blend) {
case MixBlend.setup:
constraint.spacing = constraint.data.spacing;
return;
case MixPose.current:
case MixBlend.first:
constraint.spacing += (constraint.data.spacing - constraint.spacing) * alpha;
}
return;
@ -68,7 +68,7 @@ package spine.animation {
spacing += (frames[frame + VALUE] - spacing) * percent;
}
if (pose == MixPose.setup)
if (blend == MixBlend.setup)
constraint.spacing = constraint.data.spacing + (spacing - constraint.data.spacing) * alpha;
else
constraint.spacing += (spacing - constraint.spacing) * alpha;

49
spine-as3/spine-as3/src/spine/animation/RotateTimeline.as
View File

@ -56,32 +56,36 @@ package spine.animation {
frames[int(frameIndex + ROTATION)] = degrees;
}
override public function apply(skeleton : Skeleton, lastTime : Number, time : Number, firedEvents : Vector.<Event>, alpha : Number, pose : MixPose, direction : MixDirection) : void {
override public function apply(skeleton : Skeleton, lastTime : Number, time : Number, firedEvents : Vector.<Event>, alpha : Number, blend : MixBlend, direction : MixDirection) : void {
var frames : Vector.<Number> = this.frames;
var bone : Bone = skeleton.bones[boneIndex];
var r : Number;
if (time < frames[0]) {
switch (pose) {
case MixPose.setup:
switch (blend) {
case MixBlend.setup:
bone.rotation = bone.data.rotation;
return;
case MixPose.current:
case MixBlend.first:
r = bone.data.rotation - bone.rotation;
r -= (16384 - int((16384.499999999996 - r / 360))) * 360;
bone.rotation += r * alpha;
bone.rotation += (r - (16384 - int((16384.499999999996 - r / 360))) * 360) * alpha;
}
return;
}
if (time >= frames[frames.length - ENTRIES]) { // Time is after last frame.
if (pose == MixPose.setup)
bone.rotation = bone.data.rotation + frames[frames.length + PREV_ROTATION] * alpha;
else {
r = bone.data.rotation + frames[frames.length + PREV_ROTATION] - bone.rotation;
r -= (16384 - int((16384.499999999996 - r / 360))) * 360; // Wrap within -180 and 180.
bone.rotation += r * alpha;
}
r = frames[frames.length + PREV_ROTATION];
switch (blend) {
case MixBlend.setup:
bone.rotation = bone.data.rotation + r * alpha;
break;
case MixBlend.first:
case MixBlend.replace:
r += bone.data.rotation - bone.rotation;
r -= (16384 - int((16384.499999999996 - r / 360))) * 360; // Wrap within -180 and 180.
case MixBlend.add:
bone.rotation += r * alpha;
}
return;
}
@ -92,15 +96,16 @@ package spine.animation {
var percent : Number = getCurvePercent((frame >> 1) - 1, 1 - (time - frameTime) / (frames[frame + PREV_TIME] - frameTime));
r = frames[frame + ROTATION] - prevRotation;
r -= (16384 - int((16384.499999999996 - r / 360))) * 360;
r = prevRotation + r * percent;
if (pose == MixPose.setup) {
r -= (16384 - int((16384.499999999996 - r / 360))) * 360;
bone.rotation = bone.data.rotation + r * alpha;
} else {
r = bone.data.rotation + r - bone.rotation;
r -= (16384 - int((16384.499999999996 - r / 360))) * 360;
bone.rotation += r * alpha;
r = prevRotation + (r - (16384 - int((16384.499999999996 - r / 360))) * 360) * percent;
switch (blend) {
case MixBlend.setup:
bone.rotation = bone.data.rotation + (r - (16384 - int((16384.499999999996 - r / 360))) * 360) * alpha;
break;
case MixBlend.first:
case MixBlend.replace:
r += bone.data.rotation - bone.rotation;
case MixBlend.add:
bone.rotation += (r - (16384 - int((16384.499999999996 - r / 360))) * 360) * alpha;
}
}
}

71
spine-as3/spine-as3/src/spine/animation/ScaleTimeline.as
View File

@ -43,17 +43,17 @@ package spine.animation {
return (TimelineType.scale.ordinal << 24) + boneIndex;
}
override public function apply(skeleton : Skeleton, lastTime : Number, time : Number, firedEvents : Vector.<Event>, alpha : Number, pose : MixPose, direction : MixDirection) : void {
override public function apply(skeleton : Skeleton, lastTime : Number, time : Number, firedEvents : Vector.<Event>, alpha : Number, blend : MixBlend, direction : MixDirection) : void {
var frames : Vector.<Number> = this.frames;
var bone : Bone = skeleton.bones[boneIndex];
if (time < frames[0]) {
switch (pose) {
case MixPose.setup:
switch (blend) {
case MixBlend.setup:
bone.scaleX = bone.data.scaleX;
bone.scaleY = bone.data.scaleY;
return;
case MixPose.current:
case MixBlend.first:
bone.scaleX += (bone.data.scaleX - bone.scaleX) * alpha;
bone.scaleY += (bone.data.scaleY - bone.scaleY) * alpha;
}
@ -76,27 +76,58 @@ package spine.animation {
y = (y + (frames[frame + Y] - y) * percent) * bone.data.scaleY;
}
if (alpha == 1) {
bone.scaleX = x;
bone.scaleY = y;
if (blend == MixBlend.add) {
bone.scaleX += x - bone.data.scaleX;
bone.scaleY += y - bone.data.scaleY;
} else {
bone.scaleX = x;
bone.scaleY = y;
}
} else {
var bx : Number, by : Number;
if (pose == MixPose.setup) {
bx = bone.data.scaleX;
by = bone.data.scaleY;
} else {
bx = bone.scaleX;
by = bone.scaleY;
}
// Mixing out uses sign of setup or current pose, else use sign of key.
if (direction == MixDirection.Out) {
x = Math.abs(x) * MathUtils.signum(bx);
y = Math.abs(y) * MathUtils.signum(by);
switch (blend) {
case MixBlend.setup:
bx = bone.data.scaleX;
by = bone.data.scaleY;
bone.scaleX = bx + (Math.abs(x) * MathUtils.signum(bx) - bx) * alpha;
bone.scaleY = by + (Math.abs(y) * MathUtils.signum(by) - by) * alpha;
break;
case MixBlend.first:
case MixBlend.replace:
bx = bone.scaleX;
by = bone.scaleY;
bone.scaleX = bx + (Math.abs(x) * MathUtils.signum(bx) - bx) * alpha;
bone.scaleY = by + (Math.abs(y) * MathUtils.signum(by) - by) * alpha;
break;
case MixBlend.add:
bx = bone.scaleX;
by = bone.scaleY;
bone.scaleX = bx + (Math.abs(x) * MathUtils.signum(bx) - bone.data.scaleX) * alpha;
bone.scaleY = by + (Math.abs(y) * MathUtils.signum(by) - bone.data.scaleY) * alpha;
}
} else {
bx = Math.abs(bx) * MathUtils.signum(x);
by = Math.abs(by) * MathUtils.signum(y);
switch (blend) {
case MixBlend.setup:
bx = Math.abs(bone.data.scaleX) * MathUtils.signum(x);
by = Math.abs(bone.data.scaleY) * MathUtils.signum(y);
bone.scaleX = bx + (x - bx) * alpha;
bone.scaleY = by + (y - by) * alpha;
break;
case MixBlend.first:
case MixBlend.replace:
bx = Math.abs(bone.scaleX) * MathUtils.signum(x);
by = Math.abs(bone.scaleY) * MathUtils.signum(y);
bone.scaleX = bx + (x - bx) * alpha;
bone.scaleY = by + (y - by) * alpha;
break;
case MixBlend.add:
bx = MathUtils.signum(x);
by = MathUtils.signum(y);
bone.scaleX = Math.abs(bone.scaleX) * bx + (x - Math.abs(bone.data.scaleX) * bx) * alpha;
bone.scaleY = Math.abs(bone.scaleY) * by + (y - Math.abs(bone.data.scaleY) * by) * alpha;
}
}
bone.scaleX = bx + (x - bx) * alpha;
bone.scaleY = by + (y - by) * alpha;
}
}
}

27
spine-as3/spine-as3/src/spine/animation/ShearTimeline.as
View File

@ -42,17 +42,17 @@ package spine.animation {
return (TimelineType.shear.ordinal << 24) + boneIndex;
}
override public function apply(skeleton : Skeleton, lastTime : Number, time : Number, firedEvents : Vector.<Event>, alpha : Number, pose : MixPose, direction : MixDirection) : void {
override public function apply(skeleton : Skeleton, lastTime : Number, time : Number, firedEvents : Vector.<Event>, alpha : Number, blend : MixBlend, direction : MixDirection) : void {
var frames : Vector.<Number> = this.frames;
var bone : Bone = skeleton.bones[boneIndex];
if (time < frames[0]) {
switch (pose) {
case MixPose.setup:
switch (blend) {
case MixBlend.setup:
bone.shearX = bone.data.shearX;
bone.shearY = bone.data.shearY;
return;
case MixPose.current:
case MixBlend.first:
bone.shearX += (bone.data.shearX - bone.shearX) * alpha;
bone.shearY += (bone.data.shearY - bone.shearY) * alpha;
}
@ -74,12 +74,19 @@ package spine.animation {
x = x + (frames[frame + X] - x) * percent;
y = y + (frames[frame + Y] - y) * percent;
}
if (pose == MixPose.setup) {
bone.shearX = bone.data.shearX + x * alpha;
bone.shearY = bone.data.shearY + y * alpha;
} else {
bone.shearX += (bone.data.shearX + x - bone.shearX) * alpha;
bone.shearY += (bone.data.shearY + y - bone.shearY) * alpha;
switch (blend) {
case MixBlend.setup:
bone.shearX = bone.data.shearX + x * alpha;
bone.shearY = bone.data.shearY + y * alpha;
break;
case MixBlend.first:
case MixBlend.replace:
bone.shearX += (bone.data.shearX + x - bone.shearX) * alpha;
bone.shearY += (bone.data.shearY + y - bone.shearY) * alpha;
break;
case MixBlend.add:
bone.shearX += x * alpha;
bone.shearY += y * alpha;
}
}
}

2
spine-as3/spine-as3/src/spine/animation/Timeline.as
View File

@ -34,7 +34,7 @@ package spine.animation {
public interface Timeline {
/** Sets the value(s) for the specified time. */
function apply(skeleton : Skeleton, lastTime : Number, time : Number, firedEvents : Vector.<Event>, alpha : Number, pose : MixPose, direction : MixDirection) : void;
function apply(skeleton : Skeleton, lastTime : Number, time : Number, firedEvents : Vector.<Event>, alpha : Number, blend : MixBlend, direction : MixDirection) : void;
function getPropertyId() : int;
}

1
spine-as3/spine-as3/src/spine/animation/TrackEntry.as
View File

@ -47,6 +47,7 @@ package spine.animation {
public var animationStart : Number, animationEnd : Number, animationLast : Number, nextAnimationLast : Number;
public var delay : Number, trackTime : Number, trackLast : Number, nextTrackLast : Number, trackEnd : Number, timeScale : Number;
public var alpha : Number, mixTime : Number, mixDuration : Number, interruptAlpha : Number, totalAlpha : Number = 0;
public var mixBlend: MixBlend = MixBlend.replace;
public var timelineData : Vector.<int> = new Vector.<int>();
public var timelineDipMix : Vector.<TrackEntry> = new Vector.<TrackEntry>();
public var timelinesRotation : Vector.<Number> = new Vector.<Number>();

10
spine-as3/spine-as3/src/spine/animation/TransformConstraintTimeline.as
View File

@ -60,21 +60,21 @@ package spine.animation {
frames[frameIndex + SHEAR] = shearMix;
}
override public function apply(skeleton : Skeleton, lastTime : Number, time : Number, firedEvents : Vector.<Event>, alpha : Number, pose : MixPose, direction : MixDirection) : void {
override public function apply(skeleton : Skeleton, lastTime : Number, time : Number, firedEvents : Vector.<Event>, alpha : Number, blend : MixBlend, direction : MixDirection) : void {
var frames : Vector.<Number> = this.frames;
var constraint : TransformConstraint = skeleton.transformConstraints[transformConstraintIndex];
var data : TransformConstraintData;
if (time < frames[0]) {
data = constraint.data;
switch (pose) {
case MixPose.setup:
switch (blend) {
case MixBlend.setup:
constraint.rotateMix = data.rotateMix;
constraint.translateMix = data.translateMix;
constraint.scaleMix = data.scaleMix;
constraint.shearMix = data.shearMix;
return;
case MixPose.current:
case MixBlend.first:
constraint.rotateMix += (data.rotateMix - constraint.rotateMix) * alpha;
constraint.translateMix += (data.translateMix - constraint.translateMix) * alpha;
constraint.scaleMix += (data.scaleMix - constraint.scaleMix) * alpha;
@ -105,7 +105,7 @@ package spine.animation {
scale += (frames[frame + SCALE] - scale) * percent;
shear += (frames[frame + SHEAR] - shear) * percent;
}
if (pose == MixPose.setup) {
if (blend == MixBlend.setup) {
data = constraint.data;
constraint.rotateMix = data.rotateMix + (rotate - data.rotateMix) * alpha;
constraint.translateMix = data.translateMix + (translate - data.translateMix) * alpha;

27
spine-as3/spine-as3/src/spine/animation/TranslateTimeline.as
View File

@ -57,17 +57,17 @@ package spine.animation {
frames[int(frameIndex + Y)] = y;
}
override public function apply(skeleton : Skeleton, lastTime : Number, time : Number, firedEvents : Vector.<Event>, alpha : Number, pose : MixPose, direction : MixDirection) : void {
override public function apply(skeleton : Skeleton, lastTime : Number, time : Number, firedEvents : Vector.<Event>, alpha : Number, blend : MixBlend, direction : MixDirection) : void {
var frames : Vector.<Number> = this.frames;
var bone : Bone = skeleton.bones[boneIndex];
if (time < frames[0]) {
switch (pose) {
case MixPose.setup:
switch (blend) {
case MixBlend.setup:
bone.x = bone.data.x;
bone.y = bone.data.y;
return;
case MixPose.current:
case MixBlend.first:
bone.x += (bone.data.x - bone.x) * alpha;
bone.y += (bone.data.y - bone.y) * alpha;
}
@ -89,12 +89,19 @@ package spine.animation {
x += (frames[frame + X] - x) * percent;
y += (frames[frame + Y] - y) * percent;
}
if (pose == MixPose.setup) {
bone.x = bone.data.x + x * alpha;
bone.y = bone.data.y + y * alpha;
} else {
bone.x += (bone.data.x + x - bone.x) * alpha;
bone.y += (bone.data.y + y - bone.y) * alpha;
switch (blend) {
case MixBlend.setup:
bone.x = bone.data.x + x * alpha;
bone.y = bone.data.y + y * alpha;
break;
case MixBlend.first:
case MixBlend.replace:
bone.x += (bone.data.x + x - bone.x) * alpha;
bone.y += (bone.data.y + y - bone.y) * alpha;
break;
case MixBlend.add:
bone.x += x * alpha;
bone.y += y * alpha;
}
}
}

10
spine-as3/spine-as3/src/spine/animation/TwoColorTimeline.as
View File

@ -64,18 +64,18 @@ package spine.animation {
this.frames[frameIndex + TwoColorTimeline.B2] = b2;
}
override public function apply(skeleton : Skeleton, lastTime : Number, time : Number, firedEvents : Vector.<Event>, alpha : Number, pose : MixPose, direction : MixDirection) : void {
override public function apply(skeleton : Skeleton, lastTime : Number, time : Number, firedEvents : Vector.<Event>, alpha : Number, blend : MixBlend, direction : MixDirection) : void {
var frames : Vector.<Number> = this.frames;
var slot : Slot = skeleton.slots[slotIndex];
var light : Color, dark : Color;
if (time < frames[0]) {
switch (pose) {
case MixPose.setup:
switch (blend) {
case MixBlend.setup:
slot.color.setFromColor(slot.data.color);
slot.darkColor.setFromColor(slot.data.darkColor);
return;
case MixPose.current:
case MixBlend.first:
light = slot.color;
dark = slot.darkColor;
var setupLight : Color = slot.data.color, setupDark : Color = slot.data.darkColor;
@ -123,7 +123,7 @@ package spine.animation {
} else {
light = slot.color;
dark = slot.darkColor;
if (pose == MixPose.setup) {
if (blend == MixBlend.setup) {
light.setFromColor(slot.data.color);
dark.setFromColor(slot.data.darkColor);
}

6
spine-c/spine-c/src/spine/Animation.c
View File

@ -489,8 +489,10 @@ void _spScaleTimeline_apply (const spTimeline* timeline, spSkeleton* skeleton, f
break;
case SP_MIX_BLEND_FIRST:
case SP_MIX_BLEND_REPLACE:
bone->scaleX += (x - bone->scaleX * SIGNUM(x)) * alpha;
bone->scaleY += (y - bone->scaleY * SIGNUM(y)) * alpha;
bx = ABS(bone->scaleX) * SIGNUM(x);
by = ABS(bone->scaleY) * SIGNUM(y);
bone->scaleX = bx + (x - bx) * alpha;
bone->scaleY = by + (y - by) * alpha;
break;
case SP_MIX_BLEND_ADD:
bx = SIGNUM(x);

BIN
spine-starling/spine-starling-example/lib/spine-as3.swc
View File

Binary file not shown.

2
spine-starling/spine-starling-example/src/spine/examples/Main.as
View File

@ -38,7 +38,7 @@ package spine.examples {
private var _starling : Starling;
public function Main() {
_starling = new Starling(SpineboyExample, stage);
_starling = new Starling(OwlExample, stage);
_starling.enableErrorChecking = true;
_starling.showStats = true;
_starling.skipUnchangedFrames = false;

88
spine-starling/spine-starling-example/src/spine/examples/OwlExample.as Normal file
View File

@ -0,0 +1,88 @@
package spine.examples {
import spine.animation.MixBlend;
import spine.animation.TrackEntry;
import starling.display.DisplayObjectContainer;
import starling.events.Touch;
import starling.events.TouchPhase;
import starling.core.Starling;
import starling.events.TouchEvent;
import starling.display.Sprite;
import spine.SkeletonData;
import spine.SkeletonJson;
import spine.attachments.AtlasAttachmentLoader;
import spine.starling.StarlingTextureLoader;
import spine.atlas.Atlas;
import spine.attachments.AttachmentLoader;
import spine.starling.SkeletonAnimation;
public class OwlExample extends Sprite {
[Embed(source = "/owl-pro.json", mimeType = "application/octet-stream")]
static public const OwlJson : Class;
[Embed(source = "/owl.atlas", mimeType = "application/octet-stream")]
static public const OwlAtlas : Class;
[Embed(source = "/owl.png")]
static public const OwlAtlasTexture : Class;
private var skeleton : SkeletonAnimation;
private var left: TrackEntry;
private var right: TrackEntry;
private var up: TrackEntry;
private var down: TrackEntry;
public function OwlExample() {
var attachmentLoader : AttachmentLoader;
var spineAtlas : Atlas = new Atlas(new OwlAtlas(), new StarlingTextureLoader(new OwlAtlasTexture()));
attachmentLoader = new AtlasAttachmentLoader(spineAtlas);
var json : SkeletonJson = new SkeletonJson(attachmentLoader);
json.scale = 0.5;
var skeletonData : SkeletonData = json.readSkeletonData(new OwlJson());
this.x = 400;
this.y = 400;
skeleton = new SkeletonAnimation(skeletonData);
skeleton.state.setAnimationByName(0, "idle", true);
skeleton.state.setAnimationByName(1, "blink", true);
left = skeleton.state.setAnimationByName(2, "left", true);
right = skeleton.state.setAnimationByName(3, "right", true);
up = skeleton.state.setAnimationByName(4, "up", true);
down = skeleton.state.setAnimationByName(5, "down", true);
left.alpha = right.alpha = up.alpha = down.alpha = 0;
left.mixBlend = right.mixBlend = up.mixBlend = down.mixBlend = MixBlend.add;
skeleton.state.timeScale = 0.5;
skeleton.state.update(0.25);
skeleton.state.apply(skeleton.skeleton);
skeleton.skeleton.updateWorldTransform();
addChild(skeleton);
Starling.juggler.add(skeleton);
addEventListener(TouchEvent.TOUCH, onTouch);
}
private function onTouch(event : TouchEvent) : void {
var touch : Touch = event.getTouch(this);
if (touch && touch.phase == TouchPhase.ENDED) {
var parent : DisplayObjectContainer = this.parent;
this.removeFromParent(true);
parent.addChild(new SpineboyExample());
}
if (touch && touch.phase == TouchPhase.HOVER) {
var x : Number = touch.globalX / 800.0;
left.alpha = (Math.max(x, 0.5) - 0.5) * 2;
right.alpha = (0.5 - Math.min(x, 0.5)) * 2;
var y : Number = touch.globalY / 600.0;
down.alpha = (Math.max(y, 0.5) - 0.5) * 2;
up.alpha = (0.5 - Math.min(y, 0.5)) * 2;
}
}
}
}

BIN
spine-starling/spine-starling/lib/spine-as3.swc
View File

Binary file not shown.

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

@ -554,7 +554,8 @@ module spine {
for (var i = 0, n = this.tracks.length; i < n; i++) {
let entry = this.tracks[i];
if (entry != null && (i == 0 || entry.mixBlend != MixBlend.add)) entry.setTimelineData(null, mixingTo, propertyIDs);
if (entry != null && (i == 0 || entry.mixBlend != MixBlend.add))
entry.setTimelineData(null, mixingTo, propertyIDs);
}
}