diff --git a/Spine/src/SpineCocosSharp/SpineCocosSharp/SpineCocosSharpMac.csproj b/Spine/src/SpineCocosSharp/SpineCocosSharp/SpineCocosSharpMac.csproj
index 4c94971..65825f4 100644
--- a/Spine/src/SpineCocosSharp/SpineCocosSharp/SpineCocosSharpMac.csproj
+++ b/Spine/src/SpineCocosSharp/SpineCocosSharp/SpineCocosSharpMac.csproj
@@ -67,6 +67,11 @@
     <Compile Include="spine-csharp\src\Skin.cs" />
     <Compile Include="spine-csharp\src\Slot.cs" />
     <Compile Include="spine-csharp\src\SlotData.cs" />
+    <Compile Include="spine-csharp\src\BlendMode.cs" />
+    <Compile Include="spine-csharp\src\ExposedList.cs" />
+    <Compile Include="spine-csharp\src\IkConstraint.cs" />
+    <Compile Include="spine-csharp\src\IkConstraintData.cs" />
+    <Compile Include="spine-csharp\src\SkeletonBinary.cs" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
diff --git a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-cocossharp/CCSkeleton.cs b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-cocossharp/CCSkeleton.cs
index a1f2333..1fe9de1 100644
--- a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-cocossharp/CCSkeleton.cs
+++ b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-cocossharp/CCSkeleton.cs
@@ -26,584 +26,536 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *****************************************************************************/
 
-using CocosSharp;
-using Spine;
 using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
 using System.IO;
-using Microsoft.Xna.Framework.Graphics;
-using Microsoft.Xna.Framework;
+using CocosSharp;
+using Spine;
+
 
 namespace CocosSharp.Spine
 {
 
-    public enum AttachmentType
-    {
-        ATTACHMENT_REGION = 1, ATTACHMENT_REGION_SEQUENCE = 2, ATTACHMENT_BOUNDING_BOX = 3
-    }
-
-    public class CCSkeleton : CCNode
-    {
-
-        public float FLT_MAX = 3.402823466e+38F;     /* max value */
-        public float FLT_MIN = 1.175494351e-38F;     /* min positive value */
-
-        public static int ATTACHMENT_REGION = 0;
-        public static int ATTACHMENT_REGION_SEQUENCE = 1;
-        public static int ATTACHMENT_BOUNDING_BOX = 2;
-
-        public Skeleton Skeleton { get; private set; }
-        public CCGeometryNode skeletonGeometry;
-        public CCDrawNode debugger = new CCDrawNode();
-
-        public bool DebugSlots { get; set; }
-        public CCColor4B DebugSlotColor { get; set; }
-        public bool DebugBones { get; set; }
-        public CCColor4B DebugBoneColor { get; set; }
-        public CCColor4B DebugJointColor { get; set; }
-        public bool PremultipliedAlpha { get; set; }
-        public string ImagesDirectory { get; set; }
-
-        bool ownsSkeletonData;
-        Atlas atlas;
-
-        float[] vertices = new float[8];
-        int[] quadTriangles = { 0, 1, 2, 1, 3, 2 };
-
-        private const int TL = 0;
-        private const int TR = 1;
-        private const int BL = 2;
-        private const int BR = 3;
-        BlendState defaultBlendState;
-
-        public void SetSkeletonData(SkeletonData skeletonData, bool ownsSkeletonData)
-        {
-            Skeleton = new Skeleton(skeletonData);
-            this.ownsSkeletonData = ownsSkeletonData;
-        }
-
-        public CCSkeleton()
-        {
-            Initialize();
-        }
-
-        public CCSkeleton(SkeletonData skeletonData, bool ownsSkeletonData = false)
-        {
-            Initialize();
-            SetSkeletonData(skeletonData, ownsSkeletonData);
-        }
-
-        public CCSkeleton(string skeletonDataFile, Atlas atlas, float scale = 0)
-        {
-            var json = new SkeletonJson(atlas);
-			//json.Scale = scale == 0 ? (1 / Director.ContentScaleFactor) : scale;
-            json.Scale = scale == 0 ? (1 / 1) : scale;
-            SkeletonData skeletonData = json.ReadSkeletonData(skeletonDataFile);
-            SetSkeletonData(skeletonData, true);
-        }
-
-        public CCSkeleton(string skeletonDataFile, string atlasFile, float scale = 0)
-        {
-
-            Initialize();
-
-            using (StreamReader atlasStream = new StreamReader(CCFileUtils.GetFileStream(atlasFile)))
-            {
-                atlas = new Atlas(atlasStream, "", new CocosSharpTextureLoader());
-            }
-
-            SkeletonJson json = new SkeletonJson(atlas);
-
-            //json.Scale = scale == 0 ? (1 / Director.ContentScaleFactor) : scale;
-            json.Scale = scale == 0 ? (1 / 1) : scale;
-
-            using (StreamReader skeletonDataStream = new StreamReader(CCFileUtils.GetFileStream(skeletonDataFile)))
-            {
-                SkeletonData skeletonData = json.ReadSkeletonData(skeletonDataStream);
-                skeletonData.Name = skeletonDataFile;
-                SetSkeletonData(skeletonData, true);
-            }
-        }
-
-        public void Initialize()
-        {
-            atlas = null;
-            DebugSlots = false;
-            DebugBones = false;
-            PremultipliedAlpha = false;
-            ImagesDirectory = string.Empty;
-            DebugSlotColor = CCColor4B.Magenta;
-            DebugBoneColor = CCColor4B.Blue;
-            DebugJointColor = CCColor4B.Red;
-            skeletonGeometry = new CCGeometryNode ();
-            OpacityModifyRGB = true;
-            
-            AddChild(skeletonGeometry);
-            AddChild(debugger);
-
-            Schedule();
-        }
-        
-        ~CCSkeleton()
-        {
-			CCLog.Log ("finalize");
-            //Eliminamos el skleñetp
-            //if (ownsSkeletonData!=null) 
-
-            //SkeletonData_dispose(skeleton->data);
-            //if (atlas) spAtlas_dispose(atlas);
-            //spSkeleton_dispose(skeleton);
+
+	public class CCSkeleton : CCNode
+	{
+		public float FLT_MAX = 3.402823466e+38F;
+		public float FLT_MIN = 1.175494351e-38F;
+
+		public CCGeometryNode skeletonGeometry;
+		public CCDrawNode debugger = new CCDrawNode ();
+
+		const int TL = 0;
+		const int TR = 1;
+		const int BL = 2;
+		const int BR = 3;
+
+		Atlas atlas;
+		float[] vertices = new float[8];
+		int[] quadTriangles = { 0, 1, 2, 1, 3, 2 };
+
+		public Skeleton Skeleton { get; private set; }
+
+		public bool DebugSlots { get; set; }
+
+		public CCColor4B DebugSlotColor { get; set; }
+
+		public bool DebugBones { get; set; }
+
+		public CCColor4B DebugBoneColor { get; set; }
+
+		public CCColor4B DebugJointColor { get; set; }
+
+		public bool PremultipliedAlpha { get; set; }
+
+		public string ImagesDirectory { get; set; }
+
+
+		#region Constructors
+
+
+		public CCSkeleton ()
+		{
+			Initialize ();
+		}
+
+
+		public CCSkeleton (SkeletonData skeletonData)
+		{
+			Initialize ();
+			SetSkeletonData (skeletonData);
+		}
+
+
+		public CCSkeleton (string skeletonDataFile, Atlas atlas, float scale = 0)
+		{
+			Initialize ();
+
+			var json = new SkeletonJson (atlas);
+			json.Scale = scale == 0 ? (1 / 1) : scale;
+
+			SetSkeletonData (json.ReadSkeletonData (skeletonDataFile));
+		}
+
+
+		public CCSkeleton (string skeletonDataFile, string atlasFile, float scale = 0)
+		{
+			Initialize ();
+
+			using (var atlasStream = new StreamReader (CCFileUtils.GetFileStream (atlasFile))) {
+				atlas = new Atlas (atlasStream, "", new CocosSharpTextureLoader ());
+			}
+
+			var json = new SkeletonJson (atlas);
+			json.Scale = scale == 0 ? (1 / 1) : scale;
+
+			using (var skeletonDataStream = new StreamReader (CCFileUtils.GetFileStream (skeletonDataFile))) {
+				var skeletonData = json.ReadSkeletonData (skeletonDataStream);
+				skeletonData.Name = skeletonDataFile;
+				SetSkeletonData (skeletonData);
+			}
+		}
+
+
+		#endregion
+
+
+		#region Public
+
+
+		public void Initialize ()
+		{
+			ImagesDirectory = string.Empty;
+			DebugSlotColor = CCColor4B.Magenta;
+			DebugBoneColor = CCColor4B.Blue;
+			DebugJointColor = CCColor4B.Red;
+			skeletonGeometry = new CCGeometryNode ();
+			OpacityModifyRGB = true;
             
-        }
-      
-        public override void Update(float dt)
-        {
-			base.Update(dt);
-            UpdateSkeletonGeometry();
-        }
-
-        protected void UpdateSkeletonGeometry()
-        {
-
-            skeletonGeometry.ClearInstances();
-            //defaultBlendState = PremultipliedAlpha ? BlendState.AlphaBlend : BlendState.NonPremultiplied;
-           
-
-            float[] vertices = this.vertices;
-            List<Slot> drawOrder = Skeleton.DrawOrder;
-            float x = Skeleton.X, y = Skeleton.Y;
-
-            CCColor3B color3b = Color;
-            float skeletonR = color3b.R / 255f;
-            float skeletonG = color3b.G / 255f;
-            float skeletonB = color3b.B / 255f;
-            float skeletonA = Opacity / 255f;
-
-            for (int i = 0, n = drawOrder.Count; i < n; i++)
-            {
-                Slot slot = drawOrder[i];
-                Attachment attachment = slot.Attachment;
-                if (attachment is RegionAttachment)
-                {
-                    RegionAttachment regionAttachment = (RegionAttachment)attachment;
-                    //BlendState blend = slot.Data.AdditiveBlending ? BlendState.Additive : defaultBlendState;
-
-                    var item = skeletonGeometry.CreateGeometryInstance(4, 6);
-
-                    //item.InstanceAttributes.BlendState = blend;
-                    //item.InstanceAttributes.AdditionalTransform = AffineWorldTransform;
-                    item.GeometryPacket.Indicies = quadTriangles;
-
-                    var itemVertices = item.GeometryPacket.Vertices;
-
-                    AtlasRegion region = (AtlasRegion)regionAttachment.RendererObject;
-                    item.GeometryPacket.Texture = (CCTexture2D)region.page.rendererObject;
-
-                    CCColor4B color;
-                    float a = skeletonA * slot.A * regionAttachment.A;
-                    if (PremultipliedAlpha)
-                    {
-                        color = new CCColor4B(
-                                skeletonR * slot.R * regionAttachment.R * a,
-                                skeletonG * slot.G * regionAttachment.G * a,
-                                skeletonB * slot.B * regionAttachment.B * a, a);
-                    }
-                    else
-                    {
-                        color = new CCColor4B(
-                                skeletonR * slot.R * regionAttachment.R,
-                                skeletonG * slot.G * regionAttachment.G,
-                                skeletonB * slot.B * regionAttachment.B, a);
-                    }
-                    itemVertices[TL].Colors = color;
-                    itemVertices[BL].Colors = color;
-                    itemVertices[BR].Colors = color;
-                    itemVertices[TR].Colors = color;
-
-                    regionAttachment.ComputeWorldVertices(x, y, slot.Bone, vertices);
-                    itemVertices[TL].Vertices.X = vertices[RegionAttachment.X1];
-                    itemVertices[TL].Vertices.Y = vertices[RegionAttachment.Y1];
-                    itemVertices[TL].Vertices.Z = 0;
-                    itemVertices[BL].Vertices.X = vertices[RegionAttachment.X2];
-                    itemVertices[BL].Vertices.Y = vertices[RegionAttachment.Y2];
-                    itemVertices[BL].Vertices.Z = 0;
-                    itemVertices[BR].Vertices.X = vertices[RegionAttachment.X3];
-                    itemVertices[BR].Vertices.Y = vertices[RegionAttachment.Y3];
-                    itemVertices[BR].Vertices.Z = 0;
-                    itemVertices[TR].Vertices.X = vertices[RegionAttachment.X4];
-                    itemVertices[TR].Vertices.Y = vertices[RegionAttachment.Y4];
-                    itemVertices[TR].Vertices.Z = 0;
-
-                    float[] uvs = regionAttachment.UVs;
-                    itemVertices[TL].TexCoords.U = uvs[RegionAttachment.X1];
-                    itemVertices[TL].TexCoords.V = uvs[RegionAttachment.Y1];
-                    itemVertices[BL].TexCoords.U = uvs[RegionAttachment.X2];
-                    itemVertices[BL].TexCoords.V = uvs[RegionAttachment.Y2];
-                    itemVertices[BR].TexCoords.U = uvs[RegionAttachment.X3];
-                    itemVertices[BR].TexCoords.V = uvs[RegionAttachment.Y3];
-                    itemVertices[TR].TexCoords.U = uvs[RegionAttachment.X4];
-                    itemVertices[TR].TexCoords.V = uvs[RegionAttachment.Y4];
-                }
-                else if (attachment is MeshAttachment)
-                {
-                    MeshAttachment mesh = (MeshAttachment)attachment;
-                    int vertexCount = mesh.Vertices.Length;
-                    if (vertices.Length < vertexCount) vertices = new float[vertexCount];
-                    mesh.ComputeWorldVertices(x, y, slot, vertices);
-
-                    int[] triangles = mesh.Triangles;
-                    var item = skeletonGeometry.CreateGeometryInstance(vertexCount, triangles.Length);
-                    //item.InstanceAttributes.AdditionalTransform = AffineWorldTransform;
-                    item.GeometryPacket.Indicies = triangles;
-
-                    AtlasRegion region = (AtlasRegion)mesh.RendererObject;
-                    item.GeometryPacket.Texture = (CCTexture2D)region.page.rendererObject;
-
-                    CCColor4B color;
-                    float a = skeletonA * slot.A * mesh.A;
-                    if (PremultipliedAlpha)
-                    {
-                        color = new CCColor4B(
-                                skeletonR * slot.R * mesh.R * a,
-                                skeletonG * slot.G * mesh.G * a,
-                                skeletonB * slot.B * mesh.B * a, a);
-                    }
-                    else
-                    {
-                        color = new CCColor4B(
-                                skeletonR * slot.R * mesh.R,
-                                skeletonG * slot.G * mesh.G,
-                                skeletonB * slot.B * mesh.B, a);
-                    }
-
-                    float[] uvs = mesh.UVs;
-                    var itemVertices = item.GeometryPacket.Vertices;
-                    for (int ii = 0, v = 0; v < vertexCount; ii++, v += 2)
-                    {
-                        itemVertices[ii].Colors = color;
-                        itemVertices[ii].Vertices.X = vertices[v];
-                        itemVertices[ii].Vertices.Y = vertices[v + 1];
-                        itemVertices[ii].Vertices.Z = 0;
-                        itemVertices[ii].TexCoords.U = uvs[v];
-                        itemVertices[ii].TexCoords.V = uvs[v + 1];
-                    }
-                }
-                else if (attachment is SkinnedMeshAttachment)
-                {
-                    SkinnedMeshAttachment mesh = (SkinnedMeshAttachment)attachment;
-                    int vertexCount = mesh.UVs.Length;
-                    if (vertices.Length < vertexCount) vertices = new float[vertexCount];
-                    mesh.ComputeWorldVertices(x, y, slot, vertices);
-
-                    int[] triangles = mesh.Triangles;
-                    var item = skeletonGeometry.CreateGeometryInstance(vertexCount, triangles.Length);
-                    item.GeometryPacket.Indicies = triangles;
-                    //item.InstanceAttributes.AdditionalTransform = AffineWorldTransform;
-
-                    AtlasRegion region = (AtlasRegion)mesh.RendererObject;
-                    item.GeometryPacket.Texture = (CCTexture2D)region.page.rendererObject;
-
-                    CCColor4B color;
-                    float a = skeletonA * slot.A * mesh.A;
-                    if (PremultipliedAlpha)
-                    {
-                        color = new CCColor4B(
-                                skeletonR * slot.R * mesh.R * a,
-                                skeletonG * slot.G * mesh.G * a,
-                                skeletonB * slot.B * mesh.B * a, a);
-                    }
-                    else
-                    {
-                        color = new CCColor4B(
-                                skeletonR * slot.R * mesh.R,
-                                skeletonG * slot.G * mesh.G,
-                                skeletonB * slot.B * mesh.B, a);
-                    }
-
-                    float[] uvs = mesh.UVs;
-                    var itemVertices = item.GeometryPacket.Vertices;
-                    for (int ii = 0, v = 0; v < vertexCount; ii++, v += 2)
-                    {
-                        itemVertices[ii].Colors = color;
-                        itemVertices[ii].Vertices.X = vertices[v];
-                        itemVertices[ii].Vertices.Y = vertices[v + 1];
-                        itemVertices[ii].Vertices.Z = 0;
-                        itemVertices[ii].TexCoords.U = uvs[v];
-                        itemVertices[ii].TexCoords.V = uvs[v + 1];
-                    }
-                }
-            }
-
-            debugger.Clear();
-
-            if (DebugBones || DebugSlots)
-            {
-
-
-                if (DebugSlots)
-                {
-
-                    for (int i = 0; i < Skeleton.Slots.Count; ++i)
-                    {
-
-                        var slot = Skeleton.Slots[i];
-
-                        if (slot.Attachment == null) continue;
-
-                        var verticesCount = 0;
-                        var worldVertices = new float[1000]; // Max number of vertices per mesh.
-                        if (slot.Attachment is RegionAttachment)
-                        {
-                            var attachment = (RegionAttachment)slot.Attachment;
-                            attachment.ComputeWorldVertices(Skeleton.X, Skeleton.Y, slot.bone, worldVertices);
-                            verticesCount = 8;
-                        }
-                        else if (slot.Attachment is MeshAttachment)
-                        {
-                            var mesh = (MeshAttachment)slot.Attachment;
-                            mesh.ComputeWorldVertices(Skeleton.X, Skeleton.Y, slot, worldVertices);
-                            verticesCount = mesh.Vertices.Length;
-                        }
-                        else if (slot.Attachment is SkinnedMeshAttachment)
-                        {
-                            var mesh = (SkinnedMeshAttachment)slot.Attachment;
-                            mesh.ComputeWorldVertices(Skeleton.X, Skeleton.Y, slot, worldVertices);
-                            verticesCount = mesh.UVs.Length;
-                        }
-                        else
-                            continue;
-
-                        CCPoint[] slotVertices = new CCPoint[verticesCount/2];
-
-                        for (int ii = 0, si = 0; ii < verticesCount; ii += 2, si++)
-                        {
-                            slotVertices[si].X = worldVertices[ii] * ScaleX;
-                            slotVertices[si].Y = worldVertices[ii + 1] * ScaleY;
-                        }
-
-                        debugger.DrawPolygon(slotVertices, verticesCount / 2, CCColor4B.Transparent, 1, DebugSlotColor);
-
-                    }
-
-
-                }
-
-                if (DebugBones)
-                {
-                    // Bone lengths.
-                    for (int i = 0; i < Skeleton.Bones.Count; i++)
-                    {
-                        Bone bone = Skeleton.Bones[i];
-                        x = bone.Data.Length * bone.M00 + bone.WorldX;
-                        y = bone.Data.Length * bone.M10 + bone.WorldY;
-
-                        debugger.DrawLine(new CCPoint(bone.WorldX, bone.WorldY), new CCPoint(x, y), 1, DebugJointColor);
-                    }
-
-                    // Bone origins.
-                    for (int i = 0; i < Skeleton.Bones.Count; i++)
-                    {
-                        Bone bone = Skeleton.Bones[i];
-                        debugger.DrawDot(new CCPoint(bone.WorldX, bone.WorldY), 3, DebugBoneColor);
-
-                    }
-                }
-            }
-
-        }
-
-        public override CCSize ContentSize
-        {
-            get
-            {
-                var bbox = boundingBox();
-                return new CCSize(bbox.Size.Width, bbox.Size.Height);   
-            }
-            set
-            {
-                
-            }
-        }
-
-        CCRect boundingBox()
-        {
-
-            float minX = FLT_MAX, minY = FLT_MAX, maxX = FLT_MIN, maxY = FLT_MIN;
-
-            for (int i = 0; i < Skeleton.Slots.Count; ++i)
-            {
-
-                var slot = Skeleton.Slots[i];
-
-                if (slot.Attachment == null) continue;
-
-                var verticesCount = 0;
-                var worldVertices = new float[1000]; // Max number of vertices per mesh.
-                if (slot.Attachment is RegionAttachment)
-                {
-                    var attachment = (RegionAttachment)slot.Attachment;
-                    attachment.ComputeWorldVertices(Skeleton.X, Skeleton.Y, slot.bone, worldVertices);
-                    verticesCount = 8;
-                }
-                else if (slot.Attachment is MeshAttachment)
-                {
-                    var mesh = (MeshAttachment)slot.Attachment;
-                    mesh.ComputeWorldVertices(Skeleton.X, Skeleton.Y, slot, worldVertices);
-                    verticesCount = mesh.Vertices.Length;
-                }
-                else if (slot.Attachment is SkinnedMeshAttachment)
-                {
-                    var mesh = (SkinnedMeshAttachment)slot.Attachment;
-                    mesh.ComputeWorldVertices(Skeleton.X, Skeleton.Y, slot, worldVertices);
-                    verticesCount = mesh.UVs.Length;
-                }
-                else
-                    continue;
-                for (int ii = 0; ii < verticesCount; ii += 2)
-                {
-                    float x = worldVertices[ii] * ScaleX, y = worldVertices[ii + 1] * ScaleY;
-                    minX = Math.Min(minX, x);
-                    minY = Math.Min(minY, y);
-                    maxX = Math.Max(maxX, x);
-                    maxY = Math.Max(maxY, y);
-                }
-
-            }
-            CCPoint position = Position;
-
-            return new CCRect(position.X + minX, position.Y + minY, maxX - minX, maxY - minY);
-
-        }
-
-        // --- Convenience methods for common Skeleton_* functions.
-        public void UpdateWorldTransform()
-        {
-            Skeleton.UpdateWorldTransform();
-        }
-
-        public void SetToSetupPose()
-        {
-            Skeleton.SetToSetupPose();
-        }
-        public void SetBonesToSetupPose()
-        {
-            Skeleton.SetBonesToSetupPose();
-        }
-        public void SetSlotsToSetupPose()
-        {
-            Skeleton.SetSlotsToSetupPose();
-        }
-
-        /* Returns 0 if the bone was not found. */
-        public Bone FindBone(string boneName)
-        {
-            return Skeleton.FindBone(boneName);
-        }
-        /* Returns 0 if the slot was not found. */
-        public Slot FindSlot(string slotName)
-        {
-            return Skeleton.FindSlot(slotName);
-        }
-
-        /* Sets the skin used to look up attachments not found in the SkeletonData defaultSkin. Attachments from the new skin are
+			AddChild (skeletonGeometry);
+			AddChild (debugger);
+
+			Schedule ();
+		}
+
+
+		public void SetSkeletonData (SkeletonData skeletonData)
+		{
+			Skeleton = new Skeleton (skeletonData);
+		}
+
+
+		public override void Update (float dt)
+		{
+			base.Update (dt);
+
+			UpdateSkeletonGeometry ();
+		}
+
+
+		#endregion
+
+
+		#region Private
+
+
+		protected void UpdateSkeletonGeometry ()
+		{
+			skeletonGeometry.ClearInstances ();
+
+			var vertices = this.vertices;
+			var drawOrder = Skeleton.DrawOrder;
+			var x = Skeleton.X;
+			var y = Skeleton.Y;
+
+			var color3b = Color;
+			var skeletonR = color3b.R / 255f;
+			var skeletonG = color3b.G / 255f;
+			var skeletonB = color3b.B / 255f;
+			var skeletonA = Opacity / 255f;
+
+			foreach (var slot in drawOrder) {
+				var attachment = slot.Attachment;
+
+				if (attachment is RegionAttachment) {
+					var regionAttachment = (RegionAttachment)attachment;
+					var item = skeletonGeometry.CreateGeometryInstance (4, 6);
+
+					item.GeometryPacket.Indicies = quadTriangles;
+
+					var itemVertices = item.GeometryPacket.Vertices;
+					var region = (AtlasRegion)regionAttachment.RendererObject;
+
+					item.GeometryPacket.Texture = (CCTexture2D)region.page.rendererObject;
+
+					var a = skeletonA * slot.A * regionAttachment.A;
+
+					CCColor4B color;
+					if (PremultipliedAlpha)
+						color = new CCColor4B (skeletonR * slot.R * regionAttachment.R * a, skeletonG * slot.G * regionAttachment.G * a, skeletonB * slot.B * regionAttachment.B * a, a);
+					else
+						color = new CCColor4B (skeletonR * slot.R * regionAttachment.R, skeletonG * slot.G * regionAttachment.G, skeletonB * slot.B * regionAttachment.B, a);
+
+					itemVertices [TL].Colors = color;
+					itemVertices [BL].Colors = color;
+					itemVertices [BR].Colors = color;
+					itemVertices [TR].Colors = color;
+
+					regionAttachment.ComputeWorldVertices (slot.Bone, vertices);
+
+					itemVertices [TL].Vertices.X = vertices [RegionAttachment.X1];
+					itemVertices [TL].Vertices.Y = vertices [RegionAttachment.Y1];
+					itemVertices [TL].Vertices.Z = 0;
+					itemVertices [BL].Vertices.X = vertices [RegionAttachment.X2];
+					itemVertices [BL].Vertices.Y = vertices [RegionAttachment.Y2];
+					itemVertices [BL].Vertices.Z = 0;
+					itemVertices [BR].Vertices.X = vertices [RegionAttachment.X3];
+					itemVertices [BR].Vertices.Y = vertices [RegionAttachment.Y3];
+					itemVertices [BR].Vertices.Z = 0;
+					itemVertices [TR].Vertices.X = vertices [RegionAttachment.X4];
+					itemVertices [TR].Vertices.Y = vertices [RegionAttachment.Y4];
+					itemVertices [TR].Vertices.Z = 0;
+
+					var uvs = regionAttachment.UVs;
+
+					itemVertices [TL].TexCoords.U = uvs [RegionAttachment.X1];
+					itemVertices [TL].TexCoords.V = uvs [RegionAttachment.Y1];
+					itemVertices [BL].TexCoords.U = uvs [RegionAttachment.X2];
+					itemVertices [BL].TexCoords.V = uvs [RegionAttachment.Y2];
+					itemVertices [BR].TexCoords.U = uvs [RegionAttachment.X3];
+					itemVertices [BR].TexCoords.V = uvs [RegionAttachment.Y3];
+					itemVertices [TR].TexCoords.U = uvs [RegionAttachment.X4];
+					itemVertices [TR].TexCoords.V = uvs [RegionAttachment.Y4];
+				} else if (attachment is MeshAttachment) {
+					var mesh = (MeshAttachment)attachment;
+					var vertexCount = mesh.Vertices.Length;
+
+					if (vertices.Length < vertexCount)
+						vertices = new float[vertexCount];
+					
+					mesh.ComputeWorldVertices (slot, vertices);
+
+					var triangles = mesh.Triangles;
+					var item = skeletonGeometry.CreateGeometryInstance (vertexCount, triangles.Length);
+
+					item.GeometryPacket.Indicies = triangles;
+
+					var region = (AtlasRegion)mesh.RendererObject;
+
+					item.GeometryPacket.Texture = (CCTexture2D)region.page.rendererObject;
+
+					var a = skeletonA * slot.A * mesh.A;
+
+					CCColor4B color;
+					if (PremultipliedAlpha)
+						color = new CCColor4B (skeletonR * slot.R * mesh.R * a, skeletonG * slot.G * mesh.G * a, skeletonB * slot.B * mesh.B * a, a);
+					else
+						color = new CCColor4B (skeletonR * slot.R * mesh.R, skeletonG * slot.G * mesh.G, skeletonB * slot.B * mesh.B, a);
+
+					var uvs = mesh.UVs;
+					var itemVertices = item.GeometryPacket.Vertices;
+
+					for (int ii = 0, v = 0; v < vertexCount; ii++, v += 2) {
+						itemVertices [ii].Colors = color;
+						itemVertices [ii].Vertices.X = vertices [v];
+						itemVertices [ii].Vertices.Y = vertices [v + 1];
+						itemVertices [ii].Vertices.Z = 0;
+						itemVertices [ii].TexCoords.U = uvs [v];
+						itemVertices [ii].TexCoords.V = uvs [v + 1];
+					}
+				} else if (attachment is SkinnedMeshAttachment) {
+					var mesh = (SkinnedMeshAttachment)attachment;
+					var vertexCount = mesh.UVs.Length;
+
+					if (vertices.Length < vertexCount)
+						vertices = new float[vertexCount];
+					
+					mesh.ComputeWorldVertices (slot, vertices);
+
+					var triangles = mesh.Triangles;
+					var item = skeletonGeometry.CreateGeometryInstance (vertexCount, triangles.Length);
+
+					item.GeometryPacket.Indicies = triangles;
+
+					var region = (AtlasRegion)mesh.RendererObject;
+
+					item.GeometryPacket.Texture = (CCTexture2D)region.page.rendererObject;
+
+					var a = skeletonA * slot.A * mesh.A;
+
+					CCColor4B color;
+					if (PremultipliedAlpha)
+						color = new CCColor4B (skeletonR * slot.R * mesh.R * a, skeletonG * slot.G * mesh.G * a, skeletonB * slot.B * mesh.B * a, a);
+					else
+						color = new CCColor4B (skeletonR * slot.R * mesh.R, skeletonG * slot.G * mesh.G, skeletonB * slot.B * mesh.B, a);
+
+					var uvs = mesh.UVs;
+					var itemVertices = item.GeometryPacket.Vertices;
+
+					for (int ii = 0, v = 0; v < vertexCount; ii++, v += 2) {
+						itemVertices [ii].Colors = color;
+						itemVertices [ii].Vertices.X = vertices [v];
+						itemVertices [ii].Vertices.Y = vertices [v + 1];
+						itemVertices [ii].Vertices.Z = 0;
+						itemVertices [ii].TexCoords.U = uvs [v];
+						itemVertices [ii].TexCoords.V = uvs [v + 1];
+					}
+				}
+			}
+
+			debugger.Clear ();
+
+			if (DebugBones || DebugSlots) {
+				if (DebugSlots) {
+					foreach (var slot in Skeleton.Slots) {
+						if (slot.Attachment == null)
+							continue;
+
+						int verticesCount;
+						var worldVertices = new float[1000]; // max number of vertices per mesh.
+
+						if (slot.Attachment is RegionAttachment) {
+							var attachment = (RegionAttachment)slot.Attachment;
+							attachment.ComputeWorldVertices (slot.bone, worldVertices);
+							verticesCount = 8;
+						} else if (slot.Attachment is MeshAttachment) {
+							var mesh = (MeshAttachment)slot.Attachment;
+							mesh.ComputeWorldVertices (slot, worldVertices);
+							verticesCount = mesh.Vertices.Length;
+						} else if (slot.Attachment is SkinnedMeshAttachment) {
+							var mesh = (SkinnedMeshAttachment)slot.Attachment;
+							mesh.ComputeWorldVertices (slot, worldVertices);
+							verticesCount = mesh.UVs.Length;
+						} else {
+							continue;
+						}
+
+						var slotVertices = new CCPoint[verticesCount / 2];
+
+						for (int ii = 0, si = 0; ii < verticesCount; ii += 2, si++) {
+							slotVertices [si].X = worldVertices [ii] * ScaleX;
+							slotVertices [si].Y = worldVertices [ii + 1] * ScaleY;
+						}
+
+						debugger.DrawPolygon (slotVertices, verticesCount / 2, CCColor4B.Transparent, 0.5f, DebugSlotColor);
+					}
+				}
+
+				if (DebugBones) {
+					foreach (var bone in Skeleton.Bones) {
+						x = bone.Data.Length * bone.M00 + bone.WorldX;
+						y = bone.Data.Length * bone.M10 + bone.WorldY;
+
+						debugger.DrawLine (new CCPoint (bone.WorldX, bone.WorldY), new CCPoint (x, y), 1, DebugJointColor);
+						debugger.DrawDot (new CCPoint (bone.WorldX, bone.WorldY), 3, DebugBoneColor);
+					}
+				}
+			}
+		}
+
+
+		public override CCSize ContentSize {
+			get {
+				var bbox = boundingBox ();
+				return new CCSize (bbox.Size.Width, bbox.Size.Height);   
+			}
+		}
+
+
+		public void UpdateWorldTransform ()
+		{
+			Skeleton.UpdateWorldTransform ();
+		}
+
+
+		public void SetToSetupPose ()
+		{
+			Skeleton.SetToSetupPose ();
+		}
+
+
+		public void SetBonesToSetupPose ()
+		{
+			Skeleton.SetBonesToSetupPose ();
+		}
+
+
+		public void SetSlotsToSetupPose ()
+		{
+			Skeleton.SetSlotsToSetupPose ();
+		}
+
+
+		public Bone FindBone (string boneName)
+		{
+			return Skeleton.FindBone (boneName);
+		}
+
+
+		public Slot FindSlot (string slotName)
+		{
+			return Skeleton.FindSlot (slotName);
+		}
+
+
+		/* Sets the skin used to look up attachments not found in the SkeletonData defaultSkin. Attachments from the new skin are
          * attached if the corresponding attachment from the old skin was attached. Returns false if the skin was not found.
          * @param skin May be 0.*/
-        public bool SetSkin(string skinName)
-        {
-            Skeleton.SetSkin(skinName);
-            return true;
-        }
-
-        /* Returns 0 if the slot or attachment was not found. */
-        public Attachment GetAttachment(string slotName, string attachmentName)
-        {
-            return Skeleton.GetAttachment(slotName, attachmentName);
-        }
-        /* Returns false if the slot or attachment was not found. */
-        public bool SetAttachment(string slotName, string attachmentName)
-        {
-            Skeleton.SetAttachment(slotName, attachmentName);
-            return true;
-        }
-
-        public bool OpacityModifyRGB
-        {
-            get
-            {
-                return PremultipliedAlpha;
-            }
-
-            set
-            {
-                PremultipliedAlpha = value;
-            }
-        }
-      
-        //virtual cocos2d::CCTextureAtlas* getTextureAtlas (RegionAttachment regionAttachment);
-        #region SpinesCocos2d
-
-        void UpdateRegionAttachmentQuad(RegionAttachment self, Slot slot, ref CCV3F_C4B_T2F_Quad quad, bool premultipliedAlpha = false)
-        {
-
-            float[] vertices = new float[8];
-
-            self.ComputeWorldVertices(slot.Skeleton.X, slot.Skeleton.Y, slot.Bone, vertices);
-
-            float r = slot.Skeleton.R * slot.R * 255;
-            float g = slot.Skeleton.G * slot.G * 255;
-            float b = slot.Skeleton.B * slot.B * 255;
-
-            float normalizedAlpha = slot.Skeleton.A * slot.A;
-            if (premultipliedAlpha)
-            {
-                r *= normalizedAlpha;
-                g *= normalizedAlpha;
-                b *= normalizedAlpha;
-            }
-
-            float a = normalizedAlpha * 255;
-            quad.BottomLeft.Colors.R = (byte)r;
-            quad.BottomLeft.Colors.G = (byte)g;
-            quad.BottomLeft.Colors.B = (byte)b;
-            quad.BottomLeft.Colors.A = (byte)a;
-            quad.TopLeft.Colors.R = (byte)r;
-            quad.TopLeft.Colors.G = (byte)g;
-            quad.TopLeft.Colors.B = (byte)b;
-            quad.TopLeft.Colors.A = (byte)a;
-            quad.TopRight.Colors.R = (byte)r;
-            quad.TopRight.Colors.G = (byte)g;
-            quad.TopRight.Colors.B = (byte)b;
-            quad.TopRight.Colors.A = (byte)a;
-            quad.BottomRight.Colors.R = (byte)r;
-            quad.BottomRight.Colors.G = (byte)g;
-            quad.BottomRight.Colors.B = (byte)b;
-            quad.BottomRight.Colors.A = (byte)a;
-
-            quad.BottomLeft.Vertices.X = vertices[RegionAttachment.X1];
-            quad.BottomLeft.Vertices.Y = vertices[RegionAttachment.Y1];
-            quad.TopLeft.Vertices.X = vertices[RegionAttachment.X2];
-            quad.TopLeft.Vertices.Y = vertices[RegionAttachment.Y2];
-            quad.TopRight.Vertices.X = vertices[RegionAttachment.X3];
-            quad.TopRight.Vertices.Y = vertices[RegionAttachment.Y3];
-            quad.BottomRight.Vertices.X = vertices[RegionAttachment.X4];
-            quad.BottomRight.Vertices.Y = vertices[RegionAttachment.Y4];
-
-            quad.BottomLeft.TexCoords.U = self.UVs[RegionAttachment.X1];
-            quad.BottomLeft.TexCoords.V = self.UVs[RegionAttachment.Y1];
-            quad.TopLeft.TexCoords.U = self.UVs[RegionAttachment.X2];
-            quad.TopLeft.TexCoords.V = self.UVs[RegionAttachment.Y2];
-            quad.TopRight.TexCoords.U = self.UVs[RegionAttachment.X3];
-            quad.TopRight.TexCoords.V = self.UVs[RegionAttachment.Y3];
-            quad.BottomRight.TexCoords.U = self.UVs[RegionAttachment.X4];
-            quad.BottomRight.TexCoords.V = self.UVs[RegionAttachment.Y4];
-
-        }
-
-        #endregion
+		public bool SetSkin (string skinName)
+		{
+			Skeleton.SetSkin (skinName);
+
+			return true;
+		}
+
+
+		/* Returns 0 if the slot or attachment was not found. */
+		public Attachment GetAttachment (string slotName, string attachmentName)
+		{
+			return Skeleton.GetAttachment (slotName, attachmentName);
+		}
 
+
+		/* Returns false if the slot or attachment was not found. */
+		public bool SetAttachment (string slotName, string attachmentName)
+		{
+			Skeleton.SetAttachment (slotName, attachmentName);
+
+			return true;
+		}
+
+
+		public bool OpacityModifyRGB {
+			get {
+				return PremultipliedAlpha;
+			}
+
+			set {
+				PremultipliedAlpha = value;
+			}
+		}
+
+
+		#endregion
+
+
+		#region Private
+
+
+		CCRect boundingBox ()
+		{
+			var minX = FLT_MAX;
+			var minY = FLT_MAX;
+			var maxX = FLT_MIN;
+			var maxY = FLT_MIN;
+
+			foreach (var slot in Skeleton.Slots) {
+				if (slot.Attachment == null)
+					continue;
+
+				int verticesCount;
+				var worldVertices = new float[1000]; // max number of vertices per mesh.
+
+				if (slot.Attachment is RegionAttachment) {
+					var attachment = (RegionAttachment)slot.Attachment;
+					attachment.ComputeWorldVertices (slot.bone, worldVertices);
+					verticesCount = 8;
+				} else if (slot.Attachment is MeshAttachment) {
+					var mesh = (MeshAttachment)slot.Attachment;
+					mesh.ComputeWorldVertices (slot, worldVertices);
+					verticesCount = mesh.Vertices.Length;
+				} else if (slot.Attachment is SkinnedMeshAttachment) {
+					var mesh = (SkinnedMeshAttachment)slot.Attachment;
+					mesh.ComputeWorldVertices (slot, worldVertices);
+					verticesCount = mesh.UVs.Length;
+				} else {
+					continue;
+				}
+
+				for (var ii = 0; ii < verticesCount; ii += 2) {
+					var x = worldVertices [ii] * ScaleX;
+					var y = worldVertices [ii + 1] * ScaleY;
+
+					minX = Math.Min (minX, x);
+					minY = Math.Min (minY, y);
+					maxX = Math.Max (maxX, x);
+					maxY = Math.Max (maxY, y);
+				}
+			}
+
+			var position = Position;
+
+			return new CCRect (position.X + minX, position.Y + minY, maxX - minX, maxY - minY);
+		}
+
+
+		static void UpdateRegionAttachmentQuad (RegionAttachment self, Slot slot, ref CCV3F_C4B_T2F_Quad quad, bool premultipliedAlpha = false)
+		{
+			var vert = new float[8];
+
+			self.ComputeWorldVertices (slot.Bone, vert);
+
+			var r = slot.Skeleton.R * slot.R * 255;
+			var g = slot.Skeleton.G * slot.G * 255;
+			var b = slot.Skeleton.B * slot.B * 255;
+			var normalizedAlpha = slot.Skeleton.A * slot.A;
+
+			if (premultipliedAlpha) {
+				r *= normalizedAlpha;
+				g *= normalizedAlpha;
+				b *= normalizedAlpha;
+			}
+
+			var a = normalizedAlpha * 255;
+
+			quad.BottomLeft.Colors.R = (byte)r;
+			quad.BottomLeft.Colors.G = (byte)g;
+			quad.BottomLeft.Colors.B = (byte)b;
+			quad.BottomLeft.Colors.A = (byte)a;
+			quad.TopLeft.Colors.R = (byte)r;
+			quad.TopLeft.Colors.G = (byte)g;
+			quad.TopLeft.Colors.B = (byte)b;
+			quad.TopLeft.Colors.A = (byte)a;
+			quad.TopRight.Colors.R = (byte)r;
+			quad.TopRight.Colors.G = (byte)g;
+			quad.TopRight.Colors.B = (byte)b;
+			quad.TopRight.Colors.A = (byte)a;
+			quad.BottomRight.Colors.R = (byte)r;
+			quad.BottomRight.Colors.G = (byte)g;
+			quad.BottomRight.Colors.B = (byte)b;
+			quad.BottomRight.Colors.A = (byte)a;
+
+			quad.BottomLeft.Vertices.X = vert [RegionAttachment.X1];
+			quad.BottomLeft.Vertices.Y = vert [RegionAttachment.Y1];
+			quad.TopLeft.Vertices.X = vert [RegionAttachment.X2];
+			quad.TopLeft.Vertices.Y = vert [RegionAttachment.Y2];
+			quad.TopRight.Vertices.X = vert [RegionAttachment.X3];
+			quad.TopRight.Vertices.Y = vert [RegionAttachment.Y3];
+			quad.BottomRight.Vertices.X = vert [RegionAttachment.X4];
+			quad.BottomRight.Vertices.Y = vert [RegionAttachment.Y4];
+
+			quad.BottomLeft.TexCoords.U = self.UVs [RegionAttachment.X1];
+			quad.BottomLeft.TexCoords.V = self.UVs [RegionAttachment.Y1];
+			quad.TopLeft.TexCoords.U = self.UVs [RegionAttachment.X2];
+			quad.TopLeft.TexCoords.V = self.UVs [RegionAttachment.Y2];
+			quad.TopRight.TexCoords.U = self.UVs [RegionAttachment.X3];
+			quad.TopRight.TexCoords.V = self.UVs [RegionAttachment.Y3];
+			quad.BottomRight.TexCoords.U = self.UVs [RegionAttachment.X4];
+			quad.BottomRight.TexCoords.V = self.UVs [RegionAttachment.Y4];
+		}
+
+
+		#endregion
      
 
-    }
+	}
+
+
+	public enum AttachmentType
+	{
+		ATTACHMENT_REGION = 1,
+		ATTACHMENT_REGION_SEQUENCE = 2,
+		ATTACHMENT_BOUNDING_BOX = 3
+	}
+
+
 }
diff --git a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-cocossharp/CCSkeletonAnimation.cs b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-cocossharp/CCSkeletonAnimation.cs
index 85af47e..44cc2d4 100644
--- a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-cocossharp/CCSkeletonAnimation.cs
+++ b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-cocossharp/CCSkeletonAnimation.cs
@@ -1,148 +1,173 @@
 using Spine;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
+
 
 namespace CocosSharp.Spine
 {
-    public class CCSkeletonAnimation : CCSkeleton
-    {
 
-        public float TimeScale = 1;
 
-        AnimationState State { get; set; }
-        public bool OwnsAnimationStateData { get; private set; }
+	public class CCSkeletonAnimation : CCSkeleton
+	{
+
+
+		public delegate void StartEndDelegate (AnimationState state, int trackIndex);
+
+		public delegate void EventDelegate (AnimationState state, int trackIndex, Event e);
+
+		public delegate void CompleteDelegate (AnimationState state, int trackIndex, int loopCount);
+
+		public float TimeScale = 1;
+
+		public event StartEndDelegate Start;
+		public event StartEndDelegate End;
+		public event EventDelegate Event;
+		public event CompleteDelegate Complete;
+
+		AnimationState State { get; set; }
+
+		public bool OwnsAnimationStateData { get; private set; }
+
+
+		#region Constructors
+
+
+		public CCSkeletonAnimation ()
+		{
+			Initializer ();
+		}
 
-        public delegate void StartEndDelegate(AnimationState state, int trackIndex);
-        public event StartEndDelegate Start;
-        public event StartEndDelegate End;
 
-        public delegate void EventDelegate(AnimationState state, int trackIndex, Event e);
-        public event EventDelegate Event;
+		public CCSkeletonAnimation (SkeletonData skeletonData) : base (skeletonData)
+		{
+			Initializer ();
+		}
 
-        public delegate void CompleteDelegate(AnimationState state, int trackIndex, int loopCount);
-        public event CompleteDelegate Complete;
 
-        public CCSkeletonAnimation()
-        {
-            this.Initializer();
+		public CCSkeletonAnimation (string skeletonDataFile, Atlas atlas, float scale) : base (skeletonDataFile, atlas, scale)
+		{
+			Initializer ();
+		}
 
-        }
 
-        public CCSkeletonAnimation(SkeletonData skeletonData) : 
-            base(skeletonData,false)
-        {
-            this.Initializer();
-        }
+		public CCSkeletonAnimation (string skeletonDataFile, string atlasFile, float scale) : base (skeletonDataFile, atlasFile, scale)
+		{
+			Initializer ();
+		}
 
-        public CCSkeletonAnimation(string skeletonDataFile, Atlas atlas, float scale)
-            :base(skeletonDataFile,atlas,scale)
-        {
-            this.Initializer();
-        }
 
-        public CCSkeletonAnimation(string skeletonDataFile, string atlasFile, float scale) 
-            : base(skeletonDataFile,atlasFile,scale)
-        {
-           
-           Initializer();
-        }
+		#endregion
+
+
+		#region Public
 
         
-        public void SetAnimationStateData (AnimationStateData stateData ) {
-	        
-	        if (stateData!=null)
-
-	        OwnsAnimationStateData = false;
-	        State = new AnimationState(stateData);
-            State.Event += OnEvent;
-            State.Start += OnStart;
-            State.Complete += OnComplete;
-            State.End += OnEnd;
-
-        }
-
-        public override void Update(float dt)
-        {
-            base.Update(dt);
-
-            dt *= TimeScale;
-            State.Update(dt);
-            State.Apply(Skeleton);
-            UpdateWorldTransform();
-        }
-
-        public void SetMix(string fromAnimation, string toAnimation, float duration)
-        {
-            State.Data.SetMix(fromAnimation, toAnimation, duration);
-        }
-
-        ~CCSkeletonAnimation()
-        {
-        }
-
-        void Initializer()
-        {
-            OwnsAnimationStateData = true;
-
-            State = new AnimationState(new AnimationStateData(Skeleton.Data));
-            State.Event += OnEvent;
-            State.Start += OnStart;
-            State.Complete += OnComplete;
-            State.End += OnEnd;
-        }
-
-        void OnEnd(AnimationState state, int trackIndex)
-        {
-            if (End != null)
-                End(state, trackIndex);
-
-        }
-
-        private void OnComplete(AnimationState state, int trackIndex, int loopCount)
-        {
-            // spAnimationState_clearTrack
-            if (Complete != null)
-                Complete(state, trackIndex, loopCount);
-        }
-
-        void OnStart(AnimationState state, int trackIndex)
-        {
-            if (Start != null)
-                Start(state, trackIndex);
-        }
-
-        void OnEvent(AnimationState state, int trackIndex, Event e)
-        {
-            if (Event != null)
-                Event(state, trackIndex, e);
-
-        }
-
-       public TrackEntry SetAnimation(int trackIndex, string name, bool loop)
-        {
-
-            Animation animation = Skeleton.Data.FindAnimation(name);
-            if (animation == null)
-            {
-                CCLog.Log(string.Format("Spine: Animation not found: %s", name)); //CCLog("Spine: Animation not found: %s", name);
-                return null;
-            }
-            return State.SetAnimation(trackIndex, animation, loop);
-        }
-
-       public TrackEntry AddAnimation(int trackIndex, string name, bool loop, float delay = 0)
-        {
-            Animation animation = Skeleton.Data.FindAnimation(name);
-            if (animation == null)
-            {
-                CCLog.Log("Spine: Animation not found: %s", name);
-                return null;
-            }
-            return State.AddAnimation(trackIndex, animation, loop, delay);
-        }
-
-
-    }
+		public void SetAnimationStateData (AnimationStateData stateData)
+		{
+			OwnsAnimationStateData &= stateData == null;
+			
+			State = new AnimationState (stateData);
+
+			State.Event += OnEvent;
+			State.Start += OnStart;
+			State.Complete += OnComplete;
+			State.End += OnEnd;
+		}
+
+
+		public override void Update (float dt)
+		{
+			base.Update (dt);
+
+			dt *= TimeScale;
+
+			State.Update (dt);
+			State.Apply (Skeleton);
+
+			UpdateWorldTransform ();
+		}
+
+
+		public void SetMix (string fromAnimation, string toAnimation, float duration)
+		{
+			State.Data.SetMix (fromAnimation, toAnimation, duration);
+		}
+
+
+		public TrackEntry SetAnimation (int trackIndex, string name, bool loop)
+		{
+			var animation = Skeleton.Data.FindAnimation (name);
+
+			if (animation == null) {
+				CCLog.Log (string.Format ("Spine: Animation not found: '{0}'", name));
+				return null;
+			}
+
+			return State.SetAnimation (trackIndex, animation, loop);
+		}
+
+
+		public TrackEntry AddAnimation (int trackIndex, string name, bool loop, float delay = 0)
+		{
+			var animation = Skeleton.Data.FindAnimation (name);
+
+			if (animation == null) {
+				CCLog.Log ("Spine: Animation not found: '{0}'", name);
+				return null;
+			}
+
+			return State.AddAnimation (trackIndex, animation, loop, delay);
+		}
+
+
+		#endregion
+
+
+		#region Private
+
+
+		void Initializer ()
+		{
+			OwnsAnimationStateData = true;
+
+			State = new AnimationState (new AnimationStateData (Skeleton.Data));
+			State.Event += OnEvent;
+			State.Start += OnStart;
+			State.Complete += OnComplete;
+			State.End += OnEnd;
+		}
+
+
+		void OnEnd (AnimationState state, int trackIndex)
+		{
+			if (End != null)
+				End (state, trackIndex);
+		}
+
+
+		void OnComplete (AnimationState state, int trackIndex, int loopCount)
+		{
+			if (Complete != null)
+				Complete (state, trackIndex, loopCount);
+		}
+
+
+		void OnStart (AnimationState state, int trackIndex)
+		{
+			if (Start != null)
+				Start (state, trackIndex);
+		}
+
+
+		void OnEvent (AnimationState state, int trackIndex, Event e)
+		{
+			if (Event != null)
+				Event (state, trackIndex, e);
+		}
+
+
+		#endregion
+
+
+	}
+
+
 }
diff --git a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-cocossharp/CocosSharpTextureLoader.cs b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-cocossharp/CocosSharpTextureLoader.cs
index c5c93e3..894b238 100644
--- a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-cocossharp/CocosSharpTextureLoader.cs
+++ b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-cocossharp/CocosSharpTextureLoader.cs
@@ -1,32 +1,42 @@
 using System;
-using System.IO;
 using CocosSharp;
-using Microsoft.Xna.Framework.Graphics;
 using Spine;
 
+
 namespace CocosSharp.Spine
 {
-	public class CocosSharpTextureLoader : TextureLoader 
+
+
+	public class CocosSharpTextureLoader : TextureLoader
 	{
-		public CocosSharpTextureLoader ()
-		{
-		}
+
 
 		CCTexture2D texture;
 
-		public void Load (AtlasPage page, String path) 
+
+		#region Public
+
+
+		public void Load (AtlasPage page, String path)
 		{
-			var ccTexture = CCTextureCache.SharedTextureCache.AddImage(path);
-            texture = ccTexture;
+			texture = CCTextureCache.SharedTextureCache.AddImage (path);
 
-            page.rendererObject = texture;
-            page.width = (int)texture.ContentSizeInPixels.Width;
-            page.height = (int)texture.ContentSizeInPixels.Height;
+			page.rendererObject = texture;
+			page.width = (int)texture.ContentSizeInPixels.Width;
+			page.height = (int)texture.ContentSizeInPixels.Height;
 		}
 
-		public void Unload (Object texture) {
-			((CCTexture2D)texture).Dispose();
+
+		public void Unload (Object texture)
+		{
+			((CCTexture2D)texture).Dispose ();
 		}
+
+
+		#endregion
+
+
 	}
-}
 
+
+}
diff --git a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Animation.cs b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Animation.cs
old mode 100644
new mode 100755
index 19d892c..eb0b695
--- a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Animation.cs
+++ b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Animation.cs
@@ -1,25 +1,26 @@
 /******************************************************************************
  * Spine Runtimes Software License
- * Version 2.1
+ * Version 2.3
  * 
- * Copyright (c) 2013, Esoteric Software
+ * Copyright (c) 2013-2015, Esoteric Software
  * All rights reserved.
  * 
  * You are granted a perpetual, non-exclusive, non-sublicensable and
- * non-transferable license to install, execute and perform the Spine Runtimes
- * Software (the "Software") solely for internal use. Without the written
- * permission of Esoteric Software (typically granted by licensing Spine), you
- * may not (a) modify, translate, adapt or otherwise create derivative works,
- * improvements of the Software or develop new applications using the Software
- * or (b) remove, delete, alter or obscure any trademarks or any copyright,
- * trademark, patent or other intellectual property or proprietary rights
- * notices on or in the Software, including any copy thereof. Redistributions
- * in binary or source form must include this license and terms.
+ * non-transferable license to use, install, execute and perform the Spine
+ * Runtimes Software (the "Software") and derivative works solely for personal
+ * or internal use. Without the written permission of Esoteric Software (see
+ * Section 2 of the Spine Software License Agreement), you may not (a) modify,
+ * translate, adapt or otherwise create derivative works, improvements of the
+ * Software or develop new applications using the Software or (b) remove,
+ * delete, alter or obscure any trademarks or any copyright, trademark, patent
+ * or other intellectual property or proprietary rights notices on or in the
+ * Software, including any copy thereof. Redistributions in binary or source
+ * form must include this license and terms.
  * 
  * THIS SOFTWARE IS PROVIDED BY ESOTERIC SOFTWARE "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 SOFTARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * EVENT SHALL ESOTERIC SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
@@ -33,15 +34,15 @@
 
 namespace Spine {
 	public class Animation {
-		internal List<Timeline> timelines;
+		internal ExposedList<Timeline> timelines;
 		internal float duration;
 		internal String name;
 
 		public String Name { get { return name; } }
-		public List<Timeline> Timelines { get { return timelines; } set { timelines = value; } }
+		public ExposedList<Timeline> Timelines { get { return timelines; } set { timelines = value; } }
 		public float Duration { get { return duration; } set { duration = value; } }
 
-		public Animation (String name, List<Timeline> timelines, float duration) {
+		public Animation (String name, ExposedList<Timeline> timelines, float duration) {
 			if (name == null) throw new ArgumentNullException("name cannot be null.");
 			if (timelines == null) throw new ArgumentNullException("timelines cannot be null.");
 			this.name = name;
@@ -52,7 +53,7 @@ public Animation (String name, List<Timeline> timelines, float duration) {
 		/// <summary>Poses the skeleton at the specified time for this animation.</summary>
 		/// <param name="lastTime">The last time the animation was applied.</param>
 		/// <param name="events">Any triggered events are added.</param>
-		public void Apply (Skeleton skeleton, float lastTime, float time, bool loop, List<Event> events) {
+		public void Apply (Skeleton skeleton, float lastTime, float time, bool loop, ExposedList<Event> events) {
 			if (skeleton == null) throw new ArgumentNullException("skeleton cannot be null.");
 
 			if (loop && duration != 0) {
@@ -60,16 +61,16 @@ public void Apply (Skeleton skeleton, float lastTime, float time, bool loop, Lis
 				lastTime %= duration;
 			}
 
-			List<Timeline> timelines = this.timelines;
+			ExposedList<Timeline> timelines = this.timelines;
 			for (int i = 0, n = timelines.Count; i < n; i++)
-				timelines[i].Apply(skeleton, lastTime, time, events, 1);
+				timelines.Items[i].Apply(skeleton, lastTime, time, events, 1);
 		}
 
 		/// <summary>Poses the skeleton at the specified time for this animation mixed with the current pose.</summary>
 		/// <param name="lastTime">The last time the animation was applied.</param>
 		/// <param name="events">Any triggered events are added.</param>
 		/// <param name="alpha">The amount of this animation that affects the current pose.</param>
-		public void Mix (Skeleton skeleton, float lastTime, float time, bool loop, List<Event> events, float alpha) {
+		public void Mix (Skeleton skeleton, float lastTime, float time, bool loop, ExposedList<Event> events, float alpha) {
 			if (skeleton == null) throw new ArgumentNullException("skeleton cannot be null.");
 
 			if (loop && duration != 0) {
@@ -77,9 +78,9 @@ public void Mix (Skeleton skeleton, float lastTime, float time, bool loop, List<
 				lastTime %= duration;
 			}
 
-			List<Timeline> timelines = this.timelines;
+			ExposedList<Timeline> timelines = this.timelines;
 			for (int i = 0, n = timelines.Count; i < n; i++)
-				timelines[i].Apply(skeleton, lastTime, time, events, alpha);
+				timelines.Items[i].Apply(skeleton, lastTime, time, events, alpha);
 		}
 
 		/// <param name="target">After the first and before the last entry.</param>
@@ -98,6 +99,22 @@ internal static int binarySearch (float[] values, float target, int step) {
 			}
 		}
 
+		/// <param name="target">After the first and before the last entry.</param>
+		internal static int binarySearch (float[] values, float target) {
+			int low = 0;
+			int high = values.Length - 2;
+			if (high == 0) return 1;
+			int current = (int)((uint)high >> 1);
+			while (true) {
+				if (values[(current + 1)] <= target)
+					low = current + 1;
+				else
+					high = current;
+				if (low == high) return (low + 1);
+				current = (int)((uint)(low + high) >> 1);
+			}
+		}
+
 		internal static int linearSearch (float[] values, float target, int step) {
 			for (int i = 0, last = values.Length - step; i <= last; i += step)
 				if (values[i] > target) return i;
@@ -107,78 +124,51 @@ internal static int linearSearch (float[] values, float target, int step) {
 
 	public interface Timeline {
 		/// <summary>Sets the value(s) for the specified time.</summary>
-		void Apply (Skeleton skeleton, float lastTime, float time, List<Event> firedEvents, float alpha);
+		/// <param name="events">May be null to not collect fired events.</param>
+		void Apply (Skeleton skeleton, float lastTime, float time, ExposedList<Event> events, float alpha);
 	}
 
 	/// <summary>Base class for frames that use an interpolation bezier curve.</summary>
 	abstract public class CurveTimeline : Timeline {
-		static protected float LINEAR = 0;
-		static protected float STEPPED = -1;
-		static protected int BEZIER_SEGMENTS = 10;
+		protected const float LINEAR = 0, STEPPED = 1, BEZIER = 2;
+		protected const int BEZIER_SEGMENTS = 10, BEZIER_SIZE = BEZIER_SEGMENTS * 2 - 1;
 
-		private float[] curves; // dfx, dfy, ddfx, ddfy, dddfx, dddfy, ...
-		public int FrameCount { get { return curves.Length / 6 + 1; } }
+		private float[] curves; // type, x, y, ...
+		public int FrameCount { get { return curves.Length / BEZIER_SIZE + 1; } }
 
 		public CurveTimeline (int frameCount) {
-			curves = new float[(frameCount - 1) * 6];
+			curves = new float[(frameCount - 1) * BEZIER_SIZE];
 		}
 
-		abstract public void Apply (Skeleton skeleton, float lastTime, float time, List<Event> firedEvents, float alpha);
+		abstract public void Apply (Skeleton skeleton, float lastTime, float time, ExposedList<Event> firedEvents, float alpha);
 
 		public void SetLinear (int frameIndex) {
-			curves[frameIndex * 6] = LINEAR;
+			curves[frameIndex * BEZIER_SIZE] = LINEAR;
 		}
 
 		public void SetStepped (int frameIndex) {
-			curves[frameIndex * 6] = STEPPED;
+			curves[frameIndex * BEZIER_SIZE] = STEPPED;
 		}
 
 		/// <summary>Sets the control handle positions for an interpolation bezier curve used to transition from this keyframe to the next.
 		/// cx1 and cx2 are from 0 to 1, representing the percent of time between the two keyframes. cy1 and cy2 are the percent of
 		/// the difference between the keyframe's values.</summary>
 		public void SetCurve (int frameIndex, float cx1, float cy1, float cx2, float cy2) {
-			float subdiv_step = 1f / BEZIER_SEGMENTS;
-			float subdiv_step2 = subdiv_step * subdiv_step;
-			float subdiv_step3 = subdiv_step2 * subdiv_step;
-			float pre1 = 3 * subdiv_step;
-			float pre2 = 3 * subdiv_step2;
-			float pre4 = 6 * subdiv_step2;
-			float pre5 = 6 * subdiv_step3;
-			float tmp1x = -cx1 * 2 + cx2;
-			float tmp1y = -cy1 * 2 + cy2;
-			float tmp2x = (cx1 - cx2) * 3 + 1;
-			float tmp2y = (cy1 - cy2) * 3 + 1;
-			int i = frameIndex * 6;
+			float subdiv1 = 1f / BEZIER_SEGMENTS, subdiv2 = subdiv1 * subdiv1, subdiv3 = subdiv2 * subdiv1;
+			float pre1 = 3 * subdiv1, pre2 = 3 * subdiv2, pre4 = 6 * subdiv2, pre5 = 6 * subdiv3;
+			float tmp1x = -cx1 * 2 + cx2, tmp1y = -cy1 * 2 + cy2, tmp2x = (cx1 - cx2) * 3 + 1, tmp2y = (cy1 - cy2) * 3 + 1;
+			float dfx = cx1 * pre1 + tmp1x * pre2 + tmp2x * subdiv3, dfy = cy1 * pre1 + tmp1y * pre2 + tmp2y * subdiv3;
+			float ddfx = tmp1x * pre4 + tmp2x * pre5, ddfy = tmp1y * pre4 + tmp2y * pre5;
+			float dddfx = tmp2x * pre5, dddfy = tmp2y * pre5;
+
+			int i = frameIndex * BEZIER_SIZE;
 			float[] curves = this.curves;
-			curves[i] = cx1 * pre1 + tmp1x * pre2 + tmp2x * subdiv_step3;
-			curves[i + 1] = cy1 * pre1 + tmp1y * pre2 + tmp2y * subdiv_step3;
-			curves[i + 2] = tmp1x * pre4 + tmp2x * pre5;
-			curves[i + 3] = tmp1y * pre4 + tmp2y * pre5;
-			curves[i + 4] = tmp2x * pre5;
-			curves[i + 5] = tmp2y * pre5;
-		}
+			curves[i++] = BEZIER;
 
-		public float GetCurvePercent (int frameIndex, float percent) {
-			int curveIndex = frameIndex * 6;
-			float[] curves = this.curves;
-			float dfx = curves[curveIndex];
-			if (dfx == LINEAR) return percent;
-			if (dfx == STEPPED) return 0;
-			float dfy = curves[curveIndex + 1];
-			float ddfx = curves[curveIndex + 2];
-			float ddfy = curves[curveIndex + 3];
-			float dddfx = curves[curveIndex + 4];
-			float dddfy = curves[curveIndex + 5];
 			float x = dfx, y = dfy;
-			int i = BEZIER_SEGMENTS - 2;
-			while (true) {
-				if (x >= percent) {
-					float lastX = x - dfx;
-					float lastY = y - dfy;
-					return lastY + (y - lastY) * (percent - lastX) / (x - lastX);
-				}
-				if (i == 0) break;
-				i--;
+			for (int n = i + BEZIER_SIZE - 1; i < n; i += 2) {
+				curves[i] = x;
+				curves[i + 1] = y;
 				dfx += ddfx;
 				dfy += ddfy;
 				ddfx += dddfx;
@@ -186,13 +176,41 @@ public float GetCurvePercent (int frameIndex, float percent) {
 				x += dfx;
 				y += dfy;
 			}
+		}
+
+		public float GetCurvePercent (int frameIndex, float percent) {
+			float[] curves = this.curves;
+			int i = frameIndex * BEZIER_SIZE;
+			float type = curves[i];
+			if (type == LINEAR) return percent;
+			if (type == STEPPED) return 0;
+			i++;
+			float x = 0;
+			for (int start = i, n = i + BEZIER_SIZE - 1; i < n; i += 2) {
+				x = curves[i];
+				if (x >= percent) {
+					float prevX, prevY;
+					if (i == start) {
+						prevX = 0;
+						prevY = 0;
+					} else {
+						prevX = curves[i - 2];
+						prevY = curves[i - 1];
+					}
+					return prevY + (curves[i + 1] - prevY) * (percent - prevX) / (x - prevX);
+				}
+			}
+			float y = curves[i - 1];
 			return y + (1 - y) * (percent - x) / (1 - x); // Last point is 1,1.
 		}
+		public float GetCurveType (int frameIndex) {
+			return curves[frameIndex * BEZIER_SIZE];
+		}
 	}
 
 	public class RotateTimeline : CurveTimeline {
-		static protected int LAST_FRAME_TIME = -2;
-		static protected int FRAME_VALUE = 1;
+		protected const int PREV_FRAME_TIME = -2;
+		protected const int FRAME_VALUE = 1;
 
 		internal int boneIndex;
 		internal float[] frames;
@@ -202,7 +220,7 @@ public class RotateTimeline : CurveTimeline {
 
 		public RotateTimeline (int frameCount)
 			: base(frameCount) {
-			frames = new float[frameCount * 2];
+			frames = new float[frameCount << 1];
 		}
 
 		/// <summary>Sets the time and value of the specified keyframe.</summary>
@@ -212,11 +230,11 @@ public void SetFrame (int frameIndex, float time, float angle) {
 			frames[frameIndex + 1] = angle;
 		}
 
-		override public void Apply (Skeleton skeleton, float lastTime, float time, List<Event> firedEvents, float alpha) {
+		override public void Apply (Skeleton skeleton, float lastTime, float time, ExposedList<Event> firedEvents, float alpha) {
 			float[] frames = this.frames;
 			if (time < frames[0]) return; // Time is before first frame.
 
-			Bone bone = skeleton.bones[boneIndex];
+			Bone bone = skeleton.bones.Items[boneIndex];
 
 			float amount;
 
@@ -230,19 +248,19 @@ override public void Apply (Skeleton skeleton, float lastTime, float time, List<
 				return;
 			}
 
-			// Interpolate between the last frame and the current frame.
+			// Interpolate between the previous frame and the current frame.
 			int frameIndex = Animation.binarySearch(frames, time, 2);
-			float lastFrameValue = frames[frameIndex - 1];
+			float prevFrameValue = frames[frameIndex - 1];
 			float frameTime = frames[frameIndex];
-			float percent = 1 - (time - frameTime) / (frames[frameIndex + LAST_FRAME_TIME] - frameTime);
-			percent = GetCurvePercent(frameIndex / 2 - 1, percent < 0 ? 0 : (percent > 1 ? 1 : percent));
+			float percent = 1 - (time - frameTime) / (frames[frameIndex + PREV_FRAME_TIME] - frameTime);
+			percent = GetCurvePercent((frameIndex >> 1) - 1, percent < 0 ? 0 : (percent > 1 ? 1 : percent));
 
-			amount = frames[frameIndex + FRAME_VALUE] - lastFrameValue;
+			amount = frames[frameIndex + FRAME_VALUE] - prevFrameValue;
 			while (amount > 180)
 				amount -= 360;
 			while (amount < -180)
 				amount += 360;
-			amount = bone.data.rotation + (lastFrameValue + amount * percent) - bone.rotation;
+			amount = bone.data.rotation + (prevFrameValue + amount * percent) - bone.rotation;
 			while (amount > 180)
 				amount -= 360;
 			while (amount < -180)
@@ -252,9 +270,9 @@ override public void Apply (Skeleton skeleton, float lastTime, float time, List<
 	}
 
 	public class TranslateTimeline : CurveTimeline {
-		static protected int LAST_FRAME_TIME = -3;
-		static protected int FRAME_X = 1;
-		static protected int FRAME_Y = 2;
+		protected const int PREV_FRAME_TIME = -3;
+		protected const int FRAME_X = 1;
+		protected const int FRAME_Y = 2;
 
 		internal int boneIndex;
 		internal float[] frames;
@@ -275,11 +293,11 @@ public void SetFrame (int frameIndex, float time, float x, float y) {
 			frames[frameIndex + 2] = y;
 		}
 
-		override public void Apply (Skeleton skeleton, float lastTime, float time, List<Event> firedEvents, float alpha) {
+		override public void Apply (Skeleton skeleton, float lastTime, float time, ExposedList<Event> firedEvents, float alpha) {
 			float[] frames = this.frames;
 			if (time < frames[0]) return; // Time is before first frame.
 
-			Bone bone = skeleton.bones[boneIndex];
+			Bone bone = skeleton.bones.Items[boneIndex];
 
 			if (time >= frames[frames.Length - 3]) { // Time is after last frame.
 				bone.x += (bone.data.x + frames[frames.Length - 2] - bone.x) * alpha;
@@ -287,16 +305,16 @@ override public void Apply (Skeleton skeleton, float lastTime, float time, List<
 				return;
 			}
 
-			// Interpolate between the last frame and the current frame.
+			// Interpolate between the previous frame and the current frame.
 			int frameIndex = Animation.binarySearch(frames, time, 3);
-			float lastFrameX = frames[frameIndex - 2];
-			float lastFrameY = frames[frameIndex - 1];
+			float prevFrameX = frames[frameIndex - 2];
+			float prevFrameY = frames[frameIndex - 1];
 			float frameTime = frames[frameIndex];
-			float percent = 1 - (time - frameTime) / (frames[frameIndex + LAST_FRAME_TIME] - frameTime);
+			float percent = 1 - (time - frameTime) / (frames[frameIndex + PREV_FRAME_TIME] - frameTime);
 			percent = GetCurvePercent(frameIndex / 3 - 1, percent < 0 ? 0 : (percent > 1 ? 1 : percent));
 
-			bone.x += (bone.data.x + lastFrameX + (frames[frameIndex + FRAME_X] - lastFrameX) * percent - bone.x) * alpha;
-			bone.y += (bone.data.y + lastFrameY + (frames[frameIndex + FRAME_Y] - lastFrameY) * percent - bone.y) * alpha;
+			bone.x += (bone.data.x + prevFrameX + (frames[frameIndex + FRAME_X] - prevFrameX) * percent - bone.x) * alpha;
+			bone.y += (bone.data.y + prevFrameY + (frames[frameIndex + FRAME_Y] - prevFrameY) * percent - bone.y) * alpha;
 		}
 	}
 
@@ -305,36 +323,36 @@ public ScaleTimeline (int frameCount)
 			: base(frameCount) {
 		}
 
-		override public void Apply (Skeleton skeleton, float lastTime, float time, List<Event> firedEvents, float alpha) {
+		override public void Apply (Skeleton skeleton, float lastTime, float time, ExposedList<Event> firedEvents, float alpha) {
 			float[] frames = this.frames;
 			if (time < frames[0]) return; // Time is before first frame.
 
-			Bone bone = skeleton.bones[boneIndex];
+			Bone bone = skeleton.bones.Items[boneIndex];
 			if (time >= frames[frames.Length - 3]) { // Time is after last frame.
-				bone.scaleX += (bone.data.scaleX - 1 + frames[frames.Length - 2] - bone.scaleX) * alpha;
-				bone.scaleY += (bone.data.scaleY - 1 + frames[frames.Length - 1] - bone.scaleY) * alpha;
+				bone.scaleX += (bone.data.scaleX * frames[frames.Length - 2] - bone.scaleX) * alpha;
+				bone.scaleY += (bone.data.scaleY * frames[frames.Length - 1] - bone.scaleY) * alpha;
 				return;
 			}
 
-			// Interpolate between the last frame and the current frame.
+			// Interpolate between the previous frame and the current frame.
 			int frameIndex = Animation.binarySearch(frames, time, 3);
-			float lastFrameX = frames[frameIndex - 2];
-			float lastFrameY = frames[frameIndex - 1];
+			float prevFrameX = frames[frameIndex - 2];
+			float prevFrameY = frames[frameIndex - 1];
 			float frameTime = frames[frameIndex];
-			float percent = 1 - (time - frameTime) / (frames[frameIndex + LAST_FRAME_TIME] - frameTime);
+			float percent = 1 - (time - frameTime) / (frames[frameIndex + PREV_FRAME_TIME] - frameTime);
 			percent = GetCurvePercent(frameIndex / 3 - 1, percent < 0 ? 0 : (percent > 1 ? 1 : percent));
 
-			bone.scaleX += (bone.data.scaleX - 1 + lastFrameX + (frames[frameIndex + FRAME_X] - lastFrameX) * percent - bone.scaleX) * alpha;
-			bone.scaleY += (bone.data.scaleY - 1 + lastFrameY + (frames[frameIndex + FRAME_Y] - lastFrameY) * percent - bone.scaleY) * alpha;
+			bone.scaleX += (bone.data.scaleX * (prevFrameX + (frames[frameIndex + FRAME_X] - prevFrameX) * percent) - bone.scaleX) * alpha;
+			bone.scaleY += (bone.data.scaleY * (prevFrameY + (frames[frameIndex + FRAME_Y] - prevFrameY) * percent) - bone.scaleY) * alpha;
 		}
 	}
 
 	public class ColorTimeline : CurveTimeline {
-		static protected int LAST_FRAME_TIME = -5;
-		static protected int FRAME_R = 1;
-		static protected int FRAME_G = 2;
-		static protected int FRAME_B = 3;
-		static protected int FRAME_A = 4;
+		protected const int PREV_FRAME_TIME = -5;
+		protected const int FRAME_R = 1;
+		protected const int FRAME_G = 2;
+		protected const int FRAME_B = 3;
+		protected const int FRAME_A = 4;
 
 		internal int slotIndex;
 		internal float[] frames;
@@ -348,7 +366,7 @@ public ColorTimeline (int frameCount)
 		}
 
 		/// <summary>Sets the time and value of the specified keyframe.</summary>
-		public void setFrame (int frameIndex, float time, float r, float g, float b, float a) {
+		public void SetFrame (int frameIndex, float time, float r, float g, float b, float a) {
 			frameIndex *= 5;
 			frames[frameIndex] = time;
 			frames[frameIndex + 1] = r;
@@ -357,12 +375,10 @@ public void setFrame (int frameIndex, float time, float r, float g, float b, flo
 			frames[frameIndex + 4] = a;
 		}
 
-		override public void Apply (Skeleton skeleton, float lastTime, float time, List<Event> firedEvents, float alpha) {
+		override public void Apply (Skeleton skeleton, float lastTime, float time, ExposedList<Event> firedEvents, float alpha) {
 			float[] frames = this.frames;
 			if (time < frames[0]) return; // Time is before first frame.
 
-			Slot slot = skeleton.slots[slotIndex];
-
 			float r, g, b, a;
 			if (time >= frames[frames.Length - 5]) {
 				// Time is after last frame.
@@ -372,21 +388,22 @@ override public void Apply (Skeleton skeleton, float lastTime, float time, List<
 				b = frames[i - 1];
 				a = frames[i];
 			} else {
-				// Interpolate between the last frame and the current frame.
+				// Interpolate between the previous frame and the current frame.
 				int frameIndex = Animation.binarySearch(frames, time, 5);
-				float lastFrameR = frames[frameIndex - 4];
-				float lastFrameG = frames[frameIndex - 3];
-				float lastFrameB = frames[frameIndex - 2];
-				float lastFrameA = frames[frameIndex - 1];
+				float prevFrameR = frames[frameIndex - 4];
+				float prevFrameG = frames[frameIndex - 3];
+				float prevFrameB = frames[frameIndex - 2];
+				float prevFrameA = frames[frameIndex - 1];
 				float frameTime = frames[frameIndex];
-				float percent = 1 - (time - frameTime) / (frames[frameIndex + LAST_FRAME_TIME] - frameTime);
+				float percent = 1 - (time - frameTime) / (frames[frameIndex + PREV_FRAME_TIME] - frameTime);
 				percent = GetCurvePercent(frameIndex / 5 - 1, percent < 0 ? 0 : (percent > 1 ? 1 : percent));
 
-				r = lastFrameR + (frames[frameIndex + FRAME_R] - lastFrameR) * percent;
-				g = lastFrameG + (frames[frameIndex + FRAME_G] - lastFrameG) * percent;
-				b = lastFrameB + (frames[frameIndex + FRAME_B] - lastFrameB) * percent;
-				a = lastFrameA + (frames[frameIndex + FRAME_A] - lastFrameA) * percent;
+				r = prevFrameR + (frames[frameIndex + FRAME_R] - prevFrameR) * percent;
+				g = prevFrameG + (frames[frameIndex + FRAME_G] - prevFrameG) * percent;
+				b = prevFrameB + (frames[frameIndex + FRAME_B] - prevFrameB) * percent;
+				a = prevFrameA + (frames[frameIndex + FRAME_A] - prevFrameA) * percent;
 			}
+			Slot slot = skeleton.slots.Items[slotIndex];
 			if (alpha < 1) {
 				slot.r += (r - slot.r) * alpha;
 				slot.g += (g - slot.g) * alpha;
@@ -417,23 +434,24 @@ public AttachmentTimeline (int frameCount) {
 		}
 
 		/// <summary>Sets the time and value of the specified keyframe.</summary>
-		public void setFrame (int frameIndex, float time, String attachmentName) {
+		public void SetFrame (int frameIndex, float time, String attachmentName) {
 			frames[frameIndex] = time;
 			attachmentNames[frameIndex] = attachmentName;
 		}
 
-		public void Apply (Skeleton skeleton, float lastTime, float time, List<Event> firedEvents, float alpha) {
+		public void Apply (Skeleton skeleton, float lastTime, float time, ExposedList<Event> firedEvents, float alpha) {
 			float[] frames = this.frames;
-			if (time < frames[0]) return; // Time is before first frame.
+			if (time < frames[0]) {
+				if (lastTime > time) Apply(skeleton, lastTime, int.MaxValue, null, 0);
+				return;
+			} else if (lastTime > time) //
+				lastTime = -1;
 
-			int frameIndex;
-			if (time >= frames[frames.Length - 1]) // Time is after last frame.
-				frameIndex = frames.Length - 1;
-			else
-				frameIndex = Animation.binarySearch(frames, time, 1) - 1;
+			int frameIndex = (time >= frames[frames.Length - 1] ? frames.Length : Animation.binarySearch(frames, time)) - 1;
+			if (frames[frameIndex] < lastTime) return;
 
 			String attachmentName = attachmentNames[frameIndex];
-			skeleton.slots[slotIndex].Attachment =
+			skeleton.slots.Items[slotIndex].Attachment =
 				 attachmentName == null ? null : skeleton.GetAttachment(slotIndex, attachmentName);
 		}
 	}
@@ -452,13 +470,13 @@ public EventTimeline (int frameCount) {
 		}
 
 		/// <summary>Sets the time and value of the specified keyframe.</summary>
-		public void setFrame (int frameIndex, float time, Event e) {
+		public void SetFrame (int frameIndex, float time, Event e) {
 			frames[frameIndex] = time;
 			events[frameIndex] = e;
 		}
 
 		/// <summary>Fires events for frames > lastTime and <= time.</summary>
-		public void Apply (Skeleton skeleton, float lastTime, float time, List<Event> firedEvents, float alpha) {
+		public void Apply (Skeleton skeleton, float lastTime, float time, ExposedList<Event> firedEvents, float alpha) {
 			if (firedEvents == null) return;
 			float[] frames = this.frames;
 			int frameCount = frames.Length;
@@ -474,7 +492,7 @@ public void Apply (Skeleton skeleton, float lastTime, float time, List<Event> fi
 			if (lastTime < frames[0])
 				frameIndex = 0;
 			else {
-				frameIndex = Animation.binarySearch(frames, lastTime, 1);
+				frameIndex = Animation.binarySearch(frames, lastTime);
 				float frame = frames[frameIndex];
 				while (frameIndex > 0) { // Fire multiple events with the same frame.
 					if (frames[frameIndex - 1] != frame) break;
@@ -501,12 +519,12 @@ public DrawOrderTimeline (int frameCount) {
 
 		/// <summary>Sets the time and value of the specified keyframe.</summary>
 		/// <param name="drawOrder">May be null to use bind pose draw order.</param>
-		public void setFrame (int frameIndex, float time, int[] drawOrder) {
+		public void SetFrame (int frameIndex, float time, int[] drawOrder) {
 			frames[frameIndex] = time;
 			drawOrders[frameIndex] = drawOrder;
 		}
 
-		public void Apply (Skeleton skeleton, float lastTime, float time, List<Event> firedEvents, float alpha) {
+		public void Apply (Skeleton skeleton, float lastTime, float time, ExposedList<Event> firedEvents, float alpha) {
 			float[] frames = this.frames;
 			if (time < frames[0]) return; // Time is before first frame.
 
@@ -514,17 +532,18 @@ public void Apply (Skeleton skeleton, float lastTime, float time, List<Event> fi
 			if (time >= frames[frames.Length - 1]) // Time is after last frame.
 				frameIndex = frames.Length - 1;
 			else
-				frameIndex = Animation.binarySearch(frames, time, 1) - 1;
+				frameIndex = Animation.binarySearch(frames, time) - 1;
 
-			List<Slot> drawOrder = skeleton.drawOrder;
-			List<Slot> slots = skeleton.slots;
+			ExposedList<Slot> drawOrder = skeleton.drawOrder;
+			ExposedList<Slot> slots = skeleton.slots;
 			int[] drawOrderToSetupIndex = drawOrders[frameIndex];
 			if (drawOrderToSetupIndex == null) {
 				drawOrder.Clear();
-				drawOrder.AddRange(slots);
+				for (int i = 0, n = slots.Count; i < n; i++)
+					drawOrder.Add(slots.Items[i]);
 			} else {
 				for (int i = 0, n = drawOrderToSetupIndex.Length; i < n; i++)
-					drawOrder[i] = slots[drawOrderToSetupIndex[i]];
+					drawOrder.Items[i] = slots.Items[drawOrderToSetupIndex[i]];
 			}
 		}
 	}
@@ -547,20 +566,17 @@ public FFDTimeline (int frameCount)
 		}
 
 		/// <summary>Sets the time and value of the specified keyframe.</summary>
-		public void setFrame (int frameIndex, float time, float[] vertices) {
+		public void SetFrame (int frameIndex, float time, float[] vertices) {
 			frames[frameIndex] = time;
 			frameVertices[frameIndex] = vertices;
 		}
 
-		override public void Apply (Skeleton skeleton, float lastTime, float time, List<Event> firedEvents, float alpha) {
-			Slot slot = skeleton.slots[slotIndex];
+		override public void Apply (Skeleton skeleton, float lastTime, float time, ExposedList<Event> firedEvents, float alpha) {
+			Slot slot = skeleton.slots.Items[slotIndex];
 			if (slot.attachment != attachment) return;
 
 			float[] frames = this.frames;
-			if (time < frames[0]) {
-				slot.attachmentVerticesCount = 0;
-				return; // Time is before first frame.
-			}
+			if (time < frames[0]) return; // Time is before first frame.
 
 			float[][] frameVertices = this.frameVertices;
 			int vertexCount = frameVertices[0].Length;
@@ -570,20 +586,23 @@ override public void Apply (Skeleton skeleton, float lastTime, float time, List<
 				vertices = new float[vertexCount];
 				slot.attachmentVertices = vertices;
 			}
+			if (vertices.Length != vertexCount) alpha = 1; // Don't mix from uninitialized slot vertices.
 			slot.attachmentVerticesCount = vertexCount;
 
 			if (time >= frames[frames.Length - 1]) { // Time is after last frame.
 				float[] lastVertices = frameVertices[frames.Length - 1];
 				if (alpha < 1) {
-					for (int i = 0; i < vertexCount; i++)
-						vertices[i] += (lastVertices[i] - vertices[i]) * alpha;
+					for (int i = 0; i < vertexCount; i++) {
+						float vertex = vertices[i];
+						vertices[i] = vertex + (lastVertices[i] - vertex) * alpha;
+					}
 				} else
 					Array.Copy(lastVertices, 0, vertices, 0, vertexCount);
 				return;
 			}
 
 			// Interpolate between the previous frame and the current frame.
-			int frameIndex = Animation.binarySearch(frames, time, 1);
+			int frameIndex = Animation.binarySearch(frames, time);
 			float frameTime = frames[frameIndex];
 			float percent = 1 - (time - frameTime) / (frames[frameIndex - 1] - frameTime);
 			percent = GetCurvePercent(frameIndex - 1, percent < 0 ? 0 : (percent > 1 ? 1 : percent));
@@ -594,7 +613,8 @@ override public void Apply (Skeleton skeleton, float lastTime, float time, List<
 			if (alpha < 1) {
 				for (int i = 0; i < vertexCount; i++) {
 					float prev = prevVertices[i];
-					vertices[i] += (prev + (nextVertices[i] - prev) * percent - vertices[i]) * alpha;
+					float vertex = vertices[i];
+					vertices[i] = vertex + (prev + (nextVertices[i] - prev) * percent - vertex) * alpha;
 				}
 			} else {
 				for (int i = 0; i < vertexCount; i++) {
@@ -604,4 +624,102 @@ override public void Apply (Skeleton skeleton, float lastTime, float time, List<
 			}
 		}
 	}
+
+	public class IkConstraintTimeline : CurveTimeline {
+		private const int PREV_FRAME_TIME = -3;
+		private const int PREV_FRAME_MIX = -2;
+		private const int PREV_FRAME_BEND_DIRECTION = -1;
+		private const int FRAME_MIX = 1;
+
+		internal int ikConstraintIndex;
+		internal float[] frames;
+
+		public int IkConstraintIndex { get { return ikConstraintIndex; } set { ikConstraintIndex = value; } }
+		public float[] Frames { get { return frames; } set { frames = value; } } // time, mix, bendDirection, ...
+
+		public IkConstraintTimeline (int frameCount)
+			: base(frameCount) {
+			frames = new float[frameCount * 3];
+		}
+
+		/** Sets the time, mix and bend direction of the specified keyframe. */
+		public void SetFrame (int frameIndex, float time, float mix, int bendDirection) {
+			frameIndex *= 3;
+			frames[frameIndex] = time;
+			frames[frameIndex + 1] = mix;
+			frames[frameIndex + 2] = bendDirection;
+		}
+
+		override public void Apply (Skeleton skeleton, float lastTime, float time, ExposedList<Event> firedEvents, float alpha) {
+			float[] frames = this.frames;
+			if (time < frames[0]) return; // Time is before first frame.
+
+			IkConstraint ikConstraint = skeleton.ikConstraints.Items[ikConstraintIndex];
+
+			if (time >= frames[frames.Length - 3]) { // Time is after last frame.
+				ikConstraint.mix += (frames[frames.Length - 2] - ikConstraint.mix) * alpha;
+				ikConstraint.bendDirection = (int)frames[frames.Length - 1];
+				return;
+			}
+
+			// Interpolate between the previous frame and the current frame.
+			int frameIndex = Animation.binarySearch(frames, time, 3);
+			float prevFrameMix = frames[frameIndex + PREV_FRAME_MIX];
+			float frameTime = frames[frameIndex];
+			float percent = 1 - (time - frameTime) / (frames[frameIndex + PREV_FRAME_TIME] - frameTime);
+			percent = GetCurvePercent(frameIndex / 3 - 1, percent < 0 ? 0 : (percent > 1 ? 1 : percent));
+
+			float mix = prevFrameMix + (frames[frameIndex + FRAME_MIX] - prevFrameMix) * percent;
+			ikConstraint.mix += (mix - ikConstraint.mix) * alpha;
+			ikConstraint.bendDirection = (int)frames[frameIndex + PREV_FRAME_BEND_DIRECTION];
+		}
+	}
+
+	public class FlipXTimeline : Timeline {
+		internal int boneIndex;
+		internal float[] frames;
+
+		public int BoneIndex { get { return boneIndex; } set { boneIndex = value; } }
+		public float[] Frames { get { return frames; } set { frames = value; } } // time, flip, ...
+		public int FrameCount { get { return frames.Length >> 1; } }
+
+		public FlipXTimeline (int frameCount) {
+			frames = new float[frameCount << 1];
+		}
+
+		/// <summary>Sets the time and value of the specified keyframe.</summary>
+		public void SetFrame (int frameIndex, float time, bool flip) {
+			frameIndex *= 2;
+			frames[frameIndex] = time;
+			frames[frameIndex + 1] = flip ? 1 : 0;
+		}
+
+		public void Apply (Skeleton skeleton, float lastTime, float time, ExposedList<Event> firedEvents, float alpha) {
+			float[] frames = this.frames;
+			if (time < frames[0]) {
+				if (lastTime > time) Apply(skeleton, lastTime, int.MaxValue, null, 0);
+				return;
+			} else if (lastTime > time) //
+				lastTime = -1;
+
+			int frameIndex = (time >= frames[frames.Length - 2] ? frames.Length : Animation.binarySearch(frames, time, 2)) - 2;
+			if (frames[frameIndex] < lastTime) return;
+
+			SetFlip(skeleton.bones.Items[boneIndex], frames[frameIndex + 1] != 0);
+		}
+
+		virtual protected void SetFlip (Bone bone, bool flip) {
+			bone.flipX = flip;
+		}
+	}
+
+	public class FlipYTimeline : FlipXTimeline {
+		public FlipYTimeline (int frameCount)
+			: base(frameCount) {
+		}
+
+		override protected void SetFlip (Bone bone, bool flip) {
+			bone.flipY = flip;
+		}
+	}
 }
diff --git a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/AnimationState.cs b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/AnimationState.cs
old mode 100644
new mode 100755
index 91711af..d616cb8
--- a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/AnimationState.cs
+++ b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/AnimationState.cs
@@ -1,25 +1,26 @@
 /******************************************************************************
  * Spine Runtimes Software License
- * Version 2.1
+ * Version 2.3
  * 
- * Copyright (c) 2013, Esoteric Software
+ * Copyright (c) 2013-2015, Esoteric Software
  * All rights reserved.
  * 
  * You are granted a perpetual, non-exclusive, non-sublicensable and
- * non-transferable license to install, execute and perform the Spine Runtimes
- * Software (the "Software") solely for internal use. Without the written
- * permission of Esoteric Software (typically granted by licensing Spine), you
- * may not (a) modify, translate, adapt or otherwise create derivative works,
- * improvements of the Software or develop new applications using the Software
- * or (b) remove, delete, alter or obscure any trademarks or any copyright,
- * trademark, patent or other intellectual property or proprietary rights
- * notices on or in the Software, including any copy thereof. Redistributions
- * in binary or source form must include this license and terms.
+ * non-transferable license to use, install, execute and perform the Spine
+ * Runtimes Software (the "Software") and derivative works solely for personal
+ * or internal use. Without the written permission of Esoteric Software (see
+ * Section 2 of the Spine Software License Agreement), you may not (a) modify,
+ * translate, adapt or otherwise create derivative works, improvements of the
+ * Software or develop new applications using the Software or (b) remove,
+ * delete, alter or obscure any trademarks or any copyright, trademark, patent
+ * or other intellectual property or proprietary rights notices on or in the
+ * Software, including any copy thereof. Redistributions in binary or source
+ * form must include this license and terms.
  * 
  * THIS SOFTWARE IS PROVIDED BY ESOTERIC SOFTWARE "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 SOFTARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * EVENT SHALL ESOTERIC SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
@@ -35,8 +36,8 @@
 namespace Spine {
 	public class AnimationState {
 		private AnimationStateData data;
-		private List<TrackEntry> tracks = new List<TrackEntry>();
-		private List<Event> events = new List<Event>();
+		private ExposedList<TrackEntry> tracks = new ExposedList<TrackEntry>();
+		private ExposedList<Event> events = new ExposedList<Event>();
 		private float timeScale = 1;
 
 		public AnimationStateData Data { get { return data; } }
@@ -60,7 +61,7 @@ public AnimationState (AnimationStateData data) {
 		public void Update (float delta) {
 			delta *= timeScale;
 			for (int i = 0; i < tracks.Count; i++) {
-				TrackEntry current = tracks[i];
+				TrackEntry current = tracks.Items[i];
 				if (current == null) continue;
 
 				float trackDelta = delta * current.timeScale;
@@ -92,10 +93,10 @@ public void Update (float delta) {
 		}
 
 		public void Apply (Skeleton skeleton) {
-			List<Event> events = this.events;
+			ExposedList<Event> events = this.events;
 
 			for (int i = 0; i < tracks.Count; i++) {
-				TrackEntry current = tracks[i];
+				TrackEntry current = tracks.Items[i];
 				if (current == null) continue;
 
 				events.Clear();
@@ -124,7 +125,7 @@ public void Apply (Skeleton skeleton) {
 				}
 
 				for (int ii = 0, nn = events.Count; ii < nn; ii++) {
-					Event e = events[ii];
+					Event e = events.Items[ii];
 					current.OnEvent(this, i, e);
 					if (Event != null) Event(this, i, e);
 				}
@@ -141,17 +142,17 @@ public void ClearTracks () {
 
 		public void ClearTrack (int trackIndex) {
 			if (trackIndex >= tracks.Count) return;
-			TrackEntry current = tracks[trackIndex];
+			TrackEntry current = tracks.Items[trackIndex];
 			if (current == null) return;
 
 			current.OnEnd(this, trackIndex);
 			if (End != null) End(this, trackIndex);
 
-			tracks[trackIndex] = null;
+			tracks.Items[trackIndex] = null;
 		}
 
 		private TrackEntry ExpandToIndex (int index) {
-			if (index < tracks.Count) return tracks[index];
+			if (index < tracks.Count) return tracks.Items[index];
 			while (index >= tracks.Count)
 				tracks.Add(null);
 			return null;
@@ -177,7 +178,7 @@ private void SetCurrent (int index, TrackEntry entry) {
 				}
 			}
 
-			tracks[index] = entry;
+			tracks.Items[index] = entry;
 
 			entry.OnStart(this, index);
 			if (Start != null) Start(this, index);
@@ -191,6 +192,7 @@ public TrackEntry SetAnimation (int trackIndex, String animationName, bool loop)
 
 		/// <summary>Set the current animation. Any queued animations are cleared.</summary>
 		public TrackEntry SetAnimation (int trackIndex, Animation animation, bool loop) {
+			if (animation == null) throw new ArgumentException("animation cannot be null.");
 			TrackEntry entry = new TrackEntry();
 			entry.animation = animation;
 			entry.loop = loop;
@@ -209,6 +211,7 @@ public TrackEntry AddAnimation (int trackIndex, String animationName, bool loop,
 		/// <summary>Adds an animation to be played delay seconds after the current or last queued animation.</summary>
 		/// <param name="delay">May be <= 0 to use duration of previous animation minus any mix duration plus the negative delay.</param>
 		public TrackEntry AddAnimation (int trackIndex, Animation animation, bool loop, float delay) {
+			if (animation == null) throw new ArgumentException("animation cannot be null.");
 			TrackEntry entry = new TrackEntry();
 			entry.animation = animation;
 			entry.loop = loop;
@@ -221,7 +224,7 @@ public TrackEntry AddAnimation (int trackIndex, Animation animation, bool loop,
 					last = last.next;
 				last.next = entry;
 			} else
-				tracks[trackIndex] = entry;
+				tracks.Items[trackIndex] = entry;
 
 			if (delay <= 0) {
 				if (last != null)
@@ -237,13 +240,13 @@ public TrackEntry AddAnimation (int trackIndex, Animation animation, bool loop,
 		/// <returns>May be null.</returns>
 		public TrackEntry GetCurrent (int trackIndex) {
 			if (trackIndex >= tracks.Count) return null;
-			return tracks[trackIndex];
+			return tracks.Items[trackIndex];
 		}
 
 		override public String ToString () {
 			StringBuilder buffer = new StringBuilder();
 			for (int i = 0, n = tracks.Count; i < n; i++) {
-				TrackEntry entry = tracks[i];
+				TrackEntry entry = tracks.Items[i];
 				if (entry == null) continue;
 				if (buffer.Length > 0) buffer.Append(", ");
 				buffer.Append(entry.ToString());
diff --git a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/AnimationStateData.cs b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/AnimationStateData.cs
old mode 100644
new mode 100755
index f2fa866..eea8742
--- a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/AnimationStateData.cs
+++ b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/AnimationStateData.cs
@@ -1,25 +1,26 @@
 /******************************************************************************
  * Spine Runtimes Software License
- * Version 2.1
+ * Version 2.3
  * 
- * Copyright (c) 2013, Esoteric Software
+ * Copyright (c) 2013-2015, Esoteric Software
  * All rights reserved.
  * 
  * You are granted a perpetual, non-exclusive, non-sublicensable and
- * non-transferable license to install, execute and perform the Spine Runtimes
- * Software (the "Software") solely for internal use. Without the written
- * permission of Esoteric Software (typically granted by licensing Spine), you
- * may not (a) modify, translate, adapt or otherwise create derivative works,
- * improvements of the Software or develop new applications using the Software
- * or (b) remove, delete, alter or obscure any trademarks or any copyright,
- * trademark, patent or other intellectual property or proprietary rights
- * notices on or in the Software, including any copy thereof. Redistributions
- * in binary or source form must include this license and terms.
+ * non-transferable license to use, install, execute and perform the Spine
+ * Runtimes Software (the "Software") and derivative works solely for personal
+ * or internal use. Without the written permission of Esoteric Software (see
+ * Section 2 of the Spine Software License Agreement), you may not (a) modify,
+ * translate, adapt or otherwise create derivative works, improvements of the
+ * Software or develop new applications using the Software or (b) remove,
+ * delete, alter or obscure any trademarks or any copyright, trademark, patent
+ * or other intellectual property or proprietary rights notices on or in the
+ * Software, including any copy thereof. Redistributions in binary or source
+ * form must include this license and terms.
  * 
  * THIS SOFTWARE IS PROVIDED BY ESOTERIC SOFTWARE "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 SOFTARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * EVENT SHALL ESOTERIC SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
diff --git a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Atlas.cs b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Atlas.cs
old mode 100644
new mode 100755
index e9a504a..12b15f4
--- a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Atlas.cs
+++ b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Atlas.cs
@@ -1,25 +1,26 @@
 /******************************************************************************
  * Spine Runtimes Software License
- * Version 2.1
+ * Version 2.3
  * 
- * Copyright (c) 2013, Esoteric Software
+ * Copyright (c) 2013-2015, Esoteric Software
  * All rights reserved.
  * 
  * You are granted a perpetual, non-exclusive, non-sublicensable and
- * non-transferable license to install, execute and perform the Spine Runtimes
- * Software (the "Software") solely for internal use. Without the written
- * permission of Esoteric Software (typically granted by licensing Spine), you
- * may not (a) modify, translate, adapt or otherwise create derivative works,
- * improvements of the Software or develop new applications using the Software
- * or (b) remove, delete, alter or obscure any trademarks or any copyright,
- * trademark, patent or other intellectual property or proprietary rights
- * notices on or in the Software, including any copy thereof. Redistributions
- * in binary or source form must include this license and terms.
+ * non-transferable license to use, install, execute and perform the Spine
+ * Runtimes Software (the "Software") and derivative works solely for personal
+ * or internal use. Without the written permission of Esoteric Software (see
+ * Section 2 of the Spine Software License Agreement), you may not (a) modify,
+ * translate, adapt or otherwise create derivative works, improvements of the
+ * Software or develop new applications using the Software or (b) remove,
+ * delete, alter or obscure any trademarks or any copyright, trademark, patent
+ * or other intellectual property or proprietary rights notices on or in the
+ * Software, including any copy thereof. Redistributions in binary or source
+ * form must include this license and terms.
  * 
  * THIS SOFTWARE IS PROVIDED BY ESOTERIC SOFTWARE "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 SOFTARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * EVENT SHALL ESOTERIC SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
@@ -68,11 +69,10 @@ public Atlas (String path, TextureLoader textureLoader) {
             using (StreamReader reader = new StreamReader(stream))
             {
 #else
-            Stream stream = Microsoft.Xna.Framework.TitleContainer.OpenStream(path);
-            using (TextReader reader = new StreamReader(stream)) {
+            using (StreamReader reader = new StreamReader(path)) {
 #endif
 				try {
-					Load(reader, "asdf", textureLoader);
+					Load(reader, Path.GetDirectoryName(path), textureLoader);
 				} catch (Exception ex) {
 					throw new Exception("Error reading atlas file: " + path, ex);
 				}
@@ -91,7 +91,6 @@ public Atlas (List<AtlasPage> pages, List<AtlasRegion> regions) {
 		}
 
 		private void Load (TextReader reader, String imagesDir, TextureLoader textureLoader) {
-
 			if (textureLoader == null) throw new ArgumentNullException("textureLoader cannot be null.");
 			this.textureLoader = textureLoader;
 
@@ -127,10 +126,7 @@ private void Load (TextReader reader, String imagesDir, TextureLoader textureLoa
 					else if (direction == "xy")
 						page.uWrap = page.vWrap = TextureWrap.Repeat;
 
-                    //textureLoader.Load(page, Path.Combine(imagesDir, line));
-                    // PCL does not have access to Path now
-                    // TODO: create some platform specific routines if CCFileUtils
-                    textureLoader.Load(page, line);
+					textureLoader.Load(page, Path.Combine(imagesDir, line));
 
 					pages.Add(page);
 
diff --git a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Attachments/AtlasAttachmentLoader.cs b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Attachments/AtlasAttachmentLoader.cs
old mode 100644
new mode 100755
index 37fdbb9..0976e97
--- a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Attachments/AtlasAttachmentLoader.cs
+++ b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Attachments/AtlasAttachmentLoader.cs
@@ -1,25 +1,26 @@
 /******************************************************************************
  * Spine Runtimes Software License
- * Version 2.1
+ * Version 2.3
  * 
- * Copyright (c) 2013, Esoteric Software
+ * Copyright (c) 2013-2015, Esoteric Software
  * All rights reserved.
  * 
  * You are granted a perpetual, non-exclusive, non-sublicensable and
- * non-transferable license to install, execute and perform the Spine Runtimes
- * Software (the "Software") solely for internal use. Without the written
- * permission of Esoteric Software (typically granted by licensing Spine), you
- * may not (a) modify, translate, adapt or otherwise create derivative works,
- * improvements of the Software or develop new applications using the Software
- * or (b) remove, delete, alter or obscure any trademarks or any copyright,
- * trademark, patent or other intellectual property or proprietary rights
- * notices on or in the Software, including any copy thereof. Redistributions
- * in binary or source form must include this license and terms.
+ * non-transferable license to use, install, execute and perform the Spine
+ * Runtimes Software (the "Software") and derivative works solely for personal
+ * or internal use. Without the written permission of Esoteric Software (see
+ * Section 2 of the Spine Software License Agreement), you may not (a) modify,
+ * translate, adapt or otherwise create derivative works, improvements of the
+ * Software or develop new applications using the Software or (b) remove,
+ * delete, alter or obscure any trademarks or any copyright, trademark, patent
+ * or other intellectual property or proprietary rights notices on or in the
+ * Software, including any copy thereof. Redistributions in binary or source
+ * form must include this license and terms.
  * 
  * THIS SOFTWARE IS PROVIDED BY ESOTERIC SOFTWARE "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 SOFTARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * EVENT SHALL ESOTERIC SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
@@ -32,15 +33,15 @@
 
 namespace Spine {
 	public class AtlasAttachmentLoader : AttachmentLoader {
-		private Atlas atlas;
+		private Atlas[] atlasArray;
 
-		public AtlasAttachmentLoader (Atlas atlas) {
-			if (atlas == null) throw new ArgumentNullException("atlas cannot be null.");
-			this.atlas = atlas;
+		public AtlasAttachmentLoader (params Atlas[] atlasArray) {
+			if (atlasArray == null) throw new ArgumentNullException("atlas array cannot be null.");
+			this.atlasArray = atlasArray;
 		}
 
 		public RegionAttachment NewRegionAttachment (Skin skin, String name, String path) {
-			AtlasRegion region = atlas.FindRegion(path);
+			AtlasRegion region = FindRegion(path);
 			if (region == null) throw new Exception("Region not found in atlas: " + path + " (region attachment: " + name + ")");
 			RegionAttachment attachment = new RegionAttachment(name);
 			attachment.RendererObject = region;
@@ -55,7 +56,7 @@ public RegionAttachment NewRegionAttachment (Skin skin, String name, String path
 		}
 
 		public MeshAttachment NewMeshAttachment (Skin skin, String name, String path) {
-			AtlasRegion region = atlas.FindRegion(path);
+			AtlasRegion region = FindRegion(path);
 			if (region == null) throw new Exception("Region not found in atlas: " + path + " (mesh attachment: " + name + ")");
 			MeshAttachment attachment = new MeshAttachment(name);
 			attachment.RendererObject = region;
@@ -74,7 +75,7 @@ public MeshAttachment NewMeshAttachment (Skin skin, String name, String path) {
 		}
 
 		public SkinnedMeshAttachment NewSkinnedMeshAttachment (Skin skin, String name, String path) {
-			AtlasRegion region = atlas.FindRegion(path);
+			AtlasRegion region = FindRegion(path);
 			if (region == null) throw new Exception("Region not found in atlas: " + path + " (skinned mesh attachment: " + name + ")");
 			SkinnedMeshAttachment attachment = new SkinnedMeshAttachment(name);
 			attachment.RendererObject = region;
@@ -95,5 +96,17 @@ public SkinnedMeshAttachment NewSkinnedMeshAttachment (Skin skin, String name, S
 		public BoundingBoxAttachment NewBoundingBoxAttachment (Skin skin, String name) {
 			return new BoundingBoxAttachment(name);
 		}
+
+		public AtlasRegion FindRegion(string name) {
+			AtlasRegion region;
+
+			for (int i = 0; i < atlasArray.Length; i++) {
+				region = atlasArray[i].FindRegion(name);
+				if (region != null)
+					return region;
+			}
+
+			return null;
+		}
 	}
 }
diff --git a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Attachments/Attachment.cs b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Attachments/Attachment.cs
old mode 100644
new mode 100755
index f54bf49..551785b
--- a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Attachments/Attachment.cs
+++ b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Attachments/Attachment.cs
@@ -1,25 +1,26 @@
 /******************************************************************************
  * Spine Runtimes Software License
- * Version 2.1
+ * Version 2.3
  * 
- * Copyright (c) 2013, Esoteric Software
+ * Copyright (c) 2013-2015, Esoteric Software
  * All rights reserved.
  * 
  * You are granted a perpetual, non-exclusive, non-sublicensable and
- * non-transferable license to install, execute and perform the Spine Runtimes
- * Software (the "Software") solely for internal use. Without the written
- * permission of Esoteric Software (typically granted by licensing Spine), you
- * may not (a) modify, translate, adapt or otherwise create derivative works,
- * improvements of the Software or develop new applications using the Software
- * or (b) remove, delete, alter or obscure any trademarks or any copyright,
- * trademark, patent or other intellectual property or proprietary rights
- * notices on or in the Software, including any copy thereof. Redistributions
- * in binary or source form must include this license and terms.
+ * non-transferable license to use, install, execute and perform the Spine
+ * Runtimes Software (the "Software") and derivative works solely for personal
+ * or internal use. Without the written permission of Esoteric Software (see
+ * Section 2 of the Spine Software License Agreement), you may not (a) modify,
+ * translate, adapt or otherwise create derivative works, improvements of the
+ * Software or develop new applications using the Software or (b) remove,
+ * delete, alter or obscure any trademarks or any copyright, trademark, patent
+ * or other intellectual property or proprietary rights notices on or in the
+ * Software, including any copy thereof. Redistributions in binary or source
+ * form must include this license and terms.
  * 
  * THIS SOFTWARE IS PROVIDED BY ESOTERIC SOFTWARE "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 SOFTARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * EVENT SHALL ESOTERIC SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
diff --git a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Attachments/AttachmentLoader.cs b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Attachments/AttachmentLoader.cs
old mode 100644
new mode 100755
index 8630f4b..69f4627
--- a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Attachments/AttachmentLoader.cs
+++ b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Attachments/AttachmentLoader.cs
@@ -1,25 +1,26 @@
 /******************************************************************************
  * Spine Runtimes Software License
- * Version 2.1
+ * Version 2.3
  * 
- * Copyright (c) 2013, Esoteric Software
+ * Copyright (c) 2013-2015, Esoteric Software
  * All rights reserved.
  * 
  * You are granted a perpetual, non-exclusive, non-sublicensable and
- * non-transferable license to install, execute and perform the Spine Runtimes
- * Software (the "Software") solely for internal use. Without the written
- * permission of Esoteric Software (typically granted by licensing Spine), you
- * may not (a) modify, translate, adapt or otherwise create derivative works,
- * improvements of the Software or develop new applications using the Software
- * or (b) remove, delete, alter or obscure any trademarks or any copyright,
- * trademark, patent or other intellectual property or proprietary rights
- * notices on or in the Software, including any copy thereof. Redistributions
- * in binary or source form must include this license and terms.
+ * non-transferable license to use, install, execute and perform the Spine
+ * Runtimes Software (the "Software") and derivative works solely for personal
+ * or internal use. Without the written permission of Esoteric Software (see
+ * Section 2 of the Spine Software License Agreement), you may not (a) modify,
+ * translate, adapt or otherwise create derivative works, improvements of the
+ * Software or develop new applications using the Software or (b) remove,
+ * delete, alter or obscure any trademarks or any copyright, trademark, patent
+ * or other intellectual property or proprietary rights notices on or in the
+ * Software, including any copy thereof. Redistributions in binary or source
+ * form must include this license and terms.
  * 
  * THIS SOFTWARE IS PROVIDED BY ESOTERIC SOFTWARE "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 SOFTARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * EVENT SHALL ESOTERIC SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
diff --git a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Attachments/AttachmentType.cs b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Attachments/AttachmentType.cs
old mode 100644
new mode 100755
index 3ae01ae..2f5d1c8
--- a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Attachments/AttachmentType.cs
+++ b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Attachments/AttachmentType.cs
@@ -1,25 +1,26 @@
 /******************************************************************************
  * Spine Runtimes Software License
- * Version 2.1
+ * Version 2.3
  * 
- * Copyright (c) 2013, Esoteric Software
+ * Copyright (c) 2013-2015, Esoteric Software
  * All rights reserved.
  * 
  * You are granted a perpetual, non-exclusive, non-sublicensable and
- * non-transferable license to install, execute and perform the Spine Runtimes
- * Software (the "Software") solely for internal use. Without the written
- * permission of Esoteric Software (typically granted by licensing Spine), you
- * may not (a) modify, translate, adapt or otherwise create derivative works,
- * improvements of the Software or develop new applications using the Software
- * or (b) remove, delete, alter or obscure any trademarks or any copyright,
- * trademark, patent or other intellectual property or proprietary rights
- * notices on or in the Software, including any copy thereof. Redistributions
- * in binary or source form must include this license and terms.
+ * non-transferable license to use, install, execute and perform the Spine
+ * Runtimes Software (the "Software") and derivative works solely for personal
+ * or internal use. Without the written permission of Esoteric Software (see
+ * Section 2 of the Spine Software License Agreement), you may not (a) modify,
+ * translate, adapt or otherwise create derivative works, improvements of the
+ * Software or develop new applications using the Software or (b) remove,
+ * delete, alter or obscure any trademarks or any copyright, trademark, patent
+ * or other intellectual property or proprietary rights notices on or in the
+ * Software, including any copy thereof. Redistributions in binary or source
+ * form must include this license and terms.
  * 
  * THIS SOFTWARE IS PROVIDED BY ESOTERIC SOFTWARE "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 SOFTARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * EVENT SHALL ESOTERIC SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
diff --git a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Attachments/BoundingBoxAttachment.cs b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Attachments/BoundingBoxAttachment.cs
old mode 100644
new mode 100755
index 838dbeb..3a8be79
--- a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Attachments/BoundingBoxAttachment.cs
+++ b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Attachments/BoundingBoxAttachment.cs
@@ -1,25 +1,26 @@
 /******************************************************************************
  * Spine Runtimes Software License
- * Version 2.1
+ * Version 2.3
  * 
- * Copyright (c) 2013, Esoteric Software
+ * Copyright (c) 2013-2015, Esoteric Software
  * All rights reserved.
  * 
  * You are granted a perpetual, non-exclusive, non-sublicensable and
- * non-transferable license to install, execute and perform the Spine Runtimes
- * Software (the "Software") solely for internal use. Without the written
- * permission of Esoteric Software (typically granted by licensing Spine), you
- * may not (a) modify, translate, adapt or otherwise create derivative works,
- * improvements of the Software or develop new applications using the Software
- * or (b) remove, delete, alter or obscure any trademarks or any copyright,
- * trademark, patent or other intellectual property or proprietary rights
- * notices on or in the Software, including any copy thereof. Redistributions
- * in binary or source form must include this license and terms.
+ * non-transferable license to use, install, execute and perform the Spine
+ * Runtimes Software (the "Software") and derivative works solely for personal
+ * or internal use. Without the written permission of Esoteric Software (see
+ * Section 2 of the Spine Software License Agreement), you may not (a) modify,
+ * translate, adapt or otherwise create derivative works, improvements of the
+ * Software or develop new applications using the Software or (b) remove,
+ * delete, alter or obscure any trademarks or any copyright, trademark, patent
+ * or other intellectual property or proprietary rights notices on or in the
+ * Software, including any copy thereof. Redistributions in binary or source
+ * form must include this license and terms.
  * 
  * THIS SOFTWARE IS PROVIDED BY ESOTERIC SOFTWARE "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 SOFTARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * EVENT SHALL ESOTERIC SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
@@ -42,9 +43,8 @@ public BoundingBoxAttachment (string name)
 		}
 
 		/// <param name="worldVertices">Must have at least the same length as this attachment's vertices.</param>
-		public void ComputeWorldVertices (float x, float y, Bone bone, float[] worldVertices) {
-			x += bone.worldX;
-			y += bone.worldY;
+		public void ComputeWorldVertices (Bone bone, float[] worldVertices) {
+			float x = bone.skeleton.x + bone.worldX, y = bone.skeleton.y + bone.worldY;
 			float m00 = bone.m00;
 			float m01 = bone.m01;
 			float m10 = bone.m10;
diff --git a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Attachments/MeshAttachment.cs b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Attachments/MeshAttachment.cs
old mode 100644
new mode 100755
index ff4081c..488b76b
--- a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Attachments/MeshAttachment.cs
+++ b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Attachments/MeshAttachment.cs
@@ -1,25 +1,26 @@
-/******************************************************************************
+/******************************************************************************
  * Spine Runtimes Software License
- * Version 2.1
+ * Version 2.3
  * 
- * Copyright (c) 2013, Esoteric Software
+ * Copyright (c) 2013-2015, Esoteric Software
  * All rights reserved.
  * 
  * You are granted a perpetual, non-exclusive, non-sublicensable and
- * non-transferable license to install, execute and perform the Spine Runtimes
- * Software (the "Software") solely for internal use. Without the written
- * permission of Esoteric Software (typically granted by licensing Spine), you
- * may not (a) modify, translate, adapt or otherwise create derivative works,
- * improvements of the Software or develop new applications using the Software
- * or (b) remove, delete, alter or obscure any trademarks or any copyright,
- * trademark, patent or other intellectual property or proprietary rights
- * notices on or in the Software, including any copy thereof. Redistributions
- * in binary or source form must include this license and terms.
+ * non-transferable license to use, install, execute and perform the Spine
+ * Runtimes Software (the "Software") and derivative works solely for personal
+ * or internal use. Without the written permission of Esoteric Software (see
+ * Section 2 of the Spine Software License Agreement), you may not (a) modify,
+ * translate, adapt or otherwise create derivative works, improvements of the
+ * Software or develop new applications using the Software or (b) remove,
+ * delete, alter or obscure any trademarks or any copyright, trademark, patent
+ * or other intellectual property or proprietary rights notices on or in the
+ * Software, including any copy thereof. Redistributions in binary or source
+ * form must include this license and terms.
  * 
  * THIS SOFTWARE IS PROVIDED BY ESOTERIC SOFTWARE "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 SOFTARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * EVENT SHALL ESOTERIC SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
@@ -90,10 +91,9 @@ public void UpdateUVs () {
 			}
 		}
 
-		public void ComputeWorldVertices (float x, float y, Slot slot, float[] worldVertices) {
+		public void ComputeWorldVertices (Slot slot, float[] worldVertices) {
 			Bone bone = slot.bone;
-			x += bone.worldX;
-			y += bone.worldY;
+			float x = bone.skeleton.x + bone.worldX, y = bone.skeleton.y + bone.worldY;
 			float m00 = bone.m00, m01 = bone.m01, m10 = bone.m10, m11 = bone.m11;
 			float[] vertices = this.vertices;
 			int verticesCount = vertices.Length;
@@ -105,26 +105,5 @@ public void ComputeWorldVertices (float x, float y, Slot slot, float[] worldVert
 				worldVertices[i + 1] = vx * m10 + vy * m11 + y;
 			}
 		}
-
-        public Microsoft.Xna.Framework.Matrix GetWorldTransform(float x, float y, Slot slot, float[] worldVertices)
-        {
-            Microsoft.Xna.Framework.Matrix mat = Microsoft.Xna.Framework.Matrix.Identity;
-
-            Bone bone = slot.bone;
-            x += bone.worldX;
-            y += bone.worldY;
-            float m00 = bone.m00, m01 = bone.m01, m10 = bone.m10, m11 = bone.m11;
-            return mat;
-//            float[] vertices = this.vertices;
-//            int verticesCount = vertices.Length;
-//            if (slot.attachmentVerticesCount == verticesCount) vertices = slot.AttachmentVertices;
-//            for (int i = 0; i < verticesCount; i += 2) {
-//                float vx = vertices[i];
-//                float vy = vertices[i + 1];
-//                worldVertices[i] = vx * m00 + vy * m01 + x;
-//                worldVertices[i + 1] = vx * m10 + vy * m11 + y;
-//            }
-
-        }
 	}
 }
diff --git a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Attachments/RegionAttachment.cs b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Attachments/RegionAttachment.cs
old mode 100644
new mode 100755
index 511cb41..72bdb05
--- a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Attachments/RegionAttachment.cs
+++ b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Attachments/RegionAttachment.cs
@@ -1,25 +1,26 @@
 /******************************************************************************
  * Spine Runtimes Software License
- * Version 2.1
+ * Version 2.3
  * 
- * Copyright (c) 2013, Esoteric Software
+ * Copyright (c) 2013-2015, Esoteric Software
  * All rights reserved.
  * 
  * You are granted a perpetual, non-exclusive, non-sublicensable and
- * non-transferable license to install, execute and perform the Spine Runtimes
- * Software (the "Software") solely for internal use. Without the written
- * permission of Esoteric Software (typically granted by licensing Spine), you
- * may not (a) modify, translate, adapt or otherwise create derivative works,
- * improvements of the Software or develop new applications using the Software
- * or (b) remove, delete, alter or obscure any trademarks or any copyright,
- * trademark, patent or other intellectual property or proprietary rights
- * notices on or in the Software, including any copy thereof. Redistributions
- * in binary or source form must include this license and terms.
+ * non-transferable license to use, install, execute and perform the Spine
+ * Runtimes Software (the "Software") and derivative works solely for personal
+ * or internal use. Without the written permission of Esoteric Software (see
+ * Section 2 of the Spine Software License Agreement), you may not (a) modify,
+ * translate, adapt or otherwise create derivative works, improvements of the
+ * Software or develop new applications using the Software or (b) remove,
+ * delete, alter or obscure any trademarks or any copyright, trademark, patent
+ * or other intellectual property or proprietary rights notices on or in the
+ * Software, including any copy thereof. Redistributions in binary or source
+ * form must include this license and terms.
  * 
  * THIS SOFTWARE IS PROVIDED BY ESOTERIC SOFTWARE "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 SOFTARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * EVENT SHALL ESOTERIC SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
@@ -134,9 +135,8 @@ public void UpdateOffset () {
 			offset[Y4] = localYCos + localX2Sin;
 		}
 
-		public void ComputeWorldVertices (float x, float y, Bone bone, float[] worldVertices) {
-			x += bone.worldX;
-			y += bone.worldY;
+		public void ComputeWorldVertices (Bone bone, float[] worldVertices) {
+			float x = bone.skeleton.x + bone.worldX, y = bone.skeleton.y + bone.worldY;
 			float m00 = bone.m00, m01 = bone.m01, m10 = bone.m10, m11 = bone.m11;
 			float[] offset = this.offset;
 			worldVertices[X1] = offset[X1] * m00 + offset[Y1] * m01 + x;
diff --git a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Attachments/SkinnedMeshAttachment.cs b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Attachments/SkinnedMeshAttachment.cs
old mode 100644
new mode 100755
index ebd6628..1e99fab
--- a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Attachments/SkinnedMeshAttachment.cs
+++ b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Attachments/SkinnedMeshAttachment.cs
@@ -1,25 +1,26 @@
-/******************************************************************************
+/******************************************************************************
  * Spine Runtimes Software License
- * Version 2.1
+ * Version 2.3
  * 
- * Copyright (c) 2013, Esoteric Software
+ * Copyright (c) 2013-2015, Esoteric Software
  * All rights reserved.
  * 
  * You are granted a perpetual, non-exclusive, non-sublicensable and
- * non-transferable license to install, execute and perform the Spine Runtimes
- * Software (the "Software") solely for internal use. Without the written
- * permission of Esoteric Software (typically granted by licensing Spine), you
- * may not (a) modify, translate, adapt or otherwise create derivative works,
- * improvements of the Software or develop new applications using the Software
- * or (b) remove, delete, alter or obscure any trademarks or any copyright,
- * trademark, patent or other intellectual property or proprietary rights
- * notices on or in the Software, including any copy thereof. Redistributions
- * in binary or source form must include this license and terms.
+ * non-transferable license to use, install, execute and perform the Spine
+ * Runtimes Software (the "Software") and derivative works solely for personal
+ * or internal use. Without the written permission of Esoteric Software (see
+ * Section 2 of the Spine Software License Agreement), you may not (a) modify,
+ * translate, adapt or otherwise create derivative works, improvements of the
+ * Software or develop new applications using the Software or (b) remove,
+ * delete, alter or obscure any trademarks or any copyright, trademark, patent
+ * or other intellectual property or proprietary rights notices on or in the
+ * Software, including any copy thereof. Redistributions in binary or source
+ * form must include this license and terms.
  * 
  * THIS SOFTWARE IS PROVIDED BY ESOTERIC SOFTWARE "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 SOFTARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * EVENT SHALL ESOTERIC SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
@@ -93,8 +94,10 @@ public void UpdateUVs () {
 			}
 		}
 
-		public void ComputeWorldVertices (float x, float y, Slot slot, float[] worldVertices) {
-			List<Bone> skeletonBones = slot.skeleton.bones;
+		public void ComputeWorldVertices (Slot slot, float[] worldVertices) {
+			Skeleton skeleton = slot.bone.skeleton;
+			ExposedList<Bone> skeletonBones = skeleton.bones;
+			float x = skeleton.x, y = skeleton.y;
 			float[] weights = this.weights;
 			int[] bones = this.bones;
 			if (slot.attachmentVerticesCount == 0) {
@@ -102,10 +105,10 @@ public void ComputeWorldVertices (float x, float y, Slot slot, float[] worldVert
 					float wx = 0, wy = 0;
 					int nn = bones[v++] + v;
 					for (; v < nn; v++, b += 3) {
-						Bone bone = (Bone)skeletonBones[bones[v]];
+						Bone bone = skeletonBones.Items[bones[v]];
 						float vx = weights[b], vy = weights[b + 1], weight = weights[b + 2];
-						wx += (vx * bone.M00 + vy * bone.M01 + bone.worldX) * weight;
-						wy += (vx * bone.M10 + vy * bone.M11 + bone.worldY) * weight;
+						wx += (vx * bone.m00 + vy * bone.m01 + bone.worldX) * weight;
+						wy += (vx * bone.m10 + vy * bone.m11 + bone.worldY) * weight;
 					}
 					worldVertices[w] = wx + x;
 					worldVertices[w + 1] = wy + y;
@@ -116,10 +119,10 @@ public void ComputeWorldVertices (float x, float y, Slot slot, float[] worldVert
 					float wx = 0, wy = 0;
 					int nn = bones[v++] + v;
 					for (; v < nn; v++, b += 3, f += 2) {
-						Bone bone = (Bone)skeletonBones[bones[v]];
+						Bone bone = skeletonBones.Items[bones[v]];
 						float vx = weights[b] + ffd[f], vy = weights[b + 1] + ffd[f + 1], weight = weights[b + 2];
-						wx += (vx * bone.M00 + vy * bone.M01 + bone.worldX) * weight;
-						wy += (vx * bone.M10 + vy * bone.M11 + bone.worldY) * weight;
+						wx += (vx * bone.m00 + vy * bone.m01 + bone.worldX) * weight;
+						wy += (vx * bone.m10 + vy * bone.m11 + bone.worldY) * weight;
 					}
 					worldVertices[w] = wx + x;
 					worldVertices[w + 1] = wy + y;
diff --git a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/BlendMode.cs b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/BlendMode.cs
new file mode 100755
index 0000000..6c53e00
--- /dev/null
+++ b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/BlendMode.cs
@@ -0,0 +1,36 @@
+/******************************************************************************
+ * Spine Runtimes Software License
+ * Version 2.3
+ * 
+ * Copyright (c) 2013-2015, Esoteric Software
+ * All rights reserved.
+ * 
+ * You are granted a perpetual, non-exclusive, non-sublicensable and
+ * non-transferable license to use, install, execute and perform the Spine
+ * Runtimes Software (the "Software") and derivative works solely for personal
+ * or internal use. Without the written permission of Esoteric Software (see
+ * Section 2 of the Spine Software License Agreement), you may not (a) modify,
+ * translate, adapt or otherwise create derivative works, improvements of the
+ * Software or develop new applications using the Software or (b) remove,
+ * delete, alter or obscure any trademarks or any copyright, trademark, patent
+ * or other intellectual property or proprietary rights notices on or in the
+ * Software, including any copy thereof. Redistributions in binary or source
+ * form must include this license and terms.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY ESOTERIC SOFTWARE "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 BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) 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.
+ *****************************************************************************/
+
+namespace Spine {
+	public enum BlendMode {
+		normal, additive, multiply, screen
+	}
+}
diff --git a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Bone.cs b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Bone.cs
old mode 100644
new mode 100755
index 7a9fb55..748e35d
--- a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Bone.cs
+++ b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Bone.cs
@@ -1,25 +1,26 @@
 /******************************************************************************
  * Spine Runtimes Software License
- * Version 2.1
+ * Version 2.3
  * 
- * Copyright (c) 2013, Esoteric Software
+ * Copyright (c) 2013-2015, Esoteric Software
  * All rights reserved.
  * 
  * You are granted a perpetual, non-exclusive, non-sublicensable and
- * non-transferable license to install, execute and perform the Spine Runtimes
- * Software (the "Software") solely for internal use. Without the written
- * permission of Esoteric Software (typically granted by licensing Spine), you
- * may not (a) modify, translate, adapt or otherwise create derivative works,
- * improvements of the Software or develop new applications using the Software
- * or (b) remove, delete, alter or obscure any trademarks or any copyright,
- * trademark, patent or other intellectual property or proprietary rights
- * notices on or in the Software, including any copy thereof. Redistributions
- * in binary or source form must include this license and terms.
+ * non-transferable license to use, install, execute and perform the Spine
+ * Runtimes Software (the "Software") and derivative works solely for personal
+ * or internal use. Without the written permission of Esoteric Software (see
+ * Section 2 of the Spine Software License Agreement), you may not (a) modify,
+ * translate, adapt or otherwise create derivative works, improvements of the
+ * Software or develop new applications using the Software or (b) remove,
+ * delete, alter or obscure any trademarks or any copyright, trademark, patent
+ * or other intellectual property or proprietary rights notices on or in the
+ * Software, including any copy thereof. Redistributions in binary or source
+ * form must include this license and terms.
  * 
  * THIS SOFTWARE IS PROVIDED BY ESOTERIC SOFTWARE "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 SOFTARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * EVENT SHALL ESOTERIC SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
@@ -29,24 +30,36 @@
  *****************************************************************************/
 
 using System;
+using System.Collections.Generic;
 
 namespace Spine {
-	public class Bone {
+	public class Bone{
 		static public bool yDown;
 
 		internal BoneData data;
+		internal Skeleton skeleton;
 		internal Bone parent;
-		internal float x, y, rotation, scaleX, scaleY;
+		internal ExposedList<Bone> children = new ExposedList<Bone>();
+		internal float x, y, rotation, rotationIK, scaleX, scaleY;
+		internal bool flipX, flipY;
 		internal float m00, m01, m10, m11;
 		internal float worldX, worldY, worldRotation, worldScaleX, worldScaleY;
+		internal bool worldFlipX, worldFlipY;
 
 		public BoneData Data { get { return data; } }
+		public Skeleton Skeleton { get { return skeleton; } }
 		public Bone Parent { get { return parent; } }
+		public ExposedList<Bone> Children { get { return children; } }
 		public float X { get { return x; } set { x = value; } }
 		public float Y { get { return y; } set { y = value; } }
+		/// <summary>The forward kinetics rotation.</summary>
 		public float Rotation { get { return rotation; } set { rotation = value; } }
+		/// <summary>The inverse kinetics rotation, as calculated by any IK constraints.</summary>
+		public float RotationIK { get { return rotationIK; } set { rotationIK = value; } }
 		public float ScaleX { get { return scaleX; } set { scaleX = value; } }
 		public float ScaleY { get { return scaleY; } set { scaleY = value; } }
+		public bool FlipX { get { return flipX; } set { flipX = value; } }
+		public bool FlipY { get { return flipY; } set { flipY = value; } }
 
 		public float M00 { get { return m00; } }
 		public float M01 { get { return m01; } }
@@ -57,18 +70,23 @@ public class Bone {
 		public float WorldRotation { get { return worldRotation; } }
 		public float WorldScaleX { get { return worldScaleX; } }
 		public float WorldScaleY { get { return worldScaleY; } }
+		public bool WorldFlipX { get { return worldFlipX; } set { worldFlipX = value; } }
+		public bool WorldFlipY { get { return worldFlipY; } set { worldFlipY = value; } }
 
 		/// <param name="parent">May be null.</param>
-		public Bone (BoneData data, Bone parent) {
+		public Bone (BoneData data, Skeleton skeleton, Bone parent) {
 			if (data == null) throw new ArgumentNullException("data cannot be null.");
+			if (skeleton == null) throw new ArgumentNullException("skeleton cannot be null.");
 			this.data = data;
+			this.skeleton = skeleton;
 			this.parent = parent;
 			SetToSetupPose();
 		}
 
 		/// <summary>Computes the world SRT using the parent bone and the local SRT.</summary>
-		public void UpdateWorldTransform (bool flipX, bool flipY) {
+		public void UpdateWorldTransform () {
 			Bone parent = this.parent;
+			float x = this.x, y = this.y;
 			if (parent != null) {
 				worldX = x * parent.m00 + y * parent.m01 + parent.worldX;
 				worldY = x * parent.m10 + y * parent.m11 + parent.worldY;
@@ -79,28 +97,36 @@ public void UpdateWorldTransform (bool flipX, bool flipY) {
 					worldScaleX = scaleX;
 					worldScaleY = scaleY;
 				}
-				worldRotation = data.inheritRotation ? parent.worldRotation + rotation : rotation;
+				worldRotation = data.inheritRotation ? parent.worldRotation + rotationIK : rotationIK;
+				worldFlipX = parent.worldFlipX != flipX;
+				worldFlipY = parent.worldFlipY != flipY;
 			} else {
-				worldX = flipX ? -x : x;
-				worldY = flipY != yDown ? -y : y;
+				Skeleton skeleton = this.skeleton;
+				bool skeletonFlipX = skeleton.flipX, skeletonFlipY = skeleton.flipY;
+				worldX = skeletonFlipX ? -x : x;
+				worldY = skeletonFlipY != yDown ? -y : y;
 				worldScaleX = scaleX;
 				worldScaleY = scaleY;
-				worldRotation = rotation;
+				worldRotation = rotationIK;
+				worldFlipX = skeletonFlipX != flipX;
+				worldFlipY = skeletonFlipY != flipY;
 			}
 			float radians = worldRotation * (float)Math.PI / 180;
 			float cos = (float)Math.Cos(radians);
 			float sin = (float)Math.Sin(radians);
-			m00 = cos * worldScaleX;
-			m10 = sin * worldScaleX;
-			m01 = -sin * worldScaleY;
-			m11 = cos * worldScaleY;
-			if (flipX) {
-				m00 = -m00;
-				m01 = -m01;
+			if (worldFlipX) {
+				m00 = -cos * worldScaleX;
+				m01 = sin * worldScaleY;
+			} else {
+				m00 = cos * worldScaleX;
+				m01 = -sin * worldScaleY;
 			}
-			if (flipY != yDown) {
-				m10 = -m10;
-				m11 = -m11;
+			if (worldFlipY != yDown) {
+				m10 = -sin * worldScaleX;
+				m11 = -cos * worldScaleY;
+			} else {
+				m10 = sin * worldScaleX;
+				m11 = cos * worldScaleY;
 			}
 		}
 
@@ -109,8 +135,28 @@ public void SetToSetupPose () {
 			x = data.x;
 			y = data.y;
 			rotation = data.rotation;
+			rotationIK = rotation;
 			scaleX = data.scaleX;
 			scaleY = data.scaleY;
+			flipX = data.flipX;
+			flipY = data.flipY;
+		}
+
+		public void worldToLocal (float worldX, float worldY, out float localX, out float localY) {
+			float dx = worldX - this.worldX, dy = worldY - this.worldY;
+			float m00 = this.m00, m10 = this.m10, m01 = this.m01, m11 = this.m11;
+			if (worldFlipX != (worldFlipY != yDown)) {
+				m00 = -m00;
+				m11 = -m11;
+			}
+			float invDet = 1 / (m00 * m11 - m01 * m10);
+			localX = (dx * m00 * invDet - dy * m01 * invDet);
+			localY = (dy * m11 * invDet - dx * m10 * invDet);
+		}
+
+		public void localToWorld (float localX, float localY, out float worldX, out float worldY) {
+			worldX = localX * m00 + localY * m01 + this.worldX;
+			worldY = localX * m10 + localY * m11 + this.worldY;
 		}
 
 		override public String ToString () {
diff --git a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/BoneData.cs b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/BoneData.cs
old mode 100644
new mode 100755
index 5d19b26..cc1ebac
--- a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/BoneData.cs
+++ b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/BoneData.cs
@@ -1,25 +1,26 @@
 /******************************************************************************
  * Spine Runtimes Software License
- * Version 2.1
+ * Version 2.3
  * 
- * Copyright (c) 2013, Esoteric Software
+ * Copyright (c) 2013-2015, Esoteric Software
  * All rights reserved.
  * 
  * You are granted a perpetual, non-exclusive, non-sublicensable and
- * non-transferable license to install, execute and perform the Spine Runtimes
- * Software (the "Software") solely for internal use. Without the written
- * permission of Esoteric Software (typically granted by licensing Spine), you
- * may not (a) modify, translate, adapt or otherwise create derivative works,
- * improvements of the Software or develop new applications using the Software
- * or (b) remove, delete, alter or obscure any trademarks or any copyright,
- * trademark, patent or other intellectual property or proprietary rights
- * notices on or in the Software, including any copy thereof. Redistributions
- * in binary or source form must include this license and terms.
+ * non-transferable license to use, install, execute and perform the Spine
+ * Runtimes Software (the "Software") and derivative works solely for personal
+ * or internal use. Without the written permission of Esoteric Software (see
+ * Section 2 of the Spine Software License Agreement), you may not (a) modify,
+ * translate, adapt or otherwise create derivative works, improvements of the
+ * Software or develop new applications using the Software or (b) remove,
+ * delete, alter or obscure any trademarks or any copyright, trademark, patent
+ * or other intellectual property or proprietary rights notices on or in the
+ * Software, including any copy thereof. Redistributions in binary or source
+ * form must include this license and terms.
  * 
  * THIS SOFTWARE IS PROVIDED BY ESOTERIC SOFTWARE "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 SOFTARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * EVENT SHALL ESOTERIC SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
@@ -35,6 +36,7 @@ public class BoneData {
 		internal BoneData parent;
 		internal String name;
 		internal float length, x, y, rotation, scaleX = 1, scaleY = 1;
+		internal bool flipX, flipY;
 		internal bool inheritScale = true, inheritRotation = true;
 
 		/// <summary>May be null.</summary>
@@ -46,6 +48,8 @@ public class BoneData {
 		public float Rotation { get { return rotation; } set { rotation = value; } }
 		public float ScaleX { get { return scaleX; } set { scaleX = value; } }
 		public float ScaleY { get { return scaleY; } set { scaleY = value; } }
+		public bool FlipX { get { return flipX; } set { flipX = value; } }
+		public bool FlipY { get { return flipY; } set { flipY = value; } }
 		public bool InheritScale { get { return inheritScale; } set { inheritScale = value; } }
 		public bool InheritRotation { get { return inheritRotation; } set { inheritRotation = value; } }
 
diff --git a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Event.cs b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Event.cs
old mode 100644
new mode 100755
index 36514e7..f607104
--- a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Event.cs
+++ b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Event.cs
@@ -1,25 +1,26 @@
 /******************************************************************************
  * Spine Runtimes Software License
- * Version 2.1
+ * Version 2.3
  * 
- * Copyright (c) 2013, Esoteric Software
+ * Copyright (c) 2013-2015, Esoteric Software
  * All rights reserved.
  * 
  * You are granted a perpetual, non-exclusive, non-sublicensable and
- * non-transferable license to install, execute and perform the Spine Runtimes
- * Software (the "Software") solely for internal use. Without the written
- * permission of Esoteric Software (typically granted by licensing Spine), you
- * may not (a) modify, translate, adapt or otherwise create derivative works,
- * improvements of the Software or develop new applications using the Software
- * or (b) remove, delete, alter or obscure any trademarks or any copyright,
- * trademark, patent or other intellectual property or proprietary rights
- * notices on or in the Software, including any copy thereof. Redistributions
- * in binary or source form must include this license and terms.
+ * non-transferable license to use, install, execute and perform the Spine
+ * Runtimes Software (the "Software") and derivative works solely for personal
+ * or internal use. Without the written permission of Esoteric Software (see
+ * Section 2 of the Spine Software License Agreement), you may not (a) modify,
+ * translate, adapt or otherwise create derivative works, improvements of the
+ * Software or develop new applications using the Software or (b) remove,
+ * delete, alter or obscure any trademarks or any copyright, trademark, patent
+ * or other intellectual property or proprietary rights notices on or in the
+ * Software, including any copy thereof. Redistributions in binary or source
+ * form must include this license and terms.
  * 
  * THIS SOFTWARE IS PROVIDED BY ESOTERIC SOFTWARE "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 SOFTARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * EVENT SHALL ESOTERIC SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
diff --git a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/EventData.cs b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/EventData.cs
old mode 100644
new mode 100755
index 832d3de..187bb82
--- a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/EventData.cs
+++ b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/EventData.cs
@@ -1,25 +1,26 @@
 /******************************************************************************
  * Spine Runtimes Software License
- * Version 2.1
+ * Version 2.3
  * 
- * Copyright (c) 2013, Esoteric Software
+ * Copyright (c) 2013-2015, Esoteric Software
  * All rights reserved.
  * 
  * You are granted a perpetual, non-exclusive, non-sublicensable and
- * non-transferable license to install, execute and perform the Spine Runtimes
- * Software (the "Software") solely for internal use. Without the written
- * permission of Esoteric Software (typically granted by licensing Spine), you
- * may not (a) modify, translate, adapt or otherwise create derivative works,
- * improvements of the Software or develop new applications using the Software
- * or (b) remove, delete, alter or obscure any trademarks or any copyright,
- * trademark, patent or other intellectual property or proprietary rights
- * notices on or in the Software, including any copy thereof. Redistributions
- * in binary or source form must include this license and terms.
+ * non-transferable license to use, install, execute and perform the Spine
+ * Runtimes Software (the "Software") and derivative works solely for personal
+ * or internal use. Without the written permission of Esoteric Software (see
+ * Section 2 of the Spine Software License Agreement), you may not (a) modify,
+ * translate, adapt or otherwise create derivative works, improvements of the
+ * Software or develop new applications using the Software or (b) remove,
+ * delete, alter or obscure any trademarks or any copyright, trademark, patent
+ * or other intellectual property or proprietary rights notices on or in the
+ * Software, including any copy thereof. Redistributions in binary or source
+ * form must include this license and terms.
  * 
  * THIS SOFTWARE IS PROVIDED BY ESOTERIC SOFTWARE "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 SOFTARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * EVENT SHALL ESOTERIC SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
@@ -32,14 +33,16 @@
 
 namespace Spine {
 	public class EventData {
-		public String Name { get; private set; }
+		internal String name;
+
+		public String Name { get { return name; } }
 		public int Int { get; set; }
 		public float Float { get; set; }
 		public String String { get; set; }
 
 		public EventData (String name) {
 			if (name == null) throw new ArgumentNullException("name cannot be null.");
-			Name = name;
+			this.name = name;
 		}
 
 		override public String ToString () {
diff --git a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/ExposedList.cs b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/ExposedList.cs
new file mode 100755
index 0000000..efac67a
--- /dev/null
+++ b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/ExposedList.cs
@@ -0,0 +1,585 @@
+//
+// System.Collections.Generic.List
+//
+// Authors:
+//    Ben Maurer (bmaurer@ximian.com)
+//    Martin Baulig (martin@ximian.com)
+//    Carlos Alberto Cortez (calberto.cortez@gmail.com)
+//    David Waite (mass@akuma.org)
+//
+// Copyright (C) 2004-2005 Novell, Inc (http://www.novell.com)
+// Copyright (C) 2005 David Waite
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+// 
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+// 
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics;
+
+namespace Spine {
+	[Serializable]
+	[DebuggerDisplay("Count={Count}")]
+	public class ExposedList<T> : IEnumerable<T> {
+		public T[] Items;
+		public int Count;
+
+		private const int DefaultCapacity = 4;
+		private static readonly T[] EmptyArray = new T[0];
+		private int version;
+
+		public ExposedList() {
+			Items = EmptyArray;
+		}
+
+		public ExposedList(IEnumerable<T> collection) {
+			CheckCollection(collection);
+
+			// initialize to needed size (if determinable)
+			ICollection<T> c = collection as ICollection<T>;
+			if (c == null) {
+				Items = EmptyArray;
+				AddEnumerable(collection);
+			} else {
+				Items = new T[c.Count];
+				AddCollection(c);
+			}
+		}
+
+		public ExposedList(int capacity) {
+			if (capacity < 0)
+				throw new ArgumentOutOfRangeException("capacity");
+			Items = new T[capacity];
+		}
+
+		internal ExposedList(T[] data, int size) {
+			Items = data;
+			Count = size;
+		}
+
+		public void Add(T item) {
+			// If we check to see if we need to grow before trying to grow
+			// we can speed things up by 25%
+			if (Count == Items.Length)
+				GrowIfNeeded(1);
+			Items[Count ++] = item;
+			version++;
+		}
+
+		public void GrowIfNeeded(int newCount) {
+			int minimumSize = Count + newCount;
+			if (minimumSize > Items.Length)
+				Capacity = Math.Max(Math.Max(Capacity * 2, DefaultCapacity), minimumSize);
+		}
+
+		private void CheckRange(int idx, int count) {
+			if (idx < 0)
+				throw new ArgumentOutOfRangeException("index");
+
+			if (count < 0)
+				throw new ArgumentOutOfRangeException("count");
+
+			if ((uint) idx + (uint) count > (uint) Count)
+				throw new ArgumentException("index and count exceed length of list");
+		}
+
+		private void AddCollection(ICollection<T> collection) {
+			int collectionCount = collection.Count;
+			if (collectionCount == 0)
+				return;
+
+			GrowIfNeeded(collectionCount);
+			collection.CopyTo(Items, Count);
+			Count += collectionCount;
+		}
+
+		private void AddEnumerable(IEnumerable<T> enumerable) {
+			foreach (T t in enumerable) {
+				Add(t);
+			}
+		}
+
+		public void AddRange(IEnumerable<T> collection) {
+			CheckCollection(collection);
+
+			ICollection<T> c = collection as ICollection<T>;
+			if (c != null)
+				AddCollection(c);
+			else
+				AddEnumerable(collection);
+			version++;
+		}
+
+		public int BinarySearch(T item) {
+			return Array.BinarySearch<T>(Items, 0, Count, item);
+		}
+
+		public int BinarySearch(T item, IComparer<T> comparer) {
+			return Array.BinarySearch<T>(Items, 0, Count, item, comparer);
+		}
+
+		public int BinarySearch(int index, int count, T item, IComparer<T> comparer) {
+			CheckRange(index, count);
+			return Array.BinarySearch<T>(Items, index, count, item, comparer);
+		}
+
+		public void Clear(bool clearArray = true) {
+			if (clearArray)
+				Array.Clear(Items, 0, Items.Length);
+
+			Count = 0;
+			version++;
+		}
+
+		public bool Contains(T item) {
+			return Array.IndexOf<T>(Items, item, 0, Count) != -1;
+		}
+
+		public ExposedList<TOutput> ConvertAll<TOutput>(Converter<T, TOutput> converter) {
+			if (converter == null)
+				throw new ArgumentNullException("converter");
+			ExposedList<TOutput> u = new ExposedList<TOutput>(Count);
+			for (int i = 0; i < Count; i++)
+				u.Items[i] = converter(Items[i]);
+
+			u.Count = Count;
+			return u;
+		}
+
+		public void CopyTo(T[] array) {
+			Array.Copy(Items, 0, array, 0, Count);
+		}
+
+		public void CopyTo(T[] array, int arrayIndex) {
+			Array.Copy(Items, 0, array, arrayIndex, Count);
+		}
+
+		public void CopyTo(int index, T[] array, int arrayIndex, int count) {
+			CheckRange(index, count);
+			Array.Copy(Items, index, array, arrayIndex, count);
+		}
+
+		public bool Exists(Predicate<T> match) {
+			CheckMatch(match);
+			return GetIndex(0, Count, match) != -1;
+		}
+
+		public T Find(Predicate<T> match) {
+			CheckMatch(match);
+			int i = GetIndex(0, Count, match);
+			return (i != -1) ? Items[i] : default (T);
+		}
+
+		private static void CheckMatch(Predicate<T> match) {
+			if (match == null)
+				throw new ArgumentNullException("match");
+		}
+
+		public ExposedList<T> FindAll(Predicate<T> match) {
+			CheckMatch(match);
+			return FindAllList(match);
+		}
+
+		private ExposedList<T> FindAllList(Predicate<T> match) {
+			ExposedList<T> results = new ExposedList<T>();
+			for (int i = 0; i < Count; i++)
+				if (match(Items[i]))
+					results.Add(Items[i]);
+
+			return results;
+		}
+
+		public int FindIndex(Predicate<T> match) {
+			CheckMatch(match);
+			return GetIndex(0, Count, match);
+		}
+
+		public int FindIndex(int startIndex, Predicate<T> match) {
+			CheckMatch(match);
+			CheckIndex(startIndex);
+			return GetIndex(startIndex, Count - startIndex, match);
+		}
+
+		public int FindIndex(int startIndex, int count, Predicate<T> match) {
+			CheckMatch(match);
+			CheckRange(startIndex, count);
+			return GetIndex(startIndex, count, match);
+		}
+
+		private int GetIndex(int startIndex, int count, Predicate<T> match) {
+			int end = startIndex + count;
+			for (int i = startIndex; i < end; i ++)
+				if (match(Items[i]))
+					return i;
+
+			return -1;
+		}
+
+		public T FindLast(Predicate<T> match) {
+			CheckMatch(match);
+			int i = GetLastIndex(0, Count, match);
+			return i == -1 ? default (T) : Items[i];
+		}
+
+		public int FindLastIndex(Predicate<T> match) {
+			CheckMatch(match);
+			return GetLastIndex(0, Count, match);
+		}
+
+		public int FindLastIndex(int startIndex, Predicate<T> match) {
+			CheckMatch(match);
+			CheckIndex(startIndex);
+			return GetLastIndex(0, startIndex + 1, match);
+		}
+
+		public int FindLastIndex(int startIndex, int count, Predicate<T> match) {
+			CheckMatch(match);
+			int start = startIndex - count + 1;
+			CheckRange(start, count);
+			return GetLastIndex(start, count, match);
+		}
+
+		private int GetLastIndex(int startIndex, int count, Predicate<T> match) {
+			// unlike FindLastIndex, takes regular params for search range
+			for (int i = startIndex + count; i != startIndex;)
+				if (match(Items[--i]))
+					return i;
+			return -1;
+		}
+
+		public void ForEach(Action<T> action) {
+			if (action == null)
+				throw new ArgumentNullException("action");
+			for (int i = 0; i < Count; i++)
+				action(Items[i]);
+		}
+
+		public Enumerator GetEnumerator() {
+			return new Enumerator(this);
+		}
+
+		public ExposedList<T> GetRange(int index, int count) {
+			CheckRange(index, count);
+			T[] tmpArray = new T[count];
+			Array.Copy(Items, index, tmpArray, 0, count);
+			return new ExposedList<T>(tmpArray, count);
+		}
+
+		public int IndexOf(T item) {
+			return Array.IndexOf<T>(Items, item, 0, Count);
+		}
+
+		public int IndexOf(T item, int index) {
+			CheckIndex(index);
+			return Array.IndexOf<T>(Items, item, index, Count - index);
+		}
+
+		public int IndexOf(T item, int index, int count) {
+			if (index < 0)
+				throw new ArgumentOutOfRangeException("index");
+
+			if (count < 0)
+				throw new ArgumentOutOfRangeException("count");
+
+			if ((uint) index + (uint) count > (uint) Count)
+				throw new ArgumentOutOfRangeException("index and count exceed length of list");
+
+			return Array.IndexOf<T>(Items, item, index, count);
+		}
+
+		private void Shift(int start, int delta) {
+			if (delta < 0)
+				start -= delta;
+
+			if (start < Count)
+				Array.Copy(Items, start, Items, start + delta, Count - start);
+
+			Count += delta;
+
+			if (delta < 0)
+				Array.Clear(Items, Count, -delta);
+		}
+
+		private void CheckIndex(int index) {
+			if (index < 0 || (uint) index > (uint) Count)
+				throw new ArgumentOutOfRangeException("index");
+		}
+
+		public void Insert(int index, T item) {
+			CheckIndex(index);
+			if (Count == Items.Length)
+				GrowIfNeeded(1);
+			Shift(index, 1);
+			Items[index] = item;
+			version++;
+		}
+
+		private void CheckCollection(IEnumerable<T> collection) {
+			if (collection == null)
+				throw new ArgumentNullException("collection");
+		}
+
+		public void InsertRange(int index, IEnumerable<T> collection) {
+			CheckCollection(collection);
+			CheckIndex(index);
+			if (collection == this) {
+				T[] buffer = new T[Count];
+				CopyTo(buffer, 0);
+				GrowIfNeeded(Count);
+				Shift(index, buffer.Length);
+				Array.Copy(buffer, 0, Items, index, buffer.Length);
+			} else {
+				ICollection<T> c = collection as ICollection<T>;
+				if (c != null)
+					InsertCollection(index, c);
+				else
+					InsertEnumeration(index, collection);
+			}
+			version++;
+		}
+
+		private void InsertCollection(int index, ICollection<T> collection) {
+			int collectionCount = collection.Count;
+			GrowIfNeeded(collectionCount);
+
+			Shift(index, collectionCount);
+			collection.CopyTo(Items, index);
+		}
+
+		private void InsertEnumeration(int index, IEnumerable<T> enumerable) {
+			foreach (T t in enumerable)
+				Insert(index++, t);
+		}
+
+		public int LastIndexOf(T item) {
+			return Array.LastIndexOf<T>(Items, item, Count - 1, Count);
+		}
+
+		public int LastIndexOf(T item, int index) {
+			CheckIndex(index);
+			return Array.LastIndexOf<T>(Items, item, index, index + 1);
+		}
+
+		public int LastIndexOf(T item, int index, int count) {
+			if (index < 0)
+				throw new ArgumentOutOfRangeException("index", index, "index is negative");
+
+			if (count < 0)
+				throw new ArgumentOutOfRangeException("count", count, "count is negative");
+
+			if (index - count + 1 < 0)
+				throw new ArgumentOutOfRangeException("count", count, "count is too large");
+
+			return Array.LastIndexOf<T>(Items, item, index, count);
+		}
+
+		public bool Remove(T item) {
+			int loc = IndexOf(item);
+			if (loc != -1)
+				RemoveAt(loc);
+
+			return loc != -1;
+		}
+
+		public int RemoveAll(Predicate<T> match) {
+			CheckMatch(match);
+			int i = 0;
+			int j = 0;
+
+			// Find the first item to remove
+			for (i = 0; i < Count; i++)
+				if (match(Items[i]))
+					break;
+
+			if (i == Count)
+				return 0;
+
+			version++;
+
+			// Remove any additional items
+			for (j = i + 1; j < Count; j++) {
+				if (!match(Items[j]))
+					Items[i++] = Items[j];
+			}
+			if (j - i > 0)
+				Array.Clear(Items, i, j - i);
+
+			Count = i;
+			return (j - i);
+		}
+
+		public void RemoveAt(int index) {
+			if (index < 0 || (uint) index >= (uint) Count)
+				throw new ArgumentOutOfRangeException("index");
+			Shift(index, -1);
+			Array.Clear(Items, Count, 1);
+			version++;
+		}
+
+		public void RemoveRange(int index, int count) {
+			CheckRange(index, count);
+			if (count > 0) {
+				Shift(index, -count);
+				Array.Clear(Items, Count, count);
+				version++;
+			}
+		}
+
+		public void Reverse() {
+			Array.Reverse(Items, 0, Count);
+			version++;
+		}
+
+		public void Reverse(int index, int count) {
+			CheckRange(index, count);
+			Array.Reverse(Items, index, count);
+			version++;
+		}
+
+		public void Sort() {
+			Array.Sort<T>(Items, 0, Count, Comparer<T>.Default);
+			version++;
+		}
+
+		public void Sort(IComparer<T> comparer) {
+			Array.Sort<T>(Items, 0, Count, comparer);
+			version++;
+		}
+
+		public void Sort(Comparison<T> comparison) {
+			Array.Sort<T>(Items, comparison);
+			version++;
+		}
+
+		public void Sort(int index, int count, IComparer<T> comparer) {
+			CheckRange(index, count);
+			Array.Sort<T>(Items, index, count, comparer);
+			version++;
+		}
+
+		public T[] ToArray() {
+			T[] t = new T[Count];
+			Array.Copy(Items, t, Count);
+
+			return t;
+		}
+
+		public void TrimExcess() {
+			Capacity = Count;
+		}
+
+		public bool TrueForAll(Predicate<T> match) {
+			CheckMatch(match);
+
+			for (int i = 0; i < Count; i++)
+				if (!match(Items[i]))
+					return false;
+
+			return true;
+		}
+
+		public int Capacity {
+			get {
+				return Items.Length;
+			}
+			set {
+				if ((uint) value < (uint) Count)
+					throw new ArgumentOutOfRangeException();
+
+				Array.Resize(ref Items, value);
+			}
+		}
+
+		#region Interface implementations.
+
+		IEnumerator<T> IEnumerable<T>.GetEnumerator() {
+			return GetEnumerator();
+		}
+
+		IEnumerator IEnumerable.GetEnumerator() {
+			return GetEnumerator();
+		}
+
+		#endregion
+
+		[Serializable]
+		public struct Enumerator : IEnumerator<T>, IDisposable {
+			private ExposedList<T> l;
+			private int next;
+			private int ver;
+
+			private T current;
+
+			internal Enumerator(ExposedList<T> l)
+				: this() {
+				this.l = l;
+				ver = l.version;
+			}
+
+			public void Dispose() {
+				l = null;
+			}
+
+			private void VerifyState() {
+				if (l == null)
+					throw new ObjectDisposedException(GetType().FullName);
+				if (ver != l.version)
+					throw new InvalidOperationException(
+						"Collection was modified; enumeration operation may not execute.");
+			}
+
+			public bool MoveNext() {
+				VerifyState();
+
+				if (next < 0)
+					return false;
+
+				if (next < l.Count) {
+					current = l.Items[next++];
+					return true;
+				}
+
+				next = -1;
+				return false;
+			}
+
+			public T Current {
+				get {
+					return current;
+				}
+			}
+
+			void IEnumerator.Reset() {
+				VerifyState();
+				next = 0;
+			}
+
+			object IEnumerator.Current {
+				get {
+					VerifyState();
+					if (next <= 0)
+						throw new InvalidOperationException();
+					return current;
+				}
+			}
+		}
+	}
+}
\ No newline at end of file
diff --git a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/IkConstraint.cs b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/IkConstraint.cs
new file mode 100755
index 0000000..e5b7bc9
--- /dev/null
+++ b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/IkConstraint.cs
@@ -0,0 +1,151 @@
+/******************************************************************************
+ * Spine Runtimes Software License
+ * Version 2.3
+ * 
+ * Copyright (c) 2013-2015, Esoteric Software
+ * All rights reserved.
+ * 
+ * You are granted a perpetual, non-exclusive, non-sublicensable and
+ * non-transferable license to use, install, execute and perform the Spine
+ * Runtimes Software (the "Software") and derivative works solely for personal
+ * or internal use. Without the written permission of Esoteric Software (see
+ * Section 2 of the Spine Software License Agreement), you may not (a) modify,
+ * translate, adapt or otherwise create derivative works, improvements of the
+ * Software or develop new applications using the Software or (b) remove,
+ * delete, alter or obscure any trademarks or any copyright, trademark, patent
+ * or other intellectual property or proprietary rights notices on or in the
+ * Software, including any copy thereof. Redistributions in binary or source
+ * form must include this license and terms.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY ESOTERIC SOFTWARE "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 BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) 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.
+ *****************************************************************************/
+
+using System;
+using System.Collections.Generic;
+
+namespace Spine {
+	public class IkConstraint {
+		private const float radDeg = 180 / (float)Math.PI;
+
+		internal IkConstraintData data;
+		internal ExposedList<Bone> bones = new ExposedList<Bone>();
+		internal Bone target;
+		internal int bendDirection;
+		internal float mix;
+
+		public IkConstraintData Data { get { return data; } }
+		public ExposedList<Bone> Bones { get { return bones; } }
+		public Bone Target { get { return target; } set { target = value; } }
+		public int BendDirection { get { return bendDirection; } set { bendDirection = value; } }
+		public float Mix { get { return mix; } set { mix = value; } }
+
+		public IkConstraint (IkConstraintData data, Skeleton skeleton) {
+			if (data == null) throw new ArgumentNullException("data cannot be null.");
+			if (skeleton == null) throw new ArgumentNullException("skeleton cannot be null.");
+			this.data = data;
+			mix = data.mix;
+			bendDirection = data.bendDirection;
+
+			bones = new ExposedList<Bone>(data.bones.Count);
+			foreach (BoneData boneData in data.bones)
+				bones.Add(skeleton.FindBone(boneData.name));
+			target = skeleton.FindBone(data.target.name);
+		}
+
+		public void apply () {
+			Bone target = this.target;
+			ExposedList<Bone> bones = this.bones;
+			switch (bones.Count) {
+			case 1:
+				apply(bones.Items[0], target.worldX, target.worldY, mix);
+				break;
+			case 2:
+				apply(bones.Items[0], bones.Items[1], target.worldX, target.worldY, bendDirection, mix);
+				break;
+			}
+		}
+
+		override public String ToString () {
+			return data.name;
+		}
+
+		/// <summary>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.</summary>
+		static public void apply (Bone bone, float targetX, float targetY, float alpha) {
+			float parentRotation = (!bone.data.inheritRotation || bone.parent == null) ? 0 : bone.parent.worldRotation;
+			float rotation = bone.rotation;
+			float rotationIK = (float)Math.Atan2(targetY - bone.worldY, targetX - bone.worldX) * radDeg;
+			if (bone.worldFlipX != (bone.worldFlipY != Bone.yDown)) rotationIK = -rotationIK;
+			rotationIK -= parentRotation;
+			bone.rotationIK = rotation + (rotationIK - rotation) * alpha;
+		}
+
+		/// <summary>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.</summary>
+		/// <param name="child">Any descendant bone of the parent.</param>
+		static public void apply (Bone parent, Bone child, float targetX, float targetY, int bendDirection, float alpha) {
+			float childRotation = child.rotation, parentRotation = parent.rotation;
+			if (alpha == 0) {
+				child.rotationIK = childRotation;
+				parent.rotationIK = parentRotation;
+				return;
+			}
+			float positionX, positionY;
+			Bone parentParent = parent.parent;
+			if (parentParent != null) {
+				parentParent.worldToLocal(targetX, targetY, out positionX, out positionY);
+				targetX = (positionX - parent.x) * parentParent.worldScaleX;
+				targetY = (positionY - parent.y) * parentParent.worldScaleY;
+			} else {
+				targetX -= parent.x;
+				targetY -= parent.y;
+			}
+			if (child.parent == parent) {
+				positionX = child.x;
+				positionY = child.y;
+			} else {
+				child.parent.localToWorld(child.x, child.y, out positionX, out positionY);
+				parent.worldToLocal(positionX, positionY, out positionX, out positionY);
+			}
+			float childX = positionX * parent.worldScaleX, childY = positionY * parent.worldScaleY;
+			float offset = (float)Math.Atan2(childY, childX);
+			float len1 = (float)Math.Sqrt(childX * childX + childY * childY), len2 = child.data.length * child.worldScaleX;
+			// Based on code by Ryan Juckett with permission: Copyright (c) 2008-2009 Ryan Juckett, http://www.ryanjuckett.com/
+			float cosDenom = 2 * len1 * len2;
+			if (cosDenom < 0.0001f) {
+				child.rotationIK = childRotation + ((float)Math.Atan2(targetY, targetX) * radDeg - parentRotation - childRotation)
+					* alpha;
+				return;
+			}
+			float cos = (targetX * targetX + targetY * targetY - len1 * len1 - len2 * len2) / cosDenom;
+			if (cos < -1)
+				cos = -1;
+			else if (cos > 1)
+				cos = 1;
+			float childAngle = (float)Math.Acos(cos) * bendDirection;
+			float adjacent = len1 + len2 * cos, opposite = len2 * (float)Math.Sin(childAngle);
+			float parentAngle = (float)Math.Atan2(targetY * adjacent - targetX * opposite, targetX * adjacent + targetY * opposite);
+			float rotation = (parentAngle - offset) * radDeg - parentRotation;
+			if (rotation > 180)
+				rotation -= 360;
+			else if (rotation < -180) //
+				rotation += 360;
+			parent.rotationIK = parentRotation + rotation * alpha;
+			rotation = (childAngle + offset) * radDeg - childRotation;
+			if (rotation > 180)
+				rotation -= 360;
+			else if (rotation < -180) //
+				rotation += 360;
+			child.rotationIK = childRotation + (rotation + parent.worldRotation - child.parent.worldRotation) * alpha;
+		}
+	}
+}
diff --git a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/IkConstraintData.cs b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/IkConstraintData.cs
new file mode 100755
index 0000000..6bb9c75
--- /dev/null
+++ b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/IkConstraintData.cs
@@ -0,0 +1,58 @@
+/******************************************************************************
+ * Spine Runtimes Software License
+ * Version 2.3
+ * 
+ * Copyright (c) 2013-2015, Esoteric Software
+ * All rights reserved.
+ * 
+ * You are granted a perpetual, non-exclusive, non-sublicensable and
+ * non-transferable license to use, install, execute and perform the Spine
+ * Runtimes Software (the "Software") and derivative works solely for personal
+ * or internal use. Without the written permission of Esoteric Software (see
+ * Section 2 of the Spine Software License Agreement), you may not (a) modify,
+ * translate, adapt or otherwise create derivative works, improvements of the
+ * Software or develop new applications using the Software or (b) remove,
+ * delete, alter or obscure any trademarks or any copyright, trademark, patent
+ * or other intellectual property or proprietary rights notices on or in the
+ * Software, including any copy thereof. Redistributions in binary or source
+ * form must include this license and terms.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY ESOTERIC SOFTWARE "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 BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) 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.
+ *****************************************************************************/
+
+using System;
+using System.Collections.Generic;
+
+namespace Spine {
+	public class IkConstraintData {
+		internal String name;
+		internal List<BoneData> bones = new List<BoneData>();
+		internal BoneData target;
+		internal int bendDirection = 1;
+		internal float mix = 1;
+
+		public String Name { get { return name; } }
+		public List<BoneData> Bones { get { return bones; } }
+		public BoneData Target { get { return target; } set { target = value; } }
+		public int BendDirection { get { return bendDirection; } set { bendDirection = value; } }
+		public float Mix { get { return mix; } set { mix = value; } }
+
+		public IkConstraintData (String name) {
+			if (name == null) throw new ArgumentNullException("name cannot be null.");
+			this.name = name;
+		}
+
+		override public String ToString () {
+			return name;
+		}
+	}
+}
diff --git a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Json.cs b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Json.cs
old mode 100644
new mode 100755
diff --git a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Skeleton.cs b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Skeleton.cs
old mode 100644
new mode 100755
index f8e54be..8cd9b91
--- a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Skeleton.cs
+++ b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Skeleton.cs
@@ -1,25 +1,26 @@
 /******************************************************************************
  * Spine Runtimes Software License
- * Version 2.1
+ * Version 2.3
  * 
- * Copyright (c) 2013, Esoteric Software
+ * Copyright (c) 2013-2015, Esoteric Software
  * All rights reserved.
  * 
  * You are granted a perpetual, non-exclusive, non-sublicensable and
- * non-transferable license to install, execute and perform the Spine Runtimes
- * Software (the "Software") solely for internal use. Without the written
- * permission of Esoteric Software (typically granted by licensing Spine), you
- * may not (a) modify, translate, adapt or otherwise create derivative works,
- * improvements of the Software or develop new applications using the Software
- * or (b) remove, delete, alter or obscure any trademarks or any copyright,
- * trademark, patent or other intellectual property or proprietary rights
- * notices on or in the Software, including any copy thereof. Redistributions
- * in binary or source form must include this license and terms.
+ * non-transferable license to use, install, execute and perform the Spine
+ * Runtimes Software (the "Software") and derivative works solely for personal
+ * or internal use. Without the written permission of Esoteric Software (see
+ * Section 2 of the Spine Software License Agreement), you may not (a) modify,
+ * translate, adapt or otherwise create derivative works, improvements of the
+ * Software or develop new applications using the Software or (b) remove,
+ * delete, alter or obscure any trademarks or any copyright, trademark, patent
+ * or other intellectual property or proprietary rights notices on or in the
+ * Software, including any copy thereof. Redistributions in binary or source
+ * form must include this license and terms.
  * 
  * THIS SOFTWARE IS PROVIDED BY ESOTERIC SOFTWARE "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 SOFTARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * EVENT SHALL ESOTERIC SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
@@ -34,9 +35,11 @@
 namespace Spine {
 	public class Skeleton {
 		internal SkeletonData data;
-		internal List<Bone> bones;
-		internal List<Slot> slots;
-		internal List<Slot> drawOrder;
+		internal ExposedList<Bone> bones;
+		internal ExposedList<Slot> slots;
+		internal ExposedList<Slot> drawOrder;
+		internal ExposedList<IkConstraint> ikConstraints;
+		private ExposedList<ExposedList<Bone>> boneCache = new ExposedList<ExposedList<Bone>>();
 		internal Skin skin;
 		internal float r = 1, g = 1, b = 1, a = 1;
 		internal float time;
@@ -44,23 +47,24 @@ public class Skeleton {
 		internal float x, y;
 
 		public SkeletonData Data { get { return data; } }
-		public List<Bone> Bones { get { return bones; } }
-		public List<Slot> Slots { get { return slots; } }
-		public List<Slot> DrawOrder { get { return drawOrder; } }
+		public ExposedList<Bone> Bones { get { return bones; } }
+		public ExposedList<Slot> Slots { get { return slots; } }
+		public ExposedList<Slot> DrawOrder { get { return drawOrder; } }
+		public ExposedList<IkConstraint> IkConstraints { get { return ikConstraints; } set { ikConstraints = value; } }
 		public Skin Skin { get { return skin; } set { skin = value; } }
 		public float R { get { return r; } set { r = value; } }
 		public float G { get { return g; } set { g = value; } }
 		public float B { get { return b; } set { b = value; } }
 		public float A { get { return a; } set { a = value; } }
 		public float Time { get { return time; } set { time = value; } }
-		public bool FlipX { get { return flipX; } set { flipX = value; } }
-		public bool FlipY { get { return flipY; } set { flipY = value; } }
 		public float X { get { return x; } set { x = value; } }
 		public float Y { get { return y; } set { y = value; } }
+		public bool FlipX { get { return flipX; } set { flipX = value; } }
+		public bool FlipY { get { return flipY; } set { flipY = value; } }
 
 		public Bone RootBone {
 			get {
-				return bones.Count == 0 ? null : bones[0];
+				return bones.Count == 0 ? null : bones.Items[0];
 			}
 		}
 
@@ -68,29 +72,89 @@ public Skeleton (SkeletonData data) {
 			if (data == null) throw new ArgumentNullException("data cannot be null.");
 			this.data = data;
 
-			bones = new List<Bone>(data.bones.Count);
+			bones = new ExposedList<Bone>(data.bones.Count);
 			foreach (BoneData boneData in data.bones) {
-				Bone parent = boneData.parent == null ? null : bones[data.bones.IndexOf(boneData.parent)];
-				bones.Add(new Bone(boneData, parent));
+				Bone parent = boneData.parent == null ? null : bones.Items[data.bones.IndexOf(boneData.parent)];
+				Bone bone = new Bone(boneData, this, parent);
+				if (parent != null) parent.children.Add(bone);
+				bones.Add(bone);
 			}
 
-			slots = new List<Slot>(data.slots.Count);
-			drawOrder = new List<Slot>(data.slots.Count);
+			slots = new ExposedList<Slot>(data.slots.Count);
+			drawOrder = new ExposedList<Slot>(data.slots.Count);
 			foreach (SlotData slotData in data.slots) {
-				Bone bone = bones[data.bones.IndexOf(slotData.boneData)];
-				Slot slot = new Slot(slotData, this, bone);
+				Bone bone = bones.Items[data.bones.IndexOf(slotData.boneData)];
+				Slot slot = new Slot(slotData, bone);
 				slots.Add(slot);
 				drawOrder.Add(slot);
 			}
+
+			ikConstraints = new ExposedList<IkConstraint>(data.ikConstraints.Count);
+			foreach (IkConstraintData ikConstraintData in data.ikConstraints)
+				ikConstraints.Add(new IkConstraint(ikConstraintData, this));
+
+			UpdateCache();
 		}
 
-		/// <summary>Updates the world transform for each bone.</summary>
+		/// <summary>Caches information about bones and IK constraints. Must be called if bones or IK constraints are added or
+		/// removed.</summary>
+		public void UpdateCache () {
+			ExposedList<ExposedList<Bone>> boneCache = this.boneCache;
+			ExposedList<IkConstraint> ikConstraints = this.ikConstraints;
+			int ikConstraintsCount = ikConstraints.Count;
+
+			int arrayCount = ikConstraintsCount + 1;
+			if (boneCache.Count > arrayCount) boneCache.RemoveRange(arrayCount, boneCache.Count - arrayCount);
+			for (int i = 0, n = boneCache.Count; i < n; i++)
+				boneCache.Items[i].Clear();
+			while (boneCache.Count < arrayCount)
+				boneCache.Add(new ExposedList<Bone>());
+
+			ExposedList<Bone> nonIkBones = boneCache.Items[0];
+
+			for (int i = 0, n = bones.Count; i < n; i++) {
+				Bone bone = bones.Items[i];
+				Bone current = bone;
+				do {
+					for (int ii = 0; ii < ikConstraintsCount; ii++) {
+						IkConstraint ikConstraint = ikConstraints.Items[ii];
+						Bone parent = ikConstraint.bones.Items[0];
+						Bone child = ikConstraint.bones.Items[ikConstraint.bones.Count - 1];
+						while (true) {
+							if (current == child) {
+								boneCache.Items[ii].Add(bone);
+								boneCache.Items[ii + 1].Add(bone);
+								goto outer;
+							}
+							if (child == parent) break;
+							child = child.parent;
+						}
+					}
+					current = current.parent;
+				} while (current != null);
+				nonIkBones.Add(bone);
+				outer: {}
+			}
+		}
+
+		/// <summary>Updates the world transform for each bone and applies IK constraints.</summary>
 		public void UpdateWorldTransform () {
-			bool flipX = this.flipX;
-			bool flipY = this.flipY;
-			List<Bone> bones = this.bones;
-			for (int i = 0, n = bones.Count; i < n; i++)
-				bones[i].UpdateWorldTransform(flipX, flipY);
+			ExposedList<Bone> bones = this.bones;
+			for (int ii = 0, nn = bones.Count; ii < nn; ii++) {
+				Bone bone = bones.Items[ii];
+				bone.rotationIK = bone.rotation;
+			}
+			ExposedList<ExposedList<Bone>> boneCache = this.boneCache;
+			ExposedList<IkConstraint> ikConstraints = this.ikConstraints;
+			int i = 0, last = boneCache.Count - 1;
+			while (true) {
+				ExposedList<Bone> updateBones = boneCache.Items[i];
+				for (int ii = 0, nn = updateBones.Count; ii < nn; ii++)
+					updateBones.Items[ii].UpdateWorldTransform();
+				if (i == last) break;
+				ikConstraints.Items[i].apply();
+				i++;
+			}
 		}
 
 		/// <summary>Sets the bones and slots to their setup pose values.</summary>
@@ -100,25 +164,34 @@ public void SetToSetupPose () {
 		}
 
 		public void SetBonesToSetupPose () {
-			List<Bone> bones = this.bones;
+			ExposedList<Bone> bones = this.bones;
 			for (int i = 0, n = bones.Count; i < n; i++)
-				bones[i].SetToSetupPose();
+				bones.Items[i].SetToSetupPose();
+
+			ExposedList<IkConstraint> ikConstraints = this.ikConstraints;
+			for (int i = 0, n = ikConstraints.Count; i < n; i++) {
+				IkConstraint ikConstraint = ikConstraints.Items[i];
+				ikConstraint.bendDirection = ikConstraint.data.bendDirection;
+				ikConstraint.mix = ikConstraint.data.mix;
+			}
 		}
 
 		public void SetSlotsToSetupPose () {
-			List<Slot> slots = this.slots;
+			ExposedList<Slot> slots = this.slots;
 			drawOrder.Clear();
-			drawOrder.AddRange(slots);
 			for (int i = 0, n = slots.Count; i < n; i++)
-				slots[i].SetToSetupPose(i);
+				drawOrder.Add(slots.Items[i]);
+			
+			for (int i = 0, n = slots.Count; i < n; i++)
+				slots.Items[i].SetToSetupPose(i);
 		}
 
 		/// <returns>May be null.</returns>
 		public Bone FindBone (String boneName) {
 			if (boneName == null) throw new ArgumentNullException("boneName cannot be null.");
-			List<Bone> bones = this.bones;
+			ExposedList<Bone> bones = this.bones;
 			for (int i = 0, n = bones.Count; i < n; i++) {
-				Bone bone = bones[i];
+				Bone bone = bones.Items[i];
 				if (bone.data.name == boneName) return bone;
 			}
 			return null;
@@ -127,18 +200,18 @@ public Bone FindBone (String boneName) {
 		/// <returns>-1 if the bone was not found.</returns>
 		public int FindBoneIndex (String boneName) {
 			if (boneName == null) throw new ArgumentNullException("boneName cannot be null.");
-			List<Bone> bones = this.bones;
+			ExposedList<Bone> bones = this.bones;
 			for (int i = 0, n = bones.Count; i < n; i++)
-				if (bones[i].data.name == boneName) return i;
+				if (bones.Items[i].data.name == boneName) return i;
 			return -1;
 		}
 
 		/// <returns>May be null.</returns>
 		public Slot FindSlot (String slotName) {
 			if (slotName == null) throw new ArgumentNullException("slotName cannot be null.");
-			List<Slot> slots = this.slots;
+			ExposedList<Slot> slots = this.slots;
 			for (int i = 0, n = slots.Count; i < n; i++) {
-				Slot slot = slots[i];
+				Slot slot = slots.Items[i];
 				if (slot.data.name == slotName) return slot;
 			}
 			return null;
@@ -147,9 +220,9 @@ public Slot FindSlot (String slotName) {
 		/// <returns>-1 if the bone was not found.</returns>
 		public int FindSlotIndex (String slotName) {
 			if (slotName == null) throw new ArgumentNullException("slotName cannot be null.");
-			List<Slot> slots = this.slots;
+			ExposedList<Slot> slots = this.slots;
 			for (int i = 0, n = slots.Count; i < n; i++)
-				if (slots[i].data.name.Equals(slotName)) return i;
+				if (slots.Items[i].data.name.Equals(slotName)) return i;
 			return -1;
 		}
 
@@ -160,23 +233,26 @@ public void SetSkin (String skinName) {
 			SetSkin(skin);
 		}
 
-		/// <summary>Sets the skin used to look up attachments not found in the {@link SkeletonData#getDefaultSkin() default skin}. Attachments
-		/// from the new skin are attached if the corresponding attachment from the old skin was attached. If there was no old skin, each slot's
-		/// setup mode attachment is attached from the new skin.</summary>
+		/// <summary>Sets the skin used to look up attachments before looking in the {@link SkeletonData#getDefaultSkin() default 
+		/// skin}. Attachmentsfrom 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.</summary>
 		/// <param name="newSkin">May be null.</param>
 		public void SetSkin (Skin newSkin) {
-			if (skin == null) {
-				List<Slot> slots = this.slots;
-				for (int i = 0, n = slots.Count; i < n; i++) {
-					Slot slot = slots[i];
-					String name = slot.data.attachmentName;
-					if (name != null) {
-						Attachment attachment = newSkin.GetAttachment(i, name);
-						if (attachment != null) slot.Attachment = attachment;
+			if (newSkin != null) {
+				if (skin != null)
+					newSkin.AttachAll(this, skin);
+				else {
+					ExposedList<Slot> slots = this.slots;
+					for (int i = 0, n = slots.Count; i < n; i++) {
+						Slot slot = slots.Items[i];
+						String name = slot.data.attachmentName;
+						if (name != null) {
+							Attachment attachment = newSkin.GetAttachment(i, name);
+							if (attachment != null) slot.Attachment = attachment;
+						}
 					}
 				}
-			} else if (newSkin != null) //
-				newSkin.AttachAll(this, skin);
+			}
 			skin = newSkin;
 		}
 
@@ -199,9 +275,9 @@ public Attachment GetAttachment (int slotIndex, String attachmentName) {
 		/// <param name="attachmentName">May be null.</param>
 		public void SetAttachment (String slotName, String attachmentName) {
 			if (slotName == null) throw new ArgumentNullException("slotName cannot be null.");
-			List<Slot> slots = this.slots;
+			ExposedList<Slot> slots = this.slots;
 			for (int i = 0, n = slots.Count; i < n; i++) {
-				Slot slot = slots[i];
+				Slot slot = slots.Items[i];
 				if (slot.data.name == slotName) {
 					Attachment attachment = null;
 					if (attachmentName != null) {
@@ -215,6 +291,17 @@ public void SetAttachment (String slotName, String attachmentName) {
 			throw new Exception("Slot not found: " + slotName);
 		}
 
+		/** @return May be null. */
+		public IkConstraint FindIkConstraint (String ikConstraintName) {
+			if (ikConstraintName == null) throw new ArgumentNullException("ikConstraintName cannot be null.");
+			ExposedList<IkConstraint> ikConstraints = this.ikConstraints;
+			for (int i = 0, n = ikConstraints.Count; i < n; i++) {
+				IkConstraint ikConstraint = ikConstraints.Items[i];
+				if (ikConstraint.data.name == ikConstraintName) return ikConstraint;
+			}
+			return null;
+		}
+
 		public void Update (float delta) {
 			time += delta;
 		}
diff --git a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/SkeletonBinary.cs b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/SkeletonBinary.cs
new file mode 100755
index 0000000..4cbd34f
--- /dev/null
+++ b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/SkeletonBinary.cs
@@ -0,0 +1,664 @@
+/******************************************************************************
+ * Spine Runtimes Software License
+ * Version 2.3
+ * 
+ * Copyright (c) 2013-2015, Esoteric Software
+ * All rights reserved.
+ * 
+ * You are granted a perpetual, non-exclusive, non-sublicensable and
+ * non-transferable license to use, install, execute and perform the Spine
+ * Runtimes Software (the "Software") and derivative works solely for personal
+ * or internal use. Without the written permission of Esoteric Software (see
+ * Section 2 of the Spine Software License Agreement), you may not (a) modify,
+ * translate, adapt or otherwise create derivative works, improvements of the
+ * Software or develop new applications using the Software or (b) remove,
+ * delete, alter or obscure any trademarks or any copyright, trademark, patent
+ * or other intellectual property or proprietary rights notices on or in the
+ * Software, including any copy thereof. Redistributions in binary or source
+ * form must include this license and terms.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY ESOTERIC SOFTWARE "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 BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) 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.
+ *****************************************************************************/
+
+using System;
+using System.IO;
+using System.Collections.Generic;
+
+#if WINDOWS_STOREAPP
+using System.Threading.Tasks;
+using Windows.Storage;
+#endif
+
+namespace Spine {
+	public class SkeletonBinary {
+		public const int TIMELINE_SCALE = 0;
+		public const int TIMELINE_ROTATE = 1;
+		public const int TIMELINE_TRANSLATE = 2;
+		public const int TIMELINE_ATTACHMENT = 3;
+		public const int TIMELINE_COLOR = 4;
+		public const int TIMELINE_FLIPX = 5;
+		public const int TIMELINE_FLIPY = 6;
+
+		public const int CURVE_LINEAR = 0;
+		public const int CURVE_STEPPED = 1;
+		public const int CURVE_BEZIER = 2;
+
+		private AttachmentLoader attachmentLoader;
+		public float Scale { get; set; }
+		private char[] chars = new char[32];
+		private byte[] buffer = new byte[4];
+
+		public SkeletonBinary (params Atlas[] atlasArray)
+			: this(new AtlasAttachmentLoader(atlasArray)) {
+		}
+
+		public SkeletonBinary (AttachmentLoader attachmentLoader) {
+			if (attachmentLoader == null) throw new ArgumentNullException("attachmentLoader cannot be null.");
+			this.attachmentLoader = attachmentLoader;
+			Scale = 1;
+		}
+
+#if WINDOWS_STOREAPP
+		private async Task<SkeletonData> ReadFile(string path) {
+			var folder = Windows.ApplicationModel.Package.Current.InstalledLocation;
+			using (var input = new BufferedStream(await folder.GetFileAsync(path).AsTask().ConfigureAwait(false))) {
+				SkeletonData skeletonData = ReadSkeletonData(input);
+				skeletonData.Name = Path.GetFileNameWithoutExtension(path);
+				return skeletonData;
+			}
+		}
+
+		public SkeletonData ReadSkeletonData (String path) {
+			return this.ReadFile(path).Result;
+		}
+#else
+		public SkeletonData ReadSkeletonData (String path) {
+#if WINDOWS_PHONE
+			using (var input = new BufferedStream(Microsoft.Xna.Framework.TitleContainer.OpenStream(path)))
+			{
+#else
+			using (var input = new BufferedStream(new FileStream(path, FileMode.Open))) {
+#endif
+				SkeletonData skeletonData = ReadSkeletonData(input);
+				skeletonData.name = Path.GetFileNameWithoutExtension(path);
+				return skeletonData;
+			}
+		}
+#endif
+
+		public SkeletonData ReadSkeletonData (Stream input) {
+			if (input == null) throw new ArgumentNullException("input cannot be null.");
+			float scale = Scale;
+
+			var skeletonData = new SkeletonData();
+			skeletonData.hash = ReadString(input);
+			if (skeletonData.hash.Length == 0) skeletonData.hash = null;
+			skeletonData.version = ReadString(input);
+			if (skeletonData.version.Length == 0) skeletonData.version = null;
+			skeletonData.width = ReadFloat(input);
+			skeletonData.height = ReadFloat(input);
+
+			bool nonessential = ReadBoolean(input);
+
+			if (nonessential) {
+				skeletonData.imagesPath = ReadString(input);
+				if (skeletonData.imagesPath.Length == 0) skeletonData.imagesPath = null;
+			}
+
+			// Bones.
+			for (int i = 0, n = ReadInt(input, true); i < n; i++) {
+				String name = ReadString(input);
+				BoneData parent = null;
+				int parentIndex = ReadInt(input, true) - 1;
+				if (parentIndex != -1) parent = skeletonData.bones.Items[parentIndex];
+				BoneData boneData = new BoneData(name, parent);
+				boneData.x = ReadFloat(input) * scale;
+				boneData.y = ReadFloat(input) * scale;
+				boneData.scaleX = ReadFloat(input);
+				boneData.scaleY = ReadFloat(input);
+				boneData.rotation = ReadFloat(input);
+				boneData.length = ReadFloat(input) * scale;
+				boneData.flipX = ReadBoolean(input);
+				boneData.flipY = ReadBoolean(input);
+				boneData.inheritScale = ReadBoolean(input);
+				boneData.inheritRotation = ReadBoolean(input);
+				if (nonessential) ReadInt(input); // Skip bone color.
+				skeletonData.bones.Add(boneData);
+			}
+
+			// IK constraints.
+			for (int i = 0, n = ReadInt(input, true); i < n; i++) {
+				IkConstraintData ikConstraintData = new IkConstraintData(ReadString(input));
+				for (int ii = 0, nn = ReadInt(input, true); ii < nn; ii++)
+					ikConstraintData.bones.Add(skeletonData.bones.Items[ReadInt(input, true)]);
+				ikConstraintData.target = skeletonData.bones.Items[ReadInt(input, true)];
+				ikConstraintData.mix = ReadFloat(input);
+				ikConstraintData.bendDirection = ReadSByte(input);
+				skeletonData.ikConstraints.Add(ikConstraintData);
+			}
+
+			// Slots.
+			for (int i = 0, n = ReadInt(input, true); i < n; i++) {
+				String slotName = ReadString(input);
+				BoneData boneData = skeletonData.bones.Items[ReadInt(input, true)];
+				SlotData slotData = new SlotData(slotName, boneData);
+				int color = ReadInt(input);
+				slotData.r = ((color & 0xff000000) >> 24) / 255f;
+				slotData.g = ((color & 0x00ff0000) >> 16) / 255f;
+				slotData.b = ((color & 0x0000ff00) >> 8) / 255f;
+				slotData.a = ((color & 0x000000ff)) / 255f;
+				slotData.attachmentName = ReadString(input);
+				slotData.blendMode = (BlendMode)ReadInt(input, true);
+				skeletonData.slots.Add(slotData);
+			}
+
+			// Default skin.
+			Skin defaultSkin = ReadSkin(input, "default", nonessential);
+			if (defaultSkin != null) {
+				skeletonData.defaultSkin = defaultSkin;
+				skeletonData.skins.Add(defaultSkin);
+			}
+
+			// Skins.
+			for (int i = 0, n = ReadInt(input, true); i < n; i++)
+				skeletonData.skins.Add(ReadSkin(input, ReadString(input), nonessential));
+
+			// Events.
+			for (int i = 0, n = ReadInt(input, true); i < n; i++) {
+				EventData eventData = new EventData(ReadString(input));
+				eventData.Int = ReadInt(input, false);
+				eventData.Float = ReadFloat(input);
+				eventData.String = ReadString(input);
+				skeletonData.events.Add(eventData);
+			}
+
+			// Animations.
+			for (int i = 0, n = ReadInt(input, true); i < n; i++)
+				ReadAnimation(ReadString(input), input, skeletonData);
+
+			skeletonData.bones.TrimExcess();
+			skeletonData.slots.TrimExcess();
+			skeletonData.skins.TrimExcess();
+			skeletonData.events.TrimExcess();
+			skeletonData.animations.TrimExcess();
+			skeletonData.ikConstraints.TrimExcess();
+			return skeletonData;
+		}
+
+		/** @return May be null. */
+		private Skin ReadSkin (Stream input, String skinName, bool nonessential) {
+			int slotCount = ReadInt(input, true);
+			if (slotCount == 0) return null;
+			Skin skin = new Skin(skinName);
+			for (int i = 0; i < slotCount; i++) {
+				int slotIndex = ReadInt(input, true);
+				for (int ii = 0, nn = ReadInt(input, true); ii < nn; ii++) {
+					String name = ReadString(input);
+					skin.AddAttachment(slotIndex, name, ReadAttachment(input, skin, name, nonessential));
+				}
+			}
+			return skin;
+		}
+
+		private Attachment ReadAttachment (Stream input, Skin skin, String attachmentName, bool nonessential) {
+			float scale = Scale;
+
+			String name = ReadString(input);
+			if (name == null) name = attachmentName;
+
+			switch ((AttachmentType)input.ReadByte()) {
+			case AttachmentType.region: {
+				String path = ReadString(input);
+				if (path == null) path = name;
+				RegionAttachment region = attachmentLoader.NewRegionAttachment(skin, name, path);
+				if (region == null) return null;
+				region.Path = path;
+				region.x = ReadFloat(input) * scale;
+				region.y = ReadFloat(input) * scale;
+				region.scaleX = ReadFloat(input);
+				region.scaleY = ReadFloat(input);
+				region.rotation = ReadFloat(input);
+				region.width = ReadFloat(input) * scale;
+				region.height = ReadFloat(input) * scale;
+				int color = ReadInt(input);
+				region.r = ((color & 0xff000000) >> 24) / 255f;
+				region.g = ((color & 0x00ff0000) >> 16) / 255f;
+				region.b = ((color & 0x0000ff00) >> 8) / 255f;
+				region.a = ((color & 0x000000ff)) / 255f;
+				region.UpdateOffset();
+				return region;
+			}
+			case AttachmentType.boundingbox: {
+				BoundingBoxAttachment box = attachmentLoader.NewBoundingBoxAttachment(skin, name);
+				if (box == null) return null;
+				box.vertices = ReadFloatArray(input, scale);
+				return box;
+			}
+			case AttachmentType.mesh: {
+				String path = ReadString(input);
+				if (path == null) path = name;
+				MeshAttachment mesh = attachmentLoader.NewMeshAttachment(skin, name, path);
+				if (mesh == null) return null;
+				mesh.Path = path;
+				mesh.regionUVs = ReadFloatArray(input, 1);
+				mesh.triangles = ReadShortArray(input);
+				mesh.vertices = ReadFloatArray(input, scale);
+				mesh.UpdateUVs();
+				int color = ReadInt(input);
+				mesh.r = ((color & 0xff000000) >> 24) / 255f;
+				mesh.g = ((color & 0x00ff0000) >> 16) / 255f;
+				mesh.b = ((color & 0x0000ff00) >> 8) / 255f;
+				mesh.a = ((color & 0x000000ff)) / 255f;
+				mesh.HullLength = ReadInt(input, true) * 2;
+				if (nonessential) {
+					mesh.Edges = ReadIntArray(input);
+					mesh.Width = ReadFloat(input) * scale;
+					mesh.Height = ReadFloat(input) * scale;
+				}
+				return mesh;
+			}
+			case AttachmentType.skinnedmesh: {
+				String path = ReadString(input);
+				if (path == null) path = name;
+				SkinnedMeshAttachment mesh = attachmentLoader.NewSkinnedMeshAttachment(skin, name, path);
+				if (mesh == null) return null;
+				mesh.Path = path;
+				float[] uvs = ReadFloatArray(input, 1);
+				int[] triangles = ReadShortArray(input);
+
+				int vertexCount = ReadInt(input, true);
+				var weights = new List<float>(uvs.Length * 3 * 3);
+				var bones = new List<int>(uvs.Length * 3);
+				for (int i = 0; i < vertexCount; i++) {
+					int boneCount = (int)ReadFloat(input);
+					bones.Add(boneCount);
+					for (int nn = i + boneCount * 4; i < nn; i += 4) {
+						bones.Add((int)ReadFloat(input));
+						weights.Add(ReadFloat(input) * scale);
+						weights.Add(ReadFloat(input) * scale);
+						weights.Add(ReadFloat(input));
+					}
+				}
+				mesh.bones = bones.ToArray();
+				mesh.weights = weights.ToArray();
+				mesh.triangles = triangles;
+				mesh.regionUVs = uvs;
+				mesh.UpdateUVs();
+				int color = ReadInt(input);
+				mesh.r = ((color & 0xff000000) >> 24) / 255f;
+				mesh.g = ((color & 0x00ff0000) >> 16) / 255f;
+				mesh.b = ((color & 0x0000ff00) >> 8) / 255f;
+				mesh.a = ((color & 0x000000ff)) / 255f;
+				mesh.HullLength = ReadInt(input, true) * 2;
+				if (nonessential) {
+					mesh.Edges = ReadIntArray(input);
+					mesh.Width = ReadFloat(input) * scale;
+					mesh.Height = ReadFloat(input) * scale;
+				}
+				return mesh;
+			}
+			}
+			return null;
+		}
+
+		private float[] ReadFloatArray (Stream input, float scale) {
+			int n = ReadInt(input, true);
+			float[] array = new float[n];
+			if (scale == 1) {
+				for (int i = 0; i < n; i++)
+					array[i] = ReadFloat(input);
+			} else {
+				for (int i = 0; i < n; i++)
+					array[i] = ReadFloat(input) * scale;
+			}
+			return array;
+		}
+
+		private int[] ReadShortArray (Stream input) {
+			int n = ReadInt(input, true);
+			int[] array = new int[n];
+			for (int i = 0; i < n; i++)
+				array[i] = (input.ReadByte() << 8) + input.ReadByte();
+			return array;
+		}
+
+		private int[] ReadIntArray (Stream input) {
+			int n = ReadInt(input, true);
+			int[] array = new int[n];
+			for (int i = 0; i < n; i++)
+				array[i] = ReadInt(input, true);
+			return array;
+		}
+
+		private void ReadAnimation (String name, Stream input, SkeletonData skeletonData) {
+			var timelines = new ExposedList<Timeline>();
+			float scale = Scale;
+			float duration = 0;
+	
+			// Slot timelines.
+			for (int i = 0, n = ReadInt(input, true); i < n; i++) {
+				int slotIndex = ReadInt(input, true);
+				for (int ii = 0, nn = ReadInt(input, true); ii < nn; ii++) {
+					int timelineType = input.ReadByte();
+					int frameCount = ReadInt(input, true);
+					switch (timelineType) {
+					case TIMELINE_COLOR: {
+						ColorTimeline timeline = new ColorTimeline(frameCount);
+						timeline.slotIndex = slotIndex;
+						for (int frameIndex = 0; frameIndex < frameCount; frameIndex++) {
+							float time = ReadFloat(input);
+							int color = ReadInt(input);
+							float r = ((color & 0xff000000) >> 24) / 255f;
+							float g = ((color & 0x00ff0000) >> 16) / 255f;
+							float b = ((color & 0x0000ff00) >> 8) / 255f;
+							float a = ((color & 0x000000ff)) / 255f;
+							timeline.SetFrame(frameIndex, time, r, g, b, a);
+							if (frameIndex < frameCount - 1) ReadCurve(input, frameIndex, timeline);
+						}
+						timelines.Add(timeline);
+						duration = Math.Max(duration, timeline.frames[frameCount * 5 - 5]);
+						break;
+					}
+					case TIMELINE_ATTACHMENT: {
+						AttachmentTimeline timeline = new AttachmentTimeline(frameCount);
+						timeline.slotIndex = slotIndex;
+						for (int frameIndex = 0; frameIndex < frameCount; frameIndex++)
+							timeline.SetFrame(frameIndex, ReadFloat(input), ReadString(input));
+						timelines.Add(timeline);
+						duration = Math.Max(duration, timeline.frames[frameCount - 1]);
+						break;
+					}
+					}
+				}
+			}
+
+			// Bone timelines.
+			for (int i = 0, n = ReadInt(input, true); i < n; i++) {
+				int boneIndex = ReadInt(input, true);
+				for (int ii = 0, nn = ReadInt(input, true); ii < nn; ii++) {
+					int timelineType = input.ReadByte();
+					int frameCount = ReadInt(input, true);
+					switch (timelineType) {
+					case TIMELINE_ROTATE: {
+						RotateTimeline timeline = new RotateTimeline(frameCount);
+						timeline.boneIndex = boneIndex;
+						for (int frameIndex = 0; frameIndex < frameCount; frameIndex++) {
+							timeline.SetFrame(frameIndex, ReadFloat(input), ReadFloat(input));
+							if (frameIndex < frameCount - 1) ReadCurve(input, frameIndex, timeline);
+						}
+						timelines.Add(timeline);
+						duration = Math.Max(duration, timeline.frames[frameCount * 2 - 2]);
+						break;
+					}
+					case TIMELINE_TRANSLATE:
+					case TIMELINE_SCALE: {
+						TranslateTimeline timeline;
+						float timelineScale = 1;
+						if (timelineType == TIMELINE_SCALE)
+							timeline = new ScaleTimeline(frameCount);
+						else {
+							timeline = new TranslateTimeline(frameCount);
+							timelineScale = scale;
+						}
+						timeline.boneIndex = boneIndex;
+						for (int frameIndex = 0; frameIndex < frameCount; frameIndex++) {
+							timeline.SetFrame(frameIndex, ReadFloat(input), ReadFloat(input) * timelineScale, ReadFloat(input)
+								* timelineScale);
+							if (frameIndex < frameCount - 1) ReadCurve(input, frameIndex, timeline);
+						}
+						timelines.Add(timeline);
+						duration = Math.Max(duration, timeline.frames[frameCount * 3 - 3]);
+						break;
+					}
+					case TIMELINE_FLIPX:
+					case TIMELINE_FLIPY: {
+						FlipXTimeline timeline = timelineType == TIMELINE_FLIPX ? new FlipXTimeline(frameCount) : new FlipYTimeline(
+							frameCount);
+						timeline.boneIndex = boneIndex;
+						for (int frameIndex = 0; frameIndex < frameCount; frameIndex++)
+							timeline.SetFrame(frameIndex, ReadFloat(input), ReadBoolean(input));
+						timelines.Add(timeline);
+						duration = Math.Max(duration, timeline.frames[frameCount * 2 - 2]);
+						break;
+					}
+					}
+				}
+			}
+
+			// IK timelines.
+			for (int i = 0, n = ReadInt(input, true); i < n; i++) {
+				IkConstraintData ikConstraint = skeletonData.ikConstraints.Items[ReadInt(input, true)];
+				int frameCount = ReadInt(input, true);
+				IkConstraintTimeline timeline = new IkConstraintTimeline(frameCount);
+				timeline.ikConstraintIndex = skeletonData.ikConstraints.IndexOf(ikConstraint);
+				for (int frameIndex = 0; frameIndex < frameCount; frameIndex++) {
+					timeline.SetFrame(frameIndex, ReadFloat(input), ReadFloat(input), ReadSByte(input));
+					if (frameIndex < frameCount - 1) ReadCurve(input, frameIndex, timeline);
+				}
+				timelines.Add(timeline);
+				duration = Math.Max(duration, timeline.frames[frameCount * 3 - 3]);
+			}
+
+			// FFD timelines.
+			for (int i = 0, n = ReadInt(input, true); i < n; i++) {
+				Skin skin = skeletonData.skins.Items[ReadInt(input, true)];
+				for (int ii = 0, nn = ReadInt(input, true); ii < nn; ii++) {
+					int slotIndex = ReadInt(input, true);
+					for (int iii = 0, nnn = ReadInt(input, true); iii < nnn; iii++) {
+						Attachment attachment = skin.GetAttachment(slotIndex, ReadString(input));
+						int frameCount = ReadInt(input, true);
+						FFDTimeline timeline = new FFDTimeline(frameCount);
+						timeline.slotIndex = slotIndex;
+						timeline.attachment = attachment;
+						for (int frameIndex = 0; frameIndex < frameCount; frameIndex++) {
+							float time = ReadFloat(input);
+
+							float[] vertices;
+							int vertexCount;
+							if (attachment is MeshAttachment)
+								vertexCount = ((MeshAttachment)attachment).vertices.Length;
+							else
+								vertexCount = ((SkinnedMeshAttachment)attachment).weights.Length / 3 * 2;
+
+							int end = ReadInt(input, true);
+							if (end == 0) {
+								if (attachment is MeshAttachment)
+									vertices = ((MeshAttachment)attachment).vertices;
+								else
+									vertices = new float[vertexCount];
+							} else {
+								vertices = new float[vertexCount];
+								int start = ReadInt(input, true);
+								end += start;
+								if (scale == 1) {
+									for (int v = start; v < end; v++)
+										vertices[v] = ReadFloat(input);
+								} else {
+									for (int v = start; v < end; v++)
+										vertices[v] = ReadFloat(input) * scale;
+								}
+								if (attachment is MeshAttachment) {
+									float[] meshVertices = ((MeshAttachment)attachment).vertices;
+									for (int v = 0, vn = vertices.Length; v < vn; v++)
+										vertices[v] += meshVertices[v];
+								}
+							}
+
+							timeline.SetFrame(frameIndex, time, vertices);
+							if (frameIndex < frameCount - 1) ReadCurve(input, frameIndex, timeline);
+						}
+						timelines.Add(timeline);
+						duration = Math.Max(duration, timeline.frames[frameCount - 1]);
+					}
+				}
+			}
+
+			// Draw order timeline.
+			int drawOrderCount = ReadInt(input, true);
+			if (drawOrderCount > 0) {
+				DrawOrderTimeline timeline = new DrawOrderTimeline(drawOrderCount);
+				int slotCount = skeletonData.slots.Count;
+				for (int i = 0; i < drawOrderCount; i++) {
+					int offsetCount = ReadInt(input, true);
+					int[] drawOrder = new int[slotCount];
+					for (int ii = slotCount - 1; ii >= 0; ii--)
+						drawOrder[ii] = -1;
+					int[] unchanged = new int[slotCount - offsetCount];
+					int originalIndex = 0, unchangedIndex = 0;
+					for (int ii = 0; ii < offsetCount; ii++) {
+						int slotIndex = ReadInt(input, true);
+						// Collect unchanged items.
+						while (originalIndex != slotIndex)
+							unchanged[unchangedIndex++] = originalIndex++;
+						// Set changed items.
+						drawOrder[originalIndex + ReadInt(input, true)] = originalIndex++;
+					}
+					// Collect remaining unchanged items.
+					while (originalIndex < slotCount)
+						unchanged[unchangedIndex++] = originalIndex++;
+					// Fill in unchanged items.
+					for (int ii = slotCount - 1; ii >= 0; ii--)
+						if (drawOrder[ii] == -1) drawOrder[ii] = unchanged[--unchangedIndex];
+					timeline.SetFrame(i, ReadFloat(input), drawOrder);
+				}
+				timelines.Add(timeline);
+				duration = Math.Max(duration, timeline.frames[drawOrderCount - 1]);
+			}
+
+			// Event timeline.
+			int eventCount = ReadInt(input, true);
+			if (eventCount > 0) {
+				EventTimeline timeline = new EventTimeline(eventCount);
+				for (int i = 0; i < eventCount; i++) {
+					float time = ReadFloat(input);
+					EventData eventData = skeletonData.events.Items[ReadInt(input, true)];
+					Event e = new Event(eventData);
+					e.Int = ReadInt(input, false);
+					e.Float = ReadFloat(input);
+					e.String = ReadBoolean(input) ? ReadString(input) : eventData.String;
+					timeline.SetFrame(i, time, e);
+				}
+				timelines.Add(timeline);
+				duration = Math.Max(duration, timeline.frames[eventCount - 1]);
+			}
+
+			timelines.TrimExcess();
+			skeletonData.animations.Add(new Animation(name, timelines, duration));
+		}
+
+		private void ReadCurve (Stream input, int frameIndex, CurveTimeline timeline) {
+			switch (input.ReadByte()) {
+			case CURVE_STEPPED:
+				timeline.SetStepped(frameIndex);
+				break;
+			case CURVE_BEZIER:
+				timeline.SetCurve(frameIndex, ReadFloat(input), ReadFloat(input), ReadFloat(input), ReadFloat(input));
+				break;
+			}
+		}
+
+		private sbyte ReadSByte (Stream input) {
+			int value = input.ReadByte();
+			if (value == -1) throw new EndOfStreamException();
+			return (sbyte)value;
+		}
+
+		private bool ReadBoolean (Stream input) {
+			return input.ReadByte() != 0;
+		}
+
+		private float ReadFloat (Stream input) {
+			buffer[3] = (byte)input.ReadByte();
+			buffer[2] = (byte)input.ReadByte();
+			buffer[1] = (byte)input.ReadByte();
+			buffer[0] = (byte)input.ReadByte();
+			return BitConverter.ToSingle(buffer, 0);
+		}
+
+		private int ReadInt (Stream input) {
+			return (input.ReadByte() << 24) + (input.ReadByte() << 16) + (input.ReadByte() << 8) + input.ReadByte();
+		}
+
+		private int ReadInt (Stream input, bool optimizePositive) {
+			int b = input.ReadByte();
+			int result = b & 0x7F;
+			if ((b & 0x80) != 0) {
+				b = input.ReadByte();
+				result |= (b & 0x7F) << 7;
+				if ((b & 0x80) != 0) {
+					b = input.ReadByte();
+					result |= (b & 0x7F) << 14;
+					if ((b & 0x80) != 0) {
+						b = input.ReadByte();
+						result |= (b & 0x7F) << 21;
+						if ((b & 0x80) != 0) {
+							b = input.ReadByte();
+							result |= (b & 0x7F) << 28;
+						}
+					}
+				}
+			}
+			return optimizePositive ? result : ((result >> 1) ^ -(result & 1));
+		}
+
+		private string ReadString (Stream input) {
+			int charCount = ReadInt(input, true);
+			switch (charCount) {
+			case 0:
+				return null;
+			case 1:
+				return "";
+			}
+			charCount--;
+			char[] chars = this.chars;
+			if (chars.Length < charCount) this.chars = chars = new char[charCount];
+			// Try to read 7 bit ASCII chars.
+			int charIndex = 0;
+			int b = 0;
+			while (charIndex < charCount) {
+				b = input.ReadByte();
+				if (b > 127) break;
+				chars[charIndex++] = (char)b;
+			}
+			// If a char was not ASCII, finish with slow path.
+			if (charIndex < charCount) ReadUtf8_slow(input, charCount, charIndex, b);
+			return new String(chars, 0, charCount);
+		}
+
+		private void ReadUtf8_slow (Stream input, int charCount, int charIndex, int b) {
+			char[] chars = this.chars;
+			while (true) {
+				switch (b >> 4) {
+				case 0:
+				case 1:
+				case 2:
+				case 3:
+				case 4:
+				case 5:
+				case 6:
+				case 7:
+					chars[charIndex] = (char)b;
+					break;
+				case 12:
+				case 13:
+					chars[charIndex] = (char)((b & 0x1F) << 6 | input.ReadByte() & 0x3F);
+					break;
+				case 14:
+					chars[charIndex] = (char)((b & 0x0F) << 12 | (input.ReadByte() & 0x3F) << 6 | input.ReadByte() & 0x3F);
+					break;
+				}
+				if (++charIndex >= charCount) break;
+				b = input.ReadByte() & 0xFF;
+			}
+		}
+	}
+}
diff --git a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/SkeletonBounds.cs b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/SkeletonBounds.cs
old mode 100644
new mode 100755
index 3e434a8..11d875a
--- a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/SkeletonBounds.cs
+++ b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/SkeletonBounds.cs
@@ -1,25 +1,26 @@
 /******************************************************************************
  * Spine Runtimes Software License
- * Version 2.1
+ * Version 2.3
  * 
- * Copyright (c) 2013, Esoteric Software
+ * Copyright (c) 2013-2015, Esoteric Software
  * All rights reserved.
  * 
  * You are granted a perpetual, non-exclusive, non-sublicensable and
- * non-transferable license to install, execute and perform the Spine Runtimes
- * Software (the "Software") solely for internal use. Without the written
- * permission of Esoteric Software (typically granted by licensing Spine), you
- * may not (a) modify, translate, adapt or otherwise create derivative works,
- * improvements of the Software or develop new applications using the Software
- * or (b) remove, delete, alter or obscure any trademarks or any copyright,
- * trademark, patent or other intellectual property or proprietary rights
- * notices on or in the Software, including any copy thereof. Redistributions
- * in binary or source form must include this license and terms.
+ * non-transferable license to use, install, execute and perform the Spine
+ * Runtimes Software (the "Software") and derivative works solely for personal
+ * or internal use. Without the written permission of Esoteric Software (see
+ * Section 2 of the Spine Software License Agreement), you may not (a) modify,
+ * translate, adapt or otherwise create derivative works, improvements of the
+ * Software or develop new applications using the Software or (b) remove,
+ * delete, alter or obscure any trademarks or any copyright, trademark, patent
+ * or other intellectual property or proprietary rights notices on or in the
+ * Software, including any copy thereof. Redistributions in binary or source
+ * form must include this license and terms.
  * 
  * THIS SOFTWARE IS PROVIDED BY ESOTERIC SOFTWARE "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 SOFTARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * EVENT SHALL ESOTERIC SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
@@ -33,11 +34,11 @@
 
 namespace Spine {
 	public class SkeletonBounds {
-		private List<Polygon> polygonPool = new List<Polygon>();
+		private ExposedList<Polygon> polygonPool = new ExposedList<Polygon>();
 		private float minX, minY, maxX, maxY;
 
-		public List<BoundingBoxAttachment> BoundingBoxes { get; private set; }
-		public List<Polygon> Polygons { get; private set; }
+		public ExposedList<BoundingBoxAttachment> BoundingBoxes { get; private set; }
+		public ExposedList<Polygon> Polygons { get; private set; }
 		public float MinX { get { return minX; } set { minX = value; } }
 		public float MinY { get { return minY; } set { minY = value; } }
 		public float MaxX { get { return maxX; } set { maxX = value; } }
@@ -46,24 +47,23 @@ public class SkeletonBounds {
 		public float Height { get { return maxY - minY; } }
 
 		public SkeletonBounds () {
-			BoundingBoxes = new List<BoundingBoxAttachment>();
-			Polygons = new List<Polygon>();
+			BoundingBoxes = new ExposedList<BoundingBoxAttachment>();
+			Polygons = new ExposedList<Polygon>();
 		}
 
 		public void Update (Skeleton skeleton, bool updateAabb) {
-			List<BoundingBoxAttachment> boundingBoxes = BoundingBoxes;
-			List<Polygon> polygons = Polygons;
-			List<Slot> slots = skeleton.slots;
+			ExposedList<BoundingBoxAttachment> boundingBoxes = BoundingBoxes;
+			ExposedList<Polygon> polygons = Polygons;
+			ExposedList<Slot> slots = skeleton.slots;
 			int slotCount = slots.Count;
-			float x = skeleton.x, y = skeleton.y;
 
 			boundingBoxes.Clear();
-			foreach (Polygon polygon in polygons)
-				polygonPool.Add(polygon);
+			for (int i = 0, n = polygons.Count; i < n; i++)
+				polygonPool.Add(polygons.Items[i]);
 			polygons.Clear();
 
 			for (int i = 0; i < slotCount; i++) {
-				Slot slot = slots[i];
+				Slot slot = slots.Items[i];
 				BoundingBoxAttachment boundingBox = slot.attachment as BoundingBoxAttachment;
 				if (boundingBox == null) continue;
 				boundingBoxes.Add(boundingBox);
@@ -71,7 +71,7 @@ public void Update (Skeleton skeleton, bool updateAabb) {
 				Polygon polygon = null;
 				int poolCount = polygonPool.Count;
 				if (poolCount > 0) {
-					polygon = polygonPool[poolCount - 1];
+					polygon = polygonPool.Items[poolCount - 1];
 					polygonPool.RemoveAt(poolCount - 1);
 				} else
 					polygon = new Polygon();
@@ -80,7 +80,7 @@ public void Update (Skeleton skeleton, bool updateAabb) {
 				int count = boundingBox.Vertices.Length;
 				polygon.Count = count;
 				if (polygon.Vertices.Length < count) polygon.Vertices = new float[count];
-				boundingBox.ComputeWorldVertices(x, y, slot.bone, polygon.Vertices);
+				boundingBox.ComputeWorldVertices(slot.bone, polygon.Vertices);
 			}
 
 			if (updateAabb) aabbCompute();
@@ -88,9 +88,9 @@ public void Update (Skeleton skeleton, bool updateAabb) {
 
 		private void aabbCompute () {
 			float minX = int.MaxValue, minY = int.MaxValue, maxX = int.MinValue, maxY = int.MinValue;
-			List<Polygon> polygons = Polygons;
+			ExposedList<Polygon> polygons = Polygons;
 			for (int i = 0, n = polygons.Count; i < n; i++) {
-				Polygon polygon = polygons[i];
+				Polygon polygon = polygons.Items[i];
 				float[] vertices = polygon.Vertices;
 				for (int ii = 0, nn = polygon.Count; ii < nn; ii += 2) {
 					float x = vertices[ii];
@@ -160,18 +160,18 @@ public bool ContainsPoint (Polygon polygon, float x, float y) {
 		/// <summary>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.</summary>
 		public BoundingBoxAttachment ContainsPoint (float x, float y) {
-			List<Polygon> polygons = Polygons;
+			ExposedList<Polygon> polygons = Polygons;
 			for (int i = 0, n = polygons.Count; i < n; i++)
-				if (ContainsPoint(polygons[i], x, y)) return BoundingBoxes[i];
+				if (ContainsPoint(polygons.Items[i], x, y)) return BoundingBoxes.Items[i];
 			return null;
 		}
 
 		/// <summary>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.</summary>
 		public BoundingBoxAttachment IntersectsSegment (float x1, float y1, float x2, float y2) {
-			List<Polygon> polygons = Polygons;
+			ExposedList<Polygon> polygons = Polygons;
 			for (int i = 0, n = polygons.Count; i < n; i++)
-				if (IntersectsSegment(polygons[i], x1, y1, x2, y2)) return BoundingBoxes[i];
+				if (IntersectsSegment(polygons.Items[i], x1, y1, x2, y2)) return BoundingBoxes.Items[i];
 			return null;
 		}
 
@@ -201,7 +201,7 @@ public bool IntersectsSegment (Polygon polygon, float x1, float y1, float x2, fl
 
 		public Polygon getPolygon (BoundingBoxAttachment attachment) {
 			int index = BoundingBoxes.IndexOf(attachment);
-			return index == -1 ? null : Polygons[index];
+			return index == -1 ? null : Polygons.Items[index];
 		}
 	}
 
diff --git a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/SkeletonData.cs b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/SkeletonData.cs
old mode 100644
new mode 100755
index 60a5d53..5976a24
--- a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/SkeletonData.cs
+++ b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/SkeletonData.cs
@@ -1,25 +1,26 @@
 /******************************************************************************
  * Spine Runtimes Software License
- * Version 2.1
+ * Version 2.3
  * 
- * Copyright (c) 2013, Esoteric Software
+ * Copyright (c) 2013-2015, Esoteric Software
  * All rights reserved.
  * 
  * You are granted a perpetual, non-exclusive, non-sublicensable and
- * non-transferable license to install, execute and perform the Spine Runtimes
- * Software (the "Software") solely for internal use. Without the written
- * permission of Esoteric Software (typically granted by licensing Spine), you
- * may not (a) modify, translate, adapt or otherwise create derivative works,
- * improvements of the Software or develop new applications using the Software
- * or (b) remove, delete, alter or obscure any trademarks or any copyright,
- * trademark, patent or other intellectual property or proprietary rights
- * notices on or in the Software, including any copy thereof. Redistributions
- * in binary or source form must include this license and terms.
+ * non-transferable license to use, install, execute and perform the Spine
+ * Runtimes Software (the "Software") and derivative works solely for personal
+ * or internal use. Without the written permission of Esoteric Software (see
+ * Section 2 of the Spine Software License Agreement), you may not (a) modify,
+ * translate, adapt or otherwise create derivative works, improvements of the
+ * Software or develop new applications using the Software or (b) remove,
+ * delete, alter or obscure any trademarks or any copyright, trademark, patent
+ * or other intellectual property or proprietary rights notices on or in the
+ * Software, including any copy thereof. Redistributions in binary or source
+ * form must include this license and terms.
  * 
  * THIS SOFTWARE IS PROVIDED BY ESOTERIC SOFTWARE "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 SOFTARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * EVENT SHALL ESOTERIC SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
@@ -34,36 +35,39 @@
 namespace Spine {
 	public class SkeletonData {
 		internal String name;
-		internal List<BoneData> bones = new List<BoneData>();
-		internal List<SlotData> slots = new List<SlotData>();
-		internal List<Skin> skins = new List<Skin>();
+		internal ExposedList<BoneData> bones = new ExposedList<BoneData>();
+		internal ExposedList<SlotData> slots = new ExposedList<SlotData>();
+		internal ExposedList<Skin> skins = new ExposedList<Skin>();
 		internal Skin defaultSkin;
-		internal List<EventData> events = new List<EventData>();
-		internal List<Animation> animations = new List<Animation>();
+		internal ExposedList<EventData> events = new ExposedList<EventData>();
+		internal ExposedList<Animation> animations = new ExposedList<Animation>();
+		internal ExposedList<IkConstraintData> ikConstraints = new ExposedList<IkConstraintData>();
+		internal float width, height;
+		internal String version, hash, imagesPath;
 
 		public String Name { get { return name; } set { name = value; } }
-		public List<BoneData> Bones { get { return bones; } } // Ordered parents first.
-		public List<SlotData> Slots { get { return slots; } } // Setup pose draw order.
-		public List<Skin> Skins { get { return skins; } set { skins = value; } }
+		public ExposedList<BoneData> Bones { get { return bones; } } // Ordered parents first.
+		public ExposedList<SlotData> Slots { get { return slots; } } // Setup pose draw order.
+		public ExposedList<Skin> Skins { get { return skins; } set { skins = value; } }
 		/// <summary>May be null.</summary>
 		public Skin DefaultSkin { get { return defaultSkin; } set { defaultSkin = value; } }
-		public List<EventData> Events { get { return events; } set { events = value; } }
-		public List<Animation> Animations { get { return animations; } set { animations = value; } }
+		public ExposedList<EventData> Events { get { return events; } set { events = value; } }
+		public ExposedList<Animation> Animations { get { return animations; } set { animations = value; } }
+		public ExposedList<IkConstraintData> IkConstraints { get { return ikConstraints; } set { ikConstraints = value; } }
+		public float Width { get { return width; } set { width = value; } }
+		public float Height { get { return height; } set { height = value; } }
+		/// <summary>The Spine version used to export this data.</summary>
+		public String Version { get { return version; } set { version = value; } }
+		public String Hash { get { return hash; } set { hash = value; } }
 
 		// --- Bones.
 
-		public void AddBone (BoneData bone) {
-			if (bone == null) throw new ArgumentNullException("bone cannot be null.");
-			bones.Add(bone);
-		}
-
-
 		/// <returns>May be null.</returns>
 		public BoneData FindBone (String boneName) {
 			if (boneName == null) throw new ArgumentNullException("boneName cannot be null.");
-			List<BoneData> bones = this.bones;
+			ExposedList<BoneData> bones = this.bones;
 			for (int i = 0, n = bones.Count; i < n; i++) {
-				BoneData bone = bones[i];
+				BoneData bone = bones.Items[i];
 				if (bone.name == boneName) return bone;
 			}
 			return null;
@@ -72,25 +76,20 @@ public BoneData FindBone (String boneName) {
 		/// <returns>-1 if the bone was not found.</returns>
 		public int FindBoneIndex (String boneName) {
 			if (boneName == null) throw new ArgumentNullException("boneName cannot be null.");
-			List<BoneData> bones = this.bones;
+			ExposedList<BoneData> bones = this.bones;
 			for (int i = 0, n = bones.Count; i < n; i++)
-				if (bones[i].name == boneName) return i;
+				if (bones.Items[i].name == boneName) return i;
 			return -1;
 		}
 
 		// --- Slots.
 
-		public void AddSlot (SlotData slot) {
-			if (slot == null) throw new ArgumentNullException("slot cannot be null.");
-			slots.Add(slot);
-		}
-
 		/// <returns>May be null.</returns>
 		public SlotData FindSlot (String slotName) {
 			if (slotName == null) throw new ArgumentNullException("slotName cannot be null.");
-			List<SlotData> slots = this.slots;
+			ExposedList<SlotData> slots = this.slots;
 			for (int i = 0, n = slots.Count; i < n; i++) {
-				SlotData slot = slots[i];
+				SlotData slot = slots.Items[i];
 				if (slot.name == slotName) return slot;
 			}
 			return null;
@@ -99,19 +98,14 @@ public SlotData FindSlot (String slotName) {
 		/// <returns>-1 if the bone was not found.</returns>
 		public int FindSlotIndex (String slotName) {
 			if (slotName == null) throw new ArgumentNullException("slotName cannot be null.");
-			List<SlotData> slots = this.slots;
+			ExposedList<SlotData> slots = this.slots;
 			for (int i = 0, n = slots.Count; i < n; i++)
-				if (slots[i].name == slotName) return i;
+				if (slots.Items[i].name == slotName) return i;
 			return -1;
 		}
 
 		// --- Skins.
-
-		public void AddSkin (Skin skin) {
-			if (skin == null) throw new ArgumentNullException("skin cannot be null.");
-			skins.Add(skin);
-		}
-
+		
 		/// <returns>May be null.</returns>
 		public Skin FindSkin (String skinName) {
 			if (skinName == null) throw new ArgumentNullException("skinName cannot be null.");
@@ -122,33 +116,36 @@ public Skin FindSkin (String skinName) {
 
 		// --- Events.
 
-		public void AddEvent (EventData eventData) {
-			if (eventData == null) throw new ArgumentNullException("eventData cannot be null.");
-			events.Add(eventData);
-		}
-
 		/// <returns>May be null.</returns>
 		public EventData FindEvent (String eventDataName) {
 			if (eventDataName == null) throw new ArgumentNullException("eventDataName cannot be null.");
 			foreach (EventData eventData in events)
-				if (eventData.Name == eventDataName) return eventData;
+				if (eventData.name == eventDataName) return eventData;
 			return null;
 		}
 
 		// --- Animations.
-
-		public void AddAnimation (Animation animation) {
-			if (animation == null) throw new ArgumentNullException("animation cannot be null.");
-			animations.Add(animation);
-		}
-
+		
 		/// <returns>May be null.</returns>
 		public Animation FindAnimation (String animationName) {
 			if (animationName == null) throw new ArgumentNullException("animationName cannot be null.");
-			List<Animation> animations = this.animations;
+			ExposedList<Animation> animations = this.animations;
 			for (int i = 0, n = animations.Count; i < n; i++) {
-				Animation animation = animations[i];
-				if (animation.Name == animationName) return animation;
+				Animation animation = animations.Items[i];
+				if (animation.name == animationName) return animation;
+			}
+			return null;
+		}
+
+		// --- IK constraints.
+
+		/// <returns>May be null.</returns>
+		public IkConstraintData FindIkConstraint (String ikConstraintName) {
+			if (ikConstraintName == null) throw new ArgumentNullException("ikConstraintName cannot be null.");
+			ExposedList<IkConstraintData> ikConstraints = this.ikConstraints;
+			for (int i = 0, n = ikConstraints.Count; i < n; i++) {
+				IkConstraintData ikConstraint = ikConstraints.Items[i];
+				if (ikConstraint.name == ikConstraintName) return ikConstraint;
 			}
 			return null;
 		}
diff --git a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/SkeletonJson.cs b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/SkeletonJson.cs
old mode 100644
new mode 100755
index b9bd21d..bf31c04
--- a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/SkeletonJson.cs
+++ b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/SkeletonJson.cs
@@ -1,25 +1,26 @@
 /******************************************************************************
  * Spine Runtimes Software License
- * Version 2.1
+ * Version 2.3
  * 
- * Copyright (c) 2013, Esoteric Software
+ * Copyright (c) 2013-2015, Esoteric Software
  * All rights reserved.
  * 
  * You are granted a perpetual, non-exclusive, non-sublicensable and
- * non-transferable license to install, execute and perform the Spine Runtimes
- * Software (the "Software") solely for internal use. Without the written
- * permission of Esoteric Software (typically granted by licensing Spine), you
- * may not (a) modify, translate, adapt or otherwise create derivative works,
- * improvements of the Software or develop new applications using the Software
- * or (b) remove, delete, alter or obscure any trademarks or any copyright,
- * trademark, patent or other intellectual property or proprietary rights
- * notices on or in the Software, including any copy thereof. Redistributions
- * in binary or source form must include this license and terms.
+ * non-transferable license to use, install, execute and perform the Spine
+ * Runtimes Software (the "Software") and derivative works solely for personal
+ * or internal use. Without the written permission of Esoteric Software (see
+ * Section 2 of the Spine Software License Agreement), you may not (a) modify,
+ * translate, adapt or otherwise create derivative works, improvements of the
+ * Software or develop new applications using the Software or (b) remove,
+ * delete, alter or obscure any trademarks or any copyright, trademark, patent
+ * or other intellectual property or proprietary rights notices on or in the
+ * Software, including any copy thereof. Redistributions in binary or source
+ * form must include this license and terms.
  * 
  * THIS SOFTWARE IS PROVIDED BY ESOTERIC SOFTWARE "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 SOFTARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * EVENT SHALL ESOTERIC SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
@@ -42,8 +43,8 @@ public class SkeletonJson {
 		private AttachmentLoader attachmentLoader;
 		public float Scale { get; set; }
 
-		public SkeletonJson (Atlas atlas)
-			: this(new AtlasAttachmentLoader(atlas)) {
+		public SkeletonJson (params Atlas[] atlasArray)
+			: this(new AtlasAttachmentLoader(atlasArray)) {
 		}
 
 		public SkeletonJson (AttachmentLoader attachmentLoader) {
@@ -53,26 +54,29 @@ public SkeletonJson (AttachmentLoader attachmentLoader) {
 		}
 
 #if WINDOWS_STOREAPP
-        private async Task<SkeletonData> ReadFile(string path) {
-            var folder = Windows.ApplicationModel.Package.Current.InstalledLocation;
-            var file = await folder.GetFileAsync(path).AsTask().ConfigureAwait(false);
-            using (var reader = new StreamReader(await file.OpenStreamForReadAsync().ConfigureAwait(false))) {
-                SkeletonData skeletonData = ReadSkeletonData(reader);
-                skeletonData.Name = Path.GetFileNameWithoutExtension(path);
-                return skeletonData;
-            }
-        }
+		private async Task<SkeletonData> ReadFile(string path) {
+			var folder = Windows.ApplicationModel.Package.Current.InstalledLocation;
+			var file = await folder.GetFileAsync(path).AsTask().ConfigureAwait(false);
+			using (var reader = new StreamReader(await file.OpenStreamForReadAsync().ConfigureAwait(false))) {
+				SkeletonData skeletonData = ReadSkeletonData(reader);
+				skeletonData.Name = Path.GetFileNameWithoutExtension(path);
+				return skeletonData;
+			}
+		}
 
 		public SkeletonData ReadSkeletonData (String path) {
-		    return this.ReadFile(path).Result;
+			return this.ReadFile(path).Result;
 		}
 #else
 		public SkeletonData ReadSkeletonData (String path) {
-            Stream stream = Microsoft.Xna.Framework.TitleContainer.OpenStream(path);
-            using (StreamReader reader = new StreamReader(stream))
-            {
+#if WINDOWS_PHONE
+			Stream stream = Microsoft.Xna.Framework.TitleContainer.OpenStream(path);
+			using (StreamReader reader = new StreamReader(stream)) {
+#else
+			using (StreamReader reader = new StreamReader(path)) {
+#endif
 				SkeletonData skeletonData = ReadSkeletonData(reader);
-				//skeletonData.name = Path.GetFileNameWithoutExtension(path);
+				skeletonData.name = Path.GetFileNameWithoutExtension(path);
 				return skeletonData;
 			}
 		}
@@ -86,6 +90,15 @@ public SkeletonData ReadSkeletonData (TextReader reader) {
 			var root = Json.Deserialize(reader) as Dictionary<String, Object>;
 			if (root == null) throw new Exception("Invalid JSON.");
 
+			// Skeleton.
+			if (root.ContainsKey("skeleton")) {
+				var skeletonMap = (Dictionary<String, Object>)root["skeleton"];
+				skeletonData.hash = (String)skeletonMap["hash"];
+				skeletonData.version = (String)skeletonMap["spine"];
+				skeletonData.width = GetFloat(skeletonMap, "width", 0);
+				skeletonData.height = GetFloat(skeletonMap, "height", 0);
+			}
+
 			// Bones.
 			foreach (Dictionary<String, Object> boneMap in (List<Object>)root["bones"]) {
 				BoneData parent = null;
@@ -101,9 +114,33 @@ public SkeletonData ReadSkeletonData (TextReader reader) {
 				boneData.rotation = GetFloat(boneMap, "rotation", 0);
 				boneData.scaleX = GetFloat(boneMap, "scaleX", 1);
 				boneData.scaleY = GetFloat(boneMap, "scaleY", 1);
+				boneData.flipX = GetBoolean(boneMap, "flipX", false);
+				boneData.flipY = GetBoolean(boneMap, "flipY", false);
 				boneData.inheritScale = GetBoolean(boneMap, "inheritScale", true);
 				boneData.inheritRotation = GetBoolean(boneMap, "inheritRotation", true);
-				skeletonData.AddBone(boneData);
+				skeletonData.bones.Add(boneData);
+			}
+
+			// IK constraints.
+			if (root.ContainsKey("ik")) {
+				foreach (Dictionary<String, Object> ikMap in (List<Object>)root["ik"]) {
+					IkConstraintData ikConstraintData = new IkConstraintData((String)ikMap["name"]);
+
+					foreach (String boneName in (List<Object>)ikMap["bones"]) {
+						BoneData bone = skeletonData.FindBone(boneName);
+						if (bone == null) throw new Exception("IK bone not found: " + boneName);
+						ikConstraintData.bones.Add(bone);
+					}
+
+					String targetName = (String)ikMap["target"];
+					ikConstraintData.target = skeletonData.FindBone(targetName);
+					if (ikConstraintData.target == null) throw new Exception("Target bone not found: " + targetName);
+
+					ikConstraintData.bendDirection = GetBoolean(ikMap, "bendPositive", true) ? 1 : -1;
+					ikConstraintData.mix = GetFloat(ikMap, "mix", 1);
+
+					skeletonData.ikConstraints.Add(ikConstraintData);
+				}
 			}
 
 			// Slots.
@@ -127,10 +164,12 @@ public SkeletonData ReadSkeletonData (TextReader reader) {
 					if (slotMap.ContainsKey("attachment"))
 						slotData.attachmentName = (String)slotMap["attachment"];
 
-					if (slotMap.ContainsKey("additive"))
-						slotData.additiveBlending = (bool)slotMap["additive"];
+					if (slotMap.ContainsKey("blend"))
+						slotData.blendMode = (BlendMode)Enum.Parse(typeof(BlendMode), (String)slotMap["blend"], false);
+					else
+						slotData.blendMode = BlendMode.normal;
 
-					skeletonData.AddSlot(slotData);
+					skeletonData.slots.Add(slotData);
 				}
 			}
 
@@ -145,7 +184,7 @@ public SkeletonData ReadSkeletonData (TextReader reader) {
 							if (attachment != null) skin.AddAttachment(slotIndex, attachmentEntry.Key, attachment);
 						}
 					}
-					skeletonData.AddSkin(skin);
+					skeletonData.skins.Add(skin);
 					if (skin.name == "default")
 						skeletonData.defaultSkin = skin;
 				}
@@ -159,7 +198,7 @@ public SkeletonData ReadSkeletonData (TextReader reader) {
 					eventData.Int = GetInt(entryMap, "int", 0);
 					eventData.Float = GetFloat(entryMap, "float", 0);
 					eventData.String = GetString(entryMap, "string", null);
-					skeletonData.AddEvent(eventData);
+					skeletonData.events.Add(eventData);
 				}
 			}
 
@@ -172,7 +211,9 @@ public SkeletonData ReadSkeletonData (TextReader reader) {
 			skeletonData.bones.TrimExcess();
 			skeletonData.slots.TrimExcess();
 			skeletonData.skins.TrimExcess();
+			skeletonData.events.TrimExcess();
 			skeletonData.animations.TrimExcess();
+			skeletonData.ikConstraints.TrimExcess();
 			return skeletonData;
 		}
 
@@ -332,14 +373,14 @@ private String GetString (Dictionary<String, Object> map, String name, String de
 			return (String)map[name];
 		}
 
-		public static float ToColor (String hexString, int colorIndex) {
+		private float ToColor (String hexString, int colorIndex) {
 			if (hexString.Length != 8)
 				throw new ArgumentException("Color hexidecimal length must be 8, recieved: " + hexString);
 			return Convert.ToInt32(hexString.Substring(colorIndex * 2, 2), 16) / (float)255;
 		}
 
 		private void ReadAnimation (String name, Dictionary<String, Object> map, SkeletonData skeletonData) {
-			var timelines = new List<Timeline>();
+			var timelines = new ExposedList<Timeline>();
 			float duration = 0;
 			float scale = Scale;
 
@@ -352,7 +393,7 @@ private void ReadAnimation (String name, Dictionary<String, Object> map, Skeleto
 					foreach (KeyValuePair<String, Object> timelineEntry in timelineMap) {
 						var values = (List<Object>)timelineEntry.Value;
 						var timelineName = (String)timelineEntry.Key;
-						if (timelineName.Equals("color")) {
+						if (timelineName == "color") {
 							var timeline = new ColorTimeline(values.Count);
 							timeline.slotIndex = slotIndex;
 
@@ -360,21 +401,21 @@ private void ReadAnimation (String name, Dictionary<String, Object> map, Skeleto
 							foreach (Dictionary<String, Object> valueMap in values) {
 								float time = (float)valueMap["time"];
 								String c = (String)valueMap["color"];
-								timeline.setFrame(frameIndex, time, ToColor(c, 0), ToColor(c, 1), ToColor(c, 2), ToColor(c, 3));
+								timeline.SetFrame(frameIndex, time, ToColor(c, 0), ToColor(c, 1), ToColor(c, 2), ToColor(c, 3));
 								ReadCurve(timeline, frameIndex, valueMap);
 								frameIndex++;
 							}
 							timelines.Add(timeline);
 							duration = Math.Max(duration, timeline.frames[timeline.FrameCount * 5 - 5]);
 
-						} else if (timelineName.Equals("attachment")) {
+						} else if (timelineName == "attachment") {
 							var timeline = new AttachmentTimeline(values.Count);
 							timeline.slotIndex = slotIndex;
 
 							int frameIndex = 0;
 							foreach (Dictionary<String, Object> valueMap in values) {
 								float time = (float)valueMap["time"];
-								timeline.setFrame(frameIndex++, time, (String)valueMap["name"]);
+								timeline.SetFrame(frameIndex++, time, (String)valueMap["name"]);
 							}
 							timelines.Add(timeline);
 							duration = Math.Max(duration, timeline.frames[timeline.FrameCount - 1]);
@@ -396,7 +437,7 @@ private void ReadAnimation (String name, Dictionary<String, Object> map, Skeleto
 					foreach (KeyValuePair<String, Object> timelineEntry in timelineMap) {
 						var values = (List<Object>)timelineEntry.Value;
 						var timelineName = (String)timelineEntry.Key;
-						if (timelineName.Equals("rotate")) {
+						if (timelineName == "rotate") {
 							var timeline = new RotateTimeline(values.Count);
 							timeline.boneIndex = boneIndex;
 
@@ -410,10 +451,10 @@ private void ReadAnimation (String name, Dictionary<String, Object> map, Skeleto
 							timelines.Add(timeline);
 							duration = Math.Max(duration, timeline.frames[timeline.FrameCount * 2 - 2]);
 
-						} else if (timelineName.Equals("translate") || timelineName.Equals("scale")) {
+						} else if (timelineName == "translate" || timelineName == "scale") {
 							TranslateTimeline timeline;
 							float timelineScale = 1;
-							if (timelineName.Equals("scale"))
+							if (timelineName == "scale")
 								timeline = new ScaleTimeline(values.Count);
 							else {
 								timeline = new TranslateTimeline(values.Count);
@@ -433,12 +474,47 @@ private void ReadAnimation (String name, Dictionary<String, Object> map, Skeleto
 							timelines.Add(timeline);
 							duration = Math.Max(duration, timeline.frames[timeline.FrameCount * 3 - 3]);
 
+						} else if (timelineName == "flipX" || timelineName == "flipY") {
+							bool x = timelineName == "flipX";
+							var timeline = x ? new FlipXTimeline(values.Count) : new FlipYTimeline(values.Count);
+							timeline.boneIndex = boneIndex;
+
+							String field = x ? "x" : "y";
+							int frameIndex = 0;
+							foreach (Dictionary<String, Object> valueMap in values) {
+								float time = (float)valueMap["time"];
+								timeline.SetFrame(frameIndex, time, valueMap.ContainsKey(field) ? (bool)valueMap[field] : false);
+								frameIndex++;
+							}
+							timelines.Add(timeline);
+							duration = Math.Max(duration, timeline.frames[timeline.FrameCount * 2 - 2]);
+
 						} else
 							throw new Exception("Invalid timeline type for a bone: " + timelineName + " (" + boneName + ")");
 					}
 				}
 			}
 
+			if (map.ContainsKey("ik")) {
+				foreach (KeyValuePair<String, Object> ikMap in (Dictionary<String, Object>)map["ik"]) {
+					IkConstraintData ikConstraint = skeletonData.FindIkConstraint(ikMap.Key);
+					var values = (List<Object>)ikMap.Value;
+					var timeline = new IkConstraintTimeline(values.Count);
+					timeline.ikConstraintIndex = skeletonData.ikConstraints.IndexOf(ikConstraint);
+					int frameIndex = 0;
+					foreach (Dictionary<String, Object> valueMap in values) {
+						float time = (float)valueMap["time"];
+						float mix = valueMap.ContainsKey("mix") ? (float)valueMap["mix"] : 1;
+						bool bendPositive = valueMap.ContainsKey("bendPositive") ? (bool)valueMap["bendPositive"] : true;
+						timeline.SetFrame(frameIndex, time, mix, bendPositive ? 1 : -1);
+						ReadCurve(timeline, frameIndex, valueMap);
+						frameIndex++;
+					}
+					timelines.Add(timeline);
+					duration = Math.Max(duration, timeline.frames[timeline.FrameCount * 3 - 3]);
+				}
+			}
+
 			if (map.ContainsKey("ffd")) {
 				foreach (KeyValuePair<String, Object> ffdMap in (Dictionary<String, Object>)map["ffd"]) {
 					Skin skin = skeletonData.FindSkin(ffdMap.Key);
@@ -479,12 +555,12 @@ private void ReadAnimation (String name, Dictionary<String, Object> map, Skeleto
 									}
 									if (attachment is MeshAttachment) {
 										float[] meshVertices = ((MeshAttachment)attachment).vertices;
-										for (int i = 0, n = vertices.Length; i < n; i++)
+										for (int i = 0; i < vertexCount; i++)
 											vertices[i] += meshVertices[i];
 									}
 								}
 
-								timeline.setFrame(frameIndex, (float)valueMap["time"], vertices);
+								timeline.SetFrame(frameIndex, (float)valueMap["time"], vertices);
 								ReadCurve(timeline, frameIndex, valueMap);
 								frameIndex++;
 							}
@@ -495,8 +571,8 @@ private void ReadAnimation (String name, Dictionary<String, Object> map, Skeleto
 				}
 			}
 
-			if (map.ContainsKey("draworder")) {
-				var values = (List<Object>)map["draworder"];
+			if (map.ContainsKey("drawOrder") || map.ContainsKey("draworder")) {
+				var values = (List<Object>)map[map.ContainsKey("drawOrder") ? "drawOrder" : "draworder"];
 				var timeline = new DrawOrderTimeline(values.Count);
 				int slotCount = skeletonData.slots.Count;
 				int frameIndex = 0;
@@ -516,7 +592,8 @@ private void ReadAnimation (String name, Dictionary<String, Object> map, Skeleto
 							while (originalIndex != slotIndex)
 								unchanged[unchangedIndex++] = originalIndex++;
 							// Set changed items.
-							drawOrder[originalIndex + (int)(float)offsetMap["offset"]] = originalIndex++;
+							int index = originalIndex + (int)(float)offsetMap["offset"];
+							drawOrder[index] = originalIndex++;
 						}
 						// Collect remaining unchanged items.
 						while (originalIndex < slotCount)
@@ -525,7 +602,7 @@ private void ReadAnimation (String name, Dictionary<String, Object> map, Skeleto
 						for (int i = slotCount - 1; i >= 0; i--)
 							if (drawOrder[i] == -1) drawOrder[i] = unchanged[--unchangedIndex];
 					}
-					timeline.setFrame(frameIndex++, (float)drawOrderMap["time"], drawOrder);
+					timeline.SetFrame(frameIndex++, (float)drawOrderMap["time"], drawOrder);
 				}
 				timelines.Add(timeline);
 				duration = Math.Max(duration, timeline.frames[timeline.FrameCount - 1]);
@@ -542,14 +619,14 @@ private void ReadAnimation (String name, Dictionary<String, Object> map, Skeleto
 					e.Int = GetInt(eventMap, "int", eventData.Int);
 					e.Float = GetFloat(eventMap, "float", eventData.Float);
 					e.String = GetString(eventMap, "string", eventData.String);
-					timeline.setFrame(frameIndex++, (float)eventMap["time"], e);
+					timeline.SetFrame(frameIndex++, (float)eventMap["time"], e);
 				}
 				timelines.Add(timeline);
 				duration = Math.Max(duration, timeline.frames[timeline.FrameCount - 1]);
 			}
 
 			timelines.TrimExcess();
-			skeletonData.AddAnimation(new Animation(name, timelines, duration));
+			skeletonData.animations.Add(new Animation(name, timelines, duration));
 		}
 
 		private void ReadCurve (CurveTimeline timeline, int frameIndex, Dictionary<String, Object> valueMap) {
diff --git a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Skin.cs b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Skin.cs
old mode 100644
new mode 100755
index e8e68d3..4b84083
--- a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Skin.cs
+++ b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Skin.cs
@@ -1,25 +1,26 @@
 /******************************************************************************
  * Spine Runtimes Software License
- * Version 2.1
+ * Version 2.3
  * 
- * Copyright (c) 2013, Esoteric Software
+ * Copyright (c) 2013-2015, Esoteric Software
  * All rights reserved.
  * 
  * You are granted a perpetual, non-exclusive, non-sublicensable and
- * non-transferable license to install, execute and perform the Spine Runtimes
- * Software (the "Software") solely for internal use. Without the written
- * permission of Esoteric Software (typically granted by licensing Spine), you
- * may not (a) modify, translate, adapt or otherwise create derivative works,
- * improvements of the Software or develop new applications using the Software
- * or (b) remove, delete, alter or obscure any trademarks or any copyright,
- * trademark, patent or other intellectual property or proprietary rights
- * notices on or in the Software, including any copy thereof. Redistributions
- * in binary or source form must include this license and terms.
+ * non-transferable license to use, install, execute and perform the Spine
+ * Runtimes Software (the "Software") and derivative works solely for personal
+ * or internal use. Without the written permission of Esoteric Software (see
+ * Section 2 of the Spine Software License Agreement), you may not (a) modify,
+ * translate, adapt or otherwise create derivative works, improvements of the
+ * Software or develop new applications using the Software or (b) remove,
+ * delete, alter or obscure any trademarks or any copyright, trademark, patent
+ * or other intellectual property or proprietary rights notices on or in the
+ * Software, including any copy thereof. Redistributions in binary or source
+ * form must include this license and terms.
  * 
  * THIS SOFTWARE IS PROVIDED BY ESOTERIC SOFTWARE "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 SOFTARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * EVENT SHALL ESOTERIC SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
@@ -35,8 +36,8 @@ namespace Spine {
 	/// <summary>Stores attachments by slot index and attachment name.</summary>
 	public class Skin {
 		internal String name;
-		private Dictionary<KeyValuePair<int, String>, Attachment> attachments =
-			new Dictionary<KeyValuePair<int, String>, Attachment>(AttachmentComparer.Instance);
+		private Dictionary<AttachmentKeyTuple, Attachment> attachments =
+			new Dictionary<AttachmentKeyTuple, Attachment>(AttachmentKeyTupleComparer.Instance);
 
 		public String Name { get { return name; } }
 
@@ -47,26 +48,26 @@ public Skin (String name) {
 
 		public void AddAttachment (int slotIndex, String name, Attachment attachment) {
 			if (attachment == null) throw new ArgumentNullException("attachment cannot be null.");
-			attachments[new KeyValuePair<int, String>(slotIndex, name)] = attachment;
+			attachments[new AttachmentKeyTuple(slotIndex, name)] = attachment;
 		}
 
 		/// <returns>May be null.</returns>
 		public Attachment GetAttachment (int slotIndex, String name) {
 			Attachment attachment;
-			attachments.TryGetValue(new KeyValuePair<int, String>(slotIndex, name), out attachment);
+			attachments.TryGetValue(new AttachmentKeyTuple(slotIndex, name), out attachment);
 			return attachment;
 		}
 
 		public void FindNamesForSlot (int slotIndex, List<String> names) {
 			if (names == null) throw new ArgumentNullException("names cannot be null.");
-			foreach (KeyValuePair<int, String> key in attachments.Keys)
-				if (key.Key == slotIndex) names.Add(key.Value);
+			foreach (AttachmentKeyTuple key in attachments.Keys)
+				if (key.SlotIndex == slotIndex) names.Add(key.Name);
 		}
 
 		public void FindAttachmentsForSlot (int slotIndex, List<Attachment> attachments) {
 			if (attachments == null) throw new ArgumentNullException("attachments cannot be null.");
-			foreach (KeyValuePair<KeyValuePair<int, String>, Attachment> entry in this.attachments)
-				if (entry.Key.Key == slotIndex) attachments.Add(entry.Value);
+			foreach (KeyValuePair<AttachmentKeyTuple, Attachment> entry in this.attachments)
+				if (entry.Key.SlotIndex == slotIndex) attachments.Add(entry.Value);
 		}
 
 		override public String ToString () {
@@ -75,27 +76,39 @@ override public String ToString () {
 
 		/// <summary>Attach all attachments from this skin if the corresponding attachment from the old skin is currently attached.</summary>
 		internal void AttachAll (Skeleton skeleton, Skin oldSkin) {
-			foreach (KeyValuePair<KeyValuePair<int, String>, Attachment> entry in oldSkin.attachments) {
-				int slotIndex = entry.Key.Key;
-				Slot slot = skeleton.slots[slotIndex];
+			foreach (KeyValuePair<AttachmentKeyTuple, Attachment> entry in oldSkin.attachments) {
+				int slotIndex = entry.Key.SlotIndex;
+				Slot slot = skeleton.slots.Items[slotIndex];
 				if (slot.attachment == entry.Value) {
-					Attachment attachment = GetAttachment(slotIndex, entry.Key.Value);
+					Attachment attachment = GetAttachment(slotIndex, entry.Key.Name);
 					if (attachment != null) slot.Attachment = attachment;
 				}
 			}
 		}
 
 		// Avoids boxing in the dictionary.
-		private class AttachmentComparer : IEqualityComparer<KeyValuePair<int, String>> {
-			internal static readonly AttachmentComparer Instance = new AttachmentComparer();
+		private class AttachmentKeyTupleComparer : IEqualityComparer<AttachmentKeyTuple> {
+			internal static readonly AttachmentKeyTupleComparer Instance = new AttachmentKeyTupleComparer();
 
-			bool IEqualityComparer<KeyValuePair<int, string>>.Equals (KeyValuePair<int, string> o1, KeyValuePair<int, string> o2) {
-				return o1.Key == o2.Key && o1.Value == o2.Value;
+			bool IEqualityComparer<AttachmentKeyTuple>.Equals (AttachmentKeyTuple o1, AttachmentKeyTuple o2) {
+			    return o1.SlotIndex == o2.SlotIndex && o1.NameHashCode == o2.NameHashCode && o1.Name == o2.Name;
 			}
 
-			int IEqualityComparer<KeyValuePair<int, string>>.GetHashCode (KeyValuePair<int, string> o) {
-				return o.Key;
+			int IEqualityComparer<AttachmentKeyTuple>.GetHashCode (AttachmentKeyTuple o) {
+				return o.SlotIndex;
 			}
 		}
+
+        private class AttachmentKeyTuple {
+            public readonly int SlotIndex;
+            public readonly string Name;
+            public readonly int NameHashCode;
+
+            public AttachmentKeyTuple(int slotIndex, string name) {
+                SlotIndex = slotIndex;
+                Name = name;
+                NameHashCode = Name.GetHashCode();
+            }
+        }
 	}
 }
diff --git a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Slot.cs b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Slot.cs
old mode 100644
new mode 100755
index e7a323a..e8d393b
--- a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Slot.cs
+++ b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/Slot.cs
@@ -1,25 +1,26 @@
 /******************************************************************************
  * Spine Runtimes Software License
- * Version 2.1
+ * Version 2.3
  * 
- * Copyright (c) 2013, Esoteric Software
+ * Copyright (c) 2013-2015, Esoteric Software
  * All rights reserved.
  * 
  * You are granted a perpetual, non-exclusive, non-sublicensable and
- * non-transferable license to install, execute and perform the Spine Runtimes
- * Software (the "Software") solely for internal use. Without the written
- * permission of Esoteric Software (typically granted by licensing Spine), you
- * may not (a) modify, translate, adapt or otherwise create derivative works,
- * improvements of the Software or develop new applications using the Software
- * or (b) remove, delete, alter or obscure any trademarks or any copyright,
- * trademark, patent or other intellectual property or proprietary rights
- * notices on or in the Software, including any copy thereof. Redistributions
- * in binary or source form must include this license and terms.
+ * non-transferable license to use, install, execute and perform the Spine
+ * Runtimes Software (the "Software") and derivative works solely for personal
+ * or internal use. Without the written permission of Esoteric Software (see
+ * Section 2 of the Spine Software License Agreement), you may not (a) modify,
+ * translate, adapt or otherwise create derivative works, improvements of the
+ * Software or develop new applications using the Software or (b) remove,
+ * delete, alter or obscure any trademarks or any copyright, trademark, patent
+ * or other intellectual property or proprietary rights notices on or in the
+ * Software, including any copy thereof. Redistributions in binary or source
+ * form must include this license and terms.
  * 
  * THIS SOFTWARE IS PROVIDED BY ESOTERIC SOFTWARE "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 SOFTARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * EVENT SHALL ESOTERIC SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
@@ -34,16 +35,15 @@ namespace Spine {
 	public class Slot {
 		internal SlotData data;
 		internal Bone bone;
-		internal Skeleton skeleton;
 		internal float r, g, b, a;
-		internal float attachmentTime;
 		internal Attachment attachment;
+		internal float attachmentTime;
 		internal float[] attachmentVertices = new float[0];
 		internal int attachmentVerticesCount;
 
 		public SlotData Data { get { return data; } }
 		public Bone Bone { get { return bone; } }
-		public Skeleton Skeleton { get { return skeleton; } }
+		public Skeleton Skeleton { get { return bone.skeleton; } }
 		public float R { get { return r; } set { r = value; } }
 		public float G { get { return g; } set { g = value; } }
 		public float B { get { return b; } set { b = value; } }
@@ -56,29 +56,27 @@ public Attachment Attachment {
 			}
 			set {
 				attachment = value;
-				attachmentTime = skeleton.time;
+				attachmentTime = bone.skeleton.time;
 				attachmentVerticesCount = 0;
 			}
 		}
 
 		public float AttachmentTime {
 			get {
-				return skeleton.time - attachmentTime;
+				return bone.skeleton.time - attachmentTime;
 			}
 			set {
-				attachmentTime = skeleton.time - value;
+				attachmentTime = bone.skeleton.time - value;
 			}
 		}
 
 		public float[] AttachmentVertices { get { return attachmentVertices; } set { attachmentVertices = value; } }
 		public int AttachmentVerticesCount { get { return attachmentVerticesCount; } set { attachmentVerticesCount = value; } }
 
-		public Slot (SlotData data, Skeleton skeleton, Bone bone) {
+		public Slot (SlotData data, Bone bone) {
 			if (data == null) throw new ArgumentNullException("data cannot be null.");
-			if (skeleton == null) throw new ArgumentNullException("skeleton cannot be null.");
 			if (bone == null) throw new ArgumentNullException("bone cannot be null.");
 			this.data = data;
-			this.skeleton = skeleton;
 			this.bone = bone;
 			SetToSetupPose();
 		}
@@ -88,12 +86,11 @@ internal void SetToSetupPose (int slotIndex) {
 			g = data.g;
 			b = data.b;
 			a = data.a;
-			Attachment = data.attachmentName == null ? null : skeleton.GetAttachment(slotIndex, data.attachmentName);
-			attachmentVerticesCount = 0;
+			Attachment = data.attachmentName == null ? null : bone.skeleton.GetAttachment(slotIndex, data.attachmentName);
 		}
 
 		public void SetToSetupPose () {
-			SetToSetupPose(skeleton.data.slots.IndexOf(data));
+			SetToSetupPose(bone.skeleton.data.slots.IndexOf(data));
 		}
 
 		override public String ToString () {
diff --git a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/SlotData.cs b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/SlotData.cs
old mode 100644
new mode 100755
index dd74f4f..1a0e072
--- a/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/SlotData.cs
+++ b/Spine/src/SpineCocosSharp/SpineCocosSharp/spine-csharp/src/SlotData.cs
@@ -1,25 +1,26 @@
 /******************************************************************************
  * Spine Runtimes Software License
- * Version 2.1
+ * Version 2.3
  * 
- * Copyright (c) 2013, Esoteric Software
+ * Copyright (c) 2013-2015, Esoteric Software
  * All rights reserved.
  * 
  * You are granted a perpetual, non-exclusive, non-sublicensable and
- * non-transferable license to install, execute and perform the Spine Runtimes
- * Software (the "Software") solely for internal use. Without the written
- * permission of Esoteric Software (typically granted by licensing Spine), you
- * may not (a) modify, translate, adapt or otherwise create derivative works,
- * improvements of the Software or develop new applications using the Software
- * or (b) remove, delete, alter or obscure any trademarks or any copyright,
- * trademark, patent or other intellectual property or proprietary rights
- * notices on or in the Software, including any copy thereof. Redistributions
- * in binary or source form must include this license and terms.
+ * non-transferable license to use, install, execute and perform the Spine
+ * Runtimes Software (the "Software") and derivative works solely for personal
+ * or internal use. Without the written permission of Esoteric Software (see
+ * Section 2 of the Spine Software License Agreement), you may not (a) modify,
+ * translate, adapt or otherwise create derivative works, improvements of the
+ * Software or develop new applications using the Software or (b) remove,
+ * delete, alter or obscure any trademarks or any copyright, trademark, patent
+ * or other intellectual property or proprietary rights notices on or in the
+ * Software, including any copy thereof. Redistributions in binary or source
+ * form must include this license and terms.
  * 
  * THIS SOFTWARE IS PROVIDED BY ESOTERIC SOFTWARE "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 SOFTARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * EVENT SHALL ESOTERIC SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
@@ -36,7 +37,7 @@ public class SlotData {
 		internal BoneData boneData;
 		internal float r = 1, g = 1, b = 1, a = 1;
 		internal String attachmentName;
-		internal bool additiveBlending;
+		internal BlendMode blendMode;
 
 		public String Name { get { return name; } }
 		public BoneData BoneData { get { return boneData; } }
@@ -46,7 +47,7 @@ public class SlotData {
 		public float A { get { return a; } set { a = value; } }
 		/// <summary>May be null.</summary>
 		public String AttachmentName { get { return attachmentName; } set { attachmentName = value; } }
-		public bool AdditiveBlending { get { return additiveBlending; } set { additiveBlending = value; } }
+		public BlendMode BlendMode { get { return blendMode; } set { blendMode = value; } }
 
 		public SlotData (String name, BoneData boneData) {
 			if (name == null) throw new ArgumentNullException("name cannot be null.");