https://www.tynker.com/ext/spine.js

358	var high = Math.floor(values.length / step) - 2;
359	if (!high) return step;
360	var current = high >>> 1;
361	while (true) {
362		if (values[(current + 1) * step] <= target)
363			low = current + 1;
364		else
365			high = current;
366		if (low == high) return (low + 1) * step;
367		current = (low + high) >>> 1;
368	}
369};
370spine.Animation.binarySearch1 = function (values, target) {
371	var low = 0;
372	var high = values.length - 2;
373	if (!high) return 1;
374	var current = high >>> 1;
375	while (true) {
376		if (values[current + 1] <= target)
377			low = current + 1;
378		else
379			high = current;
380		if (low == high) return low + 1;
381		current = (low + high) >>> 1;
382	}
383};
384spine.Animation.linearSearch = function (values, target, step) {
385	for (var i = 0, last = values.length - step; i <= last; i += step)
386		if (values[i] > target) return i;
387	return -1;
388};
389
390spine.Curves = function (frameCount) {
391	this.curves = []; // type, x, y, ...
392	//this.curves.length = (frameCount - 1) * 19/*BEZIER_SIZE*/;
393};
394spine.Curves.prototype = {
395	setLinear: function (frameIndex) {
396		this.curves[frameIndex * 19/*BEZIER_SIZE*/] = 0/*LINEAR*/;
397	},
398	setStepped: function (frameIndex) {
399		this.curves[frameIndex * 19/*BEZIER_SIZE*/] = 1/*STEPPED*/;
400	},
401	/** Sets the control handle positions for an interpolation bezier curve used to transition from this keyframe to the next.
402	 * cx1 and cx2 are from 0 to 1, representing the percent of time between the two keyframes. cy1 and cy2 are the percent of
403	 * the difference between the keyframe's values. */
404	setCurve: function (frameIndex, cx1, cy1, cx2, cy2) {
405		var subdiv1 = 1 / 10/*BEZIER_SEGMENTS*/, subdiv2 = subdiv1 * subdiv1, subdiv3 = subdiv2 * subdiv1;
406		var pre1 = 3 * subdiv1, pre2 = 3 * subdiv2, pre4 = 6 * subdiv2, pre5 = 6 * subdiv3;
407		var tmp1x = -cx1 * 2 + cx2, tmp1y = -cy1 * 2 + cy2, tmp2x = (cx1 - cx2) * 3 + 1, tmp2y = (cy1 - cy2) * 3 + 1;
408		var dfx = cx1 * pre1 + tmp1x * pre2 + tmp2x * subdiv3, dfy = cy1 * pre1 + tmp1y * pre2 + tmp2y * subdiv3;
409		var ddfx = tmp1x * pre4 + tmp2x * pre5, ddfy = tmp1y * pre4 + tmp2y * pre5;
410		var dddfx = tmp2x * pre5, dddfy = tmp2y * pre5;
411
412		var i = frameIndex * 19/*BEZIER_SIZE*/;
413		var curves = this.curves;
414		curves[i++] = 2/*BEZIER*/;
415		
416		var x = dfx, y = dfy;
417		for (var n = i + 19/*BEZIER_SIZE*/ - 1; i < n; i += 2) {
418			curves[i] = x;
419			curves[i + 1] = y;
420			dfx += ddfx;
421			dfy += ddfy;
422			ddfx += dddfx;
423			ddfy += dddfy;
424			x += dfx;
425			y += dfy;
426		}
427	},
428	getCurvePercent: function (frameIndex, percent) {
429		percent = percent < 0 ? 0 : (percent > 1 ? 1 : percent);
430		var curves = this.curves;
431		var i = frameIndex * 19/*BEZIER_SIZE*/;
432		var type = curves[i];
433		if (type === 0/*LINEAR*/) return percent;
434		if (type == 1/*STEPPED*/) return 0;
435		i++;
436		var x = 0;
437		for (var start = i, n = i + 19/*BEZIER_SIZE*/ - 1; i < n; i += 2) {
438			x = curves[i];
439			if (x >= percent) {
440				var prevX, prevY;
441				if (i == start) {
442					prevX = 0;
443					prevY = 0;
444				} else {
445					prevX = curves[i - 2];
446					prevY = curves[i - 1];
447				}
448				return prevY + (curves[i + 1] - prevY) * (percent - prevX) / (x - prevX);
449			}
450		}
451		var y = curves[i - 1];
452		return y + (1 - y) * (percent - x) / (1 - x); // Last point is 1,1.
453	}
454};
455
456spine.RotateTimeline = function (frameCount) {
457	this.curves = new spine.Curves(frameCount);
458	this.frames = []; // time, angle, ...
459	this.frames.length = frameCount * 2;
460};
461spine.RotateTimeline.prototype = {
462	boneIndex: 0,
463	getFrameCount: function () {
464		return this.frames.length / 2;
465	},
466	setFrame: function (frameIndex, time, angle) {
467		frameIndex *= 2;
468		this.frames[frameIndex] = time;
469		this.frames[frameIndex + 1] = angle;
470	},
471	apply: function (skeleton, lastTime, time, firedEvents, alpha) {
472		var frames = this.frames;
473		if (time < frames[0]) return; // Time is before first frame.
474
475		var bone = skeleton.bones[this.boneIndex];
476
477		if (time >= frames[frames.length - 2]) { // Time is after last frame.
478			var amount = bone.data.rotation + frames[frames.length - 1] - bone.rotation;
479			while (amount > 180)
480				amount -= 360;
481			while (amount < -180)
482				amount += 360;
483			bone.rotation += amount * alpha;
484			return;
485		}
486
487		// Interpolate between the previous frame and the current frame.
488		var frameIndex = spine.Animation.binarySearch(frames, time, 2);
489		var prevFrameValue = frames[frameIndex - 1];
490		var frameTime = frames[frameIndex];
491		var percent = 1 - (time - frameTime) / (frames[frameIndex - 2/*PREV_FRAME_TIME*/] - frameTime);
492		percent = this.curves.getCurvePercent(frameIndex / 2 - 1, percent);
493
494		var amount = frames[frameIndex + 1/*FRAME_VALUE*/] - prevFrameValue;
495		while (amount > 180)
496			amount -= 360;
497		while (amount < -180)
498			amount += 360;
499		amount = bone.data.rotation + (prevFrameValue + amount * percent) - bone.rotation;
500		while (amount > 180)
501			amount -= 360;
502		while (amount < -180)
503			amount += 360;
504		bone.rotation += amount * alpha;
505	}
506};
507
508spine.TranslateTimeline = function (frameCount) {
509	this.curves = new spine.Curves(frameCount);
510	this.frames = []; // time, x, y, ...
511	this.frames.length = frameCount * 3;
512};
513spine.TranslateTimeline.prototype = {
514	boneIndex: 0,
515	getFrameCount: function () {
516		return this.frames.length / 3;
517	},
518	setFrame: function (frameIndex, time, x, y) {
519		frameIndex *= 3;
520		this.frames[frameIndex] = time;
521		this.frames[frameIndex + 1] = x;
522		this.frames[frameIndex + 2] = y;
523	},
524	apply: function (skeleton, lastTime, time, firedEvents, alpha) {
525		var frames = this.frames;
526		if (time < frames[0]) return; // Time is before first frame.
527
528		var bone = skeleton.bones[this.boneIndex];
529
530		if (time >= frames[frames.length - 3]) { // Time is after last frame.
531			bone.x += (bone.data.x + frames[frames.length - 2] - bone.x) * alpha;
532			bone.y += (bone.data.y + frames[frames.length - 1] - bone.y) * alpha;
533			return;
534		}
535
536		// Interpolate between the previous frame and the current frame.
537		var frameIndex = spine.Animation.binarySearch(frames, time, 3);
538		var prevFrameX = frames[frameIndex - 2];
539		var prevFrameY = frames[frameIndex - 1];
540		var frameTime = frames[frameIndex];
541		var percent = 1 - (time - frameTime) / (frames[frameIndex + -3/*PREV_FRAME_TIME*/] - frameTime);
542		percent = this.curves.getCurvePercent(frameIndex / 3 - 1, percent);
543
544		bone.x += (bone.data.x + prevFrameX + (frames[frameIndex + 1/*FRAME_X*/] - prevFrameX) * percent - bone.x) * alpha;
545		bone.y += (bone.data.y + prevFrameY + (frames[frameIndex + 2/*FRAME_Y*/] - prevFrameY) * percent - bone.y) * alpha;
546	}
547};
548
549spine.ScaleTimeline = function (frameCount) {
550	this.curves = new spine.Curves(frameCount);
551	this.frames = []; // time, x, y, ...
552	this.frames.length = frameCount * 3;
553};
554spine.ScaleTimeline.prototype = {
555	boneIndex: 0,
556	getFrameCount: function () {
557		return this.frames.length / 3;
558	},
559	setFrame: function (frameIndex, time, x, y) {
560		frameIndex *= 3;
561		this.frames[frameIndex] = time;
562		this.frames[frameIndex + 1] = x;
563		this.frames[frameIndex + 2] = y;
564	},
565	apply: function (skeleton, lastTime, time, firedEvents, alpha) {
566		var frames = this.frames;
567		if (time < frames[0]) return; // Time is before first frame.
568
569		var bone = skeleton.bones[this.boneIndex];
570
571		if (time >= frames[frames.length - 3]) { // Time is after last frame.
572			bone.scaleX += (bone.data.scaleX * frames[frames.length - 2] - bone.scaleX) * alpha;
573			bone.scaleY += (bone.data.scaleY * frames[frames.length - 1] - bone.scaleY) * alpha;
574			return;
575		}
576
577		// Interpolate between the previous frame and the current frame.
578		var frameIndex = spine.Animation.binarySearch(frames, time, 3);
579		var prevFrameX = frames[frameIndex - 2];
580		var prevFrameY = frames[frameIndex - 1];
581		var frameTime = frames[frameIndex];
582		var percent = 1 - (time - frameTime) / (frames[frameIndex + -3/*PREV_FRAME_TIME*/] - frameTime);
583		percent = this.curves.getCurvePercent(frameIndex / 3 - 1, percent);
584
585		bone.scaleX += (bone.data.scaleX * (prevFrameX + (frames[frameIndex + 1/*FRAME_X*/] - prevFrameX) * percent) - bone.scaleX) * alpha;
586		bone.scaleY += (bone.data.scaleY * (prevFrameY + (frames[frameIndex + 2/*FRAME_Y*/] - prevFrameY) * percent) - bone.scaleY) * alpha;
587	}
588};
589
590spine.ColorTimeline = function (frameCount) {
591	this.curves = new spine.Curves(frameCount);
592	this.frames = []; // time, r, g, b, a, ...
593	this.frames.length = frameCount * 5;
594};
595spine.ColorTimeline.prototype = {
596	slotIndex: 0,
597	getFrameCount: function () {
598		return this.frames.length / 5;
599	},
600	setFrame: function (frameIndex, time, r, g, b, a) {
601		frameIndex *= 5;
602		this.frames[frameIndex] = time;
603		this.frames[frameIndex + 1] = r;
604		this.frames[frameIndex + 2] = g;
605		this.frames[frameIndex + 3] = b;
606		this.frames[frameIndex + 4] = a;
607	},
608	apply: function (skeleton, lastTime, time, firedEvents, alpha) {
609		var frames = this.frames;
610		if (time < frames[0]) return; // Time is before first frame.
611
612		var r, g, b, a;
613		if (time >= frames[frames.length - 5]) {
614			// Time is after last frame.
615			var i = frames.length - 1;
616			r = frames[i - 3];
617			g = frames[i - 2];
618			b = frames[i - 1];
619			a = frames[i];
620		} else {
621			// Interpolate between the previous frame and the current frame.
622			var frameIndex = spine.Animation.binarySearch(frames, time, 5);
623			var prevFrameR = frames[frameIndex - 4];
624			var prevFrameG = frames[frameIndex - 3];
625			var prevFrameB = frames[frameIndex - 2];
626			var prevFrameA = frames[frameIndex - 1];
627			var frameTime = frames[frameIndex];
628			var percent = 1 - (time - frameTime) / (frames[frameIndex - 5/*PREV_FRAME_TIME*/] - frameTime);
629			percent = this.curves.getCurvePercent(frameIndex / 5 - 1, percent);
630
631			r = prevFrameR + (frames[frameIndex + 1/*FRAME_R*/] - prevFrameR) * percent;
632			g = prevFrameG + (frames[frameIndex + 2/*FRAME_G*/] - prevFrameG) * percent;
633			b = prevFrameB + (frames[frameIndex + 3/*FRAME_B*/] - prevFrameB) * percent;
634			a = prevFrameA + (frames[frameIndex + 4/*FRAME_A*/] - prevFrameA) * percent;
635		}
636		var slot = skeleton.slots[this.slotIndex];
637		if (alpha < 1) {
638			slot.r += (r - slot.r) * alpha;
639			slot.g += (g - slot.g) * alpha;
640			slot.b += (b - slot.b) * alpha;
641			slot.a += (a - slot.a) * alpha;
642		} else {
643			slot.r = r;
644			slot.g = g;
645			slot.b = b;
646			slot.a = a;
647		}
648	}
649};
650
651spine.AttachmentTimeline = function (frameCount) {
652	this.curves = new spine.Curves(frameCount);
653	this.frames = []; // time, ...
654	this.frames.length = frameCount;
655	this.attachmentNames = [];
656	this.attachmentNames.length = frameCount;
657};
658spine.AttachmentTimeline.prototype = {
659	slotIndex: 0,
660	getFrameCount: function () {
661		return this.frames.length;
662	},
663	setFrame: function (frameIndex, time, attachmentName) {
664		this.frames[frameIndex] = time;
665		this.attachmentNames[frameIndex] = attachmentName;
666	},
667	apply: function (skeleton, lastTime, time, firedEvents, alpha) {
668		var frames = this.frames;
669		if (time < frames[0]) {
670			if (lastTime > time) this.apply(skeleton, lastTime, Number.MAX_VALUE, null, 0);
671			return;
672		} else if (lastTime > time) //
673			lastTime = -1;
674
675		var frameIndex = time >= frames[frames.length - 1] ? frames.length - 1 : spine.Animation.binarySearch1(frames, time) - 1;
676		if (frames[frameIndex] < lastTime) return;
677
678		var attachmentName = this.attachmentNames[frameIndex];
679		skeleton.slots[this.slotIndex].setAttachment(
680			!attachmentName ? null : skeleton.getAttachmentBySlotIndex(this.slotIndex, attachmentName));
681	}
682};
683
684spine.EventTimeline = function (frameCount) {
685	this.frames = []; // time, ...
686	this.frames.length = frameCount;
687	this.events = [];
688	this.events.length = frameCount;
689};
690spine.EventTimeline.prototype = {
691	getFrameCount: function () {
692		return this.frames.length;
693	},
694	setFrame: function (frameIndex, time, event) {
695		this.frames[frameIndex] = time;
696		this.events[frameIndex] = event;
697	},
698	/** Fires events for frames > lastTime and <= time. */
699	apply: function (skeleton, lastTime, time, firedEvents, alpha) {
700		if (!firedEvents) return;
701
702		var frames = this.frames;
703		var frameCount = frames.length;
704
705		if (lastTime > time) { // Fire events after last time for looped animations.
706			this.apply(skeleton, lastTime, Number.MAX_VALUE, firedEvents, alpha);
707			lastTime = -1;
708		} else if (lastTime >= frames[frameCount - 1]) // Last time is after last frame.
709			return;
710		if (time < frames[0]) return; // Time is before first frame.
711
712		var frameIndex;
713		if (lastTime < frames[0])
714			frameIndex = 0;
715		else {
716			frameIndex = spine.Animation.binarySearch1(frames, lastTime);
717			var frame = frames[frameIndex];
718			while (frameIndex > 0) { // Fire multiple events with the same frame.
719				if (frames[frameIndex - 1] != frame) break;
720				frameIndex--;
721			}
722		}
723		var events = this.events;
724		for (; frameIndex < frameCount && time >= frames[frameIndex]; frameIndex++)
725			firedEvents.push(events[frameIndex]);
726	}
727};
728
729spine.DrawOrderTimeline = function (frameCount) {
730	this.frames = []; // time, ...
731	this.frames.length = frameCount;
732	this.drawOrders = [];
733	this.drawOrders.length = frameCount;
734};
735spine.DrawOrderTimeline.prototype = {
736	getFrameCount: function () {
737		return this.frames.length;
738	},
739	setFrame: function (frameIndex, time, drawOrder) {
740		this.frames[frameIndex] = time;
741		this.drawOrders[frameIndex] = drawOrder;
742	},
743	apply: function (skeleton, lastTime, time, firedEvents, alpha) {
744		var frames = this.frames;
745		if (time < frames[0]) return; // Time is before first frame.
746
747		var frameIndex;
748		if (time >= frames[frames.length - 1]) // Time is after last frame.
749			frameIndex = frames.length - 1;
750		else
751			frameIndex = spine.Animation.binarySearch1(frames, time) - 1;
752
753		var drawOrder = skeleton.drawOrder;
754		var slots = skeleton.slots;
755		var drawOrderToSetupIndex = this.drawOrders[frameIndex];
756		if (!drawOrderToSetupIndex) {
757			for (var i = 0, n = slots.length; i < n; i++)
758				drawOrder[i] = slots[i];
759		} else {
760			for (var i = 0, n = drawOrderToSetupIndex.length; i < n; i++)
761				drawOrder[i] = skeleton.slots[drawOrderToSetupIndex[i]];
762		}
763
764	}
765};
766
767spine.FfdTimeline = function (frameCount) {
768	this.curves = new spine.Curves(frameCount);
769	this.frames = [];
770	this.frames.length = frameCount;
771	this.frameVertices = [];
772	this.frameVertices.length = frameCount;
773};
774spine.FfdTimeline.prototype = {
775	slotIndex: 0,
776	attachment: 0,
777	getFrameCount: function () {
778		return this.frames.length;
779	},
780	setFrame: function (frameIndex, time, vertices) {
781		this.frames[frameIndex] = time;
782		this.frameVertices[frameIndex] = vertices;
783	},
784	apply: function (skeleton, lastTime, time, firedEvents, alpha) {
785		var slot = skeleton.slots[this.slotIndex];
786		if (slot.attachment != this.attachment) return;
787
788		var frames = this.frames;
789		if (time < frames[0]) return; // Time is before first frame.
790
791		var frameVertices = this.frameVertices;
792		var vertexCount = frameVertices[0].length;
793
794		var vertices = slot.attachmentVertices;
795		if (vertices.length != vertexCount) alpha = 1;
796		vertices.length = vertexCount;
797
798		if (time >= frames[frames.length - 1]) { // Time is after last frame.
799			var lastVertices = frameVertices[frames.length - 1];
800			if (alpha < 1) {
801				for (var i = 0; i < vertexCount; i++)
802					vertices[i] += (lastVertices[i] - vertices[i]) * alpha;
803			} else {
804				for (var i = 0; i < vertexCount; i++)
805					vertices[i] = lastVertices[i];
806			}
807			return;
808		}
809
810		// Interpolate between the previous frame and the current frame.
811		var frameIndex = spine.Animation.binarySearch1(frames, time);
812		var frameTime = frames[frameIndex];
813		var percent = 1 - (time - frameTime) / (frames[frameIndex - 1] - frameTime);
814		percent = this.curves.getCurvePercent(frameIndex - 1, percent < 0 ? 0 : (percent > 1 ? 1 : percent));
815
816		var prevVertices = frameVertices[frameIndex - 1];
817		var nextVertices = frameVertices[frameIndex];
818
819		if (alpha < 1) {
820			for (var i = 0; i < vertexCount; i++) {
821				var prev = prevVertices[i];
822				vertices[i] += (prev + (nextVertices[i] - prev) * percent - vertices[i]) * alpha;
823			}
824		} else {
825			for (var i = 0; i < vertexCount; i++) {
826				var prev = prevVertices[i];
827				vertices[i] = prev + (nextVertices[i] - prev) * percent;
828			}
829		}
830	}
831};
832

1125			if (bones[i].data.name == boneName) return bones[i];
1126		return null;
1127	},
1128	/** @return -1 if the bone was not found. */
1129	findBoneIndex: function (boneName) {
1130		var bones = this.bones;
1131		for (var i = 0, n = bones.length; i < n; i++)
1132			if (bones[i].data.name == boneName) return i;
1133		return -1;
1134	},
1135	/** @return May be null. */
1136	findSlot: function (slotName) {
1137		var slots = this.slots;
1138		for (var i = 0, n = slots.length; i < n; i++)
1139			if (slots[i].data.name == slotName) return slots[i];
1140		return null;
1141	},
1142	/** @return -1 if the bone was not found. */
1143	findSlotIndex: function (slotName) {
1144		var slots = this.slots;
1145		for (var i = 0, n = slots.length; i < n; i++)
1146			if (slots[i].data.name == slotName) return i;
1147		return -1;
1148	},
1149	setSkinByName: function (skinName) {
1150		var skin = this.data.findSkin(skinName);
1151		if (!skin) throw "Skin not found: " + skinName;
1152		this.setSkin(skin);
1153	},
1154	/** Sets the skin used to look up attachments before looking in the {@link SkeletonData#getDefaultSkin() default skin}. 
1155	 * Attachments from the new skin are attached if the corresponding attachment from the old skin was attached. If there was 
1156	 * no old skin, each slot's setup mode attachment is attached from the new skin.
1157	 * @param newSkin May be null. */
1158	setSkin: function (newSkin) {
1159		if (newSkin) {
1160			if (this.skin)
1161				newSkin._attachAll(this, this.skin);
1162			else {
1163				var slots = this.slots;
1164				for (var i = 0, n = slots.length; i < n; i++) {
1165					var slot = slots[i];
1166					var name = slot.data.attachmentName;
1167					if (name) {
1168						var attachment = newSkin.getAttachment(i, name);
1169						if (attachment) slot.setAttachment(attachment);
1170					}
1171				}
1172			}
1173		}
1174		this.skin = newSkin;
1175	},
1176	/** @return May be null. */
1177	getAttachmentBySlotName: function (slotName, attachmentName) {
1178		return this.getAttachmentBySlotIndex(this.data.findSlotIndex(slotName), attachmentName);
1179	},
1180	/** @return May be null. */
1181	getAttachmentBySlotIndex: function (slotIndex, attachmentName) {
1182		if (this.skin) {
1183			var attachment = this.skin.getAttachment(slotIndex, attachmentName);
1184			if (attachment) return attachment;
1185		}
1186		if (this.data.defaultSkin) return this.data.defaultSkin.getAttachment(slotIndex, attachmentName);
1187		return null;
1188	},
1189	/** @param attachmentName May be null. */
1190	setAttachment: function (slotName, attachmentName) {
1191		var slots = this.slots;
1192		for (var i = 0, n = slots.length; i < n; i++) {
1193			var slot = slots[i];
1194			if (slot.data.name == slotName) {
1195				var attachment = null;
1196				if (attachmentName) {
1197					attachment = this.getAttachmentBySlotIndex(i, attachmentName);
1198					if (!attachment) throw "Attachment not found: " + attachmentName + ", for slot: " + slotName;
1199				}
1200				slot.setAttachment(attachment);
1201				return;
1202			}
1203		}
1204		throw "Slot not found: " + slotName;
1205	},
1206	/** @return May be null. */
1207	findIkConstraint: function (ikConstraintName) {
1208		var ikConstraints = this.ikConstraints;
1209		for (var i = 0, n = ikConstraints.length; i < n; i++)
1210			if (ikConstraints[i].data.name == ikConstraintName) return ikConstraints[i];
1211		return null;
1212	},
1213	update: function (delta) {
1214		this.time += delta;
1215	}
1216};
1217
1218spine.EventData = function (name) {
1219	this.name = name;
1220};
1221spine.EventData.prototype = {
1222	intValue: 0,
1223	floatValue: 0,
1224	stringValue: null
1225};
1226
1227spine.Event = function (data) {
1228	this.data = data;
1229};
1230spine.Event.prototype = {
1231	intValue: 0,
1232	floatValue: 0,
1233	stringValue: null
1234};
1235
1236spine.AttachmentType = {
1237	region: 0,
1238	boundingbox: 1,
1239	mesh: 2,
1240	skinnedmesh: 3
1241};
1242
1243spine.RegionAttachment = function (name) {
1244	this.name = name;
1245	this.offset = [];
1246	this.offset.length = 8;
1247	this.uvs = [];
1248	this.uvs.length = 8;
1249};
1250spine.RegionAttachment.prototype = {
1251	type: spine.AttachmentType.region,
1252	x: 0, y: 0,
1253	rotation: 0,
1254	scaleX: 1, scaleY: 1,
1255	width: 0, height: 0,
1256	r: 1, g: 1, b: 1, a: 1,
1257	path: null,
1258	rendererObject: null,
1259	regionOffsetX: 0, regionOffsetY: 0,
1260	regionWidth: 0, regionHeight: 0,
1261	regionOriginalWidth: 0, regionOriginalHeight: 0,
1262	setUVs: function (u, v, u2, v2, rotate) {
1263		var uvs = this.uvs;
1264		if (rotate) {
1265			uvs[2/*X2*/] = u;
1266			uvs[3/*Y2*/] = v2;
1267			uvs[4/*X3*/] = u;
1268			uvs[5/*Y3*/] = v;
1269			uvs[6/*X4*/] = u2;
1270			uvs[7/*Y4*/] = v;
1271			uvs[0/*X1*/] = u2;
1272			uvs[1/*Y1*/] = v2;
1273		} else {
1274			uvs[0/*X1*/] = u;
1275			uvs[1/*Y1*/] = v2;
1276			uvs[2/*X2*/] = u;
1277			uvs[3/*Y2*/] = v;
1278			uvs[4/*X3*/] = u2;
1279			uvs[5/*Y3*/] = v;
1280			uvs[6/*X4*/] = u2;
1281			uvs[7/*Y4*/] = v2;
1282		}
1283	},
1284	updateOffset: function () {
1285		var regionScaleX = this.width / this.regionOriginalWidth * this.scaleX;
1286		var regionScaleY = this.height / this.regionOriginalHeight * this.scaleY;
1287		var localX = -this.width / 2 * this.scaleX + this.regionOffsetX * regionScaleX;
1288		var localY = -this.height / 2 * this.scaleY + this.regionOffsetY * regionScaleY;
1289		var localX2 = localX + this.regionWidth * regionScaleX;
1290		var localY2 = localY + this.regionHeight * regionScaleY;
1291
1292        var regionScaleX = 1;
1293        var regionScaleY = 1;
1294        var localX = 0;
1295        var localY = 0;
1296        var localX2 = 0;
1297        var localY2 = 0;
1298
1299		var radians = this.rotation * spine.degRad;
1300		var cos = Math.cos(radians);
1301		var sin = Math.sin(radians);
1302		var localXCos = localX * cos + this.x;
1303		var localXSin = localX * sin;
1304		var localYCos = localY * cos + this.y;
1305		var localYSin = localY * sin;
1306		var localX2Cos = localX2 * cos + this.x;
1307		var localX2Sin = localX2 * sin;
1308		var localY2Cos = localY2 * cos + this.y;
1309		var localY2Sin = localY2 * sin;
1310		var offset = this.offset;
1311		offset[0/*X1*/] = localXCos - localYSin;
1312		offset[1/*Y1*/] = localYCos + localXSin;
1313		offset[2/*X2*/] = localXCos - localY2Sin;
1314		offset[3/*Y2*/] = localY2Cos + localXSin;
1315		offset[4/*X3*/] = localX2Cos - localY2Sin;
1316		offset[5/*Y3*/] = localY2Cos + localX2Sin;
1317		offset[6/*X4*/] = localX2Cos - localYSin;
1318		offset[7/*Y4*/] = localYCos + localX2Sin;
1319	},
1320	computeVertices: function (x, y, bone, vertices) {
1321		x += bone.worldX;
1322		y += bone.worldY;
1323		var m00 = bone.m00, m01 = bone.m01, m10 = bone.m10, m11 = bone.m11;
1324		var offset = this.offset;
1325		vertices[0/*X1*/] = offset[0/*X1*/] * m00 + offset[1/*Y1*/] * m01 + x;
1326		vertices[1/*Y1*/] = offset[0/*X1*/] * m10 + offset[1/*Y1*/] * m11 + y;
1327		vertices[2/*X2*/] = offset[2/*X2*/] * m00 + offset[3/*Y2*/] * m01 + x;
1328		vertices[3/*Y2*/] = offset[2/*X2*/] * m10 + offset[3/*Y2*/] * m11 + y;
1329		vertices[4/*X3*/] = offset[4/*X3*/] * m00 + offset[5/*X3*/] * m01 + x;
1330		vertices[5/*X3*/] = offset[4/*X3*/] * m10 + offset[5/*X3*/] * m11 + y;
1331		vertices[6/*X4*/] = offset[6/*X4*/] * m00 + offset[7/*Y4*/] * m01 + x;
1332		vertices[7/*Y4*/] = offset[6/*X4*/] * m10 + offset[7/*Y4*/] * m11 + y;
1333	}
1334};
1335
1336spine.MeshAttachment = function (name) {
1337	this.name = name;
1338};
1339spine.MeshAttachment.prototype = {
1340	type: spine.AttachmentType.mesh,
1341	vertices: null,
1342	uvs: null,
1343	regionUVs: null,
1344	triangles: null,
1345	hullLength: 0,
1346	r: 1, g: 1, b: 1, a: 1,
1347	path: null,
1348	rendererObject: null,
1349	regionU: 0, regionV: 0, regionU2: 0, regionV2: 0, regionRotate: false,
1350	regionOffsetX: 0, regionOffsetY: 0,
1351	regionWidth: 0, regionHeight: 0,
1352	regionOriginalWidth: 0, regionOriginalHeight: 0,
1353	edges: null,
1354	width: 0, height: 0,
1355	updateUVs: function () {
1356		var width = this.regionU2 - this.regionU, height = this.regionV2 - this.regionV;
1357		var n = this.regionUVs.length;
1358		if (!this.uvs || this.uvs.length != n) {
1359            this.uvs = new spine.Float32Array(n);
1360		}
1361		if (this.regionRotate) {
1362			for (var i = 0; i < n; i += 2) {
1363                this.uvs[i] = this.regionU + this.regionUVs[i + 1] * width;
1364                this.uvs[i + 1] = this.regionV + height - this.regionUVs[i] * height;
1365			}
1366		} else {
1367			for (var i = 0; i < n; i += 2) {
1368                this.uvs[i] = this.regionU + this.regionUVs[i] * width;
1369                this.uvs[i + 1] = this.regionV + this.regionUVs[i + 1] * height;
1370			}
1371		}
1372	},
1373	computeWorldVertices: function (x, y, slot, worldVertices) {
1374		var bone = slot.bone;
1375		x += bone.worldX;
1376		y += bone.worldY;
1377		var m00 = bone.m00, m01 = bone.m01, m10 = bone.m10, m11 = bone.m11;
1378		var vertices = this.vertices;
1379		var verticesCount = vertices.length;
1380		if (slot.attachmentVertices.length == verticesCount) vertices = slot.attachmentVertices;
1381		for (var i = 0; i < verticesCount; i += 2) {
1382			var vx = vertices[i];
1383			var vy = vertices[i + 1];
1384			worldVertices[i] = vx * m00 + vy * m01 + x;
1385			worldVertices[i + 1] = vx * m10 + vy * m11 + y;
1386		}
1387	}
1388};
1389
1390spine.SkinnedMeshAttachment = function (name) {
1391	this.name = name;
1392};
1393spine.SkinnedMeshAttachment.prototype = {
1394	type: spine.AttachmentType.skinnedmesh,
1395	bones: null,
1396	weights: null,
1397	uvs: null,
1398	regionUVs: null,
1399	triangles: null,
1400	hullLength: 0,
1401	r: 1, g: 1, b: 1, a: 1,
1402	path: null,
1403	rendererObject: null,
1404	regionU: 0, regionV: 0, regionU2: 0, regionV2: 0, regionRotate: false,
1405	regionOffsetX: 0, regionOffsetY: 0,
1406	regionWidth: 0, regionHeight: 0,
1407	regionOriginalWidth: 0, regionOriginalHeight: 0,
1408	edges: null,
1409	width: 0, height: 0,
1410	updateUVs: function (u, v, u2, v2, rotate) {
1411		var width = this.regionU2 - this.regionU, height = this.regionV2 - this.regionV;
1412		var n = this.regionUVs.length;
1413		if (!this.uvs || this.uvs.length != n) {
1414            this.uvs = new spine.Float32Array(n);
1415		}
1416		if (this.regionRotate) {
1417			for (var i = 0; i < n; i += 2) {
1418                this.uvs[i] = this.regionU + this.regionUVs[i + 1] * width;
1419                this.uvs[i + 1] = this.regionV + height - this.regionUVs[i] * height;
1420			}
1421		} else {
1422			for (var i = 0; i < n; i += 2) {
1423                this.uvs[i] = this.regionU + this.regionUVs[i] * width;
1424                this.uvs[i + 1] = this.regionV + this.regionUVs[i + 1] * height;
1425			}
1426		}
1427	},
1428	computeWorldVertices: function (x, y, slot, worldVertices) {
1429		var skeletonBones = slot.bone.skeleton.bones;
1430		var weights = this.weights;
1431		var bones = this.bones;
1432
1433		var w = 0, v = 0, b = 0, f = 0, n = bones.length, nn;
1434		var wx, wy, bone, vx, vy, weight;
1435		if (!slot.attachmentVertices.length) {
1436			for (; v < n; w += 2) {
1437				wx = 0;
1438				wy = 0;
1439				nn = bones[v++] + v;
1440				for (; v < nn; v++, b += 3) {
1441					bone = skeletonBones[bones[v]];
1442					vx = weights[b];
1443					vy = weights[b + 1];
1444					weight = weights[b + 2];
1445					wx += (vx * bone.m00 + vy * bone.m01 + bone.worldX) * weight;
1446					wy += (vx * bone.m10 + vy * bone.m11 + bone.worldY) * weight;
1447				}
1448				worldVertices[w] = wx + x;
1449				worldVertices[w + 1] = wy + y;
1450			}
1451		} else {
1452			var ffd = slot.attachmentVertices;
1453			for (; v < n; w += 2) {
1454				wx = 0;
1455				wy = 0;
1456				nn = bones[v++] + v;
1457				for (; v < nn; v++, b += 3, f += 2) {
1458					bone = skeletonBones[bones[v]];
1459					vx = weights[b] + ffd[f];
1460					vy = weights[b + 1] + ffd[f + 1];
1461					weight = weights[b + 2];
1462					wx += (vx * bone.m00 + vy * bone.m01 + bone.worldX) * weight;
1463					wy += (vx * bone.m10 + vy * bone.m11 + bone.worldY) * weight;
1464				}
1465				worldVertices[w] = wx + x;
1466				worldVertices[w + 1] = wy + y;
1467			}
1468		}
1469	}
1470};
1471
1472spine.BoundingBoxAttachment = function (name) {
1473	this.name = name;
1474	this.vertices = [];
1475};
1476spine.BoundingBoxAttachment.prototype = {
1477	type: spine.AttachmentType.boundingbox,
1478	computeWorldVertices: function (x, y, bone, worldVertices) {
1479		x += bone.worldX;
1480		y += bone.worldY;
1481		var m00 = bone.m00, m01 = bone.m01, m10 = bone.m10, m11 = bone.m11;
1482		var vertices = this.vertices;
1483		for (var i = 0, n = vertices.length; i < n; i += 2) {
1484			var px = vertices[i];
1485			var py = vertices[i + 1];
1486			worldVertices[i] = px * m00 + py * m01 + x;
1487			worldVertices[i + 1] = px * m10 + py * m11 + y;
1488		}
1489	}
1490};
1491
1492spine.AnimationStateData = function (skeletonData) {
1493	this.skeletonData = skeletonData;
1494	this.animationToMixTime = {};
1495};
1496spine.AnimationStateData.prototype = {
1497	defaultMix: 0,
1498	setMixByName: function (fromName, toName, duration) {
1499		var from = this.skeletonData.findAnimation(fromName);
1500		if (!from) throw "Animation not found: " + fromName;
1501		var to = this.skeletonData.findAnimation(toName);
1502		if (!to) throw "Animation not found: " + toName;
1503		this.setMix(from, to, duration);
1504	},
1505	setMix: function (from, to, duration) {
1506		this.animationToMixTime[from.name + ":" + to.name] = duration;
1507	},
1508	getMix: function (from, to) {
1509		var key = from.name + ":" + to.name;
1510		return this.animationToMixTime.hasOwnProperty(key) ? this.animationToMixTime[key] : this.defaultMix;
1511	}
1512};
1513
1514spine.TrackEntry = function () {};
1515spine.TrackEntry.prototype = {
1516	next: null, previous: null,
1517	animation: null,
1518	loop: false,
1519	delay: 0, time: 0, lastTime: -1, endTime: 0,
1520	timeScale: 1,
1521	mixTime: 0, mixDuration: 0, mix: 1,
1522	onStart: null, onEnd: null, onComplete: null, onEvent: null
1523};
1524
1525spine.AnimationState = function (stateData) {
1526	this.data = stateData;
1527	this.tracks = [];
1528	this.events = [];
1529};
1530spine.AnimationState.prototype = {
1531	onStart: null,
1532	onEnd: null,
1533	onComplete: null,
1534	onEvent: null,
1535	timeScale: 1,
1536	update: function (delta) {
1537		delta *= this.timeScale;
1538		for (var i = 0; i < this.tracks.length; i++) {
1539			var current = this.tracks[i];
1540			if (!current) continue;
1541
1542			current.time += delta * current.timeScale;
1543			if (current.previous) {
1544				var previousDelta = delta * current.previous.timeScale;
1545				current.previous.time += previousDelta;
1546				current.mixTime += previousDelta;
1547			}
1548
1549			var next = current.next;
1550			if (next) {
1551				next.time = current.lastTime - next.delay;
1552				if (next.time >= 0) this.setCurrent(i, next);
1553			} else {
1554				// End non-looping animation when it reaches its end time and there is no next entry.
1555				if (!current.loop && current.lastTime >= current.endTime) this.clearTrack(i);
1556			}
1557		}
1558	},
1559	apply: function (skeleton) {
1560		for (var i = 0; i < this.tracks.length; i++) {
1561			var current = this.tracks[i];
1562			if (!current) continue;
1563
1564			this.events.length = 0;
1565
1566			var time = current.time;
1567			var lastTime = current.lastTime;
1568			var endTime = current.endTime;
1569			var loop = current.loop;
1570			if (!loop && time > endTime) time = endTime;
1571
1572			var previous = current.previous;
1573			if (!previous) {
1574				if (current.mix == 1)
1575					current.animation.apply(skeleton, current.lastTime, time, loop, this.events);
1576				else
1577					current.animation.mix(skeleton, current.lastTime, time, loop, this.events, current.mix);
1578			} else {
1579				var previousTime = previous.time;
1580				if (!previous.loop && previousTime > previous.endTime) previousTime = previous.endTime;
1581				previous.animation.apply(skeleton, previousTime, previousTime, previous.loop, null);
1582
1583				var alpha = current.mixTime / current.mixDuration * current.mix;
1584				if (alpha >= 1) {
1585					alpha = 1;
1586					current.previous = null;
1587				}
1588				current.animation.mix(skeleton, current.lastTime, time, loop, this.events, alpha);
1589			}
1590
1591			for (var ii = 0, nn = this.events.length; ii < nn; ii++) {
1592				var event = this.events[ii];
1593				if (current.onEvent) current.onEvent(i, event);
1594				if (this.onEvent) this.onEvent(i, event);
1595			}
1596
1597			// Check if completed the animation or a loop iteration.
1598			if (loop ? (lastTime % endTime > time % endTime) : (lastTime < endTime && time >= endTime)) {
1599				var count = Math.floor(time / endTime);
1600				if (current.onComplete) current.onComplete(i, count);
1601				if (this.onComplete) this.onComplete(i, count);
1602			}
1603
1604			current.lastTime = current.time;
1605		}
1606	},
1607	clearTracks: function () {
1608		for (var i = 0, n = this.tracks.length; i < n; i++)
1609			this.clearTrack(i);
1610		this.tracks.length = 0; 
1611	},
1612	clearTrack: function (trackIndex) {
1613		if (trackIndex >= this.tracks.length) return;
1614		var current = this.tracks[trackIndex];
1615		if (!current) return;
1616
1617		if (current.onEnd) current.onEnd(trackIndex);
1618		if (this.onEnd) this.onEnd(trackIndex);
1619
1620		this.tracks[trackIndex] = null;
1621	},
1622	_expandToIndex: function (index) {
1623		if (index < this.tracks.length) return this.tracks[index];
1624		while (index >= this.tracks.length)
1625			this.tracks.push(null);
1626		return null;
1627	},
1628	setCurrent: function (index, entry) {
1629		var current = this._expandToIndex(index);
1630		if (current) {
1631			var previous = current.previous;
1632			current.previous = null;
1633
1634			if (current.onEnd) current.onEnd(index);
1635			if (this.onEnd) this.onEnd(index);
1636
1637			entry.mixDuration = this.data.getMix(current.animation, entry.animation);
1638			if (entry.mixDuration > 0) {
1639				entry.mixTime = 0;
1640				// If a mix is in progress, mix from the closest animation.
1641				if (previous && current.mixTime / current.mixDuration < 0.5)
1642					entry.previous = previous;
1643				else
1644					entry.previous = current;
1645			}
1646		}
1647
1648		this.tracks[index] = entry;
1649
1650		if (entry.onStart) entry.onStart(index);
1651		if (this.onStart) this.onStart(index);
1652	},
1653	setAnimationByName: function (trackIndex, animationName, loop) {
1654		var animation = this.data.skeletonData.findAnimation(animationName);
1655		if (!animation) throw "Animation not found: " + animationName;
1656		return this.setAnimation(trackIndex, animation, loop);
1657	},
1658	/** Set the current animation. Any queued animations are cleared. */
1659	setAnimation: function (trackIndex, animation, loop) {
1660		var entry = new spine.TrackEntry();
1661		entry.animation = animation;
1662		entry.loop = loop;
1663		entry.endTime = animation.duration;
1664		this.setCurrent(trackIndex, entry);
1665		return entry;
1666	},
1667	addAnimationByName: function (trackIndex, animationName, loop, delay) {
1668		var animation = this.data.skeletonData.findAnimation(animationName);
1669		if (!animation) throw "Animation not found: " + animationName;
1670		return this.addAnimation(trackIndex, animation, loop, delay);
1671	},
1672	/** Adds an animation to be played delay seconds after the current or last queued animation.
1673	 * @param delay May be <= 0 to use duration of previous animation minus any mix duration plus the negative delay. */
1674	addAnimation: function (trackIndex, animation, loop, delay) {
1675		var entry = new spine.TrackEntry();
1676		entry.animation = animation;
1677		entry.loop = loop;
1678		entry.endTime = animation.duration;
1679
1680		var last = this._expandToIndex(trackIndex);
1681		if (last) {
1682			while (last.next)
1683				last = last.next;
1684			last.next = entry;
1685		} else
1686			this.tracks[trackIndex] = entry;
1687
1688		if (delay <= 0) {
1689			if (last)
1690				delay += last.endTime - this.data.getMix(last.animation, animation);
1691			else

2290				region.v2 = (y + height) / page.height;
2291			}
2292			region.x = x;
2293			region.y = y;
2294			region.width = Math.abs(width);
2295			region.height = Math.abs(height);
2296
2297			if (reader.readTuple(tuple) == 4) { // split is optional
2298				region.splits = [parseInt(tuple[0]), parseInt(tuple[1]), parseInt(tuple[2]), parseInt(tuple[3])];
2299
2300				if (reader.readTuple(tuple) == 4) { // pad is optional, but only present with splits
2301					region.pads = [parseInt(tuple[0]), parseInt(tuple[1]), parseInt(tuple[2]), parseInt(tuple[3])];
2302
2303					reader.readTuple(tuple);
2304				}
2305			}
2306
2307			region.originalWidth = parseInt(tuple[0]);
2308			region.originalHeight = parseInt(tuple[1]);
2309
2310			reader.readTuple(tuple);
2311			region.offsetX = parseInt(tuple[0]);
2312			region.offsetY = parseInt(tuple[1]);
2313
2314			region.index = parseInt(reader.readValue());
2315
2316			this.regions.push(region);
2317		}
2318	}
2319};
2320spine.Atlas.prototype = {
2321	findRegion: function (name) {
2322		var regions = this.regions;
2323		for (var i = 0, n = regions.length; i < n; i++)
2324			if (regions[i].name == name) return regions[i];
2325		return null;
2326	},
2327	dispose: function () {
2328		var pages = this.pages;
2329		for (var i = 0, n = pages.length; i < n; i++)
2330			this.textureLoader.unload(pages[i].rendererObject);
2331	},
2332	updateUVs: function (page) {
2333		var regions = this.regions;
2334		for (var i = 0, n = regions.length; i < n; i++) {
2335			var region = regions[i];
2336			if (region.page != page) continue;
2337			region.u = region.x / page.width;
2338			region.v = region.y / page.height;
2339			if (region.rotate) {
2340				region.u2 = (region.x + region.height) / page.width;
2341				region.v2 = (region.y + region.width) / page.height;
2342			} else {
2343				region.u2 = (region.x + region.width) / page.width;
2344				region.v2 = (region.y + region.height) / page.height;
2345			}
2346		}
2347	}
2348};
2349
2350spine.Atlas.Format = {
2351	alpha: 0,
2352	intensity: 1,
2353	luminanceAlpha: 2,
2354	rgb565: 3,
2355	rgba4444: 4,
2356	rgb888: 5,
2357	rgba8888: 6
2358};
2359
2360spine.Atlas.TextureFilter = {
2361	nearest: 0,
2362	linear: 1,
2363	mipMap: 2,
2364	mipMapNearestNearest: 3,
2365	mipMapLinearNearest: 4,
2366	mipMapNearestLinear: 5,
2367	mipMapLinearLinear: 6
2368};
2369
2370spine.Atlas.TextureWrap = {
2371	mirroredRepeat: 0,
2372	clampToEdge: 1,
2373	repeat: 2
2374};
2375
2376spine.AtlasPage = function () {};
2377spine.AtlasPage.prototype = {
2378	name: null,
2379	format: null,
2380	minFilter: null,
2381	magFilter: null,
2382	uWrap: null,
2383	vWrap: null,
2384	rendererObject: null,
2385	width: 0,
2386	height: 0
2387};
2388
2389spine.AtlasRegion = function () {};
2390spine.AtlasRegion.prototype = {
2391	page: null,
2392	name: null,
2393	x: 0, y: 0,
2394	width: 0, height: 0,
2395	u: 0, v: 0, u2: 0, v2: 0,
2396	offsetX: 0, offsetY: 0,
2397	originalWidth: 0, originalHeight: 0,
2398	index: 0,
2399	rotate: false,
2400	splits: null,
2401	pads: null
2402};
2403
2404spine.AtlasReader = function (text) {
2405	this.lines = text.split(/\r\n|\r|\n/);
2406};
2407spine.AtlasReader.prototype = {
2408	index: 0,
2409	trim: function (value) {
2410		return value.replace(/^\s+|\s+$/g, "");
2411	},
2412	readLine: function () {
2413		if (this.index >= this.lines.length) return null;
2414		return this.lines[this.index++];
2415	},
2416	readValue: function () {
2417		var line = this.readLine();
2418		var colon = line.indexOf(":");
2419		if (colon == -1) throw "Invalid line: " + line;
2420		return this.trim(line.substring(colon + 1));
2421	},
2422	/** Returns the number of tuple values read (1, 2 or 4). */
2423	readTuple: function (tuple) {
2424		var line = this.readLine();
2425		var colon = line.indexOf(":");
2426		if (colon == -1) throw "Invalid line: " + line;
2427		var i = 0, lastMatch = colon + 1;
2428		for (; i < 3; i++) {
2429			var comma = line.indexOf(",", lastMatch);
2430			if (comma == -1) break;
2431			tuple[i] = this.trim(line.substr(lastMatch, comma - lastMatch));
2432			lastMatch = comma + 1;
2433		}
2434		tuple[i] = this.trim(line.substring(lastMatch));
2435		return i + 1;
2436	}
2437};
2438
2439spine.AtlasAttachmentLoader = function (atlas) {
2440	this.atlas = atlas;
2441};
2442spine.AtlasAttachmentLoader.prototype = {
2443	newRegionAttachment: function (skin, name, path) {
2444		var region = this.atlas.findRegion(path);
2445		if (!region) throw "Region not found in atlas: " + path + " (region attachment: " + name + ")";
2446		var attachment = new spine.RegionAttachment(name);
2447		attachment.rendererObject = region;
2448		attachment.setUVs(region.u, region.v, region.u2, region.v2, region.rotate);
2449		attachment.regionOffsetX = region.offsetX;
2450		attachment.regionOffsetY = region.offsetY;
2451		attachment.regionWidth = region.width;
2452		attachment.regionHeight = region.height;
2453		attachment.regionOriginalWidth = region.originalWidth;
2454		attachment.regionOriginalHeight = region.originalHeight;
2455		return attachment;
2456	},
2457	newMeshAttachment: function (skin, name, path) {
2458		var region = this.atlas.findRegion(path);
2459		if (!region) throw "Region not found in atlas: " + path + " (mesh attachment: " + name + ")";
2460		var attachment = new spine.MeshAttachment(name);
2461		attachment.rendererObject = region;
2462		attachment.regionU = region.u;
2463		attachment.regionV = region.v;
2464		attachment.regionU2 = region.u2;
2465		attachment.regionV2 = region.v2;
2466		attachment.regionRotate = region.rotate;
2467		attachment.regionOffsetX = region.offsetX;
2468		attachment.regionOffsetY = region.offsetY;
2469		attachment.regionWidth = region.width;
2470		attachment.regionHeight = region.height;
2471		attachment.regionOriginalWidth = region.originalWidth;
2472		attachment.regionOriginalHeight = region.originalHeight;
2473		return attachment;
2474	},
2475	newSkinnedMeshAttachment: function (skin, name, path) {
2476		var region = this.atlas.findRegion(path);
2477		if (!region) throw "Region not found in atlas: " + path + " (skinned mesh attachment: " + name + ")";
2478		var attachment = new spine.SkinnedMeshAttachment(name);
2479		attachment.rendererObject = region;
2480		attachment.regionU = region.u;
2481		attachment.regionV = region.v;
2482		attachment.regionU2 = region.u2;
2483		attachment.regionV2 = region.v2;
2484		attachment.regionRotate = region.rotate;
2485		attachment.regionOffsetX = region.offsetX;
2486		attachment.regionOffsetY = region.offsetY;
2487		attachment.regionWidth = region.width;
2488		attachment.regionHeight = region.height;
2489		attachment.regionOriginalWidth = region.originalWidth;
2490		attachment.regionOriginalHeight = region.originalHeight;
2491		return attachment;
2492	},
2493	newBoundingBoxAttachment: function (skin, name) {
2494		return new spine.BoundingBoxAttachment(name);
2495	}
2496};
2497spine.SkeletonBounds = function () {
2498    this.polygonPool = [];
2499    this.polygons = [];
2500    this.boundingBoxes = [];
2501};
2502spine.SkeletonBounds.prototype = {
2503    minX: 0, minY: 0, maxX: 0, maxY: 0,
2504    update: function (skeleton, updateAabb) {
2505        var slots = skeleton.slots;
2506        var slotCount = slots.length;
2507        var x = skeleton.x, y = skeleton.y;
2508        var boundingBoxes = this.boundingBoxes;
2509        var polygonPool = this.polygonPool;
2510        var polygons = this.polygons;
2511
2512        boundingBoxes.length = 0;
2513        for (var i = 0, n = polygons.length; i < n; i++)
2514            polygonPool.push(polygons[i]);
2515        polygons.length = 0;
2516
2517        for (var i = 0; i < slotCount; i++) {
2518            var slot = slots[i];
2519            var boundingBox = slot.attachment;
2520            if (!boundingBox || boundingBox.type != spine.AttachmentType.boundingbox) continue;
2521            boundingBoxes.push(boundingBox);
2522
2523            var poolCount = polygonPool.length, polygon;
2524            if (poolCount > 0) {
2525                polygon = polygonPool[poolCount - 1];
2526                polygonPool.splice(poolCount - 1, 1);
2527            } else
2528                polygon = [];
2529            polygons.push(polygon);
2530
2531            polygon.length = boundingBox.vertices.length;
2532            boundingBox.computeWorldVertices(x, y, slot.bone, polygon);
2533        }
2534
2535        if (updateAabb) this.aabbCompute();
2536    },
2537    aabbCompute: function () {
2538        var polygons = this.polygons;
2539        var minX = Number.MAX_VALUE, minY = Number.MAX_VALUE, maxX = Number.MIN_VALUE, maxY = Number.MIN_VALUE;
2540        for (var i = 0, n = polygons.length; i < n; i++) {
2541            var vertices = polygons[i];
2542            for (var ii = 0, nn = vertices.length; ii < nn; ii += 2) {
2543                var x = vertices[ii];
2544                var y = vertices[ii + 1];
2545                minX = Math.min(minX, x);
2546                minY = Math.min(minY, y);
2547                maxX = Math.max(maxX, x);
2548                maxY = Math.max(maxY, y);
2549            }
2550        }
2551        this.minX = minX;
2552        this.minY = minY;
2553        this.maxX = maxX;
2554        this.maxY = maxY;
2555    },
2556    /** Returns true if the axis aligned bounding box contains the point. */
2557    aabbContainsPoint: function (x, y) {
2558        return x >= this.minX && x <= this.maxX && y >= this.minY && y <= this.maxY;
2559    },
2560    /** Returns true if the axis aligned bounding box intersects the line segment. */
2561    aabbIntersectsSegment: function (x1, y1, x2, y2) {
2562        var minX = this.minX, minY = this.minY, maxX = this.maxX, maxY = this.maxY;
2563        if ((x1 <= minX && x2 <= minX) || (y1 <= minY && y2 <= minY) || (x1 >= maxX && x2 >= maxX) || (y1 >= maxY && y2 >= maxY))
2564            return false;
2565        var m = (y2 - y1) / (x2 - x1);
2566        var y = m * (minX - x1) + y1;
2567        if (y > minY && y < maxY) return true;
2568        y = m * (maxX - x1) + y1;
2569        if (y > minY && y < maxY) return true;
2570        var x = (minY - y1) / m + x1;
2571        if (x > minX && x < maxX) return true;
2572        x = (maxY - y1) / m + x1;
2573        if (x > minX && x < maxX) return true;
2574        return false;
2575    },
2576    /** Returns true if the axis aligned bounding box intersects the axis aligned bounding box of the specified bounds. */
2577    aabbIntersectsSkeleton: function (bounds) {
2578        return this.minX < bounds.maxX && this.maxX > bounds.minX && this.minY < bounds.maxY && this.maxY >

2601        for (var ii = 0; ii < nn; ii += 2) {
2602            var vertexY = polygon[ii + 1];
2603            var prevY = polygon[prevIndex + 1];
2604            if ((vertexY < y && prevY >= y) || (prevY < y && vertexY >= y)) {
2605                var vertexX = polygon[ii];
2606                if (vertexX + (y - vertexY) / (prevY - vertexY) * (polygon[prevIndex] - vertexX) < x) inside = !inside;
2607            }
2608            prevIndex = ii;
2609        }
2610        return inside;
2611    },
2612    /** Returns true if the polygon contains the line segment. */
2613    polygonIntersectsSegment: function (polygon, x1, y1, x2, y2) {
2614        var nn = polygon.length;
2615        var width12 = x1 - x2, height12 = y1 - y2;
2616        var det1 = x1 * y2 - y1 * x2;
2617        var x3 = polygon[nn - 2], y3 = polygon[nn - 1];
2618        for (var ii = 0; ii < nn; ii += 2) {
2619            var x4 = polygon[ii], y4 = polygon[ii + 1];
2620            var det2 = x3 * y4 - y3 * x4;
2621            var width34 = x3 - x4, height34 = y3 - y4;
2622            var det3 = width12 * height34 - height12 * width34;
2623            var x = (det1 * width34 - width12 * det2) / det3;
2624            if (((x >= x3 && x <= x4) || (x >= x4 && x <= x3)) && ((x >= x1 && x <= x2) || (x >= x2 && x <= x1))) {
2625                var y = (det1 * height34 - height12 * det2) / det3;
2626                if (((y >= y3 && y <= y4) || (y >= y4 && y <= y3)) && ((y >= y1 && y <= y2) || (y >= y2 && y <= y1))) return true;
2627            }
2628            x3 = x4;
2629            y3 = y4;
2630        }
2631        return false;
2632    },
2633    getPolygon: function (attachment) {
2634        var index = this.boundingBoxes.indexOf(attachment);
2635        return index == -1 ? null : this.polygons[index];
2636    },
2637    getWidth: function () {
2638        return this.maxX - this.minX;
2639    },
2640    getHeight: function () {
2641        return this.maxY - this.minY;
2642    }
2643};
2644
2645spine.SkeletonImageBounds = function () {
2646    this.polygonPool = [];
2647    this.polygons = [];
2648};
2649spine.SkeletonImageBounds.prototype = {
2650    minX: 0, minY: 0, maxX: 0, maxY: 0,
2651    update: function (skeleton, updateAabb) {
2652        var slots = skeleton.slots;
2653        var slotCount = slots.length;
2654        var x = skeleton.x, y = skeleton.y;
2655        var polygonPool = this.polygonPool;
2656        var polygons = this.polygons;
2657
2658        for (var i = 0, n = polygons.length; i < n; i++)
2659            polygonPool.push(polygons[i]);
2660        polygons.length = 0;
2661
2662        for (var i = 0; i < slotCount; i++) {
2663            var slot = slots[i];
2664            var regionAttachment = slot.attachment;
2665            if (!regionAttachment || regionAttachment.type != spine.AttachmentType.region) continue;
2666            var poolCount = polygonPool.length, polygon;
2667            if (poolCount > 0) {
2668                polygon = polygonPool[poolCount - 1];
2669                polygonPool.splice(poolCount - 1, 1);
2670            } else
2671                polygon = [];
2672            polygons.push(polygon);
2673            polygon.length = 8;
2674//            regionAttachment.updateOffset();
2675            regionAttachment.computeVertices(x, y, slot.bone, polygon);
2676        }
2677
2678        if (updateAabb) this.aabbCompute();
2679    },
2680    aabbCompute: function () {
2681        var polygons = this.polygons;
2682        var minX = Number.MAX_VALUE, minY = Number.MAX_VALUE, maxX = Number.MIN_VALUE, maxY = Number.MIN_VALUE;
2683        for (var i = 0, n = polygons.length; i < n; i++) {
2684            var vertices = polygons[i];
2685            for (var ii = 0, nn = vertices.length; ii < nn; ii += 2) {
2686                var x = vertices[ii];
2687                var y = vertices[ii + 1];
2688                minX = Math.min(minX, x);
2689                minY = Math.min(minY, y);
2690                maxX = Math.max(maxX, x);
2691                maxY = Math.max(maxY, y);
2692            }
2693        }
2694        this.minX = minX;
2695        this.minY = minY;
2696        this.maxX = maxX;
2697        this.maxY = maxY;
2698    },
2699    /** Returns true if the axis aligned bounding box contains the point. */
2700    aabbContainsPoint: function (x, y) {
2701        return x >= this.minX && x <= this.maxX && y >= this.minY && y <= this.maxY;
2702    },
2703    /** Returns true if the axis aligned bounding box intersects the line segment. */
2704    aabbIntersectsSegment: function (x1, y1, x2, y2) {
2705        var minX = this.minX, minY = this.minY, maxX = this.maxX, maxY = this.maxY;
2706        if ((x1 <= minX && x2 <= minX) || (y1 <= minY && y2 <= minY) || (x1 >= maxX && x2 >= maxX) || (y1 >= maxY && y2 >= maxY))
2707            return false;
2708        var m = (y2 - y1) / (x2 - x1);
2709        var y = m * (minX - x1) + y1;
2710        if (y > minY && y < maxY) return true;
2711        y = m * (maxX - x1) + y1;
2712        if (y > minY && y < maxY) return true;
2713        var x = (minY - y1) / m + x1;
2714        if (x > minX && x < maxX) return true;
2715        x = (maxY - y1) / m + x1;
2716        if (x > minX && x < maxX) return true;
2717        return false;
2718    },
2719    /** Returns true if the axis aligned bounding box intersects the axis aligned bounding box of the specified bounds. */
2720    aabbIntersectsSkeleton: function (bounds) {
2721        return this.minX < bounds.maxX && this.maxX > bounds.minX && this.minY < bounds.maxY && this.maxY > bounds.minY;
2722    },
2723    /** Returns the first bounding box attachment that contains the point, or null. When doing many checks, it is usually more
2724     * efficient to only call this method if {@link #aabbContainsPoint(float, float)} returns true. */
2725    containsPoint: function (x, y) {
2726        var polygons = this.polygons;
2727        for (var i = 0, n = polygons.length; i < n; i++)
2728            if (this.polygonContainsPoint(polygons[i], x, y)) return this.boundingBoxes[i];
2729        return null;
2730    },
2731    /** Returns the first bounding box attachment that contains the line segment, or null. When doing many checks, it is usually
2732     * more efficient to only call this method if {@link #aabbIntersectsSegment(float, float, float, float)} returns true. */
2733    intersectsSegment: function (x1, y1, x2, y2) {
2734        var polygons = this.polygons;
2735        for (var i = 0, n = polygons.length; i < n; i++)
2736            if (polygons[i].intersectsSegment(x1, y1, x2, y2)) return this.boundingBoxes[i];
2737        return null;
2738    },
2739    /** Returns true if the polygon contains the point. */
2740    polygonContainsPoint: function (polygon, x, y) {
2741        var nn = polygon.length;
2742        var prevIndex = nn - 2;
2743        var inside = false;
2744        for (var ii = 0; ii < nn; ii += 2) {
2745            var vertexY = polygon[ii + 1];
2746            var prevY = polygon[prevIndex + 1];
2747            if ((vertexY < y && prevY >= y) || (prevY < y && vertexY >= y)) {
2748                var vertexX = polygon[ii];
2749                if (vertexX + (y - vertexY) / (prevY - vertexY) * (polygon[prevIndex] - vertexX) < x) inside = !inside;
2750            }
2751            prevIndex = ii;
2752        }
2753        return inside;
2754    },
2755    /** Returns true if the polygon contains the line segment. */
2756    polygonIntersectsSegment: function (polygon, x1, y1, x2, y2) {
2757        var nn = polygon.length;
2758        var width12 = x1 - x2, height12 = y1 - y2;
2759        var det1 = x1 * y2 - y1 * x2;
2760        var x3 = polygon[nn - 2], y3 = polygon[nn - 1];
2761        for (var ii = 0; ii < nn; ii += 2) {
2762            var x4 = polygon[ii], y4 = polygon[ii + 1];
2763            var det2 = x3 * y4 - y3 * x4;
2764            var width34 = x3 - x4, height34 = y3 - y4;
2765            var det3 = width12 * height34 - height12 * width34;
2766            var x = (det1 * width34 - width12 * det2) / det3;
2767            if (((x >= x3 && x <= x4) || (x >= x4 && x <= x3)) && ((x >= x1 && x <= x2) || (x >= x2 && x <= x1))) {
2768                var y = (det1 * height34 - height12 * det2) / det3;
2769                if (((y >= y3 && y <= y4) || (y >= y4 && y <= y3)) && ((y >= y1 && y <= y2) || (y >= y2 && y <= y1))) return true;
2770            }
2771            x3 = x4;
2772            y3 = y4;
2773        }
2774        return false;
2775    },
2776    getPolygon: function (attachment) {
2777        var index = this.boundingBoxes.indexOf(attachment);
2778        return index == -1 ? null : this.polygons[index];
2779    },
2780    getWidth: function () {
2781        return this.maxX - this.minX;
2782    },
2783    getHeight: function () {
2784        return this.maxY - this.minY;
2785    }
2786};