Removed spine-lua, spine-solar2d, spine-love, spine-as3, and spine-starling.

These were deprecated in Spine 4.0 and are removed as of 4.1. This is because use of these runtimes has been declining over the years due to discontinuation of the products they are built upon, like Corona and Flash. We want to free up development resources to work on new features and new runtimes.

spine-as3/LICENSE

@@ -1,26 +0,0 @@
-Spine Runtimes License Agreement
-Last updated May 1, 2019. Replaces all prior versions.
-
-Copyright (c) 2013-2019, Esoteric Software LLC
-
-Integration of the Spine Runtimes into software or otherwise creating
-derivative works of the Spine Runtimes is permitted under the terms and
-conditions of Section 2 of the Spine Editor License Agreement:
-http://esotericsoftware.com/spine-editor-license
-
-Otherwise, it is permitted to integrate the Spine Runtimes into software
-or otherwise create derivative works of the Spine Runtimes (collectively,
-"Products"), provided that each user of the Products must obtain their own
-Spine Editor license and redistribution of the Products in any form must
-include this license and copyright notice.
-
-THIS SOFTWARE IS PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY EXPRESS
-OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
-OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
-NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, BUSINESS
-INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
-NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
-EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

spine-as3/README.md

@@ -1,47 +0,0 @@
-# spine-as3
-
-The spine-as3 runtime provides functionality to load and manipulate [Spine](http://esotericsoftware.com) skeletal animation data using Adobe's ActionScript 3.0 (AS3). The [`spine.flash` package](spine-as3/src/spine/flash) can be used to render Spine animations using Flash. spine-as3 can be extended to enable Spine animations for other AS3 projects, such as [Starling](../spine-starling).
-
-## Licensing
-
-You are welcome to evaluate the Spine Runtimes and the examples we provide in this repository free of charge.
-
-You can integrate the Spine Runtimes into your software free of charge, but users of your software must have their own [Spine license](https://esotericsoftware.com/spine-purchase). Please make your users aware of this requirement! This option is often chosen by those making development tools, such as an SDK, game toolkit, or software library.
-
-In order to distribute your software containing the Spine Runtimes to others that don't have a Spine license, you need a [Spine license](https://esotericsoftware.com/spine-purchase) at the time of integration. Then you can distribute your software containing the Spine Runtimes however you like, provided others don't modify it or use it to create new software. If others want to do that, they'll need their own Spine license.
-
-For the official legal terms governing the Spine Runtimes, please read the [Spine Runtimes License Agreement](http://esotericsoftware.com/spine-runtimes-license) and Section 2 of the [Spine Editor License Agreement](http://esotericsoftware.com/spine-editor-license#s2).
-
-## Spine version
-
-spine-as3 works with data exported from Spine 4.0.xx.
-
-spine-as3 supports all Spine features, including meshes. If using the `spine.flash` classes for rendering, meshes, clipping, and two color tinting are not supported.
-
-## Usage
-1. Create a new Flex or Adobe AIR project in your preferred IDE.
-2. Download the Spine Runtimes source using git (`git clone https://github.com/esotericsoftware/spine-runtimes`) or download it as a ZIP by clicking the download button above.
-3. Add the sources from `spine-as3/spine-as3/src/` to your project
-
-## Example
-The Spine AS3 example works on Windows, Linux and Mac OS X. This guide assumes you are using [Visual Studio Code](https://code.visualstudio.com/) together with the [ActionScript & MXML extension for Visual Studio Code](https://github.com/BowlerHatLLC/vscode-as3mxml/wiki) as your development environment.
-
-1. Install [Visual Studio Code](https://code.visualstudio.com/).
-2. Install the [ActionScript & MXML extension for Visual Studio Code](https://github.com/BowlerHatLLC/vscode-as3mxml/wiki).
-3. Download [Adobe Flash Player 32 projector content debugger](https://www.adobe.com/support/flashplayer/debug_downloads.html#fp15). On Windows, run it once to store its path.
-4. Download [Adobe AIR 32 SDK & Compiler](https://helpx.adobe.com/air/kb/archived-air-sdk-version.html) and extract it to a folder.
-
-To run the Flash example project `spine-as3-example`:
-
-1. Open the `spine-as3-example/` folder in Visual Studio Code.
-2. Set the AIR SDK location when prompted or by pressing `CTRL + SHIFT + P` (`CMD + SHIFT + P` on macOS) and choosing `>ActionScript: Select Workspace SDK`.
-3. Launch the `Launch Spine AS3 Example` launch configuration.
-
-Instead of directly adding the sources of from `spine-as3/src` to your project, you can also link the SWC file `spine-as3/lib/spine-as3.swc`. To (re-)compile this file yourself with Visual Studio Code:
-
-1. Open the `spine-as3/` folder in Visual Studio Code.
-2. Press `CTRL + SHIFT + B` (`CMD + SHIFT + B` on macOS) and select `ActionScript: compile release - asconfig.json`
-
-## Notes
-
-- Atlas images should not use premultiplied alpha.

spine-as3/spine-as3-example/.vscode/launch.json

@@ -1,11 +0,0 @@
-{
-	"version": "0.2.0",
-	"configurations": [
-		{
-			"type": "swf",
-			"request": "launch",
-			"name": "Launch spine-as3-example",
-			"preLaunchTask": "Compile debug"
-		}
-	]
-}

spine-as3/spine-as3-example/.vscode/tasks.json

@@ -1,10 +0,0 @@
-{
-	"version": "2.0.0",
-	"tasks": [
-		{
-			"label": "Compile debug",
-			"type": "actionscript",
-			"debug": true
-		}
-	]
-}

spine-as3/spine-as3-example/asconfig.json

@@ -1,18 +0,0 @@
-{
-	"compilerOptions": {
-		"output": "bin/spine-as3-example.swf",		
-		"source-path": [
-			"src",
-			"../spine-as3/src"
-		],
-		"default-size": {
-			"width": 550,
-			"height": 500
-		},
-		"target-player": "32.0",
-		"swf-version": 43		
-	},		
-	"files": [
-		"src/spine/examples/Main.as"
-	]
-}

spine-as3/spine-as3-example/src/spine/examples/Main.as

@@ -1,99 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine.examples {
-	import spine.animation.TrackEntry;
-	import flash.display.Sprite;
-
-	import spine.*;
-	import spine.animation.AnimationStateData;
-	import spine.atlas.Atlas;
-	import spine.attachments.AtlasAttachmentLoader;
-	import spine.flash.FlashTextureLoader;
-	import spine.flash.SkeletonAnimation;
-
-	[SWF(width = "800", height = "600", frameRate = "60", backgroundColor = "#dddddd")]
-	public class Main extends Sprite {
-		[Embed(source = "/spineboy-ess.json", mimeType = "application/octet-stream")]
-		static public const SpineboyJson : Class;
-
-		[Embed(source = "/spineboy.atlas", mimeType = "application/octet-stream")]
-		static public const SpineboyAtlas : Class;
-
-		[Embed(source = "/spineboy.png")]
-		static public const SpineboyAtlasTexture : Class;
-
-		private var skeleton : SkeletonAnimation;
-
-		public function Main() {
-			var atlas : Atlas = new Atlas(new SpineboyAtlas(), new FlashTextureLoader(new SpineboyAtlasTexture()));
-			var json : SkeletonJson = new SkeletonJson(new AtlasAttachmentLoader(atlas));
-			json.scale = 0.6;
-			var skeletonData : SkeletonData = json.readSkeletonData(new SpineboyJson());
-
-			var stateData : AnimationStateData = new AnimationStateData(skeletonData);
-			stateData.setMixByName("walk", "jump", 0.2);
-			stateData.setMixByName("jump", "run", 0.4);
-			stateData.setMixByName("jump", "jump", 0.2);
-
-			skeleton = new SkeletonAnimation(skeletonData, stateData);
-			skeleton.x = 400;
-			skeleton.y = 560;
-
-			skeleton.state.onStart.add(function(entry : TrackEntry) : void {
-				trace(entry.trackIndex + " start: " + entry.animation.name);
-			});
-			skeleton.state.onInterrupt.add(function(entry : TrackEntry) : void {
-				trace(entry.trackIndex + " interrupt: " + entry.animation.name);
-			});
-			skeleton.state.onEnd.add(function(entry : TrackEntry) : void {
-				trace(entry.trackIndex + " end: " + entry.animation.name);
-			});
-			skeleton.state.onComplete.add(function(entry : TrackEntry) : void {
-				trace(entry.trackIndex + " complete: " + entry.animation.name);
-			});
-			skeleton.state.onDispose.add(function(entry : TrackEntry) : void {
-				trace(entry.trackIndex + " dispose: " + entry.animation.name);
-			});
-			skeleton.state.onEvent.add(function(entry : TrackEntry, event : Event) : void {
-				trace(entry.trackIndex + " event: " + entry.animation.name + ", " + event.data.name + ": " + event.intValue + ", " + event.floatValue + ", " + event.stringValue);
-			});
-
-			if (false) {
-				skeleton.state.setAnimationByName(0, "test", true);
-			} else {
-				skeleton.state.setAnimationByName(0, "walk", true);
-				skeleton.state.addAnimationByName(0, "jump", false, 3);
-				skeleton.state.addAnimationByName(0, "run", true, 0);
-			}
-
-			addChild(skeleton);
-		}
-	}
-}

spine-as3/spine-as3-example/src/spineboy-ess.json

@@ -1,3672 +0,0 @@
-{
-"skeleton": {
-	"hash": "lS/mQzJwi+I",
-	"spine": "4.0.31",
-	"x": -221.27,
-	"y": -8.57,
-	"width": 470.72,
-	"height": 731.57,
-	"images": "./images/",
-	"audio": ""
-},
-"bones": [
-	{ "name": "root" },
-	{ "name": "hip", "parent": "root", "y": 247.47 },
-	{
-		"name": "torso",
-		"parent": "hip",
-		"length": 127.56,
-		"rotation": 103.82,
-		"x": -1.62,
-		"y": 4.9,
-		"color": "e0da19ff"
-	},
-	{
-		"name": "front-upper-arm",
-		"parent": "torso",
-		"length": 69.45,
-		"rotation": 168.38,
-		"x": 103.76,
-		"y": 19.33,
-		"color": "00ff04ff"
-	},
-	{
-		"name": "front-bracer",
-		"parent": "front-upper-arm",
-		"length": 40.57,
-		"rotation": 18.3,
-		"x": 68.8,
-		"y": -0.68,
-		"color": "00ff04ff"
-	},
-	{
-		"name": "front-fist",
-		"parent": "front-bracer",
-		"length": 65.39,
-		"rotation": 12.43,
-		"x": 40.57,
-		"y": 0.2,
-		"color": "00ff04ff"
-	},
-	{
-		"name": "front-thigh",
-		"parent": "hip",
-		"length": 74.81,
-		"rotation": -95.51,
-		"x": -17.46,
-		"y": -11.64,
-		"color": "00ff04ff"
-	},
-	{
-		"name": "front-shin",
-		"parent": "front-thigh",
-		"length": 128.77,
-		"rotation": -2.21,
-		"x": 78.69,
-		"y": 1.6,
-		"color": "00ff04ff"
-	},
-	{
-		"name": "front-foot",
-		"parent": "front-shin",
-		"length": 91.34,
-		"rotation": 77.91,
-		"x": 128.76,
-		"y": -0.34,
-		"color": "00ff04ff"
-	},
-	{
-		"name": "rear-upper-arm",
-		"parent": "torso",
-		"length": 51.94,
-		"rotation": -169.56,
-		"x": 92.36,
-		"y": -19.22,
-		"color": "ff000dff"
-	},
-	{ "name": "rear-bracer", "parent": "rear-upper-arm", "length": 34.56, "rotation": 23.15, "x": 51.36, "color": "ff000dff" },
-	{
-		"name": "gun",
-		"parent": "rear-bracer",
-		"length": 43.11,
-		"rotation": 5.35,
-		"x": 34.42,
-		"y": -0.45,
-		"color": "ff000dff"
-	},
-	{ "name": "gun-tip", "parent": "gun", "rotation": 6.83, "x": 201.05, "y": 52.14, "color": "ff000dff" },
-	{
-		"name": "neck",
-		"parent": "torso",
-		"length": 25.45,
-		"rotation": -31.54,
-		"x": 127.5,
-		"y": -0.31,
-		"color": "e0da19ff"
-	},
-	{
-		"name": "head",
-		"parent": "neck",
-		"length": 263.58,
-		"rotation": 23.18,
-		"x": 27.66,
-		"y": -0.26,
-		"color": "e0da19ff"
-	},
-	{
-		"name": "rear-thigh",
-		"parent": "hip",
-		"length": 85.72,
-		"rotation": -72.54,
-		"x": 8.91,
-		"y": -5.63,
-		"color": "ff000dff"
-	},
-	{
-		"name": "rear-shin",
-		"parent": "rear-thigh",
-		"length": 121.88,
-		"rotation": -19.83,
-		"x": 86.1,
-		"y": -1.33,
-		"color": "ff000dff"
-	},
-	{
-		"name": "rear-foot",
-		"parent": "rear-shin",
-		"length": 82.57,
-		"rotation": 69.3,
-		"x": 121.46,
-		"y": -0.76,
-		"color": "ff000dff"
-	}
-],
-"slots": [
-	{ "name": "rear-upper-arm", "bone": "rear-upper-arm", "attachment": "rear-upper-arm" },
-	{ "name": "rear-bracer", "bone": "rear-bracer", "attachment": "rear-bracer" },
-	{ "name": "gun", "bone": "gun", "attachment": "gun" },
-	{ "name": "rear-foot", "bone": "rear-foot", "attachment": "rear-foot" },
-	{ "name": "rear-thigh", "bone": "rear-thigh", "attachment": "rear-thigh" },
-	{ "name": "rear-shin", "bone": "rear-shin", "attachment": "rear-shin" },
-	{ "name": "neck", "bone": "neck", "attachment": "neck" },
-	{ "name": "torso", "bone": "torso", "attachment": "torso" },
-	{ "name": "front-upper-arm", "bone": "front-upper-arm", "attachment": "front-upper-arm" },
-	{ "name": "head", "bone": "head", "attachment": "head" },
-	{ "name": "eye", "bone": "head", "attachment": "eye-indifferent" },
-	{ "name": "front-thigh", "bone": "front-thigh", "attachment": "front-thigh" },
-	{ "name": "front-foot", "bone": "front-foot", "attachment": "front-foot" },
-	{ "name": "front-shin", "bone": "front-shin", "attachment": "front-shin" },
-	{ "name": "mouth", "bone": "head", "attachment": "mouth-smile" },
-	{ "name": "goggles", "bone": "head", "attachment": "goggles" },
-	{ "name": "front-bracer", "bone": "front-bracer", "attachment": "front-bracer" },
-	{ "name": "front-fist", "bone": "front-fist", "attachment": "front-fist-closed" },
-	{ "name": "muzzle", "bone": "gun-tip", "blend": "additive" },
-	{ "name": "head-bb", "bone": "head" }
-],
-"skins": [
-	{
-		"name": "default",
-		"attachments": {
-			"eye": {
-				"eye-indifferent": { "x": 85.72, "y": -28.18, "rotation": -70.63, "width": 93, "height": 89 },
-				"eye-surprised": { "x": 85.72, "y": -28.18, "rotation": -70.63, "width": 93, "height": 89 }
-			},
-			"front-bracer": {
-				"front-bracer": { "x": 12.03, "y": -1.68, "rotation": 79.6, "width": 58, "height": 80 }
-			},
-			"front-fist": {
-				"front-fist-closed": { "x": 35.5, "y": 6, "rotation": 67.16, "width": 75, "height": 82 },
-				"front-fist-open": { "x": 39.57, "y": 7.76, "rotation": 67.16, "width": 86, "height": 87 }
-			},
-			"front-foot": {
-				"front-foot": { "x": 29.52, "y": 7.84, "rotation": 18.69, "width": 126, "height": 69 }
-			},
-			"front-shin": {
-				"front-shin": { "x": 55.12, "y": -3.54, "rotation": 96.59, "width": 82, "height": 184 }
-			},
-			"front-thigh": {
-				"front-thigh": { "x": 42.48, "y": 4.45, "rotation": 84.87, "width": 45, "height": 112 }
-			},
-			"front-upper-arm": {
-				"front-upper-arm": { "x": 25.2, "y": 1.17, "rotation": 97.9, "width": 46, "height": 97 }
-			},
-			"goggles": {
-				"goggles": { "x": 97.08, "y": 6.54, "rotation": -70.63, "width": 261, "height": 166 }
-			},
-			"gun": {
-				"gun": { "x": 77.3, "y": 16.4, "rotation": 60.83, "width": 210, "height": 203 }
-			},
-			"head": {
-				"head": { "x": 128.96, "y": 0.3, "rotation": -70.63, "width": 271, "height": 298 }
-			},
-			"head-bb": {
-				"head": {
-					"type": "boundingbox",
-					"vertexCount": 6,
-					"vertices": [ -19.14, -70.3, 40.8, -118.07, 257.77, -115.62, 285.16, 57.18, 120.77, 164.95, -5.07, 76.95 ]
-				}
-			},
-			"mouth": {
-				"mouth-grind": { "x": 23.69, "y": -32.24, "rotation": -70.63, "width": 93, "height": 59 },
-				"mouth-oooo": { "x": 23.69, "y": -32.24, "rotation": -70.63, "width": 93, "height": 59 },
-				"mouth-smile": { "x": 23.69, "y": -32.24, "rotation": -70.63, "width": 93, "height": 59 }
-			},
-			"muzzle": {
-				"muzzle01": {
-					"x": 159.26,
-					"y": 5.83,
-					"scaleX": 4,
-					"scaleY": 4,
-					"rotation": 0.15,
-					"width": 133,
-					"height": 79
-				},
-				"muzzle02": {
-					"x": 191.23,
-					"y": 5.91,
-					"scaleX": 4,
-					"scaleY": 4,
-					"rotation": 0.15,
-					"width": 135,
-					"height": 84
-				},
-				"muzzle03": {
-					"x": 230.67,
-					"y": 6.02,
-					"scaleX": 4,
-					"scaleY": 4,
-					"rotation": 0.15,
-					"width": 166,
-					"height": 106
-				},
-				"muzzle04": {
-					"x": 218.54,
-					"y": 5.99,
-					"scaleX": 4,
-					"scaleY": 4,
-					"rotation": 0.15,
-					"width": 149,
-					"height": 90
-				}
-			},
-			"neck": {
-				"neck": { "x": 9.77, "y": -3.01, "rotation": -55.22, "width": 36, "height": 41 }
-			},
-			"rear-bracer": {
-				"rear-bracer": { "x": 11.15, "y": -2.2, "rotation": 66.17, "width": 56, "height": 72 }
-			},
-			"rear-foot": {
-				"rear-foot": { "x": 31.51, "y": 3.58, "rotation": 23.07, "width": 113, "height": 60 }
-			},
-			"rear-shin": {
-				"rear-shin": { "x": 58.29, "y": -2.75, "rotation": 92.37, "width": 75, "height": 178 }
-			},
-			"rear-thigh": {
-				"rear-thigh": { "x": 33.11, "y": -4.11, "rotation": 72.54, "width": 55, "height": 94 }
-			},
-			"rear-upper-arm": {
-				"rear-upper-arm": { "x": 21.13, "y": 4.09, "rotation": 89.33, "width": 40, "height": 87 }
-			},
-			"torso": {
-				"torso": { "x": 63.61, "y": 7.12, "rotation": -94.54, "width": 98, "height": 180 }
-			}
-		}
-	}
-],
-"events": {
-	"footstep": {}
-},
-"animations": {
-	"aim": {
-		"bones": {
-			"front-fist": {
-				"rotate": [
-					{ "value": 36.08 }
-				]
-			},
-			"rear-bracer": {
-				"rotate": [
-					{ "value": -26.55 }
-				]
-			},
-			"rear-upper-arm": {
-				"rotate": [
-					{ "value": 62.31 }
-				]
-			},
-			"front-bracer": {
-				"rotate": [
-					{ "value": 9.11 }
-				]
-			},
-			"gun": {
-				"rotate": [
-					{ "value": -0.31 }
-				]
-			}
-		}
-	},
-	"death": {
-		"slots": {
-			"eye": {
-				"attachment": [
-					{ "name": "eye-surprised" },
-					{ "time": 0.4667, "name": "eye-indifferent" },
-					{ "time": 2.2333, "name": "eye-surprised" },
-					{ "time": 4.5333, "name": "eye-indifferent" }
-				]
-			},
-			"front-fist": {
-				"attachment": [
-					{ "name": "front-fist-open" }
-				]
-			},
-			"mouth": {
-				"attachment": [
-					{ "name": "mouth-oooo" },
-					{ "time": 2.2333, "name": "mouth-grind" },
-					{ "time": 4.5333, "name": "mouth-oooo" }
-				]
-			}
-		},
-		"bones": {
-			"head": {
-				"rotate": [
-					{
-						"value": -2.83,
-						"curve": [ 0.044, -2.83, 0.105, -14.97 ]
-					},
-					{
-						"time": 0.1333,
-						"value": -21.89,
-						"curve": [ 0.158, -28.04, 0.2, -34.87 ]
-					},
-					{
-						"time": 0.2333,
-						"value": -34.87,
-						"curve": [ 0.267, -34.87, 0.3, -34.22 ]
-					},
-					{
-						"time": 0.3333,
-						"value": -33.33,
-						"curve": [ 0.356, -32.74, 0.374, -30.69 ]
-					},
-					{
-						"time": 0.4,
-						"value": -27.7,
-						"curve": [ 0.433, -23.82, 0.467, -10.64 ]
-					},
-					{
-						"time": 0.5,
-						"value": -10.64,
-						"curve": [ 0.522, -10.64, 0.544, -16.82 ]
-					},
-					{
-						"time": 0.5667,
-						"value": -23.05,
-						"curve": [ 0.589, -29.28, 0.611, -49.33 ]
-					},
-					{
-						"time": 0.6333,
-						"value": -55.92,
-						"curve": [ 0.678, -69.1, 0.722, -82.35 ]
-					},
-					{
-						"time": 0.7667,
-						"value": -82.35,
-						"curve": [ 0.787, -78.36, 0.912, -75.47 ]
-					},
-					{ "time": 1, "value": -78.9 },
-					{
-						"time": 2.2333,
-						"value": -78.72,
-						"curve": [ 2.289, -78.72, 2.345, -66.24 ]
-					},
-					{
-						"time": 2.4,
-						"value": -58.4,
-						"curve": [ 2.434, -53.72, 2.468, -52.12 ]
-					},
-					{
-						"time": 2.5,
-						"value": -51.96,
-						"curve": [ 2.683, -51.05, 2.856, -50.86 ]
-					},
-					{
-						"time": 3.0333,
-						"value": -50.86,
-						"curve": [ 3.343, -50.86, 3.712, -53.09 ]
-					},
-					{
-						"time": 3.9333,
-						"value": -55.94,
-						"curve": [ 4.2, -59.38, 4.463, -65.17 ]
-					},
-					{
-						"time": 4.5333,
-						"value": -69.07,
-						"curve": [ 4.598, -72.69, 4.635, -81.74 ]
-					},
-					{ "time": 4.6667, "value": -85.29 }
-				],
-				"scale": [
-					{
-						"time": 0.5,
-						"curve": [ 0.511, 1, 0.522, 1.041, 0.511, 1, 0.522, 0.953 ]
-					},
-					{
-						"time": 0.5333,
-						"x": 1.041,
-						"y": 0.953,
-						"curve": [ 0.556, 1.041, 0.589, 1.038, 0.544, 0.953, 0.589, 0.959 ]
-					},
-					{
-						"time": 0.6,
-						"x": 1.033,
-						"y": 0.966,
-						"curve": [ 0.633, 1.018, 0.667, 0.989, 0.633, 0.989, 0.667, 1.014 ]
-					},
-					{
-						"time": 0.7,
-						"x": 0.989,
-						"y": 1.014,
-						"curve": [ 0.733, 0.989, 0.8, 1, 0.733, 1.014, 0.8, 1 ]
-					},
-					{ "time": 0.8333 }
-				]
-			},
-			"neck": {
-				"rotate": [
-					{
-						"value": -2.83,
-						"curve": [ 0.033, -2.83, 0.1, 12.35 ]
-					},
-					{
-						"time": 0.1333,
-						"value": 12.35,
-						"curve": [ 0.158, 12.35, 0.267, 2.18 ]
-					},
-					{
-						"time": 0.3333,
-						"value": -8.48,
-						"curve": [ 0.389, -17.37, 0.444, -46.28 ]
-					},
-					{
-						"time": 0.5,
-						"value": -46.28,
-						"curve": [ 0.522, -46.28, 0.551, -12.18 ]
-					},
-					{
-						"time": 0.5667,
-						"value": -2.91,
-						"curve": [ 0.591, 11.16, 0.611, 20.82 ]
-					},
-					{
-						"time": 0.6333,
-						"value": 23.43,
-						"curve": [ 0.756, 37.76, 0.878, 47.9 ]
-					},
-					{
-						"time": 1,
-						"value": 47.91,
-						"curve": [ 1.411, 47.95, 1.935, 47.95 ]
-					},
-					{
-						"time": 2.2333,
-						"value": 47.95,
-						"curve": [ 2.322, 47.95, 2.432, 19.53 ]
-					},
-					{
-						"time": 2.5,
-						"value": 18.51,
-						"curve": [ 2.666, 16, 2.767, 14.59 ]
-					},
-					{
-						"time": 2.9,
-						"value": 14.59,
-						"curve": [ 3.156, 14.59, 3.425, 14.72 ]
-					},
-					{
-						"time": 3.6667,
-						"value": 15.23,
-						"curve": [ 4.026, 16, 4.28, 17.21 ]
-					},
-					{
-						"time": 4.4667,
-						"value": 18.51,
-						"curve": [ 4.527, 18.71, 4.61, 45.05 ]
-					},
-					{ "time": 4.6667, "value": 47.95 }
-				]
-			},
-			"torso": {
-				"rotate": [
-					{
-						"value": -8.62,
-						"curve": [ 0.031, -16.41, 0.1, -26.52 ]
-					},
-					{
-						"time": 0.1333,
-						"value": -26.52,
-						"curve": [ 0.167, -26.52, 0.233, 3.45 ]
-					},
-					{
-						"time": 0.2667,
-						"value": 21.92,
-						"curve": [ 0.326, 54.76, 0.422, 108.54 ]
-					},
-					{
-						"time": 0.5,
-						"value": 108.54,
-						"curve": [ 0.522, 108.54, 0.559, 79.42 ]
-					},
-					{
-						"time": 0.5667,
-						"value": 76.67,
-						"curve": [ 0.577, 72.83, 0.633, 68.68 ]
-					},
-					{
-						"time": 0.6667,
-						"value": 68.68,
-						"curve": [ 0.733, 68.68, 0.8, 74.71 ]
-					},
-					{ "time": 0.8667, "value": 74.71, "curve": "stepped" },
-					{
-						"time": 2.3333,
-						"value": 74.71,
-						"curve": [ 2.58, 74.71, 2.79, 72.33 ]
-					},
-					{
-						"time": 2.9667,
-						"value": 72,
-						"curve": [ 3.439, 71.12, 3.668, 70.89 ]
-					},
-					{
-						"time": 4,
-						"value": 71.29,
-						"curve": [ 4.189, 71.52, 4.286, 72.55 ]
-					},
-					{ "time": 4.6667, "value": 74.71 }
-				]
-			},
-			"front-upper-arm": {
-				"rotate": [
-					{
-						"value": -35.85,
-						"curve": [ 0.024, -41.49, 0.089, -48.72 ]
-					},
-					{
-						"time": 0.1333,
-						"value": -48.72,
-						"curve": [ 0.178, -48.72, 0.225, -18.52 ]
-					},
-					{
-						"time": 0.2667,
-						"value": -2.77,
-						"curve": [ 0.313, 14.63, 0.356, 29.38 ]
-					},
-					{
-						"time": 0.4,
-						"value": 42.91,
-						"curve": [ 0.411, 46.3, 0.422, 47.99 ]
-					},
-					{
-						"time": 0.4333,
-						"value": 47.99,
-						"curve": [ 0.456, 47.99, 0.482, 40.58 ]
-					},
-					{
-						"time": 0.5,
-						"value": 35.07,
-						"curve": [ 0.533, 24.91, 0.567, 12.21 ]
-					},
-					{
-						"time": 0.6,
-						"value": 12.36,
-						"curve": [ 0.633, 12.52, 0.667, 35.68 ]
-					},
-					{
-						"time": 0.7,
-						"value": 35.68,
-						"curve": [ 0.789, 35.68, 0.878, 20.08 ]
-					},
-					{ "time": 0.9667, "value": 12.28, "curve": "stepped" },
-					{ "time": 2.2333, "value": 12.28 },
-					{
-						"time": 2.5667,
-						"value": 64.63,
-						"curve": [ 2.589, 66.48, 2.611, 69.77 ]
-					},
-					{
-						"time": 2.6333,
-						"value": 70.2,
-						"curve": [ 2.756, 72.57, 2.878, 73.08 ]
-					},
-					{
-						"time": 3,
-						"value": 73.04,
-						"curve": [ 3.189, 72.97, 3.378, 69.18 ]
-					},
-					{
-						"time": 3.5667,
-						"value": 68.76,
-						"curve": [ 3.735, 68.38, 3.902, 72.6 ]
-					},
-					{
-						"time": 4.0667,
-						"value": 72.12,
-						"curve": [ 4.224, 71.68, 4.378, 72.12 ]
-					},
-					{
-						"time": 4.5333,
-						"value": 64.63,
-						"curve": [ 4.622, 60.34, 4.711, 42.63 ]
-					},
-					{ "time": 4.8, "value": 31.63 },
-					{ "time": 4.9333, "value": 10.72 }
-				]
-			},
-			"rear-upper-arm": {
-				"rotate": [
-					{
-						"value": -44.7,
-						"curve": [ 0.044, -44.7, 0.089, 52.3 ]
-					},
-					{
-						"time": 0.1333,
-						"value": 52.3,
-						"curve": [ 0.178, 52.3, 0.227, 48.52 ]
-					},
-					{
-						"time": 0.2667,
-						"value": 41.27,
-						"curve": [ 0.332, 29.13, 0.356, 21.33 ]
-					},
-					{
-						"time": 0.4,
-						"value": 21.33,
-						"curve": [ 0.511, 21.33, 0.577, 177.32 ]
-					},
-					{
-						"time": 0.6667,
-						"value": 178.37,
-						"curve": [ 0.703, 178.79, 0.822, 158.2 ]
-					},
-					{ "time": 0.9, "value": 158.2 }
-				],
-				"translate": [
-					{ "time": 0.4 },
-					{ "time": 0.9, "x": -32.41, "y": 0.65 }
-				]
-			},
-			"front-bracer": {
-				"rotate": [
-					{
-						"value": 21.88,
-						"curve": [ 0.048, 21.49, 0.089, 20.61 ]
-					},
-					{
-						"time": 0.1333,
-						"value": 11.49,
-						"curve": [ 0.156, 6.92, 0.178, -12.78 ]
-					},
-					{
-						"time": 0.2,
-						"value": -19.19,
-						"curve": [ 0.222, -25.6, 0.244, -26.96 ]
-					},
-					{
-						"time": 0.2667,
-						"value": -26.96,
-						"curve": [ 0.311, -26.96, 0.356, -25.04 ]
-					},
-					{
-						"time": 0.4,
-						"value": -15.9,
-						"curve": [ 0.433, -9.05, 0.467, 21.01 ]
-					},
-					{
-						"time": 0.5,
-						"value": 21.01,
-						"curve": [ 0.533, 21.01, 0.567, -6.78 ]
-					},
-					{
-						"time": 0.6,
-						"value": -18.23,
-						"curve": [ 0.622, -25.86, 0.644, -36.22 ]
-					},
-					{
-						"time": 0.6667,
-						"value": -36.22,
-						"curve": [ 0.689, -36.22, 0.72, 1.23 ]
-					},
-					{
-						"time": 0.7333,
-						"value": 10.31,
-						"curve": [ 0.761, 28.71, 0.822, 44.2 ]
-					},
-					{
-						"time": 0.8667,
-						"value": 44.2,
-						"curve": [ 0.911, 44.2, 1, -14.97 ]
-					},
-					{ "time": 1, "value": -18.88, "curve": "stepped" },
-					{
-						"time": 2.2333,
-						"value": -18.88,
-						"curve": [ 2.389, -18.88, 2.544, -1.96 ]
-					},
-					{
-						"time": 2.7,
-						"value": -1.96,
-						"curve": [ 2.811, -1.96, 2.923, -10.35 ]
-					},
-					{
-						"time": 3.0333,
-						"value": -10.35,
-						"curve": [ 3.224, -10.35, 3.411, -1.76 ]
-					},
-					{
-						"time": 3.6,
-						"value": -1.76,
-						"curve": [ 3.922, -1.76, 4.244, -1.96 ]
-					},
-					{
-						"time": 4.5667,
-						"value": -1.96,
-						"curve": [ 4.644, -1.96, 4.722, 34.31 ]
-					},
-					{
-						"time": 4.8,
-						"value": 34.31,
-						"curve": [ 4.844, 34.31, 4.889, -1.06 ]
-					},
-					{ "time": 4.9333, "value": -18.75 }
-				]
-			},
-			"front-fist": {
-				"rotate": [
-					{
-						"value": -2.33,
-						"curve": [ 0.044, -1.82, 0.089, -0.79 ]
-					},
-					{
-						"time": 0.1333,
-						"value": -0.79,
-						"curve": [ 0.178, -0.79, 0.222, -12.86 ]
-					},
-					{
-						"time": 0.2667,
-						"value": -12.86,
-						"curve": [ 0.322, -12.86, 0.378, -5.51 ]
-					},
-					{
-						"time": 0.4333,
-						"value": -5.51,
-						"curve": [ 0.522, -5.51, 0.611, -23.93 ]
-					},
-					{
-						"time": 0.7,
-						"value": -23.93,
-						"curve": [ 0.767, -23.93, 0.833, 6.31 ]
-					},
-					{
-						"time": 0.9,
-						"value": 6.31,
-						"curve": [ 0.978, 6.31, 1.114, -2.63 ]
-					},
-					{ "time": 1.1333, "value": -5.63, "curve": "stepped" },
-					{ "time": 2.2333, "value": -5.63 },
-					{ "time": 2.4333, "value": -17.37 },
-					{ "time": 2.7, "value": 5.73, "curve": "stepped" },
-					{
-						"time": 3.3667,
-						"value": 5.73,
-						"curve": [ 3.5, 5.73, 3.633, 1.93 ]
-					},
-					{
-						"time": 3.7667,
-						"value": 1.93,
-						"curve": [ 3.867, 1.93, 3.967, 7.13 ]
-					},
-					{
-						"time": 4.0667,
-						"value": 7.13,
-						"curve": [ 4.267, 7.13, 4.467, 5.73 ]
-					},
-					{
-						"time": 4.6667,
-						"value": 5.73,
-						"curve": [ 4.678, 5.73, 4.732, 13.73 ]
-					},
-					{
-						"time": 4.7667,
-						"value": 13.89,
-						"curve": [ 4.833, 14.19, 4.933, 4.95 ]
-					},
-					{ "time": 4.9333, "value": 3.65 }
-				]
-			},
-			"rear-bracer": {
-				"rotate": [
-					{ "value": 10.36 },
-					{ "time": 0.1333, "value": -23.12 },
-					{ "time": 0.2667, "value": -23.12 },
-					{ "time": 0.4, "value": -23.16, "curve": "stepped" },
-					{ "time": 0.4333, "value": -23.16 },
-					{ "time": 0.5667, "value": -23.2 }
-				]
-			},
-			"gun": {
-				"rotate": [
-					{ "value": -2.79 },
-					{ "time": 0.1333, "value": -24.58 }
-				]
-			},
-			"front-thigh": {
-				"rotate": [
-					{
-						"curve": [ 0.052, 4.38, 0.089, 28.31 ]
-					},
-					{
-						"time": 0.1333,
-						"value": 48.45,
-						"curve": [ 0.178, 68.6, 0.222, 99.39 ]
-					},
-					{
-						"time": 0.2667,
-						"value": 120.87,
-						"curve": [ 0.311, 142.34, 0.356, 169.02 ]
-					},
-					{
-						"time": 0.4,
-						"value": 177.3,
-						"curve": [ 0.433, 183.51, 0.467, 183.51 ]
-					},
-					{
-						"time": 0.5,
-						"value": 183.51,
-						"curve": [ 0.544, 183.51, 0.589, 176.55 ]
-					},
-					{
-						"time": 0.6333,
-						"value": 162.29,
-						"curve": [ 0.678, 148.03, 0.752, 108.37 ]
-					},
-					{
-						"time": 0.7667,
-						"value": 97.94,
-						"curve": [ 0.819, 105.34, 0.856, 110.74 ]
-					},
-					{
-						"time": 0.9,
-						"value": 110.74,
-						"curve": [ 0.944, 110.74, 1.016, 102.2 ]
-					},
-					{ "time": 1.0333, "value": 97.93 }
-				]
-			},
-			"front-shin": {
-				"rotate": [
-					{
-						"curve": [ 0.044, 0.09, 0.1, -7.14 ]
-					},
-					{
-						"time": 0.1333,
-						"value": -14.67,
-						"curve": [ 0.169, -22.83, 0.222, -43.77 ]
-					},
-					{
-						"time": 0.2667,
-						"value": -43.77,
-						"curve": [ 0.311, -43.77, 0.344, -43.27 ]
-					},
-					{
-						"time": 0.4,
-						"value": -33.94,
-						"curve": [ 0.433, -28.34, 0.467, 4.15 ]
-					},
-					{
-						"time": 0.5,
-						"value": 9.2,
-						"curve": [ 0.533, 14.25, 0.567, 14.25 ]
-					},
-					{
-						"time": 0.6,
-						"value": 14.25,
-						"curve": [ 0.733, 14.25, 0.867, 4.73 ]
-					},
-					{ "time": 1, "value": -0.03 }
-				]
-			},
-			"rear-thigh": {
-				"rotate": [
-					{
-						"curve": [ 0.044, 21.88, 0.089, 41.01 ]
-					},
-					{
-						"time": 0.1333,
-						"value": 65.64,
-						"curve": [ 0.178, 90.28, 0.222, 127.15 ]
-					},
-					{
-						"time": 0.2667,
-						"value": 147.79,
-						"curve": [ 0.311, 168.43, 0.356, 189.48 ]
-					},
-					{
-						"time": 0.4,
-						"value": 189.48,
-						"curve": [ 0.433, 189.48, 0.473, 161.8 ]
-					},
-					{
-						"time": 0.5,
-						"value": 142.56,
-						"curve": [ 0.542, 113.14, 0.589, 83.04 ]
-					},
-					{
-						"time": 0.6,
-						"value": 78.15,
-						"curve": [ 0.613, 83.04, 0.733, 108.16 ]
-					},
-					{
-						"time": 0.8,
-						"value": 108.16,
-						"curve": [ 0.878, 108.16, 1.009, 88.71 ]
-					},
-					{ "time": 1.0333, "value": 82.7 }
-				]
-			},
-			"rear-shin": {
-				"rotate": [
-					{
-						"curve": [ 0.044, -19.59, 0.089, -58.76 ]
-					},
-					{
-						"time": 0.1333,
-						"value": -58.76,
-						"curve": [ 0.178, -58.76, 0.222, -54.53 ]
-					},
-					{
-						"time": 0.2667,
-						"value": -47.85,
-						"curve": [ 0.311, -41.16, 0.356, -33.24 ]
-					},
-					{
-						"time": 0.4,
-						"value": -18.63,
-						"curve": [ 0.433, -7.68, 0.467, 28.83 ]
-					},
-					{
-						"time": 0.5,
-						"value": 28.83,
-						"curve": [ 0.533, 28.83, 0.567, 15.17 ]
-					},
-					{
-						"time": 0.6,
-						"value": 15.17,
-						"curve": [ 0.633, 15.17, 0.667, 16.17 ]
-					},
-					{
-						"time": 0.7,
-						"value": 18.37,
-						"curve": [ 0.744, 21.32, 0.789, 27.27 ]
-					},
-					{
-						"time": 0.8333,
-						"value": 30.61,
-						"curve": [ 0.878, 33.95, 0.922, 38.42 ]
-					},
-					{
-						"time": 0.9667,
-						"value": 38.42,
-						"curve": [ 1.011, 38.42, 1.079, 17.39 ]
-					},
-					{ "time": 1.1, "value": 9.11 }
-				]
-			},
-			"rear-foot": {
-				"rotate": [
-					{
-						"curve": [ 0.044, 0, 0.114, -5.44 ]
-					},
-					{
-						"time": 0.1333,
-						"value": -11.63,
-						"curve": [ 0.158, -19.61, 0.222, -57.59 ]
-					},
-					{
-						"time": 0.2667,
-						"value": -57.59,
-						"curve": [ 0.311, -57.59, 0.356, -45.6 ]
-					},
-					{
-						"time": 0.4,
-						"value": -45.6,
-						"curve": [ 0.433, -45.6, 0.467, -65.99 ]
-					},
-					{
-						"time": 0.5,
-						"value": -65.99,
-						"curve": [ 0.522, -65.99, 0.544, -21.7 ]
-					},
-					{
-						"time": 0.5667,
-						"value": -21.7,
-						"curve": [ 0.6, -21.7, 0.633, -47.61 ]
-					},
-					{
-						"time": 0.6667,
-						"value": -47.61,
-						"curve": [ 0.722, -47.61, 0.778, -25.68 ]
-					},
-					{
-						"time": 0.8333,
-						"value": -15.6,
-						"curve": [ 0.878, -7.54, 0.922, 6.79 ]
-					},
-					{
-						"time": 0.9667,
-						"value": 6.79,
-						"curve": [ 1.022, 6.79, 1.093, 2.23 ]
-					},
-					{
-						"time": 1.1333,
-						"value": -6.82,
-						"curve": [ 1.165, -13.89, 1.178, -28.53 ]
-					},
-					{
-						"time": 1.2,
-						"value": -28.53,
-						"curve": [ 1.267, -28.53, 1.333, -23.77 ]
-					},
-					{ "time": 1.4, "value": -23.77 }
-				]
-			},
-			"front-foot": {
-				"rotate": [
-					{
-						"curve": [ 0.022, -21.9, 0.044, -65.7 ]
-					},
-					{
-						"time": 0.0667,
-						"value": -65.7,
-						"curve": [ 0.089, -65.7, 0.111, -65.7 ]
-					},
-					{
-						"time": 0.1333,
-						"value": -64.65,
-						"curve": [ 0.222, -60.43, 0.311, -52.48 ]
-					},
-					{
-						"time": 0.4,
-						"value": -42.68,
-						"curve": [ 0.433, -39, 0.467, -33.17 ]
-					},
-					{
-						"time": 0.5,
-						"value": -24.22,
-						"curve": [ 0.544, -12.29, 0.589, 19.98 ]
-					},
-					{
-						"time": 0.6333,
-						"value": 19.98,
-						"curve": [ 0.656, 19.98, 0.678, 13.2 ]
-					},
-					{
-						"time": 0.7,
-						"value": 2.45,
-						"curve": [ 0.733, -13.69, 0.767, -60.68 ]
-					},
-					{
-						"time": 0.8,
-						"value": -60.68,
-						"curve": [ 0.878, -60.68, 0.956, 0.38 ]
-					},
-					{
-						"time": 1.0333,
-						"value": 0.38,
-						"curve": [ 1.078, 0.38, 1.122, -31.77 ]
-					},
-					{
-						"time": 1.1667,
-						"value": -31.77,
-						"curve": [ 1.211, -31.77, 1.256, -26.74 ]
-					},
-					{ "time": 1.3, "value": -24.22 }
-				]
-			},
-			"hip": {
-				"translate": [
-					{
-						"curve": [ 0.081, -41.14, 0.178, -93.27, 0.038, 78.73, 0.156, 168.49 ]
-					},
-					{
-						"time": 0.2667,
-						"x": -137.74,
-						"y": 169.66,
-						"curve": [ 0.333, -171.09, 0.4, -202.84, 0.377, 170.82, 0.467, 29.16 ]
-					},
-					{
-						"time": 0.4667,
-						"x": -233.47,
-						"y": -76.63,
-						"curve": [ 0.5, -248.79, 0.533, -265.16, 0.521, -158.34, 0.516, -167.9 ]
-					},
-					{
-						"time": 0.5667,
-						"x": -275.61,
-						"y": -209.28,
-						"curve": [ 0.589, -282.57, 0.608, -285.14, 0.572, -213.87, 0.611, -216.23 ]
-					},
-					{
-						"time": 0.6333,
-						"x": -285.69,
-						"y": -216.23,
-						"curve": [ 0.713, -287.45, 0.789, -288.08, 0.711, -216.23, 0.812, -213.49 ]
-					},
-					{
-						"time": 0.8667,
-						"x": -288.44,
-						"y": -209.28,
-						"curve": [ 0.911, -288.65, 0.965, -288.65, 0.919, -209.28, 0.967, -209.28 ]
-					},
-					{ "time": 1, "x": -288.65, "y": -209.28 }
-				]
-			}
-		}
-	},
-	"hit": {
-		"slots": {
-			"front-fist": {
-				"attachment": [
-					{ "time": 0.1667, "name": "front-fist-open" }
-				]
-			},
-			"mouth": {
-				"attachment": [
-					{ "name": "mouth-grind" },
-					{ "time": 0.3333, "name": "mouth-smile" }
-				]
-			}
-		},
-		"bones": {
-			"torso": {
-				"rotate": [
-					{ "value": 56.42 },
-					{ "time": 0.3333, "value": 8.89 }
-				]
-			},
-			"neck": {
-				"rotate": [
-					{ "value": 35.39 },
-					{ "time": 0.2333, "value": 24.95 }
-				]
-			},
-			"head": {
-				"rotate": [
-					{ "value": 10.22 },
-					{ "time": 0.3333, "value": -41.3 }
-				]
-			},
-			"front-upper-arm": {
-				"rotate": [
-					{
-						"value": -310.93,
-						"curve": [ 0.127, -397.15, 0.248, -472.6 ]
-					},
-					{ "time": 0.3333, "value": -472.6 }
-				],
-				"translate": [
-					{ "x": 7.23, "y": -13.13 }
-				]
-			},
-			"front-bracer": {
-				"rotate": [
-					{ "value": 36.99 },
-					{ "time": 0.3333, "value": -28.65 }
-				]
-			},
-			"front-fist": {
-				"rotate": [
-					{ "value": 13.59 },
-					{ "time": 0.3333, "value": 7.56 }
-				]
-			},
-			"rear-upper-arm": {
-				"rotate": [
-					{
-						"value": 271.02,
-						"curve": [ 0.114, 297.63, 0.227, 322.97 ]
-					},
-					{ "time": 0.3333, "value": 344.16 }
-				],
-				"translate": [
-					{ "time": 0.3333, "x": -0.1, "y": -0.46 }
-				]
-			},
-			"rear-bracer": {
-				"rotate": [
-					{},
-					{ "time": 0.3333, "value": 40.03 }
-				]
-			},
-			"gun": {
-				"rotate": [
-					{ "value": 14.98 },
-					{ "time": 0.3333, "value": 39.76 }
-				]
-			},
-			"front-thigh": {
-				"rotate": [
-					{
-						"value": 90.94,
-						"curve": [ 0.076, 75.29, 0.144, 32.03 ]
-					},
-					{ "time": 0.3333, "value": 32.03 }
-				],
-				"translate": [
-					{ "x": 7.21, "y": -4 }
-				]
-			},
-			"rear-thigh": {
-				"rotate": [
-					{
-						"value": 40.52,
-						"curve": [ 0.099, 55.81, 0.197, 90.52 ]
-					},
-					{ "time": 0.3333, "value": 90.77 }
-				],
-				"translate": [
-					{ "x": -1.96, "y": -0.32 }
-				]
-			},
-			"front-shin": {
-				"rotate": [
-					{ "value": -96.63 },
-					{ "time": 0.3333, "value": -15.13 }
-				]
-			},
-			"rear-shin": {
-				"rotate": [
-					{ "value": 8 },
-					{ "time": 0.3333, "value": -67.54 }
-				]
-			},
-			"front-foot": {
-				"rotate": [
-					{ "value": 5.4 },
-					{ "time": 0.3333, "value": -16.27 }
-				]
-			},
-			"rear-foot": {
-				"rotate": [
-					{ "value": 2.67 },
-					{ "time": 0.3333, "value": -10.31 }
-				]
-			},
-			"hip": {
-				"translate": [
-					{ "x": -75.55, "y": -78.04 },
-					{ "time": 0.2333, "x": -36.48, "y": 12.42 },
-					{ "time": 0.3333, "x": -36.48, "y": -3 }
-				]
-			}
-		}
-	},
-	"idle": {
-		"slots": {
-			"front-fist": {
-				"attachment": [
-					{ "name": "front-fist-open" }
-				]
-			}
-		},
-		"bones": {
-			"torso": {
-				"rotate": [
-					{
-						"value": -16.11,
-						"curve": [ 0.057, -15.7, 0.268, -14.61 ]
-					},
-					{
-						"time": 0.4333,
-						"value": -14.6,
-						"curve": [ 0.591, -14.59, 0.73, -15.81 ]
-					},
-					{
-						"time": 0.8333,
-						"value": -16.63,
-						"curve": [ 0.915, -17.27, 1.074, -18.04 ]
-					},
-					{
-						"time": 1.2333,
-						"value": -18.02,
-						"curve": [ 1.385, -18, 1.619, -16.57 ]
-					},
-					{ "time": 1.6667, "value": -16.11 }
-				],
-				"translate": [
-					{ "x": -6.5 }
-				],
-				"scale": [
-					{
-						"curve": [ 0.156, 0.996, 0.525, 0.994, 0.106, 1.002, 0.525, 1.01 ]
-					},
-					{
-						"time": 0.8333,
-						"x": 0.994,
-						"y": 1.01,
-						"curve": [ 1.15, 0.994, 1.52, 0.997, 1.15, 1.01, 1.519, 1.004 ]
-					},
-					{ "time": 1.6667 }
-				]
-			},
-			"front-upper-arm": {
-				"rotate": [
-					{
-						"value": -59.85,
-						"curve": [ 0.329, -59.85, 0.447, -64.99 ]
-					},
-					{
-						"time": 0.6667,
-						"value": -64.99,
-						"curve": [ 0.997, -64.99, 1.417, -59.85 ]
-					},
-					{ "time": 1.6667, "value": -59.85 }
-				],
-				"translate": [
-					{
-						"x": -7.12,
-						"y": -8.24,
-						"curve": [ 0.167, -7.12, 0.5, -3.66, 0.167, -8.24, 0.5, -5.93 ]
-					},
-					{
-						"time": 0.6667,
-						"x": -3.66,
-						"y": -5.93,
-						"curve": [ 0.917, -3.66, 1.417, -7.12, 0.917, -5.93, 1.417, -8.24 ]
-					},
-					{ "time": 1.6667, "x": -7.12, "y": -8.24 }
-				]
-			},
-			"rear-upper-arm": {
-				"rotate": [
-					{
-						"value": 39.08,
-						"curve": [ 0.37, 38.67, 0.55, 32.29 ]
-					},
-					{
-						"time": 0.7333,
-						"value": 32.29,
-						"curve": [ 0.967, 32.29, 1.433, 39.08 ]
-					},
-					{ "time": 1.6667, "value": 39.08 }
-				],
-				"translate": [
-					{
-						"x": -1.83,
-						"y": -6.48,
-						"curve": [ 0.167, -1.83, 0.5, 0.35, 0.167, -6.48, 0.447, -4.92 ]
-					},
-					{
-						"time": 0.6667,
-						"x": 0.35,
-						"y": -4.92,
-						"curve": [ 0.917, 0.35, 1.417, -1.83, 0.917, -4.92, 1.417, -6.48 ]
-					},
-					{ "time": 1.6667, "x": -1.83, "y": -6.48 }
-				]
-			},
-			"neck": {
-				"rotate": [
-					{
-						"curve": [ 0.167, 0, 0.5, 2.39 ]
-					},
-					{
-						"time": 0.6667,
-						"value": 2.39,
-						"curve": [ 0.917, 2.39, 1.417, 0 ]
-					},
-					{ "time": 1.6667 }
-				],
-				"translate": [
-					{ "x": -1.89, "y": -4.76 }
-				]
-			},
-			"front-thigh": {
-				"rotate": [
-					{
-						"value": 0.65,
-						"curve": [ 0.157, 0.6, 0.372, -4.31 ]
-					},
-					{
-						"time": 0.6667,
-						"value": -4.34,
-						"curve": [ 1.262, -4.34, 1.32, 0.65 ]
-					},
-					{ "time": 1.6667, "value": 0.65 }
-				],
-				"translate": [
-					{ "x": -13.4, "y": 6.7 }
-				],
-				"scale": [
-					{
-						"x": 0.945,
-						"curve": [ 0.157, 0.945, 0.372, 0.917, 0.157, 1, 0.372, 1 ]
-					},
-					{
-						"time": 0.6667,
-						"x": 0.917,
-						"curve": [ 1.262, 0.917, 1.32, 0.945, 1.262, 1, 1.32, 1 ]
-					},
-					{ "time": 1.6667, "x": 0.945 }
-				]
-			},
-			"front-shin": {
-				"rotate": [
-					{ "value": -19.59 }
-				],
-				"scale": [
-					{
-						"curve": [ 0.157, 1, 0.372, 0.994, 0.157, 1, 0.372, 1 ]
-					},
-					{
-						"time": 0.6667,
-						"x": 0.994,
-						"curve": [ 1.262, 0.994, 1.32, 1, 1.262, 1, 1.32, 1 ]
-					},
-					{ "time": 1.6667 }
-				]
-			},
-			"rear-thigh": {
-				"rotate": [
-					{
-						"value": 30.51,
-						"curve": [ 0.157, 30.6, 0.372, 40.09 ]
-					},
-					{
-						"time": 0.6667,
-						"value": 40.15,
-						"curve": [ 1.262, 40.14, 1.32, 30.51 ]
-					},
-					{ "time": 1.6667, "value": 30.51 }
-				]
-			},
-			"rear-shin": {
-				"rotate": [
-					{
-						"value": -24.14,
-						"curve": [ 0.157, -24.33, 0.372, -43.64 ]
-					},
-					{
-						"time": 0.6667,
-						"value": -43.77,
-						"curve": [ 1.262, -43.76, 1.32, -23.83 ]
-					},
-					{ "time": 1.6667, "value": -23.83 }
-				]
-			},
-			"front-foot": {
-				"rotate": [
-					{
-						"value": 4.83,
-						"curve": [ 0.157, 4.88, 0.372, 10.02 ]
-					},
-					{
-						"time": 0.6667,
-						"value": 10.05,
-						"curve": [ 1.262, 10.05, 1.32, 5.14 ]
-					},
-					{ "time": 1.6667, "value": 5.14 }
-				],
-				"scale": [
-					{ "x": 0.755, "y": 1.31 }
-				]
-			},
-			"rear-foot": {
-				"rotate": [
-					{
-						"value": -7.65,
-						"curve": [ 0.157, -7.54, 0.372, 3.78 ]
-					},
-					{
-						"time": 0.6667,
-						"value": 3.85,
-						"curve": [ 1.262, 3.84, 1.32, -7.34 ]
-					},
-					{ "time": 1.6667, "value": -7.34 }
-				]
-			},
-			"rear-bracer": {
-				"rotate": [
-					{
-						"value": -17.16,
-						"curve": [ 0.167, -17.16, 0.447, -4.1 ]
-					},
-					{
-						"time": 0.6667,
-						"value": -4.1,
-						"curve": [ 0.997, -4.1, 1.417, -17.16 ]
-					},
-					{ "time": 1.6667, "value": -17.16 }
-				]
-			},
-			"head": {
-				"rotate": [
-					{
-						"value": -5.51,
-						"curve": [ 0.167, -5.51, 0.7, -3.12 ]
-					},
-					{
-						"time": 0.8667,
-						"value": -3.12,
-						"curve": [ 1.117, -3.12, 1.417, -5.51 ]
-					},
-					{ "time": 1.6667, "value": -5.51 }
-				],
-				"scale": [
-					{
-						"curve": [ 0.217, 1, 0.546, 0.996, 0.217, 1, 0.546, 1.007 ]
-					},
-					{
-						"time": 0.8667,
-						"x": 0.996,
-						"y": 1.007,
-						"curve": [ 1.171, 0.996, 1.467, 1, 1.171, 1.007, 1.467, 1 ]
-					},
-					{ "time": 1.6667 }
-				]
-			},
-			"front-bracer": {
-				"rotate": [
-					{
-						"value": 35.2,
-						"curve": [ 0.086, 36.03, 0.514, 40.31 ]
-					},
-					{
-						"time": 0.6667,
-						"value": 40.3,
-						"curve": [ 0.859, 40.29, 0.969, 32.24 ]
-					},
-					{
-						"time": 1.2,
-						"value": 32.31,
-						"curve": [ 1.401, 32.37, 1.561, 34.14 ]
-					},
-					{ "time": 1.6667, "value": 35.2 }
-				]
-			},
-			"gun": {
-				"rotate": [
-					{
-						"curve": [ 0.167, 0, 0.581, -12.7 ]
-					},
-					{
-						"time": 0.8667,
-						"value": -12.7,
-						"curve": [ 1.131, -12.7, 1.437, -0.11 ]
-					},
-					{ "time": 1.6667 }
-				]
-			},
-			"front-fist": {
-				"rotate": [
-					{
-						"value": -6.85,
-						"curve": [ 0.181, -5.23, 0.5, -3.97 ]
-					},
-					{
-						"time": 0.6667,
-						"value": -3.89,
-						"curve": [ 0.84, -3.81, 1.042, -9.89 ]
-					},
-					{
-						"time": 1.2667,
-						"value": -9.76,
-						"curve": [ 1.428, -9.66, 1.537, -8.3 ]
-					},
-					{ "time": 1.6667, "value": -6.85 }
-				],
-				"scale": [
-					{
-						"curve": [ 0.167, 1, 0.5, 0.886, 0.167, 1, 0.5, 1.101 ]
-					},
-					{
-						"time": 0.6667,
-						"x": 0.886,
-						"y": 1.101,
-						"curve": [ 0.917, 0.886, 1.417, 1, 0.917, 1.101, 1.417, 1 ]
-					},
-					{ "time": 1.6667 }
-				]
-			},
-			"hip": {
-				"translate": [
-					{
-						"x": -6.64,
-						"y": -23.02,
-						"curve": [ 0.157, -6.51, 0.372, 6.19, 0.157, -23.13, 0.372, -34.93 ]
-					},
-					{
-						"time": 0.6667,
-						"x": 6.28,
-						"y": -35.01,
-						"curve": [ 1.262, 6.27, 1.32, -6.64, 1.262, -35, 1.32, -23.02 ]
-					},
-					{ "time": 1.6667, "x": -6.64, "y": -23.02 }
-				]
-			}
-		}
-	},
-	"jump": {
-		"slots": {
-			"front-fist": {
-				"attachment": [
-					{ "name": "front-fist-open" },
-					{ "time": 0.1, "name": "front-fist-closed" },
-					{ "time": 0.8333, "name": "front-fist-open" }
-				]
-			}
-		},
-		"bones": {
-			"front-thigh": {
-				"rotate": [
-					{
-						"value": 55.08,
-						"curve": [ 0.007, 46.66, 0.043, 26.3 ]
-					},
-					{
-						"time": 0.0667,
-						"value": 22.84,
-						"curve": [ 0.1, 17.99, 0.165, 15.78 ]
-					},
-					{
-						"time": 0.2333,
-						"value": 15.71,
-						"curve": [ 0.309, 15.63, 0.411, 36.56 ]
-					},
-					{
-						"time": 0.5,
-						"value": 36.56,
-						"curve": [ 0.656, 36.56, 0.811, 33.41 ]
-					},
-					{
-						"time": 0.9667,
-						"value": 26.43,
-						"curve": [ 1.011, 24.43, 1.056, 9.63 ]
-					},
-					{
-						"time": 1.1,
-						"value": 9.63,
-						"curve": [ 1.122, 9.63, 1.144, 9.63 ]
-					},
-					{
-						"time": 1.1667,
-						"value": 12.33,
-						"curve": [ 1.178, 13.68, 1.189, 47.62 ]
-					},
-					{
-						"time": 1.2,
-						"value": 56.85,
-						"curve": [ 1.211, 66.08, 1.222, 67.7 ]
-					},
-					{
-						"time": 1.2333,
-						"value": 67.72,
-						"curve": [ 1.261, 67.77, 1.322, 58.12 ]
-					},
-					{ "time": 1.3333, "value": 55.08 }
-				],
-				"translate": [
-					{
-						"x": -5.13,
-						"y": 11.55,
-						"curve": [ 0.422, -5.13, 0.733, -5.25, 0.422, 11.55, 0.733, 11.55 ]
-					},
-					{
-						"time": 1.1,
-						"x": -5.25,
-						"y": 11.55,
-						"curve": [ 1.133, -5.25, 1.167, -4.54, 1.133, 11.55, 1.167, -1.07 ]
-					},
-					{
-						"time": 1.2,
-						"x": -3.98,
-						"y": -1.07,
-						"curve": [ 1.211, -3.79, 1.222, -3.62, 1.211, -1.07, 1.222, 5.22 ]
-					},
-					{
-						"time": 1.2333,
-						"x": -3.5,
-						"y": 5.73,
-						"curve": [ 1.245, -3.37, 1.289, -3.68, 1.245, 6.24, 1.283, 5.14 ]
-					},
-					{
-						"time": 1.3,
-						"x": -4.1,
-						"y": 5.23,
-						"curve": [ 1.311, -4.52, 1.322, -4.99, 1.32, 5.32, 1.322, 9.78 ]
-					},
-					{ "time": 1.3333, "x": -5.13, "y": 11.55 }
-				]
-			},
-			"torso": {
-				"rotate": [
-					{
-						"value": -45.57,
-						"curve": [ 0.022, -44.61, 0.03, -39.06 ]
-					},
-					{
-						"time": 0.0667,
-						"value": -35.29,
-						"curve": [ 0.12, -29.77, 0.28, -19.95 ]
-					},
-					{
-						"time": 0.4333,
-						"value": -19.95,
-						"curve": [ 0.673, -19.95, 0.871, -22.38 ]
-					},
-					{
-						"time": 0.9667,
-						"value": -27.08,
-						"curve": [ 1.094, -33.33, 1.176, -44.93 ]
-					},
-					{ "time": 1.3333, "value": -45.57 }
-				],
-				"translate": [
-					{ "x": -3.79, "y": -0.77 }
-				]
-			},
-			"rear-thigh": {
-				"rotate": [
-					{
-						"value": 12.81,
-						"curve": [ 0.067, 12.81, 0.242, 67.88 ]
-					},
-					{
-						"time": 0.2667,
-						"value": 74.11,
-						"curve": [ 0.314, 86.02, 0.454, 92.23 ]
-					},
-					{
-						"time": 0.5667,
-						"value": 92.24,
-						"curve": [ 0.753, 92.26, 0.966, 67.94 ]
-					},
-					{
-						"time": 1,
-						"value": 61.32,
-						"curve": [ 1.039, 53.75, 1.218, 12.68 ]
-					},
-					{ "time": 1.3333, "value": 12.81 }
-				]
-			},
-			"rear-shin": {
-				"rotate": [
-					{
-						"value": -115.64,
-						"curve": [ 0.067, -117.17, 0.125, -117.15 ]
-					},
-					{
-						"time": 0.1667,
-						"value": -117.15,
-						"curve": [ 0.225, -117.15, 0.332, -108.76 ]
-					},
-					{
-						"time": 0.4,
-						"value": -107.15,
-						"curve": [ 0.48, -105.26, 0.685, -103.49 ]
-					},
-					{
-						"time": 0.7667,
-						"value": -101.97,
-						"curve": [ 0.826, -100.87, 0.919, -92.3 ]
-					},
-					{
-						"time": 1,
-						"value": -92.28,
-						"curve": [ 1.113, -92.26, 1.297, -114.22 ]
-					},
-					{ "time": 1.3333, "value": -115.64 }
-				]
-			},
-			"front-upper-arm": {
-				"rotate": [
-					{
-						"value": -40.21,
-						"curve": [ 0.054, -35.46, 0.15, -31.12 ]
-					},
-					{
-						"time": 0.2,
-						"value": -31.12,
-						"curve": [ 0.308, -31.12, 0.547, -80.12 ]
-					},
-					{
-						"time": 0.6333,
-						"value": -96.56,
-						"curve": [ 0.697, -108.56, 0.797, -112.54 ]
-					},
-					{
-						"time": 0.8667,
-						"value": -112.6,
-						"curve": [ 1.137, -112.84, 1.274, -49.19 ]
-					},
-					{ "time": 1.3333, "value": -40.21 }
-				]
-			},
-			"front-bracer": {
-				"rotate": [
-					{
-						"value": 20.54,
-						"curve": [ 0.054, 32.23, 0.192, 55.84 ]
-					},
-					{
-						"time": 0.2333,
-						"value": 62.58,
-						"curve": [ 0.29, 71.87, 0.375, 79.28 ]
-					},
-					{
-						"time": 0.4333,
-						"value": 79.18,
-						"curve": [ 0.555, 78.98, 0.684, 27.54 ]
-					},
-					{
-						"time": 0.7333,
-						"value": 13.28,
-						"curve": [ 0.786, -1.85, 0.874, -24.76 ]
-					},
-					{
-						"time": 1,
-						"value": -25.45,
-						"curve": [ 1.165, -26.36, 1.303, 9.1 ]
-					},
-					{ "time": 1.3333, "value": 20.54 }
-				]
-			},
-			"front-fist": {
-				"rotate": [
-					{
-						"value": -36.16,
-						"curve": [ 0.114, -39.59, 0.3, -45.61 ]
-					},
-					{
-						"time": 0.4,
-						"value": -45.61,
-						"curve": [ 0.442, -45.61, 0.537, -21.54 ]
-					},
-					{
-						"time": 0.5667,
-						"value": -15.4,
-						"curve": [ 0.592, -10.23, 0.692, 11.89 ]
-					},
-					{
-						"time": 0.7333,
-						"value": 11.73,
-						"curve": [ 0.783, 11.54, 0.831, 1.8 ]
-					},
-					{
-						"time": 0.8667,
-						"value": -5.78,
-						"curve": [ 0.897, -12.22, 0.901, -14.22 ]
-					},
-					{
-						"time": 0.9333,
-						"value": -14.51,
-						"curve": [ 0.974, -14.89, 0.976, 10.38 ]
-					},
-					{
-						"time": 1,
-						"value": 10.55,
-						"curve": [ 1.027, 10.74, 1.023, -8.44 ]
-					},
-					{
-						"time": 1.0333,
-						"value": -8.42,
-						"curve": [ 1.059, -8.36, 1.074, 10.12 ]
-					},
-					{
-						"time": 1.1,
-						"value": 10.22,
-						"curve": [ 1.168, 10.48, 1.27, -36.07 ]
-					},
-					{ "time": 1.3333, "value": -36.16 }
-				]
-			},
-			"rear-upper-arm": {
-				"rotate": [
-					{
-						"value": 40.5,
-						"curve": [ 0.048, 36.1, 0.168, 20.45 ]
-					},
-					{
-						"time": 0.3,
-						"value": 20.45,
-						"curve": [ 0.476, 20.45, 0.571, 33.76 ]
-					},
-					{
-						"time": 0.6,
-						"value": 38.67,
-						"curve": [ 0.642, 45.8, 0.681, 57.44 ]
-					},
-					{
-						"time": 0.7333,
-						"value": 62.91,
-						"curve": [ 0.829, 72.8, 0.996, 77.61 ]
-					},
-					{
-						"time": 1.0333,
-						"value": 80.37,
-						"curve": [ 1.082, 83.94, 1.148, 90.6 ]
-					},
-					{
-						"time": 1.2,
-						"value": 90.6,
-						"curve": [ 1.248, 90.46, 1.289, 44.58 ]
-					},
-					{ "time": 1.3333, "value": 40.5 }
-				]
-			},
-			"rear-bracer": {
-				"rotate": [
-					{
-						"value": 28.28,
-						"curve": [ 0.022, 25.12, 0.187, -0.89 ]
-					},
-					{
-						"time": 0.2,
-						"value": -2.52,
-						"curve": [ 0.257, -9.92, 0.372, -17.38 ]
-					},
-					{
-						"time": 0.4333,
-						"value": -17.41,
-						"curve": [ 0.54, -17.47, 0.659, -16.91 ]
-					},
-					{
-						"time": 0.7667,
-						"value": -12.1,
-						"curve": [ 0.907, -5.79, 1.025, 14.58 ]
-					},
-					{
-						"time": 1.1,
-						"value": 20.58,
-						"curve": [ 1.191, 27.85, 1.283, 29.67 ]
-					},
-					{ "time": 1.3333, "value": 29.67 }
-				]
-			},
-			"neck": {
-				"rotate": [
-					{
-						"value": 11.88,
-						"curve": [ 0.104, 11.82, 0.179, 11.15 ]
-					},
-					{
-						"time": 0.2,
-						"value": 10.08,
-						"curve": [ 0.255, 7.29, 0.405, -8.15 ]
-					},
-					{
-						"time": 0.4333,
-						"value": -9.35,
-						"curve": [ 0.508, -12.48, 0.595, -13.14 ]
-					},
-					{
-						"time": 0.6667,
-						"value": -12.61,
-						"curve": [ 0.714, -12.26, 0.815, -5.57 ]
-					},
-					{
-						"time": 0.8333,
-						"value": -4.08,
-						"curve": [ 0.883, -0.07, 1.011, 10.6 ]
-					},
-					{
-						"time": 1.1,
-						"value": 15.01,
-						"curve": [ 1.178, 18.87, 1.279, 20.64 ]
-					},
-					{ "time": 1.3333, "value": 20.73 }
-				]
-			},
-			"head": {
-				"rotate": [
-					{
-						"value": 13.14,
-						"curve": [ 0.063, 13.1, 0.222, -20.78 ]
-					},
-					{
-						"time": 0.3333,
-						"value": -20.78,
-						"curve": [ 0.467, -20.78, 0.6, 7.26 ]
-					},
-					{
-						"time": 0.7333,
-						"value": 11.44,
-						"curve": [ 0.811, 13.88, 0.889, 13.88 ]
-					},
-					{
-						"time": 0.9667,
-						"value": 13.88,
-						"curve": [ 1.044, 13.88, 1.122, 7.56 ]
-					},
-					{
-						"time": 1.2,
-						"value": 7.56,
-						"curve": [ 1.244, 7.56, 1.289, 11.28 ]
-					},
-					{ "time": 1.3333, "value": 13.14 }
-				],
-				"scale": [
-					{
-						"curve": [ 0.041, 1, 0.052, 0.962, 0.041, 1, 0.052, 1.137 ]
-					},
-					{
-						"time": 0.1,
-						"x": 0.954,
-						"y": 1.137,
-						"curve": [ 0.202, 0.962, 0.318, 1, 0.202, 1.137, 0.252, 1.002 ]
-					},
-					{ "time": 0.4667 },
-					{
-						"time": 1.0667,
-						"x": 1.002,
-						"curve": [ 1.092, 1.002, 1.126, 1.173, 1.092, 1, 1.128, 0.975 ]
-					},
-					{
-						"time": 1.1667,
-						"x": 1.174,
-						"y": 0.973,
-						"curve": [ 1.204, 1.175, 1.233, 0.959, 1.206, 0.972, 1.227, 1.062 ]
-					},
-					{
-						"time": 1.2667,
-						"x": 0.958,
-						"y": 1.063,
-						"curve": [ 1.284, 0.958, 1.311, 1, 1.288, 1.063, 1.311, 1 ]
-					},
-					{ "time": 1.3333 }
-				]
-			},
-			"hip": {
-				"translate": [
-					{
-						"y": -45.46,
-						"curve": [ 0.042, -0.09, 0.15, 15.22, 0.031, 44.98, 0.123, 289.73 ]
-					},
-					{
-						"time": 0.2,
-						"x": 15.22,
-						"y": 415.85,
-						"curve": [ 0.332, 15.22, 0.539, -34.52, 0.271, 532.93, 0.483, 753.87 ]
-					},
-					{
-						"time": 0.7667,
-						"x": -34.52,
-						"y": 754.96,
-						"curve": [ 0.888, -34.52, 1.057, -21.95, 1.049, 754.54, 1.098, 379.84 ]
-					},
-					{
-						"time": 1.1333,
-						"x": -15.67,
-						"y": 266.77,
-						"curve": [ 1.144, -14.77, 1.188, -10.53, 1.15, 213.72, 1.172, -61.32 ]
-					},
-					{
-						"time": 1.2333,
-						"x": -6.53,
-						"y": -61.34,
-						"curve": [ 1.272, -3.22, 1.311, 0.05, 1.291, -61.36, 1.296, -44.8 ]
-					},
-					{ "time": 1.3333, "y": -45.46 }
-				]
-			},
-			"front-shin": {
-				"rotate": [
-					{
-						"value": -74.19,
-						"curve": [ 0, -51.14, 0.042, -12.54 ]
-					},
-					{
-						"time": 0.1667,
-						"value": -12.28,
-						"curve": [ 0.285, -12.32, 0.389, -51.96 ]
-					},
-					{
-						"time": 0.5,
-						"value": -51.96,
-						"curve": [ 0.633, -51.96, 0.767, -40.17 ]
-					},
-					{
-						"time": 0.9,
-						"value": -30.59,
-						"curve": [ 0.967, -25.8, 1.033, -16.01 ]
-					},
-					{
-						"time": 1.1,
-						"value": -8.85,
-						"curve": [ 1.122, -6.46, 1.144, -1.91 ]
-					},
-					{
-						"time": 1.1667,
-						"value": -1.91,
-						"curve": [ 1.178, -1.91, 1.189, -58.19 ]
-					},
-					{
-						"time": 1.2,
-						"value": -72.71,
-						"curve": [ 1.211, -87.23, 1.222, -89.05 ]
-					},
-					{
-						"time": 1.2333,
-						"value": -89.05,
-						"curve": [ 1.273, -89.05, 1.308, -79.55 ]
-					},
-					{ "time": 1.3333, "value": -74.19 }
-				]
-			},
-			"front-foot": {
-				"rotate": [
-					{
-						"value": 15.88,
-						"curve": [ 0, 13.33, 0.05, -26.64 ]
-					},
-					{
-						"time": 0.0667,
-						"value": -26.64,
-						"curve": [ 0.192, -26.64, 0.442, -11.77 ]
-					},
-					{
-						"time": 0.5667,
-						"value": -11.77,
-						"curve": [ 0.692, -11.77, 0.942, -19.36 ]
-					},
-					{
-						"time": 1.0667,
-						"value": -19.36,
-						"curve": [ 1.089, -19.36, 1.127, -67.74 ]
-					},
-					{
-						"time": 1.1667,
-						"value": -63.62,
-						"curve": [ 1.178, -62.51, 1.189, 5.83 ]
-					},
-					{
-						"time": 1.2,
-						"value": 11.39,
-						"curve": [ 1.222, 22.51, 1.244, 22.51 ]
-					},
-					{
-						"time": 1.2667,
-						"value": 22.51,
-						"curve": [ 1.289, 22.51, 1.333, 16.45 ]
-					},
-					{ "time": 1.3333, "value": 15.88 }
-				]
-			},
-			"rear-foot": {
-				"rotate": [
-					{
-						"value": -7.14,
-						"curve": [ 0.044, -17.32, 0.089, -37.67 ]
-					},
-					{
-						"time": 0.1333,
-						"value": -37.67,
-						"curve": [ 0.311, -37.67, 0.521, -26.72 ]
-					},
-					{
-						"time": 0.6667,
-						"value": -15.71,
-						"curve": [ 0.776, -7.49, 0.911, 14.92 ]
-					},
-					{
-						"time": 1.0333,
-						"value": 14.92,
-						"curve": [ 1.133, 14.92, 1.233, 0.21 ]
-					},
-					{ "time": 1.3333, "value": -7.14 }
-				]
-			},
-			"gun": {
-				"rotate": [
-					{
-						"value": 12.36,
-						"curve": [ 0.022, 16.28, 0.15, 30.81 ]
-					},
-					{
-						"time": 0.2,
-						"value": 30.81,
-						"curve": [ 0.258, 30.81, 0.375, 13.26 ]
-					},
-					{
-						"time": 0.4333,
-						"value": 13.26,
-						"curve": [ 0.508, 13.26, 0.658, 15.05 ]
-					},
-					{
-						"time": 0.7333,
-						"value": 14.98,
-						"curve": [ 0.789, 14.94, 0.828, 13.62 ]
-					},
-					{
-						"time": 0.8667,
-						"value": 12.72,
-						"curve": [ 0.887, 12.25, 0.984, 9.83 ]
-					},
-					{
-						"time": 1.0333,
-						"value": 8.6,
-						"curve": [ 1.045, 8.31, 1.083, 7.55 ]
-					},
-					{
-						"time": 1.1333,
-						"value": 7.13,
-						"curve": [ 1.175, 6.78, 1.283, 6.18 ]
-					},
-					{ "time": 1.3333, "value": 6.18 }
-				]
-			}
-		},
-		"events": [
-			{ "time": 1.2, "name": "footstep" }
-		]
-	},
-	"run": {
-		"slots": {
-			"mouth": {
-				"attachment": [
-					{ "name": "mouth-grind" }
-				]
-			}
-		},
-		"bones": {
-			"front-thigh": {
-				"rotate": [
-					{
-						"value": 49.77,
-						"curve": [ 0.007, 49.71, 0.022, 41.99 ]
-					},
-					{
-						"time": 0.0333,
-						"value": 32.26,
-						"curve": [ 0.044, 22.54, 0.056, 0.1 ]
-					},
-					{
-						"time": 0.0667,
-						"value": -8.56,
-						"curve": [ 0.078, -17.22, 0.089, -19.05 ]
-					},
-					{
-						"time": 0.1,
-						"value": -19.71,
-						"curve": [ 0.144, -22.38, 0.189, -22.38 ]
-					},
-					{
-						"time": 0.2333,
-						"value": -22.38,
-						"curve": [ 0.267, -22.38, 0.3, 36.57 ]
-					},
-					{
-						"time": 0.3333,
-						"value": 54.69,
-						"curve": [ 0.367, 72.82, 0.4, 86.37 ]
-					},
-					{
-						"time": 0.4333,
-						"value": 86.37,
-						"curve": [ 0.478, 86.37, 0.522, 46.94 ]
-					},
-					{
-						"time": 0.5667,
-						"value": 46.94,
-						"curve": [ 0.589, 46.94, 0.652, 49.34 ]
-					},
-					{ "time": 0.6667, "value": 49.77 }
-				],
-				"translate": [
-					{
-						"x": -7.86,
-						"y": 10.34,
-						"curve": [ 0.036, -7.85, 0.123, -6.71, 0.056, 10.34, 0.108, 9.74 ]
-					},
-					{
-						"time": 0.1667,
-						"x": -5.7,
-						"y": 7.99,
-						"curve": [ 0.22, -4.49, 0.295, -0.78, 0.236, 5.93, 0.28, 3.22 ]
-					},
-					{
-						"time": 0.3333,
-						"x": 1.68,
-						"y": 3.19,
-						"curve": [ 0.358, 3.28, 0.449, 9.99, 0.384, 3.16, 0.449, 4.98 ]
-					},
-					{
-						"time": 0.5,
-						"x": 9.99,
-						"y": 6.76,
-						"curve": [ 0.556, 10, 0.611, -7.86, 0.556, 8.69, 0.611, 10.34 ]
-					},
-					{ "time": 0.6667, "x": -7.86, "y": 10.34 }
-				]
-			},
-			"torso": {
-				"rotate": [
-					{
-						"value": -38.65,
-						"curve": [ 0.022, -39.16, 0.067, -41.4 ]
-					},
-					{
-						"time": 0.1,
-						"value": -41.4,
-						"curve": [ 0.156, -41.4, 0.211, -37.6 ]
-					},
-					{
-						"time": 0.2667,
-						"value": -37.6,
-						"curve": [ 0.289, -37.6, 0.315, -38.2 ]
-					},
-					{
-						"time": 0.3333,
-						"value": -38.63,
-						"curve": [ 0.369, -39.48, 0.434, -41.38 ]
-					},
-					{
-						"time": 0.4667,
-						"value": -41.39,
-						"curve": [ 0.512, -41.39, 0.556, -37.69 ]
-					},
-					{
-						"time": 0.6,
-						"value": -37.69,
-						"curve": [ 0.622, -37.69, 0.652, -38.3 ]
-					},
-					{ "time": 0.6667, "value": -38.65 }
-				]
-			},
-			"rear-thigh": {
-				"rotate": [
-					{
-						"value": 17.72,
-						"curve": [ 0.025, 28.51, 0.067, 54.38 ]
-					},
-					{
-						"time": 0.1,
-						"value": 54.38,
-						"curve": [ 0.144, 54.38, 0.189, 19.31 ]
-					},
-					{
-						"time": 0.2333,
-						"value": 19.31,
-						"curve": [ 0.254, 19.31, 0.278, 32.87 ]
-					},
-					{
-						"time": 0.3,
-						"value": 32.87,
-						"curve": [ 0.311, 32.87, 0.322, 32.87 ]
-					},
-					{
-						"time": 0.3333,
-						"value": 28.23,
-						"curve": [ 0.344, 23.6, 0.356, 4.08 ]
-					},
-					{
-						"time": 0.3667,
-						"value": -3.6,
-						"curve": [ 0.389, -18.95, 0.411, -38.43 ]
-					},
-					{
-						"time": 0.4333,
-						"value": -40.85,
-						"curve": [ 0.478, -45.69, 0.522, -45.69 ]
-					},
-					{
-						"time": 0.5667,
-						"value": -45.69,
-						"curve": [ 0.6, -45.69, 0.633, -7.24 ]
-					},
-					{ "time": 0.6667, "value": 17.72 }
-				],
-				"translate": [
-					{
-						"x": -13.59,
-						"y": 3.21,
-						"curve": [ 0.013, -12.85, 0.183, -8.55, 0.03, 4.05, 0.183, 6.17 ]
-					},
-					{
-						"time": 0.2333,
-						"x": -8.55,
-						"y": 6.17,
-						"curve": [ 0.308, -8.55, 0.492, -19.75, 0.308, 6.17, 0.492, 0.61 ]
-					},
-					{
-						"time": 0.5667,
-						"x": -19.75,
-						"y": 0.61,
-						"curve": [ 0.592, -19.75, 0.633, -15.46, 0.592, 0.61, 0.633, 2.28 ]
-					},
-					{ "time": 0.6667, "x": -13.59, "y": 3.21 }
-				]
-			},
-			"front-upper-arm": {
-				"rotate": [
-					{
-						"value": 324.21,
-						"curve": [ 0.051, 363.15, 0.145, 449.66 ]
-					},
-					{
-						"time": 0.2333,
-						"value": 449.66,
-						"curve": [ 0.28, 450.07, 0.324, 419.51 ]
-					},
-					{
-						"time": 0.3333,
-						"value": 411.11,
-						"curve": [ 0.358, 390.19, 0.445, 293.13 ]
-					},
-					{
-						"time": 0.5667,
-						"value": 292.23,
-						"curve": [ 0.599, 291.99, 0.633, 298.54 ]
-					},
-					{ "time": 0.6667, "value": 324.21 }
-				]
-			},
-			"front-bracer": {
-				"rotate": [
-					{
-						"value": 7.49,
-						"curve": [ 0.032, 2.15, 0.089, -2.82 ]
-					},
-					{
-						"time": 0.1333,
-						"value": -2.8,
-						"curve": [ 0.186, -2.78, 0.221, 26.29 ]
-					},
-					{
-						"time": 0.2333,
-						"value": 32.37,
-						"curve": [ 0.247, 39.19, 0.286, 61.45 ]
-					},
-					{
-						"time": 0.3333,
-						"value": 61.58,
-						"curve": [ 0.371, 61.69, 0.42, 55.79 ]
-					},
-					{
-						"time": 0.4667,
-						"value": 49.68,
-						"curve": [ 0.533, 40.96, 0.643, 13.39 ]
-					},
-					{ "time": 0.6667, "value": 7.49 }
-				]
-			},
-			"front-fist": {
-				"rotate": [
-					{
-						"value": -10.96,
-						"curve": [ 0.014, -13.6, 0.036, -43.27 ]
-					},
-					{
-						"time": 0.0667,
-						"value": -43.37,
-						"curve": [ 0.102, -43.49, 0.182, -28.46 ]
-					},
-					{
-						"time": 0.2,
-						"value": -23.04,
-						"curve": [ 0.23, -13.87, 0.264, 3.86 ]
-					},
-					{
-						"time": 0.3333,
-						"value": 3.7,
-						"curve": [ 0.38, 3.64, 0.489, -21.29 ]
-					},
-					{
-						"time": 0.5667,
-						"value": -21.29,
-						"curve": [ 0.6, -21.29, 0.633, -10.96 ]
-					},
-					{ "time": 0.6667, "value": -10.96 }
-				]
-			},
-			"rear-upper-arm": {
-				"rotate": [
-					{
-						"value": 35.32,
-						"curve": [ 0.028, 18.56, 0.128, -79.86 ]
-					},
-					{
-						"time": 0.2333,
-						"value": -79.87,
-						"curve": [ 0.38, -79.88, 0.403, 63.25 ]
-					},
-					{
-						"time": 0.5667,
-						"value": 64.13,
-						"curve": [ 0.607, 64.35, 0.633, 55.07 ]
-					},
-					{ "time": 0.6667, "value": 35.32 }
-				],
-				"translate": [
-					{
-						"x": -4.58,
-						"y": 0.93,
-						"curve": [ 0.044, -5.37, 0.169, -5.48, 0.044, 2.63, 0.169, 2.85 ]
-					},
-					{
-						"time": 0.2333,
-						"x": -5.48,
-						"y": 2.85,
-						"curve": [ 0.346, -5.48, 0.475, -2.68, 0.346, 2.85, 0.475, -3.13 ]
-					},
-					{
-						"time": 0.5667,
-						"x": -2.68,
-						"y": -3.13,
-						"curve": [ 0.611, -2.68, 0.633, -3.98, 0.611, -3.13, 0.633, -0.35 ]
-					},
-					{ "time": 0.6667, "x": -4.58, "y": 0.93 }
-				]
-			},
-			"rear-bracer": {
-				"rotate": [
-					{ "value": 17.03 },
-					{
-						"time": 0.2333,
-						"value": -13.07,
-						"curve": [ 0.252, -16.08, 0.297, -19.37 ]
-					},
-					{
-						"time": 0.3333,
-						"value": -19.38,
-						"curve": [ 0.435, -19.41, 0.522, 38.96 ]
-					},
-					{
-						"time": 0.5667,
-						"value": 38.87,
-						"curve": [ 0.619, 38.76, 0.625, 24.64 ]
-					},
-					{ "time": 0.6667, "value": 17.03 }
-				]
-			},
-			"neck": {
-				"rotate": [
-					{
-						"value": 10.23,
-						"curve": [ 0.024, 9.75, 0.075, 9.74 ]
-					},
-					{
-						"time": 0.1,
-						"value": 9.74,
-						"curve": [ 0.125, 9.74, 0.208, 13.36 ]
-					},
-					{
-						"time": 0.2333,
-						"value": 13.36,
-						"curve": [ 0.258, 13.36, 0.3, 10.88 ]
-					},
-					{
-						"time": 0.3333,
-						"value": 10.3,
-						"curve": [ 0.367, 9.72, 0.408, 9.72 ]
-					},
-					{
-						"time": 0.4333,
-						"value": 9.72,
-						"curve": [ 0.458, 9.72, 0.542, 13.36 ]
-					},
-					{
-						"time": 0.5667,
-						"value": 13.36,
-						"curve": [ 0.592, 13.36, 0.633, 10.91 ]
-					},
-					{ "time": 0.6667, "value": 10.23 }
-				]
-			},
-			"head": {
-				"rotate": [
-					{
-						"value": 8.93,
-						"curve": [ 0.033, 7.96, 0.065, 6.03 ]
-					},
-					{
-						"time": 0.1,
-						"value": 6.03,
-						"curve": [ 0.146, 6.03, 0.189, 10.78 ]
-					},
-					{
-						"time": 0.2333,
-						"value": 10.78,
-						"curve": [ 0.267, 10.78, 0.309, 9.94 ]
-					},
-					{
-						"time": 0.3333,
-						"value": 8.93,
-						"curve": [ 0.358, 7.93, 0.388, 6.1 ]
-					},
-					{
-						"time": 0.4333,
-						"value": 6.1,
-						"curve": [ 0.486, 6.1, 0.544, 10.76 ]
-					},
-					{
-						"time": 0.6,
-						"value": 10.76,
-						"curve": [ 0.622, 10.76, 0.652, 9.58 ]
-					},
-					{ "time": 0.6667, "value": 8.93 }
-				],
-				"scale": [
-					{
-						"x": 0.992,
-						"y": 1.01,
-						"curve": [ 0.036, 0.991, 0.068, 0.991, 0.014, 1.013, 0.083, 1.026 ]
-					},
-					{
-						"time": 0.1,
-						"x": 0.991,
-						"y": 1.026,
-						"curve": [ 0.128, 0.991, 0.205, 1.038, 0.128, 1.026, 0.197, 0.982 ]
-					},
-					{
-						"time": 0.2333,
-						"x": 1.038,
-						"y": 0.982,
-						"curve": [ 0.272, 1.038, 0.305, 1.008, 0.262, 0.982, 0.311, 0.995 ]
-					},
-					{
-						"time": 0.3333,
-						"curve": [ 0.351, 0.995, 0.417, 0.981, 0.359, 1.006, 0.417, 1.026 ]
-					},
-					{
-						"time": 0.4333,
-						"x": 0.981,
-						"y": 1.026,
-						"curve": [ 0.467, 0.981, 0.533, 1.037, 0.467, 1.026, 0.533, 0.982 ]
-					},
-					{
-						"time": 0.5667,
-						"x": 1.037,
-						"y": 0.982,
-						"curve": [ 0.592, 1.037, 0.636, 0.993, 0.592, 0.982, 0.64, 1.004 ]
-					},
-					{ "time": 0.6667, "x": 0.992, "y": 1.01 }
-				]
-			},
-			"gun": {
-				"rotate": [
-					{
-						"value": 18.25,
-						"curve": [ 0.033, 19.24, 0.087, 20.25 ]
-					},
-					{
-						"time": 0.1333,
-						"value": 20.19,
-						"curve": [ 0.168, 20.32, 0.254, -8.82 ]
-					},
-					{
-						"time": 0.2667,
-						"value": -11.88,
-						"curve": [ 0.291, -17.91, 0.344, -24.11 ]
-					},
-					{
-						"time": 0.4,
-						"value": -23.88,
-						"curve": [ 0.448, -23.69, 0.533, -15.47 ]
-					},
-					{ "time": 0.5667, "value": -8.69 },
-					{ "time": 0.6667, "value": 18.25 }
-				]
-			},
-			"hip": {
-				"translate": [
-					{
-						"x": 0.63,
-						"y": -34.19,
-						"curve": [ 0.042, 0.39, 0.118, 7.62, 0.042, -33.83, 0.084, 20.04 ]
-					},
-					{
-						"time": 0.1667,
-						"x": 7.61,
-						"y": 20.36,
-						"curve": [ 0.194, 7.6, 0.21, 5.06, 0.204, 20.65, 0.217, -8.69 ]
-					},
-					{
-						"time": 0.2333,
-						"x": 1.68,
-						"y": -18.48,
-						"curve": [ 0.279, -4.99, 0.297, -5.64, 0.254, -31.08, 0.292, -34.55 ]
-					},
-					{
-						"time": 0.3333,
-						"x": -5.76,
-						"y": -35,
-						"curve": [ 0.379, -5.9, 0.451, 6.8, 0.384, -35.56, 0.416, 17.6 ]
-					},
-					{
-						"time": 0.5,
-						"x": 6.61,
-						"y": 17.01,
-						"curve": [ 0.536, 6.47, 0.545, 3.56, 0.533, 16.75, 0.548, -8.71 ]
-					},
-					{
-						"time": 0.5667,
-						"x": 0.35,
-						"y": -18.81,
-						"curve": [ 0.597, -4.07, 0.633, 0.82, 0.584, -28.58, 0.633, -34.48 ]
-					},
-					{ "time": 0.6667, "x": 0.63, "y": -34.19 }
-				]
-			},
-			"rear-foot": {
-				"rotate": [
-					{
-						"value": -27.81,
-						"curve": [ 0.078, -27.81, 0.156, 17.7 ]
-					},
-					{
-						"time": 0.2333,
-						"value": 17.7,
-						"curve": [ 0.256, 17.7, 0.278, 12.8 ]
-					},
-					{
-						"time": 0.3,
-						"value": 12.8,
-						"curve": [ 0.311, 12.8, 0.322, 17.93 ]
-					},
-					{
-						"time": 0.3333,
-						"value": 20.49,
-						"curve": [ 0.344, 20.49, 0.356, 36.91 ]
-					},
-					{
-						"time": 0.3667,
-						"value": 33.49,
-						"curve": [ 0.378, 30.04, 0.389, 28.84 ]
-					},
-					{
-						"time": 0.4,
-						"value": 19.93,
-						"curve": [ 0.411, 10.9, 0.422, -5.84 ]
-					},
-					{
-						"time": 0.4333,
-						"value": -8.18,
-						"curve": [ 0.478, -17.39, 0.523, 4.88 ]
-					},
-					{
-						"time": 0.5667,
-						"value": 2.21,
-						"curve": [ 0.6, 0.19, 0.633, -27.81 ]
-					},
-					{ "time": 0.6667, "value": -27.81 }
-				]
-			},
-			"front-foot": {
-				"rotate": [
-					{
-						"value": 11.76,
-						"curve": [ 0.008, 11.76, 0.02, 19.97 ]
-					},
-					{
-						"time": 0.0333,
-						"value": 20.38,
-						"curve": [ 0.044, 20.72, 0.056, 17.21 ]
-					},
-					{
-						"time": 0.0667,
-						"value": 11.96,
-						"curve": [ 0.079, 6.01, 0.089, -24.56 ]
-					},
-					{
-						"time": 0.1,
-						"value": -25.8,
-						"curve": [ 0.144, -30.78, 0.189, -30.78 ]
-					},
-					{
-						"time": 0.2333,
-						"value": -30.78,
-						"curve": [ 0.267, -30.78, 0.3, -29.2 ]
-					},
-					{
-						"time": 0.3333,
-						"value": -24.64,
-						"curve": [ 0.389, -17.03, 0.444, -0.27 ]
-					},
-					{
-						"time": 0.5,
-						"value": 5.74,
-						"curve": [ 0.556, 11.76, 0.633, 11.76 ]
-					},
-					{ "time": 0.6667, "value": 11.76 }
-				]
-			},
-			"front-shin": {
-				"rotate": [
-					{
-						"value": -66.44,
-						"curve": [ 0.011, -66.44, 0.022, -65.11 ]
-					},
-					{
-						"time": 0.0333,
-						"value": -58,
-						"curve": [ 0.044, -50.9, 0.056, -28.78 ]
-					},
-					{
-						"time": 0.0667,
-						"value": -23.84,
-						"curve": [ 0.078, -18.9, 0.089, -18.9 ]
-					},
-					{
-						"time": 0.1,
-						"value": -18.9,
-						"curve": [ 0.144, -18.9, 0.189, -66.55 ]
-					},
-					{
-						"time": 0.2333,
-						"value": -85.8,
-						"curve": [ 0.267, -100.25, 0.3, -120 ]
-					},
-					{
-						"time": 0.3333,
-						"value": -120,
-						"curve": [ 0.367, -120, 0.4, -116.77 ]
-					},
-					{
-						"time": 0.4333,
-						"value": -103.62,
-						"curve": [ 0.456, -94.85, 0.478, -73.54 ]
-					},
-					{
-						"time": 0.5,
-						"value": -54.26,
-						"curve": [ 0.522, -34.99, 0.544, -5.08 ]
-					},
-					{
-						"time": 0.5667,
-						"value": -5.08,
-						"curve": [ 0.589, -5.08, 0.611, -31.56 ]
-					},
-					{
-						"time": 0.6333,
-						"value": -45.19,
-						"curve": [ 0.644, -52.01, 0.656, -66.44 ]
-					},
-					{ "time": 0.6667, "value": -66.44 }
-				]
-			},
-			"rear-shin": {
-				"rotate": [
-					{
-						"value": -99.91,
-						"curve": [ 0.048, -99.45, 0.067, -87.25 ]
-					},
-					{
-						"time": 0.1,
-						"value": -72.41,
-						"curve": [ 0.144, -52.61, 0.189, 4.01 ]
-					},
-					{
-						"time": 0.2333,
-						"value": 4.01,
-						"curve": [ 0.256, 4.01, 0.278, -32.4 ]
-					},
-					{
-						"time": 0.3,
-						"value": -46.27,
-						"curve": [ 0.311, -53.2, 0.322, -58.41 ]
-					},
-					{
-						"time": 0.3333,
-						"value": -58.41,
-						"curve": [ 0.367, -58.41, 0.4, -2.86 ]
-					},
-					{
-						"time": 0.4333,
-						"value": -2.86,
-						"curve": [ 0.478, -2.86, 0.522, -61.56 ]
-					},
-					{
-						"time": 0.5667,
-						"value": -80.05,
-						"curve": [ 0.6, -93.91, 0.632, -99.87 ]
-					},
-					{ "time": 0.6667, "value": -99.91 }
-				]
-			},
-			"gun-tip": {
-				"rotate": [
-					{ "time": 0.4333, "value": 12.93 }
-				]
-			}
-		},
-		"drawOrder": [
-			{
-				"offsets": [
-					{ "slot": "head", "offset": -2 }
-				]
-			}
-		],
-		"events": [
-			{ "time": 0.2667, "name": "footstep" },
-			{ "time": 0.6, "name": "footstep" }
-		]
-	},
-	"shoot": {
-		"slots": {
-			"muzzle": {
-				"rgba": [
-					{ "time": 0.3667, "color": "ffffff00" }
-				],
-				"attachment": [
-					{ "time": 0.1333, "name": "muzzle01" },
-					{ "time": 0.2, "name": "muzzle02" },
-					{ "time": 0.2667, "name": "muzzle03" },
-					{ "time": 0.3333, "name": "muzzle04" },
-					{ "time": 0.3667, "name": null }
-				]
-			}
-		},
-		"bones": {
-			"gun-tip": {
-				"translate": [
-					{ "time": 0.1333 },
-					{ "time": 0.2333, "x": 32.31, "y": 2.94 }
-				]
-			},
-			"gun": {
-				"rotate": [
-					{ "value": 1.91, "curve": "stepped" },
-					{
-						"time": 0.1,
-						"value": 1.91,
-						"curve": [ 0.113, 4.95, 0.122, 6.56 ]
-					},
-					{
-						"time": 0.1333,
-						"value": 6.56,
-						"curve": [ 0.167, 6.56, 0.2, -0.97 ]
-					},
-					{
-						"time": 0.2333,
-						"value": -0.97,
-						"curve": [ 0.289, -0.97, 0.344, 0.95 ]
-					},
-					{ "time": 0.4, "value": 1.91 }
-				],
-				"translate": [
-					{ "x": 7.95, "y": 5.85, "curve": "stepped" },
-					{
-						"time": 0.1,
-						"x": 7.95,
-						"y": 5.85,
-						"curve": [ 0.167, 7.95, 0.204, -9.3, 0.167, 5.85, 0.204, -1.41 ]
-					},
-					{
-						"time": 0.3,
-						"x": -9.3,
-						"y": -1.41,
-						"curve": [ 0.333, -9.3, 0.367, 7.95, 0.333, -1.41, 0.367, 5.85 ]
-					},
-					{ "time": 0.4, "x": 7.95, "y": 5.85 }
-				]
-			},
-			"rear-bracer": {
-				"rotate": [
-					{ "value": -30.47 }
-				],
-				"translate": [
-					{
-						"time": 0.1,
-						"curve": [ 0.156, -4.39, 0.204, -6, 0.167, -3.38, 0.204, -3.72 ]
-					},
-					{ "time": 0.3, "x": -6, "y": -3.72 },
-					{ "time": 0.4 }
-				]
-			},
-			"rear-upper-arm": {
-				"rotate": [
-					{ "value": 62.31 }
-				],
-				"translate": [
-					{
-						"time": 0.1,
-						"curve": [ 0.167, 0, 0.204, 2.81, 0.16, 11.74, 0.23, 11.7 ]
-					},
-					{ "time": 0.3, "x": 2.81, "y": 11.53 },
-					{ "time": 0.4 }
-				]
-			}
-		}
-	},
-	"walk": {
-		"bones": {
-			"hip": {
-				"rotate": [
-					{ "value": 0.94 }
-				],
-				"translate": [
-					{
-						"x": -2.86,
-						"y": -13.86,
-						"curve": [ 0.025, -2.84, 0.067, -2.82, 0.028, -19.14, 0.054, -31.19 ]
-					},
-					{
-						"time": 0.1,
-						"x": -2.61,
-						"y": -31.36,
-						"curve": [ 0.143, -2.34, 0.202, -1.79, 0.152, -31.16, 0.213, -14.81 ]
-					},
-					{
-						"time": 0.2667,
-						"x": -1.21,
-						"y": -7.12,
-						"curve": [ 0.308, -0.86, 0.345, -0.51, 0.306, -1.63, 0.341, 3.15 ]
-					},
-					{
-						"time": 0.3667,
-						"x": -0.33,
-						"y": 3.15,
-						"curve": [ 0.41, 0.02, 0.458, 0.26, 0.427, 3.3, 0.481, -6.75 ]
-					},
-					{
-						"time": 0.5,
-						"x": 0.26,
-						"y": -10.59,
-						"curve": [ 0.553, 0.26, 0.559, 0.2, 0.519, -14.41, 0.548, -31.74 ]
-					},
-					{
-						"time": 0.6,
-						"x": -0.17,
-						"y": -31.56,
-						"curve": [ 0.632, -0.45, 0.683, -0.94, 0.646, -31.41, 0.688, -17.46 ]
-					},
-					{
-						"time": 0.7333,
-						"x": -1.4,
-						"y": -8.62,
-						"curve": [ 0.783, -1.85, 0.833, -2.28, 0.77, -1.61, 0.831, 3.51 ]
-					},
-					{
-						"time": 0.8667,
-						"x": -2.46,
-						"y": 3.48,
-						"curve": [ 0.901, -2.63, 0.967, -2.87, 0.913, 3.45, 0.967, -7.64 ]
-					},
-					{ "time": 1, "x": -2.86, "y": -13.86 }
-				]
-			},
-			"torso": {
-				"rotate": [
-					{
-						"value": -20.72,
-						"curve": [ 0.013, -20.49, 0.071, -19.12 ]
-					},
-					{
-						"time": 0.1333,
-						"value": -19.12,
-						"curve": [ 0.187, -19.12, 0.285, -22.22 ]
-					},
-					{
-						"time": 0.3667,
-						"value": -22.22,
-						"curve": [ 0.405, -22.22, 0.491, -20.92 ]
-					},
-					{
-						"time": 0.5,
-						"value": -20.71,
-						"curve": [ 0.51, -20.48, 0.582, -19.06 ]
-					},
-					{
-						"time": 0.6333,
-						"value": -19.06,
-						"curve": [ 0.709, -19.07, 0.815, -22.22 ]
-					},
-					{
-						"time": 0.8667,
-						"value": -22.22,
-						"curve": [ 0.908, -22.22, 0.981, -21.1 ]
-					},
-					{ "time": 1, "value": -20.72 }
-				]
-			},
-			"neck": {
-				"rotate": [
-					{
-						"value": 17.78,
-						"curve": [ 0.025, 17.93, 0.071, 18.46 ]
-					},
-					{
-						"time": 0.1333,
-						"value": 18.46,
-						"curve": [ 0.187, 18.46, 0.285, 17.34 ]
-					},
-					{
-						"time": 0.3667,
-						"value": 17.34,
-						"curve": [ 0.405, 17.34, 0.47, 17.6 ]
-					},
-					{
-						"time": 0.5,
-						"value": 17.79,
-						"curve": [ 0.518, 17.9, 0.582, 18.47 ]
-					},
-					{
-						"time": 0.6333,
-						"value": 18.46,
-						"curve": [ 0.709, 18.45, 0.815, 17.32 ]
-					},
-					{
-						"time": 0.8667,
-						"value": 17.32,
-						"curve": [ 0.908, 17.32, 0.971, 17.57 ]
-					},
-					{ "time": 1, "value": 17.78 }
-				]
-			},
-			"head": {
-				"rotate": [
-					{
-						"value": -12.23,
-						"curve": [ 0.061, -12.23, 0.191, -7.45 ]
-					},
-					{
-						"time": 0.2667,
-						"value": -7.43,
-						"curve": [ 0.341, -7.42, 0.421, -12.23 ]
-					},
-					{
-						"time": 0.5,
-						"value": -12.23,
-						"curve": [ 0.567, -12.26, 0.694, -7.46 ]
-					},
-					{
-						"time": 0.7667,
-						"value": -7.47,
-						"curve": [ 0.853, -7.49, 0.943, -12.23 ]
-					},
-					{ "time": 1, "value": -12.23 }
-				],
-				"scale": [
-					{
-						"curve": [ 0.039, 1, 0.084, 0.991, 0.039, 1, 0.084, 1.019 ]
-					},
-					{
-						"time": 0.1333,
-						"x": 0.991,
-						"y": 1.019,
-						"curve": [ 0.205, 0.991, 0.318, 1.019, 0.205, 1.019, 0.337, 0.992 ]
-					},
-					{
-						"time": 0.4,
-						"x": 1.019,
-						"y": 0.992,
-						"curve": [ 0.456, 1.019, 0.494, 1.001, 0.483, 0.991, 0.493, 0.999 ]
-					},
-					{
-						"time": 0.5,
-						"curve": [ 0.508, 0.998, 0.584, 0.991, 0.51, 1.002, 0.584, 1.019 ]
-					},
-					{
-						"time": 0.6333,
-						"x": 0.991,
-						"y": 1.019,
-						"curve": [ 0.705, 0.991, 0.818, 1.019, 0.705, 1.019, 0.837, 0.992 ]
-					},
-					{
-						"time": 0.9,
-						"x": 1.019,
-						"y": 0.992,
-						"curve": [ 0.956, 1.019, 0.955, 1, 0.983, 0.991, 0.955, 1 ]
-					},
-					{ "time": 1 }
-				]
-			},
-			"front-thigh": {
-				"rotate": [
-					{
-						"value": 41.41,
-						"curve": [ 0.033, 41.52, 0.075, 57.36 ]
-					},
-					{
-						"time": 0.1,
-						"value": 57.36,
-						"curve": [ 0.142, 57.36, 0.249, 30.8 ]
-					},
-					{
-						"time": 0.2667,
-						"value": 26.81,
-						"curve": [ 0.314, 16.08, 0.378, 5.4 ]
-					},
-					{
-						"time": 0.4,
-						"value": 2.75,
-						"curve": [ 0.455, -3.75, 0.54, -12.39 ]
-					},
-					{
-						"time": 0.6,
-						"value": -12.39,
-						"curve": [ 0.633, -12.39, 0.722, 21.07 ]
-					},
-					{
-						"time": 0.7333,
-						"value": 25.71,
-						"curve": [ 0.751, 32.81, 0.824, 63.52 ]
-					},
-					{
-						"time": 0.8667,
-						"value": 63.79,
-						"curve": [ 0.913, 64.09, 0.948, 41.49 ]
-					},
-					{ "time": 1, "value": 41.41 }
-				],
-				"translate": [
-					{
-						"x": 17.15,
-						"y": -0.09,
-						"curve": [ 0.178, 17.14, 0.295, -4.26, 0.009, -0.09, 0.475, 0.02 ]
-					},
-					{
-						"time": 0.5,
-						"x": -4.26,
-						"y": 0.02,
-						"curve": [ 0.705, -4.27, 0.875, 17.16, 0.525, 0.02, 0.875, -0.09 ]
-					},
-					{ "time": 1, "x": 17.15, "y": -0.09 }
-				]
-			},
-			"rear-thigh": {
-				"rotate": [
-					{
-						"value": -40.72,
-						"curve": [ 0.026, -42.96, 0.075, -43 ]
-					},
-					{
-						"time": 0.1,
-						"value": -43,
-						"curve": [ 0.142, -43, 0.239, 8.23 ]
-					},
-					{
-						"time": 0.2667,
-						"value": 18.99,
-						"curve": [ 0.284, 25.64, 0.367, 38.72 ]
-					},
-					{
-						"time": 0.4,
-						"value": 38.72,
-						"curve": [ 0.425, 38.72, 0.475, 18.7 ]
-					},
-					{
-						"time": 0.5,
-						"value": 18.7,
-						"curve": [ 0.525, 18.7, 0.575, 31.73 ]
-					},
-					{
-						"time": 0.6,
-						"value": 31.73,
-						"curve": [ 0.633, 31.73, 0.719, 15.2 ]
-					},
-					{
-						"time": 0.7333,
-						"value": 11.21,
-						"curve": [ 0.767, 2.12, 0.851, -15.29 ]
-					},
-					{
-						"time": 0.8667,
-						"value": -18.46,
-						"curve": [ 0.905, -26.32, 0.951, -35.33 ]
-					},
-					{ "time": 1, "value": -40.72 }
-				],
-				"translate": [
-					{
-						"x": -17.71,
-						"y": -4.63,
-						"curve": [ 0.028, -19.31, 0.04, -20.22, 0.027, -4.63, 0.036, 1.71 ]
-					},
-					{
-						"time": 0.0667,
-						"x": -20.72,
-						"y": 1.6,
-						"curve": [ 0.082, -21, 0.087, -20.93, 0.082, 1.54, 0.091, 0.29 ]
-					},
-					{
-						"time": 0.1,
-						"x": -20.95,
-						"y": 0.06,
-						"curve": [ 0.162, -21.05, 0.4, 7.79, 0.194, -2.43, 0.4, -1.9 ]
-					},
-					{
-						"time": 0.5,
-						"x": 7.79,
-						"y": -1.94,
-						"curve": [ 0.519, 7.78, 0.542, 7.33, 0.517, -1.94, 0.54, 5.55 ]
-					},
-					{
-						"time": 0.5667,
-						"x": 6.45,
-						"y": 5.4,
-						"curve": [ 0.587, 5.74, 0.721, -0.95, 0.587, 5.28, 0.732, -3.74 ]
-					},
-					{
-						"time": 0.7667,
-						"x": -3.61,
-						"y": -4.14,
-						"curve": [ 0.855, -8.76, 0.942, -14.37, 0.814, -4.69, 0.944, -4.63 ]
-					},
-					{ "time": 1, "x": -17.71, "y": -4.63 }
-				]
-			},
-			"front-upper-arm": {
-				"rotate": [
-					{
-						"value": -14.27,
-						"curve": [ 0.021, -18.08, 0.058, -19.4 ]
-					},
-					{
-						"time": 0.1,
-						"value": -19.4,
-						"curve": [ 0.238, -19.69, 0.337, 7.78 ]
-					},
-					{
-						"time": 0.3667,
-						"value": 16.2,
-						"curve": [ 0.399, 25.42, 0.497, 60.19 ]
-					},
-					{
-						"time": 0.6,
-						"value": 60.26,
-						"curve": [ 0.719, 60.13, 0.845, 27.61 ]
-					},
-					{
-						"time": 0.8667,
-						"value": 22.45,
-						"curve": [ 0.892, 16.38, 0.967, -8.36 ]
-					},
-					{ "time": 1, "value": -14.27 }
-				]
-			},
-			"front-bracer": {
-				"rotate": [
-					{
-						"value": 13.57,
-						"curve": [ 0.022, 9.71, 0.147, -15.4 ]
-					},
-					{
-						"time": 0.3667,
-						"value": -15.3,
-						"curve": [ 0.457, -15.28, 0.635, 30.8 ]
-					},
-					{
-						"time": 0.8,
-						"value": 30.92,
-						"curve": [ 0.894, 30.82, 0.98, 18.35 ]
-					},
-					{ "time": 1, "value": 13.57 }
-				]
-			},
-			"front-fist": {
-				"rotate": [
-					{
-						"value": -28.72,
-						"curve": [ 0.024, -31.74, 0.176, -43.4 ]
-					},
-					{
-						"time": 0.3667,
-						"value": -43.6,
-						"curve": [ 0.403, -43.65, 0.47, -40.15 ]
-					},
-					{
-						"time": 0.5,
-						"value": -35.63,
-						"curve": [ 0.547, -28.59, 0.624, -4.57 ]
-					},
-					{
-						"time": 0.7333,
-						"value": -4.59,
-						"curve": [ 0.891, -4.62, 0.954, -24.28 ]
-					},
-					{ "time": 1, "value": -28.48 }
-				]
-			},
-			"rear-upper-arm": {
-				"rotate": [
-					{
-						"value": 28.28,
-						"curve": [ 0.034, 30.94, 0.068, 32.05 ]
-					},
-					{
-						"time": 0.1,
-						"value": 31.88,
-						"curve": [ 0.194, 31.01, 0.336, -0.11 ]
-					},
-					{
-						"time": 0.3667,
-						"value": -7.11,
-						"curve": [ 0.421, -19.73, 0.53, -46.21 ]
-					},
-					{
-						"time": 0.6,
-						"value": -45.75,
-						"curve": [ 0.708, -45.03, 0.844, -13.56 ]
-					},
-					{
-						"time": 0.8667,
-						"value": -6.48,
-						"curve": [ 0.909, 6.59, 0.958, 24.21 ]
-					},
-					{ "time": 1, "value": 28.28 }
-				]
-			},
-			"rear-bracer": {
-				"rotate": [
-					{
-						"value": 10.06,
-						"curve": [ 0.044, 11.16, 0.063, 11.49 ]
-					},
-					{
-						"time": 0.1,
-						"value": 11.49,
-						"curve": [ 0.215, 11.49, 0.336, 2.92 ]
-					},
-					{
-						"time": 0.3667,
-						"value": 0.84,
-						"curve": [ 0.416, -2.52, 0.498, -10.84 ]
-					},
-					{
-						"time": 0.6,
-						"value": -10.83,
-						"curve": [ 0.762, -10.71, 0.845, -3.05 ]
-					},
-					{
-						"time": 0.8667,
-						"value": -1.34,
-						"curve": [ 0.917, 2.54, 0.977, 8.81 ]
-					},
-					{ "time": 1, "value": 10.06 }
-				]
-			},
-			"gun": {
-				"rotate": [
-					{
-						"value": -14.67,
-						"curve": [ 0.086, -14.67, 0.202, 8.31 ]
-					},
-					{
-						"time": 0.2333,
-						"value": 12.14,
-						"curve": [ 0.279, 17.71, 0.391, 25.79 ]
-					},
-					{
-						"time": 0.5,
-						"value": 25.77,
-						"curve": [ 0.631, 25.74, 0.694, 4.53 ]
-					},
-					{
-						"time": 0.7333,
-						"value": -0.65,
-						"curve": [ 0.768, -5.21, 0.902, -14.4 ]
-					},
-					{ "time": 1, "value": -14.67 }
-				]
-			},
-			"gun-tip": {
-				"rotate": [
-					{ "time": 0.2333, "value": 0.11 }
-				]
-			},
-			"rear-foot": {
-				"rotate": [
-					{ "value": 26.22 },
-					{
-						"time": 0.0333,
-						"value": 28.94,
-						"curve": [ 0.05, 28.94, 0.081, 17.62 ]
-					},
-					{
-						"time": 0.1,
-						"value": 12.68,
-						"curve": [ 0.121, 7.25, 0.239, -22.96 ]
-					},
-					{
-						"time": 0.2667,
-						"value": -26.31,
-						"curve": [ 0.299, -30.12, 0.364, -35.52 ]
-					},
-					{
-						"time": 0.4,
-						"value": -35.38,
-						"curve": [ 0.418, -35.31, 0.485, 1.14 ]
-					},
-					{
-						"time": 0.5,
-						"value": 6.17,
-						"curve": [ 0.503, 7.08, 0.519, 11.27 ]
-					},
-					{
-						"time": 0.5333,
-						"value": 11.15,
-						"curve": [ 0.545, 11.06, 0.552, 11.27 ]
-					},
-					{ "time": 0.5667, "value": 3.69 },
-					{ "time": 0.6, "value": 3.55 },
-					{ "time": 0.7, "value": 10.77 },
-					{ "time": 1, "value": 26.22 }
-				]
-			},
-			"front-shin": {
-				"rotate": [
-					{
-						"value": -6.79,
-						"curve": [ 0.028, -6.79, 0.087, -49.32 ]
-					},
-					{
-						"time": 0.1,
-						"value": -51.42,
-						"curve": [ 0.109, -52.92, 0.137, -55.37 ]
-					},
-					{
-						"time": 0.1667,
-						"value": -55.35,
-						"curve": [ 0.188, -55.34, 0.238, -44.96 ]
-					},
-					{
-						"time": 0.2667,
-						"value": -40.55,
-						"curve": [ 0.284, -37.93, 0.365, -23.14 ]
-					},
-					{
-						"time": 0.4333,
-						"value": -22.85,
-						"curve": [ 0.524, -22.46, 0.585, -48.24 ]
-					},
-					{
-						"time": 0.6,
-						"value": -54.5,
-						"curve": [ 0.618, -61.64, 0.714, -97.51 ]
-					},
-					{
-						"time": 0.7333,
-						"value": -102.65,
-						"curve": [ 0.749, -106.84, 0.768, -109.78 ]
-					},
-					{
-						"time": 0.8,
-						"value": -109.78,
-						"curve": [ 0.818, -109.78, 0.859, -94.44 ]
-					},
-					{
-						"time": 0.8667,
-						"value": -87.74,
-						"curve": [ 0.874, -81.52, 0.969, -6.79 ]
-					},
-					{ "time": 1, "value": -6.79 }
-				],
-				"scale": [
-					{},
-					{ "time": 0.0333, "x": 0.983 },
-					{ "time": 0.1, "x": 0.967, "y": 0.981 },
-					{ "time": 0.4333 },
-					{ "time": 0.5333, "x": 0.958, "y": 0.951 },
-					{ "time": 0.6333 }
-				]
-			},
-			"rear-shin": {
-				"rotate": [
-					{
-						"value": 6.84,
-						"curve": [ 0.025, 6.84, 0.093, -24.57 ]
-					},
-					{
-						"time": 0.1,
-						"value": -28.08,
-						"curve": [ 0.121, -38.52, 0.204, -92.35 ]
-					},
-					{
-						"time": 0.2667,
-						"value": -91.68,
-						"curve": [ 0.309, -91.22, 0.379, -77.62 ]
-					},
-					{
-						"time": 0.4,
-						"value": -68.91,
-						"curve": [ 0.43, -56.58, 0.474, 2.28 ]
-					},
-					{
-						"time": 0.5,
-						"value": 2.63,
-						"curve": [ 0.538, 3.15, 0.567, -35.43 ]
-					},
-					{
-						"time": 0.6,
-						"value": -35.18,
-						"curve": [ 0.634, -34.93, 0.665, -34.17 ]
-					},
-					{
-						"time": 0.7,
-						"value": -30.64,
-						"curve": [ 0.718, -28.79, 0.857, -8.34 ]
-					},
-					{
-						"time": 0.8667,
-						"value": -6.83,
-						"curve": [ 0.915, 0.75, 0.967, 6.84 ]
-					},
-					{ "time": 1, "value": 6.84 }
-				]
-			},
-			"front-foot": {
-				"rotate": [
-					{
-						"value": 2.73,
-						"curve": [ 0.013, 4.28, 0.019, 5.27 ]
-					},
-					{
-						"time": 0.0333,
-						"value": 5.15,
-						"curve": [ 0.045, 5.05, 0.063, -4.11 ]
-					},
-					{
-						"time": 0.0667,
-						"value": -6.67,
-						"curve": [ 0.111, -6.72, 0.148, 3.78 ]
-					},
-					{ "time": 0.1667, "value": 4.67 },
-					{ "time": 0.2667, "value": 7.06 },
-					{ "time": 0.3333, "value": 8.97 },
-					{ "time": 0.4, "value": 11.15 },
-					{
-						"time": 0.5333,
-						"value": 21.62,
-						"curve": [ 0.572, 21.62, 0.587, 17.19 ]
-					},
-					{
-						"time": 0.6,
-						"value": 13.77,
-						"curve": [ 0.639, 3.33, 0.713, -20.85 ]
-					},
-					{
-						"time": 0.7333,
-						"value": -27.3,
-						"curve": [ 0.757, -34.54, 0.766, -37.13 ]
-					},
-					{
-						"time": 0.8,
-						"value": -38.01,
-						"curve": [ 0.828, -38.72, 0.976, -2.16 ]
-					},
-					{ "time": 1, "value": 2.73 }
-				]
-			}
-		},
-		"events": [
-			{ "name": "footstep" },
-			{ "time": 0.5333, "name": "footstep" }
-		]
-	}
-}
-}

spine-as3/spine-as3-example/src/spineboy.atlas

@@ -1,101 +0,0 @@
-spineboy.png
-	size: 1024, 256
-	filter: Linear, Linear
-	scale: 0.5
-crosshair
-	bounds: 813, 160, 45, 45
-eye-indifferent
-	bounds: 569, 2, 47, 45
-eye-surprised
-	bounds: 643, 7, 47, 45
-	rotate: 90
-front-bracer
-	bounds: 811, 51, 29, 40
-front-fist-closed
-	bounds: 807, 93, 38, 41
-front-fist-open
-	bounds: 815, 210, 43, 44
-front-foot
-	bounds: 706, 64, 63, 35
-	rotate: 90
-front-shin
-	bounds: 80, 11, 41, 92
-front-thigh
-	bounds: 754, 12, 23, 56
-front-upper-arm
-	bounds: 618, 5, 23, 49
-goggles
-	bounds: 214, 20, 131, 83
-gun
-	bounds: 347, 14, 105, 102
-	rotate: 90
-head
-	bounds: 80, 105, 136, 149
-hoverboard-board
-	bounds: 2, 8, 246, 76
-	rotate: 90
-hoverboard-thruster
-	bounds: 478, 2, 30, 32
-hoverglow-small
-	bounds: 218, 117, 137, 38
-	rotate: 90
-mouth-grind
-	bounds: 775, 80, 47, 30
-	rotate: 90
-mouth-oooo
-	bounds: 779, 31, 47, 30
-	rotate: 90
-mouth-smile
-	bounds: 783, 207, 47, 30
-	rotate: 90
-muzzle-glow
-	bounds: 779, 4, 25, 25
-muzzle-ring
-	bounds: 451, 14, 25, 105
-muzzle01
-	bounds: 664, 60, 67, 40
-	rotate: 90
-muzzle02
-	bounds: 580, 56, 68, 42
-	rotate: 90
-muzzle03
-	bounds: 478, 36, 83, 53
-	rotate: 90
-muzzle04
-	bounds: 533, 49, 75, 45
-	rotate: 90
-muzzle05
-	bounds: 624, 56, 68, 38
-	rotate: 90
-neck
-	bounds: 806, 8, 18, 21
-portal-bg
-	bounds: 258, 121, 133, 133
-portal-flare1
-	bounds: 690, 2, 56, 30
-	rotate: 90
-portal-flare2
-	bounds: 510, 3, 57, 31
-portal-flare3
-	bounds: 722, 4, 58, 30
-	rotate: 90
-portal-shade
-	bounds: 393, 121, 133, 133
-portal-streaks1
-	bounds: 528, 126, 126, 128
-portal-streaks2
-	bounds: 656, 129, 125, 125
-rear-bracer
-	bounds: 826, 13, 28, 36
-rear-foot
-	bounds: 743, 70, 57, 30
-	rotate: 90
-rear-shin
-	bounds: 174, 14, 38, 89
-rear-thigh
-	bounds: 783, 158, 28, 47
-rear-upper-arm
-	bounds: 783, 136, 20, 44
-	rotate: 90
-torso
-	bounds: 123, 13, 49, 90

spine-as3/spine-as3/asconfig.json

@@ -1,13 +0,0 @@
-{
-	"type": "lib",
-	"compilerOptions": {
-		"source-path": [
-			"src"
-		],
-		"include-sources": [
-			"src"
-		],
-		"output": "../spine-as3/lib/spine-as3.swc",
-		"target-player": "32.0"
-	}
-}

spine-as3/spine-as3/src/spine/BinaryInput.as

@@ -1,122 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine {
-	import flash.utils.ByteArray;
-	
-	internal class BinaryInput {
-		private var bytes : ByteArray;	
-		public var strings : Vector.<String> = new Vector.<String>();
-
-		public function BinaryInput(bytes: ByteArray) {
-			this.bytes = bytes;
-		}
-
-		public function readByte() : int {
-			return bytes.readByte();
-		}
-
-		public function readUnsignedByte() : int {
-			return bytes.readUnsignedByte();
-		}
-
-		public function readShort() : int {
-			return bytes.readShort();
-		}
-
-		public function readInt32(): int {
-			 return bytes.readInt();
-		}
-
-		public function readInt(optimizePositive: Boolean) : int {
-			var b : int = readByte();
-			var result : int = b & 0x7F;
-			if ((b & 0x80) != 0) {
-				b = readByte();
-				result |= (b & 0x7F) << 7;
-				if ((b & 0x80) != 0) {
-					b = readByte();
-					result |= (b & 0x7F) << 14;
-					if ((b & 0x80) != 0) {
-						b = readByte();
-						result |= (b & 0x7F) << 21;
-						if ((b & 0x80) != 0) {
-							b = readByte();
-							result |= (b & 0x7F) << 28;
-						}
-					}
-				}
-			}
-			return optimizePositive ? result : ((result >>> 1) ^ -(result & 1));
-		}
-
-		public function readStringRef (): String {
-			var index : int = readInt(true);
-			return index == 0 ? null : strings[index - 1];
-		}
-
-		public function readString () : String {
-			var byteCount : int = readInt(true);
-			switch (byteCount) {
-			case 0:
-				return null;
-			case 1:
-				return "";
-			}
-			byteCount--;
-			var chars : String = "";
-			for (var i : int = 0; i < byteCount;) {
-				var b : int = readByte();
-				switch (b >> 4) {
-				case 12:
-				case 13:
-					chars += String.fromCharCode(((b & 0x1F) << 6 | readByte() & 0x3F));
-					i += 2;
-					break;
-				case 14:
-					chars += String.fromCharCode(((b & 0x0F) << 12 | (readByte() & 0x3F) << 6 | readByte() & 0x3F));
-					i += 3;
-					break;
-				default:
-					chars += String.fromCharCode(b);
-					i++;
-				}
-			}
-			return chars;
-		}
-
-		public function readFloat (): Number {
-			return bytes.readFloat();
-		}
-
-		public function readBoolean (): Boolean {
-			return this.readByte() != 0;
-		}
-	}
-}

spine-as3/spine-as3/src/spine/BlendMode.as

@@ -1,44 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine {
-	public class BlendMode {
-		public static const normal : BlendMode = new BlendMode(0);
-		public static const additive : BlendMode = new BlendMode(1);
-		public static const multiply : BlendMode = new BlendMode(2);
-		public static const screen : BlendMode = new BlendMode(3);
-		public var ordinal : int;
-
-		public function BlendMode(ordinal : int) {
-			this.ordinal = ordinal;
-		}
-		
-		public static const values : Array = [ normal, additive, multiply, screen ];
-	}
-}

spine-as3/spine-as3/src/spine/Bone.as

@@ -1,334 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine {
-	public class Bone implements Updatable {
-		static public var yDown : Boolean;
-		internal var _data : BoneData;
-		internal var _skeleton : Skeleton;
-		internal var _parent : Bone;
-		internal var _children : Vector.<Bone> = new Vector.<Bone>();
-		public var x : Number;
-		public var y : Number;
-		public var rotation : Number;
-		public var scaleX : Number;
-		public var scaleY : Number;
-		public var shearX : Number;
-		public var shearY : Number;
-		public var ax : Number;
-		public var ay : Number;
-		public var arotation : Number;
-		public var ascaleX : Number;
-		public var ascaleY : Number;
-		public var ashearX : Number;
-		public var ashearY : Number;
-		public var a : Number;
-		public var b : Number;
-		public var c : Number;
-		public var d : Number;
-		public var worldX : Number;
-		public var worldY : Number;
-		internal var _sorted : Boolean;
-		public var active : Boolean;
-
-
-		/** @param parent May be null. */
-		public function Bone(data : BoneData, skeleton : Skeleton, parent : Bone) {
-			if (data == null) throw new ArgumentError("data cannot be null.");
-			if (skeleton == null) throw new ArgumentError("skeleton cannot be null.");
-			_data = data;
-			_skeleton = skeleton;
-			_parent = parent;
-			setToSetupPose();
-		}
-
-		public function isActive() : Boolean {
-			return active;
-		}
-
-		/** Computes the world transform using the parent bone and this bone's local applied transform. */
-		public function update() : void {
-			updateWorldTransformWith(ax, ay, arotation, ascaleX, ascaleY, ashearX, ashearY);
-		}
-
-		/** Computes the world transform using the parent bone and this bone's local transform. */
-		public function updateWorldTransform() : void {
-			updateWorldTransformWith(x, y, rotation, scaleX, scaleY, shearX, shearY);
-		}
-
-		/** Computes the world transform using the parent bone and the specified local transform. The applied transform is set to the
-		 * specified local transform. Child bones are not updated.
-		 * <p>
-		 * See <a href="http://esotericsoftware.com/spine-runtime-skeletons#World-transforms">World transforms</a> in the Spine
-		 * Runtimes Guide. */
-		public function updateWorldTransformWith(x : Number, y : Number, rotation : Number, scaleX : Number, scaleY : Number, shearX : Number, shearY : Number) : void {
-			ax = x;
-			ay = y;
-			arotation = rotation;
-			ascaleX = scaleX;
-			ascaleY = scaleY;
-			ashearX = shearX;
-			ashearY = shearY;
-
-			var rotationY : Number = 0, la : Number = 0, lb : Number = 0, lc : Number = 0, ld : Number = 0;
-			var sin : Number = 0, cos : Number = 0;
-			var s : Number = 0;
-			var sx : Number = _skeleton.scaleX;
-			var sy : Number = _skeleton.scaleY * (yDown ? -1 : 1);
-
-			var parent : Bone = _parent;
-			if (!parent) { // Root bone.
-				rotationY = rotation + 90 + shearY;
-				a = MathUtils.cosDeg(rotation + shearX) * scaleX * sx;
-				b = MathUtils.cosDeg(rotationY) * scaleY * sx;
-				c = MathUtils.sinDeg(rotation + shearX) * scaleX * sy;
-				d = MathUtils.sinDeg(rotationY) * scaleY * sy;
-				worldX = x * sx + _skeleton.x;
-				worldY = y * sy + _skeleton.y;
-				return;
-			}
-
-			var pa : Number = parent.a, pb : Number = parent.b, pc : Number = parent.c, pd : Number = parent.d;
-			worldX = pa * x + pb * y + parent.worldX;
-			worldY = pc * x + pd * y + parent.worldY;
-
-			switch (data.transformMode) {
-				case TransformMode.normal: {
-					rotationY = rotation + 90 + shearY;
-					la = MathUtils.cosDeg(rotation + shearX) * scaleX;
-					lb = MathUtils.cosDeg(rotationY) * scaleY;
-					lc = MathUtils.sinDeg(rotation + shearX) * scaleX;
-					ld = MathUtils.sinDeg(rotationY) * scaleY;
-					a = pa * la + pb * lc;
-					b = pa * lb + pb * ld;
-					c = pc * la + pd * lc;
-					d = pc * lb + pd * ld;
-					return;
-				}
-				case TransformMode.onlyTranslation: {
-					rotationY = rotation + 90 + shearY;
-					a = MathUtils.cosDeg(rotation + shearX) * scaleX;
-					b = MathUtils.cosDeg(rotationY) * scaleY;
-					c = MathUtils.sinDeg(rotation + shearX) * scaleX;
-					d = MathUtils.sinDeg(rotationY) * scaleY;
-					break;
-				}
-				case TransformMode.noRotationOrReflection: {
-					s = pa * pa + pc * pc;
-					var prx : Number = 0;
-					if (s > 0.0001) {
-						s = Math.abs(pa * pd - pb * pc) / s;
-						pa /= _skeleton.scaleX;
-						pc /= _skeleton.scaleY;
-						pb = pc * s;
-						pd = pa * s;
-						prx = Math.atan2(pc, pa) * MathUtils.radDeg;
-					} else {
-						pa = 0;
-						pc = 0;
-						prx = 90 - Math.atan2(pd, pb) * MathUtils.radDeg;
-					}
-					var rx : Number = rotation + shearX - prx;
-					var ry : Number = rotation + shearY - prx + 90;
-					la = MathUtils.cosDeg(rx) * scaleX;
-					lb = MathUtils.cosDeg(ry) * scaleY;
-					lc = MathUtils.sinDeg(rx) * scaleX;
-					ld = MathUtils.sinDeg(ry) * scaleY;
-					a = pa * la - pb * lc;
-					b = pa * lb - pb * ld;
-					c = pc * la + pd * lc;
-					d = pc * lb + pd * ld;
-					break;
-				}
-				case TransformMode.noScale:
-				case TransformMode.noScaleOrReflection: {
-					cos = MathUtils.cosDeg(rotation);
-					sin = MathUtils.sinDeg(rotation);
-					var za : Number = (pa * cos + pb * sin) / sx;
-					var zc : Number = (pc * cos + pd * sin) / sy;
-					s = Math.sqrt(za * za + zc * zc);
-					if (s > 0.00001) s = 1 / s;
-					za *= s;
-					zc *= s;
-					s = Math.sqrt(za * za + zc * zc);
-					if (data.transformMode == TransformMode.noScale
-						&& (pa * pd - pb * pc < 0) != (sx < 0 != sy < 0)) s = -s;
-					var r : Number = Math.PI / 2 + Math.atan2(zc, za);
-					var zb : Number = Math.cos(r) * s;
-					var zd : Number = Math.sin(r) * s;
-					la = MathUtils.cosDeg(shearX) * scaleX;
-					lb = MathUtils.cosDeg(90 + shearY) * scaleY;
-					lc = MathUtils.sinDeg(shearX) * scaleX;
-					ld = MathUtils.sinDeg(90 + shearY) * scaleY;
-					a = za * la + zb * lc;
-					b = za * lb + zb * ld;
-					c = zc * la + zd * lc;
-					d = zc * lb + zd * ld;
-					break;
-				}
-			}
-			a *= sx;
-			b *= sx;
-			c *= sy;
-			d *= sy;
-		}
-
-		public function setToSetupPose() : void {
-			x = data.x;
-			y = data.y;
-			rotation = data.rotation;
-			scaleX = data.scaleX;
-			scaleY = data.scaleY;
-			shearX = data.shearX;
-			shearY = data.shearY;
-		}
-
-		public function get data() : BoneData {
-			return _data;
-		}
-
-		public function get skeleton() : Skeleton {
-			return _skeleton;
-		}
-
-		public function get parent() : Bone {
-			return _parent;
-		}
-
-		public function get children() : Vector.<Bone> {
-			;
-			return _children;
-		}
-
-		public function get worldRotationX() : Number {
-			return Math.atan2(c, a) * MathUtils.radDeg;
-		}
-
-		public function get worldRotationY() : Number {
-			return Math.atan2(d, b) * MathUtils.radDeg;
-		}
-
-		public function get worldScaleX() : Number {
-			return Math.sqrt(a * a + c * c);
-		}
-
-		public function get worldScaleY() : Number {
-			return Math.sqrt(b * b + d * d);
-		}
-
-		/** Computes the applied transform values from the world transform.
-		 * <p>
-		 * If the world transform is modified (by a constraint, {@link #rotateWorld(float)}, etc) then this method should be called so
-		 * the applied transform matches the world transform. The applied transform may be needed by other code (eg to apply another
-		 * constraint).
-		 * <p>
-		 * Some information is ambiguous in the world transform, such as -1,-1 scale versus 180 rotation. The applied transform after
-		 * calling this method is equivalent to the local transform used to compute the world transform, but may not be identical. */
-		internal function updateAppliedTransform() : void {
-			var parent : Bone = this.parent;
-			if (parent == null) {
-				ax = worldX - skeleton.x;
-				ay = worldY - skeleton.y;
-				arotation = Math.atan2(c, a) * MathUtils.radDeg;
-				ascaleX = Math.sqrt(a * a + c * c);
-				ascaleY = Math.sqrt(b * b + d * d);
-				ashearX = 0;
-				ashearY = Math.atan2(a * b + c * d, a * d - b * c) * MathUtils.radDeg;
-				return;
-			}
-			var pa : Number = parent.a, pb : Number = parent.b, pc : Number = parent.c, pd : Number = parent.d;
-			var pid : Number = 1 / (pa * pd - pb * pc);
-			var dx : Number = worldX - parent.worldX, dy : Number = worldY - parent.worldY;
-			ax = (dx * pd * pid - dy * pb * pid);
-			ay = (dy * pa * pid - dx * pc * pid);
-			var ia : Number = pid * pd;
-			var id : Number = pid * pa;
-			var ib : Number = pid * pb;
-			var ic : Number = pid * pc;
-			var ra : Number = ia * a - ib * c;
-			var rb : Number = ia * b - ib * d;
-			var rc : Number = id * c - ic * a;
-			var rd : Number = id * d - ic * b;
-			ashearX = 0;
-			ascaleX = Math.sqrt(ra * ra + rc * rc);
-			if (scaleX > 0.0001) {
-				var det : Number = ra * rd - rb * rc;
-				ascaleY = det / ascaleX;
-				ashearY = Math.atan2(ra * rb + rc * rd, det) * MathUtils.radDeg;
-				arotation = Math.atan2(rc, ra) * MathUtils.radDeg;
-			} else {
-				ascaleX = 0;
-				ascaleY = Math.sqrt(rb * rb + rd * rd);
-				ashearY = 0;
-				arotation = 90 - Math.atan2(rd, rb) * MathUtils.radDeg;
-			}
-		}
-
-		public function worldToLocal(world : Vector.<Number>) : void {
-			var invDet : Number = 1 / (a * d - b * c);
-			var x : Number = world[0] - worldX, y : Number = world[1] - worldY;
-			world[0] = x * d * invDet - y * b * invDet;
-			world[1] = y * a * invDet - x * c * invDet;
-		}
-
-		public function localToWorld(local : Vector.<Number>) : void {
-			var localX : Number = local[0], localY : Number = local[1];
-			local[0] = localX * a + localY * b + worldX;
-			local[1] = localX * c + localY * d + worldY;
-		}
-
-		public function worldToLocalRotation(worldRotation : Number) : Number {
-			var sin : Number = MathUtils.sinDeg(worldRotation), cos : Number = MathUtils.cosDeg(worldRotation);
-			return Math.atan2(a * sin - c * cos, d * cos - b * sin) * MathUtils.radDeg + rotation - shearX;
-		}
-
-		public function localToWorldRotation(localRotation : Number) : Number {
-			localRotation -= rotation - shearX;
-			var sin : Number = MathUtils.sinDeg(localRotation), cos : Number = MathUtils.cosDeg(localRotation);
-			return Math.atan2(cos * c + sin * d, cos * a + sin * b) * MathUtils.radDeg;
-		}
-
-		/** Rotates the world transform the specified amount.
-		 * <p>
-		 * After changes are made to the world transform, {@link #updateAppliedTransform()} should be called and {@link #update()} will
-		 * need to be called on any child bones, recursively. */
-		public function rotateWorld(degrees : Number) : void {
-			var cos : Number = MathUtils.cosDeg(degrees), sin : Number = MathUtils.sinDeg(degrees);
-			var a : Number = this.a, b : Number = this.b, c : Number = this.c, d : Number = this.d;
-			this.a = cos * a - sin * c;
-			this.b = cos * b - sin * d;
-			this.c = sin * a + cos * c;
-			this.d = sin * b + cos * d;
-		}
-
-		public function toString() : String {
-			return this.data._name;
-		}
-	}
-}

spine-as3/spine-as3/src/spine/BoneData.as

@@ -1,73 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine {
-	public class BoneData {
-		internal var _index : int;
-		internal var _name : String;
-		internal var _parent : BoneData;
-		public var length : Number;
-		public var x : Number;
-		public var y : Number;
-		public var rotation : Number;
-		public var scaleX : Number = 1;
-		public var scaleY : Number = 1;
-		public var shearX : Number;
-		public var shearY : Number;
-		public var transformMode : TransformMode = TransformMode.normal;
-		public var skinRequired : Boolean;
-		public var color : Color = new Color(0, 0, 0, 0);
-
-		/** @param parent May be null. */
-		public function BoneData(index : int, name : String, parent : BoneData) {
-			if (index < 0) throw new ArgumentError("index must be >= 0");
-			if (name == null) throw new ArgumentError("name cannot be null.");
-			_index = index;
-			_name = name;
-			_parent = parent;
-		}
-
-		public function get index() : int {
-			return _index;
-		}
-
-		public function get name() : String {
-			return _name;
-		}
-
-		/** @return May be null. */
-		public function get parent() : BoneData {
-			return _parent;
-		}
-
-		public function toString() : String {
-			return _name;
-		}
-	}
-}

spine-as3/spine-as3/src/spine/Color.as

@@ -1,118 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine {
-	public class Color {
-		public static var WHITE : Color = new Color(1, 1, 1, 1);
-		public static var RED : Color = new Color(1, 0, 0, 1);
-		public static var GREEN : Color = new Color(0, 1, 0, 1);
-		public static var BLUE : Color = new Color(0, 0, 1, 1);
-		public static var MAGENTA : Color = new Color(1, 0, 1, 1);
-
-		public var r : Number;
-		public var g : Number;
-		public var b : Number;
-		public var a : Number;
-
-		public function Color(r : Number, g : Number, b : Number, a : Number = 0) {
-			this.r = r;
-			this.g = g;
-			this.b = b;
-			this.a = a;
-		}
-
-		public function setFromColor(c : Color) : Color {
-			r = c.r;
-			g = c.g;
-			b = c.b;
-			a = c.a;
-			return this;
-		}
-
-		public function setFromString(hex : String) : Color {
-			if (hex.length != 8 && hex.length != 6) throw new ArgumentError("Hexadecimal color length must be 6 or 8: " + hex);
-			hex = hex.charAt(0) == '#' ? hex.substr(1) : hex;
-			r = parseInt(hex.substr(0, 2), 16) / 255.0;
-			g = parseInt(hex.substr(2, 2), 16) / 255.0;
-			b = parseInt(hex.substr(4, 2), 16) / 255.0;
-			a = (hex.length != 8 ? 255 : parseInt(hex.substr(6, 2), 16)) / 255.0;
-			return this;
-		}
-
-		public function set(r : Number, g : Number, b : Number, a : Number) : Color {
-			this.r = r;
-			this.g = g;
-			this.b = b;
-			this.a = a;
-			clamp();
-			return this;
-		}
-
-		public function add(r : Number, g : Number, b : Number, a : Number) : Color {
-			this.r += r;
-			this.g += g;
-			this.b += b;
-			this.a += a;
-			clamp();
-			return this;
-		}
-
-		public function clamp() : Color {
-			if (r < 0) r = 0;
-			else if (r > 1) r = 1;
-
-			if (g < 0) g = 0;
-			else if (g > 1) g = 1;
-
-			if (b < 0) b = 0;
-			else if (b > 1) b = 1;
-
-			if (a < 0) a = 0;
-			else if (a > 1) a = 1;
-			return this;
-		}
-		
-		public function setFromRgba8888(value: int) : void {
-			r = ((value & 0xff000000) >>> 24) / 255;
-			g = ((value & 0x00ff0000) >>> 16) / 255;
-			b = ((value & 0x0000ff00) >>> 8) / 255;
-			a = ((value & 0x000000ff)) / 255;
-		}
-
-		public function setFromRgb888(value: int) : void {
-			r = ((value & 0x00ff0000) >>> 16) / 255;
-			g = ((value & 0x0000ff00) >>> 8) / 255;
-			b = ((value & 0x000000ff)) / 255;
-		}
-
-		static public function fromString (hex : String) : Color {
-			return new Color(0, 0, 0, 0).setFromString(hex);
-		}
-	}
-}

spine-as3/spine-as3/src/spine/ConstraintData.as

@@ -1,46 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine {
-	public class ConstraintData {
-		public var name: String;
-		public var order: Number;
-		public var skinRequired: Boolean;	
-		
-		function ConstraintData(name: String, order: Number, skinRequired: Boolean) {
-			this.name = name;
-			this.order = order;
-			this.skinRequired = skinRequired;	
-		}
-		
-		public function toString() : String {
-			return name;
-		}
-	}
-}

spine-as3/spine-as3/src/spine/Event.as

@@ -1,54 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine {
-	public class Event {
-		internal var _data : EventData;
-		public var time : Number;
-		public var intValue : int;
-		public var floatValue : Number;
-		public var stringValue : String;
-		public var volume: Number = 1;
-		public var balance: Number = 0;
-
-		public function Event(time : Number, data : EventData) {
-			if (data == null) throw new ArgumentError("data cannot be null.");
-			this.time = time;
-			_data = data;
-		}
-
-		public function get data() : EventData {
-			return _data;
-		}
-
-		public function toString() : String {
-			return _data._name;
-		}
-	}
-}

spine-as3/spine-as3/src/spine/EventData.as

@@ -1,53 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine {
-	public class EventData {
-		internal var _name : String;
-		public var intValue : int;		
-		public var floatValue : Number;
-		public var stringValue : String;
-		public var audioPath: String;
-		public var volume: Number = 1;
-		public var balance: Number = 0;
-
-		public function EventData(name : String) {
-			if (name == null) throw new ArgumentError("name cannot be null.");
-			_name = name;
-		}
-
-		public function get name() : String {
-			return _name;
-		}
-
-		public function toString() : String {
-			return _name;
-		}
-	}
-}

spine-as3/spine-as3/src/spine/IkConstraint.as

@@ -1,278 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine {
-	public class IkConstraint implements Updatable {
-		internal var _data : IkConstraintData;
-		public var bones : Vector.<Bone>;
-		public var target : Bone;
-		public var bendDirection : int;
-		public var compress: Boolean;
-		public var stretch: Boolean;
-		public var mix : Number;
-		public var softness : Number = 0;
-		public var active : Boolean;
-
-		public function IkConstraint(data : IkConstraintData, skeleton : Skeleton) {
-			if (data == null) throw new ArgumentError("data cannot be null.");
-			if (skeleton == null) throw new ArgumentError("skeleton cannot be null.");
-			_data = data;
-			mix = data.mix;
-			softness = data.softness;
-			bendDirection = data.bendDirection;
-			compress = data.compress;
-			stretch = data.stretch;
-
-			bones = new Vector.<Bone>();
-			for each (var boneData : BoneData in data.bones)
-				bones[bones.length] = skeleton.findBone(boneData.name);
-			target = skeleton.findBone(data.target._name);
-		}
-
-		public function isActive() : Boolean {
-			return active;
-		}
-
-		public function update() : void {
-			if (mix == 0) return;
-			switch (bones.length) {
-				case 1:
-					apply1(bones[0], target.worldX, target.worldY, compress, stretch, _data.uniform, mix);
-					break;
-				case 2:
-					apply2(bones[0], bones[1], target.worldX, target.worldY, bendDirection, stretch, _data.uniform, softness, mix);
-					break;
-			}
-		}
-
-		public function get data() : IkConstraintData {
-			return _data;
-		}
-
-		public function toString() : String {
-			return _data.name;
-		}
-
-		/** Adjusts the bone rotation so the tip is as close to the target position as possible. The target is specified in the world
-		 * coordinate system. */
-		static public function apply1(bone : Bone, targetX : Number, targetY : Number, compress: Boolean, stretch : Boolean, uniform: Boolean, alpha : Number) : void {
-			var p : Bone = bone.parent;
-			var pa : Number = p.a, pb : Number = p.b, pc : Number = p.c, pd : Number = p.d;
-			var rotationIK : Number = -bone.ashearX - bone.arotation, tx : Number = 0, ty : Number = 0;
-			switch(bone.data.transformMode) {
-				case TransformMode.onlyTranslation:
-					tx = targetX - bone.worldX;
-					ty = targetY - bone.worldY;
-					break;
-				case TransformMode.noRotationOrReflection:
-					var s : Number = Math.abs(pa * pd - pb * pc) / (pa * pa + pc * pc);
-					var sa : Number = pa / bone.skeleton.scaleX;
-					var sc : Number = pc / bone.skeleton.scaleY;
-					pb = -sc * s * bone.skeleton.scaleX;
-					pd = sa * s * bone.skeleton.scaleY;
-					rotationIK += Math.atan2(sc, sa) * MathUtils.radDeg;
-					// Fall through.
-				default:
-					var x : Number = targetX - p.worldX, y : Number = targetY - p.worldY;
-					var d : Number = pa * pd - pb * pc;
-					tx = (x * pd - y * pb) / d - bone.ax;
-					ty = (y * pa - x * pc) / d - bone.ay;
-			}
-
-			rotationIK += Math.atan2(ty, tx) * MathUtils.radDeg;
-			if (bone.ascaleX < 0) rotationIK += 180;
-			if (rotationIK > 180)
-				rotationIK -= 360;
-			else if (rotationIK < -180) rotationIK += 360;
-			var sx : Number = bone.ascaleX;
-			var sy : Number = bone.ascaleY;
-			if (compress || stretch) {
-				switch (bone.data.transformMode) {
-					case TransformMode.noScale:
-					case TransformMode.noScaleOrReflection:
-						tx = targetX - bone.worldX;
-						ty = targetY - bone.worldY;
-				}
-				var b : Number = bone.data.length * sx, dd : Number = Math.sqrt(tx * tx + ty * ty);
-				if ((compress && dd < b) || (stretch && dd > b) && b > 0.0001) {
-					var ss : Number = (dd / b - 1) * alpha + 1;
-					sx *= ss;
-					if (uniform) sy *= ss;
-				}
-			}
-			bone.updateWorldTransformWith(bone.ax, bone.ay, bone.arotation + rotationIK * alpha, sx, sy, bone.ashearX, bone.ashearY);
-		}
-
-		/** Adjusts the parent and child bone rotations so the tip of the child is as close to the target position as possible. The
-		 * target is specified in the world coordinate system.
-		 * @param child Any descendant bone of the parent. */
-		static public function apply2(parent : Bone, child : Bone, targetX : Number, targetY : Number, bendDir : int, stretch : Boolean, uniform : Boolean, softness: Number, alpha : Number) : void {
-			var px : Number = parent.ax, py : Number = parent.ay, psx : Number = parent.ascaleX, psy : Number = parent.ascaleY, sx : Number = psx, sy : Number = psy, csx : Number = child.ascaleX;
-			var os1 : int, os2 : int, s2 : int;
-			if (psx < 0) {
-				psx = -psx;
-				os1 = 180;
-				s2 = -1;
-			} else {
-				os1 = 0;
-				s2 = 1;
-			}
-			if (psy < 0) {
-				psy = -psy;
-				s2 = -s2;
-			}
-			if (csx < 0) {
-				csx = -csx;
-				os2 = 180;
-			} else
-				os2 = 0;
-			var cx : Number = child.ax, cy : Number, cwx : Number, cwy : Number, a : Number = parent.a, b : Number = parent.b, c : Number = parent.c, d : Number = parent.d;
-			var u : Boolean = Math.abs(psx - psy) <= 0.0001;
-			if (!u || stretch) {
-				cy = 0;
-				cwx = a * cx + parent.worldX;
-				cwy = c * cx + parent.worldY;
-			} else {
-				cy = child.ay;
-				cwx = a * cx + b * cy + parent.worldX;
-				cwy = c * cx + d * cy + parent.worldY;
-			}
-			var pp : Bone = parent.parent;
-			a = pp.a;
-			b = pp.b;
-			c = pp.c;
-			d = pp.d;
-			var id : Number = 1 / (a * d - b * c), x : Number = cwx - pp.worldX, y : Number = cwy - pp.worldY;
-			var dx : Number = (x * d - y * b) * id - px, dy : Number = (y * a - x * c) * id - py;
-			var l1 : Number = Math.sqrt(dx * dx + dy * dy), l2 : Number = child.data.length * csx, a1 : Number, a2 : Number;
-			if (l1 < 0.0001) {
-				apply1(parent, targetX, targetY, false, stretch, false, alpha);
-				child.updateWorldTransformWith(cx, cy, 0, child.ascaleX, child.ascaleY, child.ashearX, child.ashearY);
-				return;
-			}
-			x = targetX - pp.worldX;
-			y = targetY - pp.worldY;
-			var tx : Number = (x * d - y * b) * id - px, ty : Number = (y * a - x * c) * id - py;
-			var dd : Number = tx * tx + ty * ty;
-			if (softness != 0) {
-				softness *= psx * (csx + 1) * 0.5;
-				var td : Number = Math.sqrt(dd), sd : Number = td - l1 - l2 * psx + softness;
-				if (sd > 0) {
-					var p : Number = Math.min(1, sd / (softness * 2)) - 1;
-					p = (sd - softness * (1 - p * p)) / td;
-					tx -= p * tx;
-					ty -= p * ty;
-					dd = tx * tx + ty * ty;
-				}
-			}
-			outer:
-			if (u) {
-				l2 *= psx;
-				var cos : Number = (dd - l1 * l1 - l2 * l2) / (2 * l1 * l2);
-				if (cos < -1) {
-					cos = -1;
-					a2 = Math.PI * bendDir;
-				} else if (cos > 1) {
-					cos = 1;
-					a2 = 0;
-					if (stretch) {
-						a = (Math.sqrt(dd) / (l1 + l2) - 1) * alpha + 1;
-						sx *= a;
-						if (uniform) sy *= a;
-					}
-				} else
-					a2 = Math.acos(cos) * bendDir;
-				a = l1 + l2 * cos;
-				b = l2 * Math.sin(a2);
-				a1 = Math.atan2(ty * a - tx * b, tx * a + ty * b);
-			} else {
-				a = psx * l2;
-				b = psy * l2;
-				var aa : Number = a * a, bb : Number = b * b, ta : Number = Math.atan2(ty, tx);
-				c = bb * l1 * l1 + aa * dd - aa * bb;
-				var c1 : Number = -2 * bb * l1, c2 : Number = bb - aa;
-				d = c1 * c1 - 4 * c2 * c;
-				if (d >= 0) {
-					var q : Number = Math.sqrt(d);
-					if (c1 < 0) q = -q;
-					q = -(c1 + q) * 0.5;
-					var r0 : Number = q / c2, r1 : Number = c / q;
-					var r : Number = Math.abs(r0) < Math.abs(r1) ? r0 : r1;
-					if (r * r <= dd) {
-						y = Math.sqrt(dd - r * r) * bendDir;
-						a1 = ta - Math.atan2(y, r);
-						a2 = Math.atan2(y / psy, (r - l1) / psx);
-						break outer;
-					}
-				}
-				var minAngle : Number = Math.PI, minX : Number = l1 - a, minDist : Number = minX * minX, minY : Number = 0;
-				var maxAngle : Number = 0, maxX : Number = l1 + a, maxDist : Number = maxX * maxX, maxY : Number = 0;
-				c = -a * l1 / (aa - bb);
-				if (c >= -1 && c <= 1) {
-					c = Math.acos(c);
-					x = a * Math.cos(c) + l1;
-					y = b * Math.sin(c);
-					d = x * x + y * y;
-					if (d < minDist) {
-						minAngle = c;
-						minDist = d;
-						minX = x;
-						minY = y;
-					}
-					if (d > maxDist) {
-						maxAngle = c;
-						maxDist = d;
-						maxX = x;
-						maxY = y;
-					}
-				}
-				if (dd <= (minDist + maxDist) * 0.5) {
-					a1 = ta - Math.atan2(minY * bendDir, minX);
-					a2 = minAngle * bendDir;
-				} else {
-					a1 = ta - Math.atan2(maxY * bendDir, maxX);
-					a2 = maxAngle * bendDir;
-				}
-			}
-			var os : Number = Math.atan2(cy, cx) * s2;
-			var rotation : Number = parent.arotation;
-			a1 = (a1 - os) * MathUtils.radDeg + os1 - rotation;
-			if (a1 > 180)
-				a1 -= 360;
-			else if (a1 < -180) a1 += 360;
-			parent.updateWorldTransformWith(px, py, rotation + a1 * alpha, sx, sy, 0, 0);
-			rotation = child.arotation;
-			a2 = ((a2 + os) * MathUtils.radDeg - child.ashearX) * s2 + os2 - rotation;
-			if (a2 > 180)
-				a2 -= 360;
-			else if (a2 < -180) a2 += 360;
-			child.updateWorldTransformWith(cx, cy, rotation + a2 * alpha, child.ascaleX, child.ascaleY, child.ashearX, child.ashearY);
-		}
-	}
-}

spine-as3/spine-as3/src/spine/IkConstraintData.as

@@ -1,45 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine {
-	public class IkConstraintData extends ConstraintData {		
-		public var bones : Vector.<BoneData> = new Vector.<BoneData>();
-		public var target : BoneData;
-		public var mix : Number = 1;
-		public var bendDirection : int = 1;
-		public var compress : Boolean = false;
-		public var stretch : Boolean = false;
-		public var uniform : Boolean = false;
-		public var softness : Number = 0;
-
-		public function IkConstraintData(name : String) {
-			super(name, 0, false);			
-		}
-	}
-}

spine-as3/spine-as3/src/spine/Interpolation.as

@@ -1,40 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine {
-	public class Interpolation {		
-		protected function applyInternal (a : Number) : Number {
-			return a;
-		}
-		
-		public function apply (start : Number, end : Number, a : Number) : Number {
-			return start + (end - start) * applyInternal(a);
-		}
-	}
-}

spine-as3/spine-as3/src/spine/MathUtils.as

@@ -1,66 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine {
-	public class MathUtils {
-		static public var PI : Number = Math.PI;
-		static public var PI2 : Number = Math.PI * 2;
-		static public var radDeg : Number = 180 / Math.PI;
-		static public var degRad : Number = Math.PI / 180;
-
-		static public function cosDeg(degrees : Number) : Number {
-			return Math.cos(degrees * degRad);
-		}
-
-		static public function sinDeg(degrees : Number) : Number {
-			return Math.sin(degrees * degRad);
-		}
-
-		static public function clamp(value : Number, min : Number, max : Number) : Number {
-			if (value < min) return min;
-			if (value > max) return max;
-			return value;
-		}
-
-		static public function signum(value : Number) : Number {
-			return value > 0 ? 1 : value < 0 ? -1 : 0;
-		}
-
-		static public function randomTriangular(min : Number, max : Number) : Number {
-			return randomTriangularWith(min, max, (min + max) * 0.5);
-		}
-
-		static public function randomTriangularWith(min : Number, max : Number, mode : Number) : Number {
-			var u : Number = Math.random();
-			var d : Number = max - min;
-			if (u <= (mode - min) / d) return min + Math.sqrt(u * d * (mode - min));
-			return max - Math.sqrt((1 - u) * d * (max - mode));
-		}
-	}
-}

spine-as3/spine-as3/src/spine/PathConstraint.as

@@ -1,498 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine {
-	import spine.attachments.PathAttachment;
-
-	public class PathConstraint implements Updatable {
-		private static const NONE : int = -1, BEFORE : int = -2, AFTER : int = -3;
-		private static const epsilon : Number = 0.00001;
-
-		internal var _data : PathConstraintData;
-		internal var _bones : Vector.<Bone>;
-		public var target : Slot;
-		public var position : Number, spacing : Number, mixRotate : Number, mixX : Number, mixY : Number;
-		internal const _spaces : Vector.<Number> = new Vector.<Number>();
-		internal const _positions : Vector.<Number> = new Vector.<Number>();
-		internal const _world : Vector.<Number> = new Vector.<Number>();
-		internal const _curves : Vector.<Number> = new Vector.<Number>();
-		internal const _lengths : Vector.<Number> = new Vector.<Number>();
-		internal const _segments : Vector.<Number> = new Vector.<Number>(10, true);
-		public var active : Boolean;
-
-		public function PathConstraint(data : PathConstraintData, skeleton : Skeleton) {
-			if (data == null) throw new ArgumentError("data cannot be null.");
-			if (skeleton == null) throw new ArgumentError("skeleton cannot be null.");
-			_data = data;
-			_bones = new Vector.<Bone>();
-			for each (var boneData : BoneData in data.bones)
-				_bones.push(skeleton.findBone(boneData.name));
-			target = skeleton.findSlot(data.target.name);
-			position = data.position;
-			spacing = data.spacing;
-			mixRotate = data.mixRotate;
-			mixX = data.mixX;
-			mixY = data.mixY;
-		}
-		
-		public function isActive() : Boolean {
-			return active;
-		}
-
-		public function apply() : void {
-			update();
-		}
-
-		public function update() : void {
-			var attachment : PathAttachment = target.attachment as PathAttachment;
-			if (attachment == null) return;
-
-			var mixRotate : Number = this.mixRotate, mixX : Number = this.mixX, mixY : Number = this.mixY;
-			if (mixRotate == 0 && mixX == 0 && mixY == 0) return;
-
-			var data : PathConstraintData = this._data;
-			var tangents : Boolean = data.rotateMode == RotateMode.tangent, scale : Boolean = data.rotateMode == RotateMode.chainScale;
-
-			var bones : Vector.<Bone> = this._bones;
-			var boneCount : int = bones.length, spacesCount : int = tangents ? boneCount : boneCount + 1;
-			this._spaces.length = spacesCount;
-			var spaces : Vector.<Number> = this._spaces, lengths : Vector.<Number> = _lengths;
-			if (scale) lengths.length = boneCount;
-			var spacing : Number = this.spacing;
-
-			var i : int, n : int, bone : Bone, setupLength : int, x : Number, y : Number, length : Number;
-
-			switch (data.spacingMode) {
-			case SpacingMode.percent:
-				if (scale) {
-					for (i = 0, n = spacesCount - 1; i < n; i++) {
-						bone = bones[i];
-						setupLength = bone.data.length;
-						if (setupLength < PathConstraint.epsilon)
-							lengths[i] = 0;
-						else {
-							x = setupLength * bone.a;
-							y = setupLength * bone.c;
-							lengths[i] = Math.sqrt(x * x + y * y);
-						}
-					}
-				}
-				for (i = 1; i < spacesCount; i++)
-					spaces[i] = spacing;
-				break;
-			case SpacingMode.proportional:
-				var sum : Number = 0;
-				for (i = 0, n = spacesCount - 1; i < n;) {
-					bone = bones[i];
-					setupLength = bone.data.length;
-					if (setupLength < PathConstraint.epsilon) {
-						if (scale) lengths[i] = 0;
-						spaces[++i] = spacing;
-					} else {
-						x = setupLength * bone.a;
-						y = setupLength * bone.c;
-						length = Math.sqrt(x * x + y * y);
-						if (scale) lengths[i] = length;
-						spaces[++i] = length;
-						sum += length;
-					}
-				}
-				if (sum > 0) {
-					sum = spacesCount / sum * spacing;
-					for (i = 1; i < spacesCount; i++)
-						spaces[i] *= sum;
-				}
-				break;
-			default:
-				var lengthSpacing : Boolean = data.spacingMode == SpacingMode.length;
-				for (i = 0, n = spacesCount - 1; i < n;) {
-					bone = bones[i];
-					setupLength = bone.data.length;
-					if (setupLength < PathConstraint.epsilon) {
-						if (scale) lengths[i] = 0;
-						spaces[++i] = spacing;
-					} else {
-						x = setupLength * bone.a;
-						y = setupLength * bone.c;
-						length = Math.sqrt(x * x + y * y);
-						if (scale) lengths[i] = length;
-						spaces[++i] = (lengthSpacing ? setupLength + spacing : spacing) * length / setupLength;
-					}
-				}
-			}
-
-			var positions : Vector.<Number> = computeWorldPositions(attachment, spacesCount, tangents);
-			var boneX : Number = positions[0], boneY : Number = positions[1], offsetRotation : Number = data.offsetRotation;
-			var tip : Boolean = false;
-			if (offsetRotation == 0)
-				tip = data.rotateMode == RotateMode.chain;
-			else {
-				tip = false;
-				var pa : Bone = target.bone;
-				offsetRotation *= pa.a * pa.d - pa.b * pa.c > 0 ? MathUtils.degRad : -MathUtils.degRad;
-			}
-			var p : int;
-			for (i = 0, p = 3; i < boneCount; i++, p += 3) {
-				bone = bones[i];
-				bone.worldX += (boneX - bone.worldX) * mixX;
-				bone.worldY += (boneY - bone.worldY) * mixY;
-				x = positions[p];
-				y = positions[p + 1];
-				var dx : Number = x - boneX, dy : Number = y - boneY;
-				if (scale) {
-					length = lengths[i];
-					if (length != 0) {
-						var s : Number = (Math.sqrt(dx * dx + dy * dy) / length - 1) * mixRotate + 1;
-						bone.a *= s;
-						bone.c *= s;
-					}
-				}
-				boneX = x;
-				boneY = y;
-				if (mixRotate > 0) {
-					var a : Number = bone.a, b : Number = bone.b, c : Number = bone.c, d : Number = bone.d, r : Number, cos : Number, sin : Number;
-					if (tangents)
-						r = positions[p - 1];
-					else if (spaces[i + 1] == 0)
-						r = positions[p + 2];
-					else
-						r = Math.atan2(dy, dx);
-					r -= Math.atan2(c, a);
-					if (tip) {
-						cos = Math.cos(r);
-						sin = Math.sin(r);
-						length = bone.data.length;
-						boneX += (length * (cos * a - sin * c) - dx) * mixRotate;
-						boneY += (length * (sin * a + cos * c) - dy) * mixRotate;
-					} else {
-						r += offsetRotation;
-					}
-					if (r > Math.PI)
-						r -= (Math.PI * 2);
-					else if (r < -Math.PI) //
-						r += (Math.PI * 2);
-					r *= mixRotate;
-					cos = Math.cos(r);
-					sin = Math.sin(r);
-					bone.a = cos * a - sin * c;
-					bone.b = cos * b - sin * d;
-					bone.c = sin * a + cos * c;
-					bone.d = sin * b + cos * d;
-				}
-				bone.updateAppliedTransform();
-			}
-		}
-
-		protected function computeWorldPositions(path : PathAttachment, spacesCount : int, tangents : Boolean) : Vector.<Number> {
-			var target : Slot = this.target;
-			var position : Number = this.position;
-			var spaces : Vector.<Number> = this._spaces;
-			this._positions.length = spacesCount * 3 + 2;
-			var out : Vector.<Number> = this._positions, world : Vector.<Number>;
-			var closed : Boolean = path.closed;
-			var verticesLength : int = path.worldVerticesLength, curveCount : int = verticesLength / 6, prevCurve : int = NONE;
-			var multiplier : Number, i : int;
-
-			if (!path.constantSpeed) {
-				var lengths : Vector.<Number> = path.lengths;
-				curveCount -= closed ? 1 : 2;
-				var pathLength : Number = lengths[curveCount];
-				if (data.positionMode == PositionMode.percent) position *= pathLength;
-
-				switch (data.spacingMode) {
-				case SpacingMode.percent:
-					multiplier = pathLength;
-					break;
-				case SpacingMode.proportional:
-					multiplier = pathLength / spacesCount;
-					break;
-				default:
-					multiplier = 1;
-				}
-				this._world.length = 8;
-				world = this._world;
-				var o : int, curve : int;
-				for (i = 0, o = 0, curve = 0; i < spacesCount; i++, o += 3) {
-					var space : Number = spaces[i] * multiplier;
-					position += space;
-					var p : Number = position;
-
-					if (closed) {
-						p %= pathLength;
-						if (p < 0) p += pathLength;
-						curve = 0;
-					} else if (p < 0) {
-						if (prevCurve != BEFORE) {
-							prevCurve = BEFORE;
-							path.computeWorldVertices(target, 2, 4, world, 0, 2);
-						}
-						addBeforePosition(p, world, 0, out, o);
-						continue;
-					} else if (p > pathLength) {
-						if (prevCurve != AFTER) {
-							prevCurve = AFTER;
-							path.computeWorldVertices(target, verticesLength - 6, 4, world, 0, 2);
-						}
-						addAfterPosition(p - pathLength, world, 0, out, o);
-						continue;
-					}
-
-					// Determine curve containing position.
-					for (;; curve++) {
-						var length : Number = lengths[curve];
-						if (p > length) continue;
-						if (curve == 0)
-							p /= length;
-						else {
-							var prev : Number = lengths[curve - 1];
-							p = (p - prev) / (length - prev);
-						}
-						break;
-					}
-					if (curve != prevCurve) {
-						prevCurve = curve;
-						if (closed && curve == curveCount) {
-							path.computeWorldVertices(target, verticesLength - 4, 4, world, 0, 2);
-							path.computeWorldVertices(target, 0, 4, world, 4, 2);
-						} else
-							path.computeWorldVertices(target, curve * 6 + 2, 8, world, 0, 2);
-					}
-					addCurvePosition(p, world[0], world[1], world[2], world[3], world[4], world[5], world[6], world[7], out, o, tangents || (i > 0 && space == 0));
-				}
-				return out;
-			}
-
-			// World vertices.
-			if (closed) {
-				verticesLength += 2;
-				this._world.length = verticesLength;
-				world = this._world;
-				path.computeWorldVertices(target, 2, verticesLength - 4, world, 0, 2);
-				path.computeWorldVertices(target, 0, 2, world, verticesLength - 4, 2);
-				world[verticesLength - 2] = world[0];
-				world[verticesLength - 1] = world[1];
-			} else {
-				curveCount--;
-				verticesLength -= 4;
-				this._world.length = verticesLength;
-				world = this._world;
-				path.computeWorldVertices(target, 2, verticesLength, world, 0, 2);
-			}
-
-			// Curve lengths.
-			this._curves.length = curveCount;
-			var curves : Vector.<Number> = this._curves;
-			pathLength = 0;
-			var x1 : Number = world[0], y1 : Number = world[1], cx1 : Number = 0, cy1 : Number = 0, cx2 : Number = 0, cy2 : Number = 0, x2 : Number = 0, y2 : Number = 0;
-			var tmpx : Number, tmpy : Number, dddfx : Number, dddfy : Number, ddfx : Number, ddfy : Number, dfx : Number, dfy : Number;
-			var w : int;
-			for (i = 0, w = 2; i < curveCount; i++, w += 6) {
-				cx1 = world[w];
-				cy1 = world[w + 1];
-				cx2 = world[w + 2];
-				cy2 = world[w + 3];
-				x2 = world[w + 4];
-				y2 = world[w + 5];
-				tmpx = (x1 - cx1 * 2 + cx2) * 0.1875;
-				tmpy = (y1 - cy1 * 2 + cy2) * 0.1875;
-				dddfx = ((cx1 - cx2) * 3 - x1 + x2) * 0.09375;
-				dddfy = ((cy1 - cy2) * 3 - y1 + y2) * 0.09375;
-				ddfx = tmpx * 2 + dddfx;
-				ddfy = tmpy * 2 + dddfy;
-				dfx = (cx1 - x1) * 0.75 + tmpx + dddfx * 0.16666667;
-				dfy = (cy1 - y1) * 0.75 + tmpy + dddfy * 0.16666667;
-				pathLength += Math.sqrt(dfx * dfx + dfy * dfy);
-				dfx += ddfx;
-				dfy += ddfy;
-				ddfx += dddfx;
-				ddfy += dddfy;
-				pathLength += Math.sqrt(dfx * dfx + dfy * dfy);
-				dfx += ddfx;
-				dfy += ddfy;
-				pathLength += Math.sqrt(dfx * dfx + dfy * dfy);
-				dfx += ddfx + dddfx;
-				dfy += ddfy + dddfy;
-				pathLength += Math.sqrt(dfx * dfx + dfy * dfy);
-				curves[i] = pathLength;
-				x1 = x2;
-				y1 = y2;
-			}
-
-			if (data.positionMode == PositionMode.percent) position *= pathLength;
-
-			switch (data.spacingMode) {
-			case SpacingMode.percent:
-				multiplier = pathLength;
-				break;
-			case SpacingMode.proportional:
-				multiplier = pathLength / spacesCount;
-				break;
-			default:
-				multiplier = 1;
-			}
-
-			var segments : Vector.<Number> = this._segments;
-			var curveLength : Number = 0;
-			var segment : int;
-			for (i = 0, o = 0, curve = 0, segment = 0; i < spacesCount; i++, o += 3) {
-				space = spaces[i] * multiplier;
-				position += space;
-				p = position;
-
-				if (closed) {
-					p %= pathLength;
-					if (p < 0) p += pathLength;
-					curve = 0;
-				} else if (p < 0) {
-					addBeforePosition(p, world, 0, out, o);
-					continue;
-				} else if (p > pathLength) {
-					addAfterPosition(p - pathLength, world, verticesLength - 4, out, o);
-					continue;
-				}
-
-				// Determine curve containing position.
-				for (;; curve++) {
-					length = curves[curve];
-					if (p > length) continue;
-					if (curve == 0)
-						p /= length;
-					else {
-						prev = curves[curve - 1];
-						p = (p - prev) / (length - prev);
-					}
-					break;
-				}
-
-				// Curve segment lengths.
-				if (curve != prevCurve) {
-					prevCurve = curve;
-					var ii : int = curve * 6;
-					x1 = world[ii];
-					y1 = world[ii + 1];
-					cx1 = world[ii + 2];
-					cy1 = world[ii + 3];
-					cx2 = world[ii + 4];
-					cy2 = world[ii + 5];
-					x2 = world[ii + 6];
-					y2 = world[ii + 7];
-					tmpx = (x1 - cx1 * 2 + cx2) * 0.03;
-					tmpy = (y1 - cy1 * 2 + cy2) * 0.03;
-					dddfx = ((cx1 - cx2) * 3 - x1 + x2) * 0.006;
-					dddfy = ((cy1 - cy2) * 3 - y1 + y2) * 0.006;
-					ddfx = tmpx * 2 + dddfx;
-					ddfy = tmpy * 2 + dddfy;
-					dfx = (cx1 - x1) * 0.3 + tmpx + dddfx * 0.16666667;
-					dfy = (cy1 - y1) * 0.3 + tmpy + dddfy * 0.16666667;
-					curveLength = Math.sqrt(dfx * dfx + dfy * dfy);
-					segments[0] = curveLength;
-					for (ii = 1; ii < 8; ii++) {
-						dfx += ddfx;
-						dfy += ddfy;
-						ddfx += dddfx;
-						ddfy += dddfy;
-						curveLength += Math.sqrt(dfx * dfx + dfy * dfy);
-						segments[ii] = curveLength;
-					}
-					dfx += ddfx;
-					dfy += ddfy;
-					curveLength += Math.sqrt(dfx * dfx + dfy * dfy);
-					segments[8] = curveLength;
-					dfx += ddfx + dddfx;
-					dfy += ddfy + dddfy;
-					curveLength += Math.sqrt(dfx * dfx + dfy * dfy);
-					segments[9] = curveLength;
-					segment = 0;
-				}
-
-				// Weight by segment length.
-				p *= curveLength;
-				for (;; segment++) {
-					length = segments[segment];
-					if (p > length) continue;
-					if (segment == 0)
-						p /= length;
-					else {
-						prev = segments[segment - 1];
-						p = segment + (p - prev) / (length - prev);
-					}
-					break;
-				}
-				addCurvePosition(p * 0.1, x1, y1, cx1, cy1, cx2, cy2, x2, y2, out, o, tangents || (i > 0 && space == 0));
-			}
-			return out;
-		}
-
-		private function addBeforePosition(p : Number, temp : Vector.<Number>, i : int, out : Vector.<Number>, o : int) : void {
-			var x1 : Number = temp[i], y1 : Number = temp[i + 1], dx : Number = temp[i + 2] - x1, dy : Number = temp[i + 3] - y1, r : Number = Math.atan2(dy, dx);
-			out[o] = x1 + p * Math.cos(r);
-			out[o + 1] = y1 + p * Math.sin(r);
-			out[o + 2] = r;
-		}
-
-		private function addAfterPosition(p : Number, temp : Vector.<Number>, i : int, out : Vector.<Number>, o : int) : void {
-			var x1 : Number = temp[i + 2], y1 : Number = temp[i + 3], dx : Number = x1 - temp[i], dy : Number = y1 - temp[i + 1], r : Number = Math.atan2(dy, dx);
-			out[o] = x1 + p * Math.cos(r);
-			out[o + 1] = y1 + p * Math.sin(r);
-			out[o + 2] = r;
-		}
-
-		private function addCurvePosition(p : Number, x1 : Number, y1 : Number, cx1 : Number, cy1 : Number, cx2 : Number, cy2 : Number, x2 : Number, y2 : Number, out : Vector.<Number>, o : int, tangents : Boolean) : void {
-			if (p == 0 || isNaN(p)) {
-				out[o] = x1;
-				out[o + 1] = y1;
-				out[o + 2] = Math.atan2(cy1 - y1, cx1 - x1);
-				return;
-			}
-			var tt : Number = p * p, ttt : Number = tt * p, u : Number = 1 - p, uu : Number = u * u, uuu : Number = uu * u;
-			var ut : Number = u * p, ut3 : Number = ut * 3, uut3 : Number = u * ut3, utt3 : Number = ut3 * p;
-			var x : Number = x1 * uuu + cx1 * uut3 + cx2 * utt3 + x2 * ttt, y : Number = y1 * uuu + cy1 * uut3 + cy2 * utt3 + y2 * ttt;
-			out[o] = x;
-			out[o + 1] = y;
-			if (tangents) {
-				if (p < 0.001)
-					out[o + 2] = Math.atan2(cy1 - y1, cx1 - x1);
-				else
-					out[o + 2] = Math.atan2(y - (y1 * uu + cy1 * ut * 2 + cy2 * tt), x - (x1 * uu + cx1 * ut * 2 + cx2 * tt));
-			}
-		}
-
-		public function get bones() : Vector.<Bone> {
-			return _bones;
-		}
-
-		public function get data() : PathConstraintData {
-			return _data;
-		}
-
-		public function toString() : String {
-			return _data.name;
-		}
-	}
-}

spine-as3/spine-as3/src/spine/PathConstraintData.as

@@ -1,48 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine {
-	public class PathConstraintData extends ConstraintData {			
-		internal var _bones : Vector.<BoneData> = new Vector.<BoneData>();
-		public var target : SlotData;
-		public var positionMode : PositionMode;
-		public var spacingMode : SpacingMode;
-		public var rotateMode : RotateMode;
-		public var offsetRotation : Number;
-		public var position : Number, spacing : Number, mixRotate : Number, mixX : Number, mixY : Number;
-
-		public function PathConstraintData(name : String) {
-			super(name, 0, false);
-		}
-
-		public function get bones() : Vector.<BoneData> {
-			return _bones;
-		}
-	}
-}

spine-as3/spine-as3/src/spine/Polygon.as

@@ -1,79 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine {
-	public class Polygon {
-		public var vertices : Vector.<Number> = new Vector.<Number>();
-
-		public function Polygon() {
-		}
-
-		/** Returns true if the polygon contains the point. */
-		public function containsPoint(x : Number, y : Number) : Boolean {
-			var nn : int = vertices.length;
-
-			var prevIndex : int = nn - 2;
-			var inside : Boolean = false;
-			for (var ii : int = 0; ii < nn; ii += 2) {
-				var vertexY : Number = vertices[ii + 1];
-				var prevY : Number = vertices[prevIndex + 1];
-				if ((vertexY < y && prevY >= y) || (prevY < y && vertexY >= y)) {
-					var vertexX : Number = vertices[ii];
-					if (vertexX + (y - vertexY) / (prevY - vertexY) * (vertices[prevIndex] - vertexX) < x) inside = !inside;
-				}
-				prevIndex = ii;
-			}
-
-			return inside;
-		}
-
-		/** Returns true if the polygon contains the line segment. */
-		public function intersectsSegment(x1 : Number, y1 : Number, x2 : Number, y2 : Number) : Boolean {
-			var nn : int = vertices.length;
-
-			var width12 : Number = x1 - x2, height12 : Number = y1 - y2;
-			var det1 : Number = x1 * y2 - y1 * x2;
-			var x3 : Number = vertices[nn - 2], y3 : Number = vertices[nn - 1];
-			for (var ii : int = 0; ii < nn; ii += 2) {
-				var x4 : Number = vertices[ii], y4 : Number = vertices[ii + 1];
-				var det2 : Number = x3 * y4 - y3 * x4;
-				var width34 : Number = x3 - x4, height34 : Number = y3 - y4;
-				var det3 : Number = width12 * height34 - height12 * width34;
-				var x : Number = (det1 * width34 - width12 * det2) / det3;
-				if (((x >= x3 && x <= x4) || (x >= x4 && x <= x3)) && ((x >= x1 && x <= x2) || (x >= x2 && x <= x1))) {
-					var y : Number = (det1 * height34 - height12 * det2) / det3;
-					if (((y >= y3 && y <= y4) || (y >= y4 && y <= y3)) && ((y >= y1 && y <= y2) || (y >= y2 && y <= y1))) return true;
-				}
-				x3 = x4;
-				y3 = y4;
-			}
-			return false;
-		}
-	}
-}

spine-as3/spine-as3/src/spine/Pool.as

@@ -1,58 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine {
-	public class Pool {
-		internal var items : Vector.<Object> = new Vector.<Object>();
-		internal var instantiator : Function;
-
-		public function Pool(instantiator : Function) {
-			this.instantiator = instantiator;
-		}
-
-		public function obtain() : Object {
-			return this.items.length > 0 ? this.items.pop() : this.instantiator();
-		}
-
-		public function free(item : Object) : void {
-			if (item is Poolable) Poolable(item).reset();
-			items.push(item);
-		}
-
-		public function freeAll(items : Vector) : void {
-			for (var i : int = 0; i < items.length; i++) {
-				free(items[i]);
-			}
-		}
-
-		public function clear() : void {
-			items.length = 0;
-		}
-	}
-}

spine-as3/spine-as3/src/spine/Poolable.as

@@ -1,34 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine {
-	public interface Poolable {
-		function reset() : void;
-	}
-}

spine-as3/spine-as3/src/spine/PositionMode.as

@@ -1,37 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine {
-	public class PositionMode {
-		public static const fixed : PositionMode = new PositionMode();
-		public static const percent : PositionMode = new PositionMode();
-		
-		public static const values : Array = [ fixed, percent ];
-	}
-}

spine-as3/spine-as3/src/spine/RotateMode.as

@@ -1,38 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine {
-	public class RotateMode {
-		public static const tangent : RotateMode = new RotateMode();
-		public static const chain : RotateMode = new RotateMode();
-		public static const chainScale : RotateMode = new RotateMode();
-		
-		public static const values : Array = [ tangent, chain, chainScale ];
-	}
-}

spine-as3/spine-as3/src/spine/Skeleton.as

@@ -1,569 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine {
-	import spine.attachments.MeshAttachment;
-	import spine.attachments.RegionAttachment;
-
-	import flash.utils.Dictionary;
-
-	import spine.attachments.PathAttachment;
-	import spine.attachments.Attachment;
-
-	public class Skeleton {
-		internal var _data : SkeletonData;
-		public var bones : Vector.<Bone>;
-		public var slots : Vector.<Slot>;
-		public var drawOrder : Vector.<Slot>;
-		public var ikConstraints : Vector.<IkConstraint>;
-		public var transformConstraints : Vector.<TransformConstraint>;
-		public var pathConstraints : Vector.<PathConstraint>;
-		private var _updateCache : Vector.<Updatable> = new Vector.<Updatable>();
-		private var _skin : Skin;
-		public var color : Color = new Color(1, 1, 1, 1);
-		public var time : Number = 0;
-		public var scaleX : Number = 1, scaleY : Number = 1;
-		public var x : Number = 0, y : Number = 0;
-
-		public function Skeleton(data : SkeletonData) {
-			if (data == null)
-				throw new ArgumentError("data cannot be null.");
-			_data = data;
-
-			bones = new Vector.<Bone>();
-			for each (var boneData : BoneData in data.bones) {
-				var bone : Bone;
-				if (boneData.parent == null)
-					bone = new Bone(boneData, this, null);
-				else {
-					var parent : Bone = bones[boneData.parent.index];
-					bone = new Bone(boneData, this, parent);
-					parent.children.push(bone);
-				}
-				bones.push(bone);
-			}
-
-			slots = new Vector.<Slot>();
-			drawOrder = new Vector.<Slot>();
-			for each (var slotData : SlotData in data.slots) {
-				bone = bones[slotData.boneData.index];
-				var slot : Slot = new Slot(slotData, bone);
-				slots.push(slot);
-				drawOrder[drawOrder.length] = slot;
-			}
-
-			ikConstraints = new Vector.<IkConstraint>();
-			for each (var ikConstraintData : IkConstraintData in data.ikConstraints)
-				ikConstraints.push(new IkConstraint(ikConstraintData, this));
-
-			transformConstraints = new Vector.<TransformConstraint>();
-			for each (var transformConstraintData : TransformConstraintData in data.transformConstraints)
-				transformConstraints.push(new TransformConstraint(transformConstraintData, this));
-
-			pathConstraints = new Vector.<PathConstraint>();
-			for each (var pathConstraintData : PathConstraintData in data.pathConstraints)
-				pathConstraints.push(new PathConstraint(pathConstraintData, this));
-
-			updateCache();
-		}
-
-		/** Caches information about bones and constraints. Must be called if bones, constraints, or weighted path attachments are
-		 * added or removed. */
-		public function updateCache() : void {
-			var updateCache : Vector.<Updatable> = this._updateCache;
-			updateCache.length = 0;
-
-			var bones : Vector.<Bone> = this.bones;
-			var i : int = 0;
-			var n : int = 0;
-			var bone : Bone;
-			for (i = 0, n = bones.length; i < n; i++) {
-				bone = bones[i];
-				bone._sorted = bone.data.skinRequired;
-				bone.active = !bone._sorted;
-			}
-
-			if (skin != null) {
-				var skinBones : Vector.<BoneData> = skin.bones;
-				for (i = 0, n = this.skin.bones.length; i < n; i++) {
-					bone = this.bones[skinBones[i].index];
-					do {
-						bone._sorted = false;
-						bone.active = true;
-						bone = bone.parent;
-					} while (bone != null);
-				}
-			}
-
-			// IK first, lowest hierarchy depth first.
-			var ikConstraints : Vector.<IkConstraint> = this.ikConstraints;
-			var transformConstraints : Vector.<TransformConstraint> = this.transformConstraints;
-			var pathConstraints : Vector.<PathConstraint> = this.pathConstraints;
-			var ikCount : int = ikConstraints.length, transformCount : int = transformConstraints.length, pathCount : int = pathConstraints.length;
-			var constraintCount : int = ikCount + transformCount + pathCount;
-
-			outer:
-			for (i = 0; i < constraintCount; i++) {
-				var ii : int = 0;
-				for (ii = 0; ii < ikCount; ii++) {
-					var ikConstraint : IkConstraint = ikConstraints[ii];
-					if (ikConstraint.data.order == i) {
-						sortIkConstraint(ikConstraint);
-						continue outer;
-					}
-				}
-				for (ii = 0; ii < transformCount; ii++) {
-					var transformConstraint : TransformConstraint = transformConstraints[ii];
-					if (transformConstraint.data.order == i) {
-						sortTransformConstraint(transformConstraint);
-						continue outer;
-					}
-				}
-				for (ii = 0; ii < pathCount; ii++) {
-					var pathConstraint : PathConstraint = pathConstraints[ii];
-					if (pathConstraint.data.order == i) {
-						sortPathConstraint(pathConstraint);
-						continue outer;
-					}
-				}
-			}
-
-			for (i = 0, n = bones.length; i < n; i++)
-				sortBone(bones[i]);
-		}
-
-		private static function contains(list : Vector.<ConstraintData>, element : ConstraintData) : Boolean {
-			for (var i : int = 0; i < list.length; i++)
-				if  (list[i] == element) return true;
-			return false;
-		}
-
-		private function sortIkConstraint(constraint : IkConstraint) : void {
-			constraint.active = constraint.target.isActive() && (!constraint.data.skinRequired || (this.skin != null && contains(this.skin.constraints, constraint.data)));
-			if (!constraint.active) return;
-
-			var target : Bone = constraint.target;
-			sortBone(target);
-
-			var constrained : Vector.<Bone> = constraint.bones;
-			var parent : Bone = constrained[0];
-			sortBone(parent);
-
-			if (constrained.length == 1) {
-				_updateCache.push(constraint);
-				sortReset(parent.children);
-			} else {
-				var child : Bone = constrained[constrained.length - 1];
-				sortBone(child);
-
-				_updateCache.push(constraint);
-
-				sortReset(parent.children);
-				child._sorted = true;
-			}
-
-			_updateCache.push(constraint);
-
-			sortReset(parent.children);
-			constrained[constrained.length - 1]._sorted = true;
-		}
-
-		private function sortPathConstraint(constraint : PathConstraint) : void {
-			constraint.active = constraint.target.bone.isActive() && (!constraint.data.skinRequired || (this.skin != null && contains(this.skin.constraints, constraint.data)));
-			if (!constraint.active) return;
-
-			var slot : Slot = constraint.target;
-			var slotIndex : int = slot.data.index;
-			var slotBone : Bone = slot.bone;
-			if (skin != null) sortPathConstraintAttachment(skin, slotIndex, slotBone);
-			if (data.defaultSkin != null && data.defaultSkin != skin)
-				sortPathConstraintAttachment(data.defaultSkin, slotIndex, slotBone);
-			var i : int = 0, n : int = 0;
-			for (i = 0, n = data.skins.length; i < n; i++)
-				sortPathConstraintAttachment(data.skins[i], slotIndex, slotBone);
-
-			var attachment : Attachment = slot.attachment;
-			if (attachment is PathAttachment) sortPathConstraintAttachment2(attachment, slotBone);
-
-			var constrained : Vector.<Bone> = constraint.bones;
-			var boneCount : int = constrained.length;
-			for (i = 0; i < boneCount; i++)
-				sortBone(constrained[i]);
-
-			_updateCache.push(constraint);
-
-			for (i = 0; i < boneCount; i++)
-				sortReset(constrained[i].children);
-			for (i = 0; i < boneCount; i++)
-				constrained[i]._sorted = true;
-		}
-
-		private function sortTransformConstraint(constraint : TransformConstraint) : void {
-			constraint.active = constraint.target.isActive() && (!constraint.data.skinRequired || (this.skin != null && contains(this.skin.constraints, constraint.data)));
-			if (!constraint.active) return;
-
-			sortBone(constraint.target);
-
-			var constrained : Vector.<Bone> = constraint.bones;
-			var boneCount : int = constrained.length;
-			var i : int = 0;
-			if (constraint.data.local) {
-				for (i = 0; i < boneCount; i++) {
-					var child : Bone = constrained[i];
-					sortBone(child.parent);
-					sortBone(child);
-				}
-			} else {
-				for (i = 0; i < boneCount; i++)
-					sortBone(constrained[i]);
-			}
-
-			_updateCache.push(constraint);
-
-			for (i = 0; i < boneCount; i++)
-				sortReset(constrained[i].children);
-			for (i = 0; i < boneCount; i++)
-				constrained[i]._sorted = true;
-		}
-
-		private function sortPathConstraintAttachment(skin : Skin, slotIndex : int, slotBone : Bone) : void {
-			if (!skin.attachments.hasOwnProperty(slotIndex)) return;
-			var dict : Dictionary = skin.attachments[slotIndex];
-			if (!dict) return;
-
-			for each (var value : Attachment in dict) {
-				sortPathConstraintAttachment2(value, slotBone);
-			}
-		}
-
-		private function sortPathConstraintAttachment2(attachment : Attachment, slotBone : Bone) : void {
-			var pathAttachment : PathAttachment = attachment as PathAttachment;
-			if (!pathAttachment) return;
-			var pathBones : Vector.<int> = pathAttachment.bones;
-			if (pathBones == null)
-				sortBone(slotBone);
-			else {
-				var bones : Vector.<Bone> = this.bones;
-				for (var i : int = 0, n : int = pathBones.length; i < n;) {
-					var nn : int = pathBones[i++];
-					nn += i;
-					while (i < nn)
-						sortBone(bones[pathBones[i++]]);
-				}
-			}
-		}
-
-		private function sortBone(bone : Bone) : void {
-			if (bone._sorted) return;
-			var parent : Bone = bone.parent;
-			if (parent != null) sortBone(parent);
-			bone._sorted = true;
-			_updateCache.push(bone);
-		}
-
-		private function sortReset(bones : Vector.<Bone>) : void {
-			for (var i : int = 0, n : int = bones.length; i < n; i++) {
-				var bone : Bone = bones[i];
-				if (!bone.active) continue;
-				if (bone._sorted) sortReset(bone.children);
-				bone._sorted = false;
-			}
-		}
-
-		/** Updates the world transform for each bone and applies constraints. */
-		public function updateWorldTransform() : void {
-			var bones : Vector.<Bone> = this.bones;
-			var i : int, n : int;
-			for (i = 0, n = bones.length; i < n; i++) {
-				var bone : Bone = bones[i];
-				bone.ax = bone.x;
-				bone.ay = bone.y;
-				bone.arotation = bone.rotation;
-				bone.ascaleX = bone.scaleX;
-				bone.ascaleY = bone.scaleY;
-				bone.ashearX = bone.shearX;
-				bone.ashearY = bone.shearY;
-			}
-
-			var updateCache : Vector.<Updatable> = _updateCache;
-			for (i = 0, n = updateCache.length; i < n; i++)
-				updateCache[i].update();
-		}
-
-		public function updateWorldTransformWith (parent : Bone) : void {
-			// Apply the parent bone transform to the root bone. The root bone always inherits scale, rotation and reflection.
-			var rootBone : Bone = rootBone;
-			var pa : Number = parent.a, pb : Number = parent.b, pc : Number = parent.c, pd : Number = parent.d;
-			rootBone.worldX = pa * x + pb * y + parent.worldX;
-			rootBone.worldY = pc * x + pd * y + parent.worldY;
-
-			var rotationY : Number = rootBone.rotation + 90 + rootBone.shearY;
-			var la : Number = MathUtils.cosDeg(rootBone.rotation + rootBone.shearX) * rootBone.scaleX;
-			var lb : Number = MathUtils.cosDeg(rotationY) * rootBone.scaleY;
-			var lc : Number = MathUtils.sinDeg(rootBone.rotation + rootBone.shearX) * rootBone.scaleX;
-			var ld : Number = MathUtils.sinDeg(rotationY) * rootBone.scaleY;
-			rootBone.a = (pa * la + pb * lc) * scaleX;
-			rootBone.b = (pa * lb + pb * ld) * scaleX;
-			rootBone.c = (pc * la + pd * lc) * scaleY;
-			rootBone.d = (pc * lb + pd * ld) * scaleY;
-
-			// Update everything except root bone.
-			var updateCache : Vector.<Updatable> = _updateCache;
-			for (var i : int = 0, n : int = updateCache.length; i < n; i++) {
-				var updatable : Updatable = updateCache[i];
-				if (updatable != rootBone) updatable.update();
-			}
-		}
-
-		/** Sets the bones, constraints, and slots to their setup pose values. */
-		public function setToSetupPose() : void {
-			setBonesToSetupPose();
-			setSlotsToSetupPose();
-		}
-
-		/** Sets the bones and constraints to their setup pose values. */
-		public function setBonesToSetupPose() : void {
-			for each (var bone : Bone in bones)
-				bone.setToSetupPose();
-
-			for each (var ikConstraint : IkConstraint in ikConstraints) {
-				var ikData : IkConstraintData = ikConstraint._data;
-				ikConstraint.mix = ikConstraint._data.mix;
-				ikConstraint.softness = ikConstraint._data.softness;
-				ikConstraint.bendDirection = ikConstraint._data.bendDirection;
-				ikConstraint.compress = ikConstraint._data.compress;
-				ikConstraint.stretch = ikConstraint._data.stretch;
-			}
-
-			for each (var transformConstraint : TransformConstraint in transformConstraints) {
-				var transformData : TransformConstraintData = transformConstraint._data;
-				transformConstraint.mixRotate = transformData.mixRotate;
-				transformConstraint.mixX = transformData.mixX;
-				transformConstraint.mixY = transformData.mixY;
-				transformConstraint.mixScaleX = transformData.mixScaleX;
-				transformConstraint.mixScaleY = transformData.mixScaleY;
-				transformConstraint.mixShearY = transformData.mixShearY;
-			}
-
-			for each (var pathConstraint : PathConstraint in pathConstraints) {
-				var pathData : PathConstraintData = pathConstraint._data;
-				pathConstraint.position = pathData.position;
-				pathConstraint.spacing = pathData.spacing;
-				pathConstraint.mixRotate = pathData.mixRotate;
-				pathConstraint.mixX = pathData.mixX;
-				pathConstraint.mixY = pathData.mixY;
-			}
-		}
-
-		public function setSlotsToSetupPose() : void {
-			var i : int = 0;
-			for each (var slot : Slot in slots) {
-				drawOrder[i++] = slot;
-				slot.setToSetupPose();
-			}
-		}
-
-		public function get data() : SkeletonData {
-			return _data;
-		}
-
-		public function get getUpdateCache() : Vector.<Updatable> {
-			return _updateCache;
-		}
-
-		public function get rootBone() : Bone {
-			if (bones.length == 0) return null;
-			return bones[0];
-		}
-
-		/** @return May be null. */
-		public function findBone(boneName : String) : Bone {
-			if (boneName == null)
-				throw new ArgumentError("boneName cannot be null.");
-			for each (var bone : Bone in bones)
-				if (bone._data._name == boneName) return bone;
-			return null;
-		}
-
-		/** @return May be null. */
-		public function findSlot(slotName : String) : Slot {
-			if (slotName == null)
-				throw new ArgumentError("slotName cannot be null.");
-			for each (var slot : Slot in slots)
-				if (slot._data._name == slotName) return slot;
-			return null;
-		}
-
-		public function get skin() : Skin {
-			return _skin;
-		}
-
-		public function set skinName(skinName : String) : void {
-			var skin : Skin = data.findSkin(skinName);
-			if (skin == null) throw new ArgumentError("Skin not found: " + skinName);
-			this.skin = skin;
-		}
-
-		/** @return May be null. */
-		public function get skinName() : String {
-			return _skin == null ? null : _skin._name;
-		}
-
-		/** Sets the skin used to look up attachments before looking in the {@link SkeletonData#getDefaultSkin() default skin}.
-		 * Attachments from the new skin are attached if the corresponding attachment from the old skin was attached. If there was
-		 * no old skin, each slot's setup mode attachment is attached from the new skin.
-		 * @param newSkin May be null. */
-		public function set skin(newSkin : Skin) : void {
-			if (newSkin == _skin) return;
-			if (newSkin) {
-				if (skin)
-					newSkin.attachAll(this, skin);
-				else {
-					var i : int = 0;
-					for each (var slot : Slot in slots) {
-						var name : String = slot._data.attachmentName;
-						if (name) {
-							var attachment : Attachment = newSkin.getAttachment(i, name);
-							if (attachment) slot.attachment = attachment;
-						}
-						i++;
-					}
-				}
-			}
-			_skin = newSkin;
-			updateCache();
-		}
-
-		/** @return May be null. */
-		public function getAttachmentForSlotName(slotName : String, attachmentName : String) : Attachment {
-			return getAttachmentForSlotIndex(data.findSlot(slotName).index, attachmentName);
-		}
-
-		/** @return May be null. */
-		public function getAttachmentForSlotIndex(slotIndex : int, attachmentName : String) : Attachment {
-			if (attachmentName == null) throw new ArgumentError("attachmentName cannot be null.");
-			if (skin != null) {
-				var attachment : Attachment = skin.getAttachment(slotIndex, attachmentName);
-				if (attachment != null) return attachment;
-			}
-			if (data.defaultSkin != null) return data.defaultSkin.getAttachment(slotIndex, attachmentName);
-			return null;
-		}
-
-		/** @param attachmentName May be null. */
-		public function setAttachment(slotName : String, attachmentName : String) : void {
-			if (slotName == null) throw new ArgumentError("slotName cannot be null.");
-			var i : int = 0;
-			for each (var slot : Slot in slots) {
-				if (slot._data._name == slotName) {
-					var attachment : Attachment = null;
-					if (attachmentName != null) {
-						attachment = getAttachmentForSlotIndex(i, attachmentName);
-						if (attachment == null)
-							throw new ArgumentError("Attachment not found: " + attachmentName + ", for slot: " + slotName);
-					}
-					slot.attachment = attachment;
-					return;
-				}
-				i++;
-			}
-			throw new ArgumentError("Slot not found: " + slotName);
-		}
-
-		/** @return May be null. */
-		public function findIkConstraint(constraintName : String) : IkConstraint {
-			if (constraintName == null) throw new ArgumentError("constraintName cannot be null.");
-			for each (var ikConstraint : IkConstraint in ikConstraints)
-				if (ikConstraint._data.name == constraintName) return ikConstraint;
-			return null;
-		}
-
-		/** @return May be null. */
-		public function findTransformConstraint(constraintName : String) : TransformConstraint {
-			if (constraintName == null) throw new ArgumentError("constraintName cannot be null.");
-			for each (var transformConstraint : TransformConstraint in transformConstraints)
-				if (transformConstraint._data.name == constraintName) return transformConstraint;
-			return null;
-		}
-
-		/** @return May be null. */
-		public function findPathConstraint(constraintName : String) : PathConstraint {
-			if (constraintName == null) throw new ArgumentError("constraintName cannot be null.");
-			for each (var pathConstraint : PathConstraint in pathConstraints)
-				if (pathConstraint._data.name == constraintName) return pathConstraint;
-			return null;
-		}
-
-		public function update(delta : Number) : void {
-			time += delta;
-		}
-
-		public function toString() : String {
-			return _data.name == null ? "null" : _data.name;
-		}
-
-		public function getBounds(offset : Vector.<Number>, size : Vector.<Number>, temp : Vector.<Number>) : void {
-			if (offset == null) throw new ArgumentError("offset cannot be null.");
-			if (size == null) throw new ArgumentError("size cannot be null.");
-			var drawOrder : Vector.<Slot> = this.drawOrder;
-			var minX : Number = Number.POSITIVE_INFINITY, minY : Number = Number.POSITIVE_INFINITY, maxX : Number = Number.NEGATIVE_INFINITY, maxY : Number = Number.NEGATIVE_INFINITY;
-			for (var i : int = 0, n : int = drawOrder.length; i < n; i++) {
-				var slot : Slot = drawOrder[i];
-				var verticesLength : int = 0;
-				var vertices : Vector.<Number> = null;
-				var attachment : Attachment = slot.attachment;
-				if (attachment is RegionAttachment) {
-					verticesLength = 8;
-					temp.length = verticesLength;
-					vertices = temp;
-					(attachment as RegionAttachment).computeWorldVertices(slot.bone, vertices, 0, 2);
-				} else if (attachment is MeshAttachment) {
-					var mesh : MeshAttachment = attachment as MeshAttachment;
-					verticesLength = mesh.worldVerticesLength;
-					temp.length = verticesLength;
-					vertices = temp;
-					mesh.computeWorldVertices(slot, 0, verticesLength, vertices, 0, 2);
-				}
-				if (vertices != null) {
-					for (var ii : int = 0, nn : int = vertices.length; ii < nn; ii += 8) {
-						var x : Number = vertices[ii], y : Number = vertices[ii + 1];
-						minX = Math.min(minX, x);
-						minY = Math.min(minY, y);
-						maxX = Math.max(maxX, x);
-						maxY = Math.max(maxY, y);
-					}
-				}
-			}
-			offset[0] = minX;
-			offset[1] = minY;
-			size[0] = maxX - minX;
-			size[1] = maxY - minY;
-		}
-	}
-}

spine-as3/spine-as3/src/spine/SkeletonBinary.as

@@ -1,1099 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine {
-	import spine.animation.*;
-	import spine.attachments.*;
-	import flash.utils.ByteArray;
-
-	public class SkeletonBinary {
-		public var attachmentLoader : AttachmentLoader;
-		public var scale : Number = 1;
-		private var linkedMeshes : Vector.<LinkedMesh> = new Vector.<LinkedMesh>();
-
-		private static const BONE_ROTATE : int = 0;
-		private static const BONE_TRANSLATE : int = 1;
-		private static const BONE_TRANSLATEX : int = 2;
-		private static const BONE_TRANSLATEY : int = 3;
-		private static const BONE_SCALE : int = 4;
-		private static const BONE_SCALEX : int = 5;
-		private static const BONE_SCALEY : int = 6;
-		private static const BONE_SHEAR : int = 7;
-		private static const BONE_SHEARX : int = 8;
-		private static const BONE_SHEARY : int = 9;
-
-		private static const SLOT_ATTACHMENT : int = 0;
-		private static const SLOT_RGBA : int = 1;
-		private static const SLOT_RGB : int = 2;
-		private static const SLOT_RGBA2 : int = 3;
-		private static const SLOT_RGB2 : int = 4;
-		private static const SLOT_ALPHA : int = 5;
-
-		private static const PATH_POSITION : int = 0;
-		private static const PATH_SPACING : int = 1;
-		private static const PATH_MIX : int = 2;
-
-		private static const CURVE_LINEAR : int = 0;
-		private static const CURVE_STEPPED : int = 1;
-		private static const CURVE_BEZIER : int = 2;
-
-		public function SkeletonBinary(attachmentLoader : AttachmentLoader = null) {
-			this.attachmentLoader = attachmentLoader;
-		}
-
-		/** @param object A String or ByteArray. */
-		public function readSkeletonData(object : *) : SkeletonData {
-			if (object == null) throw new ArgumentError("object cannot be null.");
-			if (!(object is ByteArray)) throw new ArgumentError("Object must be a ByteArray");
-
-			var scale : Number = this.scale;
-
-			var skeletonData : SkeletonData = new SkeletonData();
-			skeletonData.name = ""; // BOZO
-
-			var input : BinaryInput = new BinaryInput(object);
-
-			var lowHash : int = input.readInt32();
-			var highHash : int = input.readInt32();
-			skeletonData.hash = highHash == 0 && lowHash == 0 ? null : highHash.toString(16) + lowHash.toString(16);
-			skeletonData.version = input.readString();
-			if ("3.8.75" == skeletonData.version)
-					throw new Error("Unsupported skeleton data, please export with a newer version of Spine.");
-			skeletonData.x = input.readFloat();
-			skeletonData.y = input.readFloat();
-			skeletonData.width = input.readFloat();
-			skeletonData.height = input.readFloat();
-
-			var nonessential : Boolean = input.readBoolean();
-			if (nonessential) {
-				skeletonData.fps = input.readFloat();
-
-				skeletonData.imagesPath = input.readString();
-				skeletonData.audioPath = input.readString();
-			}
-
-			var n : int = 0;
-			var i : int = 0;
-			// Strings.
-			n = input.readInt(true);
-			for (i = 0; i < n; i++)
-				input.strings.push(input.readString());
-
-			// Bones.
-			n = input.readInt(true);
-			for (i = 0; i < n; i++) {
-				var boneName : String = input.readString();
-				var boneParent : BoneData = i == 0 ? null : skeletonData.bones[input.readInt(true)];
-				var boneData : BoneData = new BoneData(i, boneName, boneParent);
-				boneData.rotation = input.readFloat();
-				boneData.x = input.readFloat() * scale;
-				boneData.y = input.readFloat() * scale;
-				boneData.scaleX = input.readFloat();
-				boneData.scaleY = input.readFloat();
-				boneData.shearX = input.readFloat();
-				boneData.shearY = input.readFloat();
-				boneData.length = input.readFloat() * scale;
-				boneData.transformMode = TransformMode.values[input.readInt(true)];
-				boneData.skinRequired = input.readBoolean();
-				if (nonessential) boneData.color.setFromRgba8888(input.readInt32());
-				skeletonData.bones.push(boneData);
-			}
-
-			// Slots.
-			n = input.readInt(true);
-			for (i = 0; i < n; i++) {
-				var slotName : String = input.readString();
-				var slotBoneData : BoneData = skeletonData.bones[input.readInt(true)];
-				var slotData : SlotData = new SlotData(i, slotName, slotBoneData);
-				slotData.color.setFromRgba8888(input.readInt32());
-
-				var darkColor : int = input.readInt32();
-				if (darkColor != -1) slotData.darkColor.setFromRgb888(darkColor);
-
-				slotData.attachmentName = input.readStringRef();
-				slotData.blendMode = BlendMode.values[input.readInt(true)];
-				skeletonData.slots.push(slotData);
-			}
-
-			// IK constraints.
-			n = input.readInt(true);
-			var nn : int = 0;
-			var ii : int = 0;
-			for (i = 0; i < n; i++) {
-				var ikData : IkConstraintData = new IkConstraintData(input.readString());
-				ikData.order = input.readInt(true);
-				ikData.skinRequired = input.readBoolean();
-				nn = input.readInt(true);
-				for (ii = 0; ii < nn; ii++)
-					ikData.bones.push(skeletonData.bones[input.readInt(true)]);
-				ikData.target = skeletonData.bones[input.readInt(true)];
-				ikData.mix = input.readFloat();
-				ikData.softness = input.readFloat() * scale;
-				ikData.bendDirection = input.readByte();
-				ikData.compress = input.readBoolean();
-				ikData.stretch = input.readBoolean();
-				ikData.uniform = input.readBoolean();
-				skeletonData.ikConstraints.push(ikData);
-			}
-
-			// Transform constraints.
-			n = input.readInt(true);
-			for (i = 0, nn; i < n; i++) {
-				var transformData : TransformConstraintData = new TransformConstraintData(input.readString());
-				transformData.order = input.readInt(true);
-				transformData.skinRequired = input.readBoolean();
-				nn = input.readInt(true);
-				for (ii = 0; ii < nn; ii++)
-					transformData.bones.push(skeletonData.bones[input.readInt(true)]);
-				transformData.target = skeletonData.bones[input.readInt(true)];
-				transformData.local = input.readBoolean();
-				transformData.relative = input.readBoolean();
-				transformData.offsetRotation = input.readFloat();
-				transformData.offsetX = input.readFloat() * scale;
-				transformData.offsetY = input.readFloat() * scale;
-				transformData.offsetScaleX = input.readFloat();
-				transformData.offsetScaleY = input.readFloat();
-				transformData.offsetShearY = input.readFloat();
-				transformData.mixRotate = input.readFloat();
-				transformData.mixX = input.readFloat();
-				transformData.mixY = input.readFloat();
-				transformData.mixScaleX = input.readFloat();
-				transformData.mixScaleY = input.readFloat();
-				transformData.mixShearY = input.readFloat();
-				skeletonData.transformConstraints.push(transformData);
-			}
-
-			// Path constraints.
-			n = input.readInt(true);
-			for (i = 0, nn; i < n; i++) {
-				var pathData : PathConstraintData = new PathConstraintData(input.readString());
-				pathData.order = input.readInt(true);
-				pathData.skinRequired = input.readBoolean();
-				nn = input.readInt(true);
-				for (ii = 0; ii < nn; ii++)
-					pathData.bones.push(skeletonData.bones[input.readInt(true)]);
-				pathData.target = skeletonData.slots[input.readInt(true)];
-				pathData.positionMode = PositionMode.values[input.readInt(true)];
-				pathData.spacingMode = SpacingMode.values[input.readInt(true)];
-				pathData.rotateMode = RotateMode.values[input.readInt(true)];
-				pathData.offsetRotation = input.readFloat();
-				pathData.position = input.readFloat();
-				if (pathData.positionMode == PositionMode.fixed) pathData.position *= scale;
-				pathData.spacing = input.readFloat();
-				if (pathData.spacingMode == SpacingMode.length || pathData.spacingMode == SpacingMode.fixed) pathData.spacing *= scale;
-				pathData.mixRotate = input.readFloat();
-				pathData.mixX = input.readFloat();
-				pathData.mixY = input.readFloat();
-				skeletonData.pathConstraints.push(pathData);
-			}
-
-			// Default skin.
-			var defaultSkin : Skin = readSkin(input, skeletonData, true, nonessential);
-			if (defaultSkin != null) {
-				skeletonData.defaultSkin = defaultSkin;
-				skeletonData.skins.push(defaultSkin);
-			}
-
-			// Skins.
-			{
-				i = skeletonData.skins.length;
-				skeletonData.skins.length = n = i + input.readInt(true);
-				for (; i < n; i++)
-					skeletonData.skins[i] = readSkin(input, skeletonData, false, nonessential);
-			}
-
-			// Linked meshes.
-			n = this.linkedMeshes.length;
-			for (i = 0; i < n; i++) {
-				var linkedMesh : LinkedMesh = this.linkedMeshes[i];
-				var skin : Skin = linkedMesh.skin == null ? skeletonData.defaultSkin : skeletonData.findSkin(linkedMesh.skin);
-				if (skin == null) throw new Error("Skin not found: " + linkedMesh.skin);
-				var parent : Attachment = skin.getAttachment(linkedMesh.slotIndex, linkedMesh.parent);
-				if (parent == null) throw new Error("Parent mesh not found: " + linkedMesh.parent);
-				linkedMesh.mesh.deformAttachment = linkedMesh.inheritDeform ? parent as VertexAttachment : linkedMesh.mesh;
-				linkedMesh.mesh.parentMesh = parent as MeshAttachment;
-				linkedMesh.mesh.updateUVs();
-			}
-			this.linkedMeshes.length = 0;
-
-			// Events.
-			n = input.readInt(true);
-			for (i = 0; i < n; i++) {
-				var data : EventData = new EventData(input.readStringRef());
-				data.intValue = input.readInt(false);
-				data.floatValue = input.readFloat();
-				data.stringValue = input.readString();
-				data.audioPath = input.readString();
-				if (data.audioPath != null) {
-					data.volume = input.readFloat();
-					data.balance = input.readFloat();
-				}
-				skeletonData.events.push(data);
-			}
-
-			// Animations.
-			n = input.readInt(true);
-			for (i = 0; i < n; i++)
-				skeletonData.animations.push(readAnimation(input, input.readString(), skeletonData));
-			return skeletonData;
-		}
-
-		private function readSkin (input: BinaryInput, skeletonData: SkeletonData, defaultSkin: Boolean, nonessential: Boolean): Skin {
-			var skin : Skin = null;
-			var i : int = 0;
-			var n : int = 0;
-			var ii : int;
-			var nn: int;
-			var slotCount: int;
-
-			if (defaultSkin) {
-				slotCount = input.readInt(true);
-				if (slotCount == 0) return null;
-				skin = new Skin("default");
-			} else {
-				skin = new Skin(input.readStringRef());
-				skin.bones.length = input.readInt(true);
-				for (i = 0, n = skin.bones.length; i < n; i++)
-					skin.bones[i] = skeletonData.bones[input.readInt(true)];
-
-				for (i = 0, n = input.readInt(true); i < n; i++)
-					skin.constraints.push(skeletonData.ikConstraints[input.readInt(true)]);
-				for (i = 0, n = input.readInt(true); i < n; i++)
-					skin.constraints.push(skeletonData.transformConstraints[input.readInt(true)]);
-				for (i = 0, n = input.readInt(true); i < n; i++)
-					skin.constraints.push(skeletonData.pathConstraints[input.readInt(true)]);
-
-				slotCount = input.readInt(true);
-			}
-
-			for (i = 0; i < slotCount; i++) {
-				var slotIndex : int = input.readInt(true);
-				for (ii = 0, nn = input.readInt(true); ii < nn; ii++) {
-					var name : String = input.readStringRef();
-					var attachment : Attachment = readAttachment(input, skeletonData, skin, slotIndex, name, nonessential);
-					if (attachment != null) skin.setAttachment(slotIndex, name, attachment);
-				}
-			}
-			return skin;
-		}
-
-		private function readAttachment(input: BinaryInput, skeletonData: SkeletonData, skin: Skin, slotIndex: int, attachmentName: String, nonessential: Boolean): Attachment {
-			var scale : Number = this.scale;
-			var i : int = 0;
-			var n : int = 0;
-
-			var vertexCount : int;
-			var vertices : Vertices;
-			var path: String;
-			var rotation : Number;
-			var x : Number;
-			var y: Number;
-			var scaleX : Number;
-			var scaleY : Number;
-			var width : Number;
-			var height : Number;
-			var color : int;
-			var mesh : MeshAttachment;
-
-			var name : String = input.readStringRef();
-			if (name == null) name = attachmentName;
-
-			switch (AttachmentType.values[input.readByte()]) {
-			case AttachmentType.region:
-				path = input.readStringRef();
-				rotation = input.readFloat();
-				x = input.readFloat();
-				y = input.readFloat();
-				scaleX = input.readFloat();
-				scaleY = input.readFloat();
-				width = input.readFloat();
-				height = input.readFloat();
-				color = input.readInt32();
-
-				if (path == null) path = name;
-				var region : RegionAttachment = this.attachmentLoader.newRegionAttachment(skin, name, path);
-				if (region == null) return null;
-				region.path = path;
-				region.x = x * scale;
-				region.y = y * scale;
-				region.scaleX = scaleX;
-				region.scaleY = scaleY;
-				region.rotation = rotation;
-				region.width = width * scale;
-				region.height = height * scale;
-				region.color.setFromRgba8888(color);
-				region.updateOffset();
-				return region;
-			case AttachmentType.boundingbox:
-				vertexCount = input.readInt(true);
-				vertices = readVertices(input, vertexCount);
-				color = nonessential ? input.readInt32() : 0;
-
-				var box : BoundingBoxAttachment = this.attachmentLoader.newBoundingBoxAttachment(skin, name);
-				if (box == null) return null;
-				box.worldVerticesLength = vertexCount << 1;
-				box.vertices = vertices.vertices;
-				box.bones = vertices.bones;
-				if (nonessential) box.color.setFromRgba8888(color);
-				return box;
-			case AttachmentType.mesh:
-				path = input.readStringRef();
-				color = input.readInt32();
-				vertexCount = input.readInt(true);
-				var uvs : Vector.<Number> = readFloatArray(input, vertexCount << 1, 1);
-				var triangles : Vector.<uint> = readUnsignedShortArray(input);
-				vertices = readVertices(input, vertexCount);
-				var hullLength : int = input.readInt(true);
-				var edges : Vector.<int> = null;
-				if (nonessential) {
-					edges = readShortArray(input);
-					width = input.readFloat();
-					height = input.readFloat();
-				}
-
-				if (path == null) path = name;
-				mesh = this.attachmentLoader.newMeshAttachment(skin, name, path);
-				if (mesh == null) return null;
-				mesh.path = path;
-				mesh.color.setFromRgba8888(color);
-				mesh.bones = vertices.bones;
-				mesh.vertices = vertices.vertices;
-				mesh.worldVerticesLength = vertexCount << 1;
-				mesh.triangles = triangles;
-				mesh.regionUVs = uvs;
-				mesh.updateUVs();
-				mesh.hullLength = hullLength << 1;
-				if (nonessential) {
-					mesh.edges = edges;
-					mesh.width = width * scale;
-					mesh.height = height * scale;
-				}
-				return mesh;
-			case AttachmentType.linkedmesh:
-				path = input.readStringRef();
-				color = input.readInt32();
-				var skinName : String = input.readStringRef();
-				var parent : String = input.readStringRef();
-				var inheritDeform : Boolean = input.readBoolean();
-				if (nonessential) {
-					width = input.readFloat();
-					height = input.readFloat();
-				}
-
-				if (path == null) path = name;
-				mesh = this.attachmentLoader.newMeshAttachment(skin, name, path);
-				if (mesh == null) return null;
-				mesh.path = path;
-				mesh.color.setFromRgba8888(color);
-				if (nonessential) {
-					mesh.width = width * scale;
-					mesh.height = height * scale;
-				}
-				this.linkedMeshes.push(new LinkedMesh(mesh, skinName, slotIndex, parent, inheritDeform));
-				return mesh;
-			case AttachmentType.path:
-				var closed : Boolean = input.readBoolean();
-				var constantSpeed : Boolean = input.readBoolean();
-				vertexCount = input.readInt(true);
-				vertices = this.readVertices(input, vertexCount);
-				var lengths : Vector.<Number> = new Vector.<Number>();
-				lengths.length = vertexCount / 3;
-				for (i = 0, n = lengths.length; i < n; i++)
-					lengths[i] = input.readFloat() * scale;
-				color = nonessential ? input.readInt32() : 0;
-
-				var pathAttachment : PathAttachment = this.attachmentLoader.newPathAttachment(skin, name);
-				if (pathAttachment == null) return null;
-				pathAttachment.closed = closed;
-				pathAttachment.constantSpeed = constantSpeed;
-				pathAttachment.worldVerticesLength = vertexCount << 1;
-				pathAttachment.vertices = vertices.vertices;
-				pathAttachment.bones = vertices.bones;
-				pathAttachment.lengths = lengths;
-				if (nonessential) pathAttachment.color.setFromRgba8888(color);
-				return pathAttachment;
-			case AttachmentType.point:
-				rotation = input.readFloat();
-				x = input.readFloat();
-				y = input.readFloat();
-				color = nonessential ? input.readInt32() : 0;
-
-				var point : PointAttachment = this.attachmentLoader.newPointAttachment(skin, name);
-				if (point == null) return null;
-				point.x = x * scale;
-				point.y = y * scale;
-				point.rotation = rotation;
-				if (nonessential) point.color.setFromRgba8888(color);
-				return point;
-			case AttachmentType.clipping:
-				var endSlotIndex : int = input.readInt(true);
-				vertexCount = input.readInt(true);
-				vertices = this.readVertices(input, vertexCount);
-				color = nonessential ? input.readInt32() : 0;
-
-				var clip : ClippingAttachment = this.attachmentLoader.newClippingAttachment(skin, name);
-				if (clip == null) return null;
-				clip.endSlot = skeletonData.slots[endSlotIndex];
-				clip.worldVerticesLength = vertexCount << 1;
-				clip.vertices = vertices.vertices;
-				clip.bones = vertices.bones;
-				if (nonessential) clip.color.setFromRgba8888(color);
-				return clip;
-			}
-			return null;
-		}
-
-		private function readVertices (input: BinaryInput, vertexCount: int): Vertices {
-			var scale : Number = this.scale;
-			var verticesLength : int = vertexCount << 1;
-			var vertices : Vertices = new Vertices();
-			if (!input.readBoolean()) {
-				vertices.vertices = readFloatArray(input, verticesLength, scale);
-				return vertices;
-			}
-			var weights : Vector.<Number> = new Vector.<Number>();
-			var bonesArray : Vector.<int> = new Vector.<int>();
-			for (var i : int = 0; i < vertexCount; i++) {
-				var boneCount : int = input.readInt(true);
-				bonesArray.push(boneCount);
-				for (var ii : int = 0; ii < boneCount; ii++) {
-					bonesArray.push(input.readInt(true));
-					weights.push(input.readFloat() * scale);
-					weights.push(input.readFloat() * scale);
-					weights.push(input.readFloat());
-				}
-			}
-			vertices.vertices = weights;
-			vertices.bones = bonesArray;
-			return vertices;
-		}
-
-		private function readFloatArray (input: BinaryInput, n: int, scale: Number): Vector.<Number> {
-			var i : int = 0;
-			var array : Vector.<Number> = new Vector.<Number>();
-			array.length = n;
-			if (scale == 1) {
-				for (i = 0; i < n; i++)
-					array[i] = input.readFloat();
-			} else {
-				for (i = 0; i < n; i++)
-					array[i] = input.readFloat() * scale;
-			}
-			return array;
-		}
-
-		private function readShortArray (input: BinaryInput): Vector.<int> {
-			var n : int = input.readInt(true);
-			var array : Vector.<int> = new Vector.<int>();
-			array.length = n;
-			for (var i : int = 0; i < n; i++)
-				array[i] = input.readShort();
-			return array;
-		}
-
-		private function readUnsignedShortArray (input: BinaryInput): Vector.<uint> {
-			var n : int = input.readInt(true);
-			var array : Vector.<uint> = new Vector.<uint>();
-			array.length = n;
-			for (var i : int = 0; i < n; i++)
-				array[i] = input.readShort();
-			return array;
-		}
-
-		private function readAnimation (input: BinaryInput, name: String, skeletonData: SkeletonData): Animation {
-			input.readInt(true); // Number of timelines.
-			var timelines : Vector.<Timeline> = new Vector.<Timeline>();
-			var scale : Number = this.scale;
-			var i : int = 0, n : int = 0, ii : int = 0, nn : int = 0;
-			var index : int, slotIndex : int, timelineType : int, timelineScale : Number;
-			var frameCount : int, frameLast : int, frame : int, bezierCount : int, bezier : int;
-			var time : Number, time2 : Number;
-
-			// Slot timelines.
-			var r : Number, g : Number, b : Number, a : Number;
-			var r2 : Number, g2 : Number, b2 : Number, a2 : Number;
-			var nr : Number, ng : Number, nb : Number, na : Number;
-			var nr2 : Number, ng2 : Number, nb2 : Number, na2 : Number;
-			for (i = 0, n = input.readInt(true); i < n; i++) {
-				slotIndex = input.readInt(true);
-				for (ii = 0, nn = input.readInt(true); ii < nn; ii++) {
-					timelineType = input.readByte();
-					frameCount = input.readInt(true);
-					frameLast = frameCount - 1;
-					switch (timelineType) {
-					case SLOT_ATTACHMENT:
-						var attachmentTimeline : AttachmentTimeline = new AttachmentTimeline(frameCount, slotIndex);
-						for (frame = 0; frame < frameCount; frame++)
-							attachmentTimeline.setFrame(frame, input.readFloat(), input.readStringRef());
-						timelines.push(attachmentTimeline);
-						break;
-					case SLOT_RGBA:
-						bezierCount = input.readInt(true);
-						var rgbaTimeline : RGBATimeline = new RGBATimeline(frameCount, bezierCount, slotIndex);
-
-						time = input.readFloat();
-						r = input.readUnsignedByte() / 255.0;
-						g = input.readUnsignedByte() / 255.0;
-						b = input.readUnsignedByte() / 255.0;
-						a = input.readUnsignedByte() / 255.0;
-
-						for (frame = 0, bezier = 0;; frame++) {
-							rgbaTimeline.setFrame(frame, time, r, g, b, a);
-							if (frame == frameLast) break;
-
-							time2 = input.readFloat();
-							r2 = input.readUnsignedByte() / 255.0;
-							g2 = input.readUnsignedByte() / 255.0;
-							b2 = input.readUnsignedByte() / 255.0;
-							a2 = input.readUnsignedByte() / 255.0;
-
-							switch (input.readByte()) {
-							case CURVE_STEPPED:
-								rgbaTimeline.setStepped(frame);
-								break;
-							case CURVE_BEZIER:
-								setBezier(input, rgbaTimeline, bezier++, frame, 0, time, time2, r, r2, 1);
-								setBezier(input, rgbaTimeline, bezier++, frame, 1, time, time2, g, g2, 1);
-								setBezier(input, rgbaTimeline, bezier++, frame, 2, time, time2, b, b2, 1);
-								setBezier(input, rgbaTimeline, bezier++, frame, 3, time, time2, a, a2, 1);
-							}
-							time = time2;
-							r = r2;
-							g = g2;
-							b = b2;
-							a = a2;
-						}
-						timelines.push(rgbaTimeline);
-						break;
-					case SLOT_RGB:
-						bezierCount = input.readInt(true);
-						var rgbTimeline : RGBTimeline = new RGBTimeline(frameCount, bezierCount, slotIndex);
-
-						time = input.readFloat();
-						r = input.readUnsignedByte() / 255.0;
-						g = input.readUnsignedByte() / 255.0;
-						b = input.readUnsignedByte() / 255.0;
-
-						for (frame = 0, bezier = 0;; frame++) {
-							rgbTimeline.setFrame(frame, time, r, g, b);
-							if (frame == frameLast) break;
-
-							time2 = input.readFloat();
-							r2 = input.readUnsignedByte() / 255.0;
-							g2 = input.readUnsignedByte() / 255.0;
-							b2 = input.readUnsignedByte() / 255.0;
-
-							switch (input.readByte()) {
-							case CURVE_STEPPED:
-								rgbTimeline.setStepped(frame);
-								break;
-							case CURVE_BEZIER:
-								setBezier(input, rgbTimeline, bezier++, frame, 0, time, time2, r, r2, 1);
-								setBezier(input, rgbTimeline, bezier++, frame, 1, time, time2, g, g2, 1);
-								setBezier(input, rgbTimeline, bezier++, frame, 2, time, time2, b, b2, 1);
-							}
-							time = time2;
-							r = r2;
-							g = g2;
-							b = b2;
-						}
-						timelines.push(rgbTimeline);
-						break;
-					case SLOT_RGBA2:
-						bezierCount = input.readInt(true);
-						var rgba2Timeline : RGBA2Timeline = new RGBA2Timeline(frameCount, bezierCount, slotIndex);
-
-						time = input.readFloat();
-						r = input.readUnsignedByte() / 255.0;
-						g = input.readUnsignedByte() / 255.0;
-						b = input.readUnsignedByte() / 255.0;
-						a = input.readUnsignedByte() / 255.0;
-						r2 = input.readUnsignedByte() / 255.0;
-						g2 = input.readUnsignedByte() / 255.0;
-						b2 = input.readUnsignedByte() / 255.0;
-
-						for (frame = 0, bezier = 0;; frame++) {
-							rgba2Timeline.setFrame(frame, time, r, g, b, a, r2, g2, b2);
-							if (frame == frameLast) break;
-							time2 = input.readFloat();
-							nr = input.readUnsignedByte() / 255.0;
-							ng = input.readUnsignedByte() / 255.0;
-							nb = input.readUnsignedByte() / 255.0;
-							na = input.readUnsignedByte() / 255.0;
-							nr2 = input.readUnsignedByte() / 255.0;
-							ng2 = input.readUnsignedByte() / 255.0;
-							nb2 = input.readUnsignedByte() / 255.0;
-
-							switch (input.readByte()) {
-							case CURVE_STEPPED:
-								rgba2Timeline.setStepped(frame);
-								break;
-							case CURVE_BEZIER:
-								setBezier(input, rgba2Timeline, bezier++, frame, 0, time, time2, r, nr, 1);
-								setBezier(input, rgba2Timeline, bezier++, frame, 1, time, time2, g, ng, 1);
-								setBezier(input, rgba2Timeline, bezier++, frame, 2, time, time2, b, nb, 1);
-								setBezier(input, rgba2Timeline, bezier++, frame, 3, time, time2, a, na, 1);
-								setBezier(input, rgba2Timeline, bezier++, frame, 4, time, time2, r2, nr2, 1);
-								setBezier(input, rgba2Timeline, bezier++, frame, 5, time, time2, g2, ng2, 1);
-								setBezier(input, rgba2Timeline, bezier++, frame, 6, time, time2, b2, nb2, 1);
-							}
-							time = time2;
-							r = nr;
-							g = ng;
-							b = nb;
-							a = na;
-							r2 = nr2;
-							g2 = ng2;
-							b2 = nb2;
-						}
-						timelines.push(rgba2Timeline);
-						break;
-					case SLOT_RGB2:
-						bezierCount = input.readInt(true);
-						var rgb2Timeline : RGB2Timeline = new RGB2Timeline(frameCount, bezierCount, slotIndex);
-
-						time = input.readFloat();
-						r = input.readUnsignedByte() / 255.0;
-						g = input.readUnsignedByte() / 255.0;
-						b = input.readUnsignedByte() / 255.0;
-						r2 = input.readUnsignedByte() / 255.0;
-						g2 = input.readUnsignedByte() / 255.0;
-						b2 = input.readUnsignedByte() / 255.0;
-
-						for (frame = 0, bezier = 0;; frame++) {
-							rgb2Timeline.setFrame(frame, time, r, g, b, r2, g2, b2);
-							if (frame == frameLast) break;
-							time2 = input.readFloat();
-							nr = input.readUnsignedByte() / 255.0;
-							ng = input.readUnsignedByte() / 255.0;
-							nb = input.readUnsignedByte() / 255.0;
-							nr2 = input.readUnsignedByte() / 255.0;
-							ng2 = input.readUnsignedByte() / 255.0;
-							nb2 = input.readUnsignedByte() / 255.0;
-
-							switch (input.readByte()) {
-							case CURVE_STEPPED:
-								rgb2Timeline.setStepped(frame);
-								break;
-							case CURVE_BEZIER:
-								setBezier(input, rgb2Timeline, bezier++, frame, 0, time, time2, r, nr, 1);
-								setBezier(input, rgb2Timeline, bezier++, frame, 1, time, time2, g, ng, 1);
-								setBezier(input, rgb2Timeline, bezier++, frame, 2, time, time2, b, nb, 1);
-								setBezier(input, rgb2Timeline, bezier++, frame, 3, time, time2, r2, nr2, 1);
-								setBezier(input, rgb2Timeline, bezier++, frame, 4, time, time2, g2, ng2, 1);
-								setBezier(input, rgb2Timeline, bezier++, frame, 5, time, time2, b2, nb2, 1);
-							}
-							time = time2;
-							r = nr;
-							g = ng;
-							b = nb;
-							r2 = nr2;
-							g2 = ng2;
-							b2 = nb2;
-						}
-						timelines.push(rgb2Timeline);
-						break;
-					case SLOT_ALPHA:
-						var alphaTimeline : AlphaTimeline = new AlphaTimeline(frameCount, input.readInt(true), slotIndex);
-						time = input.readFloat();
-						a = input.readUnsignedByte() / 255;
-						for (frame = 0, bezier = 0;; frame++) {
-							alphaTimeline.setFrame(frame, time, a);
-							if (frame == frameLast) break;
-							time2 = input.readFloat();
-							a2 = input.readUnsignedByte() / 255;
-							switch (input.readByte()) {
-							case CURVE_STEPPED:
-								alphaTimeline.setStepped(frame);
-								break;
-							case CURVE_BEZIER:
-								setBezier(input, alphaTimeline, bezier++, frame, 0, time, time2, a, a2, 1);
-							}
-							time = time2;
-							a = a2;
-						}
-						timelines.push(alphaTimeline);
-					}
-				}
-			}
-
-			// Bone timelines.
-			for (i = 0, n = input.readInt(true); i < n; i++) {
-				var boneIndex : int = input.readInt(true);
-				for (ii = 0, nn = input.readInt(true); ii < nn; ii++) {
-					timelineType = input.readByte();
-					frameCount = input.readInt(true);
-					bezierCount = input.readInt(true);
-					switch (timelineType) {
-					case BONE_ROTATE:
-						timelines.push(readTimeline(input, new RotateTimeline(frameCount, bezierCount, boneIndex), 1));
-						break;
-					case BONE_TRANSLATE:
-						timelines.push(readTimeline2(input, new TranslateTimeline(frameCount, bezierCount, boneIndex), scale));
-						break;
-					case BONE_TRANSLATEX:
-						timelines.push(readTimeline(input, new TranslateXTimeline(frameCount, bezierCount, boneIndex), scale));
-						break;
-					case BONE_TRANSLATEY:
-						timelines.push(readTimeline(input, new TranslateYTimeline(frameCount, bezierCount, boneIndex), scale));
-						break;
-					case BONE_SCALE:
-						timelines.push(readTimeline2(input, new ScaleTimeline(frameCount, bezierCount, boneIndex), 1));
-						break;
-					case BONE_SCALEX:
-						timelines.push(readTimeline(input, new ScaleXTimeline(frameCount, bezierCount, boneIndex), 1));
-						break;
-					case BONE_SCALEY:
-						timelines.push(readTimeline(input, new ScaleYTimeline(frameCount, bezierCount, boneIndex), 1));
-						break;
-					case BONE_SHEAR:
-						timelines.push(readTimeline2(input, new ShearTimeline(frameCount, bezierCount, boneIndex), 1));
-						break;
-					case BONE_SHEARX:
-						timelines.push(readTimeline(input, new ShearXTimeline(frameCount, bezierCount, boneIndex), 1));
-						break;
-					case BONE_SHEARY:
-						timelines.push(readTimeline(input, new ShearYTimeline(frameCount, bezierCount, boneIndex), 1));
-					}
-				}
-			}
-
-			// IK constraint timelines.
-			for (i = 0, n = input.readInt(true); i < n; i++) {
-				index = input.readInt(true);
-				frameCount = input.readInt(true);
-				frameLast = frameCount - 1;
-				var ikTimeline : IkConstraintTimeline = new IkConstraintTimeline(frameCount, input.readInt(true), index);
-				time = input.readFloat();
-				var mix : Number = input.readFloat(), softness : Number = input.readFloat() * scale;
-				for (frame = 0, bezier = 0;; frame++) {
-					ikTimeline.setFrame(frame, time, mix, softness, input.readByte(), input.readBoolean(), input.readBoolean());
-					if (frame == frameLast) break;
-					time2 = input.readFloat();
-					var mix2 : Number = input.readFloat(), softness2 : Number = input.readFloat() * scale;
-					switch (input.readByte()) {
-					case CURVE_STEPPED:
-						ikTimeline.setStepped(frame);
-						break;
-					case CURVE_BEZIER:
-						setBezier(input, ikTimeline, bezier++, frame, 0, time, time2, mix, mix2, 1);
-						setBezier(input, ikTimeline, bezier++, frame, 1, time, time2, softness, softness2, scale);
-					}
-					time = time2;
-					mix = mix2;
-					softness = softness2;
-				}
-				timelines.push(ikTimeline);
-			}
-
-			// Transform constraint timelines.
-			var mixRotate : Number, mixRotate2 : Number;
-			var mixX : Number, mixX2 : Number;
-			var mixY : Number, mixY2 : Number;
-			for (i = 0, n = input.readInt(true); i < n; i++) {
-				index = input.readInt(true);
-				frameCount = input.readInt(true);
-				frameLast = frameCount - 1;
-				var transformTimeline : TransformConstraintTimeline = new TransformConstraintTimeline(frameCount, input.readInt(true), index);
-				time = input.readFloat();
-				mixRotate = input.readFloat();
-				mixX = input.readFloat();
-				mixY = input.readFloat();
-				var mixScaleX : Number = input.readFloat(), mixScaleY : Number = input.readFloat(), mixShearY : Number = input.readFloat();
-				for (frame = 0, bezier = 0;; frame++) {
-					transformTimeline.setFrame(frame, time, mixRotate, mixX, mixY, mixScaleX, mixScaleY, mixShearY);
-					if (frame == frameLast) break;
-					time2 = input.readFloat()
-					mixRotate2 = input.readFloat();
-					mixX2 = input.readFloat();
-					mixY2 = input.readFloat();
-					var mixScaleX2 : Number = input.readFloat(), mixScaleY2 : Number = input.readFloat(), mixShearY2 : Number = input.readFloat();
-					switch (input.readByte()) {
-					case CURVE_STEPPED:
-						transformTimeline.setStepped(frame);
-						break;
-					case CURVE_BEZIER:
-						setBezier(input, transformTimeline, bezier++, frame, 0, time, time2, mixRotate, mixRotate2, 1);
-						setBezier(input, transformTimeline, bezier++, frame, 1, time, time2, mixX, mixX2, 1);
-						setBezier(input, transformTimeline, bezier++, frame, 2, time, time2, mixY, mixY2, 1);
-						setBezier(input, transformTimeline, bezier++, frame, 3, time, time2, mixScaleX, mixScaleX2, 1);
-						setBezier(input, transformTimeline, bezier++, frame, 4, time, time2, mixScaleY, mixScaleY2, 1);
-						setBezier(input, transformTimeline, bezier++, frame, 5, time, time2, mixShearY, mixShearY2, 1);
-					}
-					time = time2;
-					mixRotate = mixRotate2;
-					mixX = mixX2;
-					mixY = mixY2;
-					mixScaleX = mixScaleX2;
-					mixScaleY = mixScaleY2;
-					mixShearY = mixShearY2;
-				}
-				timelines.push(transformTimeline);
-			}
-
-			// Path constraint timelines.
-			for (i = 0, n = input.readInt(true); i < n; i++) {
-				index = input.readInt(true);
-				var data : PathConstraintData = skeletonData.pathConstraints[index];
-				for (ii = 0, nn = input.readInt(true); ii < nn; ii++) {
-					switch (input.readByte()) {
-					case PATH_POSITION:
-						timelines
-							.push(readTimeline(input, new PathConstraintPositionTimeline(input.readInt(true), input.readInt(true), index),
-								data.positionMode == PositionMode.fixed ? scale : 1));
-						break;
-					case PATH_SPACING:
-						timelines
-							.push(readTimeline(input, new PathConstraintSpacingTimeline(input.readInt(true), input.readInt(true), index),
-								data.spacingMode == SpacingMode.length || data.spacingMode == SpacingMode.fixed ? scale : 1));
-						break;
-					case PATH_MIX:
-						var mixTimeline : PathConstraintMixTimeline = new PathConstraintMixTimeline(input.readInt(true), input.readInt(true), index);
-						time = input.readFloat();
-						mixRotate = input.readFloat();
-						mixX = input.readFloat();
-						mixY = input.readFloat();
-						for (frame = 0, bezier = 0, frameLast = mixTimeline.getFrameCount() - 1;; frame++) {
-							mixTimeline.setFrame(frame, time, mixRotate, mixX, mixY);
-							if (frame == frameLast) break;
-							time2 = input.readFloat();
-							mixRotate2 = input.readFloat();
-							mixX2 = input.readFloat();
-							mixY2 = input.readFloat();
-							switch (input.readByte()) {
-							case CURVE_STEPPED:
-								mixTimeline.setStepped(frame);
-								break;
-							case CURVE_BEZIER:
-								setBezier(input, mixTimeline, bezier++, frame, 0, time, time2, mixRotate, mixRotate2, 1);
-								setBezier(input, mixTimeline, bezier++, frame, 1, time, time2, mixX, mixX2, 1);
-								setBezier(input, mixTimeline, bezier++, frame, 2, time, time2, mixY, mixY2, 1);
-							}
-							time = time2;
-							mixRotate = mixRotate2;
-							mixX = mixX2;
-							mixY = mixY2;
-						}
-						timelines.push(mixTimeline);
-					}
-				}
-			}
-
-			// Deform timelines.
-			for (i = 0, n = input.readInt(true); i < n; i++) {
-				var skin : Skin = skeletonData.skins[input.readInt(true)];
-				for (ii = 0, nn = input.readInt(true); ii < nn; ii++) {
-					slotIndex = input.readInt(true);
-					for (var iii : int = 0, nnn : int = input.readInt(true); iii < nnn; iii++) {
-						var attachmentName : String = input.readStringRef();
-						var attachment : VertexAttachment = skin.getAttachment(slotIndex, attachmentName) as VertexAttachment;
-						if (attachment == null) throw Error("Vertex attachment not found: " + attachmentName);
-						var weighted : Boolean = attachment.bones != null;
-						var vertices : Vector.<Number> = attachment.vertices;
-						var deformLength : int = weighted ? vertices.length / 3 * 2 : vertices.length;
-
-						frameCount = input.readInt(true);
-						frameLast = frameCount - 1;
-						bezierCount = input.readInt(true);
-						var deformTimeline : DeformTimeline = new DeformTimeline(frameCount, bezierCount, slotIndex, attachment);
-
-						time = input.readFloat();
-						for (frame = 0, bezier = 0;; frame++) {
-							var deform : Vector.<Number>;
-							var end : int = input.readInt(true);
-							if (end == 0) {
-								if (weighted) {
-									deform = new Vector.<Number>();
-									deform.length = deformLength;
-								} else
-									deform = vertices;
-							} else {
-								var v : int, vn: int;
-								deform = new Vector.<Number>();
-								deform.length = deformLength;
-								var start : int = input.readInt(true);
-								end += start;
-								if (scale == 1) {
-									for (v = start; v < end; v++)
-										deform[v] = input.readFloat();
-								} else {
-									for (v = start; v < end; v++)
-										deform[v] = input.readFloat() * scale;
-								}
-								if (!weighted) {
-									for (v = 0, vn = deform.length; v < vn; v++)
-										deform[v] += vertices[v];
-								}
-							}
-
-							deformTimeline.setFrame(frame, time, deform);
-							if (frame == frameLast) break;
-							time2 = input.readFloat();
-							switch(input.readByte()) {
-							case CURVE_STEPPED:
-								deformTimeline.setStepped(frame);
-								break;
-							case CURVE_BEZIER:
-								SkeletonBinary.setBezier(input, deformTimeline, bezier++, frame, 0, time, time2, 0, 1, 1);
-							}
-							time = time2;
-						}
-						timelines.push(deformTimeline);
-					}
-				}
-			}
-
-			// Draw order timelines.
-			var drawOrderCount : int = input.readInt(true);
-			if (drawOrderCount > 0) {
-				var drawOrderTimeline : DrawOrderTimeline = new DrawOrderTimeline(drawOrderCount);
-				var slotCount : int = skeletonData.slots.length;
-				for (i = 0; i < drawOrderCount; i++) {
-					time = input.readFloat();
-					var offsetCount : int = input.readInt(true);
-					var drawOrder : Vector.<int> = new Vector.<int>();
-					drawOrder.length = slotCount;
-					for (ii = slotCount - 1; ii >= 0; ii--)
-						drawOrder[ii] = -1;
-					var unchanged : Vector.<int> = new Vector.<int>();
-					unchanged.length = slotCount - offsetCount;
-					var originalIndex : int = 0, unchangedIndex : int = 0;
-					for (ii = 0; ii < offsetCount; ii++) {
-						slotIndex = input.readInt(true);
-						// Collect unchanged items.
-						while (originalIndex != slotIndex)
-							unchanged[unchangedIndex++] = originalIndex++;
-						// Set changed items.
-						drawOrder[originalIndex + input.readInt(true)] = originalIndex++;
-					}
-					// Collect remaining unchanged items.
-					while (originalIndex < slotCount)
-						unchanged[unchangedIndex++] = originalIndex++;
-					// Fill in unchanged items.
-					for (ii = slotCount - 1; ii >= 0; ii--)
-						if (drawOrder[ii] == -1) drawOrder[ii] = unchanged[--unchangedIndex];
-					drawOrderTimeline.setFrame(i, time, drawOrder);
-				}
-				timelines.push(drawOrderTimeline);
-			}
-
-			// Event timelines.
-			var eventCount : int = input.readInt(true);
-			if (eventCount > 0) {
-				var eventTimeline : EventTimeline = new EventTimeline(eventCount);
-				for (i = 0; i < eventCount; i++) {
-					time = input.readFloat();
-					var eventData : EventData = skeletonData.events[input.readInt(true)];
-					var event : Event = new Event(time, eventData);
-					event.intValue = input.readInt(false);
-					event.floatValue = input.readFloat();
-					event.stringValue = input.readBoolean() ? input.readString() : eventData.stringValue;
-					if (event.data.audioPath != null) {
-						event.volume = input.readFloat();
-						event.balance = input.readFloat();
-					}
-					eventTimeline.setFrame(i, event);
-				}
-				timelines.push(eventTimeline);
-			}
-
-			var duration : Number = 0;
-			for (i = 0, n = timelines.length; i < n; i++)
-				duration = Math.max(duration, timelines[i].getDuration());
-			return new Animation(name, timelines, duration);
-		}
-
-		static private function readTimeline (input: BinaryInput, timeline: CurveTimeline1, scale: Number) : CurveTimeline1 {
-			var time : Number = input.readFloat(), value : Number = input.readFloat() * scale;
-			for (var frame : int = 0, bezier : int = 0, frameLast : int = timeline.getFrameCount() - 1;; frame++) {
-				timeline.setFrame(frame, time, value);
-				if (frame == frameLast) break;
-				var time2 : Number = input.readFloat(), value2 : Number = input.readFloat() * scale;
-				switch (input.readByte()) {
-				case CURVE_STEPPED:
-					timeline.setStepped(frame);
-					break;
-				case CURVE_BEZIER:
-					setBezier(input, timeline, bezier++, frame, 0, time, time2, value, value2, scale);
-				}
-				time = time2;
-				value = value2;
-			}
-			return timeline;
-		}
-
-		static private function readTimeline2 (input: BinaryInput, timeline: CurveTimeline2, scale: Number) : CurveTimeline2 {
-			var time : Number = input.readFloat(), value1 : Number = input.readFloat() * scale, value2 : Number = input.readFloat() * scale;
-			for (var frame : int = 0, bezier : int = 0, frameLast : int = timeline.getFrameCount() - 1;; frame++) {
-				timeline.setFrame(frame, time, value1, value2);
-				if (frame == frameLast) break;
-				var time2 : Number = input.readFloat(), nvalue1 : Number = input.readFloat() * scale, nvalue2 : Number = input.readFloat() * scale;
-				switch (input.readByte()) {
-				case CURVE_STEPPED:
-					timeline.setStepped(frame);
-					break;
-				case CURVE_BEZIER:
-					setBezier(input, timeline, bezier++, frame, 0, time, time2, value1, nvalue1, scale);
-					setBezier(input, timeline, bezier++, frame, 1, time, time2, value2, nvalue2, scale);
-				}
-				time = time2;
-				value1 = nvalue1;
-				value2 = nvalue2;
-			}
-			return timeline;
-		}
-
-		static private function setBezier (input: BinaryInput, timeline: CurveTimeline, bezier: Number, frame: Number, value: Number,
-			time1: Number, time2: Number, value1: Number, value2: Number, scale: Number) : void {
-			timeline.setBezier(bezier, frame, value, time1, value1, input.readFloat(), input.readFloat() * scale, input.readFloat(), input.readFloat() * scale, time2, value2);
-		}
-	}
-}
-
-import spine.attachments.MeshAttachment;
-
-class Vertices {
-	public var vertices : Vector.<Number> = new Vector.<Number>();
-	public var bones : Vector.<int> = new Vector.<int>();
-}
-
-class LinkedMesh {
-	internal var parent : String, skin : String;
-	internal var slotIndex : int;
-	internal var mesh : MeshAttachment;
-	internal var inheritDeform : Boolean;
-
-	public function LinkedMesh(mesh : MeshAttachment, skin : String, slotIndex : int, parent : String, inheritDeform : Boolean) {
-		this.mesh = mesh;
-		this.skin = skin;
-		this.slotIndex = slotIndex;
-		this.parent = parent;
-		this.inheritDeform = inheritDeform;
-	}
-}

spine-as3/spine-as3/src/spine/SkeletonBounds.as

@@ -1,156 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine {
-	import spine.attachments.BoundingBoxAttachment;
-
-	public class SkeletonBounds {
-		private var polygonPool : Vector.<Polygon> = new Vector.<Polygon>();
-		public var boundingBoxes : Vector.<BoundingBoxAttachment> = new Vector.<BoundingBoxAttachment>();
-		public var polygons : Vector.<Polygon> = new Vector.<Polygon>();
-		public var minX : Number, minY : Number, maxX : Number, maxY : Number;
-
-		public function SkeletonBounds() {
-		}
-
-		public function update(skeleton : Skeleton, updateAabb : Boolean) : void {
-			var slots : Vector.<Slot> = skeleton.slots;
-			var slotCount : int = slots.length;
-
-			boundingBoxes.length = 0;
-			for each (var polygon : Polygon in polygons)
-				polygonPool[polygonPool.length] = polygon;
-			polygons.length = 0;
-
-			for (var i : int = 0; i < slotCount; i++) {
-				var slot : Slot = slots[i];
-				if (!slot.bone.active) continue;
-				var boundingBox : BoundingBoxAttachment = slot.attachment as BoundingBoxAttachment;
-				if (boundingBox == null) continue;
-				boundingBoxes[boundingBoxes.length] = boundingBox;
-
-				var poolCount : int = polygonPool.length;
-				if (poolCount > 0) {
-					polygon = polygonPool[poolCount - 1];
-					polygonPool.splice(poolCount - 1, 1);
-				} else
-					polygon = new Polygon();
-				polygons[polygons.length] = polygon;
-
-				polygon.vertices.length = boundingBox.worldVerticesLength;
-				boundingBox.computeWorldVertices(slot, 0, boundingBox.worldVerticesLength, polygon.vertices, 0, 2);
-			}
-
-			if (updateAabb)
-				aabbCompute();
-			else {
-				minX = Number.MIN_VALUE;
-				minY = Number.MIN_VALUE;
-				maxX = Number.MAX_VALUE;
-				maxY = Number.MAX_VALUE;
-			}
-		}
-
-		private function aabbCompute() : void {
-			var minX : Number = Number.MAX_VALUE, minY : Number = Number.MAX_VALUE;
-			var maxX : Number = -Number.MAX_VALUE, maxY : Number = -Number.MAX_VALUE;
-			for (var i : int = 0, n : int = polygons.length; i < n; i++) {
-				var polygon : Polygon = polygons[i];
-				var vertices : Vector.<Number> = polygon.vertices;
-				for (var ii : int = 0, nn : int = vertices.length; ii < nn; ii += 2) {
-					var x : Number = vertices[ii];
-					var y : Number = vertices[ii + 1];
-					minX = Math.min(minX, x);
-					minY = Math.min(minY, y);
-					maxX = Math.max(maxX, x);
-					maxY = Math.max(maxY, y);
-				}
-			}
-			this.minX = minX;
-			this.minY = minY;
-			this.maxX = maxX;
-			this.maxY = maxY;
-		}
-
-		/** Returns true if the axis aligned bounding box contains the point. */
-		public function aabbContainsPoint(x : Number, y : Number) : Boolean {
-			return x >= minX && x <= maxX && y >= minY && y <= maxY;
-		}
-
-		/** Returns true if the axis aligned bounding box intersects the line segment. */
-		public function aabbIntersectsSegment(x1 : Number, y1 : Number, x2 : Number, y2 : Number) : Boolean {
-			if ((x1 <= minX && x2 <= minX) || (y1 <= minY && y2 <= minY) || (x1 >= maxX && x2 >= maxX) || (y1 >= maxY && y2 >= maxY))
-				return false;
-			var m : Number = (y2 - y1) / (x2 - x1);
-			var y : Number = m * (minX - x1) + y1;
-			if (y > minY && y < maxY) return true;
-			y = m * (maxX - x1) + y1;
-			if (y > minY && y < maxY) return true;
-			var x : Number = (minY - y1) / m + x1;
-			if (x > minX && x < maxX) return true;
-			x = (maxY - y1) / m + x1;
-			if (x > minX && x < maxX) return true;
-			return false;
-		}
-
-		/** Returns true if the axis aligned bounding box intersects the axis aligned bounding box of the specified bounds. */
-		public function aabbIntersectsSkeleton(bounds : SkeletonBounds) : Boolean {
-			return minX < bounds.maxX && maxX > bounds.minX && minY < bounds.maxY && maxY > bounds.minY;
-		}
-
-		/** Returns the first bounding box attachment that contains the point, or null. When doing many checks, it is usually more
-		 * efficient to only call this method if {@link #aabbContainsPoint(float, float)} returns true. */
-		public function containsPoint(x : Number, y : Number) : BoundingBoxAttachment {
-			for (var i : int = 0, n : int = polygons.length; i < n; i++)
-				if (polygons[i].containsPoint(x, y)) return boundingBoxes[i];
-			return null;
-		}
-
-		/** Returns the first bounding box attachment that contains the line segment, or null. When doing many checks, it is usually
-		 * more efficient to only call this method if {@link #aabbIntersectsSegment(float, float, float, float)} returns true. */
-		public function intersectsSegment(x1 : Number, y1 : Number, x2 : Number, y2 : Number) : BoundingBoxAttachment {
-			for (var i : int = 0, n : int = polygons.length; i < n; i++)
-				if (polygons[i].intersectsSegment(x1, y1, x2, y2)) return boundingBoxes[i];
-			return null;
-		}
-
-		public function getPolygon(attachment : BoundingBoxAttachment) : Polygon {
-			var index : int = boundingBoxes.indexOf(attachment);
-			return index == -1 ? null : polygons[index];
-		}
-
-		public function get width() : Number {
-			return maxX - minX;
-		}
-
-		public function get height() : Number {
-			return maxY - minY;
-		}
-	}
-}

spine-as3/spine-as3/src/spine/SkeletonClipping.as

@@ -1,313 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine {
-	import spine.attachments.ClippingAttachment;
-	
-	public class SkeletonClipping {
-		private var triangulator : Triangulator = new Triangulator();
-		private var clippingPolygon : Vector.<Number> = new Vector.<Number>();
-		private var clipOutput : Vector.<Number> = new Vector.<Number>();
-		public var clippedVertices : Vector.<Number> = new Vector.<Number>();
-		public var clippedUvs : Vector.<Number> = new Vector.<Number>();
-		public var clippedTriangles : Vector.<uint> = new Vector.<uint>();		
-		private var scratch : Vector.<Number> = new Vector.<Number>();
-
-		private var clipAttachment: ClippingAttachment;
-		private var clippingPolygons: Vector.<Vector.<Number>>;
-
-		public function SkeletonClipping () {
-		}
-
-		public function clipStart (slot: Slot, clip: ClippingAttachment) : int {
-			if (this.clipAttachment != null) return 0;
-			this.clipAttachment = clip;
-
-			var i : int, n : int = clip.worldVerticesLength;			
-			var vertices : Vector.<Number> = this.clippingPolygon;
-			vertices.length = n;
-			clip.computeWorldVertices(slot, 0, n, vertices, 0, 2);
-			var clippingPolygon : Vector.<Number> = this.clippingPolygon;
-			SkeletonClipping.makeClockwise(clippingPolygon);
-			var clippingPolygons : Vector.<Vector.<Number>> = this.clippingPolygons = this.triangulator.decompose(clippingPolygon, triangulator.triangulate(clippingPolygon));
-			for (i = 0, n = clippingPolygons.length; i < n; i++) {
-				var polygon : Vector.<Number> = clippingPolygons[i];
-				SkeletonClipping.makeClockwise(polygon);
-				polygon.push(polygon[0]);
-				polygon.push(polygon[1]);
-			}
-			
-			return clippingPolygons.length;
-		}
-
-		public function clipEndWithSlot (slot: Slot) : void {
-			if (this.clipAttachment != null && this.clipAttachment.endSlot == slot.data) this.clipEnd();
-		}
-
-		public function clipEnd () : void {
-			if (this.clipAttachment == null) return;
-			this.clipAttachment = null;
-			this.clippingPolygons = null;
-			this.clippedVertices.length = 0;
-			this.clippedTriangles.length = 0;
-			this.clippingPolygon.length = 0;
-		}
-
-		public function isClipping (): Boolean {
-			return this.clipAttachment != null;
-		}
-
-		public function clipTriangles (vertices: Vector.<Number>, triangles: Vector.<uint>, trianglesLength: Number, uvs: Vector.<Number>) : void {
-
-			var clipOutput : Vector.<Number> = this.clipOutput, clippedVertices : Vector.<Number> = this.clippedVertices,  clippedUvs : Vector.<Number> = this.clippedUvs;
-			var clippedTriangles : Vector.<uint> = this.clippedTriangles;
-			var polygons : Vector.<Vector.<Number>> = this.clippingPolygons;
-			var polygonsCount : int = this.clippingPolygons.length;
-
-			var index : int = 0;
-			clippedVertices.length = 0;
-			clippedUvs.length = 0;
-			clippedTriangles.length = 0;
-			outer:
-			for (var i : int = 0; i < trianglesLength; i += 3) {
-				var vertexOffset : int = triangles[i] << 1;
-				var x1 : Number = vertices[vertexOffset], y1 : Number = vertices[vertexOffset + 1];
-				var u1 : Number = uvs[vertexOffset], v1 : Number = uvs[vertexOffset + 1];
-
-				vertexOffset = triangles[i + 1] << 1;
-				var x2 : Number = vertices[vertexOffset], y2 : Number = vertices[vertexOffset + 1];
-				var u2 : Number = uvs[vertexOffset], v2 : Number = uvs[vertexOffset + 1];
-
-				vertexOffset = triangles[i + 2] << 1;
-				var x3 : Number = vertices[vertexOffset], y3 : Number = vertices[vertexOffset + 1];
-				var u3 : Number = uvs[vertexOffset], v3 : Number = uvs[vertexOffset + 1];
-
-				for (var p : int = 0; p < polygonsCount; p++) {
-					var s : int = clippedVertices.length;
-					var clippedVerticesItems : Vector.<Number>;
-					var clippedUvsItems : Vector.<Number>;
-					var clippedTrianglesItems : Vector.<uint>;
-					if (this.clip(x1, y1, x2, y2, x3, y3, polygons[p], clipOutput)) {
-						var clipOutputLength : int = clipOutput.length;
-						if (clipOutputLength == 0) continue;
-						var d0 : Number = y2 - y3, d1 : Number = x3 - x2, d2 : Number = x1 - x3, d4 : Number = y3 - y1;
-						var d : Number = 1 / (d0 * d2 + d1 * (y1 - y3));
-						
-						var clipOutputCount : int = clipOutputLength >> 1;
-						var clipOutputItems : Vector.<Number> = this.clipOutput;
-						clippedVerticesItems = clippedVertices;
-						clippedVerticesItems.length = s + clipOutputLength;
-						clippedUvsItems = clippedUvs;
-						clippedUvsItems.length = s + clipOutputLength;
-						
-						var ii : int;
-						for (ii = 0; ii < clipOutputLength; ii += 2) {
-							var x : Number = clipOutputItems[ii], y : Number = clipOutputItems[ii + 1];
-							clippedVerticesItems[s] = x;
-							clippedVerticesItems[s + 1] = y;
-							var c0 : Number = x - x3, c1 : Number = y - y3;
-							var a : Number = (d0 * c0 + d1 * c1) * d;
-							var b : Number = (d4 * c0 + d2 * c1) * d;
-							var c : Number = 1 - a - b;
-							clippedUvsItems[s] = u1 * a + u2 * b + u3 * c;
-							clippedUvsItems[s + 1] = v1 * a + v2 * b + v3 * c;
-							s += 2;
-						}
-
-						s = clippedTriangles.length;
-						clippedTrianglesItems = clippedTriangles;
-						clippedTrianglesItems.length = s + 3 * (clipOutputCount - 2);
-						clipOutputCount--;
-						for (ii = 1; ii < clipOutputCount; ii++) {
-							clippedTrianglesItems[s] = index;
-							clippedTrianglesItems[s + 1] = (index + ii);
-							clippedTrianglesItems[s + 2] = (index + ii + 1);
-							s += 3;
-						}
-						index += clipOutputCount + 1;
-
-					} else {
-						clippedVerticesItems = clippedVertices;
-						clippedVerticesItems.length = s + 3 * 2;
-						clippedVerticesItems[s] = x1;
-						clippedVerticesItems[s + 1] = y1;
-						clippedVerticesItems[s + 2] = x2;
-						clippedVerticesItems[s + 3] = y2;
-						clippedVerticesItems[s + 4] = x3;
-						clippedVerticesItems[s + 5] = y3;
-						
-						clippedUvsItems = clippedUvs;
-						clippedUvsItems.length = s + 3 * 2;
-						clippedUvsItems[s] = u1;
-						clippedUvsItems[s + 1] = v1;
-						clippedUvsItems[s + 2] = u2;
-						clippedUvsItems[s + 3] = v2;						
-						clippedUvsItems[s + 4] = u3;						
-						clippedUvsItems[s + 5] = v3;
-
-						s = clippedTriangles.length;
-						clippedTrianglesItems = clippedTriangles;
-						clippedTrianglesItems.length = s + 3;
-						clippedTrianglesItems[s] = index;
-						clippedTrianglesItems[s + 1] = (index + 1);
-						clippedTrianglesItems[s + 2] = (index + 2);
-						index += 3;
-						continue outer;
-					}
-				}
-			}
-		}
-
-		/** Clips the input triangle against the convex, clockwise clipping area. If the triangle lies entirely within the clipping
-		 * area, false is returned. The clipping area must duplicate the first vertex at the end of the vertices list. */
-		public function clip (x1: Number, y1: Number, x2: Number, y2: Number, x3: Number, y3: Number, clippingArea: Vector.<Number>, output: Vector.<Number>) : Boolean {
-			var originalOutput : Vector.<Number> = output;
-			var clipped : Boolean = false;
-
-			// Avoid copy at the end.
-			var input: Vector.<Number> = null;
-			if (clippingArea.length % 4 >= 2) {
-				input = output;
-				output = this.scratch;
-			} else
-				input = this.scratch;
-
-			input.length = 0;
-			input.push(x1);
-			input.push(y1);
-			input.push(x2);
-			input.push(y2);
-			input.push(x3);
-			input.push(y3);
-			input.push(x1);
-			input.push(y1);
-			output.length = 0;
-
-			var clippingVertices : Vector.<Number> = clippingArea;
-			var clippingVerticesLast : int = clippingArea.length - 4;
-			var c0 : Number, c2 : Number, s : Number, ua : Number;
-			var i : int, n : int;
-			for (i = 0;; i += 2) {
-				var edgeX : Number = clippingVertices[i], edgeY : Number = clippingVertices[i + 1];
-				var edgeX2 : Number = clippingVertices[i + 2], edgeY2 : Number = clippingVertices[i + 3];
-				var deltaX : Number = edgeX - edgeX2, deltaY : Number = edgeY - edgeY2;
-
-				var inputVertices : Vector.<Number> = input;
-				var inputVerticesLength : int = input.length - 2, outputStart : int = output.length;
-				for (var ii : int = 0; ii < inputVerticesLength; ii += 2) {
-					var inputX : Number = inputVertices[ii], inputY : Number = inputVertices[ii + 1];
-					var inputX2 : Number = inputVertices[ii + 2], inputY2 : Number = inputVertices[ii + 3];
-					var side2 : Boolean = deltaX * (inputY2 - edgeY2) - deltaY * (inputX2 - edgeX2) > 0;
-					if (deltaX * (inputY - edgeY2) - deltaY * (inputX - edgeX2) > 0) {
-						if (side2) { // v1 inside, v2 inside
-							output.push(inputX2);
-							output.push(inputY2);
-							continue;
-						}
-						// v1 inside, v2 outside
-						c0 = inputY2 - inputY; c2 = inputX2 - inputX;
-						s = c0 * (edgeX2 - edgeX) - c2 * (edgeY2 - edgeY);
-						if (Math.abs(s) > 0.000001) {
-							ua = (c2 * (edgeY - inputY) - c0 * (edgeX - inputX)) / s;
-							output.push(edgeX + (edgeX2 - edgeX) * ua);
-							output.push(edgeY + (edgeY2 - edgeY) * ua);
-						} else {
-							output.push(edgeX);
-							output.push(edgeY);
-						}
-					} else if (side2) { // v1 outside, v2 inside
-						c0 = inputY2 - inputY, c2 = inputX2 - inputX;
-						s = c0 * (edgeX2 - edgeX) - c2 * (edgeY2 - edgeY);
-						if (Math.abs(s) > 0.000001) {
-							ua = (c2 * (edgeY - inputY) - c0 * (edgeX - inputX)) / s;
-							output.push(edgeX + (edgeX2 - edgeX) * ua);
-							output.push(edgeY + (edgeY2 - edgeY) * ua);
-						} else {
-							output.push(edgeX);
-							output.push(edgeY);
-						}
-						output.push(inputX2);
-						output.push(inputY2);
-					}
-					clipped = true;
-				}
-
-				if (outputStart == output.length) { // All edges outside.
-					originalOutput.length = 0;
-					return true;
-				}
-
-				output.push(output[0]);
-				output.push(output[1]);
-
-				if (i == clippingVerticesLast) break;
-				var temp : Vector.<Number> = output;
-				output = input;
-				output.length = 0;
-				input = temp;
-			}
-
-			if (originalOutput != output) {
-				originalOutput.length = 0;
-				for (i = 0, n = output.length - 2; i < n; i++)
-					originalOutput[i] = output[i];
-			} else
-				originalOutput.length = originalOutput.length - 2;
-
-			return clipped;
-		}
-
-		public static function makeClockwise (polygon: Vector.<Number>) : void {
-			var vertices : Vector.<Number> = polygon;
-			var verticeslength : int = polygon.length;
-
-			var area : Number = vertices[verticeslength - 2] * vertices[1] - vertices[0] * vertices[verticeslength - 1];
-			var p1x : Number = 0, p1y : Number = 0, p2x : Number = 0, p2y : Number = 0;
-			var i : int, n : int;
-			for (i = 0, n = verticeslength - 3; i < n; i += 2) {
-				p1x = vertices[i];
-				p1y = vertices[i + 1];
-				p2x = vertices[i + 2];
-				p2y = vertices[i + 3];
-				area += p1x * p2y - p2x * p1y;
-			}
-			if (area < 0) return;
-
-			var lastX : int;
-			for (i = 0, lastX = verticeslength - 2, n = verticeslength >> 1; i < n; i += 2) {
-				var x : Number = vertices[i], y : Number = vertices[i + 1];
-				var other : int = lastX - i;
-				vertices[i] = vertices[other];
-				vertices[i + 1] = vertices[other + 1];
-				vertices[other] = x;
-				vertices[other + 1] = y;
-			}
-		}
-	}
-}

spine-as3/spine-as3/src/spine/SkeletonData.as

@@ -1,156 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine {
-	import spine.animation.Animation;
-
-	public class SkeletonData {
-		/** May be null. */
-		public var name : String;
-		public var bones : Vector.<BoneData> = new Vector.<BoneData>(); // Ordered parents first.
-		public var slots : Vector.<SlotData> = new Vector.<SlotData>(); // Setup pose draw order.
-		public var skins : Vector.<Skin> = new Vector.<Skin>();
-		public var defaultSkin : Skin;
-		public var events : Vector.<EventData> = new Vector.<EventData>();
-		public var animations : Vector.<Animation> = new Vector.<Animation>();
-		public var ikConstraints : Vector.<IkConstraintData> = new Vector.<IkConstraintData>();
-		public var transformConstraints : Vector.<TransformConstraintData> = new Vector.<TransformConstraintData>();
-		public var pathConstraints : Vector.<PathConstraintData> = new Vector.<PathConstraintData>();
-		public var x : Number, y : Number, width : Number, height : Number;
-		public var version : String, hash : String;
-		public var fps : Number;
-		public var imagesPath : String;
-		public var audioPath : String;
-
-		public function SkeletonData() {
-		}
-
-		// --- Bones.
-		/** @return May be null. */
-		public function findBone(boneName : String) : BoneData {
-			if (boneName == null) throw new ArgumentError("boneName cannot be null.");
-			for (var i : int = 0, n : int = bones.length; i < n; i++) {
-				var bone : BoneData = bones[i];
-				if (bone._name == boneName) return bone;
-			}
-			return null;
-		}
-
-		// --- Slots.
-		/** @return May be null. */
-		public function findSlot(slotName : String) : SlotData {
-			if (slotName == null) throw new ArgumentError("slotName cannot be null.");
-			for (var i : int = 0, n : int = slots.length; i < n; i++) {
-				var slot : SlotData = slots[i];
-				if (slot._name == slotName) return slot;
-			}
-			return null;
-		}
-
-		// --- Skins.
-		/** @return May be null. */
-		public function findSkin(skinName : String) : Skin {
-			if (skinName == null) throw new ArgumentError("skinName cannot be null.");
-			for each (var skin : Skin in skins)
-				if (skin._name == skinName) return skin;
-			return null;
-		}
-
-		// --- Events.
-		/** @return May be null. */
-		public function findEvent(eventName : String) : EventData {
-			if (eventName == null) throw new ArgumentError("eventName cannot be null.");
-			for each (var eventData : EventData in events)
-				if (eventData._name == eventName) return eventData;
-			return null;
-		}
-
-		// --- Animations.
-		/** @return May be null. */
-		public function findAnimation(animationName : String) : Animation {
-			if (animationName == null) throw new ArgumentError("animationName cannot be null.");
-			for each (var animation : Animation in animations)
-				if (animation.name == animationName) return animation;
-			return null;
-		}
-
-		// --- IK constraints.
-		/** @return May be null. */
-		public function findIkConstraint(constraintName : String) : IkConstraintData {
-			if (constraintName == null) throw new ArgumentError("constraintName cannot be null.");
-			for each (var ikConstraintData : IkConstraintData in ikConstraints)
-				if (ikConstraintData.name == constraintName) return ikConstraintData;
-			return null;
-		}
-
-		// --- Transform constraints.
-		/** @return May be null. */
-		public function findTransformConstraint(constraintName : String) : TransformConstraintData {
-			if (constraintName == null) throw new ArgumentError("constraintName cannot be null.");
-			for each (var transformConstraintData : TransformConstraintData in transformConstraints)
-				if (transformConstraintData.name == constraintName) return transformConstraintData;
-			return null;
-		}
-
-		/** @return -1 if the transform constraint was not found. */
-		public function findTransformConstraintIndex(transformConstraintName : String) : int {
-			if (transformConstraintName == null) throw new ArgumentError("transformConstraintName cannot be null.");
-			var transformConstraints : Vector.<TransformConstraintData> = this.transformConstraints;
-			for (var i : int = 0, n : int = transformConstraints.length; i < n; i++)
-				if (transformConstraints[i].name == transformConstraintName) return i;
-			return -1;
-		}
-
-		// --- Path constraints.
-		/** @return May be null. */
-		public function findPathConstraint(constraintName : String) : PathConstraintData {
-			if (constraintName == null) throw new ArgumentError("constraintName cannot be null.");
-			var pathConstraints : Vector.<PathConstraintData> = this.pathConstraints;
-			for (var i : int = 0, n : int = pathConstraints.length; i < n; i++) {
-				var constraint : PathConstraintData = pathConstraints[i];
-				if (constraint.name == constraintName) return constraint;
-			}
-			return null;
-		}
-
-		/** @return -1 if the path constraint was not found. */
-		public function findPathConstraintIndex(pathConstraintName : String) : int {
-			if (pathConstraintName == null) throw new ArgumentError("pathConstraintName cannot be null.");
-			var pathConstraints : Vector.<PathConstraintData> = this.pathConstraints;
-			for (var i : int = 0, n : int = pathConstraints.length; i < n; i++)
-				if (pathConstraints[i].name == pathConstraintName) return i;
-			return -1;
-		}
-
-		// ---
-		public function toString() : String {
-			return name == null ? "null" : name;
-		}
-	}
-}

spine-as3/spine-as3/src/spine/SkeletonJson.as

@@ -1,1032 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine {
-	import spine.animation.*;
-	import spine.attachments.*;
-	import flash.utils.ByteArray;
-
-	public class SkeletonJson {
-		public var attachmentLoader : AttachmentLoader;
-		public var scale : Number = 1;
-		private var linkedMeshes : Vector.<LinkedMesh> = new Vector.<LinkedMesh>();
-
-		public function SkeletonJson(attachmentLoader : AttachmentLoader = null) {
-			this.attachmentLoader = attachmentLoader;
-		}
-
-		/** @param object A String or ByteArray. */
-		public function readSkeletonData(object : *, name : String = null) : SkeletonData {
-			if (object == null) throw new ArgumentError("object cannot be null.");
-
-			var root : Object;
-			if (object is String)
-				root = JSON.parse(String(object));
-			else if (object is ByteArray)
-				root = JSON.parse(ByteArray(object).readUTFBytes(ByteArray(object).length));
-			else if (object is Object)
-				root = object;
-			else
-				throw new ArgumentError("object must be a String, ByteArray or Object.");
-
-			var skeletonData : SkeletonData = new SkeletonData();
-			skeletonData.name = name;
-
-			// Skeleton.
-			var skeletonMap : Object = root["skeleton"];
-			if (skeletonMap) {
-				skeletonData.hash = skeletonMap["hash"];
-				skeletonData.version = skeletonMap["spine"];
-				skeletonData.x = skeletonMap["x"] || 0;
-				skeletonData.y = skeletonMap["y"] || 0;
-				skeletonData.width = skeletonMap["width"] || 0;
-				skeletonData.height = skeletonMap["height"] || 0;
-				skeletonData.fps = skeletonMap["fps"] || 0;
-				skeletonData.imagesPath = skeletonMap["images"];
-			}
-
-			// Bones.
-			var boneData : BoneData;
-			for each (var boneMap : Object in root["bones"]) {
-				var parent : BoneData = null;
-				var parentName : String = boneMap["parent"];
-				if (parentName) {
-					parent = skeletonData.findBone(parentName);
-					if (!parent) throw new Error("Parent bone not found: " + parentName);
-				}
-				boneData = new BoneData(skeletonData.bones.length, boneMap["name"], parent);
-				boneData.length = Number(boneMap["length"] || 0) * scale;
-				boneData.x = Number(boneMap["x"] || 0) * scale;
-				boneData.y = Number(boneMap["y"] || 0) * scale;
-				boneData.rotation = (boneMap["rotation"] || 0);
-				boneData.scaleX = getNumber(boneMap, "scaleX", 1);
-				boneData.scaleY = getNumber(boneMap, "scaleY", 1);
-				boneData.shearX = Number(boneMap["shearX"] || 0);
-				boneData.shearY = Number(boneMap["shearY"] || 0);
-				boneData.transformMode = TransformMode[boneMap["transform"] || "normal"];
-				boneData.skinRequired = getValue(boneMap, "skin", false);
-
-				color = boneMap["color"];
-				if (color) boneData.color.setFromString(color);
-
-				skeletonData.bones.push(boneData);
-			}
-
-			// Slots.
-			for each (var slotMap : Object in root["slots"]) {
-				var slotName : String = slotMap["name"];
-				var boneName : String = slotMap["bone"];
-				boneData = skeletonData.findBone(boneName);
-				if (!boneData) throw new Error("Slot bone not found: " + boneName);
-				var slotData : SlotData = new SlotData(skeletonData.slots.length, slotName, boneData);
-
-				var color : String = slotMap["color"];
-				if (color) slotData.color.setFromString(color);
-
-				var dark : String = slotMap["dark"];
-				if (dark) slotData.darkColor = Color.fromString(dark);
-
-				slotData.attachmentName = slotMap["attachment"];
-				slotData.blendMode = BlendMode[slotMap["blend"] || "normal"];
-				skeletonData.slots.push(slotData);
-			}
-
-			// IK constraints.
-			for each (var constraintMap : Object in root["ik"]) {
-				var ikData : IkConstraintData = new IkConstraintData(constraintMap["name"]);
-				ikData.order = constraintMap["order"] || 0;
-				ikData.skinRequired = getValue(constraintMap, "skin", false);
-
-				for each (boneName in constraintMap["bones"]) {
-					var bone : BoneData = skeletonData.findBone(boneName);
-					if (!bone) throw new Error("IK constraint bone not found: " + boneName);
-					ikData.bones.push(bone);
-				}
-
-				ikData.target = skeletonData.findBone(constraintMap["target"]);
-				if (!ikData.target) throw new Error("Target bone not found: " + constraintMap["target"]);
-
-				ikData.bendDirection = (!constraintMap.hasOwnProperty("bendPositive") || constraintMap["bendPositive"]) ? 1 : -1;
-				ikData.compress = getValue(constraintMap, "compress", false);
-				ikData.stretch = getValue(constraintMap, "stretch", false);
-				ikData.uniform = getValue(constraintMap, "uniform", false);
-				ikData.softness = getNumber(constraintMap, "softness", 0) * scale;
-				ikData.mix = getNumber(constraintMap, "mix", 1);
-
-				skeletonData.ikConstraints.push(ikData);
-			}
-
-			// Transform constraints.
-			for each (constraintMap in root["transform"]) {
-				var transformData : TransformConstraintData = new TransformConstraintData(constraintMap["name"]);
-				transformData.order = constraintMap["order"] || 0;
-				transformData.skinRequired = getValue(constraintMap, "skin", false);
-
-				for each (boneName in constraintMap["bones"]) {
-					bone = skeletonData.findBone(boneName);
-					if (!bone) throw new Error("Transform constraint bone not found: " + boneName);
-					transformData.bones.push(bone);
-				}
-
-				transformData.target = skeletonData.findBone(constraintMap["target"]);
-				if (!transformData.target) throw new Error("Target bone not found: " + constraintMap["target"]);
-
-				transformData.local = getValue(constraintMap, "local", false);
-				transformData.relative = getValue(constraintMap, "relative", false);
-
-				transformData.offsetRotation = Number(constraintMap["rotation"] || 0);
-				transformData.offsetX = Number(constraintMap["x"] || 0) * scale;
-				transformData.offsetY = Number(constraintMap["y"] || 0) * scale;
-				transformData.offsetScaleX = Number(constraintMap["scaleX"] || 0);
-				transformData.offsetScaleY = Number(constraintMap["scaleY"] || 0);
-				transformData.offsetShearY = Number(constraintMap["shearY"] || 0);
-
-				transformData.mixRotate = getNumber(constraintMap, "mixRotate", 1);
-				transformData.mixX = getNumber(constraintMap, "mixX", 1);
-				transformData.mixY = getNumber(constraintMap, "mixY", transformData.mixX);
-				transformData.mixScaleX = getNumber(constraintMap, "mixScaleX", 1);
-				transformData.mixScaleY = getNumber(constraintMap, "mixScaleY", transformData.mixScaleX);
-				transformData.mixShearY = getNumber(constraintMap, "mixShearY", 1);
-
-				skeletonData.transformConstraints.push(transformData);
-			}
-
-			// Path constraints.
-			for each (constraintMap in root["path"]) {
-				var pathData : PathConstraintData = new PathConstraintData(constraintMap["name"]);
-				pathData.order = constraintMap["order"] || 0;
-				pathData.skinRequired = getValue(constraintMap, "skin", false);
-
-				for each (boneName in constraintMap["bones"]) {
-					bone = skeletonData.findBone(boneName);
-					if (!bone) throw new Error("Path constraint bone not found: " + boneName);
-					pathData.bones.push(bone);
-				}
-
-				pathData.target = skeletonData.findSlot(constraintMap["target"]);
-				if (!pathData.target) throw new Error("Path target slot not found: " + constraintMap["target"]);
-
-				pathData.positionMode = PositionMode[constraintMap["positionMode"] || "percent"];
-				pathData.spacingMode = SpacingMode[constraintMap["spacingMode"] || "length"];
-				pathData.rotateMode = RotateMode[constraintMap["rotateMode"] || "tangent"];
-				pathData.offsetRotation = Number(constraintMap["rotation"] || 0);
-				pathData.position = Number(constraintMap["position"] || 0);
-				if (pathData.positionMode == PositionMode.fixed) pathData.position *= scale;
-				pathData.spacing = Number(constraintMap["spacing"] || 0);
-				if (pathData.spacingMode == SpacingMode.length || pathData.spacingMode == SpacingMode.fixed) pathData.spacing *= scale;
-				pathData.mixRotate = getNumber(constraintMap, "mixRotate", 1);
-				pathData.mixX = getNumber(constraintMap, "mixX", 1);
-				pathData.mixY = getNumber(constraintMap, "mixY", pathData.mixX);
-
-				skeletonData.pathConstraints.push(pathData);
-			}
-
-			// Skins.
-			var skins : Object = root["skins"];
-			for (var i : int = 0; i < skins.length; i++) {
-				var ii : int;
-				var skinMap : Object = skins[i];
-				var skin : Skin = new Skin(skinMap["name"]);
-
-				if (skinMap["bones"]) {
-					for (ii = 0; ii < skinMap["bones"].length; ii++) {
-						boneData = skeletonData.findBone(skinMap["bones"][ii]);
-						if (boneData == null) throw new Error("Skin bone not found: " + skinMap["bones"][ii]);
-						skin.bones.push(boneData);
-					}
-				}
-
-				var constraint : ConstraintData;
-				if (skinMap["ik"]) {
-					for (ii = 0; ii < skinMap["ik"].length; ii++) {
-						constraint = skeletonData.findIkConstraint(skinMap["ik"][ii]);
-						if (constraint == null) throw new Error("Skin IK constraint not found: " + skinMap["ik"][ii]);
-						skin.constraints.push(constraint);
-					}
-				}
-
-				if (skinMap["transform"]) {
-					for (ii = 0; ii < skinMap["transform"].length; ii++) {
-						constraint = skeletonData.findTransformConstraint(skinMap["transform"][ii]);
-						if (constraint == null) throw new Error("Skin transform constraint not found: " + skinMap["transform"][ii]);
-						skin.constraints.push(constraint);
-					}
-				}
-
-				if (skinMap["path"]) {
-					for (ii = 0; ii < skinMap["path"].length; ii++) {
-						constraint = skeletonData.findPathConstraint(skinMap["path"][ii]);
-						if (constraint == null) throw new Error("Skin path constraint not found: " + skinMap["path"][ii]);
-						skin.constraints.push(constraint);
-					}
-				}
-
-				for (slotName in skinMap.attachments) {
-					var slot : SlotData = skeletonData.findSlot(slotName);
-					var slotEntry : Object = skinMap.attachments[slotName];
-					for (var attachmentName : String in slotEntry) {
-						var attachment : Attachment = readAttachment(slotEntry[attachmentName], skin, slot.index, attachmentName, skeletonData);
-						if (attachment != null)
-							skin.setAttachment(slot.index, attachmentName, attachment);
-					}
-				}
-				skeletonData.skins.push(skin);
-				if (skin.name == "default") skeletonData.defaultSkin = skin;
-			}
-
-			// Linked meshes.
-			var linkedMeshes : Vector.<LinkedMesh> = this.linkedMeshes;
-			for each (var linkedMesh : LinkedMesh in linkedMeshes) {
-				var parentSkin : Skin = !linkedMesh.skin ? skeletonData.defaultSkin : skeletonData.findSkin(linkedMesh.skin);
-				if (!parentSkin) throw new Error("Skin not found: " + linkedMesh.skin);
-				var parentMesh : Attachment = parentSkin.getAttachment(linkedMesh.slotIndex, linkedMesh.parent);
-				if (!parentMesh) throw new Error("Parent mesh not found: " + linkedMesh.parent);
-				linkedMesh.mesh.deformAttachment = linkedMesh.inheritDeform ? VertexAttachment(parentMesh) : linkedMesh.mesh;
-				linkedMesh.mesh.parentMesh = MeshAttachment(parentMesh);
-				linkedMesh.mesh.updateUVs();
-			}
-			linkedMeshes.length = 0;
-
-			// Events.
-			var events : Object = root["events"];
-			if (events) {
-				for (var eventName : String in events) {
-					var eventMap : Object = events[eventName];
-					var eventData : EventData = new EventData(eventName);
-					eventData.intValue = eventMap["int"] || 0;
-					eventData.floatValue = eventMap["float"] || 0;
-					eventData.stringValue = eventMap["string"] || "";
-					eventData.audioPath = eventMap["audio"] || null;
-					if (eventData.audioPath != null) {
-						eventData.volume = eventMap["volume"] || 1;
-						eventData.balance = eventMap["balance"] || 0;
-					}
-					skeletonData.events.push(eventData);
-				}
-			}
-
-			// Animations.
-			var animations : Object = root["animations"];
-			for (var animationName : String in animations)
-				readAnimation(animations[animationName], animationName, skeletonData);
-
-			return skeletonData;
-		}
-
-		private function readAttachment(map : Object, skin : Skin, slotIndex : int, name : String, skeletonData: SkeletonData) : Attachment {
-			name = map["name"] || name;
-
-			var scale : Number = this.scale;
-			var color : String;
-			switch (AttachmentType[getValue(map, "type", "region")]) {
-			case AttachmentType.region:
-				var region : RegionAttachment = attachmentLoader.newRegionAttachment(skin, name, map["path"] || name);
-				if (!region) return null;
-				region.path = map["path"] || name;
-				region.x = Number(map["x"] || 0) * scale;
-				region.y = Number(map["y"] || 0) * scale;
-				region.scaleX = getNumber(map, "scaleX", 1);
-				region.scaleY = getNumber(map, "scaleY", 1);
-				region.rotation = map["rotation"] || 0;
-				region.width = Number(map["width"] || 0) * scale;
-				region.height = Number(map["height"] || 0) * scale;
-
-				color = map["color"];
-				if (color) region.color.setFromString(color);
-
-				region.updateOffset();
-				return region;
-			case AttachmentType.mesh:
-			case AttachmentType.linkedmesh:
-				var mesh : MeshAttachment = attachmentLoader.newMeshAttachment(skin, name, map["path"] || name);
-				if (!mesh) return null;
-				mesh.path = map["path"] || name;
-
-				color = map["color"];
-				if (color) mesh.color.setFromString(color);
-
-				mesh.width = Number(map["width"] || 0) * scale;
-				mesh.height = Number(map["height"] || 0) * scale;
-				if (map["parent"]) {
-					var inheritDeform : Boolean = getValue(map, "deform", true);
-					linkedMeshes.push(new LinkedMesh(mesh, map["skin"], slotIndex, map["parent"], inheritDeform));
-					return mesh;
-				}
-				var uvs : Vector.<Number> = getFloatArray(map, "uvs", 1);
-				readVertices(map, mesh, uvs.length);
-				mesh.triangles = getUintArray(map, "triangles");
-				mesh.regionUVs = uvs;
-				mesh.updateUVs();
-				mesh.hullLength = int(map["hull"] || 0) * 2;
-				if (map["edges"]) mesh.edges = getIntArray(map, "edges");
-				return mesh;
-			case AttachmentType.boundingbox:
-				var box : BoundingBoxAttachment = attachmentLoader.newBoundingBoxAttachment(skin, name);
-				if (!box) return null;
-				readVertices(map, box, int(map["vertexCount"]) << 1);
-				return box;
-			case AttachmentType.path:
-				var path : PathAttachment = attachmentLoader.newPathAttachment(skin, name);
-				if (!path) return null;
-				path.closed = getValue(map, "closed", false);
-				path.constantSpeed = getValue(map, "constantSpeed", true);
-				var vertexCount : int = int(map["vertexCount"]);
-				readVertices(map, path, vertexCount << 1);
-				var lengths : Vector.<Number> = new Vector.<Number>();
-				for each (var curves : Object in map["lengths"]) {
-					lengths.push(Number(curves) * scale);
-				}
-				path.lengths = lengths;
-				return path;
-			case AttachmentType.point:
-				var point : PointAttachment = attachmentLoader.newPointAttachment(skin, name);
-				if (!point) return null;
-				point.x = getNumber(map, "x", 0) * scale;
-				point.y = getNumber(map, "y", 0) * scale;
-				point.rotation = getNumber(map, "rotation", 0);
-
-				color = map["color"];
-				if (color) point.color.setFromString(color);
-
-				return point;
-			case AttachmentType.clipping:
-				var clip : ClippingAttachment = attachmentLoader.newClippingAttachment(skin, name);
-				if (!clip) return null;
-				var end : String = map["end"];
-				if (end != null) {
-					var slot : SlotData = skeletonData.findSlot(end);
-					if (slot == null) throw new Error("Clipping end slot not found: " + end);
-					clip.endSlot = slot;
-				}
-
-				vertexCount = int(map["vertexCount"]);
-				readVertices(map, clip, vertexCount << 1);
-
-				color = map["color"];
-				if (color) clip.color.setFromString(color);
-
-				return clip;
-			}
-			return null;
-		}
-
-		private function readVertices(map : Object, attachment : VertexAttachment, verticesLength : int) : void {
-			attachment.worldVerticesLength = verticesLength;
-			var vertices : Vector.<Number> = getFloatArray(map, "vertices", 1);
-			if (verticesLength == vertices.length) {
-				if (scale != 1) {
-					for (var i : int = 0, n : int = vertices.length; i < n; i++) {
-						vertices[i] *= scale;
-					}
-				}
-				attachment.vertices = vertices;
-				return;
-			}
-
-			var weights : Vector.<Number> = new Vector.<Number>(verticesLength * 3 * 3);
-			weights.length = 0;
-			var bones : Vector.<int> = new Vector.<int>(verticesLength * 3);
-			bones.length = 0;
-			for (i = 0, n = vertices.length; i < n;) {
-				var boneCount : int = int(vertices[i++]);
-				bones.push(boneCount);
-				for (var nn : int = i + boneCount * 4; i < nn; i += 4) {
-					bones.push(int(vertices[i]));
-					weights.push(vertices[i + 1] * scale);
-					weights.push(vertices[i + 2] * scale);
-					weights.push(vertices[i + 3]);
-				}
-			}
-			attachment.bones = bones;
-			attachment.vertices = weights;
-		}
-
-		private function readAnimation(map : Object, name : String, skeletonData : SkeletonData) : void {
-			var scale : Number = this.scale;
-			var timelines : Vector.<Timeline> = new Vector.<Timeline>();
-
-			var slotMap : Object, slotIndex : int, slotName : String;
-			var timelineMap : Array, keyMap : Object, nextMap : Object;
-			var frame : int, bezier : int;
-			var time : Number, time2 : Number;
-			var curve : Object;
-			var timelineName : String;
-			var i : int, n : int, frames : int;
-
-			// Slot timelines.
-			var slots : Object = map["slots"];
-			for (slotName in slots) {
-				slotMap = slots[slotName];
-				slotIndex = skeletonData.findSlot(slotName).index;
-
-				for (timelineName in slotMap) {
-					timelineMap = slotMap[timelineName];
-					if (!timelineMap) continue;
-
-					frames = timelineMap.length;
-					if (timelineName == "attachment") {
-						var attachmentTimeline : AttachmentTimeline = new AttachmentTimeline(frames, slotIndex);
-						for (frame = 0; frame < frames; frame++) {
-							keyMap = timelineMap[frame];
-							attachmentTimeline.setFrame(frame, getNumber(keyMap, "time", 0), keyMap.name);
-						}
-						timelines.push(attachmentTimeline);
-
-					} else if (timelineName == "rgba") {
-						var rgbaTimeline : RGBATimeline = new RGBATimeline(frames, frames << 2, slotIndex);
-						keyMap = timelineMap[0];
-						time = getNumber(keyMap, "time", 0);
-						var rgba : Color = Color.fromString(keyMap.color);
-
-						for (frame = 0, bezier = 0;; frame++) {
-							rgbaTimeline.setFrame(frame, time, rgba.r, rgba.g, rgba.b, rgba.a);
-							nextMap = timelineMap[frame + 1];
-							if (!nextMap) {
-								rgbaTimeline.shrink(bezier);
-								break;
-							}
-							time2 = getNumber(nextMap, "time", 0);
-							var newRgba : Color = Color.fromString(nextMap.color);
-							curve = keyMap.curve;
-							if (curve) {
-								bezier = readCurve(curve, rgbaTimeline, bezier, frame, 0, time, time2, rgba.r, newRgba.r, 1);
-								bezier = readCurve(curve, rgbaTimeline, bezier, frame, 1, time, time2, rgba.g, newRgba.g, 1);
-								bezier = readCurve(curve, rgbaTimeline, bezier, frame, 2, time, time2, rgba.b, newRgba.b, 1);
-								bezier = readCurve(curve, rgbaTimeline, bezier, frame, 3, time, time2, rgba.a, newRgba.a, 1);
-							}
-							time = time2;
-							rgba = newRgba;
-							keyMap = nextMap;
-						}
-						timelines.push(rgbaTimeline);
-
-					} else if (timelineName == "rgb") {
-						var rgbTimeline : RGBTimeline = new RGBTimeline(frames, frames * 3, slotIndex);
-						keyMap = timelineMap[0];
-						time = getNumber(keyMap, "time", 0);
-						var rgb : Color = Color.fromString(keyMap.color);
-
-						for (frame = 0, bezier = 0;; frame++) {
-							rgbTimeline.setFrame(frame, time, rgb.r, rgb.g, rgb.b);
-							nextMap = timelineMap[frame + 1];
-							if (!nextMap) {
-								rgbTimeline.shrink(bezier);
-								break;
-							}
-							time2 = getNumber(nextMap, "time", 0);
-							var newRgb : Color = Color.fromString(nextMap.color);
-							curve = keyMap.curve;
-							if (curve) {
-								bezier = readCurve(curve, rgbTimeline, bezier, frame, 0, time, time2, rgb.r, newRgb.r, 1);
-								bezier = readCurve(curve, rgbTimeline, bezier, frame, 1, time, time2, rgb.g, newRgb.g, 1);
-								bezier = readCurve(curve, rgbTimeline, bezier, frame, 2, time, time2, rgb.b, newRgb.b, 1);
-							}
-							time = time2;
-							rgb = newRgb;
-							keyMap = nextMap;
-						}
-						timelines.push(rgbTimeline);
-
-					} else if (timelineName == "alpha") {
-						timelines.push(readTimeline(timelineMap, new AlphaTimeline(frames, frames, slotIndex), 0, 1));
-					} else if (timelineName == "rgba2") {
-						var rgba2Timeline : RGBA2Timeline = new RGBA2Timeline(frames, frames * 7, slotIndex);
-
-						keyMap = timelineMap[0];
-						time = getNumber(keyMap, "time", 0);
-						var lighta : Color = Color.fromString(keyMap.light);
-						var darka : Color = Color.fromString(keyMap.dark);
-
-						for (frame = 0, bezier = 0;; frame++) {
-							rgba2Timeline.setFrame(frame, time, lighta.r, lighta.g, lighta.b, lighta.a, darka.r, darka.g, darka.b);
-							nextMap = timelineMap[frame + 1];
-							if (!nextMap) {
-								rgba2Timeline.shrink(bezier);
-								break;
-							}
-							time2 = getNumber(nextMap, "time", 0);
-							var newLighta : Color = Color.fromString(nextMap.light);
-							var newDarka : Color = Color.fromString(nextMap.dark);
-							curve = keyMap.curve;
-							if (curve) {
-								bezier = readCurve(curve, rgba2Timeline, bezier, frame, 0, time, time2, lighta.r, newLighta.r, 1);
-								bezier = readCurve(curve, rgba2Timeline, bezier, frame, 1, time, time2, lighta.g, newLighta.g, 1);
-								bezier = readCurve(curve, rgba2Timeline, bezier, frame, 2, time, time2, lighta.b, newLighta.b, 1);
-								bezier = readCurve(curve, rgba2Timeline, bezier, frame, 3, time, time2, lighta.a, newLighta.a, 1);
-								bezier = readCurve(curve, rgba2Timeline, bezier, frame, 4, time, time2, darka.r, newDarka.r, 1);
-								bezier = readCurve(curve, rgba2Timeline, bezier, frame, 5, time, time2, darka.g, newDarka.g, 1);
-								bezier = readCurve(curve, rgba2Timeline, bezier, frame, 6, time, time2, darka.b, newDarka.b, 1);
-							}
-							time = time2;
-							lighta = newLighta;
-							darka = newDarka;
-							keyMap = nextMap;
-						}
-						timelines.push(rgba2Timeline);
-
-					} else if (timelineName == "rgb2") {
-						var rgb2Timeline : RGB2Timeline = new RGB2Timeline(frames, frames * 6, slotIndex);
-
-						keyMap = timelineMap[0];
-						time = getNumber(keyMap, "time", 0);
-						var light : Color = Color.fromString(keyMap.light);
-						var dark : Color = Color.fromString(keyMap.dark);
-
-						for (frame = 0, bezier = 0;; frame++) {
-							rgb2Timeline.setFrame(frame, time, light.r, light.g, light.b, dark.r, dark.g, dark.b);
-							nextMap = timelineMap[frame + 1];
-							if (!nextMap) {
-								rgb2Timeline.shrink(bezier);
-								break;
-							}
-							time2 = getNumber(nextMap, "time", 0);
-							var newLight : Color = Color.fromString(nextMap.light);
-							var newDark : Color = Color.fromString(nextMap.dark);
-							curve = keyMap.curve;
-							if (curve) {
-								bezier = readCurve(curve, rgb2Timeline, bezier, frame, 0, time, time2, light.r, newLight.r, 1);
-								bezier = readCurve(curve, rgb2Timeline, bezier, frame, 1, time, time2, light.g, newLight.g, 1);
-								bezier = readCurve(curve, rgb2Timeline, bezier, frame, 2, time, time2, light.b, newLight.b, 1);
-								bezier = readCurve(curve, rgb2Timeline, bezier, frame, 3, time, time2, dark.r, newDark.r, 1);
-								bezier = readCurve(curve, rgb2Timeline, bezier, frame, 4, time, time2, dark.g, newDark.g, 1);
-								bezier = readCurve(curve, rgb2Timeline, bezier, frame, 5, time, time2, dark.b, newDark.b, 1);
-							}
-							time = time2;
-							light = newLight;
-							dark = newDark;
-							keyMap = nextMap;
-						}
-						timelines.push(rgb2Timeline);
-
-					} else
-						throw new Error("Invalid timeline type for a slot: " + timelineName + " (" + slotName + ")");
-				}
-			}
-
-			// Bone timelines.
-			var bones : Object = map["bones"];
-			for (var boneName : String in bones) {
-				var bone : BoneData = skeletonData.findBone(boneName);
-				if (!bone) throw new Error("Bone not found: " + boneName);
-				var boneIndex : int = bone.index;
-				var boneMap : Object = bones[boneName];
-
-				for (timelineName in boneMap) {
-					timelineMap = boneMap[timelineName];
-					frames = timelineMap.length;
-					if (frames == 0) continue;
-
-					if (timelineName === "rotate") {
-						timelines.push(readTimeline(timelineMap, new RotateTimeline(frames, frames, boneIndex), 0, 1));
-					} else if (timelineName === "translate") {
-						var translateTimeline : TranslateTimeline = new TranslateTimeline(frames, frames << 1, boneIndex);
-						timelines.push(readTimeline2(timelineMap, translateTimeline, "x", "y", 0, scale));
-					} else if (timelineName === "translatex") {
-						var translateXTimeline : TranslateXTimeline = new TranslateXTimeline(frames, frames, boneIndex);
-						timelines.push(readTimeline(timelineMap, translateXTimeline, 0, scale));
-					} else if (timelineName === "translatey") {
-						var translateYTimeline : TranslateYTimeline = new TranslateYTimeline(frames, frames, boneIndex);
-						timelines.push(readTimeline(timelineMap, translateYTimeline, 0, scale));
-					} else if (timelineName === "scale") {
-						var scaleTimeline : ScaleTimeline = new ScaleTimeline(frames, frames << 1, boneIndex);
-						timelines.push(readTimeline2(timelineMap, scaleTimeline, "x", "y", 1, 1));
-					} else if (timelineName === "scalex") {
-						var scaleXTimeline : ScaleXTimeline = new ScaleXTimeline(frames, frames, boneIndex);
-						timelines.push(readTimeline(timelineMap, scaleXTimeline, 1, 1));
-					} else if (timelineName === "scaley") {
-						var scaleYTimeline : ScaleYTimeline = new ScaleYTimeline(frames, frames, boneIndex);
-						timelines.push(readTimeline(timelineMap, scaleYTimeline, 1, 1));
-					} else if (timelineName === "shear") {
-						var shearTimeline : ShearTimeline = new ShearTimeline(frames, frames << 1, boneIndex);
-						timelines.push(readTimeline2(timelineMap, shearTimeline, "x", "y", 0, 1));
-					} else if (timelineName === "shearx") {
-						var shearXTimeline : ShearXTimeline = new ShearXTimeline(frames, frames, boneIndex);
-						timelines.push(readTimeline(timelineMap, shearXTimeline, 0, 1));
-					} else if (timelineName === "sheary") {
-						var shearYTimeline : ShearYTimeline = new ShearYTimeline(frames, frames, boneIndex);
-						timelines.push(readTimeline(timelineMap, shearYTimeline, 0, 1));
-					} else
-						throw new Error("Invalid timeline type for a bone: " + timelineName + " (" + boneName + ")");
-				}
-			}
-
-			// IK constraint timelines.
-			var ikMap : Object = map["ik"];
-			for (var ikConstraintName : String in ikMap) {
-				timelineMap = map.ik[ikConstraintName];
-				keyMap = timelineMap[0];
-				if (!keyMap) continue;
-
-				var ikIndex : int = skeletonData.ikConstraints.indexOf(skeletonData.findIkConstraint(ikConstraintName));
-				var ikTimeline : IkConstraintTimeline = new IkConstraintTimeline(timelineMap.length, timelineMap.length << 1, ikIndex);
-
-				time = getNumber(keyMap, "time", 0);
-				var mix : Number = getNumber(keyMap, "mix", 1);
-				var softness : Number = getNumber(keyMap, "softness", 0) * scale;
-
-				for (frame = 0, bezier = 0;; frame++) {
-					ikTimeline.setFrame(frame, time, mix, softness, getValue(keyMap, "bendPositive", true) ? 1 : -1, getValue(keyMap, "compress", false), getValue(keyMap, "stretch", false));
-					nextMap = timelineMap[frame + 1];
-					if (!nextMap) {
-						ikTimeline.shrink(bezier);
-						break;
-					}
-
-					time2 = getNumber(nextMap, "time", 0);
-					var mix2 : Number = getNumber(nextMap, "mix", 1);
-					var softness2 : Number = getNumber(nextMap, "softness", 0) * scale;
-					curve = keyMap.curve;
-					if (curve) {
-						bezier = readCurve(curve, ikTimeline, bezier, frame, 0, time, time2, mix, mix2, 1);
-						bezier = readCurve(curve, ikTimeline, bezier, frame, 1, time, time2, softness, softness2, scale);
-					}
-
-					time = time2;
-					mix = mix2;
-					softness = softness2;
-					keyMap = nextMap;
-				}
-				timelines.push(ikTimeline);
-			}
-
-			// Transform constraint timelines.
-			var mixRotate : Number, mixRotate2 : Number;
-			var mixX : Number, mixX2 : Number;
-			var mixY : Number, mixY2 : Number;
-			var transformMap : Object = map["transform"];
-			for (var transformName : String in transformMap) {
-				timelineMap = map.transform[transformName];
-				keyMap = timelineMap[0];
-				if (!keyMap) continue;
-
-				var transformIndex : int = skeletonData.transformConstraints.indexOf(skeletonData.findTransformConstraint(transformName));
-				var transformTimeline : TransformConstraintTimeline = new TransformConstraintTimeline(timelineMap.length, timelineMap.length * 6, transformIndex);
-
-				time = getNumber(keyMap, "time", 0);
-				mixRotate = getNumber(keyMap, "mixRotate", 1);
-				var mixShearY : Number = getNumber(keyMap, "mixShearY", 1);
-				mixX = getNumber(keyMap, "mixX", 1);
-				mixY = getNumber(keyMap, "mixY", mixX);
-				var mixScaleX : Number = getNumber(keyMap, "mixScaleX", 1);
-				var mixScaleY : Number = getNumber(keyMap, "mixScaleY", mixScaleX);
-
-				for (frame = 0, bezier = 0;; frame++) {
-					transformTimeline.setFrame(frame, time, mixRotate, mixX, mixY, mixScaleX, mixScaleY, mixShearY);
-					nextMap = timelineMap[frame + 1];
-					if (!nextMap) {
-						transformTimeline.shrink(bezier);
-						break;
-					}
-
-					time2 = getNumber(nextMap, "time", 0);
-					mixRotate2 = getNumber(nextMap, "mixRotate", 1);
-					var mixShearY2 : Number = getNumber(nextMap, "mixShearY", 1);
-					mixX2 = getNumber(nextMap, "mixX", 1);
-					mixY2 = getNumber(nextMap, "mixY", mixX2);
-					var mixScaleX2 : Number = getNumber(nextMap, "mixScaleX", 1);
-					var mixScaleY2 : Number = getNumber(nextMap, "mixScaleY", mixScaleX2);
-					curve = keyMap.curve;
-					if (curve) {
-						bezier = readCurve(curve, transformTimeline, bezier, frame, 0, time, time2, mixRotate, mixRotate2, 1);
-						bezier = readCurve(curve, transformTimeline, bezier, frame, 1, time, time2, mixX, mixX2, 1);
-						bezier = readCurve(curve, transformTimeline, bezier, frame, 2, time, time2, mixY, mixY2, 1);
-						bezier = readCurve(curve, transformTimeline, bezier, frame, 3, time, time2, mixScaleX, mixScaleX2, 1);
-						bezier = readCurve(curve, transformTimeline, bezier, frame, 4, time, time2, mixScaleY, mixScaleY2, 1);
-						bezier = readCurve(curve, transformTimeline, bezier, frame, 5, time, time2, mixShearY, mixShearY2, 1);
-					}
-
-					time = time2;
-					mixRotate = mixRotate2;
-					mixX = mixX2;
-					mixY = mixY2;
-					mixScaleX = mixScaleX2;
-					mixScaleY = mixScaleY2;
-					mixScaleX = mixScaleX2;
-					keyMap = nextMap;
-				}
-				timelines.push(transformTimeline);
-			}
-
-			// Path constraint timelines.
-			var paths : Object = map["path"];
-			for (var pathName : String in paths) {
-				var index : int = skeletonData.findPathConstraintIndex(pathName);
-				if (index == -1) throw new Error("Path constraint not found: " + pathName);
-				var pathData : PathConstraintData = skeletonData.pathConstraints[index];
-
-				var pathMap : Object = paths[pathName];
-				for (timelineName in pathMap) {
-					timelineMap = pathMap[timelineName];
-					keyMap = timelineMap[0];
-					if (!keyMap) continue;
-
-					frames = timelineMap.length;
-					if (timelineName === "position") {
-						var positionTimeline : PathConstraintPositionTimeline = new PathConstraintPositionTimeline(frames, frames, index);
-						timelines.push(readTimeline(timelineMap, positionTimeline, 0, pathData.positionMode == PositionMode.fixed ? scale : 1));
-					} else if (timelineName === "spacing") {
-						var spacingTimeline : PathConstraintSpacingTimeline = new PathConstraintSpacingTimeline(frames, frames, index);
-						timelines.push(readTimeline(timelineMap, spacingTimeline, 0, pathData.spacingMode == SpacingMode.length || pathData.spacingMode == SpacingMode.fixed ? scale : 1));
-					} else if (timelineName === "mix") {
-						var mixTimeline : PathConstraintMixTimeline = new PathConstraintMixTimeline(frames, frames * 3, index);
-						time = getNumber(keyMap, "time", 0);
-						mixRotate = getNumber(keyMap, "mixRotate", 1);
-						mixX = getNumber(keyMap, "mixX", 1);
-						mixY = getNumber(keyMap, "mixY", mixX);
-						for (frame = 0, bezier = 0;; frame++) {
-							mixTimeline.setFrame(frame, time, mixRotate, mixX, mixY);
-							nextMap = timelineMap[frame + 1];
-							if (!nextMap) {
-								mixTimeline.shrink(bezier);
-								break;
-							}
-							time2 = getNumber(nextMap, "time", 0);
-							mixRotate2 = getNumber(nextMap, "mixRotate", 1);
-							mixX2 = getNumber(nextMap, "mixX", 1);
-							mixY2 = getNumber(nextMap, "mixY", mixX2);
-							curve = keyMap.curve;
-							if (curve != null) {
-								bezier = readCurve(curve, mixTimeline, bezier, frame, 0, time, time2, mixRotate, mixRotate2, 1);
-								bezier = readCurve(curve, mixTimeline, bezier, frame, 1, time, time2, mixX, mixX2, 1);
-								bezier = readCurve(curve, mixTimeline, bezier, frame, 2, time, time2, mixY, mixY2, 1);
-							}
-							time = time2;
-							mixRotate = mixRotate2;
-							mixX = mixX2;
-							mixY = mixY2;
-							keyMap = nextMap;
-						}
-						timelines.push(mixTimeline);
-					}
-				}
-			}
-
-			// Deform timelines.
-			var deforms : Object = map["deform"];
-			for (var deformName : String in deforms) {
-				var deformMap : Object = deforms[deformName];
-				var skin : Skin = skeletonData.findSkin(deformName);
-				if (skin == null) throw new Error("Skin not found: " + deformName);
-				for (slotName in deformMap) {
-					slotMap = deformMap[slotName];
-					slotIndex = skeletonData.findSlot(slotName).index;
-					if (slotIndex == -1) throw new Error("Slot not found: " + slotMap.name);
-					for (timelineName in slotMap) {
-						timelineMap = slotMap[timelineName];
-						keyMap = timelineMap[0];
-						if (!keyMap) continue;
-
-						var attachment : VertexAttachment = skin.getAttachment(slotIndex, timelineName) as VertexAttachment;
-						if (attachment == null) throw new Error("Deform attachment not found: " + timelineName);
-						var weighted : Boolean = attachment.bones != null;
-						var vertices : Vector.<Number> = attachment.vertices;
-						var deformLength : int = weighted ? vertices.length / 3 * 2 : vertices.length;
-
-						var deformTimeline : DeformTimeline = new DeformTimeline(timelineMap.length, timelineMap.length, slotIndex, attachment);
-						time = getNumber(keyMap, "time", 0);
-						for (frame = 0, bezier = 0;; frame++) {
-							var deform : Vector.<Number>;
-							var verticesValue : Object = keyMap["vertices"];
-							if (verticesValue == null)
-								deform = weighted ? new Vector.<Number>(deformLength, true) : vertices;
-							else {
-								deform = new Vector.<Number>(deformLength, true);
-								var start : int = Number(keyMap["offset"] || 0);
-								var temp : Vector.<Number> = getFloatArray(keyMap, "vertices", 1);
-								for (i = 0; i < temp.length; i++)
-									deform[start + i] = temp[i];
-								if (scale != 1) {
-									for (i = start, n = i + temp.length; i < n; i++)
-										deform[i] *= scale;
-								}
-								if (!weighted) {
-									for (i = 0; i < deformLength; i++)
-										deform[i] += vertices[i];
-								}
-							}
-
-							deformTimeline.setFrame(frame, time, deform);
-							nextMap = timelineMap[frame + 1];
-							if (!nextMap) {
-								deformTimeline.shrink(bezier);
-								break;
-							}
-							time2 = getNumber(nextMap, "time", 0);
-							curve = keyMap.curve;
-							if (curve) bezier = readCurve(curve, deformTimeline, bezier, frame, 0, time, time2, 0, 1, 1);
-							time = time2;
-							keyMap = nextMap;
-						}
-						timelines.push(deformTimeline);
-					}
-				}
-			}
-
-			// Draw order timelines.
-			var drawOrders : Array = map["drawOrder"];
-			if (drawOrders) {
-				var drawOrderTimeline : DrawOrderTimeline = new DrawOrderTimeline(drawOrders.length);
-				var slotCount : int = skeletonData.slots.length;
-				frame = 0;
-				for each (var drawOrderMap : Object in drawOrders) {
-					var drawOrder : Vector.<int> = null;
-					var offsets : Array = drawOrderMap["offsets"];
-					if (offsets) {
-						drawOrder = new Vector.<int>(slotCount, true);
-						for (i = slotCount - 1; i >= 0; i--)
-							drawOrder[i] = -1;
-						var unchanged : Vector.<int> = new Vector.<int>(slotCount - offsets.length, true);
-						var originalIndex : int = 0, unchangedIndex : int = 0;
-						for each (var offsetMap : Object in offsets) {
-							slotIndex = skeletonData.findSlot(offsetMap["slot"]).index;
-							if (slotIndex == -1) throw new Error("Slot not found: " + offsetMap["slot"]);
-							// Collect unchanged items.
-							while (originalIndex != slotIndex)
-								unchanged[unchangedIndex++] = originalIndex++;
-							// Set changed items.
-							drawOrder[originalIndex + offsetMap["offset"]] = originalIndex++;
-						}
-						// Collect remaining unchanged items.
-						while (originalIndex < slotCount)
-							unchanged[unchangedIndex++] = originalIndex++;
-						// Fill in unchanged items.
-						for (i = slotCount - 1; i >= 0; i--)
-							if (drawOrder[i] == -1) drawOrder[i] = unchanged[--unchangedIndex];
-					}
-					drawOrderTimeline.setFrame(frame++, Number(drawOrderMap["time"] || 0), drawOrder);
-				}
-				timelines.push(drawOrderTimeline);
-			}
-
-			// Event timelines.
-			var eventsMap : Array = map["events"];
-			if (eventsMap) {
-				var eventTimeline : EventTimeline = new EventTimeline(eventsMap.length);
-				frame = 0;
-				for each (var eventMap : Object in eventsMap) {
-					var eventData : EventData = skeletonData.findEvent(eventMap["name"]);
-					if (!eventData) throw new Error("Event not found: " + eventMap["name"]);
-					var event : Event = new Event(Number(eventMap["time"] || 0), eventData);
-					event.intValue = getNumber(eventMap, "int", eventData.intValue);
-					event.floatValue = getNumber(eventMap, "float", eventData.floatValue);
-					event.stringValue = String(getValue(eventMap, "string", eventData.stringValue));
-					if (eventData.audioPath != null) {
-						event.volume = getNumber(eventMap, "volume", 1);
-						event.balance = getNumber(eventMap, "balance", 0);
-					}
-					eventTimeline.setFrame(frame++, event);
-				}
-				timelines.push(eventTimeline);
-			}
-
-			var duration : Number = 0;
-			for (i = 0, n = timelines.length; i < n; i++)
-				duration = Math.max(duration, timelines[i].getDuration());
-
-			skeletonData.animations.push(new Animation(name, timelines, duration));
-		}
-
-		static private function readTimeline(keys : Array, timeline : CurveTimeline1, defaultValue : Number, scale : Number) : CurveTimeline1 {
-			var keyMap : Object = keys[0];
-			var time : Number = getNumber(keyMap, "time", 0);
-			var value : Number = getNumber(keyMap, "value", defaultValue) * scale;
-			for (var frame : int = 0, bezier : int = 0;; frame++) {
-				timeline.setFrame(frame, time, value);
-				var nextMap : Object = keys[frame + 1];
-				if (!nextMap) {
-					timeline.shrink(bezier);
-					return timeline;
-				}
-				var time2 : Number = getNumber(nextMap, "time", 0);
-				var value2 : Number = getNumber(nextMap, "value", defaultValue) * scale;
-				if (keyMap.curve) bezier = readCurve(keyMap.curve, timeline, bezier, frame, 0, time, time2, value, value2, scale);
-				time = time2;
-				value = value2;
-				keyMap = nextMap;
-			}
-		}
-
-		static private function readTimeline2(keys : Array, timeline : CurveTimeline2, name1 : String, name2 : String, defaultValue : Number, scale : Number) : CurveTimeline2 {
-			var keyMap : Object = keys[0];
-			var time : Number = getNumber(keyMap, "time", 0);
-			var value1 : Number = getNumber(keyMap, name1, defaultValue) * scale;
-			var value2 : Number = getNumber(keyMap, name2, defaultValue) * scale;
-			for (var frame : int = 0, bezier : int = 0;; frame++) {
-				timeline.setFrame(frame, time, value1, value2);
-				var nextMap : Object = keys[frame + 1];
-				if (!nextMap) {
-					timeline.shrink(bezier);
-					return timeline;
-				}
-				var time2 : Number = getNumber(nextMap, "time", 0);
-				var nvalue1 : Number = getNumber(nextMap, name1, defaultValue) * scale;
-				var nvalue2 : Number = getNumber(nextMap, name2, defaultValue) * scale;
-				var curve : Object = keyMap.curve;
-				if (curve != null) {
-					bezier = readCurve(curve, timeline, bezier, frame, 0, time, time2, value1, nvalue1, scale);
-					bezier = readCurve(curve, timeline, bezier, frame, 1, time, time2, value2, nvalue2, scale);
-				}
-				time = time2;
-				value1 = nvalue1;
-				value2 = nvalue2;
-				keyMap = nextMap;
-			}
-		}
-
-		static private function readCurve(curve : Object, timeline : CurveTimeline, bezier : int, frame : int, value : Number, time1 : Number, time2 : Number,
-			value1 : Number, value2 : Number, scale : Number) : int {
-			if (curve == "stepped") {
-				timeline.setStepped(frame);
-				return bezier;
-			}
-			var i : int = value << 2;
-			var cx1 : Number = curve[i];
-			var cy1 : Number = curve[i + 1] * scale;
-			var cx2 : Number = curve[i + 2];
-			var cy2 : Number = curve[i + 3] * scale;
-			timeline.setBezier(bezier, frame, value, time1, value1, cx1, cy1, cx2, cy2, time2, value2);
-			return bezier + 1;
-		}
-
-		static private function getValue(map : Object, property : String, defaultValue : Object) : Object {
-			return map.hasOwnProperty(property) ? map[property] : defaultValue;
-		}
-
-		static private function getNumber(map : Object, property : String, defaultValue : Number) : Number {
-			return map.hasOwnProperty(property) ? Number(map[property]) : defaultValue;
-		}
-
-		static private function getFloatArray(map : Object, name : String, scale : Number) : Vector.<Number> {
-			var list : Array = map[name];
-			var values : Vector.<Number> = new Vector.<Number>(list.length, true);
-			var i : int = 0, n : int = list.length;
-			if (scale == 1) {
-				for (; i < n; i++)
-					values[i] = list[i];
-			} else {
-				for (; i < n; i++)
-					values[i] = list[i] * scale;
-			}
-			return values;
-		}
-
-		static private function getIntArray(map : Object, name : String) : Vector.<int> {
-			var list : Array = map[name];
-			var values : Vector.<int> = new Vector.<int>(list.length, true);
-			for (var i : int = 0, n : int = list.length; i < n; i++)
-				values[i] = int(list[i]);
-			return values;
-		}
-
-		static private function getUintArray(map : Object, name : String) : Vector.<uint> {
-			var list : Array = map[name];
-			var values : Vector.<uint> = new Vector.<uint>(list.length, true);
-			for (var i : int = 0, n : int = list.length; i < n; i++)
-				values[i] = int(list[i]);
-			return values;
-		}
-	}
-}
-
-import spine.attachments.MeshAttachment;
-
-class LinkedMesh {
-	internal var parent : String, skin : String;
-	internal var slotIndex : int;
-	internal var mesh : MeshAttachment;
-	internal var inheritDeform : Boolean;
-
-	public function LinkedMesh(mesh : MeshAttachment, skin : String, slotIndex : int, parent : String, inheritDeform : Boolean) {
-		this.mesh = mesh;
-		this.skin = skin;
-		this.slotIndex = slotIndex;
-		this.parent = parent;
-		this.inheritDeform = inheritDeform;
-	}
-}

spine-as3/spine-as3/src/spine/Skin.as

@@ -1,216 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine {
-	import spine.attachments.MeshAttachment;
-	import flash.utils.Dictionary;
-
-	import spine.attachments.Attachment;
-
-	/** Stores attachments by slot index and attachment name. */
-	public class Skin {
-		internal var _name : String;
-		private var _attachments : Vector.<Dictionary> = new Vector.<Dictionary>();
-		private var _bones: Vector.<BoneData> = new Vector.<BoneData>();
-		private var _constraints: Vector.<ConstraintData> = new Vector.<ConstraintData>();
-
-		public function Skin(name : String) {
-			if (name == null) throw new ArgumentError("name cannot be null.");
-			_name = name;
-		}
-
-		public function setAttachment(slotIndex : int, name : String, attachment : Attachment) : void {
-			if (attachment == null) throw new ArgumentError("attachment cannot be null.");
-			if (slotIndex >= _attachments.length) _attachments.length = slotIndex + 1;
-			if (!_attachments[slotIndex]) _attachments[slotIndex] = new Dictionary();
-			_attachments[slotIndex][name] = attachment;
-		}
-		
-		public function addSkin (skin: Skin) : void {
-			var i : int = 0, j : int = 0;
-			var contained : Boolean = false;
-			
-			for(i = 0; i < skin._bones.length; i++) {
-				var bone : BoneData = skin._bones[i];
-				contained = false;
-				for (j = 0; j < _bones.length; j++) {
-					if (_bones[j] == bone) {
-						contained = true;
-						break;
-					}
-				}
-				if (!contained) _bones.push(bone);
-			}
-
-			for(i = 0; i < skin._constraints.length; i++) {
-				var constraint : ConstraintData = skin._constraints[i];
-				contained = false;
-				for (j = 0; j < this._constraints.length; j++) {
-					if (_constraints[j] == constraint) {
-						contained = true;
-						break;
-					}
-				}
-				if (!contained) _constraints.push(constraint);
-			}
-
-			var attachments : Vector.<SkinEntry> = skin.getAttachments();
-			for (i = 0; i < attachments.length; i++) {
-				var attachment : SkinEntry = attachments[i];
-				setAttachment(attachment.slotIndex, attachment.name, attachment.attachment);
-			}
-		}
-		
-		public function copySkin (skin: Skin) : void {
-			var i : int = 0, j : int = 0;
-			var contained : Boolean = false;
-			var attachment : SkinEntry;
-			
-			for(i = 0; i < skin._bones.length; i++) {
-				var bone : BoneData = skin._bones[i];
-				contained = false;
-				for (j = 0; j < _bones.length; j++) {
-					if (_bones[j] == bone) {
-						contained = true;
-						break;
-					}
-				}
-				if (!contained) _bones.push(bone);
-			}
-
-			for(i = 0; i < skin._constraints.length; i++) {
-				var constraint : ConstraintData = skin._constraints[i];
-				contained = false;
-				for (j = 0; j < this._constraints.length; j++) {
-					if (_constraints[j] == constraint) {
-						contained = true;
-						break;
-					}
-				}
-				if (!contained) _constraints.push(constraint);
-			}
-
-			var attachments : Vector.<SkinEntry> = skin.getAttachments();
-			for (i = 0; i < attachments.length; i++) {
-				attachment = attachments[i];
-				if (attachment.attachment == null) continue;
-				if (attachment.attachment is MeshAttachment) {
-					attachment.attachment = MeshAttachment(attachment.attachment).newLinkedMesh();
-					setAttachment(attachment.slotIndex, attachment.name, attachment.attachment);
-				} else {
-					attachment.attachment = attachment.attachment.copy();
-					setAttachment(attachment.slotIndex, attachment.name, attachment.attachment);
-				}
-			}
-		}
-				
-		public function getAttachment(slotIndex : int, name : String) : Attachment {
-			if (slotIndex >= _attachments.length) return null;
-			var dictionary : Dictionary = _attachments[slotIndex];
-			return dictionary ? dictionary[name] : null;
-		}
-		
-		public function removeAttachment(slotIndex : int, name : String) : void {
-			var dictionary : Dictionary = _attachments[slotIndex];
-			if (dictionary) dictionary[name] = null;
-		}
-		
-		public function getAttachments() : Vector.<SkinEntry> {
-			var entries : Vector.<SkinEntry> = new Vector.<SkinEntry>();
-			for (var slotIndex : int = 0; slotIndex < _attachments.length; slotIndex++) {
-				var attachments : Dictionary = _attachments[slotIndex];
-				if (attachments) {
-					for (var name : String in attachments) {
-						var attachment : Attachment = attachments[name];
-						if (attachment) entries.push(new SkinEntry(slotIndex, name, attachment));
-					}
-				}
-			}
-			return entries;
-		}
-		
-		public function getAttachmentsForSlot(slotIndex: int) : Vector.<SkinEntry> {
-			var entries : Vector.<SkinEntry> = new Vector.<SkinEntry>();			
-			var attachments : Dictionary = _attachments[slotIndex];
-			if (attachments) {
-				for (var name : String in attachments) {
-					var attachment : Attachment = attachments[name];
-					if (attachment) entries.push(new SkinEntry(slotIndex, name, attachment));
-				}
-			}			
-			return entries;
-		}
-		
-		public function clear () : void {
-			_attachments.length = 0;
-			_bones.length = 0;
-			_constraints.length = 0;
-		}
-		
-		public function get attachments() : Vector.<Dictionary> {
-			return _attachments;
-		}
-		
-		public function get bones() : Vector.<BoneData> {
-			return _bones;
-		}
-		
-		public function get constraints() : Vector.<ConstraintData> {
-			return _constraints;
-		}
-
-		public function get name() : String {
-			return _name;
-		}
-
-		public function toString() : String {
-			return _name;
-		}
-
-		/** Attach each attachment in this skin if the corresponding attachment in the old skin is currently attached. */
-		public function attachAll(skeleton : Skeleton, oldSkin : Skin) : void {
-			var slotIndex : int = 0;
-			for each (var slot : Slot in skeleton.slots) {
-				var slotAttachment : Attachment = slot.attachment;
-				if (slotAttachment && slotIndex < oldSkin._attachments.length) {
-					var dictionary : Dictionary = oldSkin._attachments[slotIndex];
-					for (var name : String in dictionary) {
-						var skinAttachment : Attachment = dictionary[name];
-						if (slotAttachment == skinAttachment) {
-							var attachment : Attachment = getAttachment(slotIndex, name);
-							if (attachment != null) slot.attachment = attachment;
-							break;
-						}
-					}
-				}
-				slotIndex++;
-			}
-		}
-	}	
-}

spine-as3/spine-as3/src/spine/SkinEntry.as

@@ -1,44 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine {
-	import spine.attachments.Attachment;
-	
-	public class SkinEntry {
-		public var slotIndex : int;
-		public var name : String;
-		public var attachment : Attachment;
-		
-		public function SkinEntry(slotIndex : int, name: String, attachment: Attachment) {
-			this.slotIndex = slotIndex;
-			this.name = name;
-			this.attachment = attachment;
-		}
-	}
-}

spine-as3/spine-as3/src/spine/Slot.as

@@ -1,109 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine {
-	import spine.attachments.Attachment;
-	import spine.attachments.VertexAttachment;
-
-	public class Slot {
-		internal var _data : SlotData;
-		internal var _bone : Bone;
-		public var color : Color;
-		public var darkColor : Color;
-		internal var _attachment : Attachment;
-		private var _attachmentTime : Number;
-		public var attachmentState : int;
-		public var deform : Vector.<Number> = new Vector.<Number>();
-
-		public function Slot(data : SlotData, bone : Bone) {
-			if (data == null) throw new ArgumentError("data cannot be null.");
-			if (bone == null) throw new ArgumentError("bone cannot be null.");
-			_data = data;
-			_bone = bone;
-			this.color = new Color(1, 1, 1, 1);
-			this.darkColor = data.darkColor == null ? null : new Color(1, 1, 1, 1);
-			setToSetupPose();
-		}
-
-		public function get data() : SlotData {
-			return _data;
-		}
-
-		public function get bone() : Bone {
-			return _bone;
-		}
-
-		public function get skeleton() : Skeleton {
-			return _bone._skeleton;
-		}
-
-		/** @return May be null. */
-		public function get attachment() : Attachment {
-			return _attachment;
-		}
-
-		/** Sets the slot's attachment and, if the attachment changed, resets {@link #attachmentTime} and clears the {@link #deform}.
-		 * The deform is not cleared if the old attachment has the same {@link VertexAttachment#getDeformAttachment()} as the specified
-		 * attachment.
-		 * @param attachment May be null. */
-		public function set attachment(attachment : Attachment) : void {
-			if (_attachment == attachment) return;
-			if (!(attachment is VertexAttachment) || !(this.attachment is VertexAttachment)
-			|| VertexAttachment(attachment).deformAttachment != VertexAttachment(this.attachment).deformAttachment) {
-				deform.length = 0;
-			}
-			_attachment = attachment;
-			_attachmentTime = _bone._skeleton.time;
-		}
-
-		public function set attachmentTime(time : Number) : void {
-			_attachmentTime = _bone._skeleton.time - time;
-		}
-
-		/** Returns the time since the attachment was set. */
-		public function get attachmentTime() : Number {
-			return _bone._skeleton.time - _attachmentTime;
-		}
-
-		public function setToSetupPose() : void {
-			color.setFromColor(data.color);
-			if (darkColor != null) darkColor.setFromColor(this.data.darkColor);
-			if (_data.attachmentName == null)
-				attachment = null;
-			else {
-				_attachment = null;
-				attachment = _bone._skeleton.getAttachmentForSlotIndex(data.index, data.attachmentName);
-			}
-		}
-
-		public function toString() : String {
-			return _data.name;
-		}
-	}
-}

spine-as3/spine-as3/src/spine/SlotData.as

@@ -1,65 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine {
-	public class SlotData {
-		internal var _index : int;
-		internal var _name : String;
-		internal var _boneData : BoneData;
-		public var color : Color = new Color(1, 1, 1, 1);
-		public var darkColor : Color;
-		public var attachmentName : String;
-		public var blendMode : BlendMode;
-
-		public function SlotData(index : int, name : String, boneData : BoneData) {
-			if (index < 0) throw new ArgumentError("index must be >= 0.");
-			if (name == null) throw new ArgumentError("name cannot be null.");
-			if (boneData == null) throw new ArgumentError("boneData cannot be null.");
-			_index = index;
-			_name = name;
-			_boneData = boneData;
-		}
-
-		public function get index() : int {
-			return _index;
-		}
-
-		public function get name() : String {
-			return _name;
-		}
-
-		public function get boneData() : BoneData {
-			return _boneData;
-		}
-
-		public function toString() : String {
-			return _name;
-		}
-	}
-}

spine-as3/spine-as3/src/spine/SpacingMode.as

@@ -1,39 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine {
-	public class SpacingMode {
-		public static const length : SpacingMode = new SpacingMode();
-		public static const fixed : SpacingMode = new SpacingMode();
-		public static const percent : SpacingMode = new SpacingMode();
-		public static const proportional : SpacingMode = new SpacingMode();
-
-		public static const values : Array = [ length, fixed, percent, proportional ];
-	}
-}

spine-as3/spine-as3/src/spine/TransformConstraint.as

@@ -1,286 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine {
-	public class TransformConstraint implements Updatable {
-		internal var _data : TransformConstraintData;
-		internal var _bones : Vector.<Bone>;
-		public var target : Bone;
-		public var mixRotate : Number;
-		public var mixX : Number, mixY : Number;
-		public var mixScaleX : Number, mixScaleY : Number;
-		public var mixShearY : Number;
-		internal var _temp : Vector.<Number> = new Vector.<Number>(2, true);
-		public var active : Boolean;
-
-		public function TransformConstraint(data : TransformConstraintData, skeleton : Skeleton) {
-			if (data == null) throw new ArgumentError("data cannot be null.");
-			if (skeleton == null) throw new ArgumentError("skeleton cannot be null.");
-			_data = data;
-			mixRotate = data.mixRotate;
-			mixX = data.mixX;
-			mixY = data.mixY;
-			mixScaleX = data.mixScaleX;
-			mixScaleY = data.mixScaleY;
-			mixShearY = data.mixShearY;
-			_bones = new Vector.<Bone>();
-			for each (var boneData : BoneData in data.bones)
-				_bones.push(skeleton.findBone(boneData.name));
-			target = skeleton.findBone(data.target._name);
-		}
-		
-		public function isActive() : Boolean {
-			return active;
-		}
-
-		public function update() : void {
-			if (mixRotate == 0 && mixX == 0 && mixY == 0 && mixScaleX == 0 && mixScaleX == 0 && mixShearY == 0) return;
-
-			if (_data.local) {
-				if (_data.relative)
-					applyRelativeLocal();
-				else
-					applyAbsoluteLocal();
-			} else {
-				if (_data.relative)
-					applyRelativeWorld();
-				else
-					applyAbsoluteWorld();
-			}
-		}
-
-		internal function applyAbsoluteWorld() : void {
-			var mixRotate : Number = this.mixRotate, mixX : Number = this.mixX, mixY : Number = this.mixY;
-			var mixScaleX : Number = this.mixScaleX, mixScaleY : Number = this.mixScaleY, mixShearY : Number = this.mixShearY;
-			var translate : Boolean = mixX != 0 || mixY != 0;
-
-			var target : Bone = this.target;
-			var ta : Number = target.a, tb : Number = target.b, tc : Number = target.c, td : Number = target.d;
-			var degRadReflect : Number = ta * td - tb * tc > 0 ? MathUtils.degRad : -MathUtils.degRad;
-			var offsetRotation : Number = _data.offsetRotation * degRadReflect;
-			var offsetShearY : Number = _data.offsetShearY * degRadReflect;
-
-			var bones : Vector.<Bone> = _bones;
-			for (var i : int = 0, n : int = bones.length; i < n; i++) {
-				var bone : Bone = bones[i];
-
-				if (mixRotate != 0) {
-					var a : Number = bone.a, b : Number = bone.b, c : Number = bone.c, d : Number = bone.d;
-					var r : Number = Math.atan2(tc, ta) - Math.atan2(c, a) + offsetRotation;
-					if (r > Math.PI)
-						r -= Math.PI * 2;
-					else if (r < -Math.PI) //
-						r += Math.PI * 2;
-					r *= mixRotate;
-					var cos : Number = Math.cos(r), sin : Number = Math.sin(r);
-					bone.a = cos * a - sin * c;
-					bone.b = cos * b - sin * d;
-					bone.c = sin * a + cos * c;
-					bone.d = sin * b + cos * d;
-				}
-
-				if (translate) {
-					_temp[0] = _data.offsetX;
-					_temp[1] = _data.offsetY;
-					target.localToWorld(_temp);
-					bone.worldX += (_temp[0] - bone.worldX) * mixX;
-					bone.worldY += (_temp[1] - bone.worldY) * mixY;
-				}
-
-				var s : Number;
-				if (mixScaleX != 0) {
-					s = Math.sqrt(bone.a * bone.a + bone.c * bone.c);
-					if (s != 0) s = (s + (Math.sqrt(ta * ta + tc * tc) - s + _data.offsetScaleX) * mixScaleX) / s;
-					bone.a *= s;
-					bone.c *= s;
-				}
-				if (mixScaleY != 0) {
-					s = Math.sqrt(bone.b * bone.b + bone.d * bone.d);
-					if (s != 0) s = (s + (Math.sqrt(tb * tb + td * td) - s + _data.offsetScaleY) * mixScaleY) / s;
-					bone.b *= s;
-					bone.d *= s;
-				}
-
-				if (mixShearY > 0) {
-					var by : Number = Math.atan2(bone.d, bone.b);
-					r = Math.atan2(td, tb) - Math.atan2(tc, ta) - (by - Math.atan2(bone.c, bone.a));
-					if (r > Math.PI)
-						r -= Math.PI * 2;
-					else if (r < -Math.PI) //
-						r += Math.PI * 2;
-					r = by + (r + offsetShearY) * mixShearY;
-					s = Math.sqrt(bone.b * bone.b + bone.d * bone.d);
-					bone.b = Math.cos(r) * s;
-					bone.d = Math.sin(r) * s;
-				}
-
-				bone.updateAppliedTransform();
-			}
-		}
-
-		public function applyRelativeWorld() : void {
-			var mixRotate : Number = this.mixRotate, mixX : Number = this.mixX, mixY : Number = this.mixY;
-			var mixScaleX : Number = this.mixScaleX, mixScaleY : Number = this.mixScaleY, mixShearY : Number = this.mixShearY;
-			var translate : Boolean = mixX != 0 || mixY != 0;
-
-			var target : Bone = this.target;
-			var ta : Number = target.a, tb : Number = target.b, tc : Number = target.c, td : Number = target.d;
-			var degRadReflect : Number = ta * td - tb * tc > 0 ? MathUtils.degRad : -MathUtils.degRad;
-			var offsetRotation : Number = _data.offsetRotation * degRadReflect, offsetShearY : Number = _data.offsetShearY * degRadReflect;
-
-			var bones : Vector.<Bone> = _bones;
-			for (var i : int = 0, n : int = bones.length; i < n; i++) {
-				var bone : Bone = bones[i];
-
-				if (mixRotate != 0) {
-					var a : Number = bone.a, b : Number = bone.b, c : Number = bone.c, d : Number = bone.d;
-					var r : Number = Math.atan2(tc, ta) + offsetRotation;
-					if (r > MathUtils.PI)
-						r -= MathUtils.PI2;
-					else if (r < -MathUtils.PI) //
-						r += MathUtils.PI2;
-					r *= mixRotate;
-					var cos : Number = Math.cos(r), sin : Number = Math.sin(r);
-					bone.a = cos * a - sin * c;
-					bone.b = cos * b - sin * d;
-					bone.c = sin * a + cos * c;
-					bone.d = sin * b + cos * d;
-				}
-
-				if (translate) {
-					var temp : Vector.<Number> = _temp;
-					temp[0] = _data.offsetX;
-					temp[1] = _data.offsetY;
-					target.localToWorld(temp);
-					bone.worldX += temp[0] * mixX;
-					bone.worldY += temp[1] * mixY;
-				}
-
-				var s : Number;
-				if (mixScaleX != 0) {
-					s = (Math.sqrt(ta * ta + tc * tc) - 1 + _data.offsetScaleX) * mixScaleX + 1;
-					bone.a *= s;
-					bone.c *= s;
-				}
-				if (mixScaleY != 0) {
-					s = (Math.sqrt(tb * tb + td * td) - 1 + _data.offsetScaleY) * mixScaleY + 1;
-					bone.b *= s;
-					bone.d *= s;
-				}
-
-				if (mixShearY > 0) {
-					r = Math.atan2(td, tb) - Math.atan2(tc, ta);
-					if (r > MathUtils.PI)
-						r -= MathUtils.PI2;
-					else if (r < -MathUtils.PI) //
-						r += MathUtils.PI2;
-					b = bone.b;
-					d = bone.d;
-					r = Math.atan2(d, b) + (r - MathUtils.PI / 2 + offsetShearY) * mixShearY;
-					s = Math.sqrt(b * b + d * d);
-					bone.b = Math.cos(r) * s;
-					bone.d = Math.sin(r) * s;
-				}
-
-				bone.updateAppliedTransform();
-			}
-		}
-
-		public function applyAbsoluteLocal() : void {
-			var mixRotate : Number = this.mixRotate, mixX : Number = this.mixX, mixY : Number = this.mixY;
-			var mixScaleX : Number = this.mixScaleX, mixScaleY : Number = this.mixScaleY, mixShearY : Number = this.mixShearY;
-
-			var target : Bone = this.target;
-
-			var bones : Vector.<Bone> = _bones;
-			for (var i : int = 0, n : int = bones.length; i < n; i++) {
-				var bone : Bone = bones[i];
-
-				var rotation : Number = bone.arotation;
-				if (mixRotate != 0) {
-					var r : Number = target.arotation - rotation + _data.offsetRotation;
-					r -= (16384 - ((16384.499999999996 - r / 360) | 0)) * 360;
-					rotation += r * mixRotate;
-				}
-
-				var x : Number = bone.ax, y : Number = bone.ay;
-				x += (target.ax - x + _data.offsetX) * mixX;
-				y += (target.ay - y + _data.offsetY) * mixY;
-
-				var scaleX : Number = bone.ascaleX, scaleY : Number = bone.ascaleY;
-				if (mixScaleX != 0 && scaleX != 0)
-					scaleX = (scaleX + (target.ascaleX - scaleX + _data.offsetScaleX) * mixScaleX) / scaleX;
-				if (mixScaleY != 0 && scaleY != 0)
-					scaleY = (scaleY + (target.ascaleY - scaleY + _data.offsetScaleY) * mixScaleY) / scaleY;
-
-				var shearY : Number = bone.ashearY;
-				if (mixShearY != 0) {
-					r = target.ashearY - shearY + _data.offsetShearY;
-					r -= (16384 - ((16384.499999999996 - r / 360) | 0)) * 360;
-					bone.shearY += r * mixShearY;
-				}
-
-				bone.updateWorldTransformWith(x, y, rotation, scaleX, scaleY, bone.ashearX, shearY);
-			}
-		}
-
-		public function applyRelativeLocal() : void {
-			var mixRotate : Number = this.mixRotate, mixX : Number = this.mixX, mixY : Number = this.mixY;
-			var mixScaleX : Number = this.mixScaleX, mixScaleY : Number = this.mixScaleY, mixShearY : Number = this.mixShearY;
-
-			var target : Bone = this.target;
-
-			var bones : Vector.<Bone> = _bones;
-			for (var i : int = 0, n : int = bones.length; i < n; i++) {
-				var bone : Bone = bones[i];
-
-				var rotation : Number = bone.arotation + (target.arotation + _data.offsetRotation) * mixRotate;
-				var x : Number = bone.ax + (target.ax + _data.offsetX) * mixX;
-				var y : Number = bone.ay + (target.ay + _data.offsetY) * mixY;
-				var scaleX : Number = bone.ascaleX * (((target.ascaleX - 1 + _data.offsetScaleX) * mixScaleX) + 1);
-				var scaleY : Number = bone.ascaleY * (((target.ascaleY - 1 + _data.offsetScaleY) * mixScaleY) + 1);
-				var shearY : Number = bone.ashearY + (target.ashearY + _data.offsetShearY) * mixShearY;
-
-				bone.updateWorldTransformWith(x, y, rotation, scaleX, scaleY, bone.ashearX, shearY);
-			}
-		}
-
-		public function get data() : TransformConstraintData {
-			return _data;
-		}
-
-		public function get bones() : Vector.<Bone> {
-			return _bones;
-		}
-
-		public function toString() : String {
-			return _data.name;
-		}
-	}
-}

spine-as3/spine-as3/src/spine/TransformConstraintData.as

@@ -1,56 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine {
-	public class TransformConstraintData extends ConstraintData {			
-		internal var _bones : Vector.<BoneData> = new Vector.<BoneData>();
-		public var target : BoneData;
-
-		public var mixRotate : Number;
-		public var mixX : Number, mixY : Number;
-		public var mixScaleX : Number, mixScaleY : Number;
-		public var mixShearY : Number;
-
-		public var offsetRotation : Number;
-		public var offsetX : Number, offsetY : Number;
-		public var offsetScaleX : Number, offsetScaleY : Number;
-		public var offsetShearY : Number;
-
-		public var relative : Boolean = false;
-		public var local : Boolean = false;
-
-		public function TransformConstraintData(name : String) {
-			super(name, 0, false);
-		}
-
-		public function get bones() : Vector.<BoneData> {			
-			return _bones;
-		}		
-	}
-}

spine-as3/spine-as3/src/spine/TransformMode.as

@@ -1,40 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine {
-	public class TransformMode {
-		public static const normal : TransformMode = new TransformMode();
-		public static const onlyTranslation : TransformMode = new TransformMode();
-		public static const noRotationOrReflection : TransformMode = new TransformMode();
-		public static const noScale : TransformMode = new TransformMode();
-		public static const noScaleOrReflection : TransformMode = new TransformMode();
-		
-		public static const values : Array = [ normal, onlyTranslation, noRotationOrReflection, noScale, noScaleOrReflection ];
-	}
-}

spine-as3/spine-as3/src/spine/Triangulator.as

@@ -1,281 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine {
-	public class Triangulator {
-		private var convexPolygons : Vector.<Vector.<Number>> = new Vector.<Vector.<Number>>();
-		private var convexPolygonsIndices : Vector.<Vector.<int>> = new Vector.<Vector.<int>>();
-		private var indicesArray : Vector.<int> = new Vector.<int>();
-		private var isConcaveArray : Vector.<Boolean> = new Vector.<Boolean>();
-		private var triangles : Vector.<int> = new Vector.<int>();
-		private var polygonPool : Pool = new Pool(function() : Vector.<Number> {
-			return new Vector.<Number>();
-		});
-		private var polygonIndicesPool : Pool = new Pool(function() : Vector.<int> {
-			return new Vector.<int>();
-		});
-		
-		public function Triangulator () {			
-		}
-		
-		public function triangulate(verticesArray : Vector.<Number>) : Vector.<int> {
-			var vertices : Vector.<Number> = verticesArray;
-			var vertexCount : int = verticesArray.length >> 1;
-			var i : int, n : int;
-
-			var indices : Vector.<int> = this.indicesArray;
-			indices.length = 0;
-			for (i = 0; i < vertexCount; i++)
-				indices[i] = i;
-
-			var isConcaveArray : Vector.<Boolean> = this.isConcaveArray;
-			isConcaveArray.length = 0;
-			for (i = 0, n = vertexCount; i < n; ++i)
-				isConcaveArray[i] = isConcave(i, vertexCount, vertices, indices);
-
-			var triangles : Vector.<int> = this.triangles;
-			triangles.length = 0;
-
-			while (vertexCount > 3) {
-				// Find ear tip.
-				var previous : int = vertexCount - 1, next : int = 1;
-				i = 0;
-				while (true) {
-					outer:
-					if (!isConcaveArray[i]) {
-						var p1 : int = indices[previous] << 1, p2 : int = indices[i] << 1, p3 : int = indices[next] << 1;
-						var p1x : Number = vertices[p1], p1y : Number = vertices[p1 + 1];
-						var p2x : Number = vertices[p2], p2y : Number = vertices[p2 + 1];
-						var p3x : Number = vertices[p3], p3y : Number = vertices[p3 + 1];
-						for (var ii : int = (next + 1) % vertexCount; ii != previous; ii = (ii + 1) % vertexCount) {
-							if (!isConcaveArray[ii]) continue;
-							var v : int = indices[ii] << 1;
-							var vx : int = vertices[v], vy : int = vertices[v + 1];
-							if (positiveArea(p3x, p3y, p1x, p1y, vx, vy)) {
-								if (positiveArea(p1x, p1y, p2x, p2y, vx, vy)) {
-									if (positiveArea(p2x, p2y, p3x, p3y, vx, vy)) break outer;
-								}
-							}
-						}
-						break;
-					}
-
-					if (next == 0) {
-						do {
-							if (!isConcaveArray[i]) break;
-							i--;
-						} while (i > 0);
-						break;
-					}
-
-					previous = i;
-					i = next;
-					next = (next + 1) % vertexCount;
-				}
-
-				// Cut ear tip.
-				triangles.push(indices[(vertexCount + i - 1) % vertexCount]);
-				triangles.push(indices[i]);
-				triangles.push(indices[(i + 1) % vertexCount]);
-				indices.splice(i, 1);
-				isConcaveArray.splice(i, 1);
-				vertexCount--;
-
-				var previousIndex : int = (vertexCount + i - 1) % vertexCount;
-				var nextIndex : int = i == vertexCount ? 0 : i;
-				isConcaveArray[previousIndex] = isConcave(previousIndex, vertexCount, vertices, indices);
-				isConcaveArray[nextIndex] = isConcave(nextIndex, vertexCount, vertices, indices);
-			}
-
-			if (vertexCount == 3) {
-				triangles.push(indices[2]);
-				triangles.push(indices[0]);
-				triangles.push(indices[1]);
-			}
-			
-			return triangles;
-		}
-
-		public function decompose(verticesArray : Vector.<Number>, triangles : Vector.<int>) : Vector.<Vector.<Number>> {
-			var vertices : Vector.<Number> = verticesArray;
-			var convexPolygons : Vector.<Vector.<Number>> = this.convexPolygons;
-			var i : int, n : int;
-			for (i = 0, n = convexPolygons.length; i < n; i++) {
-				this.polygonPool.free(convexPolygons[i]);
-			}
-			convexPolygons.length = 0;
-
-			var convexPolygonsIndices : Vector.<Vector.<int>> = this.convexPolygonsIndices;
-			for (i = 0, n = convexPolygonsIndices.length; i < n; i++) {
-				this.polygonIndicesPool.free(convexPolygonsIndices[i]);
-			}
-			convexPolygonsIndices.length = 0;
-
-			var polygonIndices : Vector.<int> = Vector.<int>(this.polygonIndicesPool.obtain());
-			polygonIndices.length = 0;
-
-			var polygon : Vector.<Number> = Vector.<Number>(this.polygonPool.obtain());
-			polygon.length = 0;
-
-			// Merge subsequent triangles if they form a triangle fan.
-			var fanBaseIndex : int = -1, lastWinding : int = 0;
-			var x1 : Number, y1 : Number, x2 : Number, y2 : Number, x3 : Number, y3 : Number;
-			var winding1 : int, winding2 : int, o : int;
-			for (i = 0, n = triangles.length; i < n; i += 3) {
-				var t1 : int = triangles[i] << 1, t2 : int = triangles[i + 1] << 1, t3 : int = triangles[i + 2] << 1;
-				x1 = vertices[t1];
-				y1 = vertices[t1 + 1];
-				x2 = vertices[t2];
-				y2 = vertices[t2 + 1];
-				x3 = vertices[t3];
-				y3 = vertices[t3 + 1];
-
-				// If the base of the last triangle is the same as this triangle, check if they form a convex polygon (triangle fan).
-				var merged : Boolean = false;
-				if (fanBaseIndex == t1) {
-					o = polygon.length - 4;
-					winding1 = Triangulator.winding(polygon[o], polygon[o + 1], polygon[o + 2], polygon[o + 3], x3, y3);
-					winding2 = Triangulator.winding(x3, y3, polygon[0], polygon[1], polygon[2], polygon[3]);
-					if (winding1 == lastWinding && winding2 == lastWinding) {
-						polygon.push(x3);
-						polygon.push(y3);
-						polygonIndices.push(t3);
-						merged = true;
-					}
-				}
-
-				// Otherwise make this triangle the new base.
-				if (!merged) {
-					if (polygon.length > 0) {
-						convexPolygons.push(polygon);
-						convexPolygonsIndices.push(polygonIndices);
-					} else {
-						polygonPool.free(polygon);
-						polygonIndicesPool.free(polygonIndices);
-					}
-					polygon = Vector.<Number>(this.polygonPool.obtain());
-					polygon.length = 0;
-					polygon.push(x1);
-					polygon.push(y1);
-					polygon.push(x2);
-					polygon.push(y2);
-					polygon.push(x3);
-					polygon.push(y3);
-					polygonIndices = Vector.<int>(this.polygonIndicesPool.obtain());
-					polygonIndices.length = 0;
-					polygonIndices.push(t1);
-					polygonIndices.push(t2);
-					polygonIndices.push(t3);
-					lastWinding = Triangulator.winding(x1, y1, x2, y2, x3, y3);
-					fanBaseIndex = t1;
-				}
-			}
-
-			if (polygon.length > 0) {
-				convexPolygons.push(polygon);
-				convexPolygonsIndices.push(polygonIndices);
-			}
-
-			// Go through the list of polygons and try to merge the remaining triangles with the found triangle fans.
-			for (i = 0, n = convexPolygons.length; i < n; i++) {
-				polygonIndices = convexPolygonsIndices[i];
-				if (polygonIndices.length == 0) continue;
-				var firstIndex : int = polygonIndices[0];
-				var lastIndex : int = polygonIndices[polygonIndices.length - 1];
-
-				polygon = convexPolygons[i];
-				o = polygon.length - 4;
-				var prevPrevX : Number = polygon[o], prevPrevY : Number = polygon[o + 1];
-				var prevX : Number = polygon[o + 2], prevY : Number = polygon[o + 3];
-				var firstX : Number = polygon[0], firstY : Number = polygon[1];
-				var secondX : Number = polygon[2], secondY : Number = polygon[3];
-				var currWinding : int = Triangulator.winding(prevPrevX, prevPrevY, prevX, prevY, firstX, firstY);
-
-				for (var ii : int = 0; ii < n; ii++) {
-					if (ii == i) continue;
-					var otherIndices : Vector.<int>= convexPolygonsIndices[ii];
-					if (otherIndices.length != 3) continue;
-					var otherFirstIndex : int = otherIndices[0];
-					var otherSecondIndex : int = otherIndices[1];
-					var otherLastIndex : int = otherIndices[2];
-
-					var otherPoly : Vector.<Number>= convexPolygons[ii];
-					x3 = otherPoly[otherPoly.length - 2];
-					y3 = otherPoly[otherPoly.length - 1];
-
-					if (otherFirstIndex != firstIndex || otherSecondIndex != lastIndex) continue;
-					winding1 = Triangulator.winding(prevPrevX, prevPrevY, prevX, prevY, x3, y3);
-					winding2 = Triangulator.winding(x3, y3, firstX, firstY, secondX, secondY);
-					if (winding1 == currWinding && winding2 == currWinding) {
-						otherPoly.length = 0;
-						otherIndices.length = 0;
-						polygon.push(x3);
-						polygon.push(y3);
-						polygonIndices.push(otherLastIndex);
-						prevPrevX = prevX;
-						prevPrevY = prevY;
-						prevX = x3;
-						prevY = y3;
-						ii = 0;
-					}
-				}
-			}
-
-			// Remove empty polygons that resulted from the merge step above.
-			for (i = convexPolygons.length - 1; i >= 0; i--) {
-				polygon = convexPolygons[i];
-				if (polygon.length == 0) {
-					convexPolygons.splice(i, 1);
-					this.polygonPool.free(polygon);
-					polygonIndices = convexPolygonsIndices[i];
-					convexPolygonsIndices.splice(i, 1);
-					this.polygonIndicesPool.free(polygonIndices);
-				}
-			}
-
-			return convexPolygons;
-		}
-
-		private static function isConcave(index : Number, vertexCount : Number, vertices : Vector.<Number>, indices : Vector.<int>) : Boolean {
-			var previous : int = indices[(vertexCount + index - 1) % vertexCount] << 1;
-			var current : int = indices[index] << 1;
-			var next : int = indices[(index + 1) % vertexCount] << 1;
-			return !positiveArea(vertices[previous], vertices[previous + 1], vertices[current], vertices[current + 1], vertices[next], vertices[next + 1]);
-		}
-
-		private static function positiveArea(p1x : Number, p1y : Number, p2x : Number, p2y : Number, p3x : Number, p3y : Number) : Boolean {
-			return p1x * (p3y - p2y) + p2x * (p1y - p3y) + p3x * (p2y - p1y) >= 0;
-		}
-
-		private static function winding(p1x : Number, p1y : Number, p2x : Number, p2y : Number, p3x : Number, p3y : Number) : int {
-			var px : Number = p2x - p1x, py : Number = p2y - p1y;
-			return p3x * py - p3y * px + px * p1y - p1x * py >= 0 ? 1 : -1;
-		}
-	}
-}

spine-as3/spine-as3/src/spine/Updatable.as

@@ -1,35 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine {
-	public interface Updatable {
-		function update() : void;
-		function isActive() : Boolean;
-	}
-}

spine-as3/spine-as3/src/spine/Vertex.as

@@ -1,44 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine {
-	/**
-	 * @author badlogic
-	 */
-	public class Vertex {
-		public var x : Number;
-		public var y : Number;
-		public var u : Number;
-		public var v : Number;
-		public var light : Color = new spine.Color(0, 0, 0);
-		public var dark : Color = new spine.Color(0, 0, 0);
-		
-		function Vertex() { }
-	}
-}

spine-as3/spine-as3/src/spine/VertexEffect.as

@@ -1,38 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine {
-	public interface VertexEffect {
-		function begin(skeleton : Skeleton) : void;
-
-		function transform(vertex : Vertex) : void;
-		
-		function end() : void;
-	}
-}

spine-as3/spine-as3/src/spine/animation/AlphaTimeline.as

@@ -1,83 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine.animation {
-	import spine.Color;
-	import spine.Event;
-	import spine.Skeleton;
-	import spine.Slot;
-
-	public class AlphaTimeline extends CurveTimeline1 implements SlotTimeline {
-		static internal const ENTRIES : Number = 4;
-		static internal const R : Number = 1;
-		static internal const G : Number = 2;
-		static internal const B : Number = 3;
-
-		private var slotIndex : int;
-
-		public function AlphaTimeline (frameCount : Number, bezierCount : Number, slotIndex : Number) {
-			super(frameCount, bezierCount, Property.alpha + "|" + slotIndex);
-			this.slotIndex = slotIndex;
-		}
-
-		public override function getFrameEntries() : int {
-			return ENTRIES;
-		}
-
-		public function getSlotIndex() : int {
-			return slotIndex;
-		}
-
-		public override function apply (skeleton : Skeleton, lastTime : Number, time : Number, events : Vector.<Event>, alpha : Number, blend : MixBlend, direction : MixDirection) : void {
-			var slot : Slot = skeleton.slots[slotIndex];
-			if (!slot.bone.active) return;
-
-			var color : Color = slot.color;
-			if (time < frames[0]) { // Time is before first frame.
-				var setup : Color = slot.data.color;
-				switch (blend) {
-				case MixBlend.setup:
-					color.a = setup.a;
-					return;
-				case MixBlend.first:
-					color.a += (setup.a - color.a) * alpha;
-				}
-				return;
-			}
-
-			var a : Number = getCurveValue(time);
-			if (alpha == 1)
-				color.a = a;
-			else {
-				if (blend == MixBlend.setup) color.a = slot.data.color.a;
-				color.a += (a - color.a) * alpha;
-			}
-		}
-	}
-}

spine-as3/spine-as3/src/spine/animation/Animation.as

@@ -1,89 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine.animation {
-	import spine.Event;
-	import spine.Skeleton;
-	import flash.utils.Dictionary;
-
-	public class Animation {
-		internal var _name : String;
-		private var _timelines : Vector.<Timeline>;
-		internal var _timelineIds : Dictionary = new Dictionary();
-		public var duration : Number;
-
-		public function Animation(name : String, timelines : Vector.<Timeline>, duration : Number) {
-			if (name == null) throw new ArgumentError("name cannot be null.");
-			_name = name;
-			setTimelines(timelines);
-			this.duration = duration;
-		}
-
-		public function setTimelines(timelines : Vector.<Timeline>) : void {
-			if (timelines == null) throw new ArgumentError("timelines cannot be null.");
-			_timelines = timelines;
-			for (var i : int = 0, n : int = timelines.length; i < n; i++) {
-				var ids : Vector.<String> = timelines[i].propertyIds;
-				for (var ii : int = 0, nn : int = ids.length; ii < nn; ii++)
-					_timelineIds[ids[ii]] = true;
-			}
-		}
-
-		public function hasTimeline(ids : Vector.<String>) : Boolean {
-			for (var i : int = 0, n : int = ids.length; i < n; i++)
-				if (_timelineIds[ids[i]]) return true;
-			return false;
-		}
-
-		/** Poses the skeleton at the specified time for this animation. */
-		public function apply(skeleton : Skeleton, lastTime : Number, time : Number, loop : Boolean, events : Vector.<Event>, alpha : Number, blend : MixBlend, direction : MixDirection) : void {
-			if (skeleton == null) throw new ArgumentError("skeleton cannot be null.");
-
-			if (loop && duration != 0) {
-				time %= duration;
-				if (lastTime > 0) lastTime %= duration;
-			}
-
-			for (var i : int = 0, n : int = timelines.length; i < n; i++)
-				timelines[i].apply(skeleton, lastTime, time, events, alpha, blend, direction);
-		}
-
-		public function get name() : String {
-			return _name;
-		}
-
-		public function toString() : String {
-			return _name;
-		}
-
-		public function get timelines() : Vector.<Timeline> {
-			return _timelines;
-		}
-	}
-}

spine-as3/spine-as3/src/spine/animation/AnimationState.as

@@ -1,727 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine.animation {
-	import spine.*;
-	import flash.utils.Dictionary;
-
-	public class AnimationState {
-		static private var SUBSEQUENT : int = 0;
-		static private var FIRST : int = 1;
-		static private var HOLD_SUBSEQUENT : int = 2;
-		static private var HOLD_FIRST : int = 3;
-		static private var HOLD_MIX : int = 4;
-		static private var SETUP : int = 1;
-		static private var CURRENT : int = 2;
-
-		static private var emptyAnimation : Animation = new Animation("<empty>", new Vector.<Timeline>(), 0);
-
-		public var data : AnimationStateData;
-		public var tracks : Vector.<TrackEntry> = new Vector.<TrackEntry>();
-		internal var events : Vector.<Event> = new Vector.<Event>();
-		public var onStart : Listeners = new Listeners();
-		public var onInterrupt : Listeners = new Listeners();
-		public var onEnd : Listeners = new Listeners();
-		public var onDispose : Listeners = new Listeners();
-		public var onComplete : Listeners = new Listeners();
-		public var onEvent : Listeners = new Listeners();
-		internal var queue : EventQueue;
-		internal var propertyIDs : StringSet = new StringSet();
-		internal var mixingTo : Vector.<TrackEntry> = new Vector.<TrackEntry>();
-		internal var animationsChanged : Boolean;
-		public var timeScale : Number = 1;
-		internal var trackEntryPool : Pool;
-		internal var unkeyedState : int = 0;
-
-		public function AnimationState(data : AnimationStateData) {
-			if (data == null) throw new ArgumentError("data can not be null");
-			this.data = data;
-			this.queue = new EventQueue(this);
-			this.trackEntryPool = new Pool(function() : Object {
-				return new TrackEntry();
-			});
-		}
-
-		public function update(delta : Number) : void {
-			delta *= timeScale;
-			for (var i : int = 0, n : int = tracks.length; i < n; i++) {
-				var current : TrackEntry = tracks[i];
-				if (current == null) continue;
-
-				current.animationLast = current.nextAnimationLast;
-				current.trackLast = current.nextTrackLast;
-
-				var currentDelta : Number = delta * current.timeScale;
-
-				if (current.delay > 0) {
-					current.delay -= currentDelta;
-					if (current.delay > 0) continue;
-					currentDelta = -current.delay;
-					current.delay = 0;
-				}
-
-				var next : TrackEntry = current.next;
-				if (next != null) {
-					// When the next entry's delay is passed, change to the next entry, preserving leftover time.
-					var nextTime : Number = current.trackLast - next.delay;
-					if (nextTime >= 0) {
-						next.delay = 0;
-						next.trackTime += current.timeScale == 0 ? 0 : (nextTime / current.timeScale + delta) * next.timeScale;
-						current.trackTime += currentDelta;
-						setCurrent(i, next, true);
-						while (next.mixingFrom != null) {
-							next.mixTime += delta;
-							next = next.mixingFrom;
-						}
-						continue;
-					}
-				} else {
-					// Clear the track when there is no next entry, the track end time is reached, and there is no mixingFrom.
-					if (current.trackLast >= current.trackEnd && current.mixingFrom == null) {
-						tracks[i] = null;
-						queue.end(current);
-						clearNext(current);
-						continue;
-					}
-				}
-				if (current.mixingFrom != null && updateMixingFrom(current, delta)) {
-					// End mixing from entries once all have completed.
-					var from : TrackEntry = current.mixingFrom;
-					current.mixingFrom = null;
-					if (from != null) from.mixingTo = null;
-					while (from != null) {
-						queue.end(from);
-						from = from.mixingFrom;
-					}
-				}
-
-				current.trackTime += currentDelta;
-			}
-
-			queue.drain();
-		}
-
-		private function updateMixingFrom(to : TrackEntry, delta : Number) : Boolean {
-			var from : TrackEntry = to.mixingFrom;
-			if (from == null) return true;
-
-			var finished : Boolean = updateMixingFrom(from, delta);
-
-			from.animationLast = from.nextAnimationLast;
-			from.trackLast = from.nextTrackLast;
-
-			// Require mixTime > 0 to ensure the mixing from entry was applied at least once.
-			if (to.mixTime > 0 && to.mixTime >= to.mixDuration) {
-				// Require totalAlpha == 0 to ensure mixing is complete, unless mixDuration == 0 (the transition is a single frame).
-				if (from.totalAlpha == 0 || to.mixDuration == 0) {
-					to.mixingFrom = from.mixingFrom;
-					if (from.mixingFrom != null) from.mixingFrom.mixingTo = to;
-					to.interruptAlpha = from.interruptAlpha;
-					queue.end(from);
-				}
-				return finished;
-			}
-
-			from.trackTime += delta * from.timeScale;
-			to.mixTime += delta;
-			return false;
-		}
-
-		public function apply(skeleton : Skeleton) : Boolean {
-			if (skeleton == null) throw new ArgumentError("skeleton cannot be null.");
-			if (animationsChanged) _animationsChanged();
-
-			var events : Vector.<Event> = this.events;
-			var applied : Boolean = false;
-
-			for (var i : int = 0, n : int = tracks.length; i < n; i++) {
-				var current : TrackEntry = tracks[i];
-				if (current == null || current.delay > 0) continue;
-				applied = true;
-				var blend : MixBlend = i == 0 ? MixBlend.first : current.mixBlend;
-
-				// Apply mixing from entries first.
-				var mix : Number = current.alpha;
-				if (current.mixingFrom != null)
-					mix *= applyMixingFrom(current, skeleton, blend);
-				else if (current.trackTime >= current.trackEnd && current.next == null)
-					mix = 0;
-
-				// Apply current entry.
-				var animationLast : Number = current.animationLast, animationTime : Number = current.getAnimationTime(), applyTime : Number = animationTime;
-				var applyEvents : Vector.<Event> = events;
-				if (current.reverse) {
-					applyTime = current.animation.duration - applyTime;
-					applyEvents = null;
-				}
-				var timelines : Vector.<Timeline> = current.animation.timelines;
-				var timelineCount : int = timelines.length;
-				var ii : int = 0;
-				var timeline : Timeline;
-				if ((i == 0 && mix == 1) || blend == MixBlend.add) {
-					for (ii = 0; ii < timelineCount; ii++) {
-						timeline = timelines[ii];
-						if (timeline is AttachmentTimeline)
-							applyAttachmentTimeline(AttachmentTimeline(timeline), skeleton, applyTime, blend, true);
-						else
-							timeline.apply(skeleton, animationLast, applyTime, applyEvents, mix, blend, MixDirection.mixIn);
-					}
-				} else {
-					var timelineMode : Vector.<int> = current.timelineMode;
-
-					var firstFrame : Boolean = current.timelinesRotation.length != timelineCount << 1;
-					if (firstFrame) current.timelinesRotation.length = timelineCount << 1;
-
-					for (ii = 0; ii < timelineCount; ii++) {
-						timeline = timelines[ii];
-						var timelineBlend : MixBlend = timelineMode[ii] == SUBSEQUENT ? blend : MixBlend.setup;
-						if (timeline is RotateTimeline)
-							applyRotateTimeline(RotateTimeline(timeline), skeleton, applyTime, mix, timelineBlend, current.timelinesRotation, ii << 1, firstFrame);
-						else if (timeline is AttachmentTimeline)
-							applyAttachmentTimeline(AttachmentTimeline(timeline), skeleton, applyTime, timelineBlend, true);
-						else
-							timeline.apply(skeleton, animationLast, applyTime, applyEvents, mix, timelineBlend, MixDirection.mixIn);
-					}
-				}
-				queueEvents(current, animationTime);
-				events.length = 0;
-				current.nextAnimationLast = animationTime;
-				current.nextTrackLast = current.trackTime;
-			}
-
-			// Set slots attachments to the setup pose, if needed. This occurs if an animation that is mixing out sets attachments so
-			// subsequent timelines see any deform, but the subsequent timelines don't set an attachment (eg they are also mixing out or
-			// the time is before the first key).
-			var setupState : int = unkeyedState + SETUP;
-			var slots : Vector.<Slot> = skeleton.slots;
-			for (var si : int = 0, sn : int = skeleton.slots.length; si < sn; si++) {
-				var slot : Slot = slots[si];
-				if (slot.attachmentState == setupState) {
-					var attachmentName : String = slot.data.attachmentName;
-					slot.attachment = attachmentName == null ? null : skeleton.getAttachmentForSlotIndex(slot.data.index, attachmentName);
-				}
-			}
-			this.unkeyedState += 2; // Increasing after each use avoids the need to reset attachmentState for every slot.
-
-			queue.drain();
-			return applied;
-		}
-
-		private function applyMixingFrom(to : TrackEntry, skeleton : Skeleton, blend : MixBlend) : Number {
-			var from : TrackEntry = to.mixingFrom;
-			if (from.mixingFrom != null) applyMixingFrom(from, skeleton, blend);
-
-			var mix : Number = 0;
-			if (to.mixDuration == 0) { // Single frame mix to undo mixingFrom changes.
-				mix = 1;
-				if (blend == MixBlend.first) blend = MixBlend.setup;
-			} else {
-				mix = to.mixTime / to.mixDuration;
-				if (mix > 1) mix = 1;
-				if (blend != MixBlend.first) blend = from.mixBlend;
-			}
-
-			var attachments : Boolean = mix < from.attachmentThreshold, drawOrder : Boolean = mix < from.drawOrderThreshold;
-			var timelines : Vector.<Timeline> = from.animation.timelines;
-			var timelineCount : int = timelines.length;
-			var alphaHold : Number = from.alpha * to.interruptAlpha, alphaMix : Number = alphaHold * (1 - mix);
-			var animationLast : Number = from.animationLast, animationTime : Number = from.getAnimationTime(), applyTime : Number = animationTime;
-			var events : Vector.<Event> = null;
-			if (from.reverse)
-				applyTime = from.animation.duration - applyTime;
-			else if (mix < from.eventThreshold)
-				events = this.events;
-
-			var i : int = 0;
-			if (blend == MixBlend.add) {
-				for (i = 0; i < timelineCount; i++)
-					timelines[i].apply(skeleton, animationLast, applyTime, events, alphaMix, blend, MixDirection.mixOut);
-			} else {
-				var timelineMode : Vector.<int> = from.timelineMode;
-				var timelineHoldMix : Vector.<TrackEntry> = from.timelineHoldMix;
-
-				var firstFrame : Boolean = from.timelinesRotation.length != timelineCount << 1;
-				if (firstFrame) from.timelinesRotation.length = timelineCount << 1;
-				var timelinesRotation : Vector.<Number> = from.timelinesRotation;
-
-				from.totalAlpha = 0;
-				for (i = 0; i < timelineCount; i++) {
-					var timeline : Timeline = timelines[i];
-					var direction : MixDirection = MixDirection.mixOut;
-					var timelineBlend: MixBlend;
-					var alpha : Number = 0;
-					switch (timelineMode[i]) {
-					case SUBSEQUENT:
-						if (!drawOrder && timeline is DrawOrderTimeline) continue;
-						timelineBlend = blend;
-						alpha = alphaMix;
-						break;
-					case FIRST:
-						timelineBlend = MixBlend.setup;
-						alpha = alphaMix;
-						break;
-					case HOLD_SUBSEQUENT:
-						timelineBlend = blend;
-						alpha = alphaHold;
-						break;
-					case HOLD_FIRST:
-						timelineBlend = MixBlend.setup;
-						alpha = alphaHold;
-						break;
-					default:
-						timelineBlend = MixBlend.setup;
-						var holdMix : TrackEntry = timelineHoldMix[i];
-						alpha = alphaHold * Math.max(0, 1 - holdMix.mixTime / holdMix.mixDuration);
-						break;
-					}
-					from.totalAlpha += alpha;
-					if (timeline is RotateTimeline)
-						applyRotateTimeline(RotateTimeline(timeline), skeleton, applyTime, alpha, timelineBlend, timelinesRotation, i << 1, firstFrame);
-					else if (timeline is AttachmentTimeline) {
-						applyAttachmentTimeline(AttachmentTimeline(timeline), skeleton, applyTime, timelineBlend, attachments);
-					} else {
-						if (drawOrder && timeline is DrawOrderTimeline && timelineBlend == MixBlend.setup) direction = MixDirection.mixIn;
-						timeline.apply(skeleton, animationLast, applyTime, events, alpha, timelineBlend, direction);
-					}
-				}
-			}
-
-			if (to.mixDuration > 0) queueEvents(from, animationTime);
-			this.events.length = 0;
-			from.nextAnimationLast = animationTime;
-			from.nextTrackLast = from.trackTime;
-
-			return mix;
-		}
-
-		private function applyAttachmentTimeline (timeline: AttachmentTimeline, skeleton: Skeleton, time: Number, blend: MixBlend, attachments: Boolean) : void {
-			var slot : Slot = skeleton.slots[timeline.getSlotIndex()];
-			if (!slot.bone.active) return;
-
-			var frames : Vector.<Number> = timeline.frames;
-			if (time < frames[0]) { // Time is before first frame.
-				if (blend == MixBlend.setup || blend == MixBlend.first)
-					setAttachment(skeleton, slot, slot.data.attachmentName, attachments);
-			} else
-				setAttachment(skeleton, slot, timeline.attachmentNames[Timeline.search1(frames, time)], attachments);
-
-			// If an attachment wasn't set (ie before the first frame or attachments is false), set the setup attachment later.
-			if (slot.attachmentState <= unkeyedState) slot.attachmentState = unkeyedState + SETUP;
-		}
-
-		private function setAttachment (skeleton: Skeleton, slot: Slot, attachmentName: String, attachments: Boolean) : void {
-			slot.attachment = attachmentName == null ? null : skeleton.getAttachmentForSlotIndex(slot.data.index, attachmentName);
-			if (attachments) slot.attachmentState = unkeyedState + CURRENT;
-		}
-
-		private function applyRotateTimeline(timeline : RotateTimeline, skeleton : Skeleton, time : Number, alpha : Number, blend : MixBlend, timelinesRotation : Vector.<Number>, i : int, firstFrame : Boolean) : void {
-			if (firstFrame) timelinesRotation[i] = 0;
-
-			if (alpha == 1) {
-				timeline.apply(skeleton, 0, time, null, 1, blend, MixDirection.mixIn);
-				return;
-			}
-
-			var bone : Bone = skeleton.bones[timeline.getBoneIndex()];
-			if (!bone.active) return;
-			var frames : Vector.<Number> = timeline.frames;
-			var r1 : Number, r2 : Number;
-			if (time < frames[0]) {
-				switch (blend) {
-					case MixBlend.setup:
-						bone.rotation = bone.data.rotation;
-					default:
-						return;
-					case MixBlend.first:
-						r1 = bone.rotation;
-						r2 = bone.data.rotation;
-				}
-			} else {
-				r1 = blend == MixBlend.setup ? bone.data.rotation : bone.rotation;
-				r2 = bone.data.rotation + timeline.getCurveValue(time);
-			}
-
-			// Mix between rotations using the direction of the shortest route on the first frame while detecting crosses.
-			var total : Number, diff : Number = r2 - r1;
-			diff -= (16384 - int((16384.499999999996 - diff / 360))) * 360;
-			if (diff == 0) {
-				total = timelinesRotation[i];
-			} else {
-				var lastTotal : Number, lastDiff : Number;
-				if (firstFrame) {
-					lastTotal = 0;
-					lastDiff = diff;
-				} else {
-					lastTotal = timelinesRotation[i]; // Angle and direction of mix, including loops.
-					lastDiff = timelinesRotation[i + 1]; // Difference between bones.
-				}
-				var current : Boolean = diff > 0, dir : Boolean = lastTotal >= 0;
-				// Detect cross at 0 (not 180).
-				if (MathUtils.signum(lastDiff) != MathUtils.signum(diff) && Math.abs(lastDiff) <= 90) {
-					// A cross after a 360 rotation is a loop.
-					if (Math.abs(lastTotal) > 180) lastTotal += 360 * MathUtils.signum(lastTotal);
-					dir = current;
-				}
-				total = diff + lastTotal - lastTotal % 360; // Store loops as part of lastTotal.
-				if (dir != current) total += 360 * MathUtils.signum(lastTotal);
-				timelinesRotation[i] = total;
-			}
-			timelinesRotation[i + 1] = diff;
-			bone.rotation = r1 + total * alpha;
-		}
-
-		private function queueEvents(entry : TrackEntry, animationTime : Number) : void {
-			var animationStart : Number = entry.animationStart, animationEnd : Number = entry.animationEnd;
-			var duration : Number = animationEnd - animationStart;
-			var trackLastWrapped : Number = entry.trackLast % duration;
-
-			// Queue events before complete.
-			var events : Vector.<Event> = this.events;
-			var event : Event;
-			var i : int = 0, n : int = events.length;
-			for (; i < n; i++) {
-				event = events[i];
-				if (event.time < trackLastWrapped) break;
-				if (event.time > animationEnd) continue; // Discard events outside animation start/end.
-				queue.event(entry, event);
-			}
-
-			// Queue complete if completed a loop iteration or the animation.
-			var complete:Boolean;
-			if (entry.loop)
-				complete = duration == 0 || trackLastWrapped > entry.trackTime % duration;
-			else
-				complete = animationTime >= animationEnd && entry.animationLast < animationEnd;
-			if (complete) queue.complete(entry);
-
-			// Queue events after complete.
-			for (; i < n; i++) {
-				event = events[i];
-				if (event.time < animationStart) continue; // Discard events outside animation start/end.
-				queue.event(entry, event);
-			}
-		}
-
-		public function clearTracks() : void {
-			var oldTrainDisabled : Boolean = queue.drainDisabled;
-			queue.drainDisabled = true;
-			for (var i : int = 0, n : int = tracks.length; i < n; i++)
-				clearTrack(i);
-			tracks.length = 0;
-			queue.drainDisabled = oldTrainDisabled;
-			queue.drain();
-		}
-
-		public function clearTrack(trackIndex : int) : void {
-			if (trackIndex >= tracks.length) return;
-			var current : TrackEntry = tracks[trackIndex];
-			if (current == null) return;
-
-			queue.end(current);
-
-			clearNext(current);
-
-			var entry : TrackEntry = current;
-			while (true) {
-				var from : TrackEntry = entry.mixingFrom;
-				if (from == null) break;
-				queue.end(from);
-				entry.mixingFrom = null;
-				entry.mixingTo = null;
-				entry = from;
-			}
-
-			tracks[current.trackIndex] = null;
-
-			queue.drain();
-		}
-
-		private function setCurrent(index : int, current : TrackEntry, interrupt : Boolean) : void {
-			var from : TrackEntry = expandToIndex(index);
-			tracks[index] = current;
-			current.previous = null;
-
-			if (from != null) {
-				if (interrupt) queue.interrupt(from);
-				current.mixingFrom = from;
-				from.mixingTo = current;
-				current.mixTime = 0;
-
-				// Store the interrupted mix percentage.
-				if (from.mixingFrom != null && from.mixDuration > 0)
-					current.interruptAlpha *= Math.min(1, from.mixTime / from.mixDuration);
-
-				from.timelinesRotation.length = 0; // Reset rotation for mixing out, in case entry was mixed in.
-			}
-
-			queue.start(current);
-		}
-
-		public function setAnimationByName(trackIndex : int, animationName : String, loop : Boolean) : TrackEntry {
-			var animation : Animation = data.skeletonData.findAnimation(animationName);
-			if (animation == null) throw new ArgumentError("Animation not found: " + animationName);
-			return setAnimation(trackIndex, animation, loop);
-		}
-
-		public function setAnimation(trackIndex : int, animation : Animation, loop : Boolean) : TrackEntry {
-			if (animation == null) throw new ArgumentError("animation cannot be null.");
-			var interrupt : Boolean = true;
-			var current : TrackEntry = expandToIndex(trackIndex);
-			if (current != null) {
-				if (current.nextTrackLast == -1) {
-					// Don't mix from an entry that was never applied.
-					tracks[trackIndex] = current.mixingFrom;
-					queue.interrupt(current);
-					queue.end(current);
-					clearNext(current);
-					current = current.mixingFrom;
-					interrupt = false;
-				} else
-					clearNext(current);
-			}
-			var entry : TrackEntry = trackEntry(trackIndex, animation, loop, current);
-			setCurrent(trackIndex, entry, interrupt);
-			queue.drain();
-			return entry;
-		}
-
-		public function addAnimationByName(trackIndex : int, animationName : String, loop : Boolean, delay : Number) : TrackEntry {
-			var animation : Animation = data.skeletonData.findAnimation(animationName);
-			if (animation == null) throw new ArgumentError("Animation not found: " + animationName);
-			return addAnimation(trackIndex, animation, loop, delay);
-		}
-
-		public function addAnimation(trackIndex : int, animation : Animation, loop : Boolean, delay : Number) : TrackEntry {
-			if (animation == null) throw new ArgumentError("animation cannot be null.");
-
-			var last : TrackEntry = expandToIndex(trackIndex);
-			if (last != null) {
-				while (last.next != null)
-					last = last.next;
-			}
-
-			var entry : TrackEntry = trackEntry(trackIndex, animation, loop, last);
-
-			if (last == null) {
-				setCurrent(trackIndex, entry, true);
-				queue.drain();
-			} else {
-				last.next = entry;
-				entry.previous = last;
-				if (delay <= 0) delay += last.getTrackComplete() - entry.mixDuration;
-			}
-
-			entry.delay = delay;
-			return entry;
-		}
-
-		public function setEmptyAnimation(trackIndex : int, mixDuration : Number) : TrackEntry {
-			var entry : TrackEntry = setAnimation(trackIndex, emptyAnimation, false);
-			entry.mixDuration = mixDuration;
-			entry.trackEnd = mixDuration;
-			return entry;
-		}
-
-		public function addEmptyAnimation(trackIndex : int, mixDuration : Number, delay : Number) : TrackEntry {
-			var entry : TrackEntry = addAnimation(trackIndex, emptyAnimation, false, delay);
-			if (delay <= 0) entry.delay += entry.mixDuration - mixDuration;
-			entry.mixDuration = mixDuration;
-			entry.trackEnd = mixDuration;
-			return entry;
-		}
-
-		public function setEmptyAnimations(mixDuration : Number) : void {
-			var oldDrainDisabled : Boolean = queue.drainDisabled;
-			queue.drainDisabled = true;
-			for (var i : int = 0, n : int = tracks.length; i < n; i++) {
-				var current : TrackEntry = tracks[i];
-				if (current != null) setEmptyAnimation(current.trackIndex, mixDuration);
-			}
-			queue.drainDisabled = oldDrainDisabled;
-			queue.drain();
-		}
-
-		private function expandToIndex(index : int) : TrackEntry {
-			if (index < tracks.length) return tracks[index];
-			tracks.length = index + 1;
-			return null;
-		}
-
-		private function trackEntry(trackIndex : int, animation : Animation, loop : Boolean, last : TrackEntry) : TrackEntry {
-			var entry : TrackEntry = TrackEntry(trackEntryPool.obtain());
-			entry.trackIndex = trackIndex;
-			entry.animation = animation;
-			entry.loop = loop;
-			entry.holdPrevious = false;
-
-			entry.eventThreshold = 0;
-			entry.attachmentThreshold = 0;
-			entry.drawOrderThreshold = 0;
-
-			entry.animationStart = 0;
-			entry.animationEnd = animation.duration;
-			entry.animationLast = -1;
-			entry.nextAnimationLast = -1;
-
-			entry.delay = 0;
-			entry.trackTime = 0;
-			entry.trackLast = -1;
-			entry.nextTrackLast = -1;
-			entry.trackEnd = int.MAX_VALUE;
-			entry.timeScale = 1;
-
-			entry.alpha = 1;
-			entry.interruptAlpha = 1;
-			entry.mixTime = 0;
-			entry.mixDuration = last == null ? 0 : data.getMix(last.animation, animation);
-			entry.mixBlend = MixBlend.replace;
-			return entry;
-		}
-
-		/** Removes the {@link TrackEntry#getNext() next entry} and all entries after it for the specified entry. */
-		public function clearNext(entry : TrackEntry) : void {
-			var next : TrackEntry = entry.next;
-			while (next != null) {
-				queue.dispose(next);
-				next = next.next;
-			}
-			entry.next = null;
-		}
-
-		private function _animationsChanged() : void {
-			animationsChanged = false;
-
-			propertyIDs.clear();
-			for (var i : int = 0, n : int = tracks.length; i < n; i++) {
-				var entry : TrackEntry = tracks[i];
-				if (!entry) continue;
-				while (entry.mixingFrom)
-					entry = entry.mixingFrom;
-				do {
-					if (!entry.mixingTo || entry.mixBlend != MixBlend.add) computeHold(entry);
-					entry = entry.mixingTo;
-				} while (entry);
-			}
-		}
-
-		private function computeHold (entry: TrackEntry) : void {
-			var to : TrackEntry = entry.mixingTo;
-			var timelines : Vector.<Timeline> = entry.animation.timelines;
-			var timelinesCount : int = entry.animation.timelines.length;
-			var timelineMode : Vector.<int> = entry.timelineMode;
-			timelineMode.length = timelinesCount;
-			entry.timelineHoldMix.length = 0;
-			var timelineHoldMix : Vector.<TrackEntry> = entry.timelineHoldMix;
-			timelineHoldMix.length = timelinesCount;
-			var propertyIDs : StringSet = this.propertyIDs;
-
-			var i : int;
-
-			if (to != null && to.holdPrevious) {
-				for (i = 0; i < timelinesCount; i++)
-					timelineMode[i] = propertyIDs.addAll(timelines[i].propertyIds) ? HOLD_FIRST : HOLD_SUBSEQUENT;
-				return;
-			}
-
-			outer:
-			for (i = 0; i < timelinesCount; i++) {
-				var timeline : Timeline = timelines[i];
-				var ids : Vector.<String> = timeline.propertyIds;
-				if (!propertyIDs.addAll(ids))
-					timelineMode[i] = SUBSEQUENT;
-				else if (to == null || timeline is AttachmentTimeline || timeline is DrawOrderTimeline
-					|| timeline is EventTimeline || !to.animation.hasTimeline(ids)) {
-					timelineMode[i] = FIRST;
-				} else {
-					for (var next : TrackEntry = to.mixingTo; next != null; next = next.mixingTo) {
-						if (next.animation.hasTimeline(ids)) continue;
-						if (entry.mixDuration > 0) {
-							timelineMode[i] = HOLD_MIX;
-							timelineHoldMix[i] = next;
-							continue outer;
-						}
-						break;
-					}
-					timelineMode[i] = HOLD_FIRST;
-				}
-			}
-		}
-
-		public function getCurrent(trackIndex : int) : TrackEntry {
-			if (trackIndex >= tracks.length) return null;
-			return tracks[trackIndex];
-		}
-
-		public function clearListeners() : void {
-			onStart.listeners.length = 0;
-			onInterrupt.listeners.length = 0;
-			onEnd.listeners.length = 0;
-			onDispose.listeners.length = 0;
-			onComplete.listeners.length = 0;
-			onEvent.listeners.length = 0;
-		}
-
-		public function clearListenerNotifications() : void {
-			queue.clear();
-		}
-	}
-}
-
-import flash.utils.Dictionary;
-
-class StringSet {
-	private var entries : Dictionary = new Dictionary();
-	private var size : int = 0;
-
-	public function add (value : String): Boolean {
-		var contains : Boolean = entries[value];
-		entries[value] = true;
-		if (!contains) {
-			size++;
-			return true;
-		}
-		return false;
-	}
-
-	public function addAll (values : Vector.<String>) : Boolean {
-		var oldSize : int = size;
-		for (var i : int = 0, n : int = values.length; i < n; i++)
-			add(values[i]);
-		return oldSize != size;
-	}
-
-	public function contains (value : String) : Boolean {
-		return entries[value];
-	}
-
-	public function clear () : void {
-		entries = new Dictionary();
-		size = 0;
-	}
-}

spine-as3/spine-as3/src/spine/animation/AnimationStateData.as

@@ -1,66 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine.animation {
-	import spine.SkeletonData;
-
-	public class AnimationStateData {
-		internal var _skeletonData : SkeletonData;
-		private var animationToMixTime : Object = new Object();
-		public var defaultMix : Number = 0;
-
-		public function AnimationStateData(skeletonData : SkeletonData) {
-			_skeletonData = skeletonData;
-		}
-
-		public function get skeletonData() : SkeletonData {
-			return _skeletonData;
-		}
-
-		public function setMixByName(fromName : String, toName : String, duration : Number) : void {
-			var from : Animation = _skeletonData.findAnimation(fromName);
-			if (from == null) throw new ArgumentError("Animation not found: " + fromName);
-			var to : Animation = _skeletonData.findAnimation(toName);
-			if (to == null) throw new ArgumentError("Animation not found: " + toName);
-			setMix(from, to, duration);
-		}
-
-		public function setMix(from : Animation, to : Animation, duration : Number) : void {
-			if (from == null) throw new ArgumentError("from cannot be null.");
-			if (to == null) throw new ArgumentError("to cannot be null.");
-			animationToMixTime[from.name + ":" + to.name] = duration;
-		}
-
-		public function getMix(from : Animation, to : Animation) : Number {
-			var time : Object = animationToMixTime[from.name + ":" + to.name];
-			if (time == null) return defaultMix;
-			return time as Number;
-		}
-	}
-}

spine-as3/spine-as3/src/spine/animation/AttachmentTimeline.as

@@ -1,84 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine.animation {
-	import spine.Slot;
-	import spine.Event;
-	import spine.Skeleton;
-
-	public class AttachmentTimeline extends Timeline implements SlotTimeline {
-		private var slotIndex : int;
-
-		/** The attachment name for each key frame. May contain null values to clear the attachment. */
-		public var attachmentNames : Vector.<String>;
-
-		public function AttachmentTimeline (frameCount : int, slotIndex : int) {
-			super(frameCount, [
-				Property.attachment + "|" + slotIndex
-			]);
-			this.slotIndex = slotIndex;
-			attachmentNames = new Vector.<String>(frameCount, true);
-		}
-
-		public override function getFrameCount () : int {
-			return frames.length;
-		}
-
-		public function getSlotIndex() : int {
-			return slotIndex;
-		}
-
-		/** Sets the time in seconds and the attachment name for the specified key frame. */
-		public function setFrame (frame : int, time : Number, attachmentName : String) : void {
-			frames[frame] = time;
-			attachmentNames[frame] = attachmentName;
-		}
-
-		public override function apply (skeleton : Skeleton, lastTime : Number, time : Number, events : Vector.<Event>, alpha : Number, blend : MixBlend, direction : MixDirection) : void {
-			var slot : Slot = skeleton.slots[slotIndex];
-			if (!slot.bone.active) return;
-
-			if (direction == MixDirection.mixOut) {
-				if (blend == MixBlend.setup) setAttachment(skeleton, slot, slot.data.attachmentName);
-				return;
-			}
-
-			if (time < frames[0]) {
-				if (blend == MixBlend.setup || blend == MixBlend.first) setAttachment(skeleton, slot, slot.data.attachmentName);
-				return;
-			}
-
-			setAttachment(skeleton, slot, attachmentNames[search1(frames, time)]);
-		}
-
-		private function setAttachment(skeleton : Skeleton, slot : Slot, attachmentName : String) : void {
-			slot.attachment = attachmentName == null ? null : skeleton.getAttachmentForSlotIndex(slotIndex, attachmentName);
-		}
-	}
-}

spine-as3/spine-as3/src/spine/animation/BoneTimeline.as

@@ -1,34 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine.animation {
-	public interface BoneTimeline {
-		function getBoneIndex() : int;
-	}
-}

spine-as3/spine-as3/src/spine/animation/CurveTimeline.as

@@ -1,131 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine.animation {
-	/** The base class for timelines that interpolate between frame values using stepped, linear, or a Bezier curve. */
-	public class CurveTimeline extends Timeline {
-		static internal const LINEAR : Number = 0;
-		static internal const STEPPED : Number = 1;
-		static internal const BEZIER : Number = 2;
-		static internal const BEZIER_SIZE : int = 18;
-
-		internal var curves : Vector.<Number>; // type, x, y, ...
-
-		public function CurveTimeline(frameCount : int, bezierCount : int, propertyIds : Array) {
-			super(frameCount, propertyIds);
-			curves = new Vector.<Number>(frameCount + bezierCount * BEZIER_SIZE, true);
-			curves[frameCount - 1] = STEPPED;
-		}
-
-		/** Sets the specified key frame to linear interpolation. */
-		public function setLinear(frame : int) : void {
-			curves[frame] = LINEAR;
-		}
-
-		/** Sets the specified key frame to stepped interpolation. */
-		public function setStepped(frame : int) : void{
-			curves[frame] = STEPPED;
-		}
-
-		/** Shrinks the storage for Bezier curves, for use when <code>bezierCount</code> (specified in the constructor) was larger
-		 * than the actual number of Bezier curves. */
-		public function shrink(bezierCount : int) : void {
-			var size : int = getFrameCount() + bezierCount * BEZIER_SIZE;
-			var curves : Vector.<Number> = this.curves;
-			if (curves.length > size) {
-				var newCurves : Vector.<Number> = new Vector.<Number>(size, true);
-				for (var i : int = 0; i < size; i++)
-					newCurves[i] = curves[i];
-				curves = newCurves;
-			}
-		}
-
-		/** Stores the segments for the specified Bezier curve. For timelines that modify multiple values, there may be more than
-		 * one curve per frame.
-		 * @param bezier The ordinal of this Bezier curve for this timeline, between 0 and <code>bezierCount - 1</code> (specified
-		 *           in the constructor), inclusive.
-		 * @param frame Between 0 and <code>frameCount - 1</code>, inclusive.
-		 * @param value The index of the value for this frame that this curve is used for.
-		 * @param time1 The time for the first key.
-		 * @param value1 The value for the first key.
-		 * @param cx1 The time for the first Bezier handle.
-		 * @param cy1 The value for the first Bezier handle.
-		 * @param cx2 The time of the second Bezier handle.
-		 * @param cy2 The value for the second Bezier handle.
-		 * @param time2 The time for the second key.
-		 * @param value2 The value for the second key. */
-		public function setBezier(bezier : int, frame : int, value : Number, time1 : Number, value1 : Number, cx1 : Number, cy1 : Number, cx2 : Number,
-			cy2 : Number, time2 : Number, value2 : Number) : void {
-			var curves : Vector.<Number> = this.curves;
-			var i : int = getFrameCount() + bezier * BEZIER_SIZE;
-			if (value == 0) curves[frame] = BEZIER + i;
-			var tmpx : Number = (time1 - cx1 * 2 + cx2) * 0.03, tmpy : Number = (value1 - cy1 * 2 + cy2) * 0.03;
-			var dddx : Number = ((cx1 - cx2) * 3 - time1 + time2) * 0.006, dddy : Number = ((cy1 - cy2) * 3 - value1 + value2) * 0.006;
-			var ddx : Number = tmpx * 2 + dddx, ddy : Number = tmpy * 2 + dddy;
-			var dx : Number = (cx1 - time1) * 0.3 + tmpx + dddx * 0.16666667, dy : Number = (cy1 - value1) * 0.3 + tmpy + dddy * 0.16666667;
-			var x : Number = time1 + dx, y : Number = value1 + dy;
-			for (var n : int = i + BEZIER_SIZE; i < n; i += 2) {
-				curves[i] = x;
-				curves[i + 1] = y;
-				dx += ddx;
-				dy += ddy;
-				ddx += dddx;
-				ddy += dddy;
-				x += dx;
-				y += dy;
-			}
-		}
-
-		/** Returns the Bezier interpolated value for the specified time.
-		 * @param frameIndex The index into {@link #getFrames()} for the values of the frame before <code>time</code>.
-		 * @param valueOffset The offset from <code>frameIndex</code> to the value this curve is used for.
-		 * @param i The index of the Bezier segments. See {@link #getCurveType(int)}. */
-		public function getBezierValue(time : Number, frameIndex : int, valueOffset : int, i : int) : Number {
-			var curves : Vector.<Number> = this.curves;
-			var x : Number, y : Number;
-			if (curves[i] > time) {
-				x = frames[frameIndex];
-				y = frames[frameIndex + valueOffset];
-				return y + (time - x) / (curves[i] - x) * (curves[i + 1] - y);
-			}
-			var n : int = i + BEZIER_SIZE;
-			for (i += 2; i < n; i += 2) {
-				if (curves[i] >= time) {
-					x = curves[i - 2];
-					y = curves[i - 1];
-					return y + (time - x) / (curves[i] - x) * (curves[i + 1] - y);
-				}
-			}
-			frameIndex += getFrameEntries();
-			x = curves[n - 2];
-			y = curves[n - 1];
-			return y + (time - x) / (frames[frameIndex] - x) * (frames[frameIndex + valueOffset] - y);
-		}
-	}
-}

spine-as3/spine-as3/src/spine/animation/CurveTimeline1.as

@@ -1,77 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine.animation {
-	/** The base class for a {@link CurveTimeline} that sets one property. */
-	public class CurveTimeline1 extends CurveTimeline {
-		static private const ENTRIES : Number = 2;
-		static private const VALUE : Number = 1;
-
-		/** @param bezierCount The maximum number of Bezier curves. See {@link #shrink(int)}.
-		 * @param propertyIds Unique identifiers for the properties the timeline modifies. */
-		public function CurveTimeline1 (frameCount : int, bezierCount : int, propertyId : String) {
-			super(frameCount, bezierCount, [ propertyId ]);
-		}
-
-		public override function getFrameEntries() : int {
-			return ENTRIES;
-		}
-
-		/** Sets the time and values for the specified frame.
-		 * @param frame Between 0 and <code>frameCount</code>, inclusive.
-		 * @param time The frame time in seconds. */
-		public function setFrame(frame : int, time : Number, value1 : Number) : void {
-			frame <<= 1;
-			frames[frame] = time;
-			frames[frame + VALUE] = value1;
-		}
-
-		/** Returns the interpolated value for the specified time. */
-		public function getCurveValue(time : Number) : Number {
-			var frames : Vector.<Number> = this.frames;
-			var i : int = frames.length - 2;
-			for (var ii : int = 2; ii <= i; ii += 2) {
-				if (frames[ii] > time) {
-					i = ii - 2;
-					break;
-				}
-			}
-
-			var curveType : Number = curves[i >> 1];
-			switch (curveType) {
-			case LINEAR:
-				var before : Number = frames[i], value : Number = frames[i + VALUE];
-				return value + (time - before) / (frames[i + ENTRIES] - before) * (frames[i + ENTRIES + VALUE] - value);
-			case STEPPED:
-				return frames[i + VALUE];
-			}
-			return getBezierValue(time, i, VALUE, curveType - BEZIER);
-		}
-	}
-}

spine-as3/spine-as3/src/spine/animation/CurveTimeline2.as

@@ -1,58 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine.animation {
-	/** The base class for a {@link CurveTimeline} which sets two properties. */
-	public class CurveTimeline2 extends CurveTimeline {
-		static internal const ENTRIES : Number = 3;
-		static internal const VALUE1 : Number = 1;
-		static internal const VALUE2 : Number = 2;
-
-		/** @param bezierCount The maximum number of Bezier curves. See {@link #shrink(int)}.
-		 * @param propertyIds Unique identifiers for the properties the timeline modifies. */
-		public function CurveTimeline2 (frameCount : int, bezierCount : int, propertyId1 : String, propertyId2 : String) {
-			super(frameCount, bezierCount, [ propertyId1, propertyId2 ]);
-		}
-
-		public override function getFrameEntries() : int {
-			return ENTRIES;
-		}
-
-		/** Sets the time and values for the specified frame.
-		 * @param frame Between 0 and <code>frameCount</code>, inclusive.
-		 * @param time The frame time in seconds. */
-		public function setFrame(frame : int, time : Number, value1 : Number, value2 : Number) : void {
-			frame *= ENTRIES;
-			var frames : Vector.<Number> = this.frames;
-			frames[frame] = time;
-			frames[frame + VALUE1] = value1;
-			frames[frame + VALUE2] = value2;
-		}
-	}
-}

spine-as3/spine-as3/src/spine/animation/DeformTimeline.as

@@ -1,298 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine.animation {
-	import spine.attachments.Attachment;
-	import spine.attachments.VertexAttachment;
-	import spine.Event;
-	import spine.Skeleton;
-	import spine.Slot;
-
-	public class DeformTimeline extends CurveTimeline implements SlotTimeline {
-		public var slotIndex : int;
-
-		/** The attachment that will be deformed. */
-		public var attachment : VertexAttachment;
-
-		/** The vertices for each key frame. */
-		public var vertices : Vector.<Vector.<Number>>;
-
-		public function DeformTimeline (frameCount : int, bezierCount : int, slotIndex : int, attachment : VertexAttachment) {
-			super(frameCount, bezierCount, [
-				Property.deform + "|" + slotIndex + "|" + attachment.id
-			]);
-			this.slotIndex = slotIndex;
-			this.attachment = attachment;
-			vertices = new Vector.<Vector.<Number>>(frameCount, true);
-		}
-
-		public override function getFrameCount () : int {
-			return frames.length;
-		}
-
-		public function getSlotIndex() : int {
-			return slotIndex;
-		}
-
-		/** Sets the time in seconds and the vertices for the specified key frame.
-		 * @param vertices Vertex positions for an unweighted VertexAttachment, or deform offsets if it has weights. */
-		public function setFrame (frame : int, time : Number, vertices : Vector.<Number>) : void {
-			frames[frame] = time;
-			this.vertices[frame] = vertices;
-		}
-
-		/** @param value1 Ignored (0 is used for a deform timeline).
-		 * @param value2 Ignored (1 is used for a deform timeline). */
-		public override function setBezier (bezier : int, frame: int, value : Number, time1 : Number, value1 : Number, cx1 : Number, cy1: Number, cx2 : Number,
-			cy2 : Number, time2 : Number, value2 : Number) : void {
-			var curves : Vector.<Number> = this.curves;
-			var i : int = getFrameCount() + bezier * BEZIER_SIZE;
-			if (value == 0) curves[frame] = BEZIER + i;
-			var tmpx : Number = (time1 - cx1 * 2 + cx2) * 0.03, tmpy : Number = cy2 * 0.03 - cy1 * 0.06;
-			var dddx : Number = ((cx1 - cx2) * 3 - time1 + time2) * 0.006, dddy : Number = (cy1 - cy2 + 0.33333333) * 0.018;
-			var ddx : Number = tmpx * 2 + dddx, ddy : Number = tmpy * 2 + dddy;
-			var dx : Number = (cx1 - time1) * 0.3 + tmpx + dddx * 0.16666667, dy : Number = cy1 * 0.3 + tmpy + dddy * 0.16666667;
-			var x : Number = time1 + dx, y : Number = dy;
-			for (var n : int = i + BEZIER_SIZE; i < n; i += 2) {
-				curves[i] = x;
-				curves[i + 1] = y;
-				dx += ddx;
-				dy += ddy;
-				ddx += dddx;
-				ddy += dddy;
-				x += dx;
-				y += dy;
-			}
-		}
-
-		private function getCurvePercent (time : Number, frame : int) : Number {
-			var curves : Vector.<Number> = this.curves;
-			var i : int = curves[frame];
-			var x : Number;
-			switch (i) {
-			case LINEAR:
-				x = frames[frame];
-				return (time - x) / (frames[frame + getFrameEntries()] - x);
-			case STEPPED:
-				return 0;
-			}
-			i -= BEZIER;
-			if (curves[i] > time) {
-				x = frames[frame];
-				return curves[i + 1] * (time - x) / (curves[i] - x);
-			}
-			var n : int = i + BEZIER_SIZE, y : Number;
-			for (i += 2; i < n; i += 2) {
-				if (curves[i] >= time) {
-					x = curves[i - 2];
-					y = curves[i - 1];
-					return y + (time - x) / (curves[i] - x) * (curves[i + 1] - y);
-				}
-			}
-			x = curves[n - 2];
-			y = curves[n - 1];
-			return y + (1 - y) * (time - x) / (frames[frame + getFrameEntries()] - x);
-		}
-
-		public override function apply (skeleton : Skeleton, lastTime : Number, time : Number, events : Vector.<Event>, alpha : Number, blend : MixBlend, direction : MixDirection) : void {
-			var slot : Slot = skeleton.slots[slotIndex];
-			if (!slot.bone.active) return;
-			var slotAttachment : Attachment = slot.attachment;
-			if (!(slotAttachment is VertexAttachment) || VertexAttachment(slotAttachment).deformAttachment != attachment) return;
-			var vertexAttachment : VertexAttachment = VertexAttachment(slotAttachment);
-
-			var deform : Vector.<Number> = slot.deform;
-			if (deform.length == 0) blend = MixBlend.setup;
-
-			var vertices : Vector.<Vector.<Number>> = this.vertices;
-			var vertexCount : int = vertices[0].length;
-
-			var i : int, setupVertices : Vector.<Number>;
-
-			var frames : Vector.<Number> = this.frames;
-			if (time < frames[0]) {
-				switch (blend) {
-				case MixBlend.setup:
-					deform.length = 0;
-					return;
-				case MixBlend.first:
-					if (alpha == 1) {
-						deform.length = 0;
-						return;
-					}
-					deform.length = vertexCount;
-					if (vertexAttachment.bones == null) {
-						// Unweighted vertex positions.
-						setupVertices = vertexAttachment.vertices;
-						for (i = 0; i < vertexCount; i++)
-							deform[i] += (setupVertices[i] - deform[i]) * alpha;
-					} else {
-						// Weighted deform offsets.
-						alpha = 1 - alpha;
-						for (i = 0; i < vertexCount; i++)
-							deform[i] *= alpha;
-					}
-				}
-				return;
-			}
-
-			deform.length = vertexCount;
-			var setup : Number;
-
-			if (time >= frames[frames.length - 1]) { // Time is after last frame.
-				var lastVertices : Vector.<Number> = vertices[frames.length - 1];
-				if (alpha == 1) {
-					if (blend == MixBlend.add) {
-						if (vertexAttachment.bones == null) {
-							// Unweighted vertex positions, with alpha.
-							setupVertices = vertexAttachment.vertices;
-							for (i = 0; i < vertexCount; i++)
-								deform[i] += lastVertices[i] - setupVertices[i];
-						} else {
-							// Weighted deform offsets, with alpha.
-							for (i = 0; i < vertexCount; i++)
-								deform[i] += lastVertices[i];
-						}
-					} else {
-						for (i = 0; i < vertexCount; i++)
-							deform[i] = lastVertices[i];
-					}
-				} else {
-					switch (blend) {
-					case MixBlend.setup: {
-						if (vertexAttachment.bones == null) {
-							// Unweighted vertex positions, with alpha.
-							setupVertices = vertexAttachment.vertices;
-							for (i = 0; i < vertexCount; i++) {
-								setup = setupVertices[i];
-								deform[i] = setup + (lastVertices[i] - setup) * alpha;
-							}
-						} else {
-							// Weighted deform offsets, with alpha.
-							for (i = 0; i < vertexCount; i++)
-								deform[i] = lastVertices[i] * alpha;
-						}
-						break;
-					}
-					case MixBlend.first:
-					case MixBlend.replace:
-						for (i = 0; i < vertexCount; i++)
-							deform[i] += (lastVertices[i] - deform[i]) * alpha;
-						break;
-					case MixBlend.add:
-						if (vertexAttachment.bones == null) {
-							// Unweighted vertex positions, with alpha.
-							setupVertices = vertexAttachment.vertices;
-							for (i = 0; i < vertexCount; i++)
-								deform[i] += (lastVertices[i] - setupVertices[i]) * alpha;
-						} else {
-							// Weighted deform offsets, with alpha.
-							for (i = 0; i < vertexCount; i++)
-								deform[i] += lastVertices[i] * alpha;
-						}
-					}
-				}
-				return;
-			}
-
-			// Interpolate between the previous frame and the current frame.
-			var frame : int = search1(frames, time);
-			var percent : Number = getCurvePercent(time, frame);
-			var prevVertices : Vector.<Number> = vertices[frame], prev : Number;
-			var nextVertices : Vector.<Number> = vertices[frame + 1];
-
-			if (alpha == 1) {
-				if (blend == MixBlend.add) {
-					if (vertexAttachment.bones == null) {
-						// Unweighted vertex positions, with alpha.
-						setupVertices = vertexAttachment.vertices;
-						for (i = 0; i < vertexCount; i++) {
-							prev = prevVertices[i];
-							deform[i] += prev + (nextVertices[i] - prev) * percent - setupVertices[i];
-						}
-					} else {
-						// Weighted deform offsets, with alpha.
-						for (i = 0; i < vertexCount; i++) {
-							prev = prevVertices[i];
-							deform[i] += prev + (nextVertices[i] - prev) * percent;
-						}
-					}
-				} else {
-					for (i = 0; i < vertexCount; i++) {
-						prev = prevVertices[i];
-						deform[i] = prev + (nextVertices[i] - prev) * percent;
-					}
-				}
-			} else {
-				switch (blend) {
-				case MixBlend.setup: {
-					if (vertexAttachment.bones == null) {
-						// Unweighted vertex positions, with alpha.
-						setupVertices = vertexAttachment.vertices;
-						for (i = 0; i < vertexCount; i++) {
-							prev = prevVertices[i];
-							setup = setupVertices[i];
-							deform[i] = setup + (prev + (nextVertices[i] - prev) * percent - setup) * alpha;
-						}
-					} else {
-						// Weighted deform offsets, with alpha.
-						for (i = 0; i < vertexCount; i++) {
-							prev = prevVertices[i];
-							deform[i] = (prev + (nextVertices[i] - prev) * percent) * alpha;
-						}
-					}
-					break;
-				}
-				case MixBlend.first:
-				case MixBlend.replace:
-					for (i = 0; i < vertexCount; i++) {
-						prev = prevVertices[i];
-						deform[i] += (prev + (nextVertices[i] - prev) * percent - deform[i]) * alpha;
-					}
-					break;
-				case MixBlend.add:
-					if (vertexAttachment.bones == null) {
-						// Unweighted vertex positions, with alpha.
-						setupVertices = vertexAttachment.vertices;
-						for (i = 0; i < vertexCount; i++) {
-							prev = prevVertices[i];
-							deform[i] += (prev + (nextVertices[i] - prev) * percent - setupVertices[i]) * alpha;
-						}
-					} else {
-						// Weighted deform offsets, with alpha.
-						for (i = 0; i < vertexCount; i++) {
-							prev = prevVertices[i];
-							deform[i] += (prev + (nextVertices[i] - prev) * percent) * alpha;
-						}
-					}
-				}
-			}
-		}
-	}
-}

spine-as3/spine-as3/src/spine/animation/DrawOrderTimeline.as

@@ -1,88 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine.animation {
-	import spine.Event;
-	import spine.Skeleton;
-	import spine.Slot;
-
-	public class DrawOrderTimeline extends Timeline {
-		public var drawOrders : Vector.<Vector.<int>>;
-
-		public function DrawOrderTimeline(frameCount : int) {
-			super(frameCount, [
-				Property.drawOrder
-			]);
-			drawOrders = new Vector.<Vector.<int>>(frameCount, true);
-		}
-
-		public function get frameCount() : int {
-			return frames.length;
-		}
-
-		/** Sets the time in seconds and the draw order for the specified key frame.
-		 * @param drawOrder For each slot in {@link Skeleton#slots}, the index of the new draw order. May be null to use setup pose
-		 *           draw order. */
-		public function setFrame(frame : int, time : Number, drawOrder : Vector.<int>) : void {
-			frames[frame] = time;
-			drawOrders[frame] = drawOrder;
-		}
-
-		public override function apply (skeleton : Skeleton, lastTime : Number, time : Number, events : Vector.<Event>, alpha : Number, blend : MixBlend, direction : MixDirection) : void {
-			var drawOrder: Vector.<Slot> = skeleton.drawOrder;
-			var slots : Vector.<Slot> = skeleton.slots;
-			var i : int = 0, n : int = slots.length;
-		
-			if (direction == MixDirection.mixOut) {
-				if (blend == MixBlend.setup) {
-					for (i = 0; i < n; i++)
-						drawOrder[i] = slots[i];
-				}
-				return;
-			}
-
-			if (time < frames[0]) {
-				if (blend == MixBlend.setup || blend == MixBlend.first) {
-					for (i = 0; i < n; i++)
-						drawOrder[i] = slots[i];
-				}
-				return;
-			}
-
-			var drawOrderToSetupIndex : Vector.<int> = drawOrders[search1(frames, time)];
-			if (drawOrderToSetupIndex == null) {
-				for (i = 0; i < n; i++)
-					drawOrder[i] = slots[i];
-			} else {
-				for (i = 0; i < n; i++)
-					drawOrder[i] = slots[drawOrderToSetupIndex[i]];
-			}
-		}
-	}
-}

spine-as3/spine-as3/src/spine/animation/EventQueue.as

@@ -1,121 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine.animation {
-	import spine.Event;
-
-	public class EventQueue {
-		internal var objects : Vector.<Object> = new Vector.<Object>();
-		internal var animationState : AnimationState;
-		public var drainDisabled : Boolean;
-
-		public function EventQueue(animationState : AnimationState) {
-			this.animationState = animationState;
-		}
-
-		public function start(entry : TrackEntry) : void {
-			objects.push(EventType.start);
-			objects.push(entry);
-			animationState.animationsChanged = true;
-		}
-
-		public function interrupt(entry : TrackEntry) : void {
-			objects.push(EventType.interrupt);
-			objects.push(entry);
-		}
-
-		public function end(entry : TrackEntry) : void {
-			objects.push(EventType.end);
-			objects.push(entry);
-			animationState.animationsChanged = true;
-		}
-
-		public function dispose(entry : TrackEntry) : void {
-			objects.push(EventType.dispose);
-			objects.push(entry);
-		}
-
-		public function complete(entry : TrackEntry) : void {
-			objects.push(EventType.complete);
-			objects.push(entry);
-		}
-
-		public function event(entry : TrackEntry, event : Event) : void {
-			objects.push(EventType.event);
-			objects.push(entry);
-			objects.push(event);
-		}
-
-		public function drain() : void {
-			if (drainDisabled) return; // Not reentrant.
-			drainDisabled = true;
-
-			var objects : Vector.<Object> = this.objects;
-			for (var i : int = 0; i < objects.length; i += 2) {
-				var type : EventType = EventType(objects[i]);
-				var entry : TrackEntry = TrackEntry(objects[i + 1]);
-				switch (type) {
-					case EventType.start:
-						entry.onStart.invoke(entry);
-						animationState.onStart.invoke(entry);
-						break;
-					case EventType.interrupt:
-						entry.onInterrupt.invoke(entry);
-						animationState.onInterrupt.invoke(entry);
-						break;
-					case EventType.end:
-						entry.onEnd.invoke(entry);
-						animationState.onEnd.invoke(entry);
-					// Fall through.
-					case EventType.dispose:
-						entry.onDispose.invoke(entry);
-						animationState.onDispose.invoke(entry);
-						animationState.trackEntryPool.free(entry);
-						break;
-					case EventType.complete:
-						entry.onComplete.invoke(entry);
-						animationState.onComplete.invoke(entry);
-						break;
-					case EventType.event:
-						var event : Event = Event(objects[i++ + 2]);
-						entry.onEvent.invoke(entry, event);
-						animationState.onEvent.invoke(entry, event);
-						break;
-				}
-			}
-			clear();
-
-			drainDisabled = false;
-		}
-
-		public function clear() : void {
-			objects.length = 0;
-		}
-	}
-}

spine-as3/spine-as3/src/spine/animation/EventTimeline.as

@@ -1,83 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine.animation {
-	import spine.Event;
-	import spine.Skeleton;
-
-	public class EventTimeline extends Timeline {
-		public var events : Vector.<Event>;
-
-		public function EventTimeline(frameCount : int) {
-			super(frameCount, [
-				Property.event
-			]);
-			events = new Vector.<Event>(frameCount, true);
-		}
-
-		public override function getFrameCount () : int {
-			return frames.length;
-		}
-
-		/** Sets the time in seconds and the event for the specified key frame. */
-		public function setFrame (frame : int, event : Event) : void {
-			frames[frame] = event.time;
-			events[frame] = event;
-		}
-
-		/** Fires events for frames > `lastTime` and <= `time`. */
-		public override function apply (skeleton : Skeleton, lastTime : Number, time : Number, firedEvents : Vector.<Event>, alpha : Number, blend : MixBlend, direction : MixDirection) : void {
-			if (firedEvents == null) return;
-
-			var frames : Vector.<Number> = this.frames;
-			var frameCount : int = frames.length;
-
-			if (lastTime > time) { // Fire events after last time for looped animations.
-				apply(skeleton, lastTime, Number.MAX_VALUE, firedEvents, alpha, blend, direction);
-				lastTime = -1;
-			} else if (lastTime >= frames[frameCount - 1]) // Last time is after last frame.
-				return;
-			if (time < frames[0]) return; // Time is before first frame.
-
-			var i : int = 0;
-			if (lastTime < frames[0])
-				i = 0;
-			else {
-				i = search1(frames, lastTime) + 1;
-				var frameTime : Number = frames[i];
-				while (i > 0) { // Fire multiple events with the same frame.
-					if (frames[i - 1] != frameTime) break;
-					i--;
-				}
-			}
-			for (; i < frameCount && time >= frames[i]; i++)
-				firedEvents.push(events[i]);
-		}
-	}
-}

spine-as3/spine-as3/src/spine/animation/EventType.as

@@ -1,39 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine.animation {
-	public class EventType {
-		public static const start : EventType = new EventType();
-		public static const interrupt : EventType = new EventType();
-		public static const end : EventType = new EventType();
-		public static const dispose : EventType = new EventType();
-		public static const complete : EventType = new EventType();
-		public static const event : EventType = new EventType();
-	}
-}

spine-as3/spine-as3/src/spine/animation/IkConstraintTimeline.as

@@ -1,133 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine.animation {
-	import spine.Event;
-	import spine.IkConstraint;
-	import spine.Skeleton;
-
-	public class IkConstraintTimeline extends CurveTimeline {
-		static internal const ENTRIES : int = 6;
-		static internal const MIX : int = 1, SOFTNESS : int = 2, BEND_DIRECTION : int = 3, COMPRESS : int = 4, STRETCH : int = 5;
-
-		/** The index of the IK constraint slot in {@link Skeleton#ikConstraints} that will be changed. */
-		public var ikConstraintIndex : int;
-
-		public function IkConstraintTimeline(frameCount : int, bezierCount : int, ikConstraintIndex : int) {
-			super(frameCount, bezierCount, [
-				Property.ikConstraint + "|" + ikConstraintIndex
-			]);
-			this.ikConstraintIndex = ikConstraintIndex;
-		}
-
-		public override function getFrameEntries() : int {
-			return ENTRIES;
-		}
-
-		/** Sets the time in seconds, mix, softness, bend direction, compress, and stretch for the specified key frame. */
-		public function setFrame (frame : int, time : Number, mix : Number, softness : Number, bendDirection : int, compress: Boolean, stretch : Boolean) : void {
-			frame *= ENTRIES;
-			frames[frame] = time;
-			frames[frame + MIX] = mix;
-			frames[frame + SOFTNESS] = softness;
-			frames[frame + BEND_DIRECTION] = bendDirection;
-			frames[frame + COMPRESS] = compress ? 1 : 0;
-			frames[frame + STRETCH] = stretch ? 1 : 0;
-		}
-
-		public override function apply (skeleton : Skeleton, lastTime : Number, time : Number, events : Vector.<Event>, alpha : Number, blend : MixBlend, direction : MixDirection) : void {
-			var constraint : IkConstraint = skeleton.ikConstraints[ikConstraintIndex];
-			if (!constraint.active) return;
-
-			var frames : Vector.<Number> = this.frames;
-			if (time < frames[0]) {
-				switch (blend) {
-				case MixBlend.setup:
-					constraint.mix = constraint.data.mix;
-					constraint.softness = constraint.data.softness;
-					constraint.bendDirection = constraint.data.bendDirection;
-					constraint.compress = constraint.data.compress;
-					constraint.stretch = constraint.data.stretch;
-					return;
-				case MixBlend.first:
-					constraint.mix += (constraint.data.mix - constraint.mix) * alpha;
-					constraint.softness += (constraint.data.softness - constraint.softness) * alpha;
-					constraint.bendDirection = constraint.data.bendDirection;
-					constraint.compress = constraint.data.compress;
-					constraint.stretch = constraint.data.stretch;
-				}
-				return;
-			}
-
-			var mix : Number = 0, softness : Number = 0;
-			var i : int = search(frames, time, ENTRIES)
-			var curveType : Number = curves[i / ENTRIES];
-			switch (curveType) {
-			case LINEAR:
-				var before : Number = frames[i];
-				mix = frames[i + MIX];
-				softness = frames[i + SOFTNESS];
-				var t : Number = (time - before) / (frames[i + ENTRIES] - before);
-				mix += (frames[i + ENTRIES + MIX] - mix) * t;
-				softness += (frames[i + ENTRIES + SOFTNESS] - softness) * t;
-				break;
-			case STEPPED:
-				mix = frames[i + MIX];
-				softness = frames[i + SOFTNESS];
-				break;
-			default:
-				mix = getBezierValue(time, i, MIX, curveType - BEZIER);
-				softness = getBezierValue(time, i, SOFTNESS, curveType + BEZIER_SIZE - BEZIER);
-			}
-
-			if (blend == MixBlend.setup) {
-				constraint.mix = constraint.data.mix + (mix - constraint.data.mix) * alpha;
-				constraint.softness = constraint.data.softness + (softness - constraint.data.softness) * alpha;
-
-				if (direction == MixDirection.mixOut) {
-					constraint.bendDirection = constraint.data.bendDirection;
-					constraint.compress = constraint.data.compress;
-					constraint.stretch = constraint.data.stretch;
-				} else {
-					constraint.bendDirection = frames[i + BEND_DIRECTION];
-					constraint.compress = frames[i + COMPRESS] != 0;
-					constraint.stretch = frames[i + STRETCH] != 0;
-				}
-			} else {
-				constraint.mix += (mix - constraint.mix) * alpha;
-				constraint.softness += (softness - constraint.softness) * alpha;
-				if (direction == MixDirection.mixIn) {
-					constraint.bendDirection = frames[i + BEND_DIRECTION];
-					constraint.compress = frames[i + COMPRESS] != 0;
-					constraint.stretch = frames[i + STRETCH] != 0;
-				}
-			}
-		}
-	}
-}

spine-as3/spine-as3/src/spine/animation/Listeners.as

@@ -1,62 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine.animation {
-	public class Listeners {
-		private var _listeners : Vector.<Function> = new Vector.<Function>();
-
-		public function Listeners() {
-		}
-
-		public function get listeners() : Vector.<Function> {
-			return _listeners;
-		}
-
-		public function add(listener : Function) : void {
-			if (listener == null)
-				throw new ArgumentError("listener cannot be null.");
-			var indexOf : int = _listeners.indexOf(listener);
-			if (indexOf == -1)
-				_listeners[_listeners.length] = listener;
-		}
-
-		public function remove(listener : Function) : void {
-			if (listener == null)
-				throw new ArgumentError("listener cannot be null.");
-			var indexOf : int = _listeners.indexOf(listener);
-			if (indexOf != -1)
-				_listeners.splice(_listeners.indexOf(listener), 1);
-		}
-
-		public function invoke(... args : *) : void {
-			for each (var listener : Function in _listeners)
-				listener.apply(null, args);
-		}
-	}
-}

spine-as3/spine-as3/src/spine/animation/MixBlend.as

@@ -1,43 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine.animation {
-	public class MixBlend {
-		public var ordinal : int;
-
-		public function MixBlend(ordinal : int) {
-			this.ordinal = ordinal;
-		}
-
-		public static const setup : MixBlend = new MixBlend(0);
-		public static const first : MixBlend = new MixBlend(1);
-		public static const replace : MixBlend = new MixBlend(2);
-		public static const add : MixBlend = new MixBlend(3);
-	}
-}

spine-as3/spine-as3/src/spine/animation/MixDirection.as

@@ -1,41 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine.animation {
-	public class MixDirection {
-		public var ordinal : int;
-
-		public function MixDirection(ordinal : int) {
-			this.ordinal = ordinal;
-		}
-
-		public static const mixIn : MixDirection = new MixDirection(0);
-		public static const mixOut : MixDirection = new MixDirection(1);
-	}
-}

spine-as3/spine-as3/src/spine/animation/PathConstraintMixTimeline.as

@@ -1,122 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine.animation {
-	import spine.Event;
-	import spine.Skeleton;
-	import spine.PathConstraint;
-	import spine.PathConstraintData;
-	
-	public class PathConstraintMixTimeline extends CurveTimeline {
-		static internal const ENTRIES : int = 4;
-		static internal const ROTATE : int = 1, X : int = 2, Y : int = 3;
-
-		/** The index of the path constraint slot in {@link Skeleton#getPathConstraints()} that will be changed. */
-		public var pathConstraintIndex : int;
-
-		public function PathConstraintMixTimeline (frameCount : int, bezierCount : int, pathConstraintIndex : int) {
-			super(frameCount, bezierCount, [
-				Property.pathConstraintMix + "|" + pathConstraintIndex
-			]);
-			this.pathConstraintIndex = pathConstraintIndex;
-		}
-
-		public override function getFrameEntries() : int {
-			return ENTRIES;
-		}
-
-		public function setFrame (frame : int, time : Number, mixRotate : Number, mixX : Number, mixY : Number) : void {
-			frame <<= 2;
-			frames[frame] = time;
-			frames[frame + ROTATE] = mixRotate;
-			frames[frame + X] = mixX;
-			frames[frame + Y] = mixY;
-		}
-
-		public override function apply (skeleton : Skeleton, lastTime : Number, time : Number, events : Vector.<Event>, alpha : Number, blend : MixBlend, direction : MixDirection) : void {
-			var constraint : PathConstraint = skeleton.pathConstraints[pathConstraintIndex];
-			if (!constraint.active) return;
-
-			var data : PathConstraintData;
-
-			var frames : Vector.<Number> = this.frames;
-			if (time < frames[0]) {
-				data = constraint.data;
-				switch (blend) {
-				case MixBlend.setup:
-					constraint.mixRotate = data.mixRotate;
-					constraint.mixX = data.mixX;
-					constraint.mixY = data.mixY;
-					return;
-				case MixBlend.first:
-					constraint.mixRotate += (data.mixRotate - constraint.mixRotate) * alpha;
-					constraint.mixX += (data.mixX - constraint.mixX) * alpha;
-					constraint.mixY += (data.mixY - constraint.mixY) * alpha;
-				}
-				return;
-			}
-
-			var rotate : Number, x : Number, y : Number;
-			var i : int = search(frames, time, ENTRIES);
-			var curveType : Number = curves[i >> 2];
-			switch (curveType) {
-			case LINEAR:
-				var before : Number = frames[i];
-				rotate = frames[i + ROTATE];
-				x = frames[i + X];
-				y = frames[i + Y];
-				var t : Number = (time - before) / (frames[i + ENTRIES] - before);
-				rotate += (frames[i + ENTRIES + ROTATE] - rotate) * t;
-				x += (frames[i + ENTRIES + X] - x) * t;
-				y += (frames[i + ENTRIES + Y] - y) * t;
-				break;
-			case STEPPED:
-				rotate = frames[i + ROTATE];
-				x = frames[i + X];
-				y = frames[i + Y];
-				break;
-			default:
-				rotate = getBezierValue(time, i, ROTATE, curveType - BEZIER);
-				x = getBezierValue(time, i, X, curveType + BEZIER_SIZE - BEZIER);
-				y = getBezierValue(time, i, Y, curveType + BEZIER_SIZE * 2 - BEZIER);
-			}
-
-			if (blend == MixBlend.setup) {
-				data = constraint.data;
-				constraint.mixRotate = data.mixRotate + (rotate - data.mixRotate) * alpha;
-				constraint.mixX = data.mixX + (x - data.mixX) * alpha;
-				constraint.mixY = data.mixY + (y - data.mixY) * alpha;
-			} else {
-				constraint.mixRotate += (rotate - constraint.mixRotate) * alpha;
-				constraint.mixX += (x - constraint.mixX) * alpha;
-				constraint.mixY += (y - constraint.mixY) * alpha;
-			}
-		}
-	}
-}

spine-as3/spine-as3/src/spine/animation/PathConstraintPositionTimeline.as

@@ -1,68 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine.animation {
-	import spine.PathConstraint;
-	import spine.Event;
-	import spine.Skeleton;
-
-	public class PathConstraintPositionTimeline extends CurveTimeline1 {
-		/** The index of the path constraint slot in {@link Skeleton#pathConstraints} that will be changed. */
-		public var pathConstraintIndex : int;
-
-		public function PathConstraintPositionTimeline (frameCount : int, bezierCount : int, pathConstraintIndex : int) {
-			super(frameCount, bezierCount, Property.pathConstraintPosition + "|" + pathConstraintIndex);
-			this.pathConstraintIndex = pathConstraintIndex;
-		}
-
-		public override function apply (skeleton : Skeleton, lastTime : Number, time : Number, events : Vector.<Event>, alpha : Number, blend : MixBlend, direction : MixDirection) : void {
-			var constraint : PathConstraint = skeleton.pathConstraints[pathConstraintIndex];
-			if (!constraint.active) return;
-
-			var frames : Vector.<Number> = this.frames;
-			if (time < frames[0]) {
-				switch (blend) {
-				case MixBlend.setup:
-					constraint.position = constraint.data.position;
-					return;
-				case MixBlend.first:
-					constraint.position += (constraint.data.position - constraint.position) * alpha;
-				}
-				return;
-			}
-
-			var position : Number = getCurveValue(time);
-
-			if (blend == MixBlend.setup)
-				constraint.position = constraint.data.position + (position - constraint.data.position) * alpha;
-			else
-				constraint.position += (position - constraint.position) * alpha;
-		}
-	}
-}

spine-as3/spine-as3/src/spine/animation/PathConstraintSpacingTimeline.as

@@ -1,68 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine.animation {
-	import spine.Skeleton;
-	import spine.Event;
-	import spine.PathConstraint;
-
-	public class PathConstraintSpacingTimeline extends CurveTimeline1 {
-		/** The index of the path constraint slot in {@link Skeleton#pathConstraints} that will be changed. */
-		public var pathConstraintIndex : int;
-
-		public function PathConstraintSpacingTimeline (frameCount : int, bezierCount : int, pathConstraintIndex : int) {
-			super(frameCount, bezierCount, Property.pathConstraintSpacing + "|" + pathConstraintIndex);
-			this.pathConstraintIndex = pathConstraintIndex;
-		}
-
-		public override function apply (skeleton : Skeleton, lastTime : Number, time : Number, events : Vector.<Event>, alpha : Number, blend : MixBlend, direction : MixDirection) : void {
-			var constraint : PathConstraint = skeleton.pathConstraints[pathConstraintIndex];
-			if (!constraint.active) return;
-
-			var frames : Vector.<Number> = this.frames;
-			if (time < frames[0]) {
-				switch (blend) {
-				case MixBlend.setup:
-					constraint.spacing = constraint.data.spacing;
-					return;
-				case MixBlend.first:
-					constraint.spacing += (constraint.data.spacing - constraint.spacing) * alpha;
-				}
-				return;
-			}
-
-			var spacing : Number = getCurveValue(time);
-
-			if (blend == MixBlend.setup)
-				constraint.spacing = constraint.data.spacing + (spacing - constraint.data.spacing) * alpha;
-			else
-				constraint.spacing += (spacing - constraint.spacing) * alpha;
-		}
-	}
-}

spine-as3/spine-as3/src/spine/animation/Property.as

@@ -1,57 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine.animation {
-	public class Property {
-		public static const rotate : int = 0;
-		public static const x : int = 1;
-		public static const y : int = 2;
-		public static const scaleX : int = 3;
-		public static const scaleY : int = 4;
-		public static const shearX : int = 5;
-		public static const shearY : int = 6;
-
-		public static const rgb : int = 7;
-		public static const alpha : int = 8;
-		public static const rgb2 : int = 9;
-
-		public static const attachment : int = 10;
-		public static const deform : int = 11;
-
-		public static const event : int = 12;
-		public static const drawOrder : int = 13;
-
-		public static const ikConstraint : int = 14;
-		public static const transformConstraint : int = 15;
-
-		public static const pathConstraintPosition : int = 16;
-		public static const pathConstraintSpacing : int = 17;
-		public static const pathConstraintMix : int = 18;
-	}
-}

spine-as3/spine-as3/src/spine/animation/RGB2Timeline.as

@@ -1,169 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine.animation {
-	import spine.Color;
-	import spine.Event;
-	import spine.Skeleton;
-	import spine.Slot;
-
-	public class RGB2Timeline extends CurveTimeline implements SlotTimeline {
-		static internal const ENTRIES : Number = 7;
-		static internal const R : Number = 1;
-		static internal const G : Number = 2;
-		static internal const B : Number = 3;
-		static internal const R2 : Number = 4;
-		static internal const G2 : Number = 5;
-		static internal const B2 : Number = 6;
-
-		private var slotIndex : int;
-
-		public function RGB2Timeline (frameCount : Number, bezierCount : Number, slotIndex : Number) {
-			super(frameCount, bezierCount, [
-				Property.rgb + "|" + slotIndex,
-				Property.rgb2 + "|" + slotIndex
-			]);
-			this.slotIndex = slotIndex;
-		}
-
-		public override function getFrameEntries() : int {
-			return ENTRIES;
-		}
-
-		public function getSlotIndex() : int {
-			return slotIndex;
-		}
-
-		/** Sets the time in seconds, light, and dark colors for the specified key frame. */
-		public function setFrame (frame: Number, time: Number, r: Number, g: Number, b: Number, r2: Number, g2: Number, b2: Number) : void {
-			frame *= ENTRIES;
-			frames[frame] = time;
-			frames[frame + R] = r;
-			frames[frame + G] = g;
-			frames[frame + B] = b;
-			frames[frame + R2] = r2;
-			frames[frame + G2] = g2;
-			frames[frame + B2] = b2;
-		}
-
-		public override function apply (skeleton : Skeleton, lastTime : Number, time : Number, events : Vector.<Event>, alpha : Number, blend : MixBlend, direction : MixDirection) : void {
-			var slot : Slot = skeleton.slots[slotIndex];
-			if (!slot.bone.active) return;
-
-			var frames : Vector.<Number> = this.frames;
-			var light : Color = slot.color, dark : Color = slot.darkColor;
-			var setupLight : Color, setupDark : Color;
-			if (time < frames[0]) {
-				setupLight = slot.data.color;
-				setupDark = slot.data.darkColor;
-				switch (blend) {
-				case MixBlend.setup:
-					light.r = setupLight.r;
-					light.g = setupLight.g;
-					light.b = setupLight.b;
-					dark.r = setupDark.r;
-					dark.g = setupDark.g;
-					dark.b = setupDark.b;
-					return;
-				case MixBlend.first:
-					light.r += (setupLight.r - light.r) * alpha;
-					light.g += (setupLight.g - light.g) * alpha;
-					light.b += (setupLight.b - light.b) * alpha;
-					dark.r += (setupDark.r - dark.r) * alpha;
-					dark.g += (setupDark.g - dark.g) * alpha;
-					dark.b += (setupDark.b - dark.b) * alpha;
-				}
-				return;
-			}
-
-			var r : Number = 0, g : Number = 0, b : Number = 0, a : Number = 0, r2 : Number = 0, g2 : Number = 0, b2 : Number = 0;
-			var i : int = search(frames, time, ENTRIES);
-			var curveType : Number = curves[i / ENTRIES];
-			switch (curveType) {
-			case LINEAR:
-				var before : Number = frames[i];
-				r = frames[i + R];
-				g = frames[i + G];
-				b = frames[i + B];
-				r2 = frames[i + R2];
-				g2 = frames[i + G2];
-				b2 = frames[i + B2];
-				var t : Number = (time - before) / (frames[i + ENTRIES] - before);
-				r += (frames[i + ENTRIES + R] - r) * t;
-				g += (frames[i + ENTRIES + G] - g) * t;
-				b += (frames[i + ENTRIES + B] - b) * t;
-				r2 += (frames[i + ENTRIES + R2] - r2) * t;
-				g2 += (frames[i + ENTRIES + G2] - g2) * t;
-				b2 += (frames[i + ENTRIES + B2] - b2) * t;
-				break;
-			case STEPPED:
-				r = frames[i + R];
-				g = frames[i + G];
-				b = frames[i + B];
-				r2 = frames[i + R2];
-				g2 = frames[i + G2];
-				b2 = frames[i + B2];
-				break;
-			default:
-				r = getBezierValue(time, i, R, curveType - BEZIER);
-				g = getBezierValue(time, i, G, curveType + BEZIER_SIZE - BEZIER);
-				b = getBezierValue(time, i, B, curveType + BEZIER_SIZE * 2 - BEZIER);
-				r2 = getBezierValue(time, i, R2, curveType + BEZIER_SIZE * 3 - BEZIER);
-				g2 = getBezierValue(time, i, G2, curveType + BEZIER_SIZE * 4 - BEZIER);
-				b2 = getBezierValue(time, i, B2, curveType + BEZIER_SIZE * 5 - BEZIER);
-			}
-
-			if (alpha == 1) {
-				light.r = r;
-				light.g = g;
-				light.b = b;
-				dark.r = r2;
-				dark.g = g2;
-				dark.b = b2;
-			} else {
-				if (blend == MixBlend.setup) {
-					setupLight = slot.data.color;
-					setupDark = slot.data.darkColor;
-					light.r = setupLight.r;
-					light.g = setupLight.g;
-					light.b = setupLight.b;
-					dark.r = setupDark.r;
-					dark.g = setupDark.g;
-					dark.b = setupDark.b;
-				}
-				light.r += (r - light.r) * alpha;
-				light.g += (g - light.g) * alpha;
-				light.b += (b - light.b) * alpha;
-				dark.r += (r2 - dark.r) * alpha;
-				dark.g += (g2 - dark.g) * alpha;
-				dark.b += (b2 - dark.b) * alpha;
-			}
-		}
-	}
-}

spine-as3/spine-as3/src/spine/animation/RGBA2Timeline.as

@@ -1,161 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine.animation {
-	import spine.Color;
-	import spine.Event;
-	import spine.Skeleton;
-	import spine.Slot;
-
-	public class RGBA2Timeline extends CurveTimeline implements SlotTimeline {
-		static internal const ENTRIES : Number = 8;
-		static internal const R : Number = 1;
-		static internal const G : Number = 2;
-		static internal const B : Number = 3;
-		static internal const A : Number = 4;
-		static internal const R2 : Number = 5;
-		static internal const G2 : Number = 6;
-		static internal const B2 : Number = 7;
-
-		private var slotIndex : int;
-
-		public function RGBA2Timeline (frameCount : Number, bezierCount : Number, slotIndex : Number) {
-			super(frameCount, bezierCount, [
-				Property.rgb + "|" + slotIndex,
-				Property.alpha + "|" + slotIndex,
-				Property.rgb2 + "|" + slotIndex
-			]);
-			this.slotIndex = slotIndex;
-		}
-
-		public override function getFrameEntries() : int {
-			return ENTRIES;
-		}
-
-		public function getSlotIndex() : int {
-			return slotIndex;
-		}
-
-		/** Sets the time in seconds, light, and dark colors for the specified key frame. */
-		public function setFrame (frame: Number, time: Number, r: Number, g: Number, b: Number, a: Number, r2: Number, g2: Number, b2: Number) : void {
-			frame <<= 3;
-			frames[frame] = time;
-			frames[frame + R] = r;
-			frames[frame + G] = g;
-			frames[frame + B] = b;
-			frames[frame + A] = a;
-			frames[frame + R2] = r2;
-			frames[frame + G2] = g2;
-			frames[frame + B2] = b2;
-		}
-
-		public override function apply (skeleton : Skeleton, lastTime : Number, time : Number, events : Vector.<Event>, alpha : Number, blend : MixBlend, direction : MixDirection) : void {
-			var slot : Slot = skeleton.slots[slotIndex];
-			if (!slot.bone.active) return;
-
-			var frames : Vector.<Number> = this.frames;
-			var light : Color = slot.color, dark : Color = slot.darkColor;
-			if (time < frames[0]) {
-				var setupLight : Color = slot.data.color, setupDark : Color = slot.data.darkColor;
-				switch (blend) {
-				case MixBlend.setup:
-					light.setFromColor(setupLight);
-					dark.r = setupDark.r;
-					dark.g = setupDark.g;
-					dark.b = setupDark.b;
-					return;
-				case MixBlend.first:
-					light.add((setupLight.r - light.r) * alpha, (setupLight.g - light.g) * alpha, (setupLight.b - light.b) * alpha,
-						(setupLight.a - light.a) * alpha);
-					dark.r += (setupDark.r - dark.r) * alpha;
-					dark.g += (setupDark.g - dark.g) * alpha;
-					dark.b += (setupDark.b - dark.b) * alpha;
-				}
-				return;
-			}
-
-			var r : Number = 0, g : Number = 0, b : Number = 0, a : Number = 0, r2 : Number = 0, g2 : Number = 0, b2 : Number = 0;
-			var i : int = search(frames, time, ENTRIES);
-			var curveType : Number = curves[i >> 3];
-			switch (curveType) {
-			case LINEAR:
-				var before : Number = frames[i];
-				r = frames[i + R];
-				g = frames[i + G];
-				b = frames[i + B];
-				a = frames[i + A];
-				r2 = frames[i + R2];
-				g2 = frames[i + G2];
-				b2 = frames[i + B2];
-				var t : Number = (time - before) / (frames[i + ENTRIES] - before);
-				r += (frames[i + ENTRIES + R] - r) * t;
-				g += (frames[i + ENTRIES + G] - g) * t;
-				b += (frames[i + ENTRIES + B] - b) * t;
-				a += (frames[i + ENTRIES + A] - a) * t;
-				r2 += (frames[i + ENTRIES + R2] - r2) * t;
-				g2 += (frames[i + ENTRIES + G2] - g2) * t;
-				b2 += (frames[i + ENTRIES + B2] - b2) * t;
-				break;
-			case STEPPED:
-				r = frames[i + R];
-				g = frames[i + G];
-				b = frames[i + B];
-				a = frames[i + A];
-				r2 = frames[i + R2];
-				g2 = frames[i + G2];
-				b2 = frames[i + B2];
-				break;
-			default:
-				r = getBezierValue(time, i, R, curveType - BEZIER);
-				g = getBezierValue(time, i, G, curveType + BEZIER_SIZE - BEZIER);
-				b = getBezierValue(time, i, B, curveType + BEZIER_SIZE * 2 - BEZIER);
-				a = getBezierValue(time, i, A, curveType + BEZIER_SIZE * 3 - BEZIER);
-				r2 = getBezierValue(time, i, R2, curveType + BEZIER_SIZE * 4 - BEZIER);
-				g2 = getBezierValue(time, i, G2, curveType + BEZIER_SIZE * 5 - BEZIER);
-				b2 = getBezierValue(time, i, B2, curveType + BEZIER_SIZE * 6 - BEZIER);
-			}
-
-			if (alpha == 1) {
-				light.set(r, g, b, a);
-				dark.r = r2;
-				dark.g = g2;
-				dark.b = b2;
-			} else {
-				if (blend == MixBlend.setup) {
-					light.setFromColor(slot.data.color);
-					dark.setFromColor(slot.data.darkColor);
-				}
-				light.add((r - light.r) * alpha, (g - light.g) * alpha, (b - light.b) * alpha, (a - light.a) * alpha);
-				dark.r += (r2 - dark.r) * alpha;
-				dark.g += (g2 - dark.g) * alpha;
-				dark.b += (b2 - dark.b) * alpha;
-			}
-		}
-	}
-}

spine-as3/spine-as3/src/spine/animation/RGBATimeline.as

@@ -1,126 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine.animation {
-	import spine.Color;
-	import spine.Event;
-	import spine.Skeleton;
-	import spine.Slot;
-
-	public class RGBATimeline extends CurveTimeline implements SlotTimeline {
-		static internal const ENTRIES : Number = 5;
-		static internal const R : Number = 1;
-		static internal const G : Number = 2;
-		static internal const B : Number = 3;
-		static internal const A : Number = 4;
-
-		private var slotIndex : int;
-
-		public function RGBATimeline (frameCount : Number, bezierCount : Number, slotIndex : Number) {
-			super(frameCount, bezierCount, [
-				Property.rgb + "|" + slotIndex,
-				Property.alpha + "|" + slotIndex
-			]);
-			this.slotIndex = slotIndex;
-		}
-
-		public override function getFrameEntries() : int {
-			return ENTRIES;
-		}
-
-		public function getSlotIndex() : int {
-			return slotIndex;
-		}
-
-		/** Sets the time in seconds, red, green, blue, and alpha for the specified key frame. */
-		public function setFrame (frame: Number, time: Number, r: Number, g: Number, b: Number, a: Number) : void {
-			frame *= ENTRIES;
-			frames[frame] = time;
-			frames[frame + R] = r;
-			frames[frame + G] = g;
-			frames[frame + B] = b;
-			frames[frame + A] = a;
-		}
-
-		public override function apply (skeleton : Skeleton, lastTime : Number, time : Number, events : Vector.<Event>, alpha : Number, blend : MixBlend, direction : MixDirection) : void {
-			var slot : Slot = skeleton.slots[slotIndex];
-			if (!slot.bone.active) return;
-
-			var frames : Vector.<Number> = this.frames;
-			var color : Color = slot.color;
-			if (time < frames[0]) {
-				var setup : Color = slot.data.color;
-				switch (blend) {
-				case MixBlend.setup:
-					color.setFromColor(setup);
-					return;
-				case MixBlend.first:
-					color.add((setup.r - color.r) * alpha, (setup.g - color.g) * alpha, (setup.b - color.b) * alpha,
-						(setup.a - color.a) * alpha);
-				}
-				return;
-			}
-
-			var r : Number = 0, g : Number = 0, b : Number = 0, a : Number = 0;
-			var i : int = search(frames, time, ENTRIES);
-			var curveType : Number = curves[i / ENTRIES];
-			switch (curveType) {
-			case LINEAR:
-				var before : Number = frames[i];
-				r = frames[i + R];
-				g = frames[i + G];
-				b = frames[i + B];
-				a = frames[i + A];
-				var t : Number = (time - before) / (frames[i + ENTRIES] - before);
-				r += (frames[i + ENTRIES + R] - r) * t;
-				g += (frames[i + ENTRIES + G] - g) * t;
-				b += (frames[i + ENTRIES + B] - b) * t;
-				a += (frames[i + ENTRIES + A] - a) * t;
-				break;
-			case STEPPED:
-				r = frames[i + R];
-				g = frames[i + G];
-				b = frames[i + B];
-				a = frames[i + A];
-				break;
-			default:
-				r = getBezierValue(time, i, R, curveType - BEZIER);
-				g = getBezierValue(time, i, G, curveType + BEZIER_SIZE - BEZIER);
-				b = getBezierValue(time, i, B, curveType + BEZIER_SIZE * 2 - BEZIER);
-				a = getBezierValue(time, i, A, curveType + BEZIER_SIZE * 3 - BEZIER);
-			}
-			if (alpha == 1)
-				color.set(r, g, b, a);
-			else {
-				if (blend == MixBlend.setup) color.setFromColor(slot.data.color);
-				color.add((r - color.r) * alpha, (g - color.g) * alpha, (b - color.b) * alpha, (a - color.a) * alpha);
-			}
-		}
-	}
-}

spine-as3/spine-as3/src/spine/animation/RGBTimeline.as

@@ -1,131 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine.animation {
-	import spine.Color;
-	import spine.Event;
-	import spine.Skeleton;
-	import spine.Slot;
-
-	public class RGBTimeline extends CurveTimeline implements SlotTimeline {
-		static internal const ENTRIES : Number = 4;
-		static internal const R : Number = 1;
-		static internal const G : Number = 2;
-		static internal const B : Number = 3;
-
-		private var slotIndex : int;
-
-		public function RGBTimeline (frameCount : Number, bezierCount : Number, slotIndex : Number) {
-			super(frameCount, bezierCount, [
-				Property.rgb + "|" + slotIndex
-			]);
-			this.slotIndex = slotIndex;
-		}
-
-		public override function getFrameEntries() : int {
-			return ENTRIES;
-		}
-
-		public function getSlotIndex() : int {
-			return slotIndex;
-		}
-
-		/** Sets the time in seconds, red, green, and blue for the specified key frame. */
-		public function setFrame (frame: Number, time: Number, r: Number, g: Number, b: Number) : void {
-			frame <<= 2;
-			frames[frame] = time;
-			frames[frame + R] = r;
-			frames[frame + G] = g;
-			frames[frame + B] = b;
-		}
-
-		public override function apply (skeleton : Skeleton, lastTime : Number, time : Number, events : Vector.<Event>, alpha : Number, blend : MixBlend, direction : MixDirection) : void {
-			var slot : Slot = skeleton.slots[slotIndex];
-			if (!slot.bone.active) return;
-
-			var frames : Vector.<Number> = this.frames;
-			var color : Color = slot.color, setup : Color;
-			if (time < frames[0]) {
-				setup = slot.data.color;
-				switch (blend) {
-				case MixBlend.setup:
-					color.r = setup.r;
-					color.g = setup.g;
-					color.b = setup.b;
-					return;
-				case MixBlend.first:
-					color.r += (setup.r - color.r) * alpha;
-					color.g += (setup.g - color.g) * alpha;
-					color.b += (setup.b - color.b) * alpha;
-				}
-				return;
-			}
-
-			var r : Number = 0, g : Number = 0, b : Number = 0;
-			var i : int = search(frames, time, ENTRIES);
-			var curveType : Number = curves[i / ENTRIES];
-			switch (curveType) {
-			case LINEAR:
-				var before : Number = frames[i];
-				r = frames[i + R];
-				g = frames[i + G];
-				b = frames[i + B];
-				var t : Number = (time - before) / (frames[i + ENTRIES] - before);
-				r += (frames[i + ENTRIES + R] - r) * t;
-				g += (frames[i + ENTRIES + G] - g) * t;
-				b += (frames[i + ENTRIES + B] - b) * t;
-				break;
-			case STEPPED:
-				r = frames[i + R];
-				g = frames[i + G];
-				b = frames[i + B];
-				break;
-			default:
-				r = getBezierValue(time, i, R, curveType - BEZIER);
-				g = getBezierValue(time, i, G, curveType + BEZIER_SIZE - BEZIER);
-				b = getBezierValue(time, i, B, curveType + BEZIER_SIZE * 2 - BEZIER);
-			}
-			if (alpha == 1) {
-				color.r = r;
-				color.g = g;
-				color.b = b;
-			} else {
-				if (blend == MixBlend.setup) {
-					setup = slot.data.color;
-					color.r = setup.r;
-					color.g = setup.g;
-					color.b = setup.b;
-				}
-				color.r += (r - color.r) * alpha;
-				color.g += (g - color.g) * alpha;
-				color.b += (b - color.b) * alpha;
-			}
-		}
-	}
-}

spine-as3/spine-as3/src/spine/animation/RotateTimeline.as

@@ -1,76 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine.animation {
-	import spine.Bone;
-	import spine.Event;
-	import spine.Skeleton;
-
-	public class RotateTimeline extends CurveTimeline1 implements BoneTimeline {
-		private var boneIndex : int;
-
-		public function RotateTimeline(frameCount : int, bezierCount : int, boneIndex : int) {
-			super(frameCount, bezierCount, Property.rotate + "|" + boneIndex);
-			this.boneIndex = boneIndex;
-		}
-
-		public function getBoneIndex() : int {
-			return boneIndex;
-		}
-
-		public override function apply (skeleton : Skeleton, lastTime : Number, time : Number, events : Vector.<Event>, alpha : Number, blend : MixBlend, direction : MixDirection) : void {
-			var bone : Bone = skeleton.bones[boneIndex];
-			if (!bone.active) return;
-
-			var frames : Vector.<Number> = this.frames;
-			if (time < frames[0]) {
-				switch (blend) {
-				case MixBlend.setup:
-					bone.rotation = bone.data.rotation;
-					return;
-				case MixBlend.first:
-					bone.rotation += (bone.data.rotation - bone.rotation) * alpha;
-				}
-				return;
-			}
-
-			var r : Number = getCurveValue(time);
-			switch (blend) {
-			case MixBlend.setup:
-				bone.rotation = bone.data.rotation + r * alpha;
-				break;
-			case MixBlend.first:
-			case MixBlend.replace:
-				r += bone.data.rotation - bone.rotation;
-			case MixBlend.add:
-				bone.rotation += r * alpha;
-			}
-		}
-	}
-}

spine-as3/spine-as3/src/spine/animation/ScaleTimeline.as

@@ -1,144 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine.animation {
-	import spine.MathUtils;
-	import spine.Bone;
-	import spine.Event;
-	import spine.Skeleton;
-
-	public class ScaleTimeline extends CurveTimeline2 implements BoneTimeline {
-		private var boneIndex : int;
-
-		public function ScaleTimeline(frameCount : int, bezierCount : int, boneIndex : int) {
-			super(frameCount, bezierCount,
-				Property.scaleX + "|" + boneIndex,
-				Property.scaleY + "|" + boneIndex
-			);
-			this.boneIndex = boneIndex;
-		}
-
-		public function getBoneIndex() : int {
-			return boneIndex;
-		}
-
-		public override function apply (skeleton : Skeleton, lastTime : Number, time : Number, events : Vector.<Event>, alpha : Number, blend : MixBlend, direction : MixDirection) : void {
-			var bone : Bone = skeleton.bones[boneIndex];
-			if (!bone.active) return;
-
-			var frames : Vector.<Number> = this.frames;
-			if (time < frames[0]) {
-				switch (blend) {
-				case MixBlend.setup:
-					bone.scaleX = bone.data.scaleX;
-					bone.scaleY = bone.data.scaleY;
-					return;
-				case MixBlend.first:
-					bone.scaleX += (bone.data.scaleX - bone.scaleX) * alpha;
-					bone.scaleY += (bone.data.scaleY - bone.scaleY) * alpha;
-				}
-				return;
-			}
-
-			var x : Number, y : Number;
-			var i : int = search(frames, time, ENTRIES);
-			var curveType : Number = curves[i / ENTRIES];
-			switch (curveType) {
-			case LINEAR:
-				var before : Number = frames[i];
-				x = frames[i + VALUE1];
-				y = frames[i + VALUE2];
-				var t : Number = (time - before) / (frames[i + ENTRIES] - before);
-				x += (frames[i + ENTRIES + VALUE1] - x) * t;
-				y += (frames[i + ENTRIES + VALUE2] - y) * t;
-				break;
-			case STEPPED:
-				x = frames[i + VALUE1];
-				y = frames[i + VALUE2];
-				break;
-			default:
-				x = getBezierValue(time, i, VALUE1, curveType - BEZIER);
-				y = getBezierValue(time, i, VALUE2, curveType + BEZIER_SIZE - BEZIER);
-			}
-			x *= bone.data.scaleX;
-			y *= bone.data.scaleY;
-
-			if (alpha == 1) {
-				if (blend == MixBlend.add) {
-					bone.scaleX += x - bone.data.scaleX;
-					bone.scaleY += y - bone.data.scaleY;
-				} else {
-					bone.scaleX = x;
-					bone.scaleY = y;
-				}
-			} else {
-				var bx : Number = 0, by : Number = 0;
-				if (direction == MixDirection.mixOut) {
-					switch (blend) {
-					case MixBlend.setup:
-						bx = bone.data.scaleX;
-						by = bone.data.scaleY;
-						bone.scaleX = bx + (Math.abs(x) * MathUtils.signum(bx) - bx) * alpha;
-						bone.scaleY = by + (Math.abs(y) * MathUtils.signum(by) - by) * alpha;
-						break;
-					case MixBlend.first:
-					case MixBlend.replace:
-						bx = bone.scaleX;
-						by = bone.scaleY;
-						bone.scaleX = bx + (Math.abs(x) * MathUtils.signum(bx) - bx) * alpha;
-						bone.scaleY = by + (Math.abs(y) * MathUtils.signum(by) - by) * alpha;
-						break;
-					case MixBlend.add:
-						bone.scaleX = (x - bone.data.scaleX) * alpha;
-						bone.scaleY = (y - bone.data.scaleY) * alpha;
-					}
-				} else {
-					switch (blend) {
-					case MixBlend.setup:
-						bx = Math.abs(bone.data.scaleX) * MathUtils.signum(x);
-						by = Math.abs(bone.data.scaleY) * MathUtils.signum(y);
-						bone.scaleX = bx + (x - bx) * alpha;
-						bone.scaleY = by + (y - by) * alpha;
-						break;
-					case MixBlend.first:
-					case MixBlend.replace:
-						bx = Math.abs(bone.scaleX) * MathUtils.signum(x);
-						by = Math.abs(bone.scaleY) * MathUtils.signum(y);
-						bone.scaleX = bx + (x - bx) * alpha;
-						bone.scaleY = by + (y - by) * alpha;
-						break;
-					case MixBlend.add:
-						bone.scaleX += (x - bone.data.scaleX) * alpha;
-						bone.scaleY += (y - bone.data.scaleY) * alpha;
-					}
-				}
-			}
-		}
-	}
-}

spine-as3/spine-as3/src/spine/animation/ScaleXTimeline.as

@@ -1,105 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine.animation {
-	import spine.Bone;
-	import spine.Event;
-	import spine.Skeleton;
-	import spine.MathUtils;
-
-	public class ScaleXTimeline extends CurveTimeline1 implements BoneTimeline {
-		private var boneIndex : int;
-
-		public function ScaleXTimeline(frameCount : int, bezierCount : int, boneIndex : int) {
-			super(frameCount, bezierCount, Property.scaleX + "|" + boneIndex);
-			this.boneIndex = boneIndex;
-		}
-
-		public function getBoneIndex() : int {
-			return boneIndex;
-		}
-
-		public override function apply (skeleton : Skeleton, lastTime : Number, time : Number, events : Vector.<Event>, alpha : Number, blend : MixBlend, direction : MixDirection) : void {
-			var bone : Bone = skeleton.bones[boneIndex];
-			if (!bone.active) return;
-
-			var frames : Vector.<Number> = this.frames;
-			if (time < frames[0]) {
-				switch (blend) {
-				case MixBlend.setup:
-					bone.scaleX = bone.data.scaleX;
-					return;
-				case MixBlend.first:
-					bone.scaleX += (bone.data.scaleX - bone.scaleX) * alpha;
-				}
-				return;
-			}
-
-			var x : Number = getCurveValue(time) * bone.data.scaleX;
-			if (alpha == 1) {
-				if (blend == MixBlend.add)
-					bone.scaleX += x - bone.data.scaleX;
-				else
-					bone.scaleX = x;
-			} else {
-				// Mixing out uses sign of setup or current pose, else use sign of key.
-				var bx : Number = 0;
-				if (direction == MixDirection.mixOut) {
-					switch (blend) {
-					case MixBlend.setup:
-						bx = bone.data.scaleX;
-						bone.scaleX = bx + (Math.abs(x) * MathUtils.signum(bx) - bx) * alpha;
-						break;
-					case MixBlend.first:
-					case MixBlend.replace:
-						bx = bone.scaleX;
-						bone.scaleX = bx + (Math.abs(x) * MathUtils.signum(bx) - bx) * alpha;
-						break;
-					case MixBlend.add:
-						bone.scaleX = (x - bone.data.scaleX) * alpha;
-					}
-				} else {
-					switch (blend) {
-					case MixBlend.setup:
-						bx = Math.abs(bone.data.scaleX) * MathUtils.signum(x);
-						bone.scaleX = bx + (x - bx) * alpha;
-						break;
-					case MixBlend.first:
-					case MixBlend.replace:
-						bx = Math.abs(bone.scaleX) * MathUtils.signum(x);
-						bone.scaleX = bx + (x - bx) * alpha;
-						break;
-					case MixBlend.add:
-						bone.scaleX += (x - bone.data.scaleX) * alpha;
-					}
-				}
-			}
-		}
-	}
-}

spine-as3/spine-as3/src/spine/animation/ScaleYTimeline.as

@@ -1,105 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine.animation {
-	import spine.Bone;
-	import spine.Event;
-	import spine.Skeleton;
-	import spine.MathUtils;
-
-	public class ScaleYTimeline extends CurveTimeline1 implements BoneTimeline {
-		private var boneIndex : int;
-
-		public function ScaleYTimeline(frameCount : int, bezierCount : int, boneIndex : int) {
-			super(frameCount, bezierCount, Property.scaleY + "|" + boneIndex);
-			this.boneIndex = boneIndex;
-		}
-
-		public function getBoneIndex() : int {
-			return boneIndex;
-		}
-
-		public override function apply (skeleton : Skeleton, lastTime : Number, time : Number, events : Vector.<Event>, alpha : Number, blend : MixBlend, direction : MixDirection) : void {
-			var bone : Bone = skeleton.bones[boneIndex];
-			if (!bone.active) return;
-
-			var frames : Vector.<Number> = this.frames;
-			if (time < frames[0]) {
-				switch (blend) {
-				case MixBlend.setup:
-					bone.scaleY = bone.data.scaleY;
-					return;
-				case MixBlend.first:
-					bone.scaleY += (bone.data.scaleY - bone.scaleY) * alpha;
-				}
-				return;
-			}
-
-			var y : Number = getCurveValue(time) * bone.data.scaleY;
-			if (alpha == 1) {
-				if (blend == MixBlend.add)
-					bone.scaleY += y - bone.data.scaleY;
-				else
-					bone.scaleY = y;
-			} else {
-				// Mixing out uses sign of setup or current pose, else use sign of key.
-				var by : Number = 0;
-				if (direction == MixDirection.mixOut) {
-					switch (blend) {
-					case MixBlend.setup:
-						by = bone.data.scaleY;
-						bone.scaleY = by + (Math.abs(y) * MathUtils.signum(by) - by) * alpha;
-						break;
-					case MixBlend.first:
-					case MixBlend.replace:
-						by = bone.scaleY;
-						bone.scaleY = by + (Math.abs(y) * MathUtils.signum(by) - by) * alpha;
-						break;
-					case MixBlend.add:
-						bone.scaleY = (y - bone.data.scaleY) * alpha;
-					}
-				} else {
-					switch (blend) {
-					case MixBlend.setup:
-						by = Math.abs(bone.data.scaleY) * MathUtils.signum(y);
-						bone.scaleY = by + (y - by) * alpha;
-						break;
-					case MixBlend.first:
-					case MixBlend.replace:
-						by = Math.abs(bone.scaleY) * MathUtils.signum(y);
-						bone.scaleY = by + (y - by) * alpha;
-						break;
-					case MixBlend.add:
-						bone.scaleY += (y - bone.data.scaleY) * alpha;
-					}
-				}
-			}
-		}
-	}
-}

spine-as3/spine-as3/src/spine/animation/ShearTimeline.as

@@ -1,105 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine.animation {
-	import spine.Event;
-	import spine.Skeleton;
-	import spine.Bone;
-
-	public class ShearTimeline extends CurveTimeline2 implements BoneTimeline {
-		private var boneIndex : int;
-
-		public function ShearTimeline(frameCount : int, bezierCount : int, boneIndex : int) {
-			super(frameCount, bezierCount,
-				Property.shearX + "|" + boneIndex,
-				Property.shearY + "|" + boneIndex
-			);
-			this.boneIndex = boneIndex;
-		}
-
-		public function getBoneIndex() : int {
-			return boneIndex;
-		}
-
-		public override function apply (skeleton : Skeleton, lastTime : Number, time : Number, events : Vector.<Event>, alpha : Number, blend : MixBlend, direction : MixDirection) : void {
-			var bone : Bone = skeleton.bones[boneIndex];
-			if (!bone.active) return;
-
-			var frames : Vector.<Number> = this.frames;
-			if (time < frames[0]) {
-				switch (blend) {
-				case MixBlend.setup:
-					bone.shearX = bone.data.shearX;
-					bone.shearY = bone.data.shearY;
-					return;
-				case MixBlend.first:
-					bone.shearX += (bone.data.shearX - bone.shearX) * alpha;
-					bone.shearY += (bone.data.shearY - bone.shearY) * alpha;
-				}
-				return;
-			}
-
-			var x : Number = 0, y : Number = 0;
-			var i : int = search(frames, time, ENTRIES);
-			var curveType : Number = curves[i / ENTRIES];
-			switch (curveType) {
-			case LINEAR:
-				var before : Number = frames[i];
-				x = frames[i + VALUE1];
-				y = frames[i + VALUE2];
-				var t : Number = (time - before) / (frames[i + ENTRIES] - before);
-				x += (frames[i + ENTRIES + VALUE1] - x) * t;
-				y += (frames[i + ENTRIES + VALUE2] - y) * t;
-				break;
-			case STEPPED:
-				x = frames[i + VALUE1];
-				y = frames[i + VALUE2];
-				break;
-			default:
-				x = getBezierValue(time, i, VALUE1, curveType - BEZIER);
-				y = getBezierValue(time, i, VALUE2, curveType + BEZIER_SIZE - BEZIER);
-			}
-
-			switch (blend) {
-			case MixBlend.setup:
-				bone.shearX = bone.data.shearX + x * alpha;
-				bone.shearY = bone.data.shearY + y * alpha;
-				break;
-			case MixBlend.first:
-			case MixBlend.replace:
-				bone.shearX += (bone.data.shearX + x - bone.shearX) * alpha;
-				bone.shearY += (bone.data.shearY + y - bone.shearY) * alpha;
-				break;
-			case MixBlend.add:
-				bone.shearX += x * alpha;
-				bone.shearY += y * alpha;
-			}
-		}
-	}
-}

spine-as3/spine-as3/src/spine/animation/ShearXTimeline.as

@@ -1,77 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine.animation {
-	import spine.Bone;
-	import spine.Event;
-	import spine.Skeleton;
-
-	public class ShearXTimeline extends CurveTimeline1 implements BoneTimeline {
-		private var boneIndex : int;
-
-		public function ShearXTimeline(frameCount : int, bezierCount : int, boneIndex : int) {
-			super(frameCount, bezierCount, Property.shearX + "|" + boneIndex);
-			this.boneIndex = boneIndex;
-		}
-
-		public function getBoneIndex() : int {
-			return boneIndex;
-		}
-
-		public override function apply (skeleton : Skeleton, lastTime : Number, time : Number, events : Vector.<Event>, alpha : Number, blend : MixBlend, direction : MixDirection) : void {
-			var bone : Bone = skeleton.bones[boneIndex];
-			if (!bone.active) return;
-
-			var frames : Vector.<Number> = this.frames;
-			if (time < frames[0]) {
-				switch (blend) {
-				case MixBlend.setup:
-					bone.shearX = bone.data.shearX;
-					return;
-				case MixBlend.first:
-					bone.shearX += (bone.data.shearX - bone.shearX) * alpha;
-				}
-				return;
-			}
-
-			var x : Number = getCurveValue(time);
-			switch (blend) {
-			case MixBlend.setup:
-				bone.shearX = bone.data.shearX + x * alpha;
-				break;
-			case MixBlend.first:
-			case MixBlend.replace:
-				bone.shearX += (bone.data.shearX + x - bone.shearX) * alpha;
-				break;
-			case MixBlend.add:
-				bone.shearX += x * alpha;
-			}
-		}
-	}
-}

spine-as3/spine-as3/src/spine/animation/ShearYTimeline.as

@@ -1,77 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine.animation {
-	import spine.Bone;
-	import spine.Event;
-	import spine.Skeleton;
-
-	public class ShearYTimeline extends CurveTimeline1 implements BoneTimeline {
-		private var boneIndex : int;
-
-		public function ShearYTimeline(frameCount : int, bezierCount : int, boneIndex : int) {
-			super(frameCount, bezierCount, Property.shearY + "|" + boneIndex);
-			this.boneIndex = boneIndex;
-		}
-
-		public function getBoneIndex() : int {
-			return boneIndex;
-		}
-
-		public override function apply (skeleton : Skeleton, lastTime : Number, time : Number, events : Vector.<Event>, alpha : Number, blend : MixBlend, direction : MixDirection) : void {
-			var bone : Bone = skeleton.bones[boneIndex];
-			if (!bone.active) return;
-
-			var frames : Vector.<Number> = this.frames;
-			if (time < frames[0]) {
-				switch (blend) {
-				case MixBlend.setup:
-					bone.shearY = bone.data.shearY;
-					return;
-				case MixBlend.first:
-					bone.shearY += (bone.data.shearY - bone.shearY) * alpha;
-				}
-				return;
-			}
-
-			var y : Number = getCurveValue(time);
-			switch (blend) {
-			case MixBlend.setup:
-				bone.shearY = bone.data.shearY + y * alpha;
-				break;
-			case MixBlend.first:
-			case MixBlend.replace:
-				bone.shearY += (bone.data.shearY + y - bone.shearY) * alpha;
-				break;
-			case MixBlend.add:
-				bone.shearY += y * alpha;
-			}
-		}
-	}
-}

spine-as3/spine-as3/src/spine/animation/SlotTimeline.as

@@ -1,34 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine.animation {
-	public interface SlotTimeline {
-		function getSlotIndex() : int;
-	}
-}

spine-as3/spine-as3/src/spine/animation/Timeline.as

@@ -1,74 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine.animation {
-	import spine.Event;
-	import spine.Skeleton;
-
-	public class Timeline {
-		public var propertyIds : Vector.<String>;
-		public var frames : Vector.<Number>;
-
-		public function Timeline(frameCount : int, propertyIds : Array) {
-			this.propertyIds = new Vector.<String>(propertyIds.length, true);
-			for (var i : int = 0, n : int = propertyIds.length; i < n; i++)
-				this.propertyIds[i] = propertyIds[i];
-			frames = new Vector.<Number>(frameCount * getFrameEntries(), true);
-		}
-
-		public function getFrameEntries() : int {
-			return 1;
-		}
-
-		public function getFrameCount() : int {
-			return frames.length / getFrameEntries();
-		}
-
-		public function getDuration() : Number {
-			return frames[frames.length - getFrameEntries()];
-		}
-
-		public function apply (skeleton: Skeleton, lastTime: Number, time: Number, events: Vector.<Event>, alpha: Number, blend: MixBlend, direction: MixDirection) : void {
-		}
-
-		static internal function search1 (frames : Vector.<Number>, time : Number) : int {
-			var n : int = frames.length;
-			for (var i : int = 1; i < n; i++)
-				if (frames[i] > time) return i - 1;
-			return n - 1;
-		}
-
-		static internal function search (frames : Vector.<Number>, time : Number, step: int) : int {
-			var n : int = frames.length;
-			for (var i : int = step; i < n; i += step)
-				if (frames[i] > time) return i - step;
-			return n - step;
-		}
-	}
-}

spine-as3/spine-as3/src/spine/animation/TrackEntry.as

@@ -1,100 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine.animation {
-	import flash.utils.Dictionary;
-	import spine.Poolable;
-
-	public class TrackEntry implements Poolable {
-		public var animation : Animation;
-		public var next : TrackEntry, previous : TrackEntry;
-		public var mixingFrom : TrackEntry, mixingTo: TrackEntry;
-		public var onStart : Listeners = new Listeners();
-		public var onInterrupt : Listeners = new Listeners();
-		public var onEnd : Listeners = new Listeners();
-		public var onDispose : Listeners = new Listeners();
-		public var onComplete : Listeners = new Listeners();
-		public var onEvent : Listeners = new Listeners();
-		public var trackIndex : int;
-		public var loop : Boolean, reverse : Boolean, holdPrevious: Boolean;
-		public var eventThreshold : Number, attachmentThreshold : Number, drawOrderThreshold : Number;
-		public var animationStart : Number, animationEnd : Number, animationLast : Number, nextAnimationLast : Number;
-		public var delay : Number, trackTime : Number, trackLast : Number, nextTrackLast : Number, trackEnd : Number, timeScale : Number;
-		public var alpha : Number, mixTime : Number, mixDuration : Number, interruptAlpha : Number, totalAlpha : Number = 0;
-		public var mixBlend: MixBlend = MixBlend.replace;
-		public var timelineMode : Vector.<int> = new Vector.<int>();
-		public var timelineHoldMix : Vector.<TrackEntry> = new Vector.<TrackEntry>();
-		public var timelinesRotation : Vector.<Number> = new Vector.<Number>();
-
-		public function TrackEntry() {
-		}
-
-		public function getAnimationTime() : Number {
-			if (loop) {
-				var duration : Number = animationEnd - animationStart;
-				if (duration == 0) return animationStart;
-				return (trackTime % duration) + animationStart;
-			}
-			return Math.min(trackTime + animationStart, animationEnd);
-		}
-
-		/** If this track entry is non-looping, the track time in seconds when {@link #getAnimationEnd()} is reached, or the current
-		 * {@link #getTrackTime()} if it has already been reached. If this track entry is looping, the track time when this
-		 * animation will reach its next {@link #getAnimationEnd()} (the next loop completion). */
-		public function getTrackComplete() : Number {
-			var duration : Number = animationEnd - animationStart;
-			if (duration != 0) {
-				if (loop) return duration * (1 + int(trackTime / duration)); // Completion of next loop.
-				if (trackTime < duration) return duration; // Before duration.
-			}
-			return trackTime; // Next update.
-		}
-
-		public function reset() : void {
-			next = null;
-			previous = null;
-			mixingFrom = null;
-			mixingTo = null;
-			animation = null;
-			onStart.listeners.length = 0;
-			onInterrupt.listeners.length = 0;
-			onEnd.listeners.length = 0;
-			onDispose.listeners.length = 0;
-			onComplete.listeners.length = 0;
-			onEvent.listeners.length = 0;
-			timelineMode.length = 0;
-			timelineHoldMix.length = 0;
-			timelinesRotation.length = 0;
-		}
-
-		public function resetRotationDirection() : void {
-			timelinesRotation.length = 0;
-		}
-	}
-}

spine-as3/spine-as3/src/spine/animation/TransformConstraintTimeline.as

@@ -1,150 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine.animation {
-	import spine.TransformConstraintData;
-	import spine.Event;
-	import spine.Skeleton;
-	import spine.TransformConstraint;
-
-	public class TransformConstraintTimeline extends CurveTimeline {
-		static internal const ENTRIES : int = 7;
-		static internal const ROTATE : int = 1, X : int = 2, Y : int = 3, SCALEX : int = 4, SCALEY : int = 5, SHEARY : int = 6;
-
-		/** The index of the transform constraint slot in {@link Skeleton#transformConstraints} that will be changed. */
-		public var transformConstraintIndex : int;
-
-		public function TransformConstraintTimeline(frameCount : int, bezierCount : int, transformConstraintIndex : int) {
-			super(frameCount, bezierCount, [
-				Property.transformConstraint + "|" + transformConstraintIndex
-			]);
-			this.transformConstraintIndex = transformConstraintIndex;
-		}
-
-		public override function getFrameEntries() : int {
-			return ENTRIES;
-		}
-
-		/** The time in seconds, rotate mix, translate mix, scale mix, and shear mix for the specified key frame. */
-		public function setFrame (frame : int, time : Number, mixRotate: Number, mixX: Number, mixY: Number, mixScaleX: Number, mixScaleY: Number, mixShearY: Number) : void {
-			frame *= ENTRIES;
-			frames[frame] = time;
-			frames[frame + ROTATE] = mixRotate;
-			frames[frame + X] = mixX;
-			frames[frame + Y] = mixY;
-			frames[frame + SCALEX] = mixScaleX;
-			frames[frame + SCALEY] = mixScaleY;
-			frames[frame + SHEARY] = mixShearY;
-		}
-
-		public override function apply (skeleton : Skeleton, lastTime : Number, time : Number, events : Vector.<Event>, alpha : Number, blend : MixBlend, direction : MixDirection) : void {
-			var constraint : TransformConstraint = skeleton.transformConstraints[transformConstraintIndex];
-			if (!constraint.active) return;
-
-			var data : TransformConstraintData;
-
-			var frames : Vector.<Number> = this.frames;
-			if (time < frames[0]) {
-				data = constraint.data;
-				switch (blend) {
-				case MixBlend.setup:
-					constraint.mixRotate = data.mixRotate;
-					constraint.mixX = data.mixX;
-					constraint.mixY = data.mixY;
-					constraint.mixScaleX = data.mixScaleX;
-					constraint.mixScaleY = data.mixScaleY;
-					constraint.mixShearY = data.mixShearY;
-					return;
-				case MixBlend.first:
-					constraint.mixRotate += (data.mixRotate - constraint.mixRotate) * alpha;
-					constraint.mixX += (data.mixX - constraint.mixX) * alpha;
-					constraint.mixY += (data.mixY - constraint.mixY) * alpha;
-					constraint.mixScaleX += (data.mixScaleX - constraint.mixScaleX) * alpha;
-					constraint.mixScaleY += (data.mixScaleY - constraint.mixScaleY) * alpha;
-					constraint.mixShearY += (data.mixShearY - constraint.mixShearY) * alpha;
-				}
-				return;
-			}
-
-			var rotate : Number, x : Number, y : Number, scaleX : Number, scaleY : Number, shearY : Number;
-			var i : int = search(frames, time, ENTRIES);
-			var curveType : Number = curves[i / ENTRIES];
-			switch (curveType) {
-			case LINEAR:
-				var before : Number = frames[i];
-				rotate = frames[i + ROTATE];
-				x = frames[i + X];
-				y = frames[i + Y];
-				scaleX = frames[i + SCALEX];
-				scaleY = frames[i + SCALEY];
-				shearY = frames[i + SHEARY];
-				var t : Number = (time - before) / (frames[i + ENTRIES] - before);
-				rotate += (frames[i + ENTRIES + ROTATE] - rotate) * t;
-				x += (frames[i + ENTRIES + X] - x) * t;
-				y += (frames[i + ENTRIES + Y] - y) * t;
-				scaleX += (frames[i + ENTRIES + SCALEX] - scaleX) * t;
-				scaleY += (frames[i + ENTRIES + SCALEY] - scaleY) * t;
-				shearY += (frames[i + ENTRIES + SHEARY] - shearY) * t;
-				break;
-			case STEPPED:
-				rotate = frames[i + ROTATE];
-				x = frames[i + X];
-				y = frames[i + Y];
-				scaleX = frames[i + SCALEX];
-				scaleY = frames[i + SCALEY];
-				shearY = frames[i + SHEARY];
-				break;
-			default:
-				rotate = getBezierValue(time, i, ROTATE, curveType - BEZIER);
-				x = getBezierValue(time, i, X, curveType + BEZIER_SIZE - BEZIER);
-				y = getBezierValue(time, i, Y, curveType + BEZIER_SIZE * 2 - BEZIER);
-				scaleX = getBezierValue(time, i, SCALEX, curveType + BEZIER_SIZE * 3 - BEZIER);
-				scaleY = getBezierValue(time, i, SCALEY, curveType + BEZIER_SIZE * 4 - BEZIER);
-				shearY = getBezierValue(time, i, SHEARY, curveType + BEZIER_SIZE * 5 - BEZIER);
-			}
-
-			if (blend == MixBlend.setup) {
-				data = constraint.data;
-				constraint.mixRotate = data.mixRotate + (rotate - data.mixRotate) * alpha;
-				constraint.mixX = data.mixX + (x - data.mixX) * alpha;
-				constraint.mixY = data.mixY + (y - data.mixY) * alpha;
-				constraint.mixScaleX = data.mixScaleX + (scaleX - data.mixScaleX) * alpha;
-				constraint.mixScaleY = data.mixScaleY + (scaleY - data.mixScaleY) * alpha;
-				constraint.mixShearY = data.mixShearY + (shearY - data.mixShearY) * alpha;
-			} else {
-				constraint.mixRotate += (rotate - constraint.mixRotate) * alpha;
-				constraint.mixX += (x - constraint.mixX) * alpha;
-				constraint.mixY += (y - constraint.mixY) * alpha;
-				constraint.mixScaleX += (scaleX - constraint.mixScaleX) * alpha;
-				constraint.mixScaleY += (scaleY - constraint.mixScaleY) * alpha;
-				constraint.mixShearY += (shearY - constraint.mixShearY) * alpha;
-			}
-		}
-	}
-}

spine-as3/spine-as3/src/spine/animation/TranslateTimeline.as

@@ -1,105 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine.animation {
-	import spine.Bone;
-	import spine.Event;
-	import spine.Skeleton;
-
-	public class TranslateTimeline extends CurveTimeline2 implements BoneTimeline {
-		private var boneIndex : int;
-
-		public function TranslateTimeline(frameCount : int, bezierCount : int, boneIndex : int) {
-			super(frameCount, bezierCount,
-				Property.x + "|" + boneIndex,
-				Property.y + "|" + boneIndex
-			);
-			this.boneIndex = boneIndex;
-		}
-
-		public function getBoneIndex() : int {
-			return boneIndex;
-		}
-
-		public override function apply (skeleton : Skeleton, lastTime : Number, time : Number, events : Vector.<Event>, alpha : Number, blend : MixBlend, direction : MixDirection) : void {
-			var bone : Bone = skeleton.bones[boneIndex];
-			if (!bone.active) return;
-
-			var frames : Vector.<Number> = this.frames;
-			if (time < frames[0]) {
-				switch (blend) {
-				case MixBlend.setup:
-					bone.x = bone.data.x;
-					bone.y = bone.data.y;
-					return;
-				case MixBlend.first:
-					bone.x += (bone.data.x - bone.x) * alpha;
-					bone.y += (bone.data.y - bone.y) * alpha;
-				}
-				return;
-			}
-
-			var x : Number = 0, y : Number = 0;
-			var i : int = search(frames, time, ENTRIES);
-			var curveType : Number = curves[i / ENTRIES];
-			switch (curveType) {
-			case LINEAR:
-				var before : Number = frames[i];
-				x = frames[i + VALUE1];
-				y = frames[i + VALUE2];
-				var t : Number = (time - before) / (frames[i + ENTRIES] - before);
-				x += (frames[i + ENTRIES + VALUE1] - x) * t;
-				y += (frames[i + ENTRIES + VALUE2] - y) * t;
-				break;
-			case STEPPED:
-				x = frames[i + VALUE1];
-				y = frames[i + VALUE2];
-				break;
-			default:
-				x = getBezierValue(time, i, VALUE1, curveType - BEZIER);
-				y = getBezierValue(time, i, VALUE2, curveType + BEZIER_SIZE - BEZIER);
-			}
-
-			switch (blend) {
-			case MixBlend.setup:
-				bone.x = bone.data.x + x * alpha;
-				bone.y = bone.data.y + y * alpha;
-				break;
-			case MixBlend.first:
-			case MixBlend.replace:
-				bone.x += (bone.data.x + x - bone.x) * alpha;
-				bone.y += (bone.data.y + y - bone.y) * alpha;
-				break;
-			case MixBlend.add:
-				bone.x += x * alpha;
-				bone.y += y * alpha;
-			}
-		}
-	}
-}

spine-as3/spine-as3/src/spine/animation/TranslateXTimeline.as

@@ -1,77 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine.animation {
-	import spine.Bone;
-	import spine.Event;
-	import spine.Skeleton;
-
-	public class TranslateXTimeline extends CurveTimeline1 implements BoneTimeline {
-		private var boneIndex : int;
-
-		public function TranslateXTimeline(frameCount : int, bezierCount : int, boneIndex : int) {
-			super(frameCount, bezierCount, Property.x + "|" + boneIndex);
-			this.boneIndex = boneIndex;
-		}
-
-		public function getBoneIndex() : int {
-			return boneIndex;
-		}
-
-		public override function apply (skeleton : Skeleton, lastTime : Number, time : Number, events : Vector.<Event>, alpha : Number, blend : MixBlend, direction : MixDirection) : void {
-			var bone : Bone = skeleton.bones[boneIndex];
-			if (!bone.active) return;
-
-			var frames : Vector.<Number> = this.frames;
-			if (time < frames[0]) {
-				switch (blend) {
-				case MixBlend.setup:
-					bone.x = bone.data.x;
-					return;
-				case MixBlend.first:
-					bone.x += (bone.data.x - bone.x) * alpha;
-				}
-				return;
-			}
-
-			var x : Number = getCurveValue(time);
-			switch (blend) {
-			case MixBlend.setup:
-				bone.x = bone.data.x + x * alpha;
-				break;
-			case MixBlend.first:
-			case MixBlend.replace:
-				bone.x += (bone.data.x + x - bone.x) * alpha;
-				break;
-			case MixBlend.add:
-				bone.x += x * alpha;
-			}
-		}
-	}
-}

spine-as3/spine-as3/src/spine/animation/TranslateYTimeline.as

@@ -1,77 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine.animation {
-	import spine.Bone;
-	import spine.Event;
-	import spine.Skeleton;
-
-	public class TranslateYTimeline extends CurveTimeline1 implements BoneTimeline {
-		private var boneIndex : int;
-
-		public function TranslateYTimeline(frameCount : int, bezierCount : int, boneIndex : int) {
-			super(frameCount, bezierCount, Property.y + "|" + boneIndex);
-			this.boneIndex = boneIndex;
-		}
-
-		public function getBoneIndex() : int {
-			return boneIndex;
-		}
-
-		public override function apply (skeleton : Skeleton, lastTime : Number, time : Number, events : Vector.<Event>, alpha : Number, blend : MixBlend, direction : MixDirection) : void {
-			var bone : Bone = skeleton.bones[boneIndex];
-			if (!bone.active) return;
-
-			var frames : Vector.<Number> = this.frames;
-			if (time < frames[0]) {
-				switch (blend) {
-				case MixBlend.setup:
-					bone.y = bone.data.y;
-					return;
-				case MixBlend.first:
-					bone.y += (bone.data.y - bone.y) * alpha;
-				}
-				return;
-			}
-
-			var y : Number = getCurveValue(time);
-			switch (blend) {
-			case MixBlend.setup:
-				bone.y = bone.data.y + y * alpha;
-				break;
-			case MixBlend.first:
-			case MixBlend.replace:
-				bone.y += (bone.data.y + y - bone.y) * alpha;
-				break;
-			case MixBlend.add:
-				bone.y += y * alpha;
-			}
-		}
-	}
-}

spine-as3/spine-as3/src/spine/atlas/Atlas.as

@@ -1,249 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine.atlas {
-	import flash.utils.ByteArray;
-	import flash.utils.Dictionary;
-
-	public class Atlas {
-		private var pages : Vector.<AtlasPage> = new Vector.<AtlasPage>();
-		private var regions : Vector.<AtlasRegion> = new Vector.<AtlasRegion>();
-		private var textureLoader : TextureLoader;
-
-		/** @param object A String or ByteArray. */
-		public function Atlas(object : *, textureLoader : TextureLoader) {
-			if (!object) return;
-			if (object is String)
-				load(String(object), textureLoader);
-			else if (object is ByteArray)
-				load(ByteArray(object).readUTFBytes(ByteArray(object).length), textureLoader);
-			else
-				throw new ArgumentError("object must be a string or ByteArray containing .atlas data.");
-		}
-
-		protected function load(atlasText : String, textureLoader : TextureLoader) : void {
-			if (textureLoader == null) throw new ArgumentError("textureLoader cannot be null.");
-			this.textureLoader = textureLoader;
-
-			var reader : Reader = new Reader(atlasText);
-			var entry : Vector.<String> = new Vector.<String>(5, true);
-			var page : AtlasPage;
-			var region : AtlasRegion;
-
-			var pageFields : Dictionary = new Dictionary();
-			pageFields["size"] = function() : void {
-				page.width = parseInt(entry[1]);
-				page.height = parseInt(entry[2]);
-			};
-			pageFields["format"] = function() : void {
-				page.format = Format[entry[0]];
-			};
-			pageFields["filter"] = function() : void {
-				page.minFilter = TextureFilter[entry[1]];
-				page.magFilter = TextureFilter[entry[2]];
-			};
-			pageFields["repeat"] = function() : void {
-				if (entry[1].indexOf('x') != -1) page.uWrap = TextureWrap.repeat;
-				if (entry[1].indexOf('y') != -1) page.vWrap = TextureWrap.repeat;
-			};
-			pageFields["pma"] = function() : void {
-				page.pma = entry[1] == "true";
-			};
-
-			var regionFields : Dictionary = new Dictionary();
-			regionFields["xy"] = function() : void { // Deprecated, use bounds.
-				region.x = parseInt(entry[1]);
-				region.y = parseInt(entry[2]);
-			};
-			regionFields["size"] = function() : void { // Deprecated, use bounds.
-				region.width = parseInt(entry[1]);
-				region.height = parseInt(entry[2]);
-			};
-			regionFields["bounds"] = function() : void {
-				region.x = parseInt(entry[1]);
-				region.y = parseInt(entry[2]);
-				region.width = parseInt(entry[3]);
-				region.height = parseInt(entry[4]);
-			};
-			regionFields["offset"] = function() : void { // Deprecated, use offsets.
-				region.offsetX = parseInt(entry[1]);
-				region.offsetY = parseInt(entry[2]);
-			};
-			regionFields["orig"] = function() : void { // Deprecated, use offsets.
-				region.originalWidth = parseInt(entry[1]);
-				region.originalHeight = parseInt(entry[2]);
-			};
-			regionFields["offsets"] = function() : void {
-				region.offsetX = parseInt(entry[1]);
-				region.offsetY = parseInt(entry[2]);
-				region.originalWidth = parseInt(entry[3]);
-				region.originalHeight = parseInt(entry[4]);
-			};
-			regionFields["rotate"] = function() : void {
-				var value : String = entry[1];
-				if (value == "true")
-					region.degrees = 90;
-				else if (value != "false")
-					region.degrees = parseInt(value);
-			};
-			regionFields["index"] = function() : void {
-				region.index = parseInt(entry[1]);
-			};
-
-			var line : String = reader.readLine();
-			// Ignore empty lines before first entry.
-			while (line != null && line.length == 0)
-				line = reader.readLine();
-			// Header entries.
-			while (true) {
-				if (line == null || line.length == 0) break;
-				if (reader.readEntry(entry, line) == 0) break; // Silently ignore all header fields.
-				line = reader.readLine();
-			}
-
-			// Page and region entries.
-			var names : Vector.<String>;
-			var values : Vector.<Vector.<Number>>;
-			var field : Function;
-			while (true) {
-				if (line == null) break;
-				if (line.length == 0) {
-					page = null;
-					line = reader.readLine();
-				} else if (page == null) {
-					page = new AtlasPage();
-					page.name = line;
-					while (true) {
-						if (reader.readEntry(entry, line = reader.readLine()) == 0) break;
-						field = pageFields[entry[0]];
-						if (field) field();
-					}
-					textureLoader.loadPage(page, line);
-					pages.push(page);
-				} else {
-					region = new AtlasRegion();
-					region.page = page;
-					region.name = line;
-					while (true) {
-						var count : int = reader.readEntry(entry, line = reader.readLine());
-						if (count == 0) break;
-						field = regionFields[entry[0]];
-						if (field)
-							field();
-						else {
-							if (names == null) {
-								names = new Vector.<String>();
-								values = new Vector.<Vector.<Number>>();
-							}
-							names.push(entry[0]);
-							var entryValues : Vector.<Number> = new Vector.<Number>(count, true);
-							for (var i : int = 0; i < count; i++)
-								entryValues[i] = parseInt(entry[i + 1]);
-							values.push(entryValues);
-						}
-					}
-					if (region.originalWidth == 0 && region.originalHeight == 0) {
-						region.originalWidth = region.width;
-						region.originalHeight = region.height;
-					}
-					if (names != null && names.length > 0) {
-						region.names = names;
-						region.values = values;
-						names = null;
-						values = null;
-					}
-					region.u = region.x / page.width;
-					region.v = region.y / page.height;
-					if (region.degrees == 90) {
-						region.u2 = (region.x + region.height) / page.width;
-						region.v2 = (region.y + region.width) / page.height;
-					} else {
-						region.u2 = (region.x + region.width) / page.width;
-						region.v2 = (region.y + region.height) / page.height;
-					}
-					textureLoader.loadRegion(region);
-					regions.push(region);
-				}
-			}
-		}
-
-		/** Returns the first region found with the specified name. This method uses string comparison to find the region, so the result
-		 * should be cached rather than calling this method multiple times.
-		 * @return The region, or null. */
-		public function findRegion(name : String) : AtlasRegion {
-			for (var i : int = 0, n : int = regions.length; i < n; i++)
-				if (regions[i].name == name)
-					return regions[i];
-			return null;
-		}
-
-		public function dispose() : void {
-			for (var i : int = 0, n : int = pages.length; i < n; i++)
-				textureLoader.unloadPage(pages[i]);
-		}
-	}
-}
-
-class Reader {
-	static private const trimRegex : RegExp = /^\s+|\s+$/gs;
-
-	private var lines : Array;
-	private var index : int;
-
-	function Reader(text : String) {
-		lines = trim(text).split(/[ \t]*(?:\r\n|\r|\n)[ \t]*/);
-	}
-
-	function trim (value : String) : String {
-		return value.replace(trimRegex, "");
-	}
-
-	function readLine() : String {
-		return index >= lines.length ? null : lines[index++];
-	}
-
-	function readEntry(entry : Vector.<String>, line : String) : int {
-		if (line == null) return 0;
-		if (line.length == 0) return 0;
-
-		var colon : int = line.indexOf(':');
-		if (colon == -1) return 0;
-		entry[0] = trim(line.substr(0, colon));
-		for (var i : int = 1, lastMatch : int = colon + 1;; i++) {
-			var comma : int = line.indexOf(',', lastMatch);
-			if (comma == -1) {
-				entry[i] = trim(line.substr(lastMatch));
-				return i;
-			}
-			entry[i] = trim(line.substr(lastMatch, comma - lastMatch));
-			lastMatch = comma + 1;
-			if (i == 4) return 4;
-		}
-	}
-}

spine-as3/spine-as3/src/spine/atlas/AtlasPage.as

@@ -1,45 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine.atlas {
-	public class AtlasPage {
-		public var name : String;
-		public var format : Format;
-		public var minFilter : TextureFilter = TextureFilter.nearest;
-		public var magFilter : TextureFilter = TextureFilter.nearest;
-		public var uWrap : TextureWrap = TextureWrap.clampToEdge;
-		public var vWrap : TextureWrap = TextureWrap.clampToEdge;
-		public var width : int, height : int;
-		public var pma : Boolean;
-		public var rendererObject : Object;
-
-		public function AtlasPage() {
-		}
-	}
-}

spine-as3/spine-as3/src/spine/atlas/AtlasRegion.as

@@ -1,50 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine.atlas {
-	public class AtlasRegion {
-		public var page : AtlasPage;
-		public var name : String;
-		public var x : int, y : int;
-		public var width : int, height : int;
-		public var u : Number, v : Number, u2 : Number, v2 : Number;
-		public var offsetX : Number = 0, offsetY : Number = 0;
-		public var originalWidth : int, originalHeight : int;
-		public var index : int;
-		public var degrees : int;
-		public var splits : Vector.<int>;
-		public var pads : Vector.<int>;
-		public var rendererObject : Object;
-		public var names : Vector.<String>;
-		public var values : Vector.<Vector.<Number>>;
-
-		public function AtlasRegion() {
-		}
-	}
-}

spine-as3/spine-as3/src/spine/atlas/Format.as

@@ -1,47 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine.atlas {
-	public class Format {
-		public static const alpha : Format = new Format(0, "alpha");
-		public static const intensity : Format = new Format(1, "intensity");
-		public static const luminanceAlpha : Format = new Format(2, "luminanceAlpha");
-		public static const rgb565 : Format = new Format(3, "rgb565");
-		public static const rgba4444 : Format = new Format(4, "rgba4444");
-		public static const rgb888 : Format = new Format(5, "rgb888");
-		public static const rgba8888 : Format = new Format(6, "rgba8888");
-		public var ordinal : int;
-		public var name : String;
-
-		public function Format(ordinal : int, name : String) {
-			this.ordinal = ordinal;
-			this.name = name;
-		}
-	}
-}

spine-as3/spine-as3/src/spine/atlas/TextureFilter.as

@@ -1,50 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine.atlas {
-	import flash.utils.Dictionary;
-
-	public class TextureFilter {
-		public static const nearest : TextureFilter = new TextureFilter(0, "nearest");
-		public static const linear : TextureFilter = new TextureFilter(1, "linear");
-		public static const mipMap : TextureFilter = new TextureFilter(2, "mipMap");
-		public static const mipMapNearestNearest : TextureFilter = new TextureFilter(3, "mipMapNearestNearest");
-		public static const mipMapLinearNearest : TextureFilter = new TextureFilter(4, "mipMapLinearNearest");
-		public static const mipMapNearestLinear : TextureFilter = new TextureFilter(5, "mipMapNearestLinear");
-		public static const mipMapLinearLinear : TextureFilter = new TextureFilter(6, "mipMapLinearLinear");
-
-		public var ordinal : int;
-		public var name : String;
-
-		public function TextureFilter(ordinal : int, name : String) {
-			this.ordinal = ordinal;
-			this.name = name;
-		}
-	}
-}

spine-as3/spine-as3/src/spine/atlas/TextureLoader.as

@@ -1,38 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine.atlas {
-	public interface TextureLoader {
-		function loadPage(page : AtlasPage, path : String) : void;
-
-		function loadRegion(region : AtlasRegion) : void;
-
-		function unloadPage(page : AtlasPage) : void;
-	}
-}

spine-as3/spine-as3/src/spine/atlas/TextureWrap.as

@@ -1,43 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine.atlas {
-	public class TextureWrap {
-		public static const mirroredRepeat : TextureWrap = new TextureWrap(0, "mirroredRepeat");
-		public static const clampToEdge : TextureWrap = new TextureWrap(1, "clampToEdge");
-		public static const repeat : TextureWrap = new TextureWrap(2, "repeat");
-		public var ordinal : int;
-		public var name : String;
-
-		public function TextureWrap(ordinal : int, name : String) {
-			this.ordinal = ordinal;
-			this.name = name;
-		}
-	}
-}

spine-as3/spine-as3/src/spine/attachments/AtlasAttachmentLoader.as

@@ -1,110 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine.attachments {
-	import spine.Skin;
-	import spine.atlas.Atlas;
-	import spine.atlas.AtlasRegion;
-
-	public class AtlasAttachmentLoader implements AttachmentLoader {
-		private var atlas : Atlas;
-
-		public function AtlasAttachmentLoader(atlas : Atlas) {
-			if (atlas == null)
-				throw new ArgumentError("atlas cannot be null.");
-			this.atlas = atlas;
-		}
-
-		public function newRegionAttachment(skin : Skin, name : String, path : String) : RegionAttachment {
-			var region : AtlasRegion = atlas.findRegion(path);
-			if (region == null)
-				throw new Error("Region not found in atlas: " + path + " (region attachment: " + name + ")");
-			var attachment : RegionAttachment = new RegionAttachment(name);
-			attachment.rendererObject = region;
-			var scaleX : Number = 1;
-			var scaleY : Number = 1;
-			attachment.setUVs(region.u * scaleX, region.v * scaleY, region.u2 * scaleX, region.v2 * scaleY, region.degrees);
-			attachment.regionOffsetX = region.offsetX;
-			attachment.regionOffsetY = region.offsetY;
-			attachment.regionWidth = region.width;
-			attachment.regionHeight = region.height;
-			attachment.regionOriginalWidth = region.originalWidth;
-			attachment.regionOriginalHeight = region.originalHeight;
-			return attachment;
-		}
-
-		public function newMeshAttachment(skin : Skin, name : String, path : String) : MeshAttachment {
-			var region : AtlasRegion = atlas.findRegion(path);
-			if (region == null)
-				throw new Error("Region not found in atlas: " + path + " (mesh attachment: " + name + ")");
-			var attachment : MeshAttachment = new MeshAttachment(name);
-			attachment.rendererObject = region;
-			var scaleX : Number = 1;
-			var scaleY : Number = 1;
-			attachment.regionU = region.u * scaleX;
-			attachment.regionV = region.v * scaleY;
-			attachment.regionU2 = region.u2 * scaleX;
-			attachment.regionV2 = region.v2 * scaleY;
-			attachment.regionDegrees = region.degrees;
-			attachment.regionOffsetX = region.offsetX;
-			attachment.regionOffsetY = region.offsetY;
-			attachment.regionWidth = region.width;
-			attachment.regionHeight = region.height;
-			attachment.regionOriginalWidth = region.originalWidth;
-			attachment.regionOriginalHeight = region.originalHeight;			
-			return attachment;
-		}
-
-		public function newBoundingBoxAttachment(skin : Skin, name : String) : BoundingBoxAttachment {
-			return new BoundingBoxAttachment(name);
-		}
-
-		public function newPathAttachment(skin : Skin, name : String) : PathAttachment {
-			return new PathAttachment(name);
-		}
-
-		public function newPointAttachment(skin : Skin, name : String) : PointAttachment {
-			return new PointAttachment(name);
-		}
-		
-		public function newClippingAttachment(skin : Skin, name : String) : ClippingAttachment {
-			return new ClippingAttachment(name);
-		}
-
-		static public function nextPOT(value : int) : int {
-			value--;
-			value |= value >> 1;
-			value |= value >> 2;
-			value |= value >> 4;
-			value |= value >> 8;
-			value |= value >> 16;
-			return value + 1;
-		}
-	}
-}

spine-as3/spine-as3/src/spine/attachments/Attachment.as

@@ -1,52 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine.attachments {
-	import flash.errors.IllegalOperationError;
-	public class Attachment {
-		internal var _name : String;
-
-		public function Attachment(name : String) {
-			if (name == null) throw new ArgumentError("name cannot be null.");
-			_name = name;
-		}
-
-		public function get name() : String {
-			return _name;
-		}
-
-		public function toString() : String {
-			return name;
-		}
-		
-		public function copy() : Attachment {
-			throw new IllegalOperationError("Not implemented");
-		}
-	}	
-}

spine-as3/spine-as3/src/spine/attachments/AttachmentLoader.as

@@ -1,52 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine.attachments {
-	import spine.Skin;
-
-	public interface AttachmentLoader {
-		/** @return May be null to not load an attachment. */
-		function newRegionAttachment(skin : Skin, name : String, path : String) : RegionAttachment;
-
-		/** @return May be null to not load an attachment. */
-		function newMeshAttachment(skin : Skin, name : String, path : String) : MeshAttachment;
-
-		/** @return May be null to not load an attachment. */
-		function newBoundingBoxAttachment(skin : Skin, name : String) : BoundingBoxAttachment;
-
-		/** @return May be null to not load an attachment */
-		function newPathAttachment(skin : Skin, name : String) : PathAttachment;
-
-		/** @return May be null to not load an attachment */
-		function newPointAttachment(skin : Skin, name : String) : PointAttachment;
-		
-		/** @return May be null to not load an attachment */
-		function newClippingAttachment(skin : Skin, name : String) : ClippingAttachment;
-	}
-}

spine-as3/spine-as3/src/spine/attachments/AttachmentType.as

@@ -1,50 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine.attachments {
-	public class AttachmentType {
-		public static const region : AttachmentType = new AttachmentType(0, "region");
-		public static const regionsequence : AttachmentType = new AttachmentType(1, "regionsequence");
-		public static const boundingbox : AttachmentType = new AttachmentType(2, "boundingbox");
-		public static const mesh : AttachmentType = new AttachmentType(3, "mesh");
-		public static const linkedmesh : AttachmentType = new AttachmentType(3, "linkedmesh");
-		public static const path : AttachmentType = new AttachmentType(4, "path");
-		public static const point : AttachmentType = new AttachmentType(5, "point");
-		public static const clipping : AttachmentType = new AttachmentType(6, "clipping");
-		public var ordinal : int;
-		public var name : String;
-		
-		public static const values : Array = [ region, boundingbox, mesh, linkedmesh, path, point, clipping ];
-
-		public function AttachmentType(ordinal : int, name : String) {
-			this.ordinal = ordinal;
-			this.name = name;
-		}
-	}
-}

spine-as3/spine-as3/src/spine/attachments/BoundingBoxAttachment.as

@@ -1,46 +0,0 @@
-/******************************************************************************
- * Spine Runtimes License Agreement
- * Last updated January 1, 2020. Replaces all prior versions.
- *
- * Copyright (c) 2013-2020, Esoteric Software LLC
- *
- * Integration of the Spine Runtimes into software or otherwise creating
- * derivative works of the Spine Runtimes is permitted under the terms and
- * conditions of Section 2 of the Spine Editor License Agreement:
- * http://esotericsoftware.com/spine-editor-license
- *
- * Otherwise, it is permitted to integrate the Spine Runtimes into software
- * or otherwise create derivative works of the Spine Runtimes (collectively,
- * "Products"), provided that each user of the Products must obtain their own
- * Spine Editor license and redistribution of the Products in any form must
- * include this license and copyright notice.
- *
- * THE SPINE RUNTIMES ARE PROVIDED BY ESOTERIC SOFTWARE LLC "AS IS" AND ANY
- * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL ESOTERIC SOFTWARE LLC BE LIABLE FOR ANY
- * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES,
- * BUSINESS INTERRUPTION, OR LOSS OF USE, DATA, OR PROFITS) HOWEVER CAUSED AND
- * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
- * THE SPINE RUNTIMES, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *****************************************************************************/
-
-package spine.attachments {
-	import spine.Color;
-	
-	public dynamic class BoundingBoxAttachment extends VertexAttachment {
-		public var color : Color = new Color(0, 0, 0, 0);
-		
-		public function BoundingBoxAttachment(name : String) {
-			super(name);
-		}
-		
-		override public function copy (): Attachment {
-			var copy : BoundingBoxAttachment = new BoundingBoxAttachment(name);
-			copyTo(copy);			
-			return copy;
-		}
-	}
-}