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;
}
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);
}
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);
}
/// <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];
}
public Polygon GetPolygon(BoundingBoxAttachment attachment)
{
int num = BoundingBoxes.IndexOf(attachment);
return((num != -1) ? Polygons.Items[num] : null);
}
public Polygon getPolygon(BoundingBoxAttachment attachment)
{
int index = BoundingBoxes.IndexOf(attachment);
return(index == -1 ? null : Polygons[index]);
}
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);
}
}
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);
}
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);
}
}
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);
}
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;
}
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);
}
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);
}
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);
}
/** 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);
}
/** 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];
}
/** 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);
}
