Attachment that has a polygon for bounds checking.
Inheritance: VertexAttachment
Esempio n. 1
0
    public static void ShowBounding(Spine.Slot boundingSlot, Transform transform, LineRenderer lineRender)
    {
        Spine.BoundingBoxAttachment bounding = boundingSlot.Attachment as Spine.BoundingBoxAttachment;
        float[] vertices = bounding.Vertices;

        int n = vertices.Length / 2;

        lineRender.SetVertexCount(n);
        for (int i = 0; i < n; ++i)
        {
            float localX = vertices[i * 2 + 0];
            float localY = vertices[i * 2 + 1];
            float worldX;
            float worldY;
            boundingSlot.Bone.localToWorld(localX, localY, out worldX, out worldY);

//			Vector3 p = new Vector3(worldX, worldY, 0);
//			p = transform.TransformPoint(p);

            lineRender.SetPosition(i, new Vector3(worldX, worldY, -1));
        }

        lineRender.transform.position   = transform.position;
        lineRender.transform.rotation   = transform.rotation;
        lineRender.transform.localScale = transform.localScale;
    }
		public static PolygonCollider2D AddBoundingBoxAsComponent (BoundingBoxAttachment box, Slot slot, GameObject gameObject, bool isTrigger = true) {
			if (box == null) return null;
			var collider = gameObject.AddComponent<PolygonCollider2D>();
			collider.isTrigger = isTrigger;
			SetColliderPointsLocal(collider, slot, box);
			return collider;
		}
Esempio n. 3
0
    public static bool IsPointInsideBounding(Vector3 worldPoint, Spine.Slot boundingSlot, Transform transform)
    {
        worldPoint = transform.InverseTransformPoint(worldPoint);
        float mx;
        float my;

        boundingSlot.Bone.worldToLocal(worldPoint.x, worldPoint.y, out mx, out my);

        Spine.BoundingBoxAttachment bounding = boundingSlot.Attachment as Spine.BoundingBoxAttachment;
        float[] vertices = (float[])bounding.Vertices.Clone();

        /*
         * Vector3 p = new Vector3 ();
         *
         * int n = vertices.Length / 2;
         * for(int i = 0; i < n; ++i)
         * {
         *      float localX = vertices[i * 2 + 0];
         *      float localY = vertices[i * 2 + 1];
         *      float worldX;
         *      float worldY;
         *      boundingSlot.Bone.localToWorld(localX, localY, out worldX, out worldY);
         *
         *      p.Set(worldX, worldY, 0);
         *      p = transform.TransformPoint(p);
         *
         *      vertices[i * 2 + 0] = p.x;
         *      vertices[i * 2 + 1] = p.y;
         * }
         */

        bool inside = GeometryHelper.IsPointInsidePolygon(mx, my, vertices);

        return(inside);
    }
		public static PolygonCollider2D AddBoundingBoxGameObject (string name, BoundingBoxAttachment box, Slot slot, Transform parent, bool isTrigger = true) {
			var go = new GameObject("[BoundingBox]" + (string.IsNullOrEmpty(name) ? box.Name : name));
			var got = go.transform;
			got.parent = parent;
			got.localPosition = Vector3.zero;
			got.localRotation = Quaternion.identity;
			got.localScale = Vector3.one;
			return AddBoundingBoxAsComponent(box, slot, go, isTrigger);
		}
Esempio n. 5
0
    public static Vector3 CalcTileArrowOffset(Spine.Slot boundingSlot, Transform transform, float rotation,
                                              float innerRate = 0.7f)
    {
        float   radius = AngleHelper.AngleToRadius(rotation - 90);
        Vector3 v      = new Vector3(Mathf.Cos(radius), Mathf.Sin(radius)) * 10000;

        Spine.BoundingBoxAttachment bounding = boundingSlot.Attachment as Spine.BoundingBoxAttachment;
        float[] vertices = (float[])bounding.Vertices.Clone();

        Vector2 p1 = new Vector2();
        Vector2 p2 = new Vector2();

        int n = vertices.Length / 2;

        for (int i = 0; i <= n; ++i)
        {
            int   m      = i % n;
            float localX = vertices[m * 2 + 0];
            float localY = vertices[m * 2 + 1];
            p2.Set(localX, localY);

            if (i >= 1)
            {
                float   intersectDist;
                Vector2 intersectPoint;
                if (GeometryHelper.CalcIntersectPoint(Vector2.zero, v, p1, p2, out intersectPoint, out intersectDist))
                {
                    intersectPoint *= innerRate;

                    float worldX;
                    float worldY;
                    boundingSlot.Bone.localToWorld(intersectPoint.x, intersectPoint.y, out worldX, out worldY);

                    Vector3 offset = new Vector3(worldX, worldY, 0);
                    offset = transform.TransformPoint(offset);
                    return(offset);
                }
            }

            p1 = p2;
        }

        Vector3 boneCenter = new Vector3(boundingSlot.Bone.WorldX, boundingSlot.Bone.WorldY, 0);

        boneCenter = transform.TransformPoint(boneCenter);
        return(boneCenter);
    }
Esempio n. 6
0
        /// <summary>
        /// Clears any previous polygons, finds all visible bounding box attachments,
        /// and computes the world vertices for each bounding box's polygon.</summary>
        /// <param name="skeleton">The skeleton.</param>
        /// <param name="updateAabb">
        /// If true, the axis aligned bounding box containing all the polygons is computed.
        /// If false, the SkeletonBounds AABB methods will always return true.
        /// </param>
        public void Update(Skeleton skeleton, bool updateAabb)
        {
            ExposedList <BoundingBoxAttachment> boundingBoxes = BoundingBoxes;
            ExposedList <Polygon> polygons = Polygons;
            ExposedList <Slot>    slots    = skeleton.slots;
            int slotCount = slots.Count;

            boundingBoxes.Clear();
            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.Items[i];
                if (!slot.bone.active)
                {
                    continue;
                }
                BoundingBoxAttachment boundingBox = slot.attachment as BoundingBoxAttachment;
                if (boundingBox == null)
                {
                    continue;
                }
                boundingBoxes.Add(boundingBox);

                Polygon polygon   = null;
                int     poolCount = polygonPool.Count;
                if (poolCount > 0)
                {
                    polygon = polygonPool.Items[poolCount - 1];
                    polygonPool.RemoveAt(poolCount - 1);
                }
                else
                {
                    polygon = new Polygon();
                }
                polygons.Add(polygon);

                int count = boundingBox.worldVerticesLength;
                polygon.Count = count;
                if (polygon.Vertices.Length < count)
                {
                    polygon.Vertices = new float[count];
                }
                boundingBox.ComputeWorldVertices(slot, polygon.Vertices);
            }

            if (updateAabb)
            {
                AabbCompute();
            }
            else
            {
                minX = int.MinValue;
                minY = int.MinValue;
                maxX = int.MaxValue;
                maxY = int.MaxValue;
            }
        }
 /** Returns true if the bounding box attachment contains the line segment. */
 public bool IntersectsSegment(BoundingBoxAttachment attachment, float x1, float y1, float x2, float y2)
 {
     int index = BoundingBoxes.IndexOf(attachment);
     return index == -1 ? false : IntersectsSegment(index, x1, y1, x2, y2);
 }
		static void DrawBoundingBox (Slot slot, BoundingBoxAttachment box) {
			if (box.Vertices.Length <= 0) return; // Handle cases where user creates a BoundingBoxAttachment but doesn't actually define it.

			var worldVerts = new float[box.Vertices.Length];
			box.ComputeWorldVertices(slot, worldVerts);

			Handles.color = Color.green;
			Vector3 lastVert = Vector3.back;
			Vector3 vert = Vector3.back;
			Vector3 firstVert = new Vector3(worldVerts[0], worldVerts[1], -1);
			for (int i = 0; i < worldVerts.Length; i += 2) {
				vert.x = worldVerts[i];
				vert.y = worldVerts[i + 1];

				if (i > 0)
					Handles.DrawLine(lastVert, vert);

				lastVert = vert;
			}

			Handles.DrawLine(lastVert, firstVert);

		}
    void SetCurrent(BoundingBoxAttachment attachment)
    {
        if (currentCollider)
            currentCollider.enabled = false;

        if (attachment != null) {
            currentCollider = colliderTable[attachment];
            currentCollider.enabled = true;
        } else {
            currentCollider = null;
        }

        currentAttachment = attachment;

        currentAttachmentName = currentAttachment == null ? null : attachmentNameTable[attachment];
    }
Esempio n. 10
0
        public Polygon GetPolygon(BoundingBoxAttachment attachment)
        {
            int num = BoundingBoxes.IndexOf(attachment);

            return((num != -1) ? Polygons.Items[num] : null);
        }
Esempio n. 11
0
        public Polygon getPolygon(BoundingBoxAttachment attachment)
        {
            int index = BoundingBoxes.IndexOf(attachment);

            return(index == -1 ? null : Polygons[index]);
        }
Esempio n. 12
0
        private Attachment ReadAttachment(Skin skin, string name, Dictionary <string, object> map)
        {
            if (map.ContainsKey("name"))
            {
                name = (string)map.get_Item("name");
            }
            AttachmentType attachmentType = AttachmentType.region;

            if (map.ContainsKey("type"))
            {
                attachmentType = (AttachmentType)((int)Enum.Parse(typeof(AttachmentType), (string)map.get_Item("type"), false));
            }
            string path = name;

            if (map.ContainsKey("path"))
            {
                path = (string)map.get_Item("path");
            }
            switch (attachmentType)
            {
            case AttachmentType.region:
            {
                RegionAttachment regionAttachment = this.attachmentLoader.NewRegionAttachment(skin, name, path);
                if (regionAttachment == null)
                {
                    return(null);
                }
                regionAttachment.Path     = path;
                regionAttachment.x        = this.GetFloat(map, "x", 0f) * this.Scale;
                regionAttachment.y        = this.GetFloat(map, "y", 0f) * this.Scale;
                regionAttachment.scaleX   = this.GetFloat(map, "scaleX", 1f);
                regionAttachment.scaleY   = this.GetFloat(map, "scaleY", 1f);
                regionAttachment.rotation = this.GetFloat(map, "rotation", 0f);
                regionAttachment.width    = this.GetFloat(map, "width", 32f) * this.Scale;
                regionAttachment.height   = this.GetFloat(map, "height", 32f) * this.Scale;
                regionAttachment.UpdateOffset();
                if (map.ContainsKey("color"))
                {
                    string hexString = (string)map.get_Item("color");
                    regionAttachment.r = this.ToColor(hexString, 0);
                    regionAttachment.g = this.ToColor(hexString, 1);
                    regionAttachment.b = this.ToColor(hexString, 2);
                    regionAttachment.a = this.ToColor(hexString, 3);
                }
                return(regionAttachment);
            }

            case AttachmentType.boundingbox:
            {
                BoundingBoxAttachment boundingBoxAttachment = this.attachmentLoader.NewBoundingBoxAttachment(skin, name);
                if (boundingBoxAttachment == null)
                {
                    return(null);
                }
                boundingBoxAttachment.vertices = this.GetFloatArray(map, "vertices", this.Scale);
                return(boundingBoxAttachment);
            }

            case AttachmentType.mesh:
            {
                MeshAttachment meshAttachment = this.attachmentLoader.NewMeshAttachment(skin, name, path);
                if (meshAttachment == null)
                {
                    return(null);
                }
                meshAttachment.Path      = path;
                meshAttachment.vertices  = this.GetFloatArray(map, "vertices", this.Scale);
                meshAttachment.triangles = this.GetIntArray(map, "triangles");
                meshAttachment.regionUVs = this.GetFloatArray(map, "uvs", 1f);
                meshAttachment.UpdateUVs();
                if (map.ContainsKey("color"))
                {
                    string hexString2 = (string)map.get_Item("color");
                    meshAttachment.r = this.ToColor(hexString2, 0);
                    meshAttachment.g = this.ToColor(hexString2, 1);
                    meshAttachment.b = this.ToColor(hexString2, 2);
                    meshAttachment.a = this.ToColor(hexString2, 3);
                }
                meshAttachment.HullLength = this.GetInt(map, "hull", 0) * 2;
                if (map.ContainsKey("edges"))
                {
                    meshAttachment.Edges = this.GetIntArray(map, "edges");
                }
                meshAttachment.Width  = (float)this.GetInt(map, "width", 0) * this.Scale;
                meshAttachment.Height = (float)this.GetInt(map, "height", 0) * this.Scale;
                return(meshAttachment);
            }

            case AttachmentType.skinnedmesh:
            {
                SkinnedMeshAttachment skinnedMeshAttachment = this.attachmentLoader.NewSkinnedMeshAttachment(skin, name, path);
                if (skinnedMeshAttachment == null)
                {
                    return(null);
                }
                skinnedMeshAttachment.Path = path;
                float[]      floatArray  = this.GetFloatArray(map, "uvs", 1f);
                float[]      floatArray2 = this.GetFloatArray(map, "vertices", 1f);
                List <float> list        = new List <float>(floatArray.Length * 3 * 3);
                List <int>   list2       = new List <int>(floatArray.Length * 3);
                float        scale       = this.Scale;
                int          i           = 0;
                int          num         = floatArray2.Length;
                while (i < num)
                {
                    int num2 = (int)floatArray2[i++];
                    list2.Add(num2);
                    int num3 = i + num2 * 4;
                    while (i < num3)
                    {
                        list2.Add((int)floatArray2[i]);
                        list.Add(floatArray2[i + 1] * scale);
                        list.Add(floatArray2[i + 2] * scale);
                        list.Add(floatArray2[i + 3]);
                        i += 4;
                    }
                }
                skinnedMeshAttachment.bones     = list2.ToArray();
                skinnedMeshAttachment.weights   = list.ToArray();
                skinnedMeshAttachment.triangles = this.GetIntArray(map, "triangles");
                skinnedMeshAttachment.regionUVs = floatArray;
                skinnedMeshAttachment.UpdateUVs();
                if (map.ContainsKey("color"))
                {
                    string hexString3 = (string)map.get_Item("color");
                    skinnedMeshAttachment.r = this.ToColor(hexString3, 0);
                    skinnedMeshAttachment.g = this.ToColor(hexString3, 1);
                    skinnedMeshAttachment.b = this.ToColor(hexString3, 2);
                    skinnedMeshAttachment.a = this.ToColor(hexString3, 3);
                }
                skinnedMeshAttachment.HullLength = this.GetInt(map, "hull", 0) * 2;
                if (map.ContainsKey("edges"))
                {
                    skinnedMeshAttachment.Edges = this.GetIntArray(map, "edges");
                }
                skinnedMeshAttachment.Width  = (float)this.GetInt(map, "width", 0) * this.Scale;
                skinnedMeshAttachment.Height = (float)this.GetInt(map, "height", 0) * this.Scale;
                return(skinnedMeshAttachment);
            }

            default:
                return(null);
            }
        }
Esempio n. 13
0
        private Attachment ReadAttachment(Skin skin, String name, Dictionary <String, Object> map)
        {
            if (map.ContainsKey("name"))
            {
                name = (String)map["name"];
            }

            var type = AttachmentType.region;

            if (map.ContainsKey("type"))
            {
                type = (AttachmentType)Enum.Parse(typeof(AttachmentType), (String)map["type"], false);
            }

            String path = name;

            if (map.ContainsKey("path"))
            {
                path = (String)map["path"];
            }

            switch (type)
            {
            case AttachmentType.region:
                RegionAttachment region = attachmentLoader.NewRegionAttachment(skin, name, path);
                if (region == null)
                {
                    return(null);
                }
                region.x        = GetFloat(map, "x", 0) * Scale;
                region.y        = GetFloat(map, "y", 0) * Scale;
                region.scaleX   = GetFloat(map, "scaleX", 1);
                region.scaleY   = GetFloat(map, "scaleY", 1);
                region.rotation = GetFloat(map, "rotation", 0);
                region.width    = GetFloat(map, "width", 32) * Scale;
                region.height   = GetFloat(map, "height", 32) * Scale;
                region.UpdateOffset();

                if (map.ContainsKey("color"))
                {
                    var color = (String)map["color"];
                    region.r = ToColor(color, 0);
                    region.g = ToColor(color, 1);
                    region.b = ToColor(color, 2);
                    region.a = ToColor(color, 3);
                }

                return(region);

            case AttachmentType.mesh: {
                MeshAttachment mesh = attachmentLoader.NewMeshAttachment(skin, name, path);
                if (mesh == null)
                {
                    return(null);
                }

                float[] uvs       = GetFloatArray(map, "uvs", 1);
                int[]   triangles = GetIntArray(map, "triangles");
                float[] vertices  = GetFloatArray(map, "vertices", Scale);
                mesh.SetMesh(vertices, triangles, uvs);

                if (map.ContainsKey("color"))
                {
                    var color = (String)map["color"];
                    mesh.r = ToColor(color, 0);
                    mesh.g = ToColor(color, 1);
                    mesh.b = ToColor(color, 2);
                    mesh.a = ToColor(color, 3);
                }

                mesh.HullLength = GetInt(map, "hull", 0) * 2;
                if (map.ContainsKey("edges"))
                {
                    mesh.Edges = GetIntArray(map, "edges");
                }
                mesh.Width  = GetInt(map, "width", 0) * Scale;
                mesh.Height = GetInt(map, "height", 0) * Scale;

                return(mesh);
            }

            case AttachmentType.skinnedmesh: {
                SkinnedMeshAttachment mesh = attachmentLoader.NewSkinnedMeshAttachment(skin, name, path);
                if (mesh == null)
                {
                    return(null);
                }

                float[] uvs       = GetFloatArray(map, "uvs", 1);
                int[]   triangles = GetIntArray(map, "triangles");

                float[] vertices = GetFloatArray(map, "vertices", 1);
                var     weights  = new List <float>(uvs.Length * 3 * 3);
                var     bones    = new List <int>(uvs.Length * 3);
                float   scale    = Scale;
                for (int i = 0, n = vertices.Length; i < n;)
                {
                    int boneCount = (int)vertices[i++];
                    bones.Add(boneCount);
                    for (int nn = i + boneCount * 4; i < nn;)
                    {
                        bones.Add((int)vertices[i]);
                        weights.Add(vertices[i + 1] * scale);
                        weights.Add(vertices[i + 2] * scale);
                        weights.Add(vertices[i + 3]);
                        i += 4;
                    }
                }
                mesh.SetMesh(bones.ToArray(), weights.ToArray(), triangles, uvs);

                if (map.ContainsKey("color"))
                {
                    var color = (String)map["color"];
                    mesh.r = ToColor(color, 0);
                    mesh.g = ToColor(color, 1);
                    mesh.b = ToColor(color, 2);
                    mesh.a = ToColor(color, 3);
                }

                mesh.HullLength = GetInt(map, "hull", 0) * 2;
                if (map.ContainsKey("edges"))
                {
                    mesh.Edges = GetIntArray(map, "edges");
                }
                mesh.Width  = GetInt(map, "width", 0) * Scale;
                mesh.Height = GetInt(map, "height", 0) * Scale;

                return(mesh);
            }

            case AttachmentType.boundingbox:
                BoundingBoxAttachment box = attachmentLoader.NewBoundingBoxAttachment(skin, name);
                if (box == null)
                {
                    return(null);
                }
                box.vertices = GetFloatArray(map, "vertices", Scale);
                return(box);
            }
            return(null);
        }
Esempio n. 14
0
        private Attachment ReadAttachment(Dictionary <string, object> map, Skin skin, int slotIndex, string name, SkeletonData skeletonData)
        {
            float scale = Scale;

            name = GetString(map, "name", name);
            string text = GetString(map, "type", "region");

            if (text == "skinnedmesh")
            {
                text = "weightedmesh";
            }
            if (text == "weightedmesh")
            {
                text = "mesh";
            }
            if (text == "weightedlinkedmesh")
            {
                text = "linkedmesh";
            }
            AttachmentType attachmentType = (AttachmentType)Enum.Parse(typeof(AttachmentType), text, ignoreCase: true);
            string         @string        = GetString(map, "path", name);

            switch (attachmentType)
            {
            case AttachmentType.Region:
            {
                RegionAttachment regionAttachment = attachmentLoader.NewRegionAttachment(skin, name, @string);
                if (regionAttachment == null)
                {
                    return(null);
                }
                regionAttachment.Path     = @string;
                regionAttachment.x        = GetFloat(map, "x", 0f) * scale;
                regionAttachment.y        = GetFloat(map, "y", 0f) * scale;
                regionAttachment.scaleX   = GetFloat(map, "scaleX", 1f);
                regionAttachment.scaleY   = GetFloat(map, "scaleY", 1f);
                regionAttachment.rotation = GetFloat(map, "rotation", 0f);
                regionAttachment.width    = GetFloat(map, "width", 32f) * scale;
                regionAttachment.height   = GetFloat(map, "height", 32f) * scale;
                regionAttachment.UpdateOffset();
                if (map.ContainsKey("color"))
                {
                    string hexString2 = (string)map["color"];
                    regionAttachment.r = ToColor(hexString2, 0);
                    regionAttachment.g = ToColor(hexString2, 1);
                    regionAttachment.b = ToColor(hexString2, 2);
                    regionAttachment.a = ToColor(hexString2, 3);
                }
                regionAttachment.UpdateOffset();
                return(regionAttachment);
            }

            case AttachmentType.Boundingbox:
            {
                BoundingBoxAttachment boundingBoxAttachment = attachmentLoader.NewBoundingBoxAttachment(skin, name);
                if (boundingBoxAttachment == null)
                {
                    return(null);
                }
                ReadVertices(map, boundingBoxAttachment, GetInt(map, "vertexCount", 0) << 1);
                return(boundingBoxAttachment);
            }

            case AttachmentType.Mesh:
            case AttachmentType.Linkedmesh:
            {
                MeshAttachment meshAttachment = attachmentLoader.NewMeshAttachment(skin, name, @string);
                if (meshAttachment == null)
                {
                    return(null);
                }
                meshAttachment.Path = @string;
                if (map.ContainsKey("color"))
                {
                    string hexString = (string)map["color"];
                    meshAttachment.r = ToColor(hexString, 0);
                    meshAttachment.g = ToColor(hexString, 1);
                    meshAttachment.b = ToColor(hexString, 2);
                    meshAttachment.a = ToColor(hexString, 3);
                }
                meshAttachment.Width  = GetFloat(map, "width", 0f) * scale;
                meshAttachment.Height = GetFloat(map, "height", 0f) * scale;
                string string3 = GetString(map, "parent", null);
                if (string3 != null)
                {
                    meshAttachment.InheritDeform = GetBoolean(map, "deform", defaultValue: true);
                    linkedMeshes.Add(new LinkedMesh(meshAttachment, GetString(map, "skin", null), slotIndex, string3));
                    return(meshAttachment);
                }
                float[] floatArray = GetFloatArray(map, "uvs", 1f);
                ReadVertices(map, meshAttachment, floatArray.Length);
                meshAttachment.triangles = GetIntArray(map, "triangles");
                meshAttachment.regionUVs = floatArray;
                meshAttachment.UpdateUVs();
                if (map.ContainsKey("hull"))
                {
                    meshAttachment.HullLength = GetInt(map, "hull", 0) * 2;
                }
                if (map.ContainsKey("edges"))
                {
                    meshAttachment.Edges = GetIntArray(map, "edges");
                }
                return(meshAttachment);
            }

            case AttachmentType.Path:
            {
                PathAttachment pathAttachment = attachmentLoader.NewPathAttachment(skin, name);
                if (pathAttachment == null)
                {
                    return(null);
                }
                pathAttachment.closed        = GetBoolean(map, "closed", defaultValue: false);
                pathAttachment.constantSpeed = GetBoolean(map, "constantSpeed", defaultValue: true);
                int @int = GetInt(map, "vertexCount", 0);
                ReadVertices(map, pathAttachment, @int << 1);
                pathAttachment.lengths = GetFloatArray(map, "lengths", scale);
                return(pathAttachment);
            }

            case AttachmentType.Point:
            {
                PointAttachment pointAttachment = attachmentLoader.NewPointAttachment(skin, name);
                if (pointAttachment == null)
                {
                    return(null);
                }
                pointAttachment.x        = GetFloat(map, "x", 0f) * scale;
                pointAttachment.y        = GetFloat(map, "y", 0f) * scale;
                pointAttachment.rotation = GetFloat(map, "rotation", 0f);
                return(pointAttachment);
            }

            case AttachmentType.Clipping:
            {
                ClippingAttachment clippingAttachment = attachmentLoader.NewClippingAttachment(skin, name);
                if (clippingAttachment == null)
                {
                    return(null);
                }
                string string2 = GetString(map, "end", null);
                if (string2 != null)
                {
                    SlotData slotData = skeletonData.FindSlot(string2);
                    if (slotData == null)
                    {
                        throw new Exception("Clipping end slot not found: " + string2);
                    }
                    clippingAttachment.EndSlot = slotData;
                }
                ReadVertices(map, clippingAttachment, GetInt(map, "vertexCount", 0) << 1);
                return(clippingAttachment);
            }

            default:
                return(null);
            }
        }
Esempio n. 15
0
        private Attachment ReadAttachment(Stream input, SkeletonData skeletonData, Skin skin, int slotIndex, string attachmentName, bool nonessential)
        {
            float  scale = Scale;
            string text  = ReadString(input);

            if (text == null)
            {
                text = attachmentName;
            }
            switch (input.ReadByte())
            {
            case 0:
            {
                string text2    = ReadString(input);
                float  rotation = ReadFloat(input);
                float  num3     = ReadFloat(input);
                float  num4     = ReadFloat(input);
                float  scaleX   = ReadFloat(input);
                float  scaleY   = ReadFloat(input);
                float  num5     = ReadFloat(input);
                float  num6     = ReadFloat(input);
                int    num7     = ReadInt(input);
                if (text2 == null)
                {
                    text2 = text;
                }
                RegionAttachment regionAttachment = attachmentLoader.NewRegionAttachment(skin, text, text2);
                if (regionAttachment == null)
                {
                    return(null);
                }
                regionAttachment.Path     = text2;
                regionAttachment.x        = num3 * scale;
                regionAttachment.y        = num4 * scale;
                regionAttachment.scaleX   = scaleX;
                regionAttachment.scaleY   = scaleY;
                regionAttachment.rotation = rotation;
                regionAttachment.width    = num5 * scale;
                regionAttachment.height   = num6 * scale;
                regionAttachment.r        = (float)((num7 & 4278190080u) >> 24) / 255f;
                regionAttachment.g        = (float)((num7 & 0xFF0000) >> 16) / 255f;
                regionAttachment.b        = (float)((num7 & 0xFF00) >> 8) / 255f;
                regionAttachment.a        = (float)(num7 & 0xFF) / 255f;
                regionAttachment.UpdateOffset();
                return(regionAttachment);
            }

            case 1:
            {
                int      num20     = ReadVarint(input, optimizePositive: true);
                Vertices vertices4 = ReadVertices(input, num20);
                if (nonessential)
                {
                    ReadInt(input);
                }
                BoundingBoxAttachment boundingBoxAttachment = attachmentLoader.NewBoundingBoxAttachment(skin, text);
                if (boundingBoxAttachment == null)
                {
                    return(null);
                }
                boundingBoxAttachment.worldVerticesLength = num20 << 1;
                boundingBoxAttachment.vertices            = vertices4.vertices;
                boundingBoxAttachment.bones = vertices4.bones;
                return(boundingBoxAttachment);
            }

            case 2:
            {
                string   text3     = ReadString(input);
                int      num8      = ReadInt(input);
                int      num9      = ReadVarint(input, optimizePositive: true);
                float[]  regionUVs = ReadFloatArray(input, num9 << 1, 1f);
                int[]    triangles = ReadShortArray(input);
                Vertices vertices2 = ReadVertices(input, num9);
                int      num10     = ReadVarint(input, optimizePositive: true);
                int[]    edges     = null;
                float    num11     = 0f;
                float    num12     = 0f;
                if (nonessential)
                {
                    edges = ReadShortArray(input);
                    num11 = ReadFloat(input);
                    num12 = ReadFloat(input);
                }
                if (text3 == null)
                {
                    text3 = text;
                }
                MeshAttachment meshAttachment = attachmentLoader.NewMeshAttachment(skin, text, text3);
                if (meshAttachment == null)
                {
                    return(null);
                }
                meshAttachment.Path                = text3;
                meshAttachment.r                   = (float)((num8 & 4278190080u) >> 24) / 255f;
                meshAttachment.g                   = (float)((num8 & 0xFF0000) >> 16) / 255f;
                meshAttachment.b                   = (float)((num8 & 0xFF00) >> 8) / 255f;
                meshAttachment.a                   = (float)(num8 & 0xFF) / 255f;
                meshAttachment.bones               = vertices2.bones;
                meshAttachment.vertices            = vertices2.vertices;
                meshAttachment.WorldVerticesLength = num9 << 1;
                meshAttachment.triangles           = triangles;
                meshAttachment.regionUVs           = regionUVs;
                meshAttachment.UpdateUVs();
                meshAttachment.HullLength = num10 << 1;
                if (nonessential)
                {
                    meshAttachment.Edges  = edges;
                    meshAttachment.Width  = num11 * scale;
                    meshAttachment.Height = num12 * scale;
                }
                return(meshAttachment);
            }

            case 3:
            {
                string text4         = ReadString(input);
                int    num13         = ReadInt(input);
                string skin2         = ReadString(input);
                string parent        = ReadString(input);
                bool   inheritDeform = ReadBoolean(input);
                float  num14         = 0f;
                float  num15         = 0f;
                if (nonessential)
                {
                    num14 = ReadFloat(input);
                    num15 = ReadFloat(input);
                }
                if (text4 == null)
                {
                    text4 = text;
                }
                MeshAttachment meshAttachment2 = attachmentLoader.NewMeshAttachment(skin, text, text4);
                if (meshAttachment2 == null)
                {
                    return(null);
                }
                meshAttachment2.Path          = text4;
                meshAttachment2.r             = (float)((num13 & 4278190080u) >> 24) / 255f;
                meshAttachment2.g             = (float)((num13 & 0xFF0000) >> 16) / 255f;
                meshAttachment2.b             = (float)((num13 & 0xFF00) >> 8) / 255f;
                meshAttachment2.a             = (float)(num13 & 0xFF) / 255f;
                meshAttachment2.inheritDeform = inheritDeform;
                if (nonessential)
                {
                    meshAttachment2.Width  = num14 * scale;
                    meshAttachment2.Height = num15 * scale;
                }
                linkedMeshes.Add(new SkeletonJson.LinkedMesh(meshAttachment2, skin2, slotIndex, parent));
                return(meshAttachment2);
            }

            case 4:
            {
                bool     closed        = ReadBoolean(input);
                bool     constantSpeed = ReadBoolean(input);
                int      num16         = ReadVarint(input, optimizePositive: true);
                Vertices vertices3     = ReadVertices(input, num16);
                float[]  array         = new float[num16 / 3];
                int      i             = 0;
                for (int num17 = array.Length; i < num17; i++)
                {
                    array[i] = ReadFloat(input) * scale;
                }
                if (nonessential)
                {
                    ReadInt(input);
                }
                PathAttachment pathAttachment = attachmentLoader.NewPathAttachment(skin, text);
                if (pathAttachment == null)
                {
                    return(null);
                }
                pathAttachment.closed              = closed;
                pathAttachment.constantSpeed       = constantSpeed;
                pathAttachment.worldVerticesLength = num16 << 1;
                pathAttachment.vertices            = vertices3.vertices;
                pathAttachment.bones   = vertices3.bones;
                pathAttachment.lengths = array;
                return(pathAttachment);
            }

            case 5:
            {
                float rotation2 = ReadFloat(input);
                float num18     = ReadFloat(input);
                float num19     = ReadFloat(input);
                if (nonessential)
                {
                    ReadInt(input);
                }
                PointAttachment pointAttachment = attachmentLoader.NewPointAttachment(skin, text);
                if (pointAttachment == null)
                {
                    return(null);
                }
                pointAttachment.x        = num18 * scale;
                pointAttachment.y        = num19 * scale;
                pointAttachment.rotation = rotation2;
                return(pointAttachment);
            }

            case 6:
            {
                int      num      = ReadVarint(input, optimizePositive: true);
                int      num2     = ReadVarint(input, optimizePositive: true);
                Vertices vertices = ReadVertices(input, num2);
                if (nonessential)
                {
                    ReadInt(input);
                }
                ClippingAttachment clippingAttachment = attachmentLoader.NewClippingAttachment(skin, text);
                if (clippingAttachment == null)
                {
                    return(null);
                }
                clippingAttachment.EndSlot             = skeletonData.slots.Items[num];
                clippingAttachment.worldVerticesLength = num2 << 1;
                clippingAttachment.vertices            = vertices.vertices;
                clippingAttachment.bones = vertices.bones;
                return(clippingAttachment);
            }

            default:
                return(null);
            }
        }
		public static void SetColliderPointsLocal (PolygonCollider2D collider, Slot slot, BoundingBoxAttachment box) {
			if (box == null) return;
			if (box.IsWeighted()) Debug.LogWarning("UnityEngine.PolygonCollider2D does not support weighted or animated points. Collider points will not be animated and may have incorrect orientation. If you want to use it as a collider, please remove weights and animations from the bounding box in Spine editor.");
			var verts = box.GetLocalVertices(slot, null);
			collider.SetPath(0, verts);
		}
Esempio n. 17
0
        private Attachment ReadAttachment(Dictionary <String, Object> map, Skin skin, int slotIndex, String name)
        {
            var scale = this.Scale;

            name = GetString(map, "name", name);

            var typeName = GetString(map, "type", "region");

            if (typeName == "skinnedmesh")
            {
                typeName = "weightedmesh";
            }
            if (typeName == "weightedmesh")
            {
                typeName = "mesh";
            }
            if (typeName == "weightedlinkedmesh")
            {
                typeName = "linkedmesh";
            }
            var type = (AttachmentType)Enum.Parse(typeof(AttachmentType), typeName, true);

            String path = GetString(map, "path", name);

            switch (type)
            {
            case AttachmentType.Region:
                RegionAttachment region = attachmentLoader.NewRegionAttachment(skin, name, path);
                if (region == null)
                {
                    return(null);
                }
                region.Path     = path;
                region.x        = GetFloat(map, "x", 0) * scale;
                region.y        = GetFloat(map, "y", 0) * scale;
                region.scaleX   = GetFloat(map, "scaleX", 1);
                region.scaleY   = GetFloat(map, "scaleY", 1);
                region.rotation = GetFloat(map, "rotation", 0);
                region.width    = GetFloat(map, "width", 32) * scale;
                region.height   = GetFloat(map, "height", 32) * scale;
                region.UpdateOffset();

                if (map.ContainsKey("color"))
                {
                    var color = (String)map["color"];
                    region.r = ToColor(color, 0);
                    region.g = ToColor(color, 1);
                    region.b = ToColor(color, 2);
                    region.a = ToColor(color, 3);
                }

                region.UpdateOffset();
                return(region);

            case AttachmentType.Boundingbox:
                BoundingBoxAttachment box = attachmentLoader.NewBoundingBoxAttachment(skin, name);
                if (box == null)
                {
                    return(null);
                }
                ReadVertices(map, box, GetInt(map, "vertexCount", 0) << 1);
                return(box);

            case AttachmentType.Mesh:
            case AttachmentType.Linkedmesh: {
                MeshAttachment mesh = attachmentLoader.NewMeshAttachment(skin, name, path);
                if (mesh == null)
                {
                    return(null);
                }
                mesh.Path = path;

                if (map.ContainsKey("color"))
                {
                    var color = (String)map["color"];
                    mesh.r = ToColor(color, 0);
                    mesh.g = ToColor(color, 1);
                    mesh.b = ToColor(color, 2);
                    mesh.a = ToColor(color, 3);
                }

                mesh.Width  = GetFloat(map, "width", 0) * scale;
                mesh.Height = GetFloat(map, "height", 0) * scale;

                String parent = GetString(map, "parent", null);
                if (parent != null)
                {
                    mesh.InheritDeform = GetBoolean(map, "deform", true);
                    linkedMeshes.Add(new LinkedMesh(mesh, GetString(map, "skin", null), slotIndex, parent));
                    return(mesh);
                }

                float[] uvs = GetFloatArray(map, "uvs", 1);
                ReadVertices(map, mesh, uvs.Length);
                mesh.triangles = GetIntArray(map, "triangles");
                mesh.regionUVs = uvs;
                mesh.UpdateUVs();

                if (map.ContainsKey("hull"))
                {
                    mesh.HullLength = GetInt(map, "hull", 0) * 2;
                }
                if (map.ContainsKey("edges"))
                {
                    mesh.Edges = GetIntArray(map, "edges");
                }
                return(mesh);
            }

            case AttachmentType.Path: {
                PathAttachment pathAttachment = attachmentLoader.NewPathAttachment(skin, name);
                if (pathAttachment == null)
                {
                    return(null);
                }
                pathAttachment.closed        = GetBoolean(map, "closed", false);
                pathAttachment.constantSpeed = GetBoolean(map, "constantSpeed", true);

                int vertexCount = GetInt(map, "vertexCount", 0);
                ReadVertices(map, pathAttachment, vertexCount << 1);

                // potential BOZO see Java impl
                pathAttachment.lengths = GetFloatArray(map, "lengths", scale);
                return(pathAttachment);
            }
            }
            return(null);
        }
		public static Bounds GetBoundingBoxBounds (BoundingBoxAttachment boundingBox, float depth = 0) {
			float[] floats = boundingBox.Vertices;
			int floatCount = floats.Length;

			Bounds bounds = new Bounds();
			bounds.center = new Vector3(floats[0], floats[1], 0);
			for (int i = 2; i < floatCount; i += 2)
				bounds.Encapsulate(new Vector3(floats[i], floats[i + 1], 0));

			Vector3 size = bounds.size;
			size.z = depth;
			bounds.size = size;

			return bounds;
		}
Esempio n. 19
0
        private Attachment ReadAttachment(Stream input, SkeletonData skeletonData, Skin skin, int slotIndex, String attachmentName, bool nonessential)
        {
            float scale = Scale;

            String name = ReadString(input);

            if (name == null)
            {
                name = attachmentName;
            }

            AttachmentType type = (AttachmentType)input.ReadByte();

            switch (type)
            {
            case AttachmentType.Region: {
                String path     = ReadString(input);
                float  rotation = ReadFloat(input);
                float  x        = ReadFloat(input);
                float  y        = ReadFloat(input);
                float  scaleX   = ReadFloat(input);
                float  scaleY   = ReadFloat(input);
                float  width    = ReadFloat(input);
                float  height   = ReadFloat(input);
                int    color    = ReadInt(input);

                if (path == null)
                {
                    path = name;
                }
                RegionAttachment region = attachmentLoader.NewRegionAttachment(skin, name, path);
                if (region == null)
                {
                    return(null);
                }
                region.Path     = path;
                region.x        = x * scale;
                region.y        = y * scale;
                region.scaleX   = scaleX;
                region.scaleY   = scaleY;
                region.rotation = rotation;
                region.width    = width * scale;
                region.height   = height * scale;
                region.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: {
                int      vertexCount = ReadVarint(input, true);
                Vertices vertices    = ReadVertices(input, vertexCount);
                if (nonessential)
                {
                    ReadInt(input);                                       //int color = nonessential ? ReadInt(input) : 0; // Avoid unused local warning.
                }
                BoundingBoxAttachment box = attachmentLoader.NewBoundingBoxAttachment(skin, name);
                if (box == null)
                {
                    return(null);
                }
                box.worldVerticesLength = vertexCount << 1;
                box.vertices            = vertices.vertices;
                box.bones = vertices.bones;
                return(box);
            }

            case AttachmentType.Mesh: {
                String   path = ReadString(input);
                int      color = ReadInt(input);
                int      vertexCount = ReadVarint(input, true);
                float[]  uvs = ReadFloatArray(input, vertexCount << 1, 1);
                int[]    triangles = ReadShortArray(input);
                Vertices vertices = ReadVertices(input, vertexCount);
                int      hullLength = ReadVarint(input, true);
                int[]    edges = null;
                float    width = 0, height = 0;
                if (nonessential)
                {
                    edges  = ReadShortArray(input);
                    width  = ReadFloat(input);
                    height = ReadFloat(input);
                }

                if (path == null)
                {
                    path = name;
                }
                MeshAttachment mesh = attachmentLoader.NewMeshAttachment(skin, name, path);
                if (mesh == null)
                {
                    return(null);
                }
                mesh.Path                = path;
                mesh.r                   = ((color & 0xff000000) >> 24) / 255f;
                mesh.g                   = ((color & 0x00ff0000) >> 16) / 255f;
                mesh.b                   = ((color & 0x0000ff00) >> 8) / 255f;
                mesh.a                   = ((color & 0x000000ff)) / 255f;
                mesh.bones               = vertices.bones;
                mesh.vertices            = vertices.vertices;
                mesh.WorldVerticesLength = vertexCount << 1;
                mesh.triangles           = triangles;
                mesh.regionUVs           = uvs;
                mesh.UpdateUVs();
                mesh.HullLength = hullLength << 1;
                if (nonessential)
                {
                    mesh.Edges  = edges;
                    mesh.Width  = width * scale;
                    mesh.Height = height * scale;
                }
                return(mesh);
            }

            case AttachmentType.Linkedmesh: {
                String path = ReadString(input);
                int    color = ReadInt(input);
                String skinName = ReadString(input);
                String parent = ReadString(input);
                bool   inheritDeform = ReadBoolean(input);
                float  width = 0, height = 0;
                if (nonessential)
                {
                    width  = ReadFloat(input);
                    height = ReadFloat(input);
                }

                if (path == null)
                {
                    path = name;
                }
                MeshAttachment mesh = attachmentLoader.NewMeshAttachment(skin, name, path);
                if (mesh == null)
                {
                    return(null);
                }
                mesh.Path          = path;
                mesh.r             = ((color & 0xff000000) >> 24) / 255f;
                mesh.g             = ((color & 0x00ff0000) >> 16) / 255f;
                mesh.b             = ((color & 0x0000ff00) >> 8) / 255f;
                mesh.a             = ((color & 0x000000ff)) / 255f;
                mesh.inheritDeform = inheritDeform;
                if (nonessential)
                {
                    mesh.Width  = width * scale;
                    mesh.Height = height * scale;
                }
                linkedMeshes.Add(new SkeletonJson.LinkedMesh(mesh, skinName, slotIndex, parent));
                return(mesh);
            }

            case AttachmentType.Path: {
                bool     closed        = ReadBoolean(input);
                bool     constantSpeed = ReadBoolean(input);
                int      vertexCount   = ReadVarint(input, true);
                Vertices vertices      = ReadVertices(input, vertexCount);
                float[]  lengths       = new float[vertexCount / 3];
                for (int i = 0, n = lengths.Length; i < n; i++)
                {
                    lengths[i] = ReadFloat(input) * scale;
                }
                if (nonessential)
                {
                    ReadInt(input);                                       //int color = nonessential ? ReadInt(input) : 0;
                }
                PathAttachment path = attachmentLoader.NewPathAttachment(skin, name);
                if (path == null)
                {
                    return(null);
                }
                path.closed              = closed;
                path.constantSpeed       = constantSpeed;
                path.worldVerticesLength = vertexCount << 1;
                path.vertices            = vertices.vertices;
                path.bones   = vertices.bones;
                path.lengths = lengths;
                return(path);
            }

            case AttachmentType.Point: {
                float rotation = ReadFloat(input);
                float x        = ReadFloat(input);
                float y        = ReadFloat(input);
                if (nonessential)
                {
                    ReadInt(input);                                       //int color = nonessential ? ReadInt(input) : 0;
                }
                PointAttachment point = attachmentLoader.NewPointAttachment(skin, name);
                if (point == null)
                {
                    return(null);
                }
                point.x        = x * scale;
                point.y        = y * scale;
                point.rotation = rotation;
                //if (nonessential) point.color = color;
                return(point);
            }

            case AttachmentType.Clipping: {
                int      endSlotIndex = ReadVarint(input, true);
                int      vertexCount  = ReadVarint(input, true);
                Vertices vertices     = ReadVertices(input, vertexCount);
                if (nonessential)
                {
                    ReadInt(input);
                }

                ClippingAttachment clip = attachmentLoader.NewClippingAttachment(skin, name);
                if (clip == null)
                {
                    return(null);
                }
                clip.EndSlot             = skeletonData.slots.Items[endSlotIndex];
                clip.worldVerticesLength = vertexCount << 1;
                clip.vertices            = vertices.vertices;
                clip.bones = vertices.bones;
                return(clip);
            }
            }
            return(null);
        }
        /// <return>May be null to not load any attachment.</return>
        public BoundingBoxAttachment NewBoundingBoxAttachment(Skin skin, string name)
        {
            var attachment = new BoundingBoxAttachment(name);

            return(attachment);
        }
        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);
        }
Esempio n. 22
0
        private Attachment ReadAttachment(Stream input, Skin skin, int slotIndex, String attachmentName, bool nonessential)
        {
            float scale = Scale;

            String name = ReadString(input);

            if (name == null)
            {
                name = attachmentName;
            }

            AttachmentType type = (AttachmentType)input.ReadByte();

            switch (type)
            {
            case AttachmentType.region: {
                String path     = ReadString(input);
                float  x        = ReadFloat(input);
                float  y        = ReadFloat(input);
                float  scaleX   = ReadFloat(input);
                float  scaleY   = ReadFloat(input);
                float  rotation = ReadFloat(input);
                float  width    = ReadFloat(input);
                float  height   = ReadFloat(input);
                int    color    = ReadInt(input);

                if (path == null)
                {
                    path = name;
                }
                RegionAttachment region = attachmentLoader.NewRegionAttachment(skin, name, path);
                if (region == null)
                {
                    return(null);
                }
                region.Path     = path;
                region.x        = x * scale;
                region.y        = y * scale;
                region.scaleX   = scaleX;
                region.scaleY   = scaleY;
                region.rotation = rotation;
                region.width    = width * scale;
                region.height   = height * scale;
                region.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: {
                float[] vertices          = ReadFloatArray(input, ReadVarint(input, true) * 2, scale);
                BoundingBoxAttachment box = attachmentLoader.NewBoundingBoxAttachment(skin, name);
                if (box == null)
                {
                    return(null);
                }
                box.vertices = vertices;
                return(box);
            }

            case AttachmentType.mesh: {
                String  path           = ReadString(input);
                int     color          = ReadInt(input);
                int     hullLength     = 0;
                int     verticesLength = ReadVarint(input, true) * 2;
                float[] uvs            = ReadFloatArray(input, verticesLength, 1);
                int[]   triangles      = ReadShortArray(input);
                float[] vertices       = ReadFloatArray(input, verticesLength, scale);
                hullLength = ReadVarint(input, true);
                int[] edges = null;
                float width = 0, height = 0;
                if (nonessential)
                {
                    edges  = ReadShortArray(input);
                    width  = ReadFloat(input);
                    height = ReadFloat(input);
                }

                if (path == null)
                {
                    path = name;
                }
                MeshAttachment mesh = attachmentLoader.NewMeshAttachment(skin, name, path);
                if (mesh == null)
                {
                    return(null);
                }
                mesh.Path      = path;
                mesh.r         = ((color & 0xff000000) >> 24) / 255f;
                mesh.g         = ((color & 0x00ff0000) >> 16) / 255f;
                mesh.b         = ((color & 0x0000ff00) >> 8) / 255f;
                mesh.a         = ((color & 0x000000ff)) / 255f;
                mesh.vertices  = vertices;
                mesh.triangles = triangles;
                mesh.regionUVs = uvs;
                mesh.UpdateUVs();
                mesh.HullLength = hullLength;
                if (nonessential)
                {
                    mesh.Edges  = edges;
                    mesh.Width  = width * scale;
                    mesh.Height = height * scale;
                }
                return(mesh);
            }

            case AttachmentType.linkedmesh: {
                String path = ReadString(input);
                int    color = ReadInt(input);
                String skinName = ReadString(input);
                String parent = ReadString(input);
                bool   inheritFFD = ReadBoolean(input);
                float  width = 0, height = 0;
                if (nonessential)
                {
                    width  = ReadFloat(input);
                    height = ReadFloat(input);
                }

                if (path == null)
                {
                    path = name;
                }
                MeshAttachment mesh = attachmentLoader.NewMeshAttachment(skin, name, path);
                if (mesh == null)
                {
                    return(null);
                }
                mesh.Path       = path;
                mesh.r          = ((color & 0xff000000) >> 24) / 255f;
                mesh.g          = ((color & 0x00ff0000) >> 16) / 255f;
                mesh.b          = ((color & 0x0000ff00) >> 8) / 255f;
                mesh.a          = ((color & 0x000000ff)) / 255f;
                mesh.inheritFFD = inheritFFD;
                if (nonessential)
                {
                    mesh.Width  = width * scale;
                    mesh.Height = height * scale;
                }
                linkedMeshes.Add(new SkeletonJson.LinkedMesh(mesh, skinName, slotIndex, parent));
                return(mesh);
            }

            case AttachmentType.weightedmesh: {
                String  path        = ReadString(input);
                int     color       = ReadInt(input);
                int     vertexCount = ReadVarint(input, true);
                float[] uvs         = ReadFloatArray(input, vertexCount * 2, 1);
                int[]   triangles   = ReadShortArray(input);
                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 ii = 0; ii < boneCount; ii++)
                    {
                        bones.Add((int)ReadFloat(input));
                        weights.Add(ReadFloat(input) * scale);
                        weights.Add(ReadFloat(input) * scale);
                        weights.Add(ReadFloat(input));
                    }
                }
                int   hullLength = ReadVarint(input, true);
                int[] edges = null;
                float width = 0, height = 0;
                if (nonessential)
                {
                    edges  = ReadShortArray(input);
                    width  = ReadFloat(input);
                    height = ReadFloat(input);
                }

                if (path == null)
                {
                    path = name;
                }
                WeightedMeshAttachment mesh = attachmentLoader.NewWeightedMeshAttachment(skin, name, path);
                if (mesh == null)
                {
                    return(null);
                }
                mesh.Path      = path;
                mesh.r         = ((color & 0xff000000) >> 24) / 255f;
                mesh.g         = ((color & 0x00ff0000) >> 16) / 255f;
                mesh.b         = ((color & 0x0000ff00) >> 8) / 255f;
                mesh.a         = ((color & 0x000000ff)) / 255f;
                mesh.bones     = bones.ToArray();
                mesh.weights   = weights.ToArray();
                mesh.triangles = triangles;
                mesh.regionUVs = uvs;
                mesh.UpdateUVs();
                mesh.HullLength = hullLength * 2;
                if (nonessential)
                {
                    mesh.Edges  = edges;
                    mesh.Width  = width * scale;
                    mesh.Height = height * scale;
                }
                //
                return(mesh);
            }

            case AttachmentType.weightedlinkedmesh: {
                String path = ReadString(input);
                int    color = ReadInt(input);
                String skinName = ReadString(input);
                String parent = ReadString(input);
                bool   inheritFFD = ReadBoolean(input);
                float  width = 0, height = 0;
                if (nonessential)
                {
                    width  = ReadFloat(input);
                    height = ReadFloat(input);
                }

                if (path == null)
                {
                    path = name;
                }
                WeightedMeshAttachment mesh = attachmentLoader.NewWeightedMeshAttachment(skin, name, path);
                if (mesh == null)
                {
                    return(null);
                }
                mesh.Path       = path;
                mesh.r          = ((color & 0xff000000) >> 24) / 255f;
                mesh.g          = ((color & 0x00ff0000) >> 16) / 255f;
                mesh.b          = ((color & 0x0000ff00) >> 8) / 255f;
                mesh.a          = ((color & 0x000000ff)) / 255f;
                mesh.inheritFFD = inheritFFD;
                if (nonessential)
                {
                    mesh.Width  = width * scale;
                    mesh.Height = height * scale;
                }
                linkedMeshes.Add(new SkeletonJson.LinkedMesh(mesh, skinName, slotIndex, parent));
                return(mesh);
            }
            }
            return(null);
        }
Esempio n. 23
0
        private Attachment ReadAttachment(Skin skin, int slotIndex, String name, Dictionary <String, Object> map)
        {
            if (map.ContainsKey("name"))
            {
                name = (String)map["name"];
            }

            var scale = this.Scale;

            var type = AttachmentType.region;

            if (map.ContainsKey("type"))
            {
                var typeName = (String)map["type"];
                if (typeName == "skinnedmesh")
                {
                    typeName = "weightedmesh";
                }
                type = (AttachmentType)Enum.Parse(typeof(AttachmentType), typeName, false);
            }

            String path = name;

            if (map.ContainsKey("path"))
            {
                path = (String)map["path"];
            }

            switch (type)
            {
            case AttachmentType.region:
                RegionAttachment region = attachmentLoader.NewRegionAttachment(skin, name, path);
                if (region == null)
                {
                    return(null);
                }
                region.Path     = path;
                region.x        = GetFloat(map, "x", 0) * scale;
                region.y        = GetFloat(map, "y", 0) * scale;
                region.scaleX   = GetFloat(map, "scaleX", 1);
                region.scaleY   = GetFloat(map, "scaleY", 1);
                region.rotation = GetFloat(map, "rotation", 0);
                region.width    = GetFloat(map, "width", 32) * scale;
                region.height   = GetFloat(map, "height", 32) * scale;
                region.UpdateOffset();

                if (map.ContainsKey("color"))
                {
                    var color = (String)map["color"];
                    region.r = ToColor(color, 0);
                    region.g = ToColor(color, 1);
                    region.b = ToColor(color, 2);
                    region.a = ToColor(color, 3);
                }

                return(region);

            case AttachmentType.mesh:
            case AttachmentType.linkedmesh: {
                MeshAttachment mesh = attachmentLoader.NewMeshAttachment(skin, name, path);
                if (mesh == null)
                {
                    return(null);
                }
                mesh.Path = path;

                if (map.ContainsKey("color"))
                {
                    var color = (String)map["color"];
                    mesh.r = ToColor(color, 0);
                    mesh.g = ToColor(color, 1);
                    mesh.b = ToColor(color, 2);
                    mesh.a = ToColor(color, 3);
                }

                mesh.Width  = GetInt(map, "width", 0) * scale;
                mesh.Height = GetInt(map, "height", 0) * scale;

                String parent = GetString(map, "parent", null);
                if (parent == null)
                {
                    mesh.vertices  = GetFloatArray(map, "vertices", scale);
                    mesh.triangles = GetIntArray(map, "triangles");
                    mesh.regionUVs = GetFloatArray(map, "uvs", 1);
                    mesh.UpdateUVs();

                    mesh.HullLength = GetInt(map, "hull", 0) * 2;
                    if (map.ContainsKey("edges"))
                    {
                        mesh.Edges = GetIntArray(map, "edges");
                    }
                }
                else
                {
                    mesh.InheritFFD = GetBoolean(map, "ffd", true);
                    linkedMeshes.Add(new LinkedMesh(mesh, GetString(map, "skin", null), slotIndex, parent));
                }

                return(mesh);
            }

            case AttachmentType.weightedmesh:
            case AttachmentType.weightedlinkedmesh: {
                WeightedMeshAttachment mesh = attachmentLoader.NewWeightedMeshAttachment(skin, name, path);
                if (mesh == null)
                {
                    return(null);
                }

                mesh.Path = path;

                if (map.ContainsKey("color"))
                {
                    var color = (String)map["color"];
                    mesh.r = ToColor(color, 0);
                    mesh.g = ToColor(color, 1);
                    mesh.b = ToColor(color, 2);
                    mesh.a = ToColor(color, 3);
                }

                mesh.Width  = GetInt(map, "width", 0) * scale;
                mesh.Height = GetInt(map, "height", 0) * scale;

                String parent = GetString(map, "parent", null);
                if (parent == null)
                {
                    float[] uvs      = GetFloatArray(map, "uvs", 1);
                    float[] vertices = GetFloatArray(map, "vertices", 1);
                    var     weights  = new List <float>(uvs.Length * 3 * 3);
                    var     bones    = new List <int>(uvs.Length * 3);
                    for (int i = 0, n = vertices.Length; i < n;)
                    {
                        int boneCount = (int)vertices[i++];
                        bones.Add(boneCount);
                        for (int nn = i + boneCount * 4; i < nn; i += 4)
                        {
                            bones.Add((int)vertices[i]);
                            weights.Add(vertices[i + 1] * scale);
                            weights.Add(vertices[i + 2] * scale);
                            weights.Add(vertices[i + 3]);
                        }
                    }
                    mesh.bones     = bones.ToArray();
                    mesh.weights   = weights.ToArray();
                    mesh.triangles = GetIntArray(map, "triangles");
                    mesh.regionUVs = uvs;
                    mesh.UpdateUVs();

                    mesh.HullLength = GetInt(map, "hull", 0) * 2;
                    if (map.ContainsKey("edges"))
                    {
                        mesh.Edges = GetIntArray(map, "edges");
                    }
                }
                else
                {
                    mesh.InheritFFD = GetBoolean(map, "ffd", true);
                    linkedMeshes.Add(new LinkedMesh(mesh, GetString(map, "skin", null), slotIndex, parent));
                }

                return(mesh);
            }

            case AttachmentType.boundingbox:
                BoundingBoxAttachment box = attachmentLoader.NewBoundingBoxAttachment(skin, name);
                if (box == null)
                {
                    return(null);
                }
                box.vertices = GetFloatArray(map, "vertices", scale);
                return(box);
            }
            return(null);
        }
Esempio n. 24
0
        /** Returns true if the bounding box attachment contains the point. The bounding box must be in the SkeletonBounds. */
        public bool containsPoint(BoundingBoxAttachment attachment, float x, float y)
        {
            int index = BoundingBoxes.IndexOf(attachment);

            return(index == -1 ? false : ContainsPoint(index, x, y));
        }
	void DrawBoundingBox (Bone bone, BoundingBoxAttachment box) {
		float[] worldVerts = new float[box.Vertices.Length];
		box.ComputeWorldVertices(bone, worldVerts);

		Handles.color = Color.green;
		Vector3 lastVert = Vector3.back;
		Vector3 vert = Vector3.back;
		Vector3 firstVert = new Vector3(worldVerts[0], worldVerts[1], -1);
		for (int i = 0; i < worldVerts.Length; i += 2) {
			vert.x = worldVerts[i];
			vert.y = worldVerts[i + 1];

			if (i > 0) {
				Handles.DrawLine(lastVert, vert);
			}


			lastVert = vert;
		}

		Handles.DrawLine(lastVert, firstVert);

		
		
	}
Esempio n. 26
0
        /** Returns true if the bounding box attachment contains the line segment. */
        public bool IntersectsSegment(BoundingBoxAttachment attachment, float x1, float y1, float x2, float y2)
        {
            int index = BoundingBoxes.IndexOf(attachment);

            return(index == -1 ? false : IntersectsSegment(index, x1, y1, x2, y2));
        }
		public Polygon GetPolygon (BoundingBoxAttachment attachment) {
			int index = BoundingBoxes.IndexOf(attachment);
			return index == -1 ? null : Polygons.Items[index];
		}
Esempio n. 28
0
 /** Returns true if the bounding box attachment contains the point. The bounding box must be in the SkeletonBounds. */
 public bool containsPoint(BoundingBoxAttachment attachment, float x, float y)
 {
     int index = BoundingBoxes.IndexOf(attachment);
     return index == -1 ? false : ContainsPoint(index, x, y);
 }