public void Apply(Skeleton skeleton, float lastTime, float time, ExposedList <Event> firedEvents, float alpha, MixPose pose, MixDirection direction) { if (firedEvents != null) { float[] frames = this.frames; int length = frames.Length; if (lastTime > time) { this.Apply(skeleton, lastTime, 2.147484E+09f, firedEvents, alpha, pose, direction); lastTime = -1f; } else if (lastTime >= frames[length - 1]) { return; } if (time >= frames[0]) { int num2; if (lastTime < frames[0]) { num2 = 0; } else { num2 = Animation.BinarySearch(frames, lastTime); float num3 = frames[num2]; while (num2 > 0) { if (frames[num2 - 1] != num3) { break; } num2--; } } while ((num2 < length) && (time >= frames[num2])) { firedEvents.Add(this.events[num2]); num2++; } } } }
public override void Apply(Skeleton skeleton, float lastTime, float time, ExposedList <Event> firedEvents, float alpha, MixPose pose, MixDirection direction) { PathConstraint constraint = skeleton.pathConstraints.Items[this.pathConstraintIndex]; float[] frames = this.frames; if (time < frames[0]) { if (pose != MixPose.Setup) { if (pose != MixPose.Current) { return; } } else { constraint.rotateMix = constraint.data.rotateMix; constraint.translateMix = constraint.data.translateMix; return; } constraint.rotateMix += (constraint.data.rotateMix - constraint.rotateMix) * alpha; constraint.translateMix += (constraint.data.translateMix - constraint.translateMix) * alpha; } else { float num; float num2; if (time >= frames[frames.Length - 3]) { num = frames[frames.Length + -2]; num2 = frames[frames.Length + -1]; } else { int index = Animation.BinarySearch(frames, time, 3); num = frames[index + -2]; num2 = frames[index + -1]; float num4 = frames[index]; float curvePercent = base.GetCurvePercent((index / 3) - 1, 1f - ((time - num4) / (frames[index + -3] - num4))); num += (frames[index + 1] - num) * curvePercent; num2 += (frames[index + 2] - num2) * curvePercent; } if (pose == MixPose.Setup) { constraint.rotateMix = constraint.data.rotateMix + ((num - constraint.data.rotateMix) * alpha); constraint.translateMix = constraint.data.translateMix + ((num2 - constraint.data.translateMix) * alpha); } else { constraint.rotateMix += (num - constraint.rotateMix) * alpha; constraint.translateMix += (num2 - constraint.translateMix) * alpha; } } }
public void Apply(Skeleton skeleton, float lastTime, float time, ExposedList <Event> firedEvents, float alpha, MixPose pose, MixDirection direction) { ExposedList <Slot> drawOrder = skeleton.drawOrder; ExposedList <Slot> slots = skeleton.slots; if (direction == MixDirection.Out && pose == MixPose.Setup) { Array.Copy(slots.Items, 0, drawOrder.Items, 0, slots.Count); return; } float[] array = frames; if (time < array[0]) { if (pose == MixPose.Setup) { Array.Copy(slots.Items, 0, drawOrder.Items, 0, slots.Count); } return; } int num = (!(time >= array[array.Length - 1])) ? (Animation.BinarySearch(array, time) - 1) : (array.Length - 1); int[] array2 = drawOrders[num]; if (array2 == null) { drawOrder.Clear(); int i = 0; for (int count = slots.Count; i < count; i++) { drawOrder.Add(slots.Items[i]); } return; } Slot[] items = drawOrder.Items; Slot[] items2 = slots.Items; int j = 0; for (int num2 = array2.Length; j < num2; j++) { items[j] = items2[array2[j]]; } }
public override void Apply(Skeleton skeleton, float lastTime, float time, ExposedList <Event> firedEvents, float alpha, MixPose pose, MixDirection direction) { TransformConstraint transformConstraint = skeleton.transformConstraints.Items[transformConstraintIndex]; float[] array = frames; if (time < array[0]) { TransformConstraintData data = transformConstraint.data; switch (pose) { case MixPose.Setup: transformConstraint.rotateMix = data.rotateMix; transformConstraint.translateMix = data.translateMix; transformConstraint.scaleMix = data.scaleMix; transformConstraint.shearMix = data.shearMix; break; case MixPose.Current: transformConstraint.rotateMix += (data.rotateMix - transformConstraint.rotateMix) * alpha; transformConstraint.translateMix += (data.translateMix - transformConstraint.translateMix) * alpha; transformConstraint.scaleMix += (data.scaleMix - transformConstraint.scaleMix) * alpha; transformConstraint.shearMix += (data.shearMix - transformConstraint.shearMix) * alpha; break; } return; } float num2; float num3; float num4; float num5; if (time >= array[array.Length - 5]) { int num = array.Length; num2 = array[num + -4]; num3 = array[num + -3]; num4 = array[num + -2]; num5 = array[num + -1]; } else { int num6 = Animation.BinarySearch(array, time, 5); num2 = array[num6 + -4]; num3 = array[num6 + -3]; num4 = array[num6 + -2]; num5 = array[num6 + -1]; float num7 = array[num6]; float curvePercent = GetCurvePercent(num6 / 5 - 1, 1f - (time - num7) / (array[num6 + -5] - num7)); num2 += (array[num6 + 1] - num2) * curvePercent; num3 += (array[num6 + 2] - num3) * curvePercent; num4 += (array[num6 + 3] - num4) * curvePercent; num5 += (array[num6 + 4] - num5) * curvePercent; } if (pose == MixPose.Setup) { TransformConstraintData data2 = transformConstraint.data; transformConstraint.rotateMix = data2.rotateMix + (num2 - data2.rotateMix) * alpha; transformConstraint.translateMix = data2.translateMix + (num3 - data2.translateMix) * alpha; transformConstraint.scaleMix = data2.scaleMix + (num4 - data2.scaleMix) * alpha; transformConstraint.shearMix = data2.shearMix + (num5 - data2.shearMix) * alpha; } else { transformConstraint.rotateMix += (num2 - transformConstraint.rotateMix) * alpha; transformConstraint.translateMix += (num3 - transformConstraint.translateMix) * alpha; transformConstraint.scaleMix += (num4 - transformConstraint.scaleMix) * alpha; transformConstraint.shearMix += (num5 - transformConstraint.shearMix) * alpha; } }
public override void Apply(Skeleton skeleton, float lastTime, float time, ExposedList <Event> firedEvents, float alpha, MixPose pose, MixDirection direction) { Slot slot = skeleton.slots.Items[slotIndex]; float[] array = frames; if (time < array[0]) { SlotData data = slot.data; switch (pose) { case MixPose.Setup: slot.r = data.r; slot.g = data.g; slot.b = data.b; slot.a = data.a; break; case MixPose.Current: slot.r += (slot.r - data.r) * alpha; slot.g += (slot.g - data.g) * alpha; slot.b += (slot.b - data.b) * alpha; slot.a += (slot.a - data.a) * alpha; break; } return; } float num2; float num3; float num4; float num5; if (time >= array[array.Length - 5]) { int num = array.Length; num2 = array[num + -4]; num3 = array[num + -3]; num4 = array[num + -2]; num5 = array[num + -1]; } else { int num6 = Animation.BinarySearch(array, time, 5); num2 = array[num6 + -4]; num3 = array[num6 + -3]; num4 = array[num6 + -2]; num5 = array[num6 + -1]; float num7 = array[num6]; float curvePercent = GetCurvePercent(num6 / 5 - 1, 1f - (time - num7) / (array[num6 + -5] - num7)); num2 += (array[num6 + 1] - num2) * curvePercent; num3 += (array[num6 + 2] - num3) * curvePercent; num4 += (array[num6 + 3] - num4) * curvePercent; num5 += (array[num6 + 4] - num5) * curvePercent; } if (alpha == 1f) { slot.r = num2; slot.g = num3; slot.b = num4; slot.a = num5; return; } float r; float g; float b; float a; if (pose == MixPose.Setup) { r = slot.data.r; g = slot.data.g; b = slot.data.b; a = slot.data.a; } else { r = slot.r; g = slot.g; b = slot.b; a = slot.a; } slot.r = r + (num2 - r) * alpha; slot.g = g + (num3 - g) * alpha; slot.b = b + (num4 - b) * alpha; slot.a = a + (num5 - a) * alpha; }
public override void Apply(Skeleton skeleton, float lastTime, float time, ExposedList <Event> firedEvents, float alpha, MixPose pose, MixDirection direction) { PathConstraint pathConstraint = skeleton.pathConstraints.Items[pathConstraintIndex]; float[] frames = base.frames; if (time < frames[0]) { switch (pose) { case MixPose.Setup: pathConstraint.spacing = pathConstraint.data.spacing; break; case MixPose.Current: pathConstraint.spacing += (pathConstraint.data.spacing - pathConstraint.spacing) * alpha; break; } return; } float num; if (time >= frames[frames.Length - 2]) { num = frames[frames.Length + -1]; } else { int num2 = Animation.BinarySearch(frames, time, 2); num = frames[num2 + -1]; float num3 = frames[num2]; float curvePercent = GetCurvePercent(num2 / 2 - 1, 1f - (time - num3) / (frames[num2 + -2] - num3)); num += (frames[num2 + 1] - num) * curvePercent; } if (pose == MixPose.Setup) { pathConstraint.spacing = pathConstraint.data.spacing + (num - pathConstraint.data.spacing) * alpha; } else { pathConstraint.spacing += (num - pathConstraint.spacing) * alpha; } }
public override void Apply(Skeleton skeleton, float lastTime, float time, ExposedList <Event> firedEvents, float alpha, MixPose pose, MixDirection direction) { IkConstraint constraint = skeleton.ikConstraints.Items[this.ikConstraintIndex]; float[] frames = this.frames; if (time < frames[0]) { if (pose != MixPose.Setup) { if (pose != MixPose.Current) { return; } } else { constraint.mix = constraint.data.mix; constraint.bendDirection = constraint.data.bendDirection; return; } constraint.mix += (constraint.data.mix - constraint.mix) * alpha; constraint.bendDirection = constraint.data.bendDirection; } else if (time >= frames[frames.Length - 3]) { if (pose == MixPose.Setup) { constraint.mix = constraint.data.mix + ((frames[frames.Length + -2] - constraint.data.mix) * alpha); constraint.bendDirection = (direction != MixDirection.Out) ? ((int)frames[frames.Length + -1]) : constraint.data.bendDirection; } else { constraint.mix += (frames[frames.Length + -2] - constraint.mix) * alpha; if (direction == MixDirection.In) { constraint.bendDirection = (int)frames[frames.Length + -1]; } } } else { int index = Animation.BinarySearch(frames, time, 3); float num2 = frames[index + -2]; float num3 = frames[index]; float curvePercent = base.GetCurvePercent((index / 3) - 1, 1f - ((time - num3) / (frames[index + -3] - num3))); if (pose == MixPose.Setup) { constraint.mix = constraint.data.mix + (((num2 + ((frames[index + 1] - num2) * curvePercent)) - constraint.data.mix) * alpha); constraint.bendDirection = (direction != MixDirection.Out) ? ((int)frames[index + -1]) : constraint.data.bendDirection; } else { constraint.mix += ((num2 + ((frames[index + 1] - num2) * curvePercent)) - constraint.mix) * alpha; if (direction == MixDirection.In) { constraint.bendDirection = (int)frames[index + -1]; } } } }
public override void Apply(Skeleton skeleton, float lastTime, float time, ExposedList <Event> firedEvents, float alpha, MixPose pose, MixDirection direction) { PathConstraint pathConstraint = skeleton.pathConstraints.Items[pathConstraintIndex]; float[] array = frames; if (time < array[0]) { switch (pose) { case MixPose.Setup: pathConstraint.rotateMix = pathConstraint.data.rotateMix; pathConstraint.translateMix = pathConstraint.data.translateMix; break; case MixPose.Current: pathConstraint.rotateMix += (pathConstraint.data.rotateMix - pathConstraint.rotateMix) * alpha; pathConstraint.translateMix += (pathConstraint.data.translateMix - pathConstraint.translateMix) * alpha; break; } return; } float num; float num2; if (time >= array[array.Length - 3]) { num = array[array.Length + -2]; num2 = array[array.Length + -1]; } else { int num3 = Animation.BinarySearch(array, time, 3); num = array[num3 + -2]; num2 = array[num3 + -1]; float num4 = array[num3]; float curvePercent = GetCurvePercent(num3 / 3 - 1, 1f - (time - num4) / (array[num3 + -3] - num4)); num += (array[num3 + 1] - num) * curvePercent; num2 += (array[num3 + 2] - num2) * curvePercent; } if (pose == MixPose.Setup) { pathConstraint.rotateMix = pathConstraint.data.rotateMix + (num - pathConstraint.data.rotateMix) * alpha; pathConstraint.translateMix = pathConstraint.data.translateMix + (num2 - pathConstraint.data.translateMix) * alpha; } else { pathConstraint.rotateMix += (num - pathConstraint.rotateMix) * alpha; pathConstraint.translateMix += (num2 - pathConstraint.translateMix) * alpha; } }
public override void Apply(Skeleton skeleton, float lastTime, float time, ExposedList <Event> firedEvents, float alpha, MixPose pose, MixDirection direction) { Bone bone = skeleton.bones.Items[boneIndex]; float[] frames = base.frames; if (time < frames[0]) { switch (pose) { case MixPose.Setup: bone.shearX = bone.data.shearX; bone.shearY = bone.data.shearY; break; case MixPose.Current: bone.shearX += (bone.data.shearX - bone.shearX) * alpha; bone.shearY += (bone.data.shearY - bone.shearY) * alpha; break; } return; } float num; float num2; if (time >= frames[frames.Length - 3]) { num = frames[frames.Length + -2]; num2 = frames[frames.Length + -1]; } else { int num3 = Animation.BinarySearch(frames, time, 3); num = frames[num3 + -2]; num2 = frames[num3 + -1]; float num4 = frames[num3]; float curvePercent = GetCurvePercent(num3 / 3 - 1, 1f - (time - num4) / (frames[num3 + -3] - num4)); num += (frames[num3 + 1] - num) * curvePercent; num2 += (frames[num3 + 2] - num2) * curvePercent; } if (pose == MixPose.Setup) { bone.shearX = bone.data.shearX + num * alpha; bone.shearY = bone.data.shearY + num2 * alpha; } else { bone.shearX += (bone.data.shearX + num - bone.shearX) * alpha; bone.shearY += (bone.data.shearY + num2 - bone.shearY) * alpha; } }
private float ApplyMixingFrom(TrackEntry to, Skeleton skeleton, MixPose currentPose) { float num; TrackEntry mixingFrom = to.mixingFrom; if (mixingFrom.mixingFrom != null) { this.ApplyMixingFrom(mixingFrom, skeleton, currentPose); } if (to.mixDuration == 0f) { num = 1f; currentPose = MixPose.Setup; } else { num = to.mixTime / to.mixDuration; if (num > 1f) { num = 1f; } } ExposedList <Spine.Event> events = (num >= mixingFrom.eventThreshold) ? null : this.events; bool flag = num < mixingFrom.attachmentThreshold; bool flag2 = num < mixingFrom.drawOrderThreshold; float animationLast = mixingFrom.animationLast; float animationTime = mixingFrom.AnimationTime; ExposedList <Timeline> timelines = mixingFrom.animation.timelines; int count = timelines.Count; Timeline[] items = timelines.Items; int[] numArray = mixingFrom.timelineData.Items; TrackEntry[] entryArray = mixingFrom.timelineDipMix.Items; bool firstFrame = mixingFrom.timelinesRotation.Count == 0; if (firstFrame) { mixingFrom.timelinesRotation.Resize(timelines.Count << 1); } float[] timelinesRotation = mixingFrom.timelinesRotation.Items; float num5 = mixingFrom.alpha * to.interruptAlpha; float num6 = num5 * (1f - num); mixingFrom.totalAlpha = 0f; for (int i = 0; i < count; i++) { MixPose setup; float num7; Timeline timeline = items[i]; switch (numArray[i]) { case 0: { if (flag || !(timeline is AttachmentTimeline)) { break; } continue; } case 1: setup = MixPose.Setup; num7 = num6; goto Label_01E3; case 2: setup = MixPose.Setup; num7 = num5; goto Label_01E3; default: { setup = MixPose.Setup; TrackEntry entry2 = entryArray[i]; num7 = num5 * Math.Max((float)0f, (float)(1f - (entry2.mixTime / entry2.mixDuration))); goto Label_01E3; } } if (!flag2 && (timeline is DrawOrderTimeline)) { continue; } setup = currentPose; num7 = num6; Label_01E3: mixingFrom.totalAlpha += num7; RotateTimeline rotateTimeline = timeline as RotateTimeline; if (rotateTimeline != null) { ApplyRotateTimeline(rotateTimeline, skeleton, animationTime, num7, setup, timelinesRotation, i << 1, firstFrame); } else { timeline.Apply(skeleton, animationLast, animationTime, events, num7, setup, MixDirection.Out); } } if (to.mixDuration > 0f) { this.QueueEvents(mixingFrom, animationTime); } this.events.Clear(false); mixingFrom.nextAnimationLast = animationTime; mixingFrom.nextTrackLast = mixingFrom.trackTime; return(num); }
private static void ApplyRotateTimeline(RotateTimeline rotateTimeline, Skeleton skeleton, float time, float alpha, MixPose pose, float[] timelinesRotation, int i, bool firstFrame) { if (firstFrame) { timelinesRotation[i] = 0f; } if (alpha == 1f) { rotateTimeline.Apply(skeleton, 0f, time, null, 1f, pose, MixDirection.In); } else { Bone bone = skeleton.bones.Items[rotateTimeline.boneIndex]; float[] frames = rotateTimeline.frames; if (time < frames[0]) { if (pose == MixPose.Setup) { bone.rotation = bone.data.rotation; } } else { float num; float num7; if (time >= frames[frames.Length - 2]) { num = bone.data.rotation + frames[frames.Length + -1]; } else { int index = Animation.BinarySearch(frames, time, 2); float num3 = frames[index + -1]; float num4 = frames[index]; float curvePercent = rotateTimeline.GetCurvePercent((index >> 1) - 1, 1f - ((time - num4) / (frames[index + -2] - num4))); num = frames[index + 1] - num3; num -= (0x4000 - ((int)(16384.499999999996 - (num / 360f)))) * 360; num = (num3 + (num * curvePercent)) + bone.data.rotation; num -= (0x4000 - ((int)(16384.499999999996 - (num / 360f)))) * 360; } float num6 = (pose != MixPose.Setup) ? bone.rotation : bone.data.rotation; float num8 = num - num6; if (num8 == 0f) { num7 = timelinesRotation[i]; } else { float num9; float num10; num8 -= (0x4000 - ((int)(16384.499999999996 - (num8 / 360f)))) * 360; if (firstFrame) { num9 = 0f; num10 = num8; } else { num9 = timelinesRotation[i]; num10 = timelinesRotation[i + 1]; } bool flag = num8 > 0f; bool flag2 = num9 >= 0f; if ((Math.Sign(num10) != Math.Sign(num8)) && (Math.Abs(num10) <= 90f)) { if (Math.Abs(num9) > 180f) { num9 += 360 * Math.Sign(num9); } flag2 = flag; } num7 = (num8 + num9) - (num9 % 360f); if (flag2 != flag) { num7 += 360 * Math.Sign(num9); } timelinesRotation[i] = num7; } timelinesRotation[i + 1] = num8; num6 += num7 * alpha; bone.rotation = num6 - ((0x4000 - ((int)(16384.499999999996 - (num6 / 360f)))) * 360); } } }
public bool Apply(Skeleton skeleton) { if (skeleton == null) { throw new ArgumentNullException("skeleton", "skeleton cannot be null."); } if (this.animationsChanged) { this.AnimationsChanged(); } ExposedList <Spine.Event> events = this.events; bool flag = false; TrackEntry[] items = this.tracks.Items; int index = 0; int count = this.tracks.Count; while (index < count) { TrackEntry to = items[index]; if ((to != null) && (to.delay <= 0f)) { flag = true; MixPose currentPose = (index != 0) ? MixPose.CurrentLayered : MixPose.Current; float alpha = to.alpha; if (to.mixingFrom != null) { alpha *= this.ApplyMixingFrom(to, skeleton, currentPose); } else if ((to.trackTime >= to.trackEnd) && (to.next == null)) { alpha = 0f; } float animationLast = to.animationLast; float animationTime = to.AnimationTime; int num6 = to.animation.timelines.Count; ExposedList <Timeline> timelines = to.animation.timelines; Timeline[] timelineArray = timelines.Items; if (alpha == 1f) { for (int i = 0; i < num6; i++) { timelineArray[i].Apply(skeleton, animationLast, animationTime, events, 1f, MixPose.Setup, MixDirection.In); } } else { int[] numArray = to.timelineData.Items; bool firstFrame = to.timelinesRotation.Count == 0; if (firstFrame) { to.timelinesRotation.EnsureCapacity(timelines.Count << 1); } float[] timelinesRotation = to.timelinesRotation.Items; for (int i = 0; i < num6; i++) { Timeline timeline = timelineArray[i]; MixPose pose = (numArray[i] < 1) ? currentPose : MixPose.Setup; RotateTimeline rotateTimeline = timeline as RotateTimeline; if (rotateTimeline != null) { ApplyRotateTimeline(rotateTimeline, skeleton, animationTime, alpha, pose, timelinesRotation, i << 1, firstFrame); } else { timeline.Apply(skeleton, animationLast, animationTime, events, alpha, pose, MixDirection.In); } } } this.QueueEvents(to, animationTime); events.Clear(false); to.nextAnimationLast = animationTime; to.nextTrackLast = to.trackTime; } index++; } this.queue.Drain(); return(flag); }
public override void Apply(Skeleton skeleton, float lastTime, float time, ExposedList <Event> firedEvents, float alpha, MixPose pose, MixDirection direction) { Slot slot = skeleton.slots.Items[slotIndex]; float[] array = frames; if (time < array[0]) { SlotData data = slot.data; switch (pose) { case MixPose.Setup: slot.r = data.r; slot.g = data.g; slot.b = data.b; slot.a = data.a; slot.r2 = data.r2; slot.g2 = data.g2; slot.b2 = data.b2; break; case MixPose.Current: slot.r += (slot.r - data.r) * alpha; slot.g += (slot.g - data.g) * alpha; slot.b += (slot.b - data.b) * alpha; slot.a += (slot.a - data.a) * alpha; slot.r2 += (slot.r2 - data.r2) * alpha; slot.g2 += (slot.g2 - data.g2) * alpha; slot.b2 += (slot.b2 - data.b2) * alpha; break; } return; } float num2; float num3; float num4; float num5; float num6; float num7; float num8; if (time >= array[array.Length - 8]) { int num = array.Length; num2 = array[num + -7]; num3 = array[num + -6]; num4 = array[num + -5]; num5 = array[num + -4]; num6 = array[num + -3]; num7 = array[num + -2]; num8 = array[num + -1]; } else { int num9 = Animation.BinarySearch(array, time, 8); num2 = array[num9 + -7]; num3 = array[num9 + -6]; num4 = array[num9 + -5]; num5 = array[num9 + -4]; num6 = array[num9 + -3]; num7 = array[num9 + -2]; num8 = array[num9 + -1]; float num10 = array[num9]; float curvePercent = GetCurvePercent(num9 / 8 - 1, 1f - (time - num10) / (array[num9 + -8] - num10)); num2 += (array[num9 + 1] - num2) * curvePercent; num3 += (array[num9 + 2] - num3) * curvePercent; num4 += (array[num9 + 3] - num4) * curvePercent; num5 += (array[num9 + 4] - num5) * curvePercent; num6 += (array[num9 + 5] - num6) * curvePercent; num7 += (array[num9 + 6] - num7) * curvePercent; num8 += (array[num9 + 7] - num8) * curvePercent; } if (alpha == 1f) { slot.r = num2; slot.g = num3; slot.b = num4; slot.a = num5; slot.r2 = num6; slot.g2 = num7; slot.b2 = num8; return; } float r; float g; float b; float a; float r2; float g2; float b2; if (pose == MixPose.Setup) { r = slot.data.r; g = slot.data.g; b = slot.data.b; a = slot.data.a; r2 = slot.data.r2; g2 = slot.data.g2; b2 = slot.data.b2; } else { r = slot.r; g = slot.g; b = slot.b; a = slot.a; r2 = slot.r2; g2 = slot.g2; b2 = slot.b2; } slot.r = r + (num2 - r) * alpha; slot.g = g + (num3 - g) * alpha; slot.b = b + (num4 - b) * alpha; slot.a = a + (num5 - a) * alpha; slot.r2 = r2 + (num6 - r2) * alpha; slot.g2 = g2 + (num7 - g2) * alpha; slot.b2 = b2 + (num8 - b2) * alpha; }
public void Apply(Skeleton skeleton, float lastTime, float time, ExposedList <Event> firedEvents, float alpha, MixPose pose, MixDirection direction) { ExposedList <Slot> drawOrder = skeleton.drawOrder; ExposedList <Slot> slots = skeleton.slots; if ((direction == MixDirection.Out) && (pose == MixPose.Setup)) { Array.Copy(slots.Items, 0, drawOrder.Items, 0, slots.Count); } else { float[] frames = this.frames; if (time < frames[0]) { if (pose == MixPose.Setup) { Array.Copy(slots.Items, 0, drawOrder.Items, 0, slots.Count); } } else { int num; if (time >= frames[frames.Length - 1]) { num = frames.Length - 1; } else { num = Animation.BinarySearch(frames, time) - 1; } int[] numArray2 = this.drawOrders[num]; if (numArray2 == null) { drawOrder.Clear(true); int index = 0; int count = slots.Count; while (index < count) { drawOrder.Add(slots.Items[index]); index++; } } else { Slot[] items = drawOrder.Items; Slot[] slotArray2 = slots.Items; int index = 0; int length = numArray2.Length; while (index < length) { items[index] = slotArray2[numArray2[index]]; index++; } } } } }
public override void Apply(Skeleton skeleton, float lastTime, float time, ExposedList <Event> firedEvents, float alpha, MixPose pose, MixDirection direction) { Bone bone = skeleton.bones.Items[base.boneIndex]; float[] frames = base.frames; if (time < frames[0]) { if (pose != MixPose.Setup) { if (pose != MixPose.Current) { return; } } else { bone.shearX = bone.data.shearX; bone.shearY = bone.data.shearY; return; } bone.shearX += (bone.data.shearX - bone.shearX) * alpha; bone.shearY += (bone.data.shearY - bone.shearY) * alpha; } else { float num; float num2; if (time >= frames[frames.Length - 3]) { num = frames[frames.Length + -2]; num2 = frames[frames.Length + -1]; } else { int index = Animation.BinarySearch(frames, time, 3); num = frames[index + -2]; num2 = frames[index + -1]; float num4 = frames[index]; float curvePercent = base.GetCurvePercent((index / 3) - 1, 1f - ((time - num4) / (frames[index + -3] - num4))); num += (frames[index + 1] - num) * curvePercent; num2 += (frames[index + 2] - num2) * curvePercent; } if (pose == MixPose.Setup) { bone.shearX = bone.data.shearX + (num * alpha); bone.shearY = bone.data.shearY + (num2 * alpha); } else { bone.shearX += ((bone.data.shearX + num) - bone.shearX) * alpha; bone.shearY += ((bone.data.shearY + num2) - bone.shearY) * alpha; } } }
public override void Apply(Skeleton skeleton, float lastTime, float time, ExposedList <Event> firedEvents, float alpha, MixPose pose, MixDirection direction) { Bone bone = skeleton.bones.Items[base.boneIndex]; float[] frames = base.frames; if (time < frames[0]) { if (pose != MixPose.Setup) { if (pose != MixPose.Current) { return; } } else { bone.scaleX = bone.data.scaleX; bone.scaleY = bone.data.scaleY; return; } bone.scaleX += (bone.data.scaleX - bone.scaleX) * alpha; bone.scaleY += (bone.data.scaleY - bone.scaleY) * alpha; } else { float num; float num2; if (time >= frames[frames.Length - 3]) { num = frames[frames.Length + -2] * bone.data.scaleX; num2 = frames[frames.Length + -1] * bone.data.scaleY; } else { int index = Animation.BinarySearch(frames, time, 3); num = frames[index + -2]; num2 = frames[index + -1]; float num4 = frames[index]; float curvePercent = base.GetCurvePercent((index / 3) - 1, 1f - ((time - num4) / (frames[index + -3] - num4))); num = (num + ((frames[index + 1] - num) * curvePercent)) * bone.data.scaleX; num2 = (num2 + ((frames[index + 2] - num2) * curvePercent)) * bone.data.scaleY; } if (alpha == 1f) { bone.scaleX = num; bone.scaleY = num2; } else { float scaleX; float scaleY; if (pose == MixPose.Setup) { scaleX = bone.data.scaleX; scaleY = bone.data.scaleY; } else { scaleX = bone.scaleX; scaleY = bone.scaleY; } if (direction == MixDirection.Out) { num = ((num < 0f) ? -num : num) * ((scaleX < 0f) ? ((float)(-1)) : ((float)1)); num2 = ((num2 < 0f) ? -num2 : num2) * ((scaleY < 0f) ? ((float)(-1)) : ((float)1)); } else { scaleX = ((scaleX < 0f) ? -scaleX : scaleX) * ((num < 0f) ? ((float)(-1)) : ((float)1)); scaleY = ((scaleY < 0f) ? -scaleY : scaleY) * ((num2 < 0f) ? ((float)(-1)) : ((float)1)); } bone.scaleX = scaleX + ((num - scaleX) * alpha); bone.scaleY = scaleY + ((num2 - scaleY) * alpha); } } }
public void Apply(Skeleton skeleton, float lastTime, float time, ExposedList <Event> firedEvents, float alpha, MixPose pose, MixDirection direction) { string attachmentName; Slot slot = skeleton.slots.Items[this.slotIndex]; if ((direction == MixDirection.Out) && (pose == MixPose.Setup)) { attachmentName = slot.data.attachmentName; slot.Attachment = (attachmentName != null) ? skeleton.GetAttachment(this.slotIndex, attachmentName) : null; } else { float[] frames = this.frames; if (time < frames[0]) { if (pose == MixPose.Setup) { attachmentName = slot.data.attachmentName; slot.Attachment = (attachmentName != null) ? skeleton.GetAttachment(this.slotIndex, attachmentName) : null; } } else { int num; if (time >= frames[frames.Length - 1]) { num = frames.Length - 1; } else { num = Animation.BinarySearch(frames, time, 1) - 1; } attachmentName = this.attachmentNames[num]; slot.Attachment = (attachmentName != null) ? skeleton.GetAttachment(this.slotIndex, attachmentName) : null; } } }
public override void Apply(Skeleton skeleton, float lastTime, float time, ExposedList <Event> firedEvents, float alpha, MixPose pose, MixDirection direction) { Bone bone = skeleton.bones.Items[boneIndex]; float[] array = frames; if (time < array[0]) { switch (pose) { case MixPose.Setup: bone.x = bone.data.x; bone.y = bone.data.y; break; case MixPose.Current: bone.x += (bone.data.x - bone.x) * alpha; bone.y += (bone.data.y - bone.y) * alpha; break; } return; } float num; float num2; if (time >= array[array.Length - 3]) { num = array[array.Length + -2]; num2 = array[array.Length + -1]; } else { int num3 = Animation.BinarySearch(array, time, 3); num = array[num3 + -2]; num2 = array[num3 + -1]; float num4 = array[num3]; float curvePercent = GetCurvePercent(num3 / 3 - 1, 1f - (time - num4) / (array[num3 + -3] - num4)); num += (array[num3 + 1] - num) * curvePercent; num2 += (array[num3 + 2] - num2) * curvePercent; } if (pose == MixPose.Setup) { bone.x = bone.data.x + num * alpha; bone.y = bone.data.y + num2 * alpha; } else { bone.x += (bone.data.x + num - bone.x) * alpha; bone.y += (bone.data.y + num2 - bone.y) * alpha; } }
public override void Apply(Skeleton skeleton, float lastTime, float time, ExposedList <Event> firedEvents, float alpha, MixPose pose, MixDirection direction) { Slot slot = skeleton.slots.Items[this.slotIndex]; VertexAttachment attachment = slot.attachment as VertexAttachment; if ((attachment != null) && attachment.ApplyDeform(this.attachment)) { float[] items; ExposedList <float> attachmentVertices = slot.attachmentVertices; if (attachmentVertices.Count == 0) { alpha = 1f; } float[][] frameVertices = this.frameVertices; int length = frameVertices[0].Length; float[] frames = this.frames; if (time < frames[0]) { if (pose != MixPose.Setup) { if (pose != MixPose.Current) { return; } } else { attachmentVertices.Clear(true); return; } if (alpha == 1f) { attachmentVertices.Clear(true); } else { if (attachmentVertices.Capacity < length) { attachmentVertices.Capacity = length; } attachmentVertices.Count = length; items = attachmentVertices.Items; if (attachment.bones == null) { float[] vertices = attachment.vertices; for (int i = 0; i < length; i++) { items[i] += (vertices[i] - items[i]) * alpha; } } else { alpha = 1f - alpha; for (int i = 0; i < length; i++) { items[i] *= alpha; } } } } else { if (attachmentVertices.Capacity < length) { attachmentVertices.Capacity = length; } attachmentVertices.Count = length; items = attachmentVertices.Items; if (time >= frames[frames.Length - 1]) { float[] sourceArray = frameVertices[frames.Length - 1]; if (alpha == 1f) { Array.Copy(sourceArray, 0, items, 0, length); } else if (pose == MixPose.Setup) { if (attachment.bones == null) { float[] vertices = attachment.vertices; for (int i = 0; i < length; i++) { float num5 = vertices[i]; items[i] = num5 + ((sourceArray[i] - num5) * alpha); } } else { for (int i = 0; i < length; i++) { items[i] = sourceArray[i] * alpha; } } } else { for (int i = 0; i < length; i++) { items[i] += (sourceArray[i] - items[i]) * alpha; } } } else { int index = Animation.BinarySearch(frames, time); float[] numArray7 = frameVertices[index - 1]; float[] numArray8 = frameVertices[index]; float num9 = frames[index]; float curvePercent = base.GetCurvePercent(index - 1, 1f - ((time - num9) / (frames[index - 1] - num9))); if (alpha == 1f) { for (int i = 0; i < length; i++) { float num12 = numArray7[i]; items[i] = num12 + ((numArray8[i] - num12) * curvePercent); } } else if (pose == MixPose.Setup) { if (attachment.bones == null) { float[] vertices = attachment.vertices; for (int i = 0; i < length; i++) { float num14 = numArray7[i]; float num15 = vertices[i]; items[i] = num15 + (((num14 + ((numArray8[i] - num14) * curvePercent)) - num15) * alpha); } } else { for (int i = 0; i < length; i++) { float num17 = numArray7[i]; items[i] = (num17 + ((numArray8[i] - num17) * curvePercent)) * alpha; } } } else { for (int i = 0; i < length; i++) { float num19 = numArray7[i]; items[i] += ((num19 + ((numArray8[i] - num19) * curvePercent)) - items[i]) * alpha; } } } } } }
public bool Apply(Skeleton skeleton) { if (skeleton == null) { throw new ArgumentNullException("skeleton", "skeleton cannot be null."); } if (animationsChanged) { AnimationsChanged(); } ExposedList <Event> exposedList = events; bool result = false; TrackEntry[] items = tracks.Items; int i = 0; for (int count = tracks.Count; i < count; i++) { TrackEntry trackEntry = items[i]; if (trackEntry == null || trackEntry.delay > 0f) { continue; } result = true; MixPose mixPose = (i == 0) ? MixPose.Current : MixPose.CurrentLayered; float num = trackEntry.alpha; if (trackEntry.mixingFrom != null) { num *= ApplyMixingFrom(trackEntry, skeleton, mixPose); } else if (trackEntry.trackTime >= trackEntry.trackEnd && trackEntry.next == null) { num = 0f; } float animationLast = trackEntry.animationLast; float animationTime = trackEntry.AnimationTime; int count2 = trackEntry.animation.timelines.Count; ExposedList <Timeline> timelines = trackEntry.animation.timelines; Timeline[] items2 = timelines.Items; if (num == 1f) { for (int j = 0; j < count2; j++) { items2[j].Apply(skeleton, animationLast, animationTime, exposedList, 1f, MixPose.Setup, MixDirection.In); } } else { int[] items3 = trackEntry.timelineData.Items; bool flag = trackEntry.timelinesRotation.Count == 0; if (flag) { trackEntry.timelinesRotation.EnsureCapacity(timelines.Count << 1); } float[] items4 = trackEntry.timelinesRotation.Items; for (int k = 0; k < count2; k++) { Timeline timeline = items2[k]; MixPose pose = (items3[k] < 1) ? mixPose : MixPose.Setup; RotateTimeline rotateTimeline = timeline as RotateTimeline; if (rotateTimeline != null) { ApplyRotateTimeline(rotateTimeline, skeleton, animationTime, num, pose, items4, k << 1, flag); } else { timeline.Apply(skeleton, animationLast, animationTime, exposedList, num, pose, MixDirection.In); } } } QueueEvents(trackEntry, animationTime); exposedList.Clear(clearArray: false); trackEntry.nextAnimationLast = animationTime; trackEntry.nextTrackLast = trackEntry.trackTime; } queue.Drain(); return(result); }
public override void Apply(Skeleton skeleton, float lastTime, float time, ExposedList <Event> firedEvents, float alpha, MixPose pose, MixDirection direction) { IkConstraint ikConstraint = skeleton.ikConstraints.Items[ikConstraintIndex]; float[] array = frames; if (time < array[0]) { switch (pose) { case MixPose.Setup: ikConstraint.mix = ikConstraint.data.mix; ikConstraint.bendDirection = ikConstraint.data.bendDirection; break; case MixPose.Current: ikConstraint.mix += (ikConstraint.data.mix - ikConstraint.mix) * alpha; ikConstraint.bendDirection = ikConstraint.data.bendDirection; break; } return; } if (time >= array[array.Length - 3]) { if (pose == MixPose.Setup) { ikConstraint.mix = ikConstraint.data.mix + (array[array.Length + -2] - ikConstraint.data.mix) * alpha; ikConstraint.bendDirection = ((direction != MixDirection.Out) ? ((int)array[array.Length + -1]) : ikConstraint.data.bendDirection); return; } ikConstraint.mix += (array[array.Length + -2] - ikConstraint.mix) * alpha; if (direction == MixDirection.In) { ikConstraint.bendDirection = (int)array[array.Length + -1]; } return; } int num = Animation.BinarySearch(array, time, 3); float num2 = array[num + -2]; float num3 = array[num]; float curvePercent = GetCurvePercent(num / 3 - 1, 1f - (time - num3) / (array[num + -3] - num3)); if (pose == MixPose.Setup) { ikConstraint.mix = ikConstraint.data.mix + (num2 + (array[num + 1] - num2) * curvePercent - ikConstraint.data.mix) * alpha; ikConstraint.bendDirection = ((direction != MixDirection.Out) ? ((int)array[num + -1]) : ikConstraint.data.bendDirection); return; } ikConstraint.mix += (num2 + (array[num + 1] - num2) * curvePercent - ikConstraint.mix) * alpha; if (direction == MixDirection.In) { ikConstraint.bendDirection = (int)array[num + -1]; } }
private float ApplyMixingFrom(TrackEntry to, Skeleton skeleton, MixPose currentPose) { TrackEntry mixingFrom = to.mixingFrom; if (mixingFrom.mixingFrom != null) { ApplyMixingFrom(mixingFrom, skeleton, currentPose); } float num; if (to.mixDuration == 0f) { num = 1f; } else { num = to.mixTime / to.mixDuration; if (num > 1f) { num = 1f; } } ExposedList <Event> exposedList = (!(num < mixingFrom.eventThreshold)) ? null : events; bool flag = num < mixingFrom.attachmentThreshold; bool flag2 = num < mixingFrom.drawOrderThreshold; float animationLast = mixingFrom.animationLast; float animationTime = mixingFrom.AnimationTime; ExposedList <Timeline> timelines = mixingFrom.animation.timelines; int count = timelines.Count; Timeline[] items = timelines.Items; int[] items2 = mixingFrom.timelineData.Items; TrackEntry[] items3 = mixingFrom.timelineDipMix.Items; bool flag3 = mixingFrom.timelinesRotation.Count == 0; if (flag3) { mixingFrom.timelinesRotation.Resize(timelines.Count << 1); } float[] items4 = mixingFrom.timelinesRotation.Items; float num2 = mixingFrom.alpha * to.interruptAlpha; float num3 = num2 * (1f - num); mixingFrom.totalAlpha = 0f; for (int i = 0; i < count; i++) { Timeline timeline = items[i]; MixPose pose; float num4; switch (items2[i]) { case 0: if ((!flag && timeline is AttachmentTimeline) || (!flag2 && timeline is DrawOrderTimeline)) { continue; } pose = currentPose; num4 = num3; break; case 1: pose = MixPose.Setup; num4 = num3; break; case 2: pose = MixPose.Setup; num4 = num2; break; default: { pose = MixPose.Setup; num4 = num2; TrackEntry trackEntry = items3[i]; num4 *= Math.Max(0f, 1f - trackEntry.mixTime / trackEntry.mixDuration); break; } } mixingFrom.totalAlpha += num4; RotateTimeline rotateTimeline = timeline as RotateTimeline; if (rotateTimeline != null) { ApplyRotateTimeline(rotateTimeline, skeleton, animationTime, num4, pose, items4, i << 1, flag3); } else { timeline.Apply(skeleton, animationLast, animationTime, exposedList, num4, pose, MixDirection.Out); } } if (to.mixDuration > 0f) { QueueEvents(mixingFrom, animationTime); } events.Clear(clearArray: false); mixingFrom.nextAnimationLast = animationTime; mixingFrom.nextTrackLast = mixingFrom.trackTime; return(num); }
public override void Apply(Skeleton skeleton, float lastTime, float time, ExposedList <Event> firedEvents, float alpha, MixPose pose, MixDirection direction) { PathConstraint constraint = skeleton.pathConstraints.Items[this.pathConstraintIndex]; float[] frames = this.frames; if (time < frames[0]) { if (pose != MixPose.Setup) { if (pose != MixPose.Current) { return; } } else { constraint.position = constraint.data.position; return; } constraint.position += (constraint.data.position - constraint.position) * alpha; } else { float num; if (time >= frames[frames.Length - 2]) { num = frames[frames.Length + -1]; } else { int index = Animation.BinarySearch(frames, time, 2); num = frames[index + -1]; float num3 = frames[index]; float curvePercent = base.GetCurvePercent((index / 2) - 1, 1f - ((time - num3) / (frames[index + -2] - num3))); num += (frames[index + 1] - num) * curvePercent; } if (pose == MixPose.Setup) { constraint.position = constraint.data.position + ((num - constraint.data.position) * alpha); } else { constraint.position += (num - constraint.position) * alpha; } } }
private static void ApplyRotateTimeline(RotateTimeline rotateTimeline, Skeleton skeleton, float time, float alpha, MixPose pose, float[] timelinesRotation, int i, bool firstFrame) { if (firstFrame) { timelinesRotation[i] = 0f; } if (alpha == 1f) { rotateTimeline.Apply(skeleton, 0f, time, null, 1f, pose, MixDirection.In); return; } Bone bone = skeleton.bones.Items[rotateTimeline.boneIndex]; float[] frames = rotateTimeline.frames; if (time < frames[0]) { if (pose == MixPose.Setup) { bone.rotation = bone.data.rotation; } return; } float num; if (time >= frames[frames.Length - 2]) { num = bone.data.rotation + frames[frames.Length + -1]; } else { int num2 = Animation.BinarySearch(frames, time, 2); float num3 = frames[num2 + -1]; float num4 = frames[num2]; float curvePercent = rotateTimeline.GetCurvePercent((num2 >> 1) - 1, 1f - (time - num4) / (frames[num2 + -2] - num4)); num = frames[num2 + 1] - num3; num -= (float)((16384 - (int)(16384.499999999996 - (double)(num / 360f))) * 360); num = num3 + num * curvePercent + bone.data.rotation; num -= (float)((16384 - (int)(16384.499999999996 - (double)(num / 360f))) * 360); } float num5 = (pose != 0) ? bone.rotation : bone.data.rotation; float num6 = num - num5; float num7; if (num6 == 0f) { num7 = timelinesRotation[i]; } else { num6 -= (float)((16384 - (int)(16384.499999999996 - (double)(num6 / 360f))) * 360); float num8; float value; if (firstFrame) { num8 = 0f; value = num6; } else { num8 = timelinesRotation[i]; value = timelinesRotation[i + 1]; } bool flag = num6 > 0f; bool flag2 = num8 >= 0f; if (Math.Sign(value) != Math.Sign(num6) && Math.Abs(value) <= 90f) { if (Math.Abs(num8) > 180f) { num8 += (float)(360 * Math.Sign(num8)); } flag2 = flag; } num7 = num6 + num8 - num8 % 360f; if (flag2 != flag) { num7 += (float)(360 * Math.Sign(num8)); } timelinesRotation[i] = num7; } timelinesRotation[i + 1] = num6; num5 += num7 * alpha; bone.rotation = num5 - (float)((16384 - (int)(16384.499999999996 - (double)(num5 / 360f))) * 360); }
public void Apply(Skeleton skeleton, float lastTime, float time, bool loop, ExposedList <Event> events, float alpha, MixPose pose, MixDirection direction) { if (skeleton == null) { throw new ArgumentNullException("skeleton", "skeleton cannot be null."); } if (loop && duration != 0f) { time %= duration; if (lastTime > 0f) { lastTime %= duration; } } ExposedList <Timeline> exposedList = timelines; int i = 0; for (int count = exposedList.Count; i < count; i++) { exposedList.Items[i].Apply(skeleton, lastTime, time, events, alpha, pose, direction); } }
public override void Apply(Skeleton skeleton, float lastTime, float time, ExposedList <Event> firedEvents, float alpha, MixPose pose, MixDirection direction) { Slot slot = skeleton.slots.Items[this.slotIndex]; float[] frames = this.frames; if (time < frames[0]) { SlotData data = slot.data; if (pose != MixPose.Setup) { if (pose != MixPose.Current) { return; } } else { slot.r = data.r; slot.g = data.g; slot.b = data.b; slot.a = data.a; slot.r2 = data.r2; slot.g2 = data.g2; slot.b2 = data.b2; return; } slot.r += (slot.r - data.r) * alpha; slot.g += (slot.g - data.g) * alpha; slot.b += (slot.b - data.b) * alpha; slot.a += (slot.a - data.a) * alpha; slot.r2 += (slot.r2 - data.r2) * alpha; slot.g2 += (slot.g2 - data.g2) * alpha; slot.b2 += (slot.b2 - data.b2) * alpha; } else { float num; float num2; float num3; float num4; float num5; float num6; float num7; if (time >= frames[frames.Length - 8]) { int length = frames.Length; num = frames[length + -7]; num2 = frames[length + -6]; num3 = frames[length + -5]; num4 = frames[length + -4]; num5 = frames[length + -3]; num6 = frames[length + -2]; num7 = frames[length + -1]; } else { int index = Animation.BinarySearch(frames, time, 8); num = frames[index + -7]; num2 = frames[index + -6]; num3 = frames[index + -5]; num4 = frames[index + -4]; num5 = frames[index + -3]; num6 = frames[index + -2]; num7 = frames[index + -1]; float num10 = frames[index]; float curvePercent = base.GetCurvePercent((index / 8) - 1, 1f - ((time - num10) / (frames[index + -8] - num10))); num += (frames[index + 1] - num) * curvePercent; num2 += (frames[index + 2] - num2) * curvePercent; num3 += (frames[index + 3] - num3) * curvePercent; num4 += (frames[index + 4] - num4) * curvePercent; num5 += (frames[index + 5] - num5) * curvePercent; num6 += (frames[index + 6] - num6) * curvePercent; num7 += (frames[index + 7] - num7) * curvePercent; } if (alpha == 1f) { slot.r = num; slot.g = num2; slot.b = num3; slot.a = num4; slot.r2 = num5; slot.g2 = num6; slot.b2 = num7; } else { float r; float g; float b; float a; float num16; float num17; float num18; if (pose == MixPose.Setup) { r = slot.data.r; g = slot.data.g; b = slot.data.b; a = slot.data.a; num16 = slot.data.r2; num17 = slot.data.g2; num18 = slot.data.b2; } else { r = slot.r; g = slot.g; b = slot.b; a = slot.a; num16 = slot.r2; num17 = slot.g2; num18 = slot.b2; } slot.r = r + ((num - r) * alpha); slot.g = g + ((num2 - g) * alpha); slot.b = b + ((num3 - b) * alpha); slot.a = a + ((num4 - a) * alpha); slot.r2 = num16 + ((num5 - num16) * alpha); slot.g2 = num17 + ((num6 - num17) * alpha); slot.b2 = num18 + ((num7 - num18) * alpha); } } }
public override void Apply(Skeleton skeleton, float lastTime, float time, ExposedList <Event> firedEvents, float alpha, MixPose pose, MixDirection direction) { TransformConstraint constraint = skeleton.transformConstraints.Items[this.transformConstraintIndex]; float[] frames = this.frames; if (time < frames[0]) { TransformConstraintData data = constraint.data; if (pose != MixPose.Setup) { if (pose != MixPose.Current) { return; } } else { constraint.rotateMix = data.rotateMix; constraint.translateMix = data.translateMix; constraint.scaleMix = data.scaleMix; constraint.shearMix = data.shearMix; return; } constraint.rotateMix += (data.rotateMix - constraint.rotateMix) * alpha; constraint.translateMix += (data.translateMix - constraint.translateMix) * alpha; constraint.scaleMix += (data.scaleMix - constraint.scaleMix) * alpha; constraint.shearMix += (data.shearMix - constraint.shearMix) * alpha; } else { float num; float num2; float num3; float num4; if (time >= frames[frames.Length - 5]) { int length = frames.Length; num = frames[length + -4]; num2 = frames[length + -3]; num3 = frames[length + -2]; num4 = frames[length + -1]; } else { int index = Animation.BinarySearch(frames, time, 5); num = frames[index + -4]; num2 = frames[index + -3]; num3 = frames[index + -2]; num4 = frames[index + -1]; float num7 = frames[index]; float curvePercent = base.GetCurvePercent((index / 5) - 1, 1f - ((time - num7) / (frames[index + -5] - num7))); num += (frames[index + 1] - num) * curvePercent; num2 += (frames[index + 2] - num2) * curvePercent; num3 += (frames[index + 3] - num3) * curvePercent; num4 += (frames[index + 4] - num4) * curvePercent; } if (pose == MixPose.Setup) { TransformConstraintData data = constraint.data; constraint.rotateMix = data.rotateMix + ((num - data.rotateMix) * alpha); constraint.translateMix = data.translateMix + ((num2 - data.translateMix) * alpha); constraint.scaleMix = data.scaleMix + ((num3 - data.scaleMix) * alpha); constraint.shearMix = data.shearMix + ((num4 - data.shearMix) * alpha); } else { constraint.rotateMix += (num - constraint.rotateMix) * alpha; constraint.translateMix += (num2 - constraint.translateMix) * alpha; constraint.scaleMix += (num3 - constraint.scaleMix) * alpha; constraint.shearMix += (num4 - constraint.shearMix) * alpha; } } }
public override void Apply(Skeleton skeleton, float lastTime, float time, ExposedList <Event> firedEvents, float alpha, MixPose pose, MixDirection direction) { Slot slot = skeleton.slots.Items[slotIndex]; VertexAttachment vertexAttachment = slot.attachment as VertexAttachment; if (vertexAttachment == null || !vertexAttachment.ApplyDeform(attachment)) { return; } ExposedList <float> attachmentVertices = slot.attachmentVertices; float[][] array = frameVertices; int num = array[0].Length; if (attachmentVertices.Capacity < num) { attachmentVertices.Capacity = num; } attachmentVertices.Count = num; float[] items = attachmentVertices.Items; float[] array2 = frames; if (time < array2[0]) { switch (pose) { case MixPose.Setup: { float[] array3; if (vertexAttachment.bones == null) { array3 = vertexAttachment.vertices; } else { array3 = zeros; if (array3.Length < num) { array3 = (zeros = new float[num]); } } Array.Copy(array3, 0, items, 0, num); break; } case MixPose.Current: if (alpha == 1f) { break; } if (vertexAttachment.bones == null) { float[] vertices = vertexAttachment.vertices; for (int i = 0; i < num; i++) { items[i] += (vertices[i] - items[i]) * alpha; } } else { alpha = 1f - alpha; for (int j = 0; j < num; j++) { items[j] *= alpha; } } break; } return; } if (time >= array2[array2.Length - 1]) { float[] array4 = array[array2.Length - 1]; if (alpha == 1f) { Array.Copy(array4, 0, items, 0, num); } else if (pose == MixPose.Setup) { if (vertexAttachment.bones == null) { float[] vertices2 = vertexAttachment.vertices; for (int k = 0; k < num; k++) { float num2 = vertices2[k]; items[k] = num2 + (array4[k] - num2) * alpha; } } else { for (int l = 0; l < num; l++) { items[l] = array4[l] * alpha; } } } else { for (int m = 0; m < num; m++) { items[m] += (array4[m] - items[m]) * alpha; } } return; } int num3 = Animation.BinarySearch(array2, time); float[] array5 = array[num3 - 1]; float[] array6 = array[num3]; float num4 = array2[num3]; float curvePercent = GetCurvePercent(num3 - 1, 1f - (time - num4) / (array2[num3 - 1] - num4)); if (alpha == 1f) { for (int n = 0; n < num; n++) { float num5 = array5[n]; items[n] = num5 + (array6[n] - num5) * curvePercent; } } else if (pose == MixPose.Setup) { if (vertexAttachment.bones == null) { float[] vertices3 = vertexAttachment.vertices; for (int num6 = 0; num6 < num; num6++) { float num7 = array5[num6]; float num8 = vertices3[num6]; items[num6] = num8 + (num7 + (array6[num6] - num7) * curvePercent - num8) * alpha; } } else { for (int num9 = 0; num9 < num; num9++) { float num10 = array5[num9]; items[num9] = (num10 + (array6[num9] - num10) * curvePercent) * alpha; } } } else { for (int num11 = 0; num11 < num; num11++) { float num12 = array5[num11]; items[num11] += (num12 + (array6[num11] - num12) * curvePercent - items[num11]) * alpha; } } }
public abstract void Apply(Skeleton skeleton, float lastTime, float time, ExposedList <Event> firedEvents, float alpha, MixPose pose, MixDirection direction);
// NOTE: This function is called at runtime and edit time. Keep that in mind when setting the values of properties. public override void ProcessFrame(Playable playable, FrameData info, object playerData) { trackBindingSkeletonAnimation = playerData as SkeletonAnimation; if (!trackBindingSkeletonAnimation) { return; } int inputCount = playable.GetInputCount(); if (trackBindingSkeleton == null) { trackBindingSkeleton = trackBindingSkeletonAnimation.Skeleton; } //trackBindingSkeleton.SetToSetupPose(); for (int i = 0; i < inputCount; i++) { var inputPlayable = (ScriptPlayable <SpineAnimationBehaviour>)playable.GetInput(i); // The clip var clipBehaviourData = inputPlayable.GetBehaviour(); // the stateless data clipBehaviourData.EnsureInitialize(trackBindingSkeleton.Data); var animation = clipBehaviourData.animation; if (animation != null) { animation.SetKeyedItemsToSetupPose(trackBindingSkeleton); } } float totalWeight = 0f; int currentInputs = 0; for (int i = 0; i < inputCount; i++) { float inputWeight = playable.GetInputWeight(i); var inputPlayable = (ScriptPlayable <SpineAnimationBehaviour>)playable.GetInput(i); // The clip var clipBehaviourData = inputPlayable.GetBehaviour(); // the stateless data float time = (float)inputPlayable.GetTime(); // clip time. totalWeight += inputWeight; // clipBehaviourData.EnsureInitialize(trackBindingSkeleton.Data); var animation = clipBehaviourData.animation; if (animation != null) { if (!Mathf.Approximately(inputWeight, 0f)) { MixPose mixPose = currentInputs == 0 ? MixPose.Setup : MixPose.Current; MixDirection mixDirection = MixDirection.In; if (inputWeight < 1 && currentInputs > 1) { mixDirection = MixDirection.Out; } animation.Apply(trackBindingSkeleton, 0f, time, clipBehaviourData.loop, null, inputWeight, mixPose, mixDirection); Debug.LogFormat("Applying {0} at {1} as input [{2}] using {3} {4}", animation.Name, inputWeight, i, mixPose, mixDirection); currentInputs++; } else { //animation.Apply(trackBindingSkeleton, 0f, time, clipBehaviourData.loop, null, 0, MixPose.Current, MixDirection.Out); continue; } } // SPINETODO: Translate AnimationState into MixerBehaviour for robustness. } }