From 2c78e228554c05ed08a81441db1dcf92338cbeb4 Mon Sep 17 00:00:00 2001 From: NathanSweet Date: Wed, 20 Feb 2013 01:15:31 +0100 Subject: [PATCH] Initial libgdx runtime. --- .gitignore | 4 + spine-libgdx/.classpath | 9 + spine-libgdx/.project | 17 + .../.settings/org.eclipse.jdt.core.prefs | 95 ++++ .../com/esotericsoftware/spine/Animation.java | 477 ++++++++++++++++++ .../esotericsoftware/spine/Attachment.java | 91 ++++ .../spine/AttachmentResolver.java | 6 + .../src/com/esotericsoftware/spine/Bone.java | 185 +++++++ .../com/esotericsoftware/spine/BoneData.java | 93 ++++ .../com/esotericsoftware/spine/Skeleton.java | 279 ++++++++++ .../spine/SkeletonBinary.java | 270 ++++++++++ .../esotericsoftware/spine/SkeletonData.java | 120 +++++ .../esotericsoftware/spine/SkeletonJson.java | 277 ++++++++++ .../src/com/esotericsoftware/spine/Skin.java | 97 ++++ .../src/com/esotericsoftware/spine/Slot.java | 93 ++++ .../com/esotericsoftware/spine/SlotData.java | 49 ++ .../spine/attachments/RegionAttachment.java | 153 ++++++ .../attachments/RegionSequenceAttachment.java | 68 +++ .../TextureAtlasAttachmentResolver.java | 29 ++ .../com/esotericsoftware/spine/MixTest.java | 124 +++++ .../esotericsoftware/spine/SkeletonTest.java | 123 +++++ spine-libgdx/test/goblins-skeleton.json | 202 ++++++++ spine-libgdx/test/goblins-walk.anim | Bin 0 -> 1705 bytes spine-libgdx/test/goblins-walk.json | 288 +++++++++++ spine-libgdx/test/goblins.atlas | 297 +++++++++++ spine-libgdx/test/goblins.png | Bin 0 -> 88884 bytes spine-libgdx/test/goblins.skel | Bin 0 -> 4152 bytes spine-libgdx/test/goblins2.png | Bin 0 -> 116173 bytes spine-libgdx/test/spineboy-jump.anim | Bin 0 -> 2932 bytes spine-libgdx/test/spineboy-jump.json | 410 +++++++++++++++ spine-libgdx/test/spineboy-skeleton.json | 101 ++++ spine-libgdx/test/spineboy-walk.anim | Bin 0 -> 1752 bytes spine-libgdx/test/spineboy-walk.json | 278 ++++++++++ spine-libgdx/test/spineboy.atlas | 166 ++++++ spine-libgdx/test/spineboy.png | Bin 0 -> 66315 bytes spine-libgdx/test/spineboy.skel | Bin 0 -> 2209 bytes 36 files changed, 4401 insertions(+) create mode 100644 spine-libgdx/.classpath create mode 100644 spine-libgdx/.project create mode 100644 spine-libgdx/.settings/org.eclipse.jdt.core.prefs create mode 100644 spine-libgdx/src/com/esotericsoftware/spine/Animation.java create mode 100644 spine-libgdx/src/com/esotericsoftware/spine/Attachment.java create mode 100644 spine-libgdx/src/com/esotericsoftware/spine/AttachmentResolver.java create mode 100644 spine-libgdx/src/com/esotericsoftware/spine/Bone.java create mode 100644 spine-libgdx/src/com/esotericsoftware/spine/BoneData.java create mode 100644 spine-libgdx/src/com/esotericsoftware/spine/Skeleton.java create mode 100644 spine-libgdx/src/com/esotericsoftware/spine/SkeletonBinary.java create mode 100644 spine-libgdx/src/com/esotericsoftware/spine/SkeletonData.java create mode 100644 spine-libgdx/src/com/esotericsoftware/spine/SkeletonJson.java create mode 100644 spine-libgdx/src/com/esotericsoftware/spine/Skin.java create mode 100644 spine-libgdx/src/com/esotericsoftware/spine/Slot.java create mode 100644 spine-libgdx/src/com/esotericsoftware/spine/SlotData.java create mode 100644 spine-libgdx/src/com/esotericsoftware/spine/attachments/RegionAttachment.java create mode 100644 spine-libgdx/src/com/esotericsoftware/spine/attachments/RegionSequenceAttachment.java create mode 100644 spine-libgdx/src/com/esotericsoftware/spine/attachments/TextureAtlasAttachmentResolver.java create mode 100644 spine-libgdx/test/com/esotericsoftware/spine/MixTest.java create mode 100644 spine-libgdx/test/com/esotericsoftware/spine/SkeletonTest.java create mode 100644 spine-libgdx/test/goblins-skeleton.json create mode 100644 spine-libgdx/test/goblins-walk.anim create mode 100644 spine-libgdx/test/goblins-walk.json create mode 100644 spine-libgdx/test/goblins.atlas create mode 100644 spine-libgdx/test/goblins.png create mode 100644 spine-libgdx/test/goblins.skel create mode 100644 spine-libgdx/test/goblins2.png create mode 100644 spine-libgdx/test/spineboy-jump.anim create mode 100644 spine-libgdx/test/spineboy-jump.json create mode 100644 spine-libgdx/test/spineboy-skeleton.json create mode 100644 spine-libgdx/test/spineboy-walk.anim create mode 100644 spine-libgdx/test/spineboy-walk.json create mode 100644 spine-libgdx/test/spineboy.atlas create mode 100644 spine-libgdx/test/spineboy.png create mode 100644 spine-libgdx/test/spineboy.skel diff --git a/.gitignore b/.gitignore index 4478e9e1f..d0064313e 100644 --- a/.gitignore +++ b/.gitignore @@ -1,2 +1,6 @@ spine-cpp/Debug/* spine-libgdx/bin/* +spine-libgdx/libs/gdx-backend-lwjgl-natives.jar +spine-libgdx/libs/gdx-backend-lwjgl.jar +spine-libgdx/libs/gdx-natives.jar +spine-libgdx/libs/gdx.jar diff --git a/spine-libgdx/.classpath b/spine-libgdx/.classpath new file mode 100644 index 000000000..70260f375 --- /dev/null +++ b/spine-libgdx/.classpath @@ -0,0 +1,9 @@ + + + + + + + + + diff --git a/spine-libgdx/.project b/spine-libgdx/.project new file mode 100644 index 000000000..7d65046eb --- /dev/null +++ b/spine-libgdx/.project @@ -0,0 +1,17 @@ + + + spine-libgdx + + + + + + org.eclipse.jdt.core.javabuilder + + + + + + org.eclipse.jdt.core.javanature + + diff --git a/spine-libgdx/.settings/org.eclipse.jdt.core.prefs b/spine-libgdx/.settings/org.eclipse.jdt.core.prefs new file mode 100644 index 000000000..089aa9ace --- /dev/null +++ b/spine-libgdx/.settings/org.eclipse.jdt.core.prefs @@ -0,0 +1,95 @@ +eclipse.preferences.version=1 +org.eclipse.jdt.core.compiler.annotation.missingNonNullByDefaultAnnotation=ignore +org.eclipse.jdt.core.compiler.annotation.nonnull=org.eclipse.jdt.annotation.NonNull +org.eclipse.jdt.core.compiler.annotation.nonnullbydefault=org.eclipse.jdt.annotation.NonNullByDefault +org.eclipse.jdt.core.compiler.annotation.nullable=org.eclipse.jdt.annotation.Nullable +org.eclipse.jdt.core.compiler.annotation.nullanalysis=disabled +org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled +org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.5 +org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve +org.eclipse.jdt.core.compiler.compliance=1.5 +org.eclipse.jdt.core.compiler.debug.lineNumber=generate +org.eclipse.jdt.core.compiler.debug.localVariable=generate +org.eclipse.jdt.core.compiler.debug.sourceFile=generate +org.eclipse.jdt.core.compiler.problem.annotationSuperInterface=warning +org.eclipse.jdt.core.compiler.problem.assertIdentifier=error +org.eclipse.jdt.core.compiler.problem.autoboxing=ignore +org.eclipse.jdt.core.compiler.problem.comparingIdentical=warning +org.eclipse.jdt.core.compiler.problem.deadCode=ignore +org.eclipse.jdt.core.compiler.problem.deprecation=ignore +org.eclipse.jdt.core.compiler.problem.deprecationInDeprecatedCode=disabled +org.eclipse.jdt.core.compiler.problem.deprecationWhenOverridingDeprecatedMethod=disabled +org.eclipse.jdt.core.compiler.problem.discouragedReference=warning +org.eclipse.jdt.core.compiler.problem.emptyStatement=ignore +org.eclipse.jdt.core.compiler.problem.enumIdentifier=error +org.eclipse.jdt.core.compiler.problem.explicitlyClosedAutoCloseable=ignore +org.eclipse.jdt.core.compiler.problem.fallthroughCase=ignore +org.eclipse.jdt.core.compiler.problem.fatalOptionalError=disabled +org.eclipse.jdt.core.compiler.problem.fieldHiding=ignore +org.eclipse.jdt.core.compiler.problem.finalParameterBound=warning +org.eclipse.jdt.core.compiler.problem.finallyBlockNotCompletingNormally=warning +org.eclipse.jdt.core.compiler.problem.forbiddenReference=warning +org.eclipse.jdt.core.compiler.problem.hiddenCatchBlock=warning +org.eclipse.jdt.core.compiler.problem.includeNullInfoFromAsserts=disabled +org.eclipse.jdt.core.compiler.problem.incompatibleNonInheritedInterfaceMethod=warning +org.eclipse.jdt.core.compiler.problem.incompleteEnumSwitch=warning +org.eclipse.jdt.core.compiler.problem.indirectStaticAccess=ignore +org.eclipse.jdt.core.compiler.problem.localVariableHiding=ignore +org.eclipse.jdt.core.compiler.problem.methodWithConstructorName=warning +org.eclipse.jdt.core.compiler.problem.missingDefaultCase=ignore +org.eclipse.jdt.core.compiler.problem.missingDeprecatedAnnotation=ignore +org.eclipse.jdt.core.compiler.problem.missingEnumCaseDespiteDefault=disabled +org.eclipse.jdt.core.compiler.problem.missingHashCodeMethod=ignore +org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotation=ignore +org.eclipse.jdt.core.compiler.problem.missingOverrideAnnotationForInterfaceMethodImplementation=enabled +org.eclipse.jdt.core.compiler.problem.missingSerialVersion=ignore +org.eclipse.jdt.core.compiler.problem.missingSynchronizedOnInheritedMethod=ignore +org.eclipse.jdt.core.compiler.problem.noEffectAssignment=warning +org.eclipse.jdt.core.compiler.problem.noImplicitStringConversion=warning +org.eclipse.jdt.core.compiler.problem.nonExternalizedStringLiteral=ignore +org.eclipse.jdt.core.compiler.problem.nullAnnotationInferenceConflict=error +org.eclipse.jdt.core.compiler.problem.nullReference=warning +org.eclipse.jdt.core.compiler.problem.nullSpecViolation=error +org.eclipse.jdt.core.compiler.problem.nullUncheckedConversion=warning +org.eclipse.jdt.core.compiler.problem.overridingPackageDefaultMethod=warning +org.eclipse.jdt.core.compiler.problem.parameterAssignment=ignore +org.eclipse.jdt.core.compiler.problem.possibleAccidentalBooleanAssignment=warning +org.eclipse.jdt.core.compiler.problem.potentialNullReference=ignore +org.eclipse.jdt.core.compiler.problem.potentiallyUnclosedCloseable=ignore +org.eclipse.jdt.core.compiler.problem.rawTypeReference=ignore +org.eclipse.jdt.core.compiler.problem.redundantNullAnnotation=warning +org.eclipse.jdt.core.compiler.problem.redundantNullCheck=ignore +org.eclipse.jdt.core.compiler.problem.redundantSpecificationOfTypeArguments=ignore +org.eclipse.jdt.core.compiler.problem.redundantSuperinterface=ignore +org.eclipse.jdt.core.compiler.problem.reportMethodCanBePotentiallyStatic=ignore +org.eclipse.jdt.core.compiler.problem.reportMethodCanBeStatic=ignore +org.eclipse.jdt.core.compiler.problem.specialParameterHidingField=disabled +org.eclipse.jdt.core.compiler.problem.staticAccessReceiver=warning +org.eclipse.jdt.core.compiler.problem.suppressOptionalErrors=disabled +org.eclipse.jdt.core.compiler.problem.suppressWarnings=enabled +org.eclipse.jdt.core.compiler.problem.syntheticAccessEmulation=warning +org.eclipse.jdt.core.compiler.problem.typeParameterHiding=warning +org.eclipse.jdt.core.compiler.problem.unavoidableGenericTypeProblems=enabled +org.eclipse.jdt.core.compiler.problem.uncheckedTypeOperation=ignore +org.eclipse.jdt.core.compiler.problem.unclosedCloseable=ignore +org.eclipse.jdt.core.compiler.problem.undocumentedEmptyBlock=ignore +org.eclipse.jdt.core.compiler.problem.unhandledWarningToken=warning +org.eclipse.jdt.core.compiler.problem.unnecessaryElse=ignore +org.eclipse.jdt.core.compiler.problem.unnecessaryTypeCheck=ignore +org.eclipse.jdt.core.compiler.problem.unqualifiedFieldAccess=ignore +org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownException=ignore +org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionExemptExceptionAndThrowable=enabled +org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionIncludeDocCommentReference=enabled +org.eclipse.jdt.core.compiler.problem.unusedDeclaredThrownExceptionWhenOverriding=enabled +org.eclipse.jdt.core.compiler.problem.unusedImport=ignore +org.eclipse.jdt.core.compiler.problem.unusedLabel=warning +org.eclipse.jdt.core.compiler.problem.unusedLocal=ignore +org.eclipse.jdt.core.compiler.problem.unusedObjectAllocation=ignore +org.eclipse.jdt.core.compiler.problem.unusedParameter=ignore +org.eclipse.jdt.core.compiler.problem.unusedParameterIncludeDocCommentReference=enabled +org.eclipse.jdt.core.compiler.problem.unusedParameterWhenImplementingAbstract=enabled +org.eclipse.jdt.core.compiler.problem.unusedParameterWhenOverridingConcrete=enabled +org.eclipse.jdt.core.compiler.problem.unusedPrivateMember=ignore +org.eclipse.jdt.core.compiler.problem.unusedWarningToken=warning +org.eclipse.jdt.core.compiler.problem.varargsArgumentNeedCast=warning +org.eclipse.jdt.core.compiler.source=1.5 diff --git a/spine-libgdx/src/com/esotericsoftware/spine/Animation.java b/spine-libgdx/src/com/esotericsoftware/spine/Animation.java new file mode 100644 index 000000000..3148feb2d --- /dev/null +++ b/spine-libgdx/src/com/esotericsoftware/spine/Animation.java @@ -0,0 +1,477 @@ + +package com.esotericsoftware.spine; + +import com.badlogic.gdx.graphics.Color; +import com.badlogic.gdx.math.MathUtils; +import com.badlogic.gdx.utils.Array; + +public class Animation { + private final Array timelines; + private float duration; + + public Animation (Array timelines, float duration) { + if (timelines == null) throw new IllegalArgumentException("timelines cannot be null."); + this.timelines = timelines; + this.duration = duration; + } + + public Array getTimelines () { + return timelines; + } + + /** Returns the duration of the animation in seconds. Defaults to the max {@link Timeline#getDuration() duration} of the + * timelines. */ + public float getDuration () { + return duration; + } + + public void setDuration (float duration) { + this.duration = duration; + } + + /** Poses the skeleton at the specified time for this animation. */ + public void apply (Skeleton skeleton, float time, boolean loop) { + if (skeleton == null) throw new IllegalArgumentException("skeleton cannot be null."); + + if (loop && duration != 0) time %= duration; + + Array timeline = this.timelines; + for (int i = 0, n = timeline.size; i < n; i++) + timeline.get(i).apply(skeleton, time, 1); + } + + /** Poses the skeleton at the specified time for this animation mixed with the current pose. + * @param alpha The amount of this animation that affects the current pose. */ + public void mix (Skeleton skeleton, float time, boolean loop, float alpha) { + if (skeleton == null) throw new IllegalArgumentException("skeleton cannot be null."); + + if (loop && duration != 0) time %= duration; + + Array timeline = this.timelines; + for (int i = 0, n = timeline.size; i < n; i++) + timeline.get(i).apply(skeleton, time, alpha); + } + + /** @param target After the first and before the last entry. */ + static int binarySearch (float[] values, float target, int step) { + int low = 0; + int high = values.length / step - 2; + if (high == 0) return step; + int current = high >>> 1; + while (true) { + if (values[(current + 1) * step] <= target) + low = current + 1; + else + high = current; + if (low == high) return (low + 1) * step; + current = (low + high) >>> 1; + } + } + + static int linearSearch (float[] values, float target, int step) { + for (int i = 0, last = values.length - step; i <= last; i += step) { + if (values[i] <= target) continue; + return i; + } + return -1; + } + + /** The keyframes for a single animation timeline. */ + static public interface Timeline { + /** Returns the time in seconds of the last keyframe. */ + public float getDuration (); + + public int getKeyframeCount (); + + /** Sets the value(s) for the specified time. */ + public void apply (Skeleton skeleton, float time, float alpha); + } + + /** Base class for frames that use an interpolation bezier curve. */ + static public abstract class CurveTimeline implements Timeline { + static private final float LINEAR = 0; + static private final float STEPPED = -1; + static private final int BEZIER_SEGMENTS = 10; + + private final float[] curves; // dfx, dfy, ddfx, ddfy, dddfx, dddfy, ... + + public CurveTimeline (int keyframeCount) { + curves = new float[(keyframeCount - 1) * 6]; + } + + public void setLinear (int keyframeIndex) { + curves[keyframeIndex * 6] = LINEAR; + } + + public void setStepped (int keyframeIndex) { + curves[keyframeIndex * 6] = STEPPED; + } + + /** Sets the control handle positions for an interpolation bezier curve used to transition from this keyframe to the next. + * cx1 and cx2 are from 0 to 1, representing the percent of time between the two keyframes. cy1 and cy2 are the percent of + * the difference between the keyframe's values. */ + public void setCurve (int keyframeIndex, float cx1, float cy1, float cx2, float cy2) { + float subdiv_step = 1f / BEZIER_SEGMENTS; + float subdiv_step2 = subdiv_step * subdiv_step; + float subdiv_step3 = subdiv_step2 * subdiv_step; + float pre1 = 3 * subdiv_step; + float pre2 = 3 * subdiv_step2; + float pre4 = 6 * subdiv_step2; + float pre5 = 6 * subdiv_step3; + float tmp1x = -cx1 * 2 + cx2; + float tmp1y = -cy1 * 2 + cy2; + float tmp2x = (cx1 - cx2) * 3 + 1; + float tmp2y = (cy1 - cy2) * 3 + 1; + int i = keyframeIndex * 6; + float[] curves = this.curves; + curves[i] = cx1 * pre1 + tmp1x * pre2 + tmp2x * subdiv_step3; + curves[i + 1] = cy1 * pre1 + tmp1y * pre2 + tmp2y * subdiv_step3; + curves[i + 2] = tmp1x * pre4 + tmp2x * pre5; + curves[i + 3] = tmp1y * pre4 + tmp2y * pre5; + curves[i + 4] = tmp2x * pre5; + curves[i + 5] = tmp2y * pre5; + } + + public float getCurvePercent (int keyframeIndex, float percent) { + int curveIndex = keyframeIndex * 6; + float[] curves = this.curves; + float dfx = curves[curveIndex]; + if (dfx == LINEAR) return percent; + if (dfx == STEPPED) return 0; + float dfy = curves[curveIndex + 1]; + float ddfx = curves[curveIndex + 2]; + float ddfy = curves[curveIndex + 3]; + float dddfx = curves[curveIndex + 4]; + float dddfy = curves[curveIndex + 5]; + float x = dfx, y = dfy; + int i = BEZIER_SEGMENTS - 2; + while (true) { + if (x >= percent) { + float lastX = x - dfx; + float lastY = y - dfy; + return lastY + (y - lastY) * (percent - lastX) / (x - lastX); + } + if (i == 0) break; + i--; + dfx += ddfx; + dfy += ddfy; + ddfx += dddfx; + ddfy += dddfy; + x += dfx; + y += dfy; + } + return y + (1 - y) * (percent - x) / (1 - x); // Last point is 1,1. + } + } + + static public class RotateTimeline extends CurveTimeline { + static private final int LAST_FRAME_TIME = -2; + static private final int FRAME_VALUE = 1; + + private int boneIndex; + private final float[] frames; // time, value, ... + + public RotateTimeline (int keyframeCount) { + super(keyframeCount); + frames = new float[keyframeCount * 2]; + } + + public float getDuration () { + return frames[frames.length - 2]; + } + + public int getKeyframeCount () { + return frames.length / 2; + } + + public void setBoneIndex (int boneIndex) { + this.boneIndex = boneIndex; + } + + public int getBoneIndex () { + return boneIndex; + } + + public float[] getKeyframes () { + return frames; + } + + /** Sets the time and value of the specified keyframe. */ + public void setKeyframe (int keyframeIndex, float time, float value) { + keyframeIndex *= 2; + frames[keyframeIndex] = time; + frames[keyframeIndex + 1] = value; + } + + public void apply (Skeleton skeleton, float time, float alpha) { + float[] frames = this.frames; + if (time < frames[0]) return; // Time is before first frame. + + Bone bone = skeleton.bones.get(boneIndex); + + if (time >= frames[frames.length - 2]) { // Time is after last frame. + float amount = bone.data.rotation + frames[frames.length - 1] - bone.rotation; + while (amount > 180) + amount -= 360; + while (amount < -180) + amount += 360; + bone.rotation += amount * alpha; + return; + } + + // Interpolate between the last frame and the current frame. + int frameIndex = binarySearch(frames, time, 2); + float lastFrameValue = frames[frameIndex - 1]; + float frameTime = frames[frameIndex]; + float percent = MathUtils.clamp(1 - (time - frameTime) / (frames[frameIndex + LAST_FRAME_TIME] - frameTime), 0, 1); + percent = getCurvePercent(frameIndex / 2 - 1, percent); + + float amount = frames[frameIndex + FRAME_VALUE] - lastFrameValue; + while (amount > 180) + amount -= 360; + while (amount < -180) + amount += 360; + amount = bone.data.rotation + (lastFrameValue + amount * percent) - bone.rotation; + while (amount > 180) + amount -= 360; + while (amount < -180) + amount += 360; + bone.rotation += amount * alpha; + } + } + + static public class TranslateTimeline extends CurveTimeline { + static final int LAST_FRAME_TIME = -3; + static final int FRAME_X = 1; + static final int FRAME_Y = 2; + + int boneIndex; + final float[] frames; // time, value, value, ... + + public TranslateTimeline (int keyframeCount) { + super(keyframeCount); + frames = new float[keyframeCount * 3]; + } + + public float getDuration () { + return frames[frames.length - 3]; + } + + public int getKeyframeCount () { + return frames.length / 3; + } + + public void setBoneIndex (int boneIndex) { + this.boneIndex = boneIndex; + } + + public int getBoneIndex () { + return boneIndex; + } + + public float[] getKeyframes () { + return frames; + } + + /** Sets the time and value of the specified keyframe. */ + public void setKeyframe (int keyframeIndex, float time, float x, float y) { + keyframeIndex *= 3; + frames[keyframeIndex] = time; + frames[keyframeIndex + 1] = x; + frames[keyframeIndex + 2] = y; + } + + public void apply (Skeleton skeleton, float time, float alpha) { + float[] frames = this.frames; + if (time < frames[0]) return; // Time is before first frame. + + Bone bone = skeleton.bones.get(boneIndex); + + if (time >= frames[frames.length - 3]) { // Time is after last frame. + bone.x += (bone.data.x + frames[frames.length - 2] - bone.x) * alpha; + bone.y += (bone.data.y + frames[frames.length - 1] - bone.y) * alpha; + return; + } + + // Interpolate between the last frame and the current frame. + int frameIndex = binarySearch(frames, time, 3); + float lastFrameX = frames[frameIndex - 2]; + float lastFrameY = frames[frameIndex - 1]; + float frameTime = frames[frameIndex]; + float percent = MathUtils.clamp(1 - (time - frameTime) / (frames[frameIndex + LAST_FRAME_TIME] - frameTime), 0, 1); + percent = getCurvePercent(frameIndex / 3 - 1, percent); + + bone.x += (bone.data.x + lastFrameX + (frames[frameIndex + FRAME_X] - lastFrameX) * percent - bone.x) * alpha; + bone.y += (bone.data.y + lastFrameY + (frames[frameIndex + FRAME_Y] - lastFrameY) * percent - bone.y) * alpha; + } + } + + static public class ScaleTimeline extends TranslateTimeline { + public ScaleTimeline (int keyframeCount) { + super(keyframeCount); + } + + public void apply (Skeleton skeleton, float time, float alpha) { + float[] frames = this.frames; + if (time < frames[0]) return; // Time is before first frame. + + Bone bone = skeleton.bones.get(boneIndex); + if (time >= frames[frames.length - 3]) { // Time is after last frame. + bone.scaleX += (bone.data.scaleX - 1 + frames[frames.length - 2] - bone.scaleX) * alpha; + bone.scaleY += (bone.data.scaleY - 1 + frames[frames.length - 1] - bone.scaleY) * alpha; + return; + } + + // Interpolate between the last frame and the current frame. + int frameIndex = binarySearch(frames, time, 3); + float lastFrameX = frames[frameIndex - 2]; + float lastFrameY = frames[frameIndex - 1]; + float frameTime = frames[frameIndex]; + float percent = MathUtils.clamp(1 - (time - frameTime) / (frames[frameIndex + LAST_FRAME_TIME] - frameTime), 0, 1); + percent = getCurvePercent(frameIndex / 3 - 1, percent); + + bone.scaleX += (bone.data.scaleX - 1 + lastFrameX + (frames[frameIndex + FRAME_X] - lastFrameX) * percent - bone.scaleX) + * alpha; + bone.scaleY += (bone.data.scaleY - 1 + lastFrameY + (frames[frameIndex + FRAME_Y] - lastFrameY) * percent - bone.scaleY) + * alpha; + } + } + + static public class ColorTimeline extends CurveTimeline { + static private final int LAST_FRAME_TIME = -5; + static private final int FRAME_R = 1; + static private final int FRAME_G = 2; + static private final int FRAME_B = 3; + static private final int FRAME_A = 4; + + private int slotIndex; + private final float[] frames; // time, r, g, b, a, ... + + public ColorTimeline (int keyframeCount) { + super(keyframeCount); + frames = new float[keyframeCount * 5]; + } + + public float getDuration () { + return frames[frames.length - 5]; + } + + public int getKeyframeCount () { + return frames.length / 5; + } + + public void setSlotIndex (int slotIndex) { + this.slotIndex = slotIndex; + } + + public int getSlotIndex () { + return slotIndex; + } + + public float[] getKeyframes () { + return frames; + } + + /** Sets the time and value of the specified keyframe. */ + public void setKeyframe (int keyframeIndex, float time, float r, float g, float b, float a) { + keyframeIndex *= 5; + frames[keyframeIndex] = time; + frames[keyframeIndex + 1] = r; + frames[keyframeIndex + 2] = g; + frames[keyframeIndex + 3] = b; + frames[keyframeIndex + 4] = a; + } + + public void apply (Skeleton skeleton, float time, float alpha) { + float[] frames = this.frames; + if (time < frames[0]) return; // Time is before first frame. + + Color color = skeleton.slots.get(slotIndex).color; + + if (time >= frames[frames.length - 5]) { // Time is after last frame. + int i = frames.length - 1; + float r = frames[i - 3]; + float g = frames[i - 2]; + float b = frames[i - 1]; + float a = frames[i]; + color.set(r, g, b, a); + return; + } + + // Interpolate between the last frame and the current frame. + int frameIndex = binarySearch(frames, time, 5); + float lastFrameR = frames[frameIndex - 4]; + float lastFrameG = frames[frameIndex - 3]; + float lastFrameB = frames[frameIndex - 2]; + float lastFrameA = frames[frameIndex - 1]; + float frameTime = frames[frameIndex]; + float percent = MathUtils.clamp(1 - (time - frameTime) / (frames[frameIndex + LAST_FRAME_TIME] - frameTime), 0, 1); + percent = getCurvePercent(frameIndex / 5 - 1, percent); + + float r = lastFrameR + (frames[frameIndex + FRAME_R] - lastFrameR) * percent; + float g = lastFrameG + (frames[frameIndex + FRAME_G] - lastFrameG) * percent; + float b = lastFrameB + (frames[frameIndex + FRAME_B] - lastFrameB) * percent; + float a = lastFrameA + (frames[frameIndex + FRAME_A] - lastFrameA) * percent; + if (alpha < 1) + color.add((r - color.r) * alpha, (g - color.g) * alpha, (b - color.b) * alpha, (a - color.a) * alpha); + else + color.set(r, g, b, a); + } + } + + static public class AttachmentTimeline implements Timeline { + private int slotIndex; + private final float[] frames; // time, ... + private final String[] attachmentNames; + + public AttachmentTimeline (int keyframeCount) { + frames = new float[keyframeCount]; + attachmentNames = new String[keyframeCount]; + } + + public float getDuration () { + return frames[frames.length - 1]; + } + + public int getKeyframeCount () { + return frames.length; + } + + public int getSlotIndex () { + return slotIndex; + } + + public void setSlotIndex (int slotIndex) { + this.slotIndex = slotIndex; + } + + public float[] getKeyframes () { + return frames; + } + + public String[] getAttachmentNames () { + return attachmentNames; + } + + /** Sets the time and value of the specified keyframe. */ + public void setKeyframe (int keyframeIndex, float time, String attachmentName) { + frames[keyframeIndex] = time; + attachmentNames[keyframeIndex] = attachmentName; + } + + public void apply (Skeleton skeleton, float time, float alpha) { + float[] frames = this.frames; + if (time < frames[0]) return; // Time is before first frame. + + int frameIndex; + if (time >= frames[frames.length - 1]) // Time is after last frame. + frameIndex = frames.length - 1; + else + frameIndex = binarySearch(frames, time, 1) - 1; + + String attachmentName = attachmentNames[frameIndex]; + skeleton.slots.get(slotIndex).setAttachment( + attachmentName == null ? null : skeleton.getAttachment(slotIndex, attachmentName)); + } + } +} diff --git a/spine-libgdx/src/com/esotericsoftware/spine/Attachment.java b/spine-libgdx/src/com/esotericsoftware/spine/Attachment.java new file mode 100644 index 000000000..aaa7528a2 --- /dev/null +++ b/spine-libgdx/src/com/esotericsoftware/spine/Attachment.java @@ -0,0 +1,91 @@ + +package com.esotericsoftware.spine; + +import com.badlogic.gdx.graphics.g2d.SpriteBatch; + +abstract public class Attachment { + final String name; + boolean resolved; + private float x, y, scaleX, scaleY, rotation, width, height; + + public Attachment (String name) { + if (name == null) throw new IllegalArgumentException("name cannot be null."); + this.name = name; + } + + abstract public void updateOffset (); + + abstract public void draw (SpriteBatch batch, Slot slot); + + public float getX () { + return x; + } + + public void setX (float x) { + this.x = x; + } + + public float getY () { + return y; + } + + public void setY (float y) { + this.y = y; + } + + public float getScaleX () { + return scaleX; + } + + public void setScaleX (float scaleX) { + this.scaleX = scaleX; + } + + public float getScaleY () { + return scaleY; + } + + public void setScaleY (float scaleY) { + this.scaleY = scaleY; + } + + public float getRotation () { + return rotation; + } + + public void setRotation (float rotation) { + this.rotation = rotation; + } + + public float getWidth () { + return width; + } + + public void setWidth (float width) { + this.width = width; + } + + public float getHeight () { + return height; + } + + public void setHeight (float height) { + this.height = height; + } + + public boolean isResolved () { + return resolved; + } + + public void setResolved (boolean resolved) { + this.resolved = resolved; + } + + public String getName () { + return name; + } + + public String toString () { + return name; + } +} diff --git a/spine-libgdx/src/com/esotericsoftware/spine/AttachmentResolver.java b/spine-libgdx/src/com/esotericsoftware/spine/AttachmentResolver.java new file mode 100644 index 000000000..4d668b8d9 --- /dev/null +++ b/spine-libgdx/src/com/esotericsoftware/spine/AttachmentResolver.java @@ -0,0 +1,6 @@ + +package com.esotericsoftware.spine; + +public interface AttachmentResolver { + public void resolve (Attachment attachment); +} diff --git a/spine-libgdx/src/com/esotericsoftware/spine/Bone.java b/spine-libgdx/src/com/esotericsoftware/spine/Bone.java new file mode 100644 index 000000000..b0d4b7ec8 --- /dev/null +++ b/spine-libgdx/src/com/esotericsoftware/spine/Bone.java @@ -0,0 +1,185 @@ + +package com.esotericsoftware.spine; + +import static com.badlogic.gdx.math.Matrix3.*; + +import com.badlogic.gdx.math.MathUtils; +import com.badlogic.gdx.math.Matrix3; + +public class Bone { + final BoneData data; + final Bone parent; + float x, y; + float rotation; + float scaleX = 1, scaleY = 1; + + float m00, m01, worldX; // a b x + float m10, m11, worldY; // c d y + float worldRotation; + float worldScaleX, worldScaleY; + + /** @param parent May be null. */ + public Bone (BoneData data, Bone parent) { + if (data == null) throw new IllegalArgumentException("data cannot be null."); + this.data = data; + this.parent = parent; + setToBindPose(); + } + + /** Copy constructor. + * @param parent May be null. */ + public Bone (Bone bone, Bone parent) { + if (bone == null) throw new IllegalArgumentException("bone cannot be null."); + this.parent = parent; + data = bone.data; + x = bone.x; + y = bone.y; + rotation = bone.rotation; + scaleX = bone.scaleX; + scaleY = bone.scaleY; + } + + /** Computes the world SRT using the parent bone and the local SRT. */ + public void updateWorldTransform (boolean flipX, boolean flipY) { + Bone parent = this.parent; + if (parent != null) { + worldX = x * parent.m00 + y * parent.m01 + parent.worldX; + worldY = x * parent.m10 + y * parent.m11 + parent.worldY; + worldScaleX = parent.worldScaleX * scaleX; + worldScaleY = parent.worldScaleY * scaleY; + worldRotation = parent.worldRotation + rotation; + } else { + worldX = x; + worldY = y; + worldScaleX = scaleX; + worldScaleY = scaleY; + worldRotation = rotation; + } + float cos = MathUtils.cosDeg(worldRotation); + float sin = MathUtils.sinDeg(worldRotation); + m00 = cos * worldScaleX; + m10 = sin * worldScaleX; + m01 = -sin * worldScaleY; + m11 = cos * worldScaleY; + if (flipX) { + m00 = -m00; + m01 = -m01; + } + if (flipY) { + m10 = -m10; + m11 = -m11; + } + } + + public void setToBindPose () { + BoneData data = this.data; + x = data.x; + y = data.y; + rotation = data.rotation; + scaleX = data.scaleX; + scaleY = data.scaleY; + } + + public BoneData getData () { + return data; + } + + public Bone getParent () { + return parent; + } + + public float getX () { + return x; + } + + public void setX (float x) { + this.x = x; + } + + public float getY () { + return y; + } + + public void setY (float y) { + this.y = y; + } + + public float getRotation () { + return rotation; + } + + public void setRotation (float rotation) { + this.rotation = rotation; + } + + public float getScaleX () { + return scaleX; + } + + public void setScaleX (float scaleX) { + this.scaleX = scaleX; + } + + public float getScaleY () { + return scaleY; + } + + public void setScaleY (float scaleY) { + this.scaleY = scaleY; + } + + public float getM00 () { + return m00; + } + + public float getM01 () { + return m01; + } + + public float getM10 () { + return m10; + } + + public float getM11 () { + return m11; + } + + public float getWorldX () { + return worldX; + } + + public float getWorldY () { + return worldY; + } + + public float getWorldRotation () { + return worldRotation; + } + + public float getWorldScaleX () { + return worldScaleX; + } + + public float getWorldScaleY () { + return worldScaleY; + } + + public Matrix3 getWorldTransform (Matrix3 worldTransform) { + if (worldTransform == null) throw new IllegalArgumentException("worldTransform cannot be null."); + float[] val = worldTransform.val; + val[M00] = m00; + val[M01] = m01; + val[M02] = worldX; + val[M10] = m10; + val[M11] = m11; + val[M12] = worldY; + val[M20] = 0; + val[M21] = 0; + val[M22] = 1; + return worldTransform; + } + + public String toString () { + return data.name; + } +} diff --git a/spine-libgdx/src/com/esotericsoftware/spine/BoneData.java b/spine-libgdx/src/com/esotericsoftware/spine/BoneData.java new file mode 100644 index 000000000..dbf1069f1 --- /dev/null +++ b/spine-libgdx/src/com/esotericsoftware/spine/BoneData.java @@ -0,0 +1,93 @@ + +package com.esotericsoftware.spine; + +public class BoneData { + final BoneData parent; + final String name; + float length; + float x, y; + float rotation; + float scaleX = 1, scaleY = 1; + + /** @param parent May be null. */ + public BoneData (String name, BoneData parent) { + if (name == null) throw new IllegalArgumentException("name cannot be null."); + this.name = name; + this.parent = parent; + } + + /** Copy constructor. + * @param parent May be null. */ + public BoneData (BoneData bone, BoneData parent) { + if (bone == null) throw new IllegalArgumentException("bone cannot be null."); + this.parent = parent; + name = bone.name; + length = bone.length; + x = bone.x; + y = bone.y; + rotation = bone.rotation; + scaleX = bone.scaleX; + scaleY = bone.scaleY; + } + + /** @return May be null. */ + public BoneData getParent () { + return parent; + } + + public String getName () { + return name; + } + + public float getLength () { + return length; + } + + public void setLength (float length) { + this.length = length; + } + + public float getX () { + return x; + } + + public void setX (float x) { + this.x = x; + } + + public float getY () { + return y; + } + + public void setY (float y) { + this.y = y; + } + + public float getRotation () { + return rotation; + } + + public void setRotation (float rotation) { + this.rotation = rotation; + } + + public float getScaleX () { + return scaleX; + } + + public void setScaleX (float scaleX) { + this.scaleX = scaleX; + } + + public float getScaleY () { + return scaleY; + } + + public void setScaleY (float scaleY) { + this.scaleY = scaleY; + } + + public String toString () { + return name; + } +} diff --git a/spine-libgdx/src/com/esotericsoftware/spine/Skeleton.java b/spine-libgdx/src/com/esotericsoftware/spine/Skeleton.java new file mode 100644 index 000000000..64cfe3ac9 --- /dev/null +++ b/spine-libgdx/src/com/esotericsoftware/spine/Skeleton.java @@ -0,0 +1,279 @@ + +package com.esotericsoftware.spine; + +import com.esotericsoftware.spine.Skin.Key; + +import com.badlogic.gdx.graphics.Color; +import com.badlogic.gdx.graphics.g2d.SpriteBatch; +import com.badlogic.gdx.graphics.glutils.ShapeRenderer; +import com.badlogic.gdx.graphics.glutils.ShapeRenderer.ShapeType; +import com.badlogic.gdx.utils.Array; +import com.badlogic.gdx.utils.ObjectMap.Entry; + +public class Skeleton { + final SkeletonData data; + final Array bones; + final Array slots; + final Array drawOrder; + Skin skin; + final Color color; + float time; + boolean flipX, flipY; + + public Skeleton (SkeletonData data) { + if (data == null) throw new IllegalArgumentException("data cannot be null."); + this.data = data; + + bones = new Array(data.bones.size); + for (BoneData boneData : data.bones) { + Bone parent = boneData.parent == null ? null : bones.get(data.bones.indexOf(boneData.parent, true)); + bones.add(new Bone(boneData, parent)); + } + + slots = new Array(data.slots.size); + drawOrder = new Array(data.slots.size); + for (SlotData slotData : data.slots) { + Bone bone = bones.get(data.bones.indexOf(slotData.boneData, true)); + Slot slot = new Slot(slotData, this, bone); + slots.add(slot); + drawOrder.add(slot); + } + + color = new Color(1, 1, 1, 1); + } + + /** Copy constructor. */ + public Skeleton (Skeleton skeleton) { + if (skeleton == null) throw new IllegalArgumentException("skeleton cannot be null."); + data = skeleton.data; + + bones = new Array(skeleton.bones.size); + for (Bone bone : skeleton.bones) { + Bone parent = bones.get(skeleton.bones.indexOf(bone.parent, true)); + bones.add(new Bone(bone, parent)); + } + + slots = new Array(skeleton.slots.size); + for (Slot slot : skeleton.slots) { + Bone bone = bones.get(skeleton.bones.indexOf(slot.bone, true)); + Slot newSlot = new Slot(slot, this, bone); + slots.add(newSlot); + } + + drawOrder = new Array(slots.size); + for (Slot slot : skeleton.drawOrder) + drawOrder.add(slots.get(skeleton.slots.indexOf(slot, true))); + + skin = skeleton.skin; + color = new Color(skeleton.color); + time = skeleton.time; + } + + /** Updates the world transform for each bone. */ + public void updateWorldTransform () { + boolean flipX = this.flipX; + boolean flipY = this.flipY; + Array bones = this.bones; + for (int i = 0, n = bones.size; i < n; i++) + bones.get(i).updateWorldTransform(flipX, flipY); + } + + /** Sets the bones and slots to their bind pose values. */ + public void setToBindPose () { + setBonesToBindPose(); + setSlotsToBindPose(); + } + + public void setBonesToBindPose () { + Array bones = this.bones; + for (int i = 0, n = bones.size; i < n; i++) + bones.get(i).setToBindPose(); + } + + public void setSlotsToBindPose () { + Array slots = this.slots; + for (int i = 0, n = slots.size; i < n; i++) + slots.get(i).setToBindPose(i); + } + + public void draw (SpriteBatch batch) { + Array drawOrder = this.drawOrder; + for (int i = 0, n = drawOrder.size; i < n; i++) { + Slot slot = drawOrder.get(i); + Attachment attachment = slot.attachment; + if (attachment != null) { + if (!attachment.resolved) data.attachmentResolver.resolve(attachment); + attachment.updateOffset(); + attachment.draw(batch, slot); + } + } + } + + public void drawDebug (ShapeRenderer renderer) { + renderer.setColor(Color.RED); + renderer.begin(ShapeType.Line); + for (int i = 0, n = bones.size; i < n; i++) { + Bone bone = bones.get(i); + if (bone.parent == null) continue; + float x = bone.data.length * bone.m00 + bone.worldX; + float y = bone.data.length * bone.m10 + bone.worldY; + renderer.line(bone.worldX, bone.worldY, x, y); + } + renderer.end(); + + renderer.setColor(Color.GREEN); + renderer.begin(ShapeType.Filled); + for (int i = 0, n = bones.size; i < n; i++) { + Bone bone = bones.get(i); + renderer.setColor(Color.GREEN); + renderer.circle(bone.worldX, bone.worldY, 3); + } + renderer.end(); + } + + public SkeletonData getData () { + return data; + } + + public Array getBones () { + return bones; + } + + /** @return May return null. */ + public Bone getRootBone () { + if (bones.size == 0) return null; + return bones.first(); + } + + /** @return May be null. */ + public Bone findBone (String boneName) { + if (boneName == null) throw new IllegalArgumentException("boneName cannot be null."); + Array bones = this.bones; + for (int i = 0, n = bones.size; i < n; i++) { + Bone bone = bones.get(i); + if (bone.data.name.equals(boneName)) return bone; + } + return null; + } + + /** @return -1 if the bone was not found. */ + public int findBoneIndex (String boneName) { + if (boneName == null) throw new IllegalArgumentException("boneName cannot be null."); + Array bones = this.bones; + for (int i = 0, n = bones.size; i < n; i++) + if (bones.get(i).data.name.equals(boneName)) return i; + return -1; + } + + public Array getSlots () { + return slots; + } + + /** @return May be null. */ + public Slot findSlot (String slotName) { + if (slotName == null) throw new IllegalArgumentException("slotName cannot be null."); + Array slots = this.slots; + for (int i = 0, n = slots.size; i < n; i++) { + Slot slot = slots.get(i); + if (slot.data.name.equals(slotName)) return slot; + } + return null; + } + + /** @return -1 if the bone was not found. */ + public int findSlotIndex (String slotName) { + if (slotName == null) throw new IllegalArgumentException("slotName cannot be null."); + Array slots = this.slots; + for (int i = 0, n = slots.size; i < n; i++) + if (slots.get(i).data.name.equals(slotName)) return i; + return -1; + } + + /** Returns the slots in the order they will be drawn. The returned array may be modified to change the draw order. */ + public Array getDrawOrder () { + return drawOrder; + } + + /** @return May be null. */ + public Skin getSkin () { + return skin; + } + + /** Sets a skin by name. + * @see #setSkin(Skin) */ + public void setSkin (String skinName) { + Skin skin = data.findSkin(skinName); + if (skin == null) throw new IllegalArgumentException("Skin not found: " + skinName); + setSkin(skin); + } + + /** Sets the skin used to look up attachments not found in the {@link SkeletonData#getDefaultSkin() default skin}. Attachments + * from the new skin are attached if the corresponding attachment from the old skin is currently attached. + * @param newSkin May be null. */ + public void setSkin (Skin newSkin) { + if (skin != null && newSkin != null) newSkin.attachAll(this, skin); + skin = newSkin; + } + + /** @return May be null. */ + public Attachment getAttachment (String slotName, String attachmentName) { + return getAttachment(data.findSlotIndex(slotName), attachmentName); + } + + /** @return May be null. */ + public Attachment getAttachment (int slotIndex, String attachmentName) { + if (attachmentName == null) throw new IllegalArgumentException("attachmentName cannot be null."); + if (data.defaultSkin != null) { + Attachment attachment = data.defaultSkin.getAttachment(slotIndex, attachmentName); + if (attachment != null) return attachment; + } + if (skin != null) return skin.getAttachment(slotIndex, attachmentName); + return null; + } + + /** @param attachmentName May be null. */ + public void setAttachment (String slotName, String attachmentName) { + if (slotName == null) throw new IllegalArgumentException("slotName cannot be null."); + if (attachmentName == null) throw new IllegalArgumentException("attachmentName cannot be null."); + for (int i = 0, n = slots.size; i < n; i++) { + Slot slot = slots.get(i); + if (slot.data.name.equals(slotName)) { + slot.setAttachment(getAttachment(i, attachmentName)); + return; + } + } + throw new IllegalArgumentException("Slot not found: " + slotName); + } + + public Color getColor () { + return color; + } + + public boolean getFlipX () { + return flipX; + } + + public void setFlipX (boolean flipX) { + this.flipX = flipX; + } + + public boolean getFlipY () { + return flipY; + } + + public void setFlipY (boolean flipY) { + this.flipY = flipY; + } + + public float getTime () { + return time; + } + + public void setTime (float time) { + this.time = time; + } + + public void update (float delta) { + time += delta; + } +} diff --git a/spine-libgdx/src/com/esotericsoftware/spine/SkeletonBinary.java b/spine-libgdx/src/com/esotericsoftware/spine/SkeletonBinary.java new file mode 100644 index 000000000..5480b536b --- /dev/null +++ b/spine-libgdx/src/com/esotericsoftware/spine/SkeletonBinary.java @@ -0,0 +1,270 @@ + +package com.esotericsoftware.spine; + +import com.esotericsoftware.spine.Animation.AttachmentTimeline; +import com.esotericsoftware.spine.Animation.ColorTimeline; +import com.esotericsoftware.spine.Animation.CurveTimeline; +import com.esotericsoftware.spine.Animation.RotateTimeline; +import com.esotericsoftware.spine.Animation.ScaleTimeline; +import com.esotericsoftware.spine.Animation.Timeline; +import com.esotericsoftware.spine.Animation.TranslateTimeline; +import com.esotericsoftware.spine.attachments.RegionAttachment; +import com.esotericsoftware.spine.attachments.RegionSequenceAttachment; +import com.esotericsoftware.spine.attachments.RegionSequenceAttachment.Mode; +import com.esotericsoftware.spine.attachments.TextureAtlasAttachmentResolver; + +import com.badlogic.gdx.files.FileHandle; +import com.badlogic.gdx.graphics.Color; +import com.badlogic.gdx.graphics.g2d.TextureAtlas; +import com.badlogic.gdx.utils.Array; +import com.badlogic.gdx.utils.DataInput; +import com.badlogic.gdx.utils.SerializationException; + +import java.io.IOException; + +public class SkeletonBinary { + static public final int TIMELINE_SCALE = 0; + static public final int TIMELINE_ROTATE = 1; + static public final int TIMELINE_TRANSLATE = 2; + static public final int TIMELINE_ATTACHMENT = 3; + static public final int TIMELINE_COLOR = 4; + + static public final int ATTACHMENT_REGION = 0; + static public final int ATTACHMENT_REGION_SEQUENCE = 1; + + static public final int CURVE_LINEAR = 0; + static public final int CURVE_STEPPED = 1; + static public final int CURVE_BEZIER = 2; + + private final AttachmentResolver attachmentResolver; + private float scale = 1; + + public SkeletonBinary (TextureAtlas atlas) { + attachmentResolver = new TextureAtlasAttachmentResolver(atlas); + } + + public SkeletonBinary (AttachmentResolver attachmentResolver) { + this.attachmentResolver = attachmentResolver; + } + + public float getScale () { + return scale; + } + + /** Scales the bones, images, and animations as they are loaded. */ + public void setScale (float scale) { + this.scale = scale; + } + + public SkeletonData readSkeletonData (FileHandle file) { + if (file == null) throw new IllegalArgumentException("file cannot be null."); + + SkeletonData skeletonData = new SkeletonData(attachmentResolver); + DataInput input = new DataInput(file.read(512)); + try { + // Bones. + for (int i = 0, n = input.readInt(true); i < n; i++) { + String name = input.readString(); + BoneData parent = null; + String parentName = input.readString(); + if (parentName != null) { + parent = skeletonData.findBone(parentName); + if (parent == null) throw new SerializationException("Bone not found: " + parentName); + } + BoneData boneData = new BoneData(name, parent); + boneData.x = input.readFloat() * scale; + boneData.y = input.readFloat() * scale; + boneData.scaleX = input.readFloat(); + boneData.scaleY = input.readFloat(); + boneData.rotation = input.readFloat(); + boneData.length = input.readFloat() * scale; + skeletonData.addBone(boneData); + } + + // Slots. + for (int i = 0, n = input.readInt(true); i < n; i++) { + String slotName = input.readString(); + String boneName = input.readString(); + BoneData boneData = skeletonData.findBone(boneName); + if (boneData == null) throw new SerializationException("Bone not found: " + boneName); + SlotData slotData = new SlotData(slotName, boneData); + Color.rgba8888ToColor(slotData.getColor(), input.readInt()); + slotData.setAttachmentName(input.readString()); + skeletonData.addSlot(slotData); + } + + // Default skin. + Skin defaultSkin = readSkin(input, "default"); + if (defaultSkin != null) { + skeletonData.setDefaultSkin(defaultSkin); + skeletonData.addSkin(defaultSkin); + } + + // Skins. + for (int i = 0, n = input.readInt(true); i < n; i++) + skeletonData.addSkin(readSkin(input, input.readString())); + + input.close(); + } catch (IOException ex) { + throw new SerializationException("Error reading skeleton file.", ex); + } + + skeletonData.bones.shrink(); + skeletonData.slots.shrink(); + skeletonData.skins.shrink(); + return skeletonData; + } + + private Skin readSkin (DataInput input, String skinName) throws IOException { + int slotCount = input.readInt(true); + if (slotCount == 0) return null; + Skin skin = new Skin(skinName); + for (int i = 0; i < slotCount; i++) { + int slotIndex = input.readInt(true); + int attachmentCount = input.readInt(true); + for (int ii = 0; ii < attachmentCount; ii++) { + String name = input.readString(); + skin.addAttachment(slotIndex, name, readAttachment(input, name)); + } + } + return skin; + } + + private Attachment readAttachment (DataInput input, String attachmentName) throws IOException { + String name = input.readString(); + if (name == null) name = attachmentName; + + Attachment attachment; + int type = input.readByte(); + switch (type) { + case ATTACHMENT_REGION: + attachment = new RegionAttachment(name); + break; + case ATTACHMENT_REGION_SEQUENCE: + float fps = input.readFloat(); + Mode mode = Mode.values()[input.readInt(true)]; + attachment = new RegionSequenceAttachment(name, 1 / fps, mode); + break; + default: + throw new SerializationException("Unknown attachment type: " + type + " (" + name + ")"); + } + + attachment.setX(input.readFloat() * scale); + attachment.setY(input.readFloat() * scale); + attachment.setScaleX(input.readFloat()); + attachment.setScaleY(input.readFloat()); + attachment.setRotation(input.readFloat()); + attachment.setWidth(input.readFloat() * scale); + attachment.setHeight(input.readFloat() * scale); + return attachment; + } + + public Animation readAnimation (FileHandle file, SkeletonData skeleton) { + if (file == null) throw new IllegalArgumentException("file cannot be null."); + if (skeleton == null) throw new IllegalArgumentException("skeleton cannot be null."); + + Array timelines = new Array(); + float duration = 0; + + DataInput input = new DataInput(file.read(512)); + try { + int boneCount = input.readInt(true); + for (int i = 0; i < boneCount; i++) { + String boneName = input.readString(); + int boneIndex = skeleton.findBoneIndex(boneName); + if (boneIndex == -1) throw new SerializationException("Bone not found: " + boneName); + int itemCount = input.readInt(true); + for (int ii = 0; ii < itemCount; ii++) { + int timelineType = input.readByte(); + int keyCount = input.readInt(true); + switch (timelineType) { + case TIMELINE_ROTATE: { + RotateTimeline timeline = new RotateTimeline(keyCount); + timeline.setBoneIndex(boneIndex); + for (int keyframeIndex = 0; keyframeIndex < keyCount; keyframeIndex++) { + timeline.setKeyframe(keyframeIndex, input.readFloat(), input.readFloat()); + if (keyframeIndex < keyCount - 1) readCurve(input, keyframeIndex, timeline); + } + timelines.add(timeline); + duration = Math.max(duration, timeline.getDuration()); + break; + } + case TIMELINE_TRANSLATE: + case TIMELINE_SCALE: + TranslateTimeline timeline; + float timelineScale = 1; + if (timelineType == TIMELINE_SCALE) + timeline = new ScaleTimeline(keyCount); + else { + timeline = new TranslateTimeline(keyCount); + timelineScale = scale; + } + timeline.setBoneIndex(boneIndex); + for (int keyframeIndex = 0; keyframeIndex < keyCount; keyframeIndex++) { + timeline.setKeyframe(keyframeIndex, input.readFloat(), input.readFloat() * timelineScale, input.readFloat() + * timelineScale); + if (keyframeIndex < keyCount - 1) readCurve(input, keyframeIndex, timeline); + } + timelines.add(timeline); + duration = Math.max(duration, timeline.getDuration()); + break; + default: + throw new RuntimeException("Invalid timeline type for a bone: " + timelineType + " (" + boneName + ")"); + } + } + } + + int slotCount = input.readInt(true); + for (int i = 0; i < slotCount; i++) { + String slotName = input.readString(); + int slotIndex = skeleton.findSlotIndex(slotName); + int itemCount = input.readInt(true); + for (int ii = 0; ii < itemCount; ii++) { + int timelineType = input.readByte(); + int keyCount = input.readInt(true); + switch (timelineType) { + case TIMELINE_COLOR: { + ColorTimeline timeline = new ColorTimeline(keyCount); + timeline.setSlotIndex(slotIndex); + for (int keyframeIndex = 0; keyframeIndex < keyCount; keyframeIndex++) { + float time = input.readFloat(); + Color.rgba8888ToColor(Color.tmp, input.readInt()); + timeline.setKeyframe(keyframeIndex, time, Color.tmp.r, Color.tmp.g, Color.tmp.b, Color.tmp.a); + if (keyframeIndex < keyCount - 1) readCurve(input, keyframeIndex, timeline); + } + timelines.add(timeline); + duration = Math.max(duration, timeline.getDuration()); + break; + } + case TIMELINE_ATTACHMENT: + AttachmentTimeline timeline = new AttachmentTimeline(keyCount); + timeline.setSlotIndex(slotIndex); + for (int keyframeIndex = 0; keyframeIndex < keyCount; keyframeIndex++) + timeline.setKeyframe(keyframeIndex, input.readFloat(), input.readString()); + timelines.add(timeline); + duration = Math.max(duration, timeline.getDuration()); + break; + default: + throw new RuntimeException("Invalid timeline type for a slot: " + timelineType + " (" + slotName + ")"); + } + } + } + } catch (IOException ex) { + throw new SerializationException("Error reading skeleton file.", ex); + } + + timelines.shrink(); + return new Animation(timelines, duration); + } + + private void readCurve (DataInput input, int keyframeIndex, CurveTimeline timeline) throws IOException { + switch (input.readByte()) { + case CURVE_STEPPED: + timeline.setStepped(keyframeIndex); + break; + case CURVE_BEZIER: + timeline.setCurve(keyframeIndex, input.readFloat(), input.readFloat(), input.readFloat(), input.readFloat()); + break; + } + } +} diff --git a/spine-libgdx/src/com/esotericsoftware/spine/SkeletonData.java b/spine-libgdx/src/com/esotericsoftware/spine/SkeletonData.java new file mode 100644 index 000000000..a98d17a47 --- /dev/null +++ b/spine-libgdx/src/com/esotericsoftware/spine/SkeletonData.java @@ -0,0 +1,120 @@ + +package com.esotericsoftware.spine; + +import com.badlogic.gdx.utils.Array; + +public class SkeletonData { + final Array bones = new Array(); // Ordered parents first. + final Array slots = new Array(); // Bind pose draw order. + final Array skins = new Array(); + Skin defaultSkin; + final AttachmentResolver attachmentResolver; + + public SkeletonData (AttachmentResolver attachmentResolver) { + if (attachmentResolver == null) throw new IllegalArgumentException("attachmentResolver cannot be null."); + this.attachmentResolver = attachmentResolver; + } + + public void clear () { + bones.clear(); + slots.clear(); + skins.clear(); + defaultSkin = null; + } + + public AttachmentResolver getAttachmentResolver () { + return attachmentResolver; + } + + // --- Bones. + + public void addBone (BoneData bone) { + if (bone == null) throw new IllegalArgumentException("bone cannot be null."); + bones.add(bone); + } + + public Array getBones () { + return bones; + } + + /** @return May be null. */ + public BoneData findBone (String boneName) { + if (boneName == null) throw new IllegalArgumentException("boneName cannot be null."); + Array bones = this.bones; + for (int i = 0, n = bones.size; i < n; i++) { + BoneData bone = bones.get(i); + if (bone.name.equals(boneName)) return bone; + } + return null; + } + + /** @return -1 if the bone was not found. */ + public int findBoneIndex (String boneName) { + if (boneName == null) throw new IllegalArgumentException("boneName cannot be null."); + Array bones = this.bones; + for (int i = 0, n = bones.size; i < n; i++) + if (bones.get(i).name.equals(boneName)) return i; + return -1; + } + + // --- Slots. + + public void addSlot (SlotData slot) { + if (slot == null) throw new IllegalArgumentException("slot cannot be null."); + slots.add(slot); + } + + public Array getSlots () { + return slots; + } + + /** @return May be null. */ + public SlotData findSlot (String slotName) { + if (slotName == null) throw new IllegalArgumentException("slotName cannot be null."); + Array slots = this.slots; + for (int i = 0, n = slots.size; i < n; i++) { + SlotData slot = slots.get(i); + if (slot.name.equals(slotName)) return slot; + } + return null; + } + + /** @return -1 if the bone was not found. */ + public int findSlotIndex (String slotName) { + if (slotName == null) throw new IllegalArgumentException("slotName cannot be null."); + Array slots = this.slots; + for (int i = 0, n = slots.size; i < n; i++) + if (slots.get(i).name.equals(slotName)) return i; + return -1; + } + + // --- Skins. + + /** @return May be null. */ + public Skin getDefaultSkin () { + return defaultSkin; + } + + /** @param defaultSkin May be null. */ + public void setDefaultSkin (Skin defaultSkin) { + this.defaultSkin = defaultSkin; + } + + public void addSkin (Skin skin) { + if (skin == null) throw new IllegalArgumentException("skin cannot be null."); + skins.add(skin); + } + + /** @return May be null. */ + public Skin findSkin (String skinName) { + if (skinName == null) throw new IllegalArgumentException("skinName cannot be null."); + for (Skin skin : skins) + if (skin.name.equals(skinName)) return skin; + return null; + } + + /** Returns all skins, including the default skin. */ + public Array getSkins () { + return skins; + } +} diff --git a/spine-libgdx/src/com/esotericsoftware/spine/SkeletonJson.java b/spine-libgdx/src/com/esotericsoftware/spine/SkeletonJson.java new file mode 100644 index 000000000..0dcd5f04e --- /dev/null +++ b/spine-libgdx/src/com/esotericsoftware/spine/SkeletonJson.java @@ -0,0 +1,277 @@ + +package com.esotericsoftware.spine; + +import com.esotericsoftware.spine.Animation.AttachmentTimeline; +import com.esotericsoftware.spine.Animation.ColorTimeline; +import com.esotericsoftware.spine.Animation.CurveTimeline; +import com.esotericsoftware.spine.Animation.RotateTimeline; +import com.esotericsoftware.spine.Animation.ScaleTimeline; +import com.esotericsoftware.spine.Animation.Timeline; +import com.esotericsoftware.spine.Animation.TranslateTimeline; +import com.esotericsoftware.spine.attachments.RegionSequenceAttachment; +import com.esotericsoftware.spine.attachments.RegionSequenceAttachment.Mode; +import com.esotericsoftware.spine.attachments.RegionAttachment; +import com.esotericsoftware.spine.attachments.TextureAtlasAttachmentResolver; + +import com.badlogic.gdx.files.FileHandle; +import com.badlogic.gdx.graphics.Color; +import com.badlogic.gdx.graphics.g2d.TextureAtlas; +import com.badlogic.gdx.utils.Array; +import com.badlogic.gdx.utils.Json; +import com.badlogic.gdx.utils.ObjectMap.Entry; +import com.badlogic.gdx.utils.OrderedMap; +import com.badlogic.gdx.utils.SerializationException; + +public class SkeletonJson { + static public final String TIMELINE_SCALE = "scale"; + static public final String TIMELINE_ROTATE = "rotate"; + static public final String TIMELINE_TRANSLATE = "translate"; + static public final String TIMELINE_ATTACHMENT = "attachment"; + static public final String TIMELINE_COLOR = "color"; + + static public final String ATTACHMENT_REGION = "region"; + static public final String ATTACHMENT_REGION_SEQUENCE = "regionSequence"; + + private final Json json = new Json(); + private final AttachmentResolver attachmentResolver; + private float scale = 1; + + public SkeletonJson (TextureAtlas atlas) { + attachmentResolver = new TextureAtlasAttachmentResolver(atlas); + } + + public SkeletonJson (AttachmentResolver attachmentResolver) { + this.attachmentResolver = attachmentResolver; + } + + public float getScale () { + return scale; + } + + /** Scales the bones, images, and animations as they are loaded. */ + public void setScale (float scale) { + this.scale = scale; + } + + public SkeletonData readSkeletonData (FileHandle file) { + if (file == null) throw new IllegalArgumentException("file cannot be null."); + + SkeletonData skeletonData = new SkeletonData(attachmentResolver); + + OrderedMap root = json.fromJson(OrderedMap.class, file); + + // Bones. + for (OrderedMap boneMap : (Array)root.get("bones")) { + BoneData parent = null; + String parentName = (String)boneMap.get("parent"); + if (parentName != null) { + parent = skeletonData.findBone(parentName); + if (parent == null) throw new SerializationException("Parent bone not found: " + parentName); + } + BoneData boneData = new BoneData((String)boneMap.get("name"), parent); + boneData.length = getFloat(boneMap, "length", 0) * scale; + boneData.x = getFloat(boneMap, "x", 0) * scale; + boneData.y = getFloat(boneMap, "y", 0) * scale; + boneData.rotation = getFloat(boneMap, "rotation", 0); + boneData.scaleX = getFloat(boneMap, "scaleX", 1); + boneData.scaleY = getFloat(boneMap, "scaleY", 1); + skeletonData.addBone(boneData); + } + + // Slots. + Array slots = (Array)root.get("slots"); + if (slots != null) { + for (OrderedMap slotMap : slots) { + String slotName = (String)slotMap.get("name"); + String boneName = (String)slotMap.get("bone"); + BoneData boneData = skeletonData.findBone(boneName); + if (boneData == null) throw new SerializationException("Slot bone not found: " + boneName); + SlotData slotData = new SlotData(slotName, boneData); + + String color = (String)slotMap.get("color"); + if (color != null) slotData.getColor().set(Color.valueOf(color)); + + slotData.setAttachmentName((String)slotMap.get("attachment")); + + skeletonData.addSlot(slotData); + } + } + + // Skins. + OrderedMap slotMap = (OrderedMap)root.get("skins"); + if (slotMap != null) { + for (Entry entry : slotMap.entries()) { + Skin skin = new Skin(entry.key); + for (Entry slotEntry : ((OrderedMap)entry.value).entries()) { + int slotIndex = skeletonData.findSlotIndex(slotEntry.key); + for (Entry attachmentEntry : ((OrderedMap)slotEntry.value).entries()) { + Attachment attachment = readAttachment(attachmentEntry.key, attachmentEntry.value); + skin.addAttachment(slotIndex, attachmentEntry.key, attachment); + } + } + skeletonData.addSkin(skin); + if (skin.name.equals("default")) skeletonData.setDefaultSkin(skin); + } + } + + skeletonData.bones.shrink(); + skeletonData.slots.shrink(); + skeletonData.skins.shrink(); + return skeletonData; + } + + private Attachment readAttachment (String name, OrderedMap map) { + name = (String)map.get("name", name); + Attachment attachment; + String type = (String)map.get("type"); + if (type == null) type = ATTACHMENT_REGION; + if (type.equals(ATTACHMENT_REGION)) { + attachment = new RegionAttachment(name); + + } else if (type.equals(ATTACHMENT_REGION_SEQUENCE)) { + Float fps = (Float)map.get("fps"); + if (fps == null) throw new SerializationException("Region sequence attachment missing fps: " + name); + + String modeString = (String)map.get("mode"); + Mode mode = modeString == null ? Mode.forward : Mode.valueOf(modeString); + + attachment = new RegionSequenceAttachment(name, 1 / fps, mode); + + } else + throw new SerializationException("Unknown attachment type: " + type + " (" + name + ")"); + + attachment.setX(getFloat(map, "x", 0) * scale); + attachment.setY(getFloat(map, "y", 0) * scale); + attachment.setScaleX(getFloat(map, "scaleX", 1)); + attachment.setScaleY(getFloat(map, "scaleY", 1)); + attachment.setRotation(getFloat(map, "rotation", 0)); + attachment.setWidth(getFloat(map, "width", 32) * scale); + attachment.setHeight(getFloat(map, "height", 32) * scale); + return attachment; + } + + private float getFloat (OrderedMap map, String name, float defaultValue) { + Object value = map.get(name); + if (value == null) return defaultValue; + return (Float)value; + } + + public Animation readAnimation (FileHandle file, SkeletonData skeletonData) { + if (file == null) throw new IllegalArgumentException("file cannot be null."); + if (skeletonData == null) throw new IllegalArgumentException("skeletonData cannot be null."); + + OrderedMap map = json.fromJson(OrderedMap.class, file); + + Array timelines = new Array(); + float duration = 0; + + OrderedMap bonesMap = (OrderedMap)map.get("bones"); + for (Entry entry : bonesMap.entries()) { + String boneName = entry.key; + int boneIndex = skeletonData.findBoneIndex(boneName); + if (boneIndex == -1) throw new SerializationException("Bone not found: " + boneName); + OrderedMap propertyMap = (OrderedMap)entry.value; + + for (Entry propertyEntry : propertyMap.entries()) { + Array values = (Array)propertyEntry.value; + String timelineType = (String)propertyEntry.key; + if (timelineType.equals(TIMELINE_ROTATE)) { + RotateTimeline timeline = new RotateTimeline(values.size); + timeline.setBoneIndex(boneIndex); + + int keyframeIndex = 0; + for (OrderedMap valueMap : values) { + float time = (Float)valueMap.get("time"); + timeline.setKeyframe(keyframeIndex, time, (Float)valueMap.get("angle")); + readCurve(timeline, keyframeIndex, valueMap); + keyframeIndex++; + } + timelines.add(timeline); + duration = Math.max(duration, timeline.getDuration()); + + } else if (timelineType.equals(TIMELINE_TRANSLATE) || timelineType.equals(TIMELINE_SCALE)) { + TranslateTimeline timeline; + float timelineScale = 1; + if (timelineType.equals(TIMELINE_SCALE)) + timeline = new ScaleTimeline(values.size); + else { + timeline = new TranslateTimeline(values.size); + timelineScale = scale; + } + timeline.setBoneIndex(boneIndex); + + int keyframeIndex = 0; + for (OrderedMap valueMap : values) { + float time = (Float)valueMap.get("time"); + Float x = (Float)valueMap.get("x"), y = (Float)valueMap.get("y"); + timeline.setKeyframe(keyframeIndex, time, x == null ? 0 : (x * timelineScale), y == null ? 0 + : (y * timelineScale)); + readCurve(timeline, keyframeIndex, valueMap); + keyframeIndex++; + } + timelines.add(timeline); + duration = Math.max(duration, timeline.getDuration()); + + } else + throw new RuntimeException("Invalid timeline type for a bone: " + timelineType + " (" + boneName + ")"); + } + } + + OrderedMap slotsMap = (OrderedMap)map.get("slots"); + if (slotsMap != null) { + for (Entry entry : slotsMap.entries()) { + String slotName = entry.key; + int slotIndex = skeletonData.findSlotIndex(slotName); + OrderedMap propertyMap = (OrderedMap)entry.value; + + for (Entry propertyEntry : propertyMap.entries()) { + Array values = (Array)propertyEntry.value; + String timelineType = (String)propertyEntry.key; + if (timelineType.equals(TIMELINE_COLOR)) { + ColorTimeline timeline = new ColorTimeline(values.size); + timeline.setSlotIndex(slotIndex); + + int keyframeIndex = 0; + for (OrderedMap valueMap : values) { + float time = (Float)valueMap.get("time"); + Color color = Color.valueOf((String)valueMap.get("color")); + timeline.setKeyframe(keyframeIndex, time, color.r, color.g, color.b, color.a); + readCurve(timeline, keyframeIndex, valueMap); + keyframeIndex++; + } + timelines.add(timeline); + duration = Math.max(duration, timeline.getDuration()); + + } else if (timelineType.equals(TIMELINE_ATTACHMENT)) { + AttachmentTimeline timeline = new AttachmentTimeline(values.size); + timeline.setSlotIndex(slotIndex); + + int keyframeIndex = 0; + for (OrderedMap valueMap : values) { + float time = (Float)valueMap.get("time"); + timeline.setKeyframe(keyframeIndex++, time, (String)valueMap.get("name")); + } + timelines.add(timeline); + duration = Math.max(duration, timeline.getDuration()); + + } else + throw new RuntimeException("Invalid timeline type for a slot: " + timelineType + " (" + slotName + ")"); + } + } + } + + timelines.shrink(); + return new Animation(timelines, duration); + } + + private void readCurve (CurveTimeline timeline, int keyframeIndex, OrderedMap valueMap) { + Object curveObject = valueMap.get("curve"); + if (curveObject == null) return; + if (curveObject.equals("stepped")) + timeline.setStepped(keyframeIndex); + else if (curveObject instanceof Array) { + Array curve = (Array)curveObject; + timeline.setCurve(keyframeIndex, (Float)curve.get(0), (Float)curve.get(1), (Float)curve.get(2), (Float)curve.get(3)); + } + } +} diff --git a/spine-libgdx/src/com/esotericsoftware/spine/Skin.java b/spine-libgdx/src/com/esotericsoftware/spine/Skin.java new file mode 100644 index 000000000..d18b3cd6f --- /dev/null +++ b/spine-libgdx/src/com/esotericsoftware/spine/Skin.java @@ -0,0 +1,97 @@ + +package com.esotericsoftware.spine; + +import com.badlogic.gdx.utils.Array; +import com.badlogic.gdx.utils.ObjectMap; +import com.badlogic.gdx.utils.ObjectMap.Entry; + +/** Stores attachments by slot index and attachment name. */ +public class Skin { + static private final Key lookup = new Key(); + + final String name; + final ObjectMap attachments = new ObjectMap(); + + public Skin (String name) { + if (name == null) throw new IllegalArgumentException("name cannot be null."); + this.name = name; + } + + public void addAttachment (int slotIndex, String name, Attachment attachment) { + if (attachment == null) throw new IllegalArgumentException("attachment cannot be null."); + Key key = new Key(); + key.set(slotIndex, name); + attachments.put(key, attachment); + } + + /** @return May be null. */ + public Attachment getAttachment (int slotIndex, String name) { + lookup.set(slotIndex, name); + return attachments.get(lookup); + } + + public void findNamesForSlot (int slotIndex, Array names) { + if (names == null) throw new IllegalArgumentException("names cannot be null."); + for (Key key : attachments.keys()) + if (key.slotIndex == slotIndex) names.add(key.name); + } + + public void findAttachmentsForSlot (int slotIndex, Array attachments) { + if (attachments == null) throw new IllegalArgumentException("attachments cannot be null."); + for (Entry entry : this.attachments.entries()) + if (entry.key.slotIndex == slotIndex) attachments.add(entry.value); + } + + public void clear () { + attachments.clear(); + } + + public String getName () { + return name; + } + + public String toString () { + return name; + } + + static class Key { + int slotIndex; + String name; + int hashCode; + + public void set (int slotName, String name) { + if (name == null) throw new IllegalArgumentException("attachmentName cannot be null."); + this.slotIndex = slotName; + this.name = name; + hashCode = 31 * (31 + name.hashCode()) + slotIndex; + } + + public int hashCode () { + return hashCode; + } + + public boolean equals (Object object) { + if (object == null) return false; + Key other = (Key)object; + if (slotIndex != other.slotIndex) return false; + if (!name.equals(other.name)) return false; + return true; + } + + public String toString () { + return slotIndex + ":" + name; + } + } + + /** Attach all attachments from this skin if the corresponding attachment from the old skin is currently attached. */ + void attachAll (Skeleton skeleton, Skin oldSkin) { + for (Entry entry : oldSkin.attachments.entries()) { + int slotIndex = entry.key.slotIndex; + Slot slot = skeleton.slots.get(slotIndex); + if (slot.attachment == entry.value) { + Attachment attachment = getAttachment(slotIndex, entry.key.name); + if (attachment != null) slot.setAttachment(attachment); + } + } + } +} diff --git a/spine-libgdx/src/com/esotericsoftware/spine/Slot.java b/spine-libgdx/src/com/esotericsoftware/spine/Slot.java new file mode 100644 index 000000000..4d8b3eb73 --- /dev/null +++ b/spine-libgdx/src/com/esotericsoftware/spine/Slot.java @@ -0,0 +1,93 @@ + +package com.esotericsoftware.spine; + +import com.badlogic.gdx.graphics.Color; + +public class Slot { + final SlotData data; + final Bone bone; + private final Skeleton skeleton; + final Color color; + Attachment attachment; + private float attachmentTime; + + Slot () { + data = null; + bone = null; + skeleton = null; + color = new Color(1, 1, 1, 1); + } + + public Slot (SlotData data, Skeleton skeleton, Bone bone) { + if (data == null) throw new IllegalArgumentException("data cannot be null."); + if (skeleton == null) throw new IllegalArgumentException("skeleton cannot be null."); + if (bone == null) throw new IllegalArgumentException("bone cannot be null."); + this.data = data; + this.skeleton = skeleton; + this.bone = bone; + color = new Color(1, 1, 1, 1); + } + + /** Copy constructor. */ + public Slot (Slot slot, Skeleton skeleton, Bone bone) { + if (slot == null) throw new IllegalArgumentException("slot cannot be null."); + if (skeleton == null) throw new IllegalArgumentException("skeleton cannot be null."); + if (bone == null) throw new IllegalArgumentException("bone cannot be null."); + data = slot.data; + this.skeleton = skeleton; + this.bone = bone; + color = new Color(slot.color); + attachment = slot.attachment; + attachmentTime = slot.attachmentTime; + } + + public SlotData getData () { + return data; + } + + public Skeleton getSkeleton () { + return skeleton; + } + + public Bone getBone () { + return bone; + } + + public Color getColor () { + return color; + } + + /** @return May be null. */ + public Attachment getAttachment () { + return attachment; + } + + /** Sets the attachment and resets {@link #getAttachmentTime()}. + * @param attachment May be null. */ + public void setAttachment (Attachment attachment) { + this.attachment = attachment; + attachmentTime = skeleton.time; + } + + public void setAttachmentTime (float time) { + attachmentTime = skeleton.time - time; + } + + /** Returns the time since the attachment was set. */ + public float getAttachmentTime () { + return skeleton.time - attachmentTime; + } + + void setToBindPose (int slotIndex) { + color.set(data.color); + setAttachment(data.attachmentName == null ? null : skeleton.getAttachment(slotIndex, data.attachmentName)); + } + + public void setToBindPose () { + setToBindPose(skeleton.slots.indexOf(this, true)); + } + + public String toString () { + return data.name; + } +} diff --git a/spine-libgdx/src/com/esotericsoftware/spine/SlotData.java b/spine-libgdx/src/com/esotericsoftware/spine/SlotData.java new file mode 100644 index 000000000..f5c9ce203 --- /dev/null +++ b/spine-libgdx/src/com/esotericsoftware/spine/SlotData.java @@ -0,0 +1,49 @@ + +package com.esotericsoftware.spine; + +import com.badlogic.gdx.graphics.Color; + +public class SlotData { + final String name; + final BoneData boneData; + final Color color = new Color(1, 1, 1, 1); + String attachmentName; + + SlotData () { + name = null; + boneData = null; + } + + public SlotData (String name, BoneData boneData) { + if (name == null) throw new IllegalArgumentException("name cannot be null."); + if (boneData == null) throw new IllegalArgumentException("boneData cannot be null."); + this.name = name; + this.boneData = boneData; + } + + public String getName () { + return name; + } + + public BoneData getBoneData () { + return boneData; + } + + public Color getColor () { + return color; + } + + /** @param attachmentName May be null. */ + public void setAttachmentName (String attachmentName) { + this.attachmentName = attachmentName; + } + + /** @return May be null. */ + public String getAttachmentName () { + return attachmentName; + } + + public String toString () { + return name; + } +} diff --git a/spine-libgdx/src/com/esotericsoftware/spine/attachments/RegionAttachment.java b/spine-libgdx/src/com/esotericsoftware/spine/attachments/RegionAttachment.java new file mode 100644 index 000000000..a5cf355da --- /dev/null +++ b/spine-libgdx/src/com/esotericsoftware/spine/attachments/RegionAttachment.java @@ -0,0 +1,153 @@ + +package com.esotericsoftware.spine.attachments; + +import com.esotericsoftware.spine.Attachment; +import com.esotericsoftware.spine.Bone; +import com.esotericsoftware.spine.Slot; + +import static com.badlogic.gdx.graphics.g2d.SpriteBatch.*; + +import com.badlogic.gdx.graphics.Color; +import com.badlogic.gdx.graphics.g2d.SpriteBatch; +import com.badlogic.gdx.graphics.g2d.TextureAtlas.AtlasRegion; +import com.badlogic.gdx.graphics.g2d.TextureRegion; +import com.badlogic.gdx.math.MathUtils; +import com.badlogic.gdx.utils.NumberUtils; + +/** Attachment that displays a texture region. */ +public class RegionAttachment extends Attachment { + private TextureRegion region; + private final float[] vertices = new float[20]; + private final float[] offset = new float[8]; + + public RegionAttachment (String name) { + super(name); + } + + public void updateOffset () { + float width = getWidth(); + float height = getHeight(); + float localX2 = width / 2; + float localY2 = height / 2; + float localX = -localX2; + float localY = -localY2; + if (region instanceof AtlasRegion) { + AtlasRegion region = (AtlasRegion)this.region; + if (region.rotate) { + localX += region.offsetX / region.originalWidth * height; + localY += region.offsetY / region.originalHeight * width; + localX2 -= (region.originalWidth - region.offsetX - region.packedHeight) / region.originalWidth * width; + localY2 -= (region.originalHeight - region.offsetY - region.packedWidth) / region.originalHeight * height; + } else { + localX += region.offsetX / region.originalWidth * width; + localY += region.offsetY / region.originalHeight * height; + localX2 -= (region.originalWidth - region.offsetX - region.packedWidth) / region.originalWidth * width; + localY2 -= (region.originalHeight - region.offsetY - region.packedHeight) / region.originalHeight * height; + } + } + float scaleX = getScaleX(); + float scaleY = getScaleY(); + localX *= scaleX; + localY *= scaleY; + localX2 *= scaleX; + localY2 *= scaleY; + float rotation = getRotation(); + float cos = MathUtils.cosDeg(rotation); + float sin = MathUtils.sinDeg(rotation); + float x = getX(); + float y = getY(); + float localXCos = localX * cos + x; + float localXSin = localX * sin; + float localYCos = localY * cos + y; + float localYSin = localY * sin; + float localX2Cos = localX2 * cos + x; + float localX2Sin = localX2 * sin; + float localY2Cos = localY2 * cos + y; + float localY2Sin = localY2 * sin; + float[] offset = this.offset; + offset[0] = localXCos - localYSin; + offset[1] = localYCos + localXSin; + offset[2] = localXCos - localY2Sin; + offset[3] = localY2Cos + localXSin; + offset[4] = localX2Cos - localY2Sin; + offset[5] = localY2Cos + localX2Sin; + offset[6] = localX2Cos - localYSin; + offset[7] = localYCos + localX2Sin; + } + + public void setRegion (TextureRegion region) { + if (region == null) throw new IllegalArgumentException("region cannot be null."); + TextureRegion oldRegion = this.region; + this.region = region; + float[] vertices = this.vertices; + if (region instanceof AtlasRegion && ((AtlasRegion)region).rotate) { + vertices[U2] = region.getU(); + vertices[V2] = region.getV2(); + vertices[U3] = region.getU(); + vertices[V3] = region.getV(); + vertices[U4] = region.getU2(); + vertices[V4] = region.getV(); + vertices[U1] = region.getU2(); + vertices[V1] = region.getV2(); + } else { + vertices[U1] = region.getU(); + vertices[V1] = region.getV2(); + vertices[U2] = region.getU(); + vertices[V2] = region.getV(); + vertices[U3] = region.getU2(); + vertices[V3] = region.getV(); + vertices[U4] = region.getU2(); + vertices[V4] = region.getV2(); + } + updateOffset(); + } + + public TextureRegion getRegion () { + if (region == null) throw new IllegalStateException("RegionAttachment is not resolved: " + this); + return region; + } + + public void draw (SpriteBatch batch, Slot slot) { + if (region == null) throw new IllegalStateException("RegionAttachment is not resolved: " + this); + + Color skeletonColor = slot.getSkeleton().getColor(); + Color slotColor = slot.getColor(); + float color = NumberUtils.intToFloatColor( // + ((int)(255 * skeletonColor.a * slotColor.a) << 24) // + | ((int)(255 * skeletonColor.b * slotColor.b) << 16) // + | ((int)(255 * skeletonColor.g * slotColor.g) << 8) // + | ((int)(255 * skeletonColor.r * slotColor.r))); + float[] vertices = this.vertices; + vertices[C1] = color; + vertices[C2] = color; + vertices[C3] = color; + vertices[C4] = color; + + updateWorldVertices(slot.getBone()); + + batch.draw(region.getTexture(), vertices, 0, vertices.length); + } + + public void updateWorldVertices (Bone bone) { + float[] vertices = this.vertices; + float[] offset = this.offset; + float x = bone.getWorldX(); + float y = bone.getWorldY(); + float m00 = bone.getM00(); + float m01 = bone.getM01(); + float m10 = bone.getM10(); + float m11 = bone.getM11(); + vertices[X1] = offset[0] * m00 + offset[1] * m01 + x; + vertices[Y1] = offset[0] * m10 + offset[1] * m11 + y; + vertices[X2] = offset[2] * m00 + offset[3] * m01 + x; + vertices[Y2] = offset[2] * m10 + offset[3] * m11 + y; + vertices[X3] = offset[4] * m00 + offset[5] * m01 + x; + vertices[Y3] = offset[4] * m10 + offset[5] * m11 + y; + vertices[X4] = offset[6] * m00 + offset[7] * m01 + x; + vertices[Y4] = offset[6] * m10 + offset[7] * m11 + y; + } + + public float[] getWorldVertices () { + return vertices; + } +} diff --git a/spine-libgdx/src/com/esotericsoftware/spine/attachments/RegionSequenceAttachment.java b/spine-libgdx/src/com/esotericsoftware/spine/attachments/RegionSequenceAttachment.java new file mode 100644 index 000000000..80acea639 --- /dev/null +++ b/spine-libgdx/src/com/esotericsoftware/spine/attachments/RegionSequenceAttachment.java @@ -0,0 +1,68 @@ + +package com.esotericsoftware.spine.attachments; + +import com.esotericsoftware.spine.Slot; + +import com.badlogic.gdx.graphics.g2d.SpriteBatch; +import com.badlogic.gdx.graphics.g2d.TextureRegion; +import com.badlogic.gdx.math.MathUtils; + +/** Attachment that displays various texture regions over time. */ +public class RegionSequenceAttachment extends RegionAttachment { + private final Mode mode; + private float frameTime; + private TextureRegion[] regions; + + /** @param frameTime Time in seconds each frame is shown. */ + public RegionSequenceAttachment (String name, float frameTime, Mode mode) { + super(name); + if (mode == null) throw new IllegalArgumentException("mode cannot be null."); + + this.frameTime = frameTime; + this.mode = mode; + } + + public void draw (SpriteBatch batch, Slot slot) { + if (regions == null) throw new IllegalStateException("RegionSequenceAttachment is not resolved: " + this); + + int frameIndex = (int)(slot.getAttachmentTime() / frameTime); + switch (mode) { + case forward: + frameIndex = Math.min(regions.length - 1, frameIndex); + break; + case forwardLoop: + frameIndex = frameIndex % regions.length; + break; + case pingPong: + frameIndex = frameIndex % (regions.length * 2); + if (frameIndex >= regions.length) frameIndex = regions.length - 1 - (frameIndex - regions.length); + break; + case random: + frameIndex = MathUtils.random(regions.length - 1); + break; + case backward: + frameIndex = Math.max(regions.length - frameIndex - 1, 0); + break; + case backwardLoop: + frameIndex = frameIndex % regions.length; + frameIndex = regions.length - frameIndex - 1; + break; + } + setRegion(regions[frameIndex]); + super.draw(batch, slot); + } + + /** May be null if the attachment is not resolved. */ + public TextureRegion[] getRegions () { + if (regions == null) throw new IllegalStateException("RegionSequenceAttachment is not resolved: " + this); + return regions; + } + + public void setRegions (TextureRegion[] regions) { + this.regions = regions; + } + + static public enum Mode { + forward, backward, forwardLoop, backwardLoop, pingPong, random + } +} diff --git a/spine-libgdx/src/com/esotericsoftware/spine/attachments/TextureAtlasAttachmentResolver.java b/spine-libgdx/src/com/esotericsoftware/spine/attachments/TextureAtlasAttachmentResolver.java new file mode 100644 index 000000000..ed5b70530 --- /dev/null +++ b/spine-libgdx/src/com/esotericsoftware/spine/attachments/TextureAtlasAttachmentResolver.java @@ -0,0 +1,29 @@ + +package com.esotericsoftware.spine.attachments; + +import com.esotericsoftware.spine.Attachment; +import com.esotericsoftware.spine.AttachmentResolver; + +import com.badlogic.gdx.graphics.g2d.TextureAtlas; +import com.badlogic.gdx.graphics.g2d.TextureAtlas.AtlasRegion; + +public class TextureAtlasAttachmentResolver implements AttachmentResolver { + private TextureAtlas atlas; + + public TextureAtlasAttachmentResolver (TextureAtlas atlas) { + if (atlas == null) throw new IllegalArgumentException("atlas cannot be null."); + this.atlas = atlas; + } + + public void resolve (Attachment attachment) { + if (attachment instanceof RegionAttachment) { + AtlasRegion region = atlas.findRegion(attachment.getName()); + if (region == null) throw new RuntimeException("Region not found in atlas: " + attachment); + ((RegionAttachment)attachment).setRegion(region); + attachment.setResolved(true); + return; + } + + throw new IllegalArgumentException("Unable to resolve attachment of type: " + attachment.getClass().getName()); + } +} diff --git a/spine-libgdx/test/com/esotericsoftware/spine/MixTest.java b/spine-libgdx/test/com/esotericsoftware/spine/MixTest.java new file mode 100644 index 000000000..cb78495b0 --- /dev/null +++ b/spine-libgdx/test/com/esotericsoftware/spine/MixTest.java @@ -0,0 +1,124 @@ + +package com.esotericsoftware.spine; + +import com.badlogic.gdx.ApplicationAdapter; +import com.badlogic.gdx.Gdx; +import com.badlogic.gdx.Input.Keys; +import com.badlogic.gdx.InputAdapter; +import com.badlogic.gdx.backends.lwjgl.LwjglApplication; +import com.badlogic.gdx.backends.lwjgl.LwjglApplicationConfiguration; +import com.badlogic.gdx.graphics.Color; +import com.badlogic.gdx.graphics.GL10; +import com.badlogic.gdx.graphics.g2d.SpriteBatch; +import com.badlogic.gdx.graphics.g2d.TextureAtlas; +import com.badlogic.gdx.graphics.glutils.ShapeRenderer; + +public class MixTest extends ApplicationAdapter { + SpriteBatch batch; + float time; + ShapeRenderer renderer; + + SkeletonData skeletonData; + Skeleton skeleton; + Animation walkAnimation; + Animation jumpAnimation; + + public void create () { + batch = new SpriteBatch(); + renderer = new ShapeRenderer(); + + final String name = "spineboy"; + + TextureAtlas atlas = new TextureAtlas(Gdx.files.internal(name + ".atlas")); + + if (true) { + SkeletonJson json = new SkeletonJson(atlas); + // json.setScale(2); + skeletonData = json.readSkeletonData(Gdx.files.internal(name + "-skeleton.json")); + walkAnimation = json.readAnimation(Gdx.files.internal(name + "-walk.json"), skeletonData); + jumpAnimation = json.readAnimation(Gdx.files.internal(name + "-jump.json"), skeletonData); + } else { + SkeletonBinary binary = new SkeletonBinary(atlas); + // binary.setScale(2); + skeletonData = binary.readSkeletonData(Gdx.files.internal(name + ".skel")); + walkAnimation = binary.readAnimation(Gdx.files.internal(name + "-walk.anim"), skeletonData); + jumpAnimation = binary.readAnimation(Gdx.files.internal(name + "-jump.anim"), skeletonData); + } + + skeleton = new Skeleton(skeletonData); + skeleton.setToBindPose(); + + final Bone root = skeleton.getRootBone(); + root.x = -50; + root.y = 20; + root.scaleX = 1f; + root.scaleY = 1f; + skeleton.updateWorldTransform(); + } + + public void render () { + float delta = Gdx.graphics.getDeltaTime() * 0.25f; // Reduced to make mixing easier to see. + + float jump = jumpAnimation.getDuration(); + float beforeJump = 1f; + float blendIn = 0.4f; + float blendOut = 0.4f; + float blendOutStart = beforeJump + jump - blendOut; + float total = 3.75f; + + time += delta; + + Bone root = skeleton.getRootBone(); + float speed = 180; + if (time > beforeJump + blendIn && time < blendOutStart) speed = 360; + root.setX(root.getX() + speed * delta); + + Gdx.gl.glClear(GL10.GL_COLOR_BUFFER_BIT); + batch.begin(); + batch.setColor(Color.GRAY); + + if (time > total) { + // restart + time = 0; + root.setX(-50); + } else if (time > beforeJump + jump) { + // just walk after jump + walkAnimation.apply(skeleton, time, true); + } else if (time > blendOutStart) { + // blend out jump + walkAnimation.apply(skeleton, time, true); + jumpAnimation.mix(skeleton, time - beforeJump, false, 1 - (time - blendOutStart) / blendOut); + } else if (time > beforeJump + blendIn) { + // just jump + jumpAnimation.apply(skeleton, time - beforeJump, false); + } else if (time > beforeJump) { + // blend in jump + walkAnimation.apply(skeleton, time, true); + jumpAnimation.mix(skeleton, time - beforeJump, false, (time - beforeJump) / blendIn); + } else { + // just walk before jump + walkAnimation.apply(skeleton, time, true); + } + + skeleton.updateWorldTransform(); + skeleton.update(Gdx.graphics.getDeltaTime()); + skeleton.draw(batch); + + batch.end(); + + // skeleton.drawDebug(renderer); + } + + public void resize (int width, int height) { + batch.getProjectionMatrix().setToOrtho2D(0, 0, width, height); + renderer.setProjectionMatrix(batch.getProjectionMatrix()); + } + + public static void main (String[] args) throws Exception { + LwjglApplicationConfiguration config = new LwjglApplicationConfiguration(); + config.title = "Mix Test"; + config.width = 640; + config.height = 480; + new LwjglApplication(new MixTest(), config); + } +} diff --git a/spine-libgdx/test/com/esotericsoftware/spine/SkeletonTest.java b/spine-libgdx/test/com/esotericsoftware/spine/SkeletonTest.java new file mode 100644 index 000000000..7367dabba --- /dev/null +++ b/spine-libgdx/test/com/esotericsoftware/spine/SkeletonTest.java @@ -0,0 +1,123 @@ + +package com.esotericsoftware.spine; + +import com.badlogic.gdx.ApplicationAdapter; +import com.badlogic.gdx.Gdx; +import com.badlogic.gdx.Input.Keys; +import com.badlogic.gdx.InputAdapter; +import com.badlogic.gdx.backends.lwjgl.LwjglApplication; +import com.badlogic.gdx.backends.lwjgl.LwjglApplicationConfiguration; +import com.badlogic.gdx.files.FileHandle; +import com.badlogic.gdx.graphics.Color; +import com.badlogic.gdx.graphics.GL10; +import com.badlogic.gdx.graphics.Pixmap; +import com.badlogic.gdx.graphics.Pixmap.Format; +import com.badlogic.gdx.graphics.Texture; +import com.badlogic.gdx.graphics.g2d.SpriteBatch; +import com.badlogic.gdx.graphics.g2d.TextureAtlas; +import com.badlogic.gdx.graphics.g2d.TextureAtlas.AtlasRegion; +import com.badlogic.gdx.graphics.g2d.TextureAtlas.TextureAtlasData; +import com.badlogic.gdx.graphics.glutils.ShapeRenderer; + +public class SkeletonTest extends ApplicationAdapter { + SpriteBatch batch; + float time; + ShapeRenderer renderer; + + SkeletonData skeletonData; + Skeleton skeleton; + Animation animation; + + public void create () { + batch = new SpriteBatch(); + renderer = new ShapeRenderer(); + + final String name = "goblins"; + + // A regular texture atlas would normally usually be used. This returns a white image for images not found in the atlas. + Pixmap pixmap = new Pixmap(32, 32, Format.RGBA8888); + pixmap.setColor(Color.WHITE); + pixmap.fill(); + final AtlasRegion fake = new AtlasRegion(new Texture(pixmap), 0, 0, 32, 32); + pixmap.dispose(); + FileHandle atlasFile = Gdx.files.internal(name + ".atlas"); + TextureAtlasData data = !atlasFile.exists() ? null : new TextureAtlasData(atlasFile, atlasFile.parent(), false); + TextureAtlas atlas = new TextureAtlas(data) { + public AtlasRegion findRegion (String name) { + AtlasRegion region = super.findRegion(name); + return region != null ? region : fake; + } + }; + + if (true) { + SkeletonJson json = new SkeletonJson(atlas); + // json.setScale(2); + skeletonData = json.readSkeletonData(Gdx.files.internal(name + "-skeleton.json")); + animation = json.readAnimation(Gdx.files.internal(name + "-walk.json"), skeletonData); + } else { + SkeletonBinary binary = new SkeletonBinary(atlas); + // binary.setScale(2); + skeletonData = binary.readSkeletonData(Gdx.files.internal(name + ".skel")); + animation = binary.readAnimation(Gdx.files.internal(name + "-walk.anim"), skeletonData); + } + + skeleton = new Skeleton(skeletonData); + if (name.equals("goblins")) skeleton.setSkin("goblin"); + skeleton.setToBindPose(); + + Bone root = skeleton.getRootBone(); + root.x = 50; + root.y = 20; + root.scaleX = 1f; + root.scaleY = 1f; + skeleton.updateWorldTransform(); + + Gdx.input.setInputProcessor(new InputAdapter() { + public boolean keyDown (int keycode) { + if (keycode == Keys.SPACE) { + if (name.equals("goblins")) { + skeleton.setSkin(skeleton.getSkin().getName().equals("goblin") ? "goblingirl" : "goblin"); + skeleton.setSlotsToBindPose(); + } + } + return true; + } + }); + } + + public void render () { + time += Gdx.graphics.getDeltaTime(); + + Bone root = skeleton.getRootBone(); + float x = root.getX() + 160 * Gdx.graphics.getDeltaTime() * (skeleton.getFlipX() ? -1 : 1); + if (x > Gdx.graphics.getWidth()) skeleton.setFlipX(true); + if (x < 0) skeleton.setFlipX(false); + root.setX(x); + + Gdx.gl.glClear(GL10.GL_COLOR_BUFFER_BIT); + batch.begin(); + batch.setColor(Color.GRAY); + + animation.apply(skeleton, time, true); + skeleton.updateWorldTransform(); + skeleton.update(Gdx.graphics.getDeltaTime()); + skeleton.draw(batch); + + batch.end(); + + skeleton.drawDebug(renderer); + } + + public void resize (int width, int height) { + batch.getProjectionMatrix().setToOrtho2D(0, 0, width, height); + renderer.setProjectionMatrix(batch.getProjectionMatrix()); + } + + public static void main (String[] args) throws Exception { + LwjglApplicationConfiguration config = new LwjglApplicationConfiguration(); + config.title = "Skeleton Test"; + config.width = 640; + config.height = 480; + new LwjglApplication(new SkeletonTest(), config); + } +} diff --git a/spine-libgdx/test/goblins-skeleton.json b/spine-libgdx/test/goblins-skeleton.json new file mode 100644 index 000000000..be335a530 --- /dev/null +++ b/spine-libgdx/test/goblins-skeleton.json @@ -0,0 +1,202 @@ +{ +"bones": [ + { "name": "root", "length": 0 }, + { "name": "hip", "parent": "root", "length": 0, "x": 0.64, "y": 114.41 }, + { "name": "left upper leg", "parent": "hip", "length": 50.39, "x": 14.45, "y": 2.81, "rotation": -89.09 }, + { "name": "left lower leg", "parent": "left upper leg", "length": 49.89, "x": 56.34, "y": 0.98, "rotation": -16.65 }, + { "name": "left foot", "parent": "left lower leg", "length": 46.5, "x": 58.94, "y": -7.61, "rotation": 102.43 }, + { "name": "right upper leg", "parent": "hip", "length": 42.45, "x": -20.07, "y": -6.83, "rotation": -97.49 }, + { "name": "right lower leg", "parent": "right upper leg", "length": 58.52, "x": 42.99, "y": -0.61, "rotation": -14.34 }, + { "name": "right foot", "parent": "right lower leg", "length": 45.45, "x": 64.88, "y": 0.04, "rotation": 110.3 }, + { "name": "torso", "parent": "hip", "length": 85.82, "x": -6.42, "y": 1.97, "rotation": 93.92 }, + { "name": "neck", "parent": "torso", "length": 18.38, "x": 81.67, "y": -6.34, "rotation": -1.51 }, + { "name": "head", "parent": "neck", "length": 68.28, "x": 20.93, "y": 11.59, "rotation": -13.92 }, + { "name": "right shoulder", "parent": "torso", "length": 37.24, "x": 76.02, "y": 18.14, "rotation": 133.88 }, + { "name": "right arm", "parent": "right shoulder", "length": 36.74, "x": 37.6, "y": 0.31, "rotation": 36.32 }, + { "name": "right hand", "parent": "right arm", "length": 15.32, "x": 36.9, "y": 0.34, "rotation": 2.35 }, + { "name": "left shoulder", "parent": "torso", "length": 35.43, "x": 74.04, "y": -20.38, "rotation": -156.96 }, + { "name": "left arm", "parent": "left shoulder", "length": 35.62, "x": 37.85, "y": -2.34, "rotation": 28.16 }, + { "name": "left hand", "parent": "left arm", "length": 11.52, "x": 35.62, "y": 0.07, "rotation": 2.7 }, + { "name": "pelvis", "parent": "hip", "length": 0, "x": 1.41, "y": -6.57 } +], +"slots": [ + { "name": "left shoulder", "bone": "left shoulder", "attachment": "left shoulder" }, + { "name": "left arm", "bone": "left arm", "attachment": "left arm" }, + { "name": "left hand item", "bone": "left hand", "attachment": "left hand item" }, + { "name": "left hand", "bone": "left hand", "attachment": "left hand" }, + { "name": "left foot", "bone": "left foot", "attachment": "left foot" }, + { "name": "left lower leg", "bone": "left lower leg", "attachment": "left lower leg" }, + { "name": "left upper leg", "bone": "left upper leg", "attachment": "left upper leg" }, + { "name": "neck", "bone": "neck", "attachment": "neck" }, + { "name": "torso", "bone": "torso", "attachment": "torso" }, + { "name": "pelvis", "bone": "pelvis", "attachment": "pelvis" }, + { "name": "right foot", "bone": "right foot", "attachment": "right foot" }, + { "name": "right lower leg", "bone": "right lower leg", "attachment": "right lower leg" }, + { "name": "undie straps", "bone": "pelvis", "attachment": "undie straps" }, + { "name": "undies", "bone": "pelvis", "attachment": "undies" }, + { "name": "right upper leg", "bone": "right upper leg", "attachment": "right upper leg" }, + { "name": "head", "bone": "head", "attachment": "head" }, + { "name": "eyes", "bone": "head", "attachment": "eyes open" }, + { "name": "right shoulder", "bone": "right shoulder", "attachment": "right shoulder" }, + { "name": "right arm", "bone": "right arm", "attachment": "right arm" }, + { "name": "right hand item 2", "bone": "right hand", "attachment": "right hand item 2" }, + { "name": "right hand", "bone": "right hand", "attachment": "right hand" }, + { "name": "right hand item", "bone": "right hand", "attachment": "right hand item" } +], +"skins": { + "goblin": { + "neck": { + "neck": { "name": "goblin/neck", "x": 10.1, "y": 0.42, "rotation": -93.69, "width": 36, "height": 41 } + }, + "undies": { + "undies": { "name": "goblin/undies", "x": 6.3, "y": 0.12, "rotation": 0.91, "width": 36, "height": 29 } + }, + "right hand": { + "right hand": { "name": "goblin/right-hand", "x": 7.88, "y": 2.78, "rotation": 91.96, "width": 36, "height": 37 } + }, + "right arm": { + "right arm": { "name": "goblin/right-arm", "x": 16.44, "y": -1.04, "rotation": 94.32, "width": 23, "height": 50 } + }, + "head": { + "head": { "name": "goblin/head", "x": 25.73, "y": 2.33, "rotation": -92.29, "width": 103, "height": 66 } + }, + "left shoulder": { + "left shoulder": { "name": "goblin/left-shoulder", "x": 15.56, "y": -2.26, "rotation": 62.01, "width": 29, "height": 44 } + }, + "left arm": { + "left arm": { + "name": "goblin/left-arm", + "x": 16.7, + "y": -1.69, + "scaleX": 1.057, + "scaleY": 1.057, + "rotation": 33.84, + "width": 37, + "height": 35 + } + }, + "left hand": { + "left hand": { + "name": "goblin/left-hand", + "x": 3.47, + "y": 3.41, + "scaleX": 0.892, + "scaleY": 0.892, + "rotation": 31.14, + "width": 36, + "height": 41 + } + }, + "right lower leg": { + "right lower leg": { "name": "goblin/right-lower-leg", "x": 25.68, "y": -3.15, "rotation": 111.83, "width": 36, "height": 76 } + }, + "right upper leg": { + "right upper leg": { "name": "goblin/right-upper-leg", "x": 20.35, "y": 1.47, "rotation": 97.49, "width": 34, "height": 63 } + }, + "pelvis": { + "pelvis": { "name": "goblin/pelvis", "x": -5.61, "y": 0.76, "width": 62, "height": 43 } + }, + "left lower leg": { + "left lower leg": { "name": "goblin/left-lower-leg", "x": 23.58, "y": -2.06, "rotation": 105.75, "width": 33, "height": 70 } + }, + "left upper leg": { + "left upper leg": { "name": "goblin/left-upper-leg", "x": 29.68, "y": -3.87, "rotation": 89.09, "width": 33, "height": 73 } + }, + "torso": { + "torso": { "name": "goblin/torso", "x": 38.09, "y": -3.87, "rotation": -94.95, "width": 68, "height": 96 } + }, + "right shoulder": { + "right shoulder": { "name": "goblin/right-shoulder", "x": 15.68, "y": -1.03, "rotation": 130.65, "width": 39, "height": 45 } + }, + "right foot": { + "right foot": { "name": "goblin/right-foot", "x": 23.56, "y": 9.8, "rotation": 1.52, "width": 63, "height": 33 } + }, + "left foot": { + "left foot": { "name": "goblin/left-foot", "x": 24.85, "y": 8.74, "rotation": 3.32, "width": 65, "height": 31 } + }, + "right hand item": { + "right hand item": { "name": "goblin/shield", "x": -0.47, "y": 1.1, "rotation": 91.16, "width": 70, "height": 72 } + }, + "left hand item": { + "left hand item": { "name": "goblin/spear", "x": -4.55, "y": 39.2, "rotation": 13.04, "width": 22, "height": 368 } + }, + "undie straps": { + "undie straps": { "name": "goblin/undie-straps", "x": -3.87, "y": 13.1, "scaleX": 1.089, "width": 55, "height": 19 } + } + }, + "goblingirl": { + "left upper leg": { + "left upper leg": { "name": "goblingirl/left-upper-leg", "x": 30.21, "y": -2.95, "rotation": 89.09, "width": 33, "height": 70 } + }, + "left lower leg": { + "left lower leg": { "name": "goblingirl/left-lower-leg", "x": 25.02, "y": -0.6, "rotation": 105.75, "width": 33, "height": 70 } + }, + "left foot": { + "left foot": { "name": "goblingirl/left-foot", "x": 25.17, "y": 7.92, "rotation": 3.32, "width": 65, "height": 31 } + }, + "right upper leg": { + "right upper leg": { "name": "goblingirl/right-upper-leg", "x": 19.69, "y": 2.13, "rotation": 97.49, "width": 34, "height": 63 } + }, + "right lower leg": { + "right lower leg": { "name": "goblingirl/right-lower-leg", "x": 26.15, "y": -3.27, "rotation": 111.83, "width": 36, "height": 76 } + }, + "right foot": { + "right foot": { "name": "goblingirl/right-foot", "x": 23.46, "y": 9.66, "rotation": 1.52, "width": 63, "height": 33 } + }, + "torso": { + "torso": { "name": "goblingirl/torso", "x": 36.28, "y": -5.14, "rotation": -95.74, "width": 68, "height": 96 } + }, + "left shoulder": { + "left shoulder": { "name": "goblingirl/left-shoulder", "x": 19.8, "y": -0.42, "rotation": 61.21, "width": 28, "height": 46 } + }, + "left arm": { + "left arm": { "name": "goblingirl/left-arm", "x": 19.64, "y": -2.42, "rotation": 33.05, "width": 37, "height": 35 } + }, + "left hand": { + "left hand": { + "name": "goblingirl/left-hand", + "x": 4.34, + "y": 2.39, + "scaleX": 0.896, + "scaleY": 0.896, + "rotation": 30.34, + "width": 35, + "height": 40 + } + }, + "neck": { + "neck": { "name": "goblingirl/neck", "x": 6.16, "y": -3.14, "rotation": -98.86, "width": 35, "height": 41 } + }, + "head": { + "head": { "name": "goblingirl/head", "x": 27.71, "y": -4.32, "rotation": -85.58, "width": 103, "height": 81 } + }, + "right shoulder": { + "right shoulder": { "name": "goblingirl/right-shoulder", "x": 14.46, "y": 0.45, "rotation": 129.85, "width": 39, "height": 45 } + }, + "right arm": { + "right arm": { "name": "goblingirl/right-arm", "x": 16.85, "y": -0.66, "rotation": 93.52, "width": 28, "height": 50 } + }, + "right hand": { + "right hand": { "name": "goblingirl/right-hand", "x": 7.21, "y": 3.43, "rotation": 91.16, "width": 36, "height": 37 } + }, + "pelvis": { + "pelvis": { "name": "goblingirl/pelvis", "x": -3.87, "y": 3.18, "width": 62, "height": 43 } + }, + "undie straps": { + "undie straps": { "name": "goblingirl/undie-straps", "x": -1.51, "y": 14.18, "width": 55, "height": 19 } + }, + "undies": { + "undies": { "name": "goblingirl/undies", "x": 5.4, "y": 1.7, "width": 36, "height": 29 } + }, + "left hand item": { + "left hand item": { "name": "goblingirl/dagger", "x": 7.88, "y": -23.45, "rotation": 10.47, "width": 26, "height": 108 } + }, + "right hand item 2": { + "right hand item 2": { "name": "goblingirl/dagger", "x": 7.17, "y": -22.38, "rotation": -5.27, "width": 26, "height": 108 } + }, + "right hand item": { + "right hand item": { "name": "goblingirl/dagger-tip", "x": 13.45, "y": 22.07, "rotation": -3.23, "width": 17, "height": 17 } + } + } +} +} \ No newline at end of file diff --git a/spine-libgdx/test/goblins-walk.anim b/spine-libgdx/test/goblins-walk.anim new file mode 100644 index 0000000000000000000000000000000000000000..f77b26afdb58a2187b12fb014b4880ed9cbb3c87 GIT binary patch literal 1705 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 literal 0 HcmV?d00001 diff --git a/spine-libgdx/test/goblins.skel b/spine-libgdx/test/goblins.skel new file mode 100644 index 0000000000000000000000000000000000000000..6b9e70b106c3fe236cd0ae6bd80bb3065e5a1c1e GIT binary patch literal 4152 zcmaJ@4Nw$S9Dgey$cKCgh`>1KjG2z24ibZv-0s5}B{Q{jGBpSAR=7O5^A7SfWiFCp z%qcZ3DoxZmz%7@W$nAvp}pvUR`D>ce!M@#UU3Xd8s(BM$Aen zprV0enXxecy&NLyaIPn!CQVpakZs+ZX`xzeRe7`FoSJcw*uiQQq)8vHY426;?0%Oj z!1Grx!N-Nq;@tM)5)-7h+I<0~=h}2C8wlJ#11DX{)?^tbvo4(cPq=^V4xAFC+a`N^ z;Y+FSM-d+gmDvP*^{awe*P_}DkC!^@m*j}zrb>GTa)hi>^O7})f~Agn)} zA66=_T0_L(!R0fQa}$!Oh(EAEl-?QT4J(lgZCFk^T%kxaD<@Kkwv}f)VD--WSc1$` z;w*RAWVdFnChBu($JEounxc45p|aH_ocf(NSciAC+=m=nr?vj+gBolz8ijw)4u@)fcIA z+T_Vbr^ej_^=CX`F4+RfunlQbgw0|vlh^7{k<@>_G>YjvvOdHEneTCV?9c|3NRgHYMGK4#`T(we}C4YfElkxFr(cw&qDP?~%CqET+8FW|u9V zGIycN!}&FyV~0rx{R*-k?g z2BdL^j^=hh+e7Cp&}2)8aR9*a0K^Dd?ni1Gq!K_pyFVgVILXG>x+Zfv(vfZgkSK6) z5;Q%WhztZ6h(jy3iaK-QNQ18;d_h4-B{c4b}KyGyoxj&KERB?3H9^Wu{A9 zR^YSRRzvhie@$3Ps}Ut=m1X2G+K?lBoT1+9YUCT|DNm)vG2A~LxsI*W05FnTVMAiH zf{%%n0~cJ@mKg=i3c80Q)F?IqFhbDgmv#mrZlE0RsDhFGeaiaYO6oPx(!Ui}s~QRb@q%ggsaMk1dcSP!@Ahw*>Z3ODh8=nZrmHrx0Enb> zfvyMRT%Z#mHCL5M=~s_XUF+!22tYGluk_MD$xE+9DTC$lg&6vj}7rKG6<6;6#@5-ls zrG*`XQUd^a>P$up22xMdQjPf|gIoYW@xp3p(FvdRO>YRYfqrm>id*f{D56kocRP}T zYM!dUoQ6k-tNS0V&B~KE1}G*->#l|r)PF&CxE}17;_#nz3fAYToQHxNz&g;eCM zV~%*=^BqOOS0s4;(ztL)Lviu!efy>uu|zKqH-o`^5NwHy=u%dZvZ$+;VuBne7QlQV$H2o{m+8g8T)fw^R7qQ*C|j48FrE6z zGx1$@;34e8_pO+O$lO>6s}1O zY~l~B+a?ta_qX*_n7gg-t0E`lXzwjPr;^#U`+wn9THKEjfQ9w-u6F8rHf+3^K?gG;D%W9;C QJxiI91<^oK?=STH3r)VCi2wiq literal 0 HcmV?d00001 diff --git a/spine-libgdx/test/goblins2.png b/spine-libgdx/test/goblins2.png new file mode 100644 index 0000000000000000000000000000000000000000..f90ce4753f8649bfe617a3022d15bc0f7a9d441a GIT binary patch literal 116173 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 Y7ged%i)qzt;{X5v07*qoM6N<$f>U9mF#rGn literal 0 HcmV?d00001 diff --git a/spine-libgdx/test/spineboy-jump.anim b/spine-libgdx/test/spineboy-jump.anim new file mode 100644 index 0000000000000000000000000000000000000000..966f8a03cc8aec5e119f8b39cfde8f899fc9fc5d GIT binary patch literal 2932 zcmb`Je@s(X6vtm%iu`Z_8*!L9(g9g?kqE@G5#ZhT9&GFfiplJJU{TN*cxQpcaVWOgW~-mmS?uluhd@K63of7r zAIa9jr~l!JS|AA-uvE;)B~9%us+NhSeocUYI)116-dMqMw&X&QB!Ss zghxg$40Dg8_i}*efK8G^85@gmD}wilV;G3Z9Cd^QQd!?%OM5tuw4-jz*?aM z3vAR}$^Y@zjW1fcw_M2$SgBujR&YzXzi#4|y85h7AZD|f9{yn?Rz^3+>bbW(Q!jCE zL7qr=DV}$Uo9i*A8rgHug|xCO&m)L#_Yt`)4F=3*jvlZZ+s)Q819#clo-Dqt-Sxd# z5p8E7BE3*V`OUn@$tMilN3czz3f97mcJL zu|FaCDCavcy9xQ^nxRJIli!;JV&L;@hWNf<(>b4N%^4@x5`iC*g#)M|6fDpr`a08Q zt4@Qbj$C@Qnrq$Mdk~eCFW+|{p4|9?8}Uf@iSxLswDj8v#FPA&^8|9zY?iwwa=7Oq zPo#C!TTGQzbDYx2SJrUO;{~@lXZ=<S)X~>cAe3G*ALRnEusQW%aA$;Wxv)zS8(RcCFYxn-6V! zojl*Olk6zZBr&aRgX^PDJhHEY+xu@}UkBa$tFf<2atEBjATX|i;;Vl?uuGG{&yG+4 z&xGzQw6DA#R9MeErn+Xw`A*-vxEzJ$SD3**80|+8b|uon&Yk%49oAQ&;hn_+a~KRF ty{_H?A23=?6ssM7_?2RD!j}|$r^-*?Nx_ow7PdI}t;sFsf?WxJ;U95;yB7ce literal 0 HcmV?d00001 diff --git a/spine-libgdx/test/spineboy-jump.json b/spine-libgdx/test/spineboy-jump.json new file mode 100644 index 000000000..4ec271f64 --- /dev/null +++ b/spine-libgdx/test/spineboy-jump.json @@ -0,0 +1,410 @@ +{ +"bones": { + "hip": { + "rotate": [ + { "time": 0, "angle": 0, "curve": "stepped" }, + { "time": 0.9333, "angle": 0, "curve": "stepped" }, + { "time": 1.3666, "angle": 0 } + ], + "translate": [ + { "time": 0, "x": -11.57, "y": -3 }, + { "time": 0.2333, "x": -16.2, "y": -19.43 }, + { + "time": 0.3333, + "x": 7.66, + "y": -8.48, + "curve": [ 0.057, 0.06, 0.712, 1 ] + }, + { "time": 0.3666, "x": 15.38, "y": 5.01 }, + { "time": 0.4666, "x": -7.84, "y": 57.22 }, + { + "time": 0.6, + "x": -10.81, + "y": 96.34, + "curve": [ 0.241, 0, 1, 1 ] + }, + { "time": 0.7333, "x": -7.01, "y": 54.7 }, + { "time": 0.8, "x": -10.58, "y": 32.2 }, + { "time": 0.9333, "x": -31.99, "y": 0.45 }, + { "time": 1.0666, "x": -12.48, "y": -29.47 }, + { "time": 1.3666, "x": -11.57, "y": -3 } + ], + "scale": [ + { "time": 0, "x": 1, "y": 1, "curve": "stepped" }, + { "time": 0.9333, "x": 1, "y": 1, "curve": "stepped" }, + { "time": 1.3666, "x": 1, "y": 1 } + ] + }, + "left upper leg": { + "rotate": [ + { "time": 0, "angle": 17.13 }, + { "time": 0.2333, "angle": 44.35 }, + { "time": 0.3333, "angle": 16.46 }, + { "time": 0.4, "angle": -9.88 }, + { "time": 0.4666, "angle": -11.42 }, + { "time": 0.5666, "angle": 23.46 }, + { "time": 0.7666, "angle": 71.82 }, + { "time": 0.9333, "angle": 65.53 }, + { "time": 1.0666, "angle": 51.01 }, + { "time": 1.3666, "angle": 17.13 } + ], + "translate": [ + { "time": 0, "x": -3, "y": -2.25, "curve": "stepped" }, + { "time": 0.9333, "x": -3, "y": -2.25, "curve": "stepped" }, + { "time": 1.3666, "x": -3, "y": -2.25 } + ], + "scale": [ + { "time": 0, "x": 1, "y": 1, "curve": "stepped" }, + { "time": 0.9333, "x": 1, "y": 1, "curve": "stepped" }, + { "time": 1.3666, "x": 1, "y": 1 } + ] + }, + "left lower leg": { + "rotate": [ + { "time": 0, "angle": -16.25 }, + { "time": 0.2333, "angle": -52.21 }, + { "time": 0.4, "angle": 15.04 }, + { "time": 0.4666, "angle": -8.95 }, + { "time": 0.5666, "angle": -39.53 }, + { "time": 0.7666, "angle": -27.27 }, + { "time": 0.9333, "angle": -3.52 }, + { "time": 1.0666, "angle": -61.92 }, + { "time": 1.3666, "angle": -16.25 } + ], + "translate": [ + { "time": 0, "x": 0, "y": 0, "curve": "stepped" }, + { "time": 0.9333, "x": 0, "y": 0, "curve": "stepped" }, + { "time": 1.3666, "x": 0, "y": 0 } + ], + "scale": [ + { "time": 0, "x": 1, "y": 1, "curve": "stepped" }, + { "time": 0.9333, "x": 1, "y": 1, "curve": "stepped" }, + { "time": 1.3666, "x": 1, "y": 1 } + ] + }, + "left foot": { + "rotate": [ + { "time": 0, "angle": 0.33 }, + { "time": 0.2333, "angle": 6.2 }, + { "time": 0.3333, "angle": 14.73 }, + { "time": 0.4, "angle": -15.54 }, + { "time": 0.4333, "angle": -21.2 }, + { "time": 0.5666, "angle": -7.55 }, + { "time": 0.7666, "angle": -0.67 }, + { "time": 0.9333, "angle": -0.58 }, + { "time": 1.0666, "angle": 14.64 }, + { "time": 1.3666, "angle": 0.33 } + ], + "translate": [ + { "time": 0, "x": 0, "y": 0, "curve": "stepped" }, + { "time": 0.9333, "x": 0, "y": 0, "curve": "stepped" }, + { "time": 1.3666, "x": 0, "y": 0 } + ], + "scale": [ + { "time": 0, "x": 1, "y": 1, "curve": "stepped" }, + { "time": 0.9333, "x": 1, "y": 1, "curve": "stepped" }, + { "time": 1.3666, "x": 1, "y": 1 } + ] + }, + "right upper leg": { + "rotate": [ + { "time": 0, "angle": 25.97 }, + { "time": 0.2333, "angle": 46.43 }, + { "time": 0.3333, "angle": 22.61 }, + { "time": 0.4, "angle": 2.13 }, + { + "time": 0.4666, + "angle": 0.04, + "curve": [ 0, 0, 0.637, 0.98 ] + }, + { "time": 0.6, "angle": 65.55 }, + { "time": 0.7666, "angle": 64.93 }, + { "time": 0.9333, "angle": 41.08 }, + { "time": 1.0666, "angle": 66.25 }, + { "time": 1.3666, "angle": 25.97 } + ], + "translate": [ + { "time": 0, "x": 5.74, "y": 0.61 }, + { "time": 0.2333, "x": 4.79, "y": 1.79 }, + { "time": 0.3333, "x": 6.05, "y": -4.55 }, + { "time": 0.9333, "x": 4.79, "y": 1.79, "curve": "stepped" }, + { "time": 1.0666, "x": 4.79, "y": 1.79 }, + { "time": 1.3666, "x": 5.74, "y": 0.61 } + ], + "scale": [ + { "time": 0, "x": 1, "y": 1, "curve": "stepped" }, + { "time": 0.9333, "x": 1, "y": 1, "curve": "stepped" }, + { "time": 1.3666, "x": 1, "y": 1 } + ] + }, + "right lower leg": { + "rotate": [ + { "time": 0, "angle": -27.46 }, + { "time": 0.2333, "angle": -64.03 }, + { "time": 0.4, "angle": -48.36 }, + { "time": 0.5666, "angle": -76.86 }, + { "time": 0.7666, "angle": -26.89 }, + { "time": 0.9, "angle": -18.97 }, + { "time": 0.9333, "angle": -14.18 }, + { "time": 1.0666, "angle": -80.45 }, + { "time": 1.3666, "angle": -27.46 } + ], + "translate": [ + { "time": 0, "x": 0, "y": 0, "curve": "stepped" }, + { "time": 0.9333, "x": 0, "y": 0, "curve": "stepped" }, + { "time": 1.3666, "x": 0, "y": 0 } + ], + "scale": [ + { "time": 0, "x": 1, "y": 1, "curve": "stepped" }, + { "time": 0.9333, "x": 1, "y": 1, "curve": "stepped" }, + { "time": 1.3666, "x": 1, "y": 1 } + ] + }, + "right foot": { + "rotate": [ + { "time": 0, "angle": 1.08 }, + { "time": 0.2333, "angle": 16.02 }, + { "time": 0.3, "angle": 12.94 }, + { "time": 0.3333, "angle": 15.16 }, + { "time": 0.4, "angle": -14.7 }, + { "time": 0.4333, "angle": -12.85 }, + { "time": 0.4666, "angle": -19.18 }, + { "time": 0.5666, "angle": -15.82 }, + { "time": 0.6, "angle": -3.59 }, + { "time": 0.7666, "angle": -3.56 }, + { "time": 0.9333, "angle": 1.86 }, + { "time": 1.0666, "angle": 16.02 }, + { "time": 1.3666, "angle": 1.08 } + ], + "translate": [ + { "time": 0, "x": 0, "y": 0, "curve": "stepped" }, + { "time": 0.9333, "x": 0, "y": 0, "curve": "stepped" }, + { "time": 1.3666, "x": 0, "y": 0 } + ], + "scale": [ + { "time": 0, "x": 1, "y": 1, "curve": "stepped" }, + { "time": 0.9333, "x": 1, "y": 1, "curve": "stepped" }, + { "time": 1.3666, "x": 1, "y": 1 } + ] + }, + "torso": { + "rotate": [ + { "time": 0, "angle": -13.35 }, + { "time": 0.2333, "angle": -48.95 }, + { "time": 0.4333, "angle": -35.77 }, + { "time": 0.6, "angle": -4.59 }, + { "time": 0.7666, "angle": 14.61 }, + { "time": 0.9333, "angle": 15.74 }, + { "time": 1.0666, "angle": -32.44 }, + { "time": 1.3666, "angle": -13.35 } + ], + "translate": [ + { "time": 0, "x": -3.67, "y": 1.68, "curve": "stepped" }, + { "time": 0.9333, "x": -3.67, "y": 1.68, "curve": "stepped" }, + { "time": 1.3666, "x": -3.67, "y": 1.68 } + ], + "scale": [ + { "time": 0, "x": 1, "y": 1, "curve": "stepped" }, + { "time": 0.9333, "x": 1, "y": 1, "curve": "stepped" }, + { "time": 1.3666, "x": 1, "y": 1 } + ] + }, + "neck": { + "rotate": [ + { "time": 0, "angle": 12.78 }, + { "time": 0.2333, "angle": 16.46 }, + { "time": 0.4, "angle": 26.49 }, + { "time": 0.6, "angle": 15.51 }, + { "time": 0.7666, "angle": 1.34 }, + { "time": 0.9333, "angle": 2.35 }, + { "time": 1.0666, "angle": 6.08 }, + { "time": 1.3, "angle": 21.23 }, + { "time": 1.3666, "angle": 12.78 } + ], + "translate": [ + { "time": 0, "x": 0, "y": 0, "curve": "stepped" }, + { "time": 0.9333, "x": 0, "y": 0, "curve": "stepped" }, + { "time": 1.3666, "x": 0, "y": 0 } + ], + "scale": [ + { "time": 0, "x": 1, "y": 1, "curve": "stepped" }, + { "time": 0.9333, "x": 1, "y": 1, "curve": "stepped" }, + { "time": 1.3666, "x": 1, "y": 1 } + ] + }, + "head": { + "rotate": [ + { "time": 0, "angle": 5.19 }, + { "time": 0.2333, "angle": 20.27 }, + { "time": 0.4, "angle": 15.27 }, + { "time": 0.6, "angle": -24.69 }, + { "time": 0.7666, "angle": -11.02 }, + { "time": 0.9333, "angle": -24.38 }, + { "time": 1.0666, "angle": 11.99 }, + { "time": 1.3, "angle": 4.86 }, + { "time": 1.3666, "angle": 5.19 } + ], + "translate": [ + { "time": 0, "x": 0, "y": 0, "curve": "stepped" }, + { "time": 0.9333, "x": 0, "y": 0, "curve": "stepped" }, + { "time": 1.3666, "x": 0, "y": 0 } + ], + "scale": [ + { "time": 0, "x": 1, "y": 1, "curve": "stepped" }, + { "time": 0.9333, "x": 1, "y": 1, "curve": "stepped" }, + { "time": 1.3666, "x": 1, "y": 1 } + ] + }, + "left shoulder": { + "rotate": [ + { + "time": 0, + "angle": 0.05, + "curve": [ 0, 0, 0.62, 1 ] + }, + { + "time": 0.2333, + "angle": 279.66, + "curve": [ 0.218, 0.67, 0.66, 0.99 ] + }, + { + "time": 0.5, + "angle": 62.27, + "curve": [ 0.462, 0, 0.764, 0.58 ] + }, + { "time": 0.9333, "angle": 28.91 }, + { "time": 1.0666, "angle": -8.62 }, + { "time": 1.1666, "angle": -18.43 }, + { "time": 1.3666, "angle": 0.05 } + ], + "translate": [ + { "time": 0, "x": -1.76, "y": 0.56, "curve": "stepped" }, + { "time": 0.9333, "x": -1.76, "y": 0.56, "curve": "stepped" }, + { "time": 1.3666, "x": -1.76, "y": 0.56 } + ], + "scale": [ + { "time": 0, "x": 1, "y": 1, "curve": "stepped" }, + { "time": 0.9333, "x": 1, "y": 1, "curve": "stepped" }, + { "time": 1.3666, "x": 1, "y": 1 } + ] + }, + "left hand": { + "rotate": [ + { "time": 0, "angle": 11.58, "curve": "stepped" }, + { "time": 0.9333, "angle": 11.58, "curve": "stepped" }, + { "time": 1.3666, "angle": 11.58 } + ], + "translate": [ + { "time": 0, "x": 0, "y": 0, "curve": "stepped" }, + { "time": 0.9333, "x": 0, "y": 0, "curve": "stepped" }, + { "time": 1.3666, "x": 0, "y": 0 } + ], + "scale": [ + { "time": 0, "x": 1, "y": 1, "curve": "stepped" }, + { "time": 0.9333, "x": 1, "y": 1, "curve": "stepped" }, + { "time": 1.3666, "x": 1, "y": 1 } + ] + }, + "left arm": { + "rotate": [ + { "time": 0, "angle": 0.51 }, + { "time": 0.4333, "angle": 12.82 }, + { "time": 0.6, "angle": 47.55 }, + { "time": 0.9333, "angle": 12.82 }, + { "time": 1.1666, "angle": -6.5 }, + { "time": 1.3666, "angle": 0.51 } + ], + "translate": [ + { "time": 0, "x": 0, "y": 0, "curve": "stepped" }, + { "time": 0.9333, "x": 0, "y": 0, "curve": "stepped" }, + { "time": 1.3666, "x": 0, "y": 0 } + ], + "scale": [ + { "time": 0, "x": 1, "y": 1, "curve": "stepped" }, + { "time": 0.9333, "x": 1, "y": 1, "curve": "stepped" }, + { "time": 1.3666, "x": 1, "y": 1 } + ] + }, + "right shoulder": { + "rotate": [ + { + "time": 0, + "angle": 43.82, + "curve": [ 0, 0, 0.62, 1 ] + }, + { + "time": 0.2333, + "angle": -8.74, + "curve": [ 0.304, 0.58, 0.709, 0.97 ] + }, + { + "time": 0.5333, + "angle": -208.02, + "curve": [ 0.462, 0, 0.764, 0.58 ] + }, + { "time": 0.9333, "angle": -246.72 }, + { "time": 1.0666, "angle": -307.13 }, + { "time": 1.1666, "angle": 37.15 }, + { "time": 1.3666, "angle": 43.82 } + ], + "translate": [ + { "time": 0, "x": -7.84, "y": 7.19, "curve": "stepped" }, + { "time": 0.9333, "x": -7.84, "y": 7.19, "curve": "stepped" }, + { "time": 1.3666, "x": -7.84, "y": 7.19 } + ], + "scale": [ + { "time": 0, "x": 1, "y": 1, "curve": "stepped" }, + { "time": 0.9333, "x": 1, "y": 1, "curve": "stepped" }, + { "time": 1.3666, "x": 1, "y": 1 } + ] + }, + "right arm": { + "rotate": [ + { "time": 0, "angle": -4.02 }, + { "time": 0.6, "angle": 17.5 }, + { "time": 0.9333, "angle": -4.02 }, + { "time": 1.1666, "angle": -16.72 }, + { "time": 1.3666, "angle": -4.02 } + ], + "translate": [ + { "time": 0, "x": 0, "y": 0, "curve": "stepped" }, + { "time": 0.9333, "x": 0, "y": 0, "curve": "stepped" }, + { "time": 1.3666, "x": 0, "y": 0 } + ], + "scale": [ + { "time": 0, "x": 1, "y": 1, "curve": "stepped" }, + { "time": 0.9333, "x": 1, "y": 1, "curve": "stepped" }, + { "time": 1.3666, "x": 1, "y": 1 } + ] + }, + "right hand": { + "rotate": [ + { "time": 0, "angle": 22.92, "curve": "stepped" }, + { "time": 0.9333, "angle": 22.92, "curve": "stepped" }, + { "time": 1.3666, "angle": 22.92 } + ], + "translate": [ + { "time": 0, "x": 0, "y": 0, "curve": "stepped" }, + { "time": 0.9333, "x": 0, "y": 0, "curve": "stepped" }, + { "time": 1.3666, "x": 0, "y": 0 } + ], + "scale": [ + { "time": 0, "x": 1, "y": 1, "curve": "stepped" }, + { "time": 0.9333, "x": 1, "y": 1, "curve": "stepped" }, + { "time": 1.3666, "x": 1, "y": 1 } + ] + }, + "root": { + "rotate": [ + { "time": 0, "angle": 0 }, + { "time": 0.4333, "angle": -14.52 }, + { "time": 0.8, "angle": 9.86 }, + { "time": 1.3666, "angle": 0 } + ], + "scale": [ + { "time": 0, "x": 1, "y": 1, "curve": "stepped" }, + { "time": 1.3666, "x": 1, "y": 1 } + ] + } +} +} \ No newline at end of file diff --git a/spine-libgdx/test/spineboy-skeleton.json b/spine-libgdx/test/spineboy-skeleton.json new file mode 100644 index 000000000..a51a9feeb --- /dev/null +++ b/spine-libgdx/test/spineboy-skeleton.json @@ -0,0 +1,101 @@ +{ +"bones": [ + { "name": "root", "length": 0 }, + { "name": "hip", "parent": "root", "length": 0, "x": 0.64, "y": 114.41 }, + { "name": "left upper leg", "parent": "hip", "length": 50.39, "x": 14.45, "y": 2.81, "rotation": -89.09 }, + { "name": "left lower leg", "parent": "left upper leg", "length": 56.45, "x": 51.78, "y": 3.46, "rotation": -16.65 }, + { "name": "left foot", "parent": "left lower leg", "length": 46.5, "x": 64.02, "y": -8.67, "rotation": 102.43 }, + { "name": "right upper leg", "parent": "hip", "length": 45.76, "x": -18.27, "rotation": -101.13 }, + { "name": "right lower leg", "parent": "right upper leg", "length": 58.52, "x": 50.21, "y": 0.6, "rotation": -10.7 }, + { "name": "right foot", "parent": "right lower leg", "length": 45.45, "x": 64.88, "y": 0.04, "rotation": 110.3 }, + { "name": "torso", "parent": "hip", "length": 85.82, "x": -6.42, "y": 1.97, "rotation": 94.95 }, + { "name": "neck", "parent": "torso", "length": 18.38, "x": 83.64, "y": -1.78, "rotation": 0.9 }, + { "name": "head", "parent": "neck", "length": 68.28, "x": 19.09, "y": 6.97, "rotation": -8.94 }, + { "name": "right shoulder", "parent": "torso", "length": 49.95, "x": 81.9, "y": 6.79, "rotation": 130.6 }, + { "name": "right arm", "parent": "right shoulder", "length": 36.74, "x": 49.95, "y": -0.12, "rotation": 40.12 }, + { "name": "right hand", "parent": "right arm", "length": 15.32, "x": 36.9, "y": 0.34, "rotation": 2.35 }, + { "name": "left shoulder", "parent": "torso", "length": 44.19, "x": 78.96, "y": -15.75, "rotation": -156.96 }, + { "name": "left arm", "parent": "left shoulder", "length": 35.62, "x": 44.19, "y": -0.01, "rotation": 28.16 }, + { "name": "left hand", "parent": "left arm", "length": 11.52, "x": 35.62, "y": 0.07, "rotation": 2.7 }, + { "name": "pelvis", "parent": "hip", "length": 0, "x": 1.41, "y": -6.57 } +], +"slots": [ + { "name": "template", "bone": "root", "color": "ff898c86" }, + { "name": "left shoulder", "bone": "left shoulder", "attachment": "left-shoulder" }, + { "name": "left arm", "bone": "left arm", "attachment": "left-arm" }, + { "name": "left hand", "bone": "left hand", "attachment": "left-hand" }, + { "name": "left foot", "bone": "left foot", "attachment": "left-foot" }, + { "name": "left lower leg", "bone": "left lower leg", "attachment": "left-lower-leg" }, + { "name": "left upper leg", "bone": "left upper leg", "attachment": "left-upper-leg" }, + { "name": "pelvis", "bone": "pelvis", "attachment": "pelvis" }, + { "name": "right foot", "bone": "right foot", "attachment": "right-foot" }, + { "name": "right lower leg", "bone": "right lower leg", "attachment": "right-lower-leg" }, + { "name": "right upper leg", "bone": "right upper leg", "attachment": "right-upper-leg" }, + { "name": "torso", "bone": "torso", "attachment": "torso" }, + { "name": "neck", "bone": "neck", "attachment": "neck" }, + { "name": "head", "bone": "head", "attachment": "head" }, + { "name": "eyes", "bone": "head", "attachment": "eyes" }, + { "name": "right shoulder", "bone": "right shoulder", "attachment": "right-shoulder" }, + { "name": "right arm", "bone": "right arm", "attachment": "right-arm" }, + { "name": "right hand", "bone": "right hand", "attachment": "right-hand" } +], +"skins": { + "default": { + "template": { + "spineboy": { "y": 167.82, "width": 145, "height": 341 } + }, + "left shoulder": { + "left-shoulder": { "x": 23.74, "y": 0.11, "rotation": 62.01, "width": 34, "height": 53 } + }, + "left arm": { + "left-arm": { "x": 15.11, "y": -0.44, "rotation": 33.84, "width": 35, "height": 29 } + }, + "left hand": { + "left-hand": { "x": 0.75, "y": 1.86, "rotation": 31.14, "width": 35, "height": 38 } + }, + "left foot": { + "left-foot": { "x": 24.35, "y": 8.88, "rotation": 3.32, "width": 65, "height": 30 } + }, + "left lower leg": { + "left-lower-leg": { "x": 24.55, "y": -1.92, "rotation": 105.75, "width": 49, "height": 64 } + }, + "left upper leg": { + "left-upper-leg": { "x": 26.12, "y": -1.85, "rotation": 89.09, "width": 33, "height": 67 } + }, + "pelvis": { + "pelvis": { "x": -4.83, "y": 10.62, "width": 63, "height": 47 } + }, + "right foot": { + "right-foot": { "x": 19.02, "y": 8.47, "rotation": 1.52, "width": 67, "height": 30 } + }, + "right lower leg": { + "right-lower-leg": { "x": 23.28, "y": -2.59, "rotation": 111.83, "width": 51, "height": 64 } + }, + "right upper leg": { + "right-upper-leg": { "x": 23.03, "y": 0.25, "rotation": 101.13, "width": 44, "height": 70 } + }, + "torso": { + "torso": { "x": 44.57, "y": -7.08, "rotation": -94.95, "width": 68, "height": 92 } + }, + "neck": { + "neck": { "x": 9.42, "y": -3.66, "rotation": -100.15, "width": 34, "height": 28 } + }, + "head": { + "head": { "x": 53.94, "y": -5.75, "rotation": -86.9, "width": 121, "height": 132 } + }, + "eyes": { + "eyes": { "x": 28.94, "y": -32.92, "rotation": -86.9, "width": 34, "height": 27 }, + "eyes-closed": { "x": 28.77, "y": -32.86, "rotation": -86.9, "width": 34, "height": 27 } + }, + "right shoulder": { + "right-shoulder": { "x": 25.86, "y": 0.03, "rotation": 134.44, "width": 52, "height": 51 } + }, + "right arm": { + "right-arm": { "x": 18.34, "y": -2.64, "rotation": 94.32, "width": 21, "height": 45 } + }, + "right hand": { + "right-hand": { "x": 6.82, "y": 1.25, "rotation": 91.96, "width": 32, "height": 32 } + } + } +} +} \ No newline at end of file diff --git a/spine-libgdx/test/spineboy-walk.anim b/spine-libgdx/test/spineboy-walk.anim new file mode 100644 index 0000000000000000000000000000000000000000..077f20f5a45b50cfed86eecb92096dfb88bc82e8 GIT binary patch literal 1752 zcmZWpZA@EL7`{C%Tmx-{Wm|?hS=JO-{e3o|rNfc=T`f^($&dq*Kp6IH{>RJop}m{EP+GJ0+BO~b9*623~r4o zu#kI;ya6l#$^ej-`h)wVr6v>V&{s9jBXsPUBO|CI7SS3c zfD0U(w11B;xYu9jX(A>InsTa$5w+u~(y*dr zQ>F+*&B7oSsNzKJI_tu~6R%XEsZeI3Yt;p5he$;bzHlSNei6NgME?0H#^TRUNx_Bd z-e;#BCnby2wk*k{rfHW+lHlQFf~b+1AIpX&H`A(x+i2Tx5T~j-09_@kJ_lSDW zv7|b7ZYRzEZkm2_u@6V`lC77}!phgm1~0FM|2?$z>Ium$^9)&-r|VjLrJMD$xbLWC~wGplQE={5pL?!|OF4jZ3!bBPXM1f}xEq6GckuE@C% zi?#W%062^+4ire=AQH9B$!sGh)kJw1(uHySv=frWH19u?kSNnHL6VrcVLgGPue)zL zk&Sxg2L;)Ptkli(j}t2ax82!})MD%MuS;Z?y95FC*EbwRZn2k-!X+rY9$fhmp*bVF z)zaA3B?AN-K(Y85Lc~M_OMJv6iWh=6gZu`+qRV2z|A_YE*`nJQA2YCoEh4B{DU4fc zXY|`PkO4D*X_sc4MBNR8;c5BMNE6&dkd-+YD#yk799X1Ch!1H2&(6lwrNX=i2vX6y z=G#ynw>WaP5YXSsFZ<9<hd-bjOl0O`Fa5PA(oYG@*ey{?K178C+l zuwz{zdH-|1%wPx!q=O6dJmXQ3&Uf8)*B<|~kHeeuZ#~vrH2Tx6 zrDjK)OQlD*7i*3;mzZK-*53g9<SbnyxUv0m5)8TqgZydxg_%F z_L7Wa+e-?_mXRGGJKVCpwv zWpn;8CW>ok_!SI=X)TGq7XrJWh@L4lsB4($?M^>c9MJ`E8jLlAoi?*E^7cnL) zIqHF^sHneRyG^dU?&DpB_Z;0;>cBug)?D%;0rx9141)bmc9d*y%l6_bA_||AyNVyY zb_E6y^i3r<(zTRp$@f+5wLEjdwP-FqdHT7Unb!#5Dt!>xjmb;T)q3>b1_|&zGCGcz z=w^*RzO&??*C5=t$FXg>cOKndT1=$+V^7cf>E~;)y(GCjTqgVXpZ)}7B*t2##zqw< zM1*`C6B2-^Kwm@!`5`*kAJMdpq`zb6IgtX=5@IkrIsVMd=q>9Qv)eldNi!vqK zLms~!_zZe2z%OPY-tO)D(UyP@FMHKew!t_?52^GvjZ9|Xppdz16w*k0r99DIDT~u6 zWJwNk=`4*>mO}4k*vqB!92D|w+Rm|8$Z|DuSqbe^&d==?Qf~*jT<&0Fb6>x1l;+}~ zZf*n}2rs81xcK*PD|z~}t@SrugL|iVzq!P;Ki7cNAcX;Sczx+?c$!-vTBAw7@;!cH z%=onUn7Z?TPu~4f!0&9~eqQi#vV*JAwvg?AnE;OOC>wu~8=-XwynkN_qV>G+U|UJR zHQ4|0_;!EwoBhteG?(JX=WDRFC>GAfmYD1Bo_VDv_9mpo#cX5g9vR?sPS*Dp_#Fwr z+ffY{g^eFue~wM1Qr%0yUQQscaZt*93Dh|b3h8Fr9whsP3KoDdqn|1B_^_# zJw7M)&c*U1;rj~yFkeq$o^}d2NhKC+eK|IbTyEtcmn|gFe?LGV@2MShwo^LyhV! z?Xm$q$4AM&c)A*2>?%e{s1w3es^^9d`0>#*Nanw%i|+@@+jo}!5&qt-{;rO2kx5!O zN!OEOv$M0igMh#FN&x;j0Vq%0D`V)%Sy7d0!C7Id(mk5B9R)PR_ltup;fj?u$ zjEAR8nKD~XPw!RQf(QVUCr@73)BpFik;teYE(aHVq7pqz{>C#M_Y!h+@yD1Q#-vH1a% z`Q3Vc7Yz^lopDvmdL$q1WU`3_y3@Fv+0vxn>cae9c&$sTOyI% zV`XA8>AA&OJMcy$zTH30qYQk0?USc+@$srO9Bz!o zru^_T@&3-`=0-;Pe-iBfA9?xhB>Q1yWd#=(7dSXLz{JEvn5n6$Fd~I{7aan3bGvu8 zulu)0HW!jqr}MI_>JN~2SwB(SZaXd#D$x5aJ1cN}cMXm=m*A~c^RTrzS%d;7n+q_@ z!yZ9O9KL5O6e7t2S?Y+3+hF z`G$suBS`Ll#Nbz{RPgcffvcw`s(|Ow0h?6g_Ma!N# ztrF1Rt&7Vbi!fSr`B zUngQ_M9`RUU$5LSAI~4zGt}Pg{_O3*1yvc-YGnJvmlKg~CjuQd}{>cOcpC zOtN2TV=X*CgP(4w>$^I3C%N@(PkRLlGZK*)8UPz}3krE8NDp;KReBhf&X2*eoEWSv zOu$oR$-*|3&%{=;ZI#KwwpY$Xb5#m<~s6~@m$ zU6(~3J{^bY|K4qg!E5Eg*fqx;jnOL1@wP#L${hB#*6?(8Ms8{%R#p_W`8(S|C9%l3 zQo&EMK9ba#ko@fNy}Z1H$z(F|T4(TUt=lnpe~Ik%opil;%>MX+wBK9Yz4U)NAy&#cG*pJ%yhFJ$0>-*&M=pNIhObKs}A-@C`zezn@l zPG$>7wNebXX%zCy27Yl21>g<@uNu z7YTniSGcIv^jj1lf`fxx4vk#aZal0=ztLIwhdIinaFE%+LCPi}@JV22V+A#ZA1XQ) zduuaz%FGa;wm^{D5@Gh1h<3C@tdkWIT&ywM%N9BQGR!BN=PSiLKPd`=6sU=^$C5-R zEKhdEvUBDltTE9U6%lsG4Ul7|yDfZGR?x^Ka3k=%jkk~*xfFUP8?BCM(`!g3;pB_+AS z7I$F_3+JOgFB>&ES*V&f8x`3Z!pi4lpe!p5IVlN9jSfe0L?{x&LlGMih)91wx&}T7 z^mK=(lLnrSYz}lExFIsY7l9sba3w->QBo+Tmcvyg6Xqti^tW0;AsWeK7bk?$=VZi1 zqnf^dU0peLtXM$5WdRXD75!a?o%HwevV6Y2p9BZ%U(a@hWcei|`A>6(pFKST-`(9^ zkN``6j`eAu^Wy(5NWj12XGYlBIkV-3c;l;QD9n0c1x_+xpIg~3?{`(5fH_W|hL@8|2;N+ffJOzg+s#U;M( zD(TP8GV4X|GTFmDP1LYCU3cAIr;Qyu%518Bp5dhNU$ED;G@33vuuug|2CNDOi3~K# zcCz8mmsy&NO#ckM@omOa^a|;`cH3ghRb@Sl&Ckj1YO#4y4W1&9HW5gh2)O(` zOemRg5y(qTXeXG`JS;5AInNdl;WQTKV0lFW);CnpG1Li=Gl6YhRE-Vv8WR|Uzy0`Y zP(5!JLOh(91SYUuZtzc=Hf=s<`5D9-jYi0Q20a^le~CnLp7iHD09zLXaHQk44z!h} zur1Gw!fBG|E&JLf`w5EMITT>2-wy5)?Y2})4g_p^Ul0K)0nQgN=v$gggo)?7h$voI zD~O~$Txh}%uPnif3o{TbS0c&9v98Z2B$(nvKfVSNY}`2Td_hJ#Wjviuf?({x^ckJ*%o6E8U*!N$^@EhQolv*V-S z?x3Rc?TDlhf6R^!CGf>#F#+tU1(oN3%Rpz)ZfdL+pxsFC>44VJ_%)qv?6BqiH+Fok zHU2FAOeP*CgfK4`*qBU*yPaHsc3;!d^N6J**)Xy2|8{jO{5q4^%8EkFONvHg(LCg( z#DT(|Qnt$pe)9NL41NYVgPo1D{cNlPI049>|02@Avnuc)a=3-f%hINZZAEqret5oC z0RH&i1!#G?0Y|mq=OH|utmmQK<1Fi6T6->35HUXe&rxk2prymUEqfRKp%xA-!#4-& z@Shdg2&ZEXQ78t6SlyI1&O`*S@D$ttcV{8d!~KM0*P7S4a3RdsO8`8)voYXl%Ot>~ z2YiEbs6jFQr{n>O-4wQiR=P+^z|u%xuZ)P`6QjwKU^Z=v$g(pTs5wR^LeLO+H6&%3 z5QGt+b>?&tV**f9jBR6X0`uupMWWA0f5H)ysgrs<`^`aS@i1G6hx4a%Qj;ymt zA$w#7w(dE<$A9y-d0D+s1pN0-lI#rPP*#9M((%DQsLja~Am;DkeL9m(XX1HkVdXiJ zSXEhw(#)C2PKZQ(ZWeZvs>vX7)7V%vuw72@bG&bBYYT60Zz1<};Ai>o?CdOnZD?qC zN$~3kfQVuhZIx`k*3vw-x_Ezl`E)rx+g(91et}5pwQO$(@%!uZabjng@a*leJ(0xI z^&&@bd_NhHg{Y~Z_dnQJh$EYe#QyC=g+*fjmK_y>9KPIBfg?mH$*xWKdGv)?kgNbS)fn`JnCmF0JQ}qRK*=t*oLg1L4jS0fW%mlXPrd+pwp;?$g zVrDG<&zOsP^e3F5&)q`6_wJksx^(C@{YExYLif zEPsypo8MbdFjsiv1qIot$WBLDRw|LpYfa)5v8)Tw#w`RN`M zlD{MPyOaJsv^U98*aBqgK(_KAM|`|E0Vjw6PVA`?QlDe`lRL}t{)QqPT$?L~WEtpU z$d8kL3~n~|{IvaYZx#NtIv4xvXSMI!u~d)!#(?*jg{7T#ZlKoEh zTf0s8h2B3(+npv;CZ(7dOnkDx#}w$Q*_2M+KRG4>>G9F1&6|troNS7-bG31M2hUF6 zW2wEC0JVZ-HHQcc?8>Fd+GT1|$EB5O9H#ADwkVBe5?h*^2Co(c z;LyT2e6lHD)J!lDe6_C{FVrMs!ORd*^uyJXTujw@Xz;`yuJbR!zOqN6GMX~wF=K;Cqs=CdAItGPn~{N@zIaaW z59Am7IN1fK5%A-q!ZABB77Ggr)P?iOcBql3*{qh-H6! zOyAKqcQSr$_o_w_VlasJtXd=pW{WmdV9@e+HPx1h{du2RF`uX?;_jH1y)r!x}^|@ z7sQ}B(+3q{?l`zG0WG8wj&mg-5eAdM$Lr_eU`+&G&hy1wUzZOVpVtWBPecG-63NYh z9xg{Y53rCtIsJQ67p+FDGnB^~8JS^jdW!-d~oA4_3{_;T5y+{?Ziu zr!pLGl?LM3ydac@dE&*QARMfX#5)af!rrQhZvQ;m=e3exdl> z{|=U5VPWww+qqFSwS9D&yB%ID3&bJv(o6zu|0xf_do^L~v9UD48z0q&3vv(yQ4-Yt zyvScXf2T5(fFFW_5Dy$E2*x`V!Fa9E|D3&EN~BN~hL;M1kmcp{ZB1C%o!1E9&qe?$ z!&^yF9pR)L$H@$sp&$VE)?8S$tSqlv&n*am) z6kvU;A_PYoB2W?TiTofp@%&9DhtlA7(-H;S+qCaX#UUt*^u}{U00%2W{@909#9NgS zII=JX`$;8)E9KvA%T2j*2*BS)F(FW<@bk4*75GRLTfD3lFME>Fc4vT0SrVpH+C}wn zj{pC@3NW+vbF$OM%JoA+0vx0B7(G`SZoEjy!8w2x6$OY3^v2?n9Pu|F-=&U`-{)$; z^$q3mLvb<5N4%OmbFXMUo18 zay;=Gf%fgHa2%=&$D%|JB)VwuI)V9cZG=z;9l_7W3gGp!P!tkbJe?bY4{9kas0hWo zL?-Xo#o%4C4;!OemnFI)RH=OBGG^G#9-vrj`q&A2_FhVIj#YAPHuE_AvAVi^pw?y$-fJ{*qLCWB2Cjq&cabZe$fT#l0mCz0*0WjID z(GKx-C+l^`zzN2T=nyfAzy(7+`Fsu+)-{y74x!{%lh^-=yuT>q(UtXf2Y#0Rc6N4s z%KCS*7cX{P(GE^~Qk-RIh?ZkXf*sb+a>4ewZm5oQK!{R}#yAZt1pKEWj1)pRSp?p# zZnr~33@?@hAl1VG)ltrPr#2J^7sTO}%5Xee=!g9UKCNqKxg*v=j$~Ko&>_ER>16AX zJ!4>C@H^L26Z>M+mEdu8bXXE|*DgBu|DlT?x`TqX5W_Y_V3zo@G zN88EULZlJ|+gc$+E`z_V5}`61EKan?t{e~S$@RqEJa0T(;7u{VH}>Uwp&`}*KGsr% zDP&lhq`}sCURa&xMA)%IexM!VGgn z4|?=>pvD@t@lLI;R)(~Gw9Z#n&D1I}ZD?O6bdwUl-P+*A<@~nDaKxfM2#FtPO4vH zHTLg@D(#jlTW&a2|QuK)YPPHs=+ioI(j1h{lqvy3Uh+( z+x8a*w4PWR)%xX%=+^h^LeG#AX!~$s7+RJ_;A2t-`|<-&M&SYzfxD&r^h}L&(A7o) z&Qgg#7wE7T?TNP?)I0$lgD&Zp5*8pT33<4$JGDT^+`4mRqxlex?T;g`|7FMd`<=)4 zyYv3M9}f%m*ZY&bF%Z9HVM_QDIU#q}wmU z({scu9}mMsFRyzp%gsq1zJNVFgP%{Hu02x6R!JS7i#ll{hOrYTyFhzFi&M_Fi3Rn=VXvxiko+!F0hatzl+pyn?=S%GE>y4ibyG zp`OlIUS5FRs}`NBrW;D|b1lM#`U)&4&c%YF94!H4iF`m;;NR3(^-1&6g_DK|{Pvva zpXENwd_HmQp5C-alO@c|c*2Acg#`w9 zVE8zU7&i%S3JWYtb!$6Gir|}7F=t5;FcGvKtPN>9u`CjwEsugmW{w-~8;%Kj{Jm2W zt|k)jP|N3pcsPqHJeJ*DVK>kupey*faDOKEuWi(%K3AU77;AUkGFIx8WJVH zi)*Vp9Qt1d`CgpO_aIN^;g(&xwq3m;04@jai}&y7(7y)>|;x!8sF zH5~MnnMr2dO~60Gp1-r#@9oJGq(RRoPc^`U!^h*{k>lYgHN)x*_cm4o#}`MozEu_6 z`c8ESseuUWF9~T4a+bCYA3F&TJ~5hOwv|^C38Y7ds2ye2UuDLHi;6s+cRv^;(Ao1d z_#4Udm(R;YZT>uzWThiJAxcybb{;Z(dex#WL*#^Rq|kE*hn?b{varBpLlf9YmM zNT5w?y#hX$|MH|CE(aFVhY8r58{0z-o{vy5FAG&UbI@3lFM1a6WFICWo!4iTK=J<0 zq44|!d}kis<9OeIwxh?7$5j2vkeSTDq)B=(FfxU^o9iVLfb9Kw!cTAIzwVyZg}-zh zioX7q*I%!{{`mG1TLOGV%l4AD2*f7|;J@^-`}1#K?5TYJ%RLpFTecNvw`?mMJAgNy z(_abvhXxY--6;b7DN}LxV`E@xVu%Ap0j=M!iEVwiHbjI3@7IO2o?a7k_QMr3&)Qg9 zVEE|qEa4)qw&bA7%Cspt)c@Rk`)-s#kH~<%K8F=N!6%E<1y}3w)Zb<01*plJD?ER7 zZZbA@IO5iznkur2MKWBv*#a2z`yU|hoC=pJfc)etWR-4 zexMX%>Geqlh6HdoK?0r2efyLA)7__x0X~MYW5=fT<#&9#y>ue4lXz@f$&b3V9e6JP z&(GE2`~5ZTU4MG9c*rMPi^czcv$qOg@2v!0Uxc$S)#LY97QK(}UbpM_i6`K19_rSIhL7W8dgZ#S z@WH(q(jtRJg`Ft0xsU|fI&51nMF5E*zL*^wh7AjH zG^1`O{4n?(9Ua^6wI0fUZL^Pdhnm{)Rl@jYXoJ`;pG=z`L>U_EqCQYv#k!(j4X%ric%Ag`>(AHrD3I%}PRD zMyw-SU$gzO41V3JD1!z5&Ma$2&mS8-5s!_Uh^AQ{?IchWLPQX9_V|*hGky-%t&h@s z^gn00{nFJ&09-62Gc|lRH8SY;-K!RTt1HXxMg?3{2{aRsGh@RsCovieiu29^UuWE# zfC+$`wMP4S2-4vZiPbeF^M^3`Y{}kw#K=+j=RNme^60S$v6W$W-CX?m#!7s$CKCtC zg79H=5X!<7qz=cz(9{B6o}L#Z274?2b$KohJy`aS967S8FTa7}`iZQT6i!y~b7oCDGK>$n`^;zM#?z-#AZpC#s4#U{V z1~9d;J*8)0_<5v8HJPn1o`0fl9kf0q`&zZucOoz~!INW%1V&H5ra4|`Pp^$Vdvb9& zK52}Ajk%Ff2-^J@UX3b1rLw%&#&pJk?1aeApIN(9Owa9YVo=vJfUEoFCdFY90lmIp zetSa__Wopx$_kN{5Dh1(m6$W|(&ja-jfL6HL-|_`4GlMp9ybp6+&>HkW5yv;p~Sw% zJpA^-PJH#sTD0t{z@g>oqyj?laZL!)JSBK&_!vlRq!$bgvNBL86g?{b(cSm#0ND|a z7%`$x_ZmrhbC&gZtr0IR%Z5@W!2_cv;JRBLAkg04ZhyN+`~0tn4RXcVR~C{|xbzB5 zUp-xkH&)NboLC=Jq=#Vt!VF$arUf50|6S)S`qUqQfd2^-0JCHt37}tUKqvtsfyapi zMvk3`oh6ZN*gNmc{9tw4BO}IP8eNnQ$MxXVNCMoCL1Afnm^%uyC+FrKou>4jy;umq z`o05o}j1&}QrHlBViGUTslJX+avDwRB@my1Fae8@H+SsA~os%X{`QY&< zpM>Gq32liQd%U`)6u*DC6Q94Z5=XbUFQ0be>1rHaorS~Ip?Iy(2M$)#MFAR*^>>^I z#0r3?1z(B)boUl34=yhrK74plUyq-TZ{d#zYVpjX*|_EIM{(Uv_rXqW3pb4%0q*ul z3Ux&zIFQBUHm`iarchPxwSsLCc z3&e&rC(M|tk8%126!*KH%Li}{fEB>S;(uK}ib;ZT@c848+xPX@Ki*Y%4}tlIZz)!{ zwz3fQFE1{gL(+XQ{`*n`{`+Es2no)Tu|mM>jba&bUN1nj{OZj*joQUUj_+UcPQOk# zdH#p*L+S=6K!N&3pj??o~ z<3%fP?i{>x>@0JS31&y6`YFRnv!co2cx0?E-4q9ZXkCgt9Q=|lib1|D{DkjnTr z!pCRK<@#MlQ>RW)Og8+jG%^UMUS5M=4>ybU*`m2-r)9H_6A64upn0=47Oxd}p)^#E zG2C21_>Ia|N0E}gbTIP=m1 zkqA6a;6AylT&%Zva(DY0i`)i`S5*FzjMr=A1wTJ0>)ArEW$jCg?O*g!f4skquEe(^ zzZz8muEOAKcR3SD%63&ElF2qJt}D;e|XO?49e1cvnk2K?+i-of^z4fJXuN zp6zC#&vQe4B>NZi_1KSXEA|xDT)b1a)cfgYYw+zeRp(X%;@*Gk;XiK5#D~jf;=|?1 zII<=K2T8>|TN#C21p(Mw6of--=7>dDFBk%(P~l4=iSM6VAV}i#ouz_UT6UBl=<`W8 zFfdrd2@f4RG6`5(S_(oKJ$f`Ad+aeh`skx#`@|DZVBENIVn5zzuu0$&xrnlB@IU{d zR4Q+>vo@QkvNW}3Q%g*hQgb7JM_cP0F9+3+4mK7@i3}mohlnu1-A?{HdHnaCW!80( z{$7(W=dnj96w^a&rDwKRX5qIFn(^%$>v42vmA1EjQMb!xAKz7h51QuUrNRJgOx2)i zracrEGcaN5jB_f0>jU_H?VJbDfu9}Rs8ORnq{HZQ7wco&i$mJ2LYMyVHA#RoL|;g@ZUz@|CNV4_+&6kvWMp+$iojmj0YZgKx}pP&_fU5{`>D2 zWWXnliz_ZyzJTm!?*D%c_C0$fhWJk>0;qIR*sLMYm$@jV(qK2u$nfy+%Ra0csZ>51 zDwlu1yJ0?l|7a(^B! z%5$Rve6Q*Vpkt8_-^XLej{TAD>wYa^&LzE~tap3K{tLlhiKCnI@m573p3im1n-xKL zt11Mq^OEYhURarIk0tRcG{!2iAV!I*U@JUZ6^m2P)Sep}#xEv&)8>t|Rz6R|- zKLNOyT5MfcG7D{=?7`>HFC)oc-1TzWU4;PTB|l!1g}vDxSdpm0hEz2c#5u#%a0aGK zHxyw2=K**k5EFn-Rr0;d;2%GJ{8_r!_4@l8TDF&{*^X^1S$AHXzN1Vm0&;j^G+rZb zzcmO`lvQ8)O|MA*P9IOn$sa5evb1@RY?P%j3xmUCe_7nJ_;^=M;nLYY&)sw5b$D>Zcsw|A66}n|eBA4U%)0e?qh(%`UxNu;+0L_Fp{-NX#zj4dHInE{E3A%+`U<56Q9jHlO_7&`9H z7mnwH`}+EdEnP%0ZcD$xbtrFKCV-1A1Agt%vqzYn-Oim03vl+M9S{>`wiNUj{9FUT z;Qw@CIM$?iAyTb@^)zGLPfqDy_uYqK6sC?EHA>t!oDAfV0G)#5dxjj?pf#J(&I35y zKCWMeLyO|@-I_R5hT5D5dd5#mN{XlkbTb-`@7E>ay;^Py?oVOOETJBBzxlV<8b@^a ziZ{8(hM}oBG6R&oCjbJzijBuT*^{#O=eWMN;AdmvU?sqx)tiw4_VNY<{*eUuBJ&aW z!s=!mvb+OpEFMCR`A9gJPQxf;D?DK=!D!m*8JS^{u{q2fJs|ZAfYQSk=C(3SoTP`T zQ>Oe(7k0>+igKwXowt7x30$>GAkf3%ftu`D#sT*7UR4SPE0s5~d7D{=tjbRZjy;1D zPuG+5&+obHCp)w>1)nSk$EMi$ql4twpfW5=G8^L;U`a%d$Gp6N{} z@F;;h)odJK{a5_g`Ud=D{SSKnH(@8NZoyWI`!Uaa6nsr5!_;s(9Br+T?XCc~TMl=1 zfV;OZCfg`6Y9grsqZ#=_2>`W?xp#z@%ZmKufD`aEvj~h4c z*uD4Od-GtQpO2a={!ZXO!36N(l6ZW*G8SGIH~e(t4Sz>om@6rOUiM@l;5)GCx~#BN>JI_% z$tDGHmZa60o~nScB=P-C^>La&|C80E58Bk+?G(t*FDW8%a%dww43W+PRg7^?Gi zyt!;I7ycY-jK%kB6Oim^cpd@Vdh4y2LKx)dfszUMc5NaK68Jw@nbz+8MOkoZU00tS zZp+HA38-kev`IdKNYo&J#7NeO#dWZ;d^;gD02zs~ zNR5xe?4&r9&6|ye!W=9r&aGTgQSql<{)}fHsw_>G+FP6dH_X!+c`0#NTs&V)Ddx2d zc@dKro?1;rkOF%fi;sId4b{U;q9_RW#i_lOIJv890$|VoDTN2TT-M9EK4Q|(o29`> zb#;Qq+_r7RsF7{=(S0k5)U?CWx)Cbg^6PwGveKn{^DACYU?|Ta#qM#Oto(3QI!-N% z!m1RfZV6z^94~yaB96R&`nlNu=++YZK{+r2z7-pv7#;y&mh2A!=*omSnb;Eo;Gw>e zL;&UHPvUnX0QT}7!Twn{1n`C89(?WeXgdjL?MpJa+=qS2C-I0rCwUC52m8YEDn>4H z$;r5|KrxYKW=sU~XQyIeac=uUnvJ?Cx@F}}B_%ihnSk#hl|Eo+Wl~ANM|^+BBLp5Q@3vhwAMEQ}0;fy!OPMU-%lP3$AKXT+qk@RE0>#9~cvCa3U zmH;*k^|?H;y?8he1M=@Vv@jZ{R>mVjHSGfMhsdYm)QVUfS`bBEzgP?%9&0X{GiV1! zOsL1kCx+_)7`zv&{Oiu^)3%LIu+Df`uBUCodFao_bTYoSz6HNp|3f7GbYSOvz=`t+ zfC$3!W_(HV|3U(Im_mVn;TdN=j5f8wL_NK?hJXNuxhieGj}Iqr6c>$5^8VaVqp>7U zOuyZDe#hPaZm6$_{WE}HV`C9%XJvMpJwDGaY+l}QZq353`U@}t*&O*0t~AGIn-od`~kWa1xMTr+eM_a-35F@)GvwpKK|_Crjh;)yg>3MXMm2Hkyb` zAL}z*@#XSpd{7&VkDBJ_ynp$i9u%F7N454N$49*-00Ms-ZGR`WZDk_RWn6hQq4SjD zi-iG90<(-q;3u1#0qKqSl7N1k0Dp`K-~tk`ya`{b{(T++a0u{=ND>~OfzQ9?VqJ%r0CJLJ;i9xXl@;rI2U~BxcczP@I>A|k*O$*l>l=;u zdS8{u2k>;+!z(lJYN0<4R)ym8rO{$F-B67^{1x`+okOn4pnG@}nUqLi32obSF+XpK zAbzF$+~;zgTaMw6Z7camkigbre6%73-!&!U$Bn7@c~b_yS(_w0|3~ZQw$B-8E?YF{ z2Q_~D_?y`%4ER*^UL(frX%P^EoxFW3{eLSb51Bl4@9}7YZt;+w)B(&ex5N|U_2Blz zop|2tPMlTTh97NiZuj_|LjZFk0Oh@Z5P-vj_|=8I{~c(un*YN1BN&2q9uNzv?&8A{w*~RZM8R+V*d)oZN$k+sr(szxz z=MKb=y9cjX-HkKy+W`43_^|sey>OHo$4NJkv<`2 zdnsK#MN>##_nlP08D2Afu+E#at>unTFIS|H{GXeeBwA{%s3`1KDtB!aYcBUqX>Vg` zt1vghocIXrT)9w4{&l_RF}QR20?bQ_fvckL1Rz2xTX{f`OnxBI#qm^Wv_Cc!B;u*u z7%YhKK!T$kTr6bpwN;#oa&UOy&zx92wyiYk*!I#hoZLLVyHX@Md6a+%;54a(p;sxS z0G6-<=!yWkEBN8Kib2ms3=Cl2vgBtK!C?fCEbwbRDhA?NecWlt(h~aP$Kn2a?!mNS zcOql-ZD^W&GoG7qGY*>Hh7TnFM2l(|zI1*JpV&W&=j4x}YQ`|QJb5=vZRAjU`NPe{ zS+s%Tc>){{5(#7uid=TExldzj`F(VdA5!C^QJ_u!t+$emC< zbUUmbz6;~-y#tRw_yA0-Y@l)XgoCRGG%jv%)pmi^PHy^vLV*EUNeCTQzfnspl%5nT zCq;#l{EtQ1+)OMjFA&RW^>LZ5Gi2$D7cc(Dkb&RE(wJmF3eyts^qM7YoBFT_DUWtM zvwk_s=FNh$O!8e$RMg#U*9hRxMF62p01Vno5dgo>LoK3vZzqYbYbL@u0agM%9SOL= z=rc^MtVtDEv`^V2vY9w`G{!#uD8@YY2&PUL4@*-MNUbd3sL?>-6AUXiU)Vdlz}CeR zax!lZcTxMTZE+qy0H^6M9SOieYMC71;(!c_{qr-^P?tXstE)>cmi+6f{j$EHym)hC z{-Bl?JIEv^1pYI*GuiVm!lpj1K)kl57zZ}3L1k{1=p&ew5d1H;D+Opx6*+e=Eza|7 z$jh2jM^>Agl{GsiBp@p)@J|s&IN8|zQ)OvptFScjP?(#z+gqEP4*1*?0!b=oN_8E8 zF6RB&yI*X=4-J@8VHE!tWo6LKpDotY>tXV*r*>-ng0k_0 za#P79)^=8ALiY1wADbF`2L7&o+uE8EJhyo*DWF-rhQK$e5fOK>T_b=$5djz&7>p-t zV_DB}e|NnAm>h-=AAT-zcdWWYRJS%Q_ zS%LS8ih@0Bs*8W)<7S1!zm<)bRa;+QL5i(-e`E1n)s+T%p37oyW8vp2v)vWw>hN`9 zurJahgOM5@hzM`j@13O9dlhCTF?Ldmfos{$Ex}m@bT<^J^Zr~=(Uas}zdV1ZI)N!B z=7=$!h}SLuB_;>)NWk}&f5)$;*Ws-7_4vi{0i1GtSkwdjthpcGX&yj`vmF#3eqwTakRDi-Cb$> zbW=^~7G6W3Kg*4?{NG5x`p^DdD4#c*2*C2YREqyo`Rx=~@|dU#_*U~Ees}mc$~DH2xcb1=-CcYRg#lj;m;#VX^j(!U zD4Lyu`l4Jh{MV#iGJBxG-+t2yVmb8G;?g_%ddyO(^zU?Iy(c#lGtsWwy0muc7P^_V zq}A)?#X0%MH|L&pEAaM#Jt&=%&eOCns{+WG8C$VI3+^6-Vq*P7K?XzwO?9Pj)z{Zw ze>uVLAhF2e>dOWB*Z-8zkY4U$6qptdquKM)GQNk;%(B?6fg zSpN5*P4|Erw+K_3Oh=2=tvD;W;ezSHTpE0Ws{`%s$JZ{8;~S?(0J}S}OsxkiA^;CB zFVM{|!T<_OtOg|hx3zHc(I`>P3u@-gLt{zqpn3ld=S%P9eLZIK`U^BR7F@3%z<)QE zWT;h*?K{UH1tDFkr!gomdGNFs^S;2AS!EE|}MWtJK2?kLvL zZhY4xt>Lqw~ z>w4_p+|*70S!r;zvHUJGG4vh)mOyF0wxI&f)+Kd*43r*veH{V(-ks{9&+r{;@T;th zSIrFd7Yn_z)W1Ync5dZo-jA1S=ikluqrJq!qQ7Cl3a*`IPv0>N(2e~MwfsL8hIBsO}ZZMo85x1c=C|+7Mzvcf>!yhVh+I>$=~s!;xYI*JBndJE(+p$0A3P` z6P$GXpAX0dvou{78|aNj@}8CR=U~Mk#{U;42V0D*tsrnT6|1n|rb6wR7BYxiA5+3aBrb*Q4Xtd8O?u7K*r^J^!;?)(H||0uVU>snz#G zl>`j&bn#wHp%=^kPTsM#e+kzzY^<*~8tmiukV2*Zz%m5dnP01wkDNfO7&|_dnF$|2*TOB6CYjpEw@lAGjBz?!FBp|8*;d-~JB_ zzvXXu{Pr91$iMG_9)&3m8qIl2L-TWqM1m(qj7G4Vs-V9YPi<}betL8m7M2tYs{G&3 z&CuJrhO)Vryup+b1Tv4T|+Vb#)itC$Nx3O zc&f2lfPX)c022UL0uB`c#0B`oH5BKIRg624SHB2=0mxo>X=!feU><+4zW((NwwA9H zrYH5P4&!3S%@eXJ=A^+_qk5~q1W?BDvM%f2vH0h*5`eZ;*u+XA3WN*|reZpq-b5IT zAA@On6JShU-q5(cBw6SAU9@Gv90uI?$Z+Jw`+U^v_Q@UNX|?1*@~WrjB*tKIS>Zrc z|8-3OU3~6__PGXcU#d>QS!(sQyGq7QN`B=fz-PuriY35#C1CdcOafIo*{GlpW>r;j z?|uW_aH}f|v31!39N;7%6TsYAgI))qv@smxqfzf-(rPHmZ4bQ$@Z59ajfdH0$A*2J zl{I*so>kUn3$x-PMRS$DR$z9vtxIZoI1^l*+K@MIMt?>FCi7fsT|I!Vof4Pi4)$um zy;1`fmhEO~El9zbx7y?5vSw9>Rbh3@Lyy;+0xL7))BE;i{jKi=U}Nkom!N=R-X-Nl zA}O|UFyudfW*48kX<;RnR}`WqC)>39q@Og1rGI3A&zqU#@ly!=YzdKJ$WBQVAwUh0 z02eSVD9j-cRrET9X-@`LV&7A1@Yb`tP|gHkYdIj3fx06#jjhGI`5DP*EGlhR}>-0%?VZW zGm`pskOZJNba?<>L&c#U{_DwNB8H-=X#1K0x`jmex!w$8SX!8$rvjJ^EG(@sV$|5S z`s@gUzMdNowbao~B}ECv(o0DGud6Q`viP4bG%JpB0&Zhj{_1YQBC|Z;yfLy?|lDueNfyCj!t~E-4x)2{m(7V`Dt zo((*VyRaxnOhV(CsC-_c{k)Kq6rHI3%DyRGQUI%Y$dAF#@jp)!X77Kc5CDUJs)?Bx z9t<~~gk=_wV5P;wSZMwjQq9ImPs;w zo$N&Hyo?yPJx(8d@H6AH{IAhU_r}r!_&M9r;!0vmfsGdl04+4&qRQ;Jt@2-!-4({-VVxlSzRnD&2L>>TgDZh zy}EZq6(jv-K5iz$^0}Ep#j&-wqRU5Oh(BBvlKo+xP9yq!phN)a9P{he{o^H+t{C~x z5}(%)G`2vg`IBP30B$MXzL3aY#rB}pKM`Uy4wKAnM0X%v2*5o8MvtEawXMbTeXiEB zv0NYK?MCcdC}PkJ_2olC04)7k_Lj|^EpiXJX-RNZ+9KG^5zY#mAU0Q-#DL93ZvAsY zc<}LA$?7G~+du**$XR1UfIZ!+suFRNa_r6% zkT{O?)2QDsPEUU@I5_xvHdm?DBsM3h)ej-wt}i7-gq%){2>G7Ce|lz2WNR{!024?Z z699)1Jb|en^$Sb@EStFys4^!DYKi&h6szCDHju#aQcLIX?_ETyM*x*bptq`Jqjp4v zTeflU2Cm{LfOU1HBIC{=<#>-P_n76&3B)c6Tf_x;WptSXu(f9;t^mqe0Z1%PvDX}E&*`p`z8)Ls zBLK?8#pj|o@}I8{6UIWJpfcMSI0XDw@}g}-CPa#vty#(Ot(+juo*Ccf>!?Dwr}Kag z1!g5gj&zn=w{iUlUqd>UHuC6aHuP}VlCRUU^1{~AxwFsEv7gZrz*$lftz6B?E$O*2 zZ6uv1I{sf1A_5-n*8x))ut?YAucv+fhjM;^lc@pTCaK?Mdn4Mo8j$Qa+neztsR9lO zzN4*&=@g8dZUTiuA-umB4z#z!{f~`AVWNMp>j6B}3VW8_#hK|8GZtYL5x`)1eI}Mo zi)yfSX}$1XODIld*~haFlfnW)H`Cd-5!t-dg~jYzC@Q)AUxy0&Ks+-K=H&T4D@+qxsiyE(ut{1Rxps8~~}DxkM}|$VhIb7`;tQy(SP4 zXnxlMrnNiJbOz7jlDxAF90~)(EWpj$3OagSoF68D*bsks69L5fdq@Y80HXapvzV02 zwINu2!94A3#LBisC3&q(2z-pBR$4DIPoa%SL+rP>G+(F~{yn0oi_S~l>@=j(wf1vT z{}R~W#;FDd1_>50QP+o9^Otpgc!M*^%G zT31(>w2H|?+Uv&Tz|*3+L^_p7AUPrkJ{lr`K(A2)NdOd5)VZr=LVYcuP=v1qmtk`! zDefv&mp@m8Dm};vw9-A-O25BtRaJ3YgP4#u=bSp6mmCW(d&SS*PKx{cTM?MVCBaMr zm$w4&B1AwWU}9v9>0?G<%3}{eZ|rF3QFt)j^!#vzRe)SBKSu!8Hnx~BaT1m#yY%WJ zJJ?!mj`H)wippYEkSjs#Fe1faAqKEh?LYy$zBlDN1V-BdQm!@b=E`L%nxIb#0B zT2YA947Z=7>WHtiJ<EGp4VG~nKBG9YNX292MiYO8qL-OCa0|{_*QZ|it zl902D3mzY*k9arR9yfq+Q%XkC&3Gm!B>~Gw0f;IrB7l_x90rKeQ1WcgY+Qq<*RK$D z`YaU}5&?vGIK#tEcBH36m@)odMa~L|NNn-KCGGY9oCnY*02>B?0G2k0Bp?%j!p!jS zKoUTVzefRuT`0~<7nyT0c0Vt(z5n6>PrqgW?O5K>79Zrz(`q*j=m zxoOEFB;%wV*L8@J-T}IQxIqXn*Y2W_eCMW8-P>;h;NAdND)>#b%|gc;TO!SDtXN0z zwDmvmq1Ek(Hk%--1UrWT+!=@ofK|YxX~wX#HhHzjwdhi-FkUmSHjiSr!W>Zq#KUOZ zQAbw|I1ox;t&sn9V!l03z2!q#A8q1FgeUWw5P|M9v+}{mRln#$Pe>LJ?IF4 z*Dq|ZLK|2DkeSW+a3Di~0B8GWy)`P4xa7i_Dy{ct`9IJTu(%YM2(dNX%Y_I)Qaz9a zkP;qZ%f&@poykkcWyH59WOW5z1N9r20LqB~oaK^loutyc2Sfo}$ppaQcQBnM#{FBZ zugBL`H;E#kuV^bZHNr(9K=m;MlA6QCkFlDm-FIm2JJsPqi@4q?P&qEZW zFp$=1y*1aQ4`e?8237N_#iG^Ldb-K^M&W74p`NbrQp*mZ7xmrgVS&?l*fJ{6_dEg^ zs21iO37|T64iSK1i%O-sm94*^sSggmo?`J&gFReC?t_n=$Gcg14b&u{juUaXQ!s@U zZ2>O!aFt6E2a*6{1HCgHi2xEKLXbl8KPP>r2s!>(KECgDBAhVpOaM+Yt8d(t%KpvB zoHAuf;+0GQEb&JeTcf~yB!T{Ve6C$cw7m%EuVQ`xzt3HTb^pW7PB^Dk$|Mu?ecx+WR}odDF`kb5_*!v0NbMX!O{{P`%&o&_hl1POuO zDZROdvtoj#xDf$_`g)2XBKD+JoP{P;(Os{BzT^Pj+P@3cd87bLjgC86S>4XoU(lpS zhtFWe!!-{)>yitXH~~0N=e@nI{*S4++m_amn#+ZkgA&e48_hrxK!lg;4p*gA#QqtH zv4Viv^Y`ccx3@v77Ol{9B%mVzN2%3U_V$){{ZA7B1A7E{_RhgRqtKe-s|kD zYt>f0cOfBB1V~6i1qq4Xn`p)qV=!QhE4Y9QIBs-o$Gun1f6g~MLdZg>EH+Lw&vTwx zt+vd}&ikHzzS`Q~+05E^$dZ|Z=R!-!J7a_#U3(hJdJvU`P&dK|U}hx^etm-$6d5f6 z%=kXI07;>qa5D54@UHkj*h<2mNdE)A68{L^ll&B-L%mtwKuDipAdvtC1F12{gO&~R z_C9yBw#jI%I)-w%RO~`U94v=^3-bR&0DIRjhlls=#G7-O1F$oJ^7-hSE*p06sWj)0 zF*?O3$w&b7Ib99{p!B6Pf@pmSfMNigLi|})bo5_HMhhH!ld)XQ$!0@NL+`9>DUASq#nm znvB~w!b5wuqbt$LXO7m91%L#g5WPNX687@)+D#_&ZJh-Oj{u*500{W+UqSSL{~NST z`x%@H`xU${{S`EaPXMowaF!+L9}JYqWXuYn@@5xzcL?+f9JF=PBo~(_TJ-!VE$6KP z_zjbe#&w@-IZpoiJ6Ifro%k(~J)EtYySPi*C#< z%?GVG^i^jCG1+fWkXcTy%>3!4d;uB$20f#QzX(|(3J}v=#-sOcgT0P50t5mu$s^tz zl?&kG`uuv8YaGyL8?)-nhfxrCcZy?Ou9Zk_t@Cc3o|Bx`27Q8NY z;7AElNiaw$84tkM-%xMtQTP* zEA0>M*u)5hMv5=uXETn@1@QItmC!r@ik#oh1VClJG#`)_4-E+lgdjg3@CptCH}v~y zT2SbX<_Vw`K*K>ej$_N2qbwcldKhHkhx3!;nJ-F#G-u?{zoC`zhrNIE8aTFR2kWt4 z!G=?mqFF70imc?gk^YwGKAb5@PwHL6&{+Y%zLkJ95{$9{dP&&3lztj*3JS^gN$Pgw ziC2!M@cM+<1Iua|c*y@DPrdh>gsD ziUp9BgXjBqJnbJ2n8L9|{?#B2|CrAJG%&y1*<-*rcQmom--mW@N55_Zb1_!pcTwe7 zq(=6}yz-Hc*g^vMduc{85&$1br|CD&vR{6A{qB6a0I?S^G(x-bRt(mRVJ- z0O;Bjoi?ZW{^Y;Wto>tqcc5>&lGPTFwx+;icD!{|MJbE`m<8Zi#MFraOg0j1El&WQ z^JkIy{0{k^qwzmy73XD>`9G^9pAqi*_9mwm%TNG~x-5?h1b`L*HC*+ebwP0+gG`j= zECQIBmsP@_O98BHZywe3rT%f32k*U}07!xCaSSy@0(g5=Ru~e%<76iPvlD>Op&-Dv|?dIPOU zwh#6pfCHOWu^2-v`syZyNbf8HNapm%X|@0<4rg><_O-hD69D}V6ayd^07?Iy(GtLm z|Lg?NHy%K70Dph~_<=R3yeTEp*gHwrnHrP|I7s``O?Y%S<^K7I^zKz%SF;i#sjc&o z(cXlD3qS-wF2H)H6TmWf^3Xomu($;%-KCR>f=NbXGFO*-Q}a(|d^FSkqYao1l>gt> z-NpicLJ*Be_wcs$u(V+|l>mc9D{;y&(AxYg4|E-&DmNY0En4Wb`-ZtNXtDGz&E_D1 zeH&M?Oh$M8EVKX=uj}<;zZog`|A6wvzXAc!`H>|+1b{A2&Op~AQY%|xkLK7gN{ZyJ zA7u`=zwb|Ze~SFmk4TTH&}Cg)!&g+nmzNw{HhKb3o~9+E$OWJ>;7v|UVUjsb#V7&+ zP`!J!P9`Q9QS(n?^a{Ns92U)~ajd!E++Zt_EnCqDK~LA4frldL+c!W5Wib@uk4D`^ z=h$+S0qkABqSs<1Au^-!?0Z*t!;*$sVAaUp<&?@lj5Gsa za+t*b5(GdgK_UP=?+pXj0Eix?d2~WQI;GH@QHn}TPJt)-@hBR72yeulD;Bdz?t-df zmis3yGTIw4MyGtXFeM&VweTg(!(N^@QpU@4^l2^jwh1VDSrc%U5a ze=Ra&x$$^Yd|F$S!y0l}8?6(5Nb*C8$@gzwz>giyp0j{^BHjK3KrTRIbt#QBd)^t>+#Y4# z$0?hJ$k z1>kk&Ka%g!otvOxdI>1Qf?l@SY(E`c>2HRZv_Ew*u5hejxP9r!&qV+}3DptMB&P$8 zD#l&{z;mF$<~IBuY6!|pilybvR*b~_my@ z$lv?&_BD&|7?t*q=C+d6NHrIf{#)BNGNnNSTl#`uAOPC;&0+{dMoNSTZa>~z^O4L{ z;X#j&qz9nzcAo-ts|Wyr|5ZRhz+Xs&>tU9Q9wt=vn8vbFK-Tvp1UhDeOoIi33 z@h3DmmYSHZ&0cgK0c`HzOUC=B0oefAHA`R*x|S=N=dt+_R+V_ta4mp!|7!j}ohxNL zDDdg;@9$2M9v629i9r_r=B(m87C@t3^wDTfp@s7SWNN{Gqdj${vE1(JE?9#%e~eD~ zrB$!E(^&*S>(S*V#j!qyb#0AKA%Nb76vs{Y#DROEXITf$(nIqzCY5AJReuH9)AW)s zpyQ*F)|6(w6^&Mc|4+GcMgSB&cYue0^Z*jTy0!(7$mu~A8W=p%Yh9QUH=WFX8sA1_ zMpdIDb!Gbc{e6YfxO5)EwLc`JG*ReYVlxKO5}?$zK^BoXTmtyVzmoqi5CEOCBNZ4# z!fC{RCP9tx9<}3AUH)jyQWn8Q?N2|DVEXg^=N9&35ugrkS_uu6#h?|19T?}tEmp63 zHrvLJGV9aEeAOBC^nw;53t$s!EUE)2vd5>83@KNh7~82u?N38Lsab}6f8JldH7hMq z%;NApo0$pCNPxA|@&vGL=_1ICkEC9JxRGi9(qC#t!Ivq3OMy%Z0Mfk3p;$B9`!@)6 z(Y}pUg!U(ZjfCZ_t5h16^d}fUtqZp%2em~uOLcx!q{i%3^h=C&i^tvRA5sXq%vQr7bpn5hlA)1{- zpQXS??E+9V{Xs`Z+GG27!A5+J>Hsq1B5fo$JFc=!dyqyH4B2QduVhPp&1BVbLz(wC zs8)5X0Q}AW^L_O9_pI&x4R{w|D+>(nLG!sJJrT@G@$8XY=VE(OzAVI_t=dfHKaDSE zMPoxCfPv13cL4@)13DJ62}V@PDl@;%h+K;_kxDx*b9HeWlw!2xr#mRk0|wr>Eer;GQ;sTSbi)(wonSO+Ga%l(^H zK}}u;#2YjRhkK1XYHNSNDJ4(QvT;lCT!bmcTLxAdS4ZOlFri=|-Z#BMnI(sdLzS7k zP@&Mhm4y~facYufXcmCC_rv51-_DDG+=?QgAhdWKK|rzqG$ehm%hJaA2f9Z%1AwjW zi~GYnHeZ*wrQ#Wipl|AEg#GK6!OEt&V3v!)A{Wb?O#oC0n41*K7BlTr#dvkJ{xlUX z(Ksq10V)N)XYFzp1WdIWB1r~2rs~4%SV^D{OwY@N)$L7eSuuX%&n;MIvEL#Z3|I&n zB8hv+CD_6LCWp`sSXfhz1g3v|L2>cVhg-6ZB$P(v}Mly{ryATJUqbHpDzI(Ouo;c7le8M+&w+P z)!m&<2lnFKA3aIm>$0JfG08kTN}9$ogn}%9?T!T@sBnV(T#r1_AV10eC%xp_F_bKnGCQWP(+HC&^&PWL8QZM`B{L6-fJ&zf5Z^ z4AA&9y5sC>y$(2ASWylCJjF3Kwl^XXw8Ku+mgEAgZkdN}m;uT&ljXy?#tCNKI!gV~ zFX!)HM&#Hv#MBCV3Juc9ny(JgoMlv zKy5hH#gzfW9f9HL<%QzSs^x@nT7ALveF8llyDy&KvK1h#`f<<^P zWd4)?KiclUp02@yhCJx$_;<4Au|~GoOXJKcm{nE`)kS$wj@DI0em11USRp-@duGTt zOj?v_W>QRKk4homqm)aJh$A8%kwk>ukKnlnN#KB=pYQ8L2;O|q?6zAucp%V|YvbbP z1`{Suf@v-Y9_w>Wn#10pdb0Gg(&6NfkF#d9~!p+~9Z2UvM^?Q~WsL)w2d>9U~+ zTM8V3axW4wfuAfo%9W$3{&n;0YM3*<6w30lpr$AvsPT&y@hD7+4|&9T-WfnG3+$;F_lMMONcs3l8LJLaXQKt^Ib*yExg$!bE-D4&QkYVzYu znr53xt)yditaJE-aW@zpZ<33ii7}}0bE}w3!`5D;0w5=KjS|>N)6;ouaDaY(bvYxf zjKl;;j5I?Wx?a&#KcbetVo^%ASQOGElS=%z>q?Xn^o}z38=lMcHO+lMKhUPpXnv-U zO06=9_(ULTSWizc<}L&T1m5zPLI2MuON0PVn%+^@|2_hLo0peYc0_Qnk4)yA9`Bx| zZNd1Xyfs=TZ=W**{muE&-v;QBlz&u|G37md8f646&rEyN@&p!gcW42Z7QEJTtIDCeqyUO? zG9kyF1R1tiNJf_hP5t*Hwep=YT4j2?M$_MV`GEs4H?$Hfaxy}dp#hMY7{^xq6$qe< zRgI3kYm^3{(s>Z@>2sDg)RflMT=*Nj`Ks}Ux;zr_lXT3V75{DhHst1z7Q=n-&9P-!^Y8E+ zYVnw^40i=x0vT$y=e8|vt=+M5@n8FX&!Bn#th5kCs6V79#IQ9Ax);>3U>QZs`}zM@ zhk7k{I4miOdedX-x+4wQgxYvkMF~_C=0ah124thfk%n5{#_1_j@f>Q%1y)6bg5$zQ z)o&4R(k`LKEi%E|9KaXWUfed!!Lc-{h~g0hdO8;(MT#ZVmK8x^W*Q@{#7NVZ(R%gP zNR?bm*7~^HZKIp4Fe6oK(5SYAgajQ&ZG4&vY{*SO-UDCP-Z^B2mcDFr;$N6{M zzr;)H-?w$OKDu>r%lh>ljRk9(>%B&D45(?h)2MG+ACIk4hwCM{o_i~evLnf7sDkF|cDXfZqzrBQ6^h$bsJm&~cu%ii-^sc_$-k#m9<6{hx2lX?Cn7F#PvXt`bCD`pnL#SO zW8C*`Q%EF%R+FLJYSedHjQR((O2rf6i13raK|z<%b@+_HOer{b4-XcoBcI*ToyUM4 z6cqT8OceeQ`tS`>v8W>?B(NBXBAolC$@ZOW0Pq9UsN=VFwS;W%YLVcLX~Dk1Ad(~o=9a^4*v?@)!q4zh;s6gNqGcBK&kqVhf320qJLsF#aVvJ7J6RDIIpu6FvP$+(K zE3PG_)-1GoQCc!v^N(dSdRJebJLoi{dzSOTJOVw%Cg^+`(Q2821eTv^XXKR}#X*cg z{klah%^f$46`{X38{UM!D9f||xw^2>wXU*MG`%P%rm`SAIyp86~6EzQmU@z3y^2?R3yYD8sCq*?~0IT`5xm$CNh&OS?(_s;+b znx0a1yg5vrb*SZ0Ggg-tKskcGh)nww8>Gfq08R0eQCdYkCzlvTyC}(!3#{~tRj~#& zl;>x&b0Ytr+!+dL4wTg(GNAJzZBKc6BEE(hl`y?94+_x4&q}sII{Nk$!RM6HlXxz+ z@64wkBY-gia25f?bDBS+_Ww9DAquKc!_}karklSPERA)&t1Mq1@or>M`+3!T0FN|% zDf-$4r0vNcwiqrTsdPGXCEp=iG@NdlNge@(_CzG4LjIh3380p_C4x)CraZ4)%)n0* znOkPhVCR#c?yy=|K+iyWzf|94xEnnv21Y&Ad?654bW zA~PDcLhZjaHy~i$mgYAdD8r3HZQ1|4y|=HEM=FE zesE4|A~Wx4sAaTP`HEF3sgE4#cxjq|91>2|Fi_a^@vp*gekc%eHE7C?|TquGz1WDRGUd+bP84` zTUm%;DJx=tnO>X+<@j7tb~{gpXmJek=c|e-ke3G~Wa3jG zFCj(%{Z|$=i6hk#!|iSoBl!PH5~-1YUW`DWSy9Te00o(L)b>ey6yKzy(P+<`6{6A+ zug){JeSfz=1-IQ-&VieZgHR*_iHhw%^Ol=4Z}($A(OvfI_l|aMMbN*E0{!IibGzpa zd6{ynTDpgX2!KWKb2A~E59Fa{RDB((k{*jxNGdt4Z2b4-w~f}SI1(BaPX#~(cnao4 z>r_`G)v^De)RZ!N2I{B8~fbh?0BL6A9qX2qWAbp$8AC5yBlrfY!ld-b(Ja z(+X4=R23hy_Jy5ISKfS}4F&)|le2r8HVpMMlOj#?NvQlb!K^29_+yJ&@<5bIRurw4 z-1U9@eXS}v$3!iCl_-^OfXdu1#UVUOq5z- zA`*e0%mh-kg{*;3-DMW>?R4B}3dQ8rbIRb;XSc%H-AxGgrW=vK7tp7acqm(XJomq5 zxkN-mR=@ARFQ=CIkXSYHOg1=HCi@*H7XNze&L7)&|6guim6ZX!Li1Smd$F2RD^h5(exmIqeW!zZVF+WJg>zKlE zp2-$tU}B`n*Q!zY#p-kc@fKq^K2}6(RoW=6QXZ*N1xKmX{*gMRZl`itOBsT<%wqYj zjyp*%zk8YB}Q}yEX*bFS8y}Fi{nm~Dm1MnS@6z@EpX+L zjd1bk8aRJn``~WCz9yx!zCYh+RN2JRBdKx)nWm zDgT!o6Ddlxm=bIjb6tYP*l5*i7V2b@#j@a_d&B+wo(=c)`7q4K=L?iiL%qB{^>=ms z%xCJ9ue>Ku2G2>895V4U&xsR1MESsL^5pk@rc6B_?CE_1U%y%s=%*d`&)E6*udoFw zEnEEM9893dzabgHUd}YWe{3Eo%N9aZ^A=E)G_lw~NKzU2STm3W3@}A(L@U4oR6yh> z=L)~=<4#v9>$f&l!AGZdFz{b^XdPTQvWf@$KqRoc8P4xrs2}b3W*ZC<2_ng>NisPs z$W4U@md}Ofw=RHVOJ~5=d4*7HHA7U0_=9Y{KJPp8`Bf@Utwgd+91wUWz|HM#kBJk( zUX$(wpDA~N@01DP?=lgB+$Ter*HjSuxq&Ru z6XZc&yo7jzJlLB(AL2O$yeE&x&%6^{@$xei3ujj zEZ`TN!?b>20-FBu1)#6#2J3>2V5wivNWecPml1?-WEKk!P7#|R90?!-#YUgJ8u{VxO86&T-w`s-$=i&JUaTf=_=*U=#U6lkdq2e zZR>#dPws$Ep51o!od*}g`$s$Av&WafE4vzDNm)81N|lf-SMB*WuSuLqCkt|Sf0%&o zHeoyhn+J4==VS=+Kw!H~V0)3zR8RzafI;F9k?Jsr(@P-9qJ-2a4P?X_AS=NPxk(l% zOpS)(^f)NVh=y!&7We05?OoLD;>N~1VP zQL5M9>T6M3lJBM!g+J*s9<}(iNf3&F7x_#ERj@1QBfOYcNlrWHIBftyoF;JG3 z2$i|XFg-7oNmV}X^HY2OuFOq=ikxJq$WDTC5_~A7$jiRQ~QyWz@_rC*-i-Tc+rT@7#^zw@m_ zi{L~2{P!PP3~wRP{NqqNeEdi^vjjBWp%5J=J(H|Z&B#$Ge&y_Ikrp34-`~{*HSk>! z>@fu*yeEM+)DvPg;gE)4&qqyNkP?N!wIR6eJg^be1nAOC8*2D?C?ZLVV^V03y(VdW z_Vhm{v3-PpeF=U}ZE*&(7JR3n>k#0h8bjD^zWFOGtNls)iwrPL84W>+#Sol`76590 zA^>$|J8J!nV5(ci#5j97lEFGg1R*I%6bZ%56_|(wFhOhv9|cbW0Sd1BRv&wwR(to{ zj6}F_Yy-UU_$D~FukB_jK=|-j7wl{(0-IDZ;T~{v3l2iZ~O@O^b(>GjgHI77H;V z`P-RlwbU8cpv-RnwNWN{%>C|(=)X^7roAj+8q@N*iB<;cG6Z>rLyHSwC(!1n#xN<# zNPsFNgc{W1wM7{)vp5rG6=%V$k}Q~AnhkTy^I(2OJ~UPrLvw8@G}rL5u(k}EYD!>k zMIOv9$%g9uG@b;C(tyT|xlNdK?-;^v~IFnf6D} zo9C_N!H;5?wTy{n!6r~uwDGUQ_t1MMgzI1ux&mlXu<~JFDd%}Bk3ZL_Gqe}k;q4PW zaOv<;NBXaMQ2F54V%S`l4~a76wxN8-{Pe{79K8-+JG2VEd~r8iJhT+f-isu2?}Dor z4=jT7dz#?&U3IXfE)OihB8ZQWLS>8v<|DwmOYE>|P98kHaW1@me+#_1Yc{;FrV`o< zk|9Q{f)tsmXf)?vo}T_!k)QV))9xG(LGDu^%=2zE_uZNAPM|MJPhemtfHT0S#6ST8 zo}MGqeIA0kV{SDpYn%;B8fL=cc{AAG9d*@g-#K>%w9lRn3kmQuN}yqSAtQqM<@r!w zQ2=ug^z)D$nvn!rkPN!!*FfjIYN#vEfgB_s?hC{s3~9G(!v_y_ zz`Mt~;kE5`@YuX~c%eNN&aN(m4KvapQKf?fsdDv5&b=}(<@aH}-WSQ=5A${bvELNX zgnA(GEKr)21bGPdyp(7JeKgbZWa>9m6+t%wedWTru(WX&w9Tr3nu2sli#C8o5e9m3 zAQ;2}pce(Oy-^Yf>M(Cm1bc!y)EmVMlp&t%ZzYN>(3SnI3H8Cp9$;04LoI$D5lVek z0Yv!wL7?l@Wn)OY4L6F`v%()4pZarE$1)HHv*I6~0HpczSny9EfT#r`p#9xQ0FxwUpq_#-CHJYX!uZEqbq;o=vb?9h96ma^9nSA-y{Y+s z@xB)H%NIdob|NGxRI`ReGAi}a<2`Ng!O0zbl_8SM#RDDia?c!irX>}gS(pr&3Mtei z$HNyd?0}D-+XYu1+XR;%-2|5&S_|iqG|unk$>-T6h45It4NkV&;p~bWxUW7F(sf3N zm#7X7r+BE=X8Wng-}kv`cix4-cLg~DQ61tA88JF2Vc?I3oTNx7K)<}MEEg7|W?t1Y zk7@W>MVXKt&jBY7WA6=ey9C{gKwrCrSqDS}^mKrmPs>W?imGB`WfSZ;8vlQSP2issin#8F}Wz~>^Yf9yg$2PUV2TyOs z&sYc-?rVkDQ1d_8k_In!q{5Er@emazg(o(*z^A8o!-b=3;o?K<;Nr0jaOvSqaQ;9S zx(o}@VrXZ_@Kjp{9B)d2r&{dr>XHn2xV-?%Vxl2Qt{U=!o~rQRbuQy4pn2^MDg>=O zz!joZp-`BPWcb(~ z7{Mgb5DqpyNf_HFn?#VxNx*KALYhT}kELMe_{a2IvPsO|lZ5Y0!o4=k3;d@34asF1 zh+|^P!Gt2#Ohg4jG*~1UiRKm(z}ov3&qD3I4Yl*an_B?;7P82E zL#7Q<$HYkx z?&F4F^JIB^(!QxyB?3N!`TnH&Q=)WWlm;^`ALw!yYWne@401z_9SAlZ0bay}z#Fd( zMG0Yh0)3KE#DJa=rG%U~4dlh^cuCMhZk!gM(?Tx(O+t?|qg9Y%mM|ho(1kIpAQCME zZMYAFc)Eiz!Z)tAcH9rgkawGG0SfLZ($IIK_Map|?H`%RNAw-w7c2l}dCPSKzygAl z2AsRPmjJl>b!(^u=>PzL07*naR3OQ%W9C1-j{=8YW;?4X!0%xs;3u=*l9i9Lwd#A1 zt*Lit=jK7nfBRYh^U~snOaSo_lFh5;l%bok6)quwU)fp*r`qiBB%1z9a-%`x6AH6z zR(R(ik^_;@{tmc&bQN5DpbH6O;dMO;mk)KpYxmT{iRM%!06UyolnIY4u)+E=160Ov zkfPAF4R$PX2I(Ck9v&A1-CPj#2z~@KX@3)%=w$vE;dw=AL?8?DfH1GgAoiKUUKgbd z>ec3?UfU72sY5u<2KOnw{teRli1x-zX# z+Fau20v1IGYTRHjiv2+z=nf(7cY`9(m6`TrmZu=-lNjg)P2UIfXu^~BCh+Fl3=I6K zcph;Y(&9m=#e>lACm-J*OkzJK^fwVooF)Vk`g|T)00I#R7D0+B0*}cDLcQEy9_>1Y zW7{w{cct+!zDlmaUBON6`@Fw`+t0MW*u*0LzERnH=U*S~Pug6RHH!}b_GPJ?&$)x){v*|2|R6cia{UPvg!k#!3o&t!o42_|@GZUQ_$ zHx`aJB*IhenehCIQh4>A26(Aw4g>uYX#Ugwsn&EPfK0fjIubUPYM~|F2zIspe5O`A zo}|wqu;v;?kWak#6!NQ4>jzFlAATyt8|9D^sRdnx4~TuIfsCvHi66uwIFkfTuL)&f z9SEoltT6;uDa4~&K)^Ojc%ajsllnU(fB~O`{x+jnQ4q=~3!UzHPWC0M75TWG7 zYd{m`2fov$UFQ7#|6>f5-_qu((frH@eeZBqnrr#eL&`-k?JuzelJ=h_<@5d?hNN$R zpMrU;{I{x;Y4^djKO=zoYe7GADQgg-Mjv0EHPsRorv8;ym*W`lH9U zv?2iv%>uZ9COMS?H{~Rvxvi=k%6H6&wX90j=%F(w2D);iAXBRbE=U9iyJy4KFYRIe z{`)63!uh=|uz%5Xczk&^JioFGPIhFoVBc{E;GZGTH>a@2i~vxcMFQA9-2&@NHPCD~ zLaJK-qTOixZ<4;ppbPQ-Q-G`6b3tydAoF)Y-`^Y3<4jP5M5e*VQhZK{R)IRivlq0y zug`0GGSf*b3%+|M5&)U?vFcC+asVR@qsW(mUI6;dgb@M0-ikyJuMNA-!m#Nh&~=bQ zc8rn{fY+319|gF$jIA~CZESaIwZ9BjaL;?o%-|xof44V!WJpyg>u>h?rx&OH^~v_E&*mgrAzG}u8Yk62l1u>) zbj^UzPu~Mq9^J%uA0A!>R}QqpyGItml?N8V1vK|5D0y;m9vp8>M!?(Q=sX)dfu{d+ z9a+ruf1xuQo@vW~Efpr%Sf+!TIJ5vXy4?dEN2r%az0Xt^X7b1AL{OYzgNnRVuoZ)7G+QAUHe z0>4{nrdDB_GtZN9;UyNsnUgyf!P}3mzi9?QCEVn>Ob>(Uke8XFIdM zczIbKEH8}zoC_Ai=DGs7dS)kFd2BOWIJ&N1wBPYv_&t{ncEag3mCWQP!0)Y%MzEXV zv8Ggbv@r!9s7rvI)mGS4riCWE0n)Vw$TgY1F{eNs>f`U{;s)W~u3!-PfQ?f@erhbF zSk+)e(DPvCHFq3p;#7yWPmkn-cVyZ}tAc^U{~MhI`WulzJhM0=Sa6Zt1S|Vr00euw zL!i5Rved=p=Okk&y>-$3gH+rz1x@^^su=jIXE6Nqzy1gQIL!xSx@hK))4&f;vmF6j z!BTd;+8;s73VIO8l;1b^ruuH6`5o2)z3w^!paCL|&zh!=15afnL?8k9E4Z0X)&3m! zyXi5OD`)m~!#^Hg4d?E?IRWs!0E=OJeGw!|6o-fMJ;&QJUm^myw>I&sY`yO4%lo_G zy^}lO!m;(N`|#o;n~?w(f1?VKf_^V97sW{bl(YSY4!N`?WFYkb=T|bTZk|1SjxCJG6e1QH+{5*b%hj0WbLT z&IJ8HBtY&!tU83b9|ZhJIlm8dM*{Qls#6B}OduIUsgg1_^xM>-1-(Gyz$aN#q=l6QdUQq9Fh9+beU{QZAN;_v46mMp*v!S2KI z{Ye%TGySPbuRjP$>l($w^W~jM0F*5t5#kUQ8UBq#gyug)_;|Ldf_yzm#t`eo&0B8C z4OMVo1;}~LKM{q>ddCMy;g<;h|DEKH+SkH{c1)65n3fK4MCw_<4oQH_cGB21?4y6) z|K>r!b!=crFdHAnrw>C@%E6mUW6eR+!qkia0u|<2P9*@dIe?=1uRpvNE+1YpWCEZ* z{l{0$gmjJO>#``*6q3Qd=b`4z%qwdPV104)M@b0Q=XNiJ51-o10DfU#3!LB6_zm}i zv_DNAdb&N61p+DPcM|>mCz|c(@0(ynftH#6i?TULQ5j&i&Ge0R2IRrME+mxpQ-%02 zvzk(KMsx%8VIGVCt^sY70CoiQsH9i08hS{t5gyGyMmu15i^}AesM^26O}#UC;%gVjx$Me)ujx zZS4>JWajxuTuA{+<6lVnza&keHZLwohj*V?&j;Oh56uOjG~ns2^^k8eLV?*FOfuM^ z)F)|wd2Us~g~yxIAVn&Lo|akg$??^2c6|k$-9CpE`_T7axW65N-_DAK&fnJprDxE0~<>9P!($;-@j+zoWGYliO*C@_o-ldZZZ_vV<9g&68(P_ z#Hd5julHx*BM|liuot}i-#oB+aQ6kd0BH7Jk&nZK4`KmCl4w;3D=&`GghQMzf>|9& zoC3dF38|54ut#dZ9;Jb_Xf0&K=pi%C2wCwaCNyXyJHf;z2~lTakcT@2d%7+b2YUFC zjG=d=+Fr^1AwXd+CE$~}Pmz9R@+0sm=tqy;wDB+zHSe$g_y1s$Zy31Kpbz|;YV-wD zzi;4=dj7-HYnUb%I{$`60QKuZGrhx62T;fgfrwD1AR!R}Ob(WVNJ;YnEcHVpHgi~r zlDkaHlKILk)!x#`Kauo*UA#nAwy~}VK74WmOTpbN10cwi`&;1x0<=&mHdr zev+q=0BFCZf`fG>8feedLx$D>**cwUpzoFXc_~P|CQpF`lM3cl=EAJfET}2Ufa&>Z zP?}|f{FErjh}A=qSq`z<2#D2$F^N(0LIAd+KTf{6AXGF&;7%||7?BWw39$LeQEaFO zwF%@5$G|0F{t4H4-leWwOh<_gc*nanK7VxJZ0?v5njx=0k@?M*U<}n{2eRXN@$b1`|Xs|IqpDO&0Hzhk#e`(jrQ>|&N^mk{K1y&WP zp(08TX&S@98-1@Nz*9=%=i&kZ=mr?15s((kv1vWjX*aVZ6J{bIP{R*_k3dRbB_ZIJ zWZ0M#v8g^Wyrjmkzv=%3=;?jHDvbRq7bKgX79>cSV+;TWCiu8 z$=3~B^*3k@z#5hYl;+Q6LBHNAK)Dr<$IQ}=fAI)}Ac+n_)z+tPKyKqHdm-ZI39>Fi zJlCB!yFPhF{ZmhGZG(3oUXBDXH2x|h%>PfUj#ZL z1RBRhkBJmW$Xci^&b;n9UeXv~X_jBF5QrT>7XC-CyC!zFCvX!15fRXwftef!bWwajtTZvpX0nve zV)!e#U4vaGnyFVF8~NUudpqFGL*)NAT^$MmP;l<0O|@`pVG=Az<{&|)EhV|x?~I+O{|N;Ca|nDY`XOT2 zSZ0LvB`T;(G=N>Df5mRM|9GhPhCa;gH)1~zV~B@ai_g@_uhNWu?jhyK16T?Gw(z6>~}7|aR@sKSCF!p{c+(YL2Lgd~10(}3I+Vf_HFDO29_nL6cc zu)FIMA>Quu@D#?n0SDNAfZ8sIBIH4G?hu0h-M~KDelm;dTbS0LEH*N&>ZXYYZ%aCO znNk_Z$kZ0hfBHX>09gW)S)V^&?%P-E3+X@d)79mz5ZSzC*nvMG`cG4W!&v$+kBt(e z&*gz{Wy~?TPUA zi7oKvW1AfP{_Ekw;pM%BKbH@8u~@*<2=oWhEm&J@U=e>Jg2VG{u(D8xqJmY02uPz5 zGBvt+qq%Y9z8)?SKAvTPZqx4Zo-+9YS_q5~e5XwVf95t2D5rui3Z>yF7vC%RH-VN0 zcOsdfOkn^Pgnxbte%@pzUe_%QGU+3qDN`;4xK6u2#LKNa+{?W!%*(wi)W@Sv(*^ZrthL(_X9;N4`T#W^-tZ=$1Fhk#F7pL}~7+7aj& z)=6eIwensA|23ia3E-!)TsGwMx^mxaw$hK4%6%Pq{9zFQS_`E8Wd-xuv9LJ+v}~9% zhH3xaW5Hvb5UgYb5UP%RgvN!_AQBoBLYm)0Yyb~q3i!nrp*54h;uSQaEKtss40ioe zmt{J@kV7Qyq-*X~a2;n~Ng`u7v9Vkme5umgupay%o_3la7|GnLphI-T9ga4bC z4hCu;kM=Nck40f#o{PhMJewrGUU9NO?Ex5;?i!3s0@-DIsnyIOtVa90()f2?b0zCUVc zGSg3X=fmUm3Gni=Tv$;M2U%LJgk;d~5{rLr2@HK>`HTYiA@5*q~j#_!OfHcu4oZZ7QjcrcQ4+^|1Y$d-#fjn z9{%w_`;Z8Lz)xejjxS8R`h0sToM_F2_0?&xqBPA+ahZp|-VDU02NuJN8)h)=&(eOa>F`urI`mX>Eb70t(gf3^(C1d`UaWN@fb5?3 zA6tSXUCAoV4C;@#UGDwY_b>SQYx@@d_1x}-;&XeOQqS&f&PG?M^xU4NigSAw)}VBq z-P5!IuicvSyPMn3?`^KcYngv`&%%`Rdz-BI+Q4(W=l%BkY2wQ);UT<<{|~{ZckA`( zc}?G6V^gZm2Z2i(o@VO_+Pkj?Ckr6VUdjCT$!waBk>%UzbI9~2v!AR53dRXtetq{8 z@sG%w$*=O`@cW0P{n;$QH4xdfnN0*{LBtq7h)Boeu1nwvOk!r5f11<`?nnp}$dqcV zAVTodb)aFPWHc1vyMFGz0mU4kpnU1tBa!qxvuRjh>qe^);+~PM=CW9=xRtXyk9xxUI=zbFaBg8lRTy zrkDWv_QGNve5-HiwU%G{Ox#oNeiUl|fk01_e@XiPk8=H%`VF8eYhlrTA`(VaNHlb; zL|$|}RF~k%y8jUPDt;Uo4IXtNmq27-!$)c5VR}!fWBfR2e{U|G)eI0xpq230z{P>J zKP1W2>yOiNTh!Heb}0FOB#HB=sb5%{53eq^!{Y4d52GdOVV5N*NF>?>u^h7XI@q(Y z?CTGXEx!8Rv2Hkv-$7k}PcF2>lg%ik`H=ulcjmyMx_DS$qK0|N21r8i z)@byT&t5;!{=ypv+U_~OyJ^<>-3zAPp2)|WGEiZuM&JGms>k;j1oVQ&ClP?p`tLJp zm`_bXH5#xf z4UcVthzLs0DiwVqvwC|5$bt}#kBXVd{Rw3~1C{~j;!*b>NtRys#_687gy$7U6vd5S(H>+GSZ(qpX1z;WXhA4U@^26q{55qro*{adGJ(o5+i_TJF-~Q z&*{!=I66Pk(dw&%R25bI>6@H=>pk9J+w%I}X87XFt}k9bxC*v3Rw2pgASPUTC7&~X zYs+%Iwr8OmYV?)ob~k@`)^XhtxbX2qUGUzKPBs?(>@bS8UcI-8z5ne87QtKS=D~>- z@YSQ;@WtaRUVwK`=x-bB`%BGg)cBW4bGgf|1@k5k5SeEYduAfzYqbdwj5oh1dp0PF zn^+V+vS|ww0w)dR5c2fo4v^MoCO-Mj4$V&`zf{F1+;zuzeOO* zoY}j^-;GRtn)@GxX1HMVHwt-SxA-%|VUc&&Hx6PH_9Oy;vkmN3A+h2VW`?M!%K+kAj0 zSHK5I*slz+W&7R39q{y~IuMD%Av_`!3hj|#*2+O935R*LCD2usZzlQ9fKT)G(7!!Q zKCYL;x4(N3;FC}qk8XAv#39M6V;yt^M$)hpSR*rAJ7Y13&_@@563WcuG`KrV%QP*4 zjzCXV11r6CtjMD*X=b0Ns%XXc*Y@`0)B6L_za|TVpX0xFz-m4s9m)uBtge3%=w3seGynhk>LuMn`l8(KN8j!>rm9Ns!#>3=~}Aur#XMm zIy2>m#8yXXM>G8F*puIW`!oox0w||)kf1c>V#+N;~qK0X6`kih@07MwwwV5z(+>cRy3FH3b ze_*PYFNDhEZ+iF!Udc9Ty-2QlL{1H8W0Os4e-WE2|^=I*n|IX)&}(|e;9ZUw{a<;;B$dh)~5 zs~HK9rln{<*RRx<2mQ67pXRx%keKH3d3_|6u(T@nSkU^Uttr4r=|187rYR!%6lFYL z1t=?QVAg_PRJJ2vIi3AY$D&4Z5(tlunTU>Dpo!=nkmW>i6C%~2{07-ttyfii+Wv99q^3{NCcEV;kVzr?ijQhnO5wySNUl6O69rzqxsCg zXOVe50|)u|jt032yszLd6=H?bW)F%O(7zN3y@2Duf@?;O^%PsAWc zkWurE(P7S$na(EjRl2wpLYkfa_G1%;%h$8*o=i9h3 zN|Us|%rhBsvkj)BscOTgc8&h!9KErqfa9Dt3HRJXoxerkzkLlTyiZL5&hz^h^$Hax zoqupGym@>pe12v(Jhi<8D&wNS8Wi^CEL&`_vySKdp5|pA9$gHFR?L83{MY}%xS#zu z=yh_4GN~Xr+5jc#(NK~W1(`N8G?k~qOZO~**Y9r~k_+$(lK7iw*}*fbnLF{}k#>0N zq2e#$Dr8EY9k_UlK;QamLyY&Q+D#4mj7HtXHatk&7 zpz&av?KfElgCtk|%>f_7-2le@fTZtp7Y}rNa2;645}-jS*GU6g!|?pUC2$EX0%}}( z4=sX@@@z2sheCvKsoG=X@Sv?a?_m%MZqf6lPN0u;` z;42ie5a7gec=KQzyoSe1t=s2^n7-|mUG;F`$f{G{`VUGCD*+1b9vZqq=`10S-yis- z`6(ApT3ayB{n>oI3YK;wz*E zU!VN`DUL=P27EM&*}8a?dP5;iO28(6n)$p98~KPj0$5wU7{b%4+5eelcbMDc4+|x^ z!AJzu@Z)Jn>Rq9iCyuoaAPp43=X3WIOr#*2l-hd{n3PqpIIIN%o+NiJPfqx`eTRbF zNCF+T1H3g*%7{Zz(#%^i{nCkK?sJZSqOo6Z0TBZ$JI3eP`J+|Anw6+qQOcYDK?=+2 zTk$)tDK<=9Q)CEQU7-Ho?^7`ukr>H=y5s^{ZHQ(KJky!;^=mup9eoEwNUI?*&ms|= z-MtXrd}J+r@%Mf3*yc9KH5ec+T=YzJf+g@8_``m5vkFBdo>(S(o9+`*upd0w3GWr zo_uQp2rswXMaON=rxVBLlIZ3ispZ(y140vTpCOkSfjx8>F z`OsoM)j7np8o37a+KY#l!WS>>g!2!sfyTTvhzt=!f>?g6ILa_2*X!J#rZirfj}BOK zftvoco%7(i?ksqwm6kzIgy$C}!$b39V0n%L7TG1xl_`S`y9m~o=;80%=AuP#Jqi5d z$Pzf!Gan9i6vK0?%iu)29iCs34X^E}Yx!0#Jes2!VU9pw{|G-z>7nMQ8<>F4(rh$P zGm5XkQynye(i^^euB0oKdnbCF3Jzzd_^A_HRN05^F?`2M9QFuO5 zzu^X&eUXXx)Yh*o)N(5ewDQ#jI`N8pjmNqi#jkF6B8XG!e5c1+*qVdSFG_o9?txuRrBGnfgC$r5$x7wQo7W#SrLwZ# zJC>5S=vB9YhJDlpIc?junqBR-z&5D8zrAAnitA?d{8YBZTJh&(y z-b6AJQiJ4HynTElEG&$K3WFys&6Y!BVg&S*Y2p6)>1nt8Vh1TLU7-rTZvQ&)letRW zYxtOgR|I?(42#NQ8k82t6oPv~ijPcgvIclRKfkw)m)@(cXlGiTndgp19E$vVBe8gz zk{LnJppNS&^sZ!a1R?}M)01h>YxpXV(|&;m)RWYvLGe?T?< zWZu*HkhUj6B2CZAfXUn^7i8`TMuy?>>Z-dwL!$W*zxyky9;9L>Y8aX(;~XQyxizEK z^m&>;uPV~dM!=s!`4|OmDn+`tRu$+@;^U>O3k~YkS%&|-ElEJ8O<#}}1+Om42I^;^ zK_jnhpUZj>SWI9z0kz$Yj07&Dnf>u2-E2l8Wl&-xWRNITY|l|BelkepUq^CocXQA6 zla^Xo$@TL~av1oZMd0_9)7=^H(y}agp(`B@&5MKONB|w_GI(@p3A}Nr^V+<|{Vnjq z-VWGU9Rr7FTiI*xpA!SSYb>yDcGBIq7W@isSFmHQ=GC&-`!h4$q3H(<==Ib5NJzpMFlz82;mKwtb6<#<=s89*^Vasd7lQU5 zss+HYWy6+{i}WQP+ehf~d`)RYx}JASco&QM2Ha&9@o0X#)rGn;1o7uX0{!6fK3WQE zR~KttZZ{H$m1_$ZWk)j-ID=Z2#*dv|R|OZ*PrlHnD{*Mj#AX-J?p?wLc|c%{u+G|I3?e;AC48Jd2vYKLPY5g1;}#f@2Hf;eola zjKpY8gYY?&CVYBl>w;yKu@Ak}WrtUmqv^jQ8=mdXx^SX<_yOV}Zy^Z&AjP%0`a&@e z72(hV8U04&sRP*7+ibP36;7`z<_X{i;O{GEkO+^I75<>s-`W@aQymREd=+0z zui4ISVzdA#)y7h44)dHf%rx=^Fumol!pLprdl$3+4HU_@vZ9z)zT%E`+2t{Rn*jg+ z+j|c%sp_kLoHxJ!o8(PTOiavcj7ezQrtePK*}glym!0ipw)f7`S$gliBOn5z2!bMF z?_HE49RX3$SffUTJ^ypQ_ukpUE-dUUU|#2W&U0t(%-k84`Fu`4hh3N7&_gbUaBbmr znw+|;2Y!>F*AR2v-j68&nf)i7`hEF z&B}#`XI38TToVx-vmbrW&YGX4_wWZwEvm6h>vJ1(sT+>WeFje2hezFVlesjXv1tac z>1!F7*u&bWKeDcOXy@0mUCSRdV zm>d4lbd@Af&*k+gUO>S~-csRQ7yj7(9B-iru8q3gd8!5^Qec0dnVT5_P~{`%lGJg3 zM_LwQN)J^25%@Jm@2;y(kJWkq2Z8xsJCL^aF$sLKa)|Awnr~NPw|jC7wsXyC9#~zU z1y7C7L~U6Gr)fwjiwn%XW^3S|Pb`Elo?QZK$5cX|&d}Ob zi%Yu&{l0e3QHJ2iJtG4IfEGoEWv!1+%xZajN;Y1v2wq)KerEq>?~j8U?KgNvQh`r6 zU)IY7`s{3Nwub-F2DJXLxy)}5?93zZlQ~aw@zAta^8gjvZq;nX_Sk@y@5*Q9ntzrA z3USD_VE#SD5Gu!W9f1spHJ5;w4dUQIMek$v_<0SiOOLDDZ@z>qu1=bIlZS)EHVbylcwSmB-_J~+Ij6i#g(&03&2Yhd#vwpoJ}!- zd%F7$M;@B@69oSmW&t1p?44HtugxoD8GwC@DFeU*ABBkF%>~8y9PLLaLMepf_fKTs zl_#GLF2~a|@$$1BY=|cQIH{s9RbBUY7y52lvW<-tm_EIra;{R z1=C2QaxJ+|Ry;(hM&Wuy0zz>TiSWM5OLHgT-`@iZgJmA5o*=ue*PkjO>2FDCKOyi( zbN^{5Xe1KwwFmvIcdtbPxVy;?Yx|f8&;?+harY4VJjYG9GpC zJT)O5j;ySKcORI_;sR8Ock1CetygOaP=;X7!r^2EK$*=ph@`8}KmE|0$H@ISxU!ZJ zzzZ|;S=#SSB!RsY5G25((7C6kTBywWlGc33v7 zaCgxDU}5pzUm*D3rTX*1?S^o&PsgzEZ9*kgK)!_QWSNjr(mk;mRgwf}4gNGB2z9=DGzuqGm&sJInj z-T?TCaA_!Lw8?wbRb87~T7FD2Dlao)LYDE^s00uTWZ@Y&<}e%QC9EYQewa_6k` zr+3ZzU3dSk#bZiuJ#gQ|+k*Co!XMvisy$~DcvIX=gDUy|Dd1)a+5?2rUf6kRM`le<+&lyNcN4Iw9)ie&Y9ZQ_0qbU@c>wr* z1?xnJuf%iPe?F0RvF!6ox1~#q|C?leOI7H?`l8111?g{4%WZ?p3@d7EuxY3r2&k)r zOaPmj?XA-a?NDlSuw8;Tsui^-w;^d>TY<^`X_46iiz=M({FF>Mgl@s%mGyAq-tlmD z&q8Jq^mKL>@%Zpo=`R#63WLgkZbv2 z9Kv!X=09Z?5#AEgUt3|fPZ}xcdT&{_#Iom4<*Dcd1-f+J6(@wrVoD#3or9^(F)+ef6rwLWN5A)E2kBzOj>MMRxr092Io=sdPceOy5%J#c5d2mTV{g4?w&_zTJ%D1X+v;g2YPLb;8XKl5^1v4@jo7z=D3mIX%^7PanMPzDF@9)+Nt$*h6X zySXktstGv#@NBs7>PpzXU>Fn_Odppzowt&7_c`Rlzq@1B5y7lKw6+#O)^cDU81HUX=)A2dw$#>)w6xa3>~t7Yo(+qJ;)py;WlHwi03dM(u(>#kiq=(v>X{LG#COn*ZNgizohi{9jKh z&UrK|$pW*A9c&A4ZwP>bi?d3&iN2K%$E1GW^IN0Wn^A`^)89DchNXQmI3p@?YS)QM&Kus zAh&^ng*4!zrz^Fo^N%YE+QcUHsM0Gs`1_1x*vx-d$NhR;X?g_xUs1c0wkE)bB)B2b z;)RO*44Bi93+qPZ!>%cX@Y393cxOo|9A8li@2@F`57(ir6{M_9?ka=xDCc-NySfa{ ztSp1$%S++e*+sAluUA)+4Jj@k3_t?-t;PkvL-}*88~%otMo1^{59ZT-ac1w4cthHq z*X#fL!It8mHKwI~RBWP-GaIa`v%tz)+ts@R4IBZC%&A#OPdXCW#QEbl#HJ@wmyeqFOp$a>y;-hJ{lxrvOQ?O9z zqN6G|X7=}Bt1hz+Q2SHaEcMfq1rWza$=idUTnizn)+O-K`WS$kp3L($NCxAPp>M2j}YAF?<$A)5X2`C_=lF3z`-S41eS^~s9KAHF?;9b^G82B z*Cu}S6aBCc<-h_zoLJ(Ak5(7K`8B0*U~viTnpz0ckz}&7G9cOMW6e{4Kr*;99xW_d zbw(S0k;IUA7u<*+_{!lGsd)w)Of7W7gJZl5(95bUY(L-fYAce0?TQ3I^#zM7?NH@( zK$+EXyx)J=ZAg}PP@uj0V@bgPDxM1GUKu>>X ziKPj+sbzsh9+Wd@#DN4r@d4JX)5CpwRPyUY?Qa}1lRY*y&E)$98n{wk{4Nyb?=H|6 zs^>H+Y5Tv%xG!X8WL#LWmY(rlyAgo$z4tp<^ZXQ9Bcn7a}a9IT$TIfe2D1eXGmck43OJP!JCX|@1 z`)>4)dv<+M-jMWEcx!Pv9A8z=deILpD`%;wmuCA}pZWGNz77K_+LsnnVbP)rJCs;# z(3s{~*Y7{{MnS^DWOGQN!6quzbsyyGiw##zaEPdr_CtUH&z&Hz=%1h;~R9`Pl z&!NU0Z>Lt-o(PS`rXw4OnavIBAn;RaQOK=#1^)gC=wHX$zh2Oo^EqnyiyyBqXFmO2 z0rYe8*^m0b%320=(%Q$ijE583rm&vxQyqXlpBo{~21s0GjX1wwk0S_<80h+BG0&;lr9R*_JcLIWv?2pAzO=Lq4s8F{cC ziGWC;GXa!ZZP1+QoB9I*+@u5$os#xv5}Mpg5ocj9A8CIo^`)_1bWTh=>-goA0~1|H z3U0Qkw*4XxPEr{GL>PR5LL8w;hYbL!opi~9jUEL6kpOHX7BVY@o5{y%f0>gr{k!t{ z$>0A+jPtwY%~@Z3y{WSG=<-rlPD!9AEq`ET4Vv$xScH{|D!K&vL$l!;7c*XYS}T1f zvk>ON@vW2Kz^Vo~b5|Mc9-jl{Hpi1U>PJ1MBwMkv5v`I9H7xkaQc+!XrZGY&gOjVP z;Kf;fSdNy!s#;rs0Opr-%RPo?`X=1$Kz1f2-IDIK#-$nz>27^;QI^A2Q&&<{I;^VP zHN3oBGOelUPdCeVjh0IPtdU4sG-B}!czhS-J(QzriR48*E=NL$y83`$viA;+A$7Ud z=>3`&cO-O@cwS=ojXq>0gmp3BUnpjwC_mT8($HZ-E}NFqL-Svloa12=dFQgM0o&Y@ zT^oo+P58>bU{t;eSTw!iU01k8k>@X}NZTt@e(EFQKDiuddB%2ZB7f|2|azHJWUj6=p zSffX$HF(M+O{uX;vsbRxd!wTCUNasuvUYK!j<(Xd$RFxITWN zHlKoY!p2<}&At!p*W;$~b_M$O_qlz03t77?HT-bRLqqtr+G(sPsWSomJ(1RjyIY@{ z?r%M}wt|75N-D_*XJwoOxEl%j%k6dh^i|llYzCC*bklAYfV?`l_ztuPv}f785*f{We-4qiJ-NxB>1%fMxRP)@Lo`JyXcv_FqoeOKtn*NBae;pqGgr{SnAEE z;vDMF_e^fv#uFHkCCtp@qx~fGIvNr}9fjN$pY@CY*n9!1FW^aq3Vyos|9>CthK$Vg z3-7NfYdyfH??~&P*|YeXdc3cf97BS-aO`0?`N|F`HD#1d*hQ1XG;mye%oNHCdwqMOfGe zija^Yedgs-IcbEc%;HTDC()_|u4>JF0#$R&Pc$N~R z>AQmYPgVd0_Gk(Y^$a-q3O@_F2sB}rh=DE3Wbfg21CaY5j07hOfU*xl`D|wb_?_C- zT2tWr_WWICt#8fCX92!5k1o1tfgczq@xT=L@VQm+?Rzi4d?^s!Tip~{{4SK{(Y|qKq7fh86N(} z;MEAATcG8q|Az3r>Qv!JTA75K;a|y$eW)XlMeFggFblAKEk9{=nxAJKxtLi2))Dgq zQGY5Yrj=gIO5lfqk`=(s-mislV_KKs57ni@Eh@*wI=}Zj%I{NA4r`#;z2K%NfRhhS zX9FhT>~pYmOcVID2|4|4(pz3${7;uQdw+fAu8Lbey}RtUaFe$9CPYRiX%+I_kzwJ? zv`PulX3OycCQ^X4g`euA> zQ&}D!{rH*^b}rLl0{o0m&?2w}4Qq1w;9i2CiApL>4xUM3^p;VbKxl`cUwt6rF96gz zb_J{77be{ZyYSq+Ur$qis5hQ01_HbTUvC|`h;;?hya3YhbfnZD9n)vs8(0BO?nRi; zRo6wS?=5O)Yh`}w#rId2z=5UZY@q`yr~Doe0IjWp4_<&ZlZHV~LW2K$kP7?p<`(bo z-d5nzf@fGa5qJjszz;L)L0&xB!B zg)o8ujzaed*n$i}O@Ae6D9wRdyiPM(1ml}4&|>g_N+g2Fh=|yrU`-?n4+a5H05NEP z*chXCD|H19=G$1=qK~3sfoMO|{?!v9W6pidhi3~v{X@XZkLVVLgm5$as+l=YWIB@poYoJK01mFM@AH&i&FQcGdVw4!o z`$$MLYQSeufhQ#jiqox3(~qbv2>_h{+#Sf9NXl{%?AcI{mO=wceQ_4v&qC7h!?>mj zm_DizmP{D~cg>v$SxyT`1`MWA?Y*ADtCmPIf&g7^MLRCOFs_EWz&= z7G}_qqWwewWahJRSa}WLYFWmuy5^_*wvF?uXK?^p=D}8T590@hPzo`(ZSS5i(mRIl z`ja~H0^5eVAb{3URe2XbT2lh=tZCqfCww0WU>ckA4j;S(cTXFI7C_Rt9|)j_ib*b) zMayLCQS*NnBaZ-ctPIi&YRE9hfHy^nnqLWJXzmX|v%QuFaA!^5RGy1|ehvdW0i85F zohQN=+fWXZht;6eGQiInI}{d98U=I54uf$G6;Pe$gNiIWcntBaiqP=0K_N4VWO*CJz3)^Pek+wI~Ph-3N$j_&tpfsS9dI!kFXUi^7DAFIt zIt964Ayo)ck&m!oQy3N2-D)njOcco@FowL7D?kN24S9*l*Cm2(G#Y=Epw)_1Dpg2WSlEyIeUEOjBGKQ}QtA9?N_$DdAxRklZq)SY zCM{}yEoyxgxY6`4NANcx_-hI?pt>NP34xqQfIv^$oqYM0#&Vc4ybh+1ZiJbmn_zZJ zGdoTn*?=Ta2E*_gL(u=P%t?hTyB-`#YB0vgSRj#H49XP9!y>-Yt0H^lcgM%a{}jP{ zIv4~HEtLi*E}=Dg8p!`2jHbWHlF1k33<+p|YWN{@p2mV%hR+Mkz!w&E3d=Z2<8xhw z4S{+Afed=GnoA%78Y)7i$y5u#4gN@F1aOPm3B~zYU!Pr7a`DjWy6=w*z_!)SMgn*S zHq0Cgg()d3ejtEufR8@DS|q(YS}M61rw~CxWH=-$!@!vs2^ppsH2F113E`N0JN|}nC43ZJ*l#<^FYtbw-+~cG3mF7#TM9- zQFJr7xqF;TKz;Vf&a`j$FD$xn;;!1Z1&l$g-s`bk&2{hE(N0mzDL6nUsev|<>Bk;`$G3FSVe3wcjhFH0XY5Zgrf-h5Zdw5&yvJhl3Tb zn~K-WbtFPDg1wvvdwIGEioH6>cP2u%H5PJgv3TAHezy*y!o~Q0@n>djd^exr?Po_!fXJxQ5S(u5&O)!TiJX-0%bJ6M=y>i04|-k zfvvm}eEiET*AV9G)91wUEy(TLklDO_Hou=+GcGb_Fl&IO?(|ReT-Y_)|K0iZ)ohU? za|5n7_^*-#$ORw*fKyMwqpN2?Ub1d>UxG=i)oxHJl@NuZiH?Stm>AHg)j;PI3I)jJ z@^>O5Bjau~=v_wR?Z#MbvsNN|Q5iwidJzbC5u~Ui7(f%F!ojGOqNY}W9W8(~fdG=D znBU)setZpT{Py6d0WDL}tRIdhy%pc5B*2IN17c)@kx)dSQ;Qks3FHL$vUDR9r|O{4 zoeX)X^>b`-4D=lE;~>`_&x9VAq$Yz`rv-T^l8IFOzEP?C)m38cr)Wi-3K{{3#glvQ z{~O&>E${z_n=(O#02ef{FyWVG_EED>41$(gh~tVzaD4&A!`tThPgu<|0GHGL1bVg$ z4@rgEi>c;cV$WqkM<#4We-YQF%o74F(Im2AmH>Xo->O}$6Kit5`*d9y9KCNshaGCy z4fs7FfKIO?H{imNhhXdc@sOL8)MpkzY;0@|n*0p(adB}>@EpX(#C+p$IKFke-GDzt zA_0hsigMlv;1_tkzq7<^$0HcNQiex>RuTaTQ4tLI$*Kqjd=f*n6wGLn6A93LXOfbU zfEWG$_P)O$l)9t*esQ`TuQ>oT;sNYBCiLZ9$w~w-=RRa3ut~dfuEO!y^ly5QnNG$4_o<7^Yyv(UNhh7%YmKt+L@c@fYMjS z8h2>%r4R!ka-fPow$6*C^15Em$@&O#8`&7K_7iitIs0vM`UmkNzG>1BRT>ibX&yls zzov}bfH-UFg#!x;E}q>y98Nv5;KqReawO2j>)zWn8{U6x0ZgqdfJ&RKw2w6ZZ#5dt zhj?rQJ}=Q|2_z*YeV&t(^L2iHJ|rY0fJ7qs0xf~RUoYSz@%+LVrzwk9DnC$!hH=3? z()cP4_+<8T;E!N{x5UaAcu9x^NF0e#XaOjhJ5ZYCL=wnnz$Z&!XjK8^p?@DO?$7-C z6x8^JXbDRhrW>On1KkKB03Y5bFy~zc=mH@K)_@?nc#cTGpp63YpioFu%9mZo>c7si zAqWKE8Kcs>Aen( z9DfAAii&)YWCkVJx*hM;eu^$P`Pad>BX=wa`kl&oaY{|r#eZ$CV_RCT*$wCm0=VQg z6sVj9AMKd~udE*jbC>F0Dd|OnqL6FAUd^(k$^2h2@dq%J?ILQ zWY`%AG$Z&+v)xE2;SBubLXf#n;3pC=YGr5vs96Sqj+y2dW(5dfZ*TSsmH<8PcO^lg zCk2YUIwo|#BGU}j*;cezB0+*AkPs=`+=JZztRRD*WG7#jaP74T=>Knw)VUzsoC%Sh zl0a8p`=Ow0OKvt7(WmM@)6hB00w8jrT7Iev(AQ1nS93R9vc!XkL(uqFzkI{pAst8) zh;K(LK%#TEzA?WDKHo7GPCh*E#(=*^1iE9Ir zkdS*|Fc_eqpaAT4JIG`*P%4$WV0{O#RrfcN45z8u7#saEE7cW=K_wQk%01HVmja($ zfN)60`vmaL;MZ%!EQn`MR6(XK87y&;%)d`XAX7ll?=eDojvI*~3S!aM7p_TU;7(S7 z2VbX0Qqdz3xKq^33Lwd{2!4J713Ce`G!3tnVMdT!peox2)j4*k$#n#T9#>`Cp~3Hj z+FUz+KNXTd82;O&FPk*dE;lXu?SMp!3*KHo3O;^(!OcSeovuw)fTtc^0&wmX zSTkujl$(rwHc1Cf|L3{`z91|hh??JOwE|fJ^ca6YdxP~Id}duZNv7R+K&MebRCqYk z_8i#5dEtRCXniCD0y%-*9NT8{rznXO!oV6I3E55^lw`WVqt^y30dfb(6`-IX5dpad zr0o+T!`QXs@knXCOmi$F0kQ%p)kh>CfS*!*m04B>?AknMJCNI$&~qeJBt!^|6m0Bu zb@@&xOVi``qwc{7(8?rdl9T1X?xOJLsUU*Bl^4MR=yeKkpCpB|04U;5+F#hfqs?#Z zPz+>jn#Ip4w zj?C-}HACtz4j(hJb>z6wt)s@bTqvln{qBznUF)x&o?jM zGv&L_pPYYVz~6&R0CfU>^vY)V>fPsHTwyj;*la0%@l5Z1c74Ea{j%L9%KPR26QQ_ABa7tN_z zt^XaNV?{uJ&~kJ4e=4(pF*T$0;QiAseE#GDwzcJ^BLKnte{cqTwfA1wyKM=Sn9Y4Q z7?g^A2-rO#01~nS5)%`d6+i(&N(}~`loZm9TB#T;2v#AWNB+GIK}oCs%u&zY=-!gL$+?MKv=fIroO&x@Js&^a!kkM2YQ#%M+aL@4o!FsAi=JTZ{gFF;d2 z&zTSi_W50jOz1w97gM1Tz1EYWX4Qt?l(ze<`j8}9#jFkXJieA<2U*rQP>a#}P{`+{ zXd)#ff_aWWeX}nJKqZkx2cZhk`?i>xZ;a`T0LZi_(|lm8nML1O;SXwe0y+c#1g`mq za{j`~?wEGPJi*k%@AQ}m!GL5yRzPuv0~*V6p{_U^nk)URzCXj3guXm! za?vH=4_E?70)jihqWpLyq0gc8ADyEN0BLs8{DStU$3l?MmY`r@rc|MjF6@bTndPBj zZiPSqMzump(#{2Vpf3oZ*WG|LmMF&LJucCCm|0GFcrv#M{4$3>uqlW%y&g?{AHNlt zruuI?7&$r;S{SU#}$CtA4 z+%!%1OfPd|p1pmbIC$4o0P#+P% z2ahj-16wA;!TYBm32=Q1A3eDc_HCXFHBQ>4XO;Cq;P1~QXaQ7RE(6e&(Cf(xNKH*; zk0T=^*9Y^v#VO>E$H>sc*YW^s2Ts8xr(j-ER2Tw18LA61@R-7K`U3b9BSRTLO)>H= z2|$P!nD{7v8wqH*&(L#`e-8YdkhUjlfKr20TR>I^eUJ9<@2QX#K+Q?E1U0$<6w{D4 zCn=SGBnkW2g~i0yy(9e&5Gez_vN{ za2Sc}%p)8D{Og5fuzf}&6dJ4#_l4$1Q~p+xsHmutt0e%z6|mWC;BYvY6@ZU}wyZQp zF5MrekTCzBnrbL&-yS?^j0mF9LXbe7*Mw%j9aQ0ehpK{fC`hxRHVt8}0-5nb9Y9w? zuOTAn3}7N0s`{gRzn@R}Wm-5h-@~-MnkS>^YXZI_LC*e7l{pU3X*D1Z3HvH3D(aR? ztTU-JsTV-M$V>36099sRNVE|(v`$!k?P2+Mst1S_Mt|pWqrXkfb9e$+4Q7`1o5J<* z=XUh{qkLS-PgvkdWb)JSM3~T2^dY>q{NFUe=ll!n*&5~}E34q(qC(hIV}iBi26%lg zw|48$-NU=A@FUQl4o34&FbRPFKJPy=2j1E`3!Ym&8qPnqfVlwFr|{V`i(pYhA>QoG<AU|63fL4$aUa^J4df^pl__mAccKY)#~&c+*5AOqoCG+vwhE5j zJGS>FzSr3bIREH8cyaxB*gm%bK6-p1JOBQp^N|QTYK z9ZBeMrZpald=?m5k;|q9<+$x2LhvW6m7ff)^Z&hjYe;?@0{2*_bl%mZ{Mt7GH3j9z zqqcbeS7r46OGvHJF@zC7!KDN+d_K4MbJATb^~X|$6#QeuJh?@l5^Hvcg&yI0AN*Xb zgZc{pcks%J)_}SE=t4NZV-hScNC3m_w?KCIUm-2zcF2|d1D>3a31_!{{|MkcbW`?k zn+^BOsE1RueF(Mx`NtQ)f%~Syi0rg~4$sQEtuHI?kN^w>f@ywqmvzz(>JUoaQzHBxBKTnY1Q?bu5Db6*EfmQ6L%#IyXbIekq>u#XwvJ+( zb^5&5KUf5?V5h?7aK z+FC*lp2=_ixf<|)faH-D)E|x7>-`_J06vl#yq}}?KPPMfYVQJQ`6@s&9|NG7095)b z^a==7f7HH9S%miGzM+P6xJ8--iz?0V$)*M_Eye@p-}|@1V+)$Var-a8JK#@{5&9Q! z_5U+$YqG()2Pa&gX}>`xfPcPxFTAyT9o##s0bPQ*ECcZB`Ux;JBlVqmRee8F3r+Vo z2+Y@N1yFGiSpY(D5MHlWbMdLw+!zyCrWS=Clp$E+qawkPk^~tJ6BMMmpdt@}?9V`J zAPa$-&7`gArX3>oBmq}BdR+J zyC%K2zJ$FlaNWi-XlX2C_lb0B3o{|#YX?(&EYQvY>7WpZ3=REQD;00oMJukksEg_Y zXv>dUBH6^R0_zU=uj1>{`vqYZ;iVB|lk2ZqlXrzm?~|eSKOP#00kl~F!cY(z14dJS zQrSkI1^f`tw$49_2hf->&I0fR2;jG28dy?ghR?P%bKpmzMHyebvkL&;huw1;!S?50 zg6>bhf$44~oLF1OQfR&E^Cv*k5DtnpknEVz_YFZb`SM|bF&Hxes>)RU~N~OfL9X`r1z(#rGd$0qHaM-4N7|Zy;@rO{m2llD2bJd zwnv4BomYg0vJzpnNF)rm1oV+RNCH|7`j}`mvtz-M7zdVwHZda@jd5ChUIQr_73j5U zFyMVdY%~~SwP1?l#E6gS9D5E$uhp>k==s;O*Tu&$p=;7-vCqTLAi&dJ02)vt8ypJw zoj-|JNS7q5WqL=vdvXJ8BNsv1%uQ^`2RFa3?$Z2!`-UH5I{adw5@wc|;Pd;2vY{B{8&i4g z8PxFb`2m3Mj>FT7hQhj{1URs`1m52@3r_8t&$jGd8~A5%@5O7J+Pw&`wSZORaYWG7 zHG@L{Z0_G93*hs;JK(wdm%zG7mGJq~i{S9qX)roB4O;TkG}nOuN=S=eD**_xfRvOJ z$jZuMgdmg2o(|@BB-a4RV2~+B;npc-#fd6ub3&wSS)5$5I#wp0&qOX+sFjLVs6}B9 zsUpJ8C?mo?R)&XtNJ0ccM^$(@6SXMfyecC6BjK?!BK-ZRu&@*Ox|1mHssxE32@f2V z{PX39a^s7e&EGd@x}S*Mme%v$Yl`>=@X#t?vT6X~*lF4cR_5dlyTP|=P6 zggifu^QP&(LN*qU+-I&pf*pK7Q*V*t32nJilfneERGPm{f|sZ*E$3U;jU%SveR<;Nq1!0(%+| zBv*iH1C&Z-pRF}->DTW^_Sne3SYxC9W{Qve6Nx@Xep|9uen*lfGSZ+{l;}0`h7`5D zhD4{4R~vZIt0U=gm0qo=rTcm0 zzx@D@RJLC1Cx4SdgD)9AT~h@ISJkr!|C!wjS?xTLz%5bhko%da#Ac!g?@Ry!37|#5 zVhn6hXD>*Aa{s&M!;x(>;GLcG;55Y=)*=b4o&_hCO@=e~E`o1PJPmJdUjmOHDGbf< z9d3z_@AK7KG~5HFSKx1-7R<=VpiyE}8}JpL8~6hO1U+tZi&`RCgWx}ZnM?px0&b0w zN<;h10zmK|6A3-{G`NETf(Z`R5*$xkg4le3rod#Nw&33|)-~9^{I~N6FDY6Sw<&b+ zv)c#3$_5{Nd3P-wT2clF*A9h~+orI+dE^$*p1)J9&VNqd5CF;Zo8k16Yj~gi8eIW? z9QlbY<6!^&NLVj#hck~ag_9emF#>pZFIy$ z>mL+q?%&~$>RfN*0D=`jgF`4QfR+Wx6W<5WTjI6xNlN9UIHmF>)TCdj#Sv_=N3>K7 zDp5Gd1`TAJgq7jp6y^UsS|U3ZtB8D3AFY|_GU;NK5fZz2zAoR}j_${Lp~!4V0@6hI@ofWP zRK68HTvG#QSCqjU^NQfW$~ri@aTFZeG9Hej`A^_Fy=xxlS6`J2Ft2+TAYcXD!(KxT zMO~%`djNj+-L_4J7pG;xvrC7=`!8%_*34=A{L|a;c<(&;=k6u&`o^j7%(`iC>c#tE zXr}MWX0P{->!ek7^d=qH-U<-Xf>a+M7K_(};1UC=8;-p%5z% zWitX}q=WJC0MLl~gPJ6wKRXvA4Fy%iV0;`72~lz|XjNZX6JtN6bReZ8WrIVWQ-p`d z2m8B54;u7K1oO++R1GMRJV8~3LH$BV08g>aya;-Z08#^iya+=Yo94^S0c`Hj{dc8> zo&gfTYbuZg{-Q{Ne!u=JSdwDk!EyO;a(M+DUQ`VG<`=@j#YM1xaWNwVatV5r3f$2t z2>93vrscaO0iFO@da$z_&>abMdj9n8g>dwq5%A(vB!HPEa0g0*4D@A<*LuAOpt(0?!Cj>VX^1EV7bzZqq#(X&KyS7F z%%O`fKn?zeA~YN{;&3*3$Q&aAYb?zPP_SP8bW@!a`A64obyCRG5@zHE>mbAt6Cs=Y~Ko>Sa6d3AIetKWJYlLZ3Q2jGy2`py%fI zdAM<0DCFN$K#v9ecoJX(L~{5Bpe`o;hF@X{q=Lkf#rg&M{b3Lc2vNY2ifnjfLLt05 zrxe~^S_21{SHhdKvti$oaxS-ixq_e_?FnF3K%=uv0B`PJLIgwrPp{?5k}p>vbQvLc z<@kLQVDJ0_*oWkGU_~{&G^YrjpPmD6&&z|yC*{D_iREy3%S8D0z*hM1t%so{KmD5` zlj*wn&+R3f>b8Vrv)Fm(ZHulx)_?C~--prgQ} zXJx@uzdy7hABI;Ku&O|+CKM_Lxhlc7a^qoD1^i;sd}u1;mWNX5GF2v8lj1-!Xz=r@ z@bHjee18h`-4uHP0tAra%?rOIiqCcQkeG8`zT)p~zr`jAR>BIbBednhv|CSHiKSg-8IUOsij!0J^IJd}uCO1Iu|L*u)0_ zIWl0GfNKPQdlERhc?_Fj@bsi~SYBy><<(|*dTKVjvAmIekM|y$4xhb+1h97}wB)8; zEV5d|u1hLOsk|NK>tMtIgux-SOoYaVku@NdO6i>924VldG$LuWQY1PPEumH660pWc zv5rEYUIis-7N*UIR~NCyqY*X50bmQ#-OBI|8->|qqAVt44N(7r&#VV|Xy`En@BjAN z1&~Od4FUly4ccEdOz#tmn3nDw$V+WU2HcS*{Zj3}maX(2%6bRdR{#?5BQEC-;5BcH z^+0vD9kvW{z^F_cRM;)xH|XKs5t(od-GbNW6u^o5Cvt^DS3>}TJHX0-r?H4X6$Vk@ z@AMO^SfDUaE!YbJU;)dA=fFFw>d<;AfSoNq*f}N@UYV5#?`|Fm?>)KzPHdY7Umku0 zK6v$h7@O;Z61zS0dZ8pTGV-?HKyNPRkKF*jiEj#`!J~o@=;{1uv=$}}tznylSIwFL z3nq^EP9KYI(4dexz4?czWU`PRwgX>jH{e~t)f`6e5zY$W0)av-AP^KpD}d62k>27! z15k8sBZyI>Q~iLD1-KFc&^2$3@q*87f!(8Ru(8<=>znMby3PWdnw{{*yi#~|2AbE) zYv9c8`Mp~J8t4V!Vg%j#{ntVQ_`N7?d5U5W+b6?2OG{xdx-WYd6rqbSp4B^ied0+t zix$Xuf5vykI_u!;NB}j#bOQt;pc#U6&8VoTXRgP;BVHo;4VwDH(GNcsEunn^VsIr# zu^E4~FqGy5P`fW}1g0UPv?*9v4=#XQxX-%(&?TVf={|v+tb;M=4iL~M53hx(BkEyR z%Mh49VFWCiI0~kZXn+wF1yGvlgwk}&x5ijCD8j;b^veI2O4EWd7K|E+f*YAMdZyEO zu)zWWuyNd}0aKm`fF8>ndCc?|27<6Q;C4a4?#zGYUhpJwXQB^OdK;`m&~HR5;I0Nc z+*NOfWz`mVYDymLTUY@vP0fSD8%DyJJ&Sq?Rw3m#v%_?uV37bTY(kBH94(gp%d6qQ z%32o0JoDI6`1Y{ zk)#H-+_`9}2x8^oV2MNj-lz#|3MR9kru@_uXF?y7m7V_&otP z;7{lVH0Rmik&!l7jo@E{vK$HEo*^!@0!rYGIYsc=>_Rpulxq*389ePB3<9870}>0l z7vx%;MlxVA3$h3vT>@ub*a-jLe?L62d>j-Qja#m_vrJWimvIAHds82P7QlBJjpnbx z{>~b?{2v;zbO!#oKaNv~+0sy2^kIsTu#sW}cwr_V9jp94XyCywED5Fiv@ej%c?$G# zAg_l}=o&O38C2(bp(xb?Y32m5CMZFtk+K~ElrE%=McmSnNH!+Cz>@-HX-2j-yez{E zZe1K}3)V=)pBUqnw_l_Ge|L}w;Q65cXrhhYEh4=Kt$;QHpa?$&00r&M)^(xAr~QD` z6cpVl6L7fzV0)7IOF}9r3~so)(FWUxAqmuRB(S*B1P_nPgo8^e;pORQ4XmhRdG%sOPdzdRt${gk?(v22ucy|+g(p_Q;`&1H>rJKCn*ii;`5kBl zeASH=a7_e2*P*NcUiU*~5bNaiT5WQiLa`Nn{8pMIOq+d@RkT$oj77{&$E+(9=vo8W2iLKMK8i zC`&i7-G3Db_R=&1TN}=%2wP(z-;n^-*=9&L$Ac^+f_(5}#u(`zu3FJbB>RIz0B`gQ z_M8B<*`tXva8rT>u!bP8LwEuZKu%GAD)6DoK-w9=8i6iT4AdP7+!p7B1e+Vyp$o8W zC}#;Qud%`!B!kyx7sI{<B!*W16}4Y;8du#^BxQT$-I0Ym^~0f=StPfhXh zf9lP5OLG|RG{i&?iX(;Urqy?YCP*4JD8bA1xMt0kHMpyy;Jm$?VT_8$m7l2Wsho>{>?V$14Lv zL}@R8-<8nqX5jAEhI5NWXhpa+P6^V%;Se7wyT8W@Rw_*o;%HZ(Z`uE6dIS#V%c z1-v>VpOp%80l}F!lmMt{iG2Jo_icxF_bi1CEtN0_HT|5@5?Ik#4iAj0gO?VJg|8o3 z4jV_;LXOUmdn1cxkObxlRzPn^fO~HY^bd=GIHekfq{+P~wr-&E+I zk_NO0bYg)K9vJ3i8G#kGR@gAa1#iwTg*Rpw!rP0>;q=3^S;No`1OE}EQUQx zN5h5Z7DAP*^MLsG})#2Lt&=7 zP#knEM39)60Dl{VU`>d*@XESzFg6d(ZnwkTZ3-_w{ukz0mCYCvITroBKp^NvJr)HhA{B@!sjc0;zy0M|IcA_^)B1kf4if+axD)9Ua7cQRWa-d?J*EKrG(q>4lm2t&e=ZS{tQ z{rCzcz`@)U477T@&we-&dhc^`oeL85?nT16B$IQXB*D6WP?C$e2n2ktO3-sv+CP+u z4+iVg;4g`3@T*7*n2dV3tHFU50OtmftV9ynGbtMmF0Mo?AP?SI)4;V6-ym0j2#EIo zJvg%wmN%Eco2#e7zjiN%54Vkhozp5|NLD%w$0a{E->%b_DNHK*>b4&p2v@ek20JJik3kF)a)!=L;xSeeg zZZCAc!S90FTsyiLN|2yCpp{DY>$Oo`_DaNuh5Z6Sdp4*95Ud>mT}F|Uy}yn&dOwUa zrCu`5DpK!SPVPa6Y(a{o=pfVvT$|AR|AY5Ug~t|;fOC&6MBjfp99UWeug))qZPS`y z=j2K_bD)Q!|i2 z0<AM5gsj-d}Y!||JsE`^#4&4PcR8UEs?y~w{_(y?g8;eSC{!twZY>R={%ndM&Jv( z1$sgNAuM)~3i+uvSX8cuyBpBgA8m*GhjSHyYa81LU~Qv=Wd-gX?t!-!l%Xq73~$Ww z!-=hv;LM|oZjc)=6Fzu!9-Mu2KI~s!1+Py_gE!~;VgIr!_1)LzmSxkr(z;X>(Smo()I*o0y*6;PNiieNoW-$u%I7Fwl%)(J}>lq9@{yX zz+wWWsmW+nL^Bddh>|VQtJS|F=~T{qBG`*UuiNm@u5PqpIMU!5Dbu;W9gJ?lAaV!V z7ybwq0^d}``Uxnupi6_nF$NftZiGdpP8fp>JR!#d3(9S*D)63WJ8T+ihYdsctU#q1 z_Dsx%LrbgB74XAb3rkp8FC&2)ln$g=#PO{Y;o$0eIC9TOIKO8ueDcgv7@CyH7;t74Kg%rtIvNSq-f(t{wX& zT0UREYpdZy1pl$^TqD)TPcDSL8z<4?lXF#>nZF_tu5C$F|F2pk`d0#L){zDLc>*T+ z_#}e4&%jK;Mj`*+hT54lJ=NrotS^OXe>&LlTr%$lnA%wh!h%q82ZR(Mx9n5HK9ei} z$^bBvKLt&GQw;Oz^Z8|=g6YrBAt6w{pSA{*Yr$;{QuC|G)Pa>`Y-Jc*Ii?D%Dx=qC zvDiU8SpX0xmprJCjtnCS^Z-aCcV1%;z?I&!=!XB8lF41rJI6|r9iI(OasrV-NV10s zxe63BV1i~p9se3@1C_z~%#i%NHzt?lzc98a_wl;a)NjhHcBr(OVRWVqW)@Q>fLs6) zE39j@!Hcu}@XnG-*gLlX-dJLxR$XX)ZOw&?FRy4tfp1?}4z$zp99ldl zJ2hXO+cOW2JTMK$7iK||&m|)X{2sLOJ2Ya+1tI_{;WhH+y$u0wN6k)wIWr>!DW}y@ z{5}gS;HjfpeLN1WDnzs2j$|QX;J@5@a1wV)+k((EehoQ&o;#Ue5!QZ9I3M6Ea3wPE z>RFmm#y~AB0==rmq5Mj6dY?c5#u#NNNgx9t62|BncJ}C)&OiB|4srN^zBRe($=8wYM#5C@CFRnDan|(|xGG zjAY<&z|b@YOfGPsbznj3zzVO-$%A)SSHR(=#c*&@5gc0Aj6cp9Y|yAMS}f>RL8tLy zWO*F9XB6z6=Z8b&3bjve4c9q(lu&X5(-rLZ`0-dLK zUwJp<+1+y)DNIMO);pbIl0ao2YQAXvVJ1Ya&7j7Ary8Qr1&CKj7k736qNUP;z9ImvNMt3sseV{dNzPlMOum6CV`_Aa0gWoX zH;R^!^z{8DCX=GdBtC-+s9r4QF=EVHuGH4Mk9e;IC>&0JJuXewaxr0;ZHj=~=|S9ca=R zK%>DDBVoRNMP4dIh2DvlfRz>ZaIt_0W<3a6zB^%c14t&RomYg@(Gbmm??+Rgz)!$$ zTMDWUxD9F72z*C^oYf>$fUFu(4%Qm6CQ zdXKXaN#Mykm*us&CFaN1H`;e?9pyXx)RZiE6D@;7OH1MCswz0Pt`UxH8pX_X3fggm zuz(30JW7o_ml^wYiOJ6kfr3b8-{MjR{=>^k;q2WttxFpVA=h9#efQ9^-+o{JzIAD7 zNL#UFV1vAS+*No2uwZY{1MbbDX@i)7jPnDLg(l?GW7|}owYZm|A+vxt#OcR zi{mtYyS3uiBJ|za>T>+I&~*yD1{hi6hkT!ttqOPO;-9~YA|Uebzv)eRuv#j;uiyXm z+p=nl^X?|+>20G@Vb6pNcz#+o?46s>6GAl{M?yG$&j>iaWgHtrF0}HJbwEFI0yYz# zB-ni-3SMa7=xH?jPi&vg`u*wJCs&ul=`|Iwq&fqZ1{~hZx(C*$q3!_+Zb(40w8S z2D~yO2M#PMg2T(p;lT1rIIyw?4z8+$gR2|h(AsA7<%hxH4I|*_rZI4A%LF+7z*IJ+ zn0ot<+>e6i-of`ATULzVuYl)g7sKQNA7mw)p()+%{!jTE)@P(O7Fivzqs0&Bw@=`D zFxm}eA@HByGatTqZV4_R>=iTeThUEEewS*%D1k1VaSz=|3xt1`TA zgcqJiA~>e0agS!}xl7xQ z^`-nwKW<>>aDHg#kg{B;r{*7j8dT+b*%&aA%3KeMn-e4!BA2Q>57Zz*Hxy?=Q+aNO zxqwXANU$7eq)}ja&Dw%AHYvC&Kb5_gu3KA}#)gX0cbYJ?imekb&rOF6yP0hfR1a|_|g$$7B0DGSEtr$Ld$fxx%# zY4Cbe{!{;Eq*Y2>-ZxwF)8XL4Quyc2iSWhq%UOot)wSbcX>%#md)-HxbGqMk;7Zi| zHASPC7!?-!1vUR9s#W0BCn0!DP>|+=id+P-KOI4q#YS+~krZXIqMwG695$YNWNlGE zMj;`LMgWd!M-rpzirY>5ZJYQj2%YCFk3vR3BT$C(Lg(0Z@fxG}_j1=R3kaPXf&@^W z>to+LNzF!rG0;bbg`J6$OYYT2%X(aoA1#p-UL)u)b{-3k7DenEw+OcY00O#6L_t&! z=)TI^hDMucy5Ck`V6^Pa(OLeTtG7bA-2o%gT`&Q)$m|jy%q;f7WWN{2<#=F3h6{%H zoKR-7vmjrw)j4rkx_j{dg}>FXeD5Esy}rW>ses_z z6twVDrPv;f{wOQoa!<0Jmp z8S9qW6JQ*~$L@fuD0LD@%Rzfc}TnS)~Q7wic@|K~{n zL0y$;{8epQ+MVMHGvs6PGE7ZrUSC71+tHZnP9Ea*4!RyoJ#Y3~Sw_Zh>wV6F4e9B> z5Avn|%N4J@-K>rL0f7L1|2wS(Pf{xXNJpbmdAm-d2uDfNspXB_I&fJn9cfLtupYc^ zRk(tGF0uxRr8H3~%kRmG@b+uMg%#l))`V*m_O5dJeRb2y<#(WEBvXsUQGDf~gwFi{ t{2vJ52Lkwk0DidraQor*!|n37{~x%~sn6&2FwX!0002ovPDHLkV1gq%=O_RG literal 0 HcmV?d00001 diff --git a/spine-libgdx/test/spineboy.skel b/spine-libgdx/test/spineboy.skel new file mode 100644 index 0000000000000000000000000000000000000000..71f85c3951b5c743381827bfba33026966cc1794 GIT binary patch literal 2209 zcmZvde`s4(6vxkNlcvpTv!yai*FTD|$<#oYbH-wp_iid%rJ#et5V15iuT5vx#3Y@a zR!lpboleCn*r|ickcrbd%fQg}$4fR;W>-6d;)=3XN8KN;mWnIg3iF=(a_>tXeehoH zIq!4sJ@=mPd2w1}kw^mg&iL~U0zs>W)=YCG~u zyMIvLUe&_U%BS^SJZ_ zo^xbh^|5vO8km)N3ex*si+9Hbu@w33_}}E=pT|oQkyt!}=c8RpF8Wq)B>ALdZ2k>$ z>STkpQ*C`-$H>WscPIW_uHuNVZTY71US+p6qy~bFQwB%Q$XDy9Igxg_Z;}3iQw}|| zcqq~p4yv)-bSI`ClCQko!(o5Xv46;}A78iYa3Hqd6h>b*k6X?do2Y&DEOD;34+gspFZPuUWPc_YaL_jHQVb2GLhf zjJ6Jmsg=2=O{C(LOS&j94G~D)DesU+pt7sxE5-Blye+DR4|K%w;C*M)liE-H;>@_n zon;Aie>5COs7&g2jvPGV#$k*+a9fLShfnnL9|fyy$7 zHPmlv24tDb#kB0At!U~mlW7F7-o=32N#%YJ$PM$fw?ab*L_Bc=5{mN zc`+hOUD5gz-|HjR6YPOL-D16h59VT)dQgqC9%3%EOu{#ri0Lj-YD4$N2r=ElYUedc z-VmAGabdxoAeF_V9i8fPk%PJp{r4H)GW7U2(EIZwNK&EJ0Fw|A*WNS$;$N=YdI zX#yycgz6~x!Y{kW=jIL27Q98ussB1av1F)^ei#*}=396v$@@}S+0u+8sRFR%NUSoA z&0OwPDz+|hQf~TWmh@5oB7jvgX^^@v9Jn@d({_mCB-=Mj>gmKufRY?8YD@9y+tm{b zm5Tz${|*bq4+GewoE`zR58sI@_glpG5zmYC(EBlfQYlZBbjHEDpkjOTI-k*ZeoV&M zFyAuCtVrq~*`;cmS2WI(t6$8KMm=FW=kqg8$q(*4q=}Ow_}Aj5{84~)lCDl_ZQBFd zA79t(=%~x&`$8o*AsGG7E5*#B@s|_D-g>l(k$yUrs$k zmZ((dDOD6%QPVWyuOpsJ@o;qkgfsn0mqWzW8ji%(Aoa|9Ff0k{dZcR M-z)&Zieg#+2OMPoSO5S3 literal 0 HcmV?d00001