private Attachment ReadAttachment(Skin skin, String name, Dictionary <String, Object> map)
{
if (map.ContainsKey("name"))
{
name = (String)map["name"];
}
AttachmentType type = AttachmentType.region;
if (map.ContainsKey("type"))
{
type = (AttachmentType)Enum.Parse(typeof(AttachmentType), (String)map["type"], false);
}
Attachment attachment = attachmentLoader.NewAttachment(skin, type, name);
if (attachment is RegionAttachment)
{
RegionAttachment regionAttachment = (RegionAttachment)attachment;
regionAttachment.X = GetFloat(map, "x", 0) * Scale;
regionAttachment.Y = GetFloat(map, "y", 0) * Scale;
regionAttachment.ScaleX = GetFloat(map, "scaleX", 1);
regionAttachment.ScaleY = GetFloat(map, "scaleY", 1);
regionAttachment.Rotation = GetFloat(map, "rotation", 0);
regionAttachment.Width = GetFloat(map, "width", 32) * Scale;
regionAttachment.Height = GetFloat(map, "height", 32) * Scale;
regionAttachment.UpdateOffset();
}
return(attachment);
}
private Attachment ReadAttachment(Skin skin, String name, Dictionary <String, Object> map)
{
if (map.ContainsKey("name"))
{
name = (String)map["name"];
}
AttachmentType type = AttachmentType.region;
if (map.ContainsKey("type"))
{
type = (AttachmentType)Enum.Parse(typeof(AttachmentType), (String)map["type"], false);
}
Attachment attachment = attachmentLoader.NewAttachment(skin, type, name);
RegionAttachment regionAttachment = attachment as RegionAttachment;
if (regionAttachment != null)
{
regionAttachment.x = GetFloat(map, "x", 0) * Scale;
regionAttachment.y = GetFloat(map, "y", 0) * Scale;
regionAttachment.scaleX = GetFloat(map, "scaleX", 1);
regionAttachment.scaleY = GetFloat(map, "scaleY", 1);
regionAttachment.rotation = GetFloat(map, "rotation", 0);
regionAttachment.width = GetFloat(map, "width", 32) * Scale;
regionAttachment.height = GetFloat(map, "height", 32) * Scale;
regionAttachment.UpdateOffset();
}
BoundingBoxAttachment boundingBox = attachment as BoundingBoxAttachment;
if (boundingBox != null)
{
List <Object> values = (List <Object>)map["vertices"];
float[] vertices = new float[values.Count];
for (int i = 0, n = values.Count; i < n; i++)
{
vertices[i] = (float)values[i] * Scale;
}
boundingBox.Vertices = vertices;
}
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);
}
public RegionAttachment NewRegionAttachment(Skin skin, string name, string path)
{
RegionAttachment attachment = new RegionAttachment(name);
Texture2D tex = sprite.texture;
int instanceId = tex.GetInstanceID();
AtlasRegion atlasRegion;
//check cache first
if (atlasTable.ContainsKey(instanceId)) {
atlasRegion = atlasTable[instanceId];
} else {
//Setup new material
Material mat = new Material(shader);
if (sprite.packed)
mat.name = "Unity Packed Sprite Material";
else
mat.name = sprite.name + " Sprite Material";
mat.mainTexture = tex;
//create faux-region to play nice with SkeletonRenderer
atlasRegion = new AtlasRegion();
AtlasPage page = new AtlasPage();
page.rendererObject = mat;
atlasRegion.page = page;
//cache it
atlasTable[instanceId] = atlasRegion;
}
Rect texRect = sprite.textureRect;
//normalize rect to UV space of packed atlas
texRect.x = Mathf.InverseLerp(0, tex.width, texRect.x);
texRect.y = Mathf.InverseLerp(0, tex.height, texRect.y);
texRect.width = Mathf.InverseLerp(0, tex.width, texRect.width);
texRect.height = Mathf.InverseLerp(0, tex.height, texRect.height);
Bounds bounds = sprite.bounds;
Vector3 size = bounds.size;
//TODO: make sure this rotation thing actually works
bool rotated = false;
if (sprite.packed)
rotated = sprite.packingRotation == SpritePackingRotation.Any;
//do some math and assign UVs and sizes
attachment.SetUVs(texRect.xMin, texRect.yMax, texRect.xMax, texRect.yMin, rotated);
attachment.RendererObject = atlasRegion;
attachment.SetColor(Color.white);
attachment.ScaleX = 1;
attachment.ScaleY = 1;
attachment.RegionOffsetX = sprite.rect.width * (0.5f - Mathf.InverseLerp(bounds.min.x, bounds.max.x, 0)) / sprite.pixelsPerUnit;
attachment.RegionOffsetY = sprite.rect.height * (0.5f - Mathf.InverseLerp(bounds.min.y, bounds.max.y, 0)) / sprite.pixelsPerUnit;
attachment.Width = size.x;
attachment.Height = size.y;
attachment.RegionWidth = size.x;
attachment.RegionHeight = size.y;
attachment.RegionOriginalWidth = size.x;
attachment.RegionOriginalHeight = size.y;
attachment.UpdateOffset();
return attachment;
}
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);
}
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 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: {
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);
}
private Attachment ReadAttachment(NewStream 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 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; // Avoid unused local warning.
}
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);
}
}
return(null);
}
private Attachment ReadAttachment(Stream input, Skin skin, int slotIndex, string attachmentName, bool nonessential)
{
float scale = this.Scale;
string text = this.ReadString(input);
if (text == null)
{
text = attachmentName;
}
switch (input.ReadByte())
{
case 0:
{
string text2 = this.ReadString(input);
float rotation = this.ReadFloat(input);
float num = this.ReadFloat(input);
float num2 = this.ReadFloat(input);
float scaleX = this.ReadFloat(input);
float scaleY = this.ReadFloat(input);
float num3 = this.ReadFloat(input);
float num4 = this.ReadFloat(input);
int num5 = SkeletonBinary.ReadInt(input);
if (text2 == null)
{
text2 = text;
}
RegionAttachment regionAttachment = this.attachmentLoader.NewRegionAttachment(skin, text, text2);
if (regionAttachment == null)
{
return(null);
}
regionAttachment.Path = text2;
regionAttachment.x = num * scale;
regionAttachment.y = num2 * scale;
regionAttachment.scaleX = scaleX;
regionAttachment.scaleY = scaleY;
regionAttachment.rotation = rotation;
regionAttachment.width = num3 * scale;
regionAttachment.height = num4 * scale;
regionAttachment.r = (float)((num5 & 4278190080u) >> 24) / 255f;
regionAttachment.g = (float)((num5 & 16711680) >> 16) / 255f;
regionAttachment.b = (float)((num5 & 65280) >> 8) / 255f;
regionAttachment.a = (float)(num5 & 255) / 255f;
regionAttachment.UpdateOffset();
return(regionAttachment);
}
case 1:
{
int num6 = SkeletonBinary.ReadVarint(input, true);
Vertices vertices = this.ReadVertices(input, num6);
if (nonessential)
{
SkeletonBinary.ReadInt(input);
}
BoundingBoxAttachment boundingBoxAttachment = this.attachmentLoader.NewBoundingBoxAttachment(skin, text);
if (boundingBoxAttachment == null)
{
return(null);
}
boundingBoxAttachment.worldVerticesLength = num6 << 1;
boundingBoxAttachment.vertices = vertices.vertices;
boundingBoxAttachment.bones = vertices.bones;
return(boundingBoxAttachment);
}
case 2:
{
string text3 = this.ReadString(input);
int num7 = SkeletonBinary.ReadInt(input);
int num8 = SkeletonBinary.ReadVarint(input, true);
float[] regionUVs = this.ReadFloatArray(input, num8 << 1, 1f);
int[] triangles = this.ReadShortArray(input);
Vertices vertices2 = this.ReadVertices(input, num8);
int num9 = SkeletonBinary.ReadVarint(input, true);
int[] edges = null;
float num10 = 0f;
float num11 = 0f;
if (nonessential)
{
edges = this.ReadShortArray(input);
num10 = this.ReadFloat(input);
num11 = this.ReadFloat(input);
}
if (text3 == null)
{
text3 = text;
}
MeshAttachment meshAttachment = this.attachmentLoader.NewMeshAttachment(skin, text, text3);
if (meshAttachment == null)
{
return(null);
}
meshAttachment.Path = text3;
meshAttachment.r = (float)((num7 & 4278190080u) >> 24) / 255f;
meshAttachment.g = (float)((num7 & 16711680) >> 16) / 255f;
meshAttachment.b = (float)((num7 & 65280) >> 8) / 255f;
meshAttachment.a = (float)(num7 & 255) / 255f;
meshAttachment.bones = vertices2.bones;
meshAttachment.vertices = vertices2.vertices;
meshAttachment.WorldVerticesLength = num8 << 1;
meshAttachment.triangles = triangles;
meshAttachment.regionUVs = regionUVs;
meshAttachment.UpdateUVs();
meshAttachment.HullLength = num9 << 1;
if (nonessential)
{
meshAttachment.Edges = edges;
meshAttachment.Width = num10 * scale;
meshAttachment.Height = num11 * scale;
}
return(meshAttachment);
}
case 3:
{
string text4 = this.ReadString(input);
int num12 = SkeletonBinary.ReadInt(input);
string skin2 = this.ReadString(input);
string parent = this.ReadString(input);
bool inheritDeform = SkeletonBinary.ReadBoolean(input);
float num13 = 0f;
float num14 = 0f;
if (nonessential)
{
num13 = this.ReadFloat(input);
num14 = this.ReadFloat(input);
}
if (text4 == null)
{
text4 = text;
}
MeshAttachment meshAttachment2 = this.attachmentLoader.NewMeshAttachment(skin, text, text4);
if (meshAttachment2 == null)
{
return(null);
}
meshAttachment2.Path = text4;
meshAttachment2.r = (float)((num12 & 4278190080u) >> 24) / 255f;
meshAttachment2.g = (float)((num12 & 16711680) >> 16) / 255f;
meshAttachment2.b = (float)((num12 & 65280) >> 8) / 255f;
meshAttachment2.a = (float)(num12 & 255) / 255f;
meshAttachment2.inheritDeform = inheritDeform;
if (nonessential)
{
meshAttachment2.Width = num13 * scale;
meshAttachment2.Height = num14 * scale;
}
this.linkedMeshes.Add(new SkeletonJson.LinkedMesh(meshAttachment2, skin2, slotIndex, parent));
return(meshAttachment2);
}
case 4:
{
bool closed = SkeletonBinary.ReadBoolean(input);
bool constantSpeed = SkeletonBinary.ReadBoolean(input);
int num15 = SkeletonBinary.ReadVarint(input, true);
Vertices vertices3 = this.ReadVertices(input, num15);
float[] array = new float[num15 / 3];
int i = 0;
int num16 = array.Length;
while (i < num16)
{
array[i] = this.ReadFloat(input) * scale;
i++;
}
if (nonessential)
{
SkeletonBinary.ReadInt(input);
}
PathAttachment pathAttachment = this.attachmentLoader.NewPathAttachment(skin, text);
if (pathAttachment == null)
{
return(null);
}
pathAttachment.closed = closed;
pathAttachment.constantSpeed = constantSpeed;
pathAttachment.worldVerticesLength = num15 << 1;
pathAttachment.vertices = vertices3.vertices;
pathAttachment.bones = vertices3.bones;
pathAttachment.lengths = array;
return(pathAttachment);
}
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.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: {
MeshAttachment mesh = attachmentLoader.NewMeshAttachment(skin, name, path);
if (mesh == null)
{
return(null);
}
mesh.Path = path;
float[] uvs = GetFloatArray(map, "uvs", 1);
int[] triangles = GetIntArray(map, "triangles");
float[] vertices = GetFloatArray(map, "vertices", Scale);
mesh.SetMesh(vertices, triangles, uvs);
mesh.UpdateUVs();
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);
}
mesh.Path = path;
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);
mesh.UpdateUVs();
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 void addSkeletonAttachment(string slotName, string attachmentName, TextureData textureData)
{
RegionAttachment regionAttachment = new RegionAttachment(attachmentName);
regionAttachment.RendererObject = textureData.Texture;
regionAttachment.Width = regionAttachment.RegionWidth = regionAttachment.RegionOriginalWidth = textureData.Texture.Width;
regionAttachment.Height = regionAttachment.RegionHeight = regionAttachment.RegionOriginalHeight = textureData.Texture.Height;
regionAttachment.RegionOffsetX = textureData.OriginX;
regionAttachment.RegionOffsetY = textureData.OriginY;
regionAttachment.Rotation = textureData.Rotation;
regionAttachment.SetUVs(0, 0, 1, 1, false);
regionAttachment.UpdateOffset();
Skeleton.Data.FindSkin("default").AddAttachment(Skeleton.FindSlotIndex(slotName), attachmentName, regionAttachment);
}
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(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 RegionAttachment NewRegionAttachment (Skin skin, string name, string path) {
RegionAttachment attachment = new RegionAttachment(name);
Texture2D tex = sprite.texture;
int instanceId = tex.GetInstanceID();
AtlasRegion atlasRegion;
bool cachedMaterialExists = atlasTable.TryGetValue(instanceId, out atlasRegion);
if (!cachedMaterialExists) {
// Setup new material.
var material = new Material(shader);
if (sprite.packed)
material.name = "Unity Packed Sprite Material";
else
material.name = sprite.name + " Sprite Material";
material.mainTexture = tex;
// Create faux-region to play nice with SkeletonRenderer.
atlasRegion = new AtlasRegion();
var page = new AtlasPage();
page.rendererObject = material;
atlasRegion.page = page;
// Cache it.
atlasTable[instanceId] = atlasRegion;
}
Rect texRect = sprite.textureRect;
// Normalize rect to UV space of packed atlas
texRect.x = Mathf.InverseLerp(0, tex.width, texRect.x);
texRect.y = Mathf.InverseLerp(0, tex.height, texRect.y);
texRect.width = Mathf.InverseLerp(0, tex.width, texRect.width);
texRect.height = Mathf.InverseLerp(0, tex.height, texRect.height);
Bounds bounds = sprite.bounds;
Vector2 boundsMin = bounds.min, boundsMax = bounds.max;
Vector2 size = bounds.size;
float spriteUnitsPerPixel = 1f / sprite.pixelsPerUnit;
bool rotated = false;
if (sprite.packed)
rotated = sprite.packingRotation == SpritePackingRotation.Any;
attachment.SetUVs(texRect.xMin, texRect.yMax, texRect.xMax, texRect.yMin, rotated);
attachment.RendererObject = atlasRegion;
attachment.SetColor(Color.white);
attachment.ScaleX = 1;
attachment.ScaleY = 1;
attachment.RegionOffsetX = sprite.rect.width * (0.5f - InverseLerp(boundsMin.x, boundsMax.x, 0)) * spriteUnitsPerPixel;
attachment.RegionOffsetY = sprite.rect.height * (0.5f - InverseLerp(boundsMin.y, boundsMax.y, 0)) * spriteUnitsPerPixel;
attachment.Width = size.x;
attachment.Height = size.y;
attachment.RegionWidth = size.x;
attachment.RegionHeight = size.y;
attachment.RegionOriginalWidth = size.x;
attachment.RegionOriginalHeight = size.y;
attachment.UpdateOffset();
return attachment;
}
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);
}
}
