// this is the attachment loader which will hook into Futile's AtlasManager for the attachment/element data
public Attachment NewAttachment(Skin skin, AttachmentType type, String name)
{
switch(type){
case AttachmentType.region:
FAtlasElement element = Futile.atlasManager.GetElementWithName(name);
RegionAttachment attachment = new RegionAttachment(name);
if(element != null){
attachment.Texture = element;
attachment.SetUVs(element.uvBottomLeft.x, element.uvBottomLeft.y, element.uvTopRight.x, element.uvTopRight.y, false);
attachment.RegionOffsetX = 0.0f;
attachment.RegionOffsetY = 0.0f;
attachment.RegionWidth = element.sourceSize.x;
attachment.RegionHeight = element.sourceSize.y;
attachment.RegionOriginalWidth = element.sourceSize.x;
attachment.RegionOriginalHeight = element.sourceSize.y;
}else{
attachment.Texture = null;
attachment.SetUVs(0.0f, 0.0f, 0.0f, 0.0f, false);
attachment.RegionOffsetX = 0.0f;
attachment.RegionOffsetY = 0.0f;
attachment.RegionWidth = 0.0f;
attachment.RegionHeight = 0.0f;
attachment.RegionOriginalWidth = 0.0f;
attachment.RegionOriginalHeight = 0.0f;
Debug.Log("Element [" + name + "] not found in Futile.AtlasManager");
}
return attachment;
}
throw new Exception("Unknown attachment type: " + type);
}
public Attachment NewAttachment(Skin skin, AttachmentType type, String name)
{
if (type != AttachmentType.region)
throw new Exception("Unknown attachment type: " + type);
// Strip folder names.
int index = name.LastIndexOfAny(new char[] {'/', '\\'});
if (index != -1)
name = name.Substring(index + 1);
tk2dSpriteDefinition def = sprites.GetSpriteDefinition(name);
if (def == null)
throw new Exception("Sprite not found in atlas: " + name + " (" + type + ")");
if (def.complexGeometry)
throw new NotImplementedException("Complex geometry is not supported: " + name + " (" + type + ")");
if (def.flipped == tk2dSpriteDefinition.FlipMode.TPackerCW)
throw new NotImplementedException("Only 2D Toolkit atlases are supported: " + name + " (" + type + ")");
RegionAttachment attachment = new RegionAttachment(name);
Vector2 minTexCoords = Vector2.one;
Vector2 maxTexCoords = Vector2.zero;
for (int i = 0; i < def.uvs.Length; ++i) {
Vector2 uv = def.uvs[i];
minTexCoords = Vector2.Min(minTexCoords, uv);
maxTexCoords = Vector2.Max(maxTexCoords, uv);
}
bool rotated = def.flipped == tk2dSpriteDefinition.FlipMode.Tk2d;
if (rotated) {
float temp = minTexCoords.x;
minTexCoords.x = maxTexCoords.x;
maxTexCoords.x = temp;
}
attachment.SetUVs(
minTexCoords.x,
maxTexCoords.y,
maxTexCoords.x,
minTexCoords.y,
rotated
);
attachment.RegionOriginalWidth = (int)(def.untrimmedBoundsData[1].x / def.texelSize.x);
attachment.RegionOriginalHeight = (int)(def.untrimmedBoundsData[1].y / def.texelSize.y);
attachment.RegionWidth = (int)(def.boundsData[1].x / def.texelSize.x);
attachment.RegionHeight = (int)(def.boundsData[1].y / def.texelSize.y);
float x0 = def.untrimmedBoundsData[0].x - def.untrimmedBoundsData[1].x / 2;
float x1 = def.boundsData[0].x - def.boundsData[1].x / 2;
attachment.RegionOffsetX = (int)((x1 - x0) / def.texelSize.x);
float y0 = def.untrimmedBoundsData[0].y - def.untrimmedBoundsData[1].y / 2;
float y1 = def.boundsData[0].y - def.boundsData[1].y / 2;
attachment.RegionOffsetY = (int)((y1 - y0) / def.texelSize.y);
attachment.RendererObject = def.material;
return attachment;
}
public RegionAttachment NewRegionAttachment(Skin skin, String name, String path)
{
FAtlasElement element = Futile.atlasManager.GetElementWithName(name);
RegionAttachment attachment = new RegionAttachment(name);
if(element != null){
attachment.RendererObject = element;
attachment.SetUVs(element.uvBottomLeft.x, element.uvBottomLeft.y, element.uvTopRight.x, element.uvTopRight.y, false);
attachment.RegionOffsetX = 0.0f;
attachment.RegionOffsetY = 0.0f;
attachment.RegionWidth = element.sourceSize.x;
attachment.RegionHeight = element.sourceSize.y;
attachment.RegionOriginalWidth = element.sourceSize.x;
attachment.RegionOriginalHeight = element.sourceSize.y;
}else{
attachment.RendererObject = null;
attachment.SetUVs(0.0f, 0.0f, 0.0f, 0.0f, false);
attachment.RegionOffsetX = 0.0f;
attachment.RegionOffsetY = 0.0f;
attachment.RegionWidth = 0.0f;
attachment.RegionHeight = 0.0f;
attachment.RegionOriginalWidth = 0.0f;
attachment.RegionOriginalHeight = 0.0f;
Debug.Log("Element [" + name + "] not found in Futile.AtlasManager");
}
return attachment;
}
public Attachment NewAttachment(Skin skin, AttachmentType type, String name)
{
if (type != AttachmentType.region) throw new Exception("Unknown attachment type: " + type);
// Strip folder names.
int index = name.LastIndexOfAny(new char[] {'/', '\\'});
if (index != -1) name = name.Substring(index + 1);
tk2dSpriteDefinition attachmentParameters = null;
for (int i = 0; i < sprites.inst.spriteDefinitions.Length; ++i) {
tk2dSpriteDefinition def = sprites.inst.spriteDefinitions[i];
if (def.name == name) {
attachmentParameters = def;
break;
}
}
if (attachmentParameters == null) throw new Exception("Sprite not found in atlas: " + name + " (" + type + ")");
if (attachmentParameters.complexGeometry) throw new NotImplementedException("Complex geometry is not supported: " + name + " (" + type + ")");
if (attachmentParameters.flipped == tk2dSpriteDefinition.FlipMode.TPackerCW) throw new NotImplementedException("Only 2D Toolkit atlases are supported: " + name + " (" + type + ")");
Vector2 minTexCoords = Vector2.one;
Vector2 maxTexCoords = Vector2.zero;
for (int i = 0; i < attachmentParameters.uvs.Length; ++i) {
Vector2 uv = attachmentParameters.uvs[i];
minTexCoords = Vector2.Min(minTexCoords, uv);
maxTexCoords = Vector2.Max(maxTexCoords, uv);
}
Texture texture = attachmentParameters.material.mainTexture;
int width = (int)(Mathf.Abs(maxTexCoords.x - minTexCoords.x) * texture.width);
int height = (int)(Mathf.Abs(maxTexCoords.y - minTexCoords.y) * texture.height);
bool rotated = (attachmentParameters.flipped == tk2dSpriteDefinition.FlipMode.Tk2d);
if (rotated) {
float temp = minTexCoords.x;
minTexCoords.x = maxTexCoords.x;
maxTexCoords.x = temp;
}
RegionAttachment attachment = new RegionAttachment(name);
attachment.SetUVs(
minTexCoords.x,
maxTexCoords.y,
maxTexCoords.x,
minTexCoords.y,
rotated
);
// TODO - Set attachment.RegionOffsetX/Y. What units does attachmentParameters.untrimmedBoundsData use?!
attachment.RegionWidth = width;
attachment.RegionHeight = height;
attachment.RegionOriginalWidth = width;
attachment.RegionOriginalHeight = height;
return attachment;
}
void spRegionAttachment_updateQuad(ref RegionAttachment self, ref Slot slot, CCV3F_C4B_T2F_Quad quad, bool premultipliedAlpha)
{
float[] vertices = new float[8];
self.ComputeWorldVertices(slot.Skeleton.X, slot.Skeleton.Y, slot.Bone, vertices);
float r = (slot.Skeleton.R * slot.R * 255);
float g = (slot.Skeleton.G * slot.G * 255);
float b = (slot.Skeleton.B * slot.B * 255);
float normalizedAlpha = slot.Skeleton.A * slot.A;
if (premultipliedAlpha)
{
r *= normalizedAlpha;
g *= normalizedAlpha;
b *= normalizedAlpha;
}
float a = normalizedAlpha * 255;
quad.BottomLeft.Colors.R = Convert.ToByte(r);
quad.BottomLeft.Colors.G = Convert.ToByte(g);
quad.BottomLeft.Colors.B = Convert.ToByte(b);
quad.BottomLeft.Colors.A = Convert.ToByte(a);
quad.TopLeft.Colors.R = Convert.ToByte(r);
quad.TopLeft.Colors.G = Convert.ToByte(g);
quad.TopLeft.Colors.B = Convert.ToByte(b);
quad.TopLeft.Colors.A = Convert.ToByte(a);
quad.TopRight.Colors.R = Convert.ToByte(r);
quad.TopRight.Colors.G = Convert.ToByte(g);
quad.TopRight.Colors.B = Convert.ToByte(b);
quad.TopRight.Colors.A = Convert.ToByte(a);
quad.BottomRight.Colors.R = Convert.ToByte(r);
quad.BottomRight.Colors.G = Convert.ToByte(g);
quad.BottomRight.Colors.B = Convert.ToByte(b);
quad.BottomRight.Colors.A = Convert.ToByte(a);
quad.BottomLeft.Vertices.X = vertices[RegionAttachment.X1];
quad.BottomLeft.Vertices.Y = vertices[RegionAttachment.Y1];
quad.TopLeft.Vertices.X = vertices[RegionAttachment.X2];
quad.TopLeft.Vertices.Y = vertices[RegionAttachment.Y2];
quad.TopRight.Vertices.X = vertices[RegionAttachment.X3];
quad.TopRight.Vertices.Y = vertices[RegionAttachment.Y3];
quad.BottomRight.Vertices.X = vertices[RegionAttachment.X4];
quad.BottomRight.Vertices.Y = vertices[RegionAttachment.Y4];
quad.BottomLeft.TexCoords.U = self.UVs[RegionAttachment.X1];
quad.BottomLeft.TexCoords.V = self.UVs[RegionAttachment.Y1];
quad.TopLeft.TexCoords.U = self.UVs[RegionAttachment.X2];
quad.TopLeft.TexCoords.V = self.UVs[RegionAttachment.Y2];
quad.TopRight.TexCoords.U = self.UVs[RegionAttachment.X3];
quad.TopRight.TexCoords.V = self.UVs[RegionAttachment.Y3];
quad.BottomRight.TexCoords.U = self.UVs[RegionAttachment.X4];
quad.BottomRight.TexCoords.V = self.UVs[RegionAttachment.Y4];
}
// update the attachment with the current slot data
public void Update(Slot slot)
{
_attachment = slot.Attachment as RegionAttachment;
_attachment.UpdateVertices(slot.Bone);
element = _attachment.Texture as FAtlasElement;
base.color = _slotCustomColor * new Color(slot.R, slot.G, slot.B, slot.A);
UpdateLocalVertices();
}
public Attachment NewAttachment(Skin skin,AttachmentType type,String name)
{
if(type != AttachmentType.region) throw new Exception("Unknown attachment type: " + type);
tk2dSpriteDefinition attachmentParameters = null;
for(int i = 0; i < sprites.spriteDefinitions.Length; ++i) {
tk2dSpriteDefinition def = sprites.spriteDefinitions[i];
if(def.name == name) {
attachmentParameters = def;
break;
}
}
if(attachmentParameters == null ) throw new Exception("Sprite not found in atlas: " + name + " (" + type + ")");
if(attachmentParameters.complexGeometry) throw new NotImplementedException("Complex geometry is not supported: " + name + " (" + type + ")");
if(attachmentParameters.flipped == tk2dSpriteDefinition.FlipMode.TPackerCW) throw new NotImplementedException("Only 2d toolkit atlases are supported: " + name + " (" + type + ")");
Texture tex = attachmentParameters.material.mainTexture;
Vector2 minTexCoords = Vector2.one;
Vector2 maxTexCoords = Vector2.zero;
for(int i = 0; i < attachmentParameters.uvs.Length; ++i) {
Vector2 uv = attachmentParameters.uvs[i];
minTexCoords = Vector2.Min(minTexCoords,uv);
maxTexCoords = Vector2.Max(maxTexCoords,uv);
}
int width = (int)(Mathf.Abs(maxTexCoords.x - minTexCoords.x) * tex.width);
int height = (int)(Mathf.Abs(maxTexCoords.y - minTexCoords.y) * tex.height);
bool rotated = (attachmentParameters.flipped == tk2dSpriteDefinition.FlipMode.Tk2d);
if(rotated) {
float temp = minTexCoords.x;
minTexCoords.x = maxTexCoords.x;
maxTexCoords.x = temp;
}
RegionAttachment attachment = new RegionAttachment(name);
attachment.SetUVs(
minTexCoords.x,
maxTexCoords.y,
maxTexCoords.x,
minTexCoords.y,
rotated
);
attachment.RegionWidth = width;
attachment.RegionHeight = height;
attachment.RegionOriginalWidth = width;
attachment.RegionOriginalHeight = height;
return attachment;
}
void spRegionAttachment_updateQuad(RegionAttachment self, Slot slot, CCV3F_C4B_T2F_Quad quad, bool premultipliedAlpha = false)
{
float[] vertices = new float[8];
self.ComputeWorldVertices(slot.Skeleton.X, slot.Skeleton.Y, slot.Bone, vertices);
byte r = Convert.ToByte(slot.Skeleton.R * slot.R * 255);
byte g =Convert.ToByte( slot.Skeleton.G * slot.G * 255);
byte b = Convert.ToByte(slot.Skeleton.B * slot.B * 255);
byte normalizedAlpha = Convert.ToByte( slot.Skeleton.A * slot.A);
if (premultipliedAlpha)
{
r *= normalizedAlpha;
g *= normalizedAlpha;
b *= normalizedAlpha;
}
byte a = Convert.ToByte(normalizedAlpha * 255);
quad.BottomLeft.Colors.R = r;
quad.BottomLeft.Colors.G = g;
quad.BottomLeft.Colors.B = b;
quad.BottomLeft.Colors.A = a;
quad.TopLeft.Colors.R = r;
quad.TopLeft.Colors.G = g;
quad.TopLeft.Colors.B = b;
quad.TopLeft.Colors.A = a;
quad.TopRight.Colors.R = r;
quad.TopRight.Colors.G = g;
quad.TopRight.Colors.B = b;
quad.TopRight.Colors.A = a;
quad.BottomRight.Colors.R = r;
quad.BottomRight.Colors.G = g;
quad.BottomRight.Colors.B = b;
quad.BottomRight.Colors.A = a;
quad.BottomLeft.Vertices.X = vertices[VERTEX_X1];
quad.BottomLeft.Vertices.Y = vertices[VERTEX_Y1];
quad.TopLeft.Vertices.X = vertices[VERTEX_X2];
quad.TopLeft.Vertices.Y = vertices[VERTEX_Y2];
quad.TopRight.Vertices.X = vertices[VERTEX_X3];
quad.TopRight.Vertices.Y = vertices[VERTEX_Y3];
quad.BottomRight.Vertices.X = vertices[VERTEX_X4];
quad.BottomRight.Vertices.Y = vertices[VERTEX_Y4];
quad.BottomLeft.TexCoords.U = self.UVs[VERTEX_X1];
quad.BottomLeft.TexCoords.V = self.UVs[VERTEX_Y1];
quad.TopLeft.TexCoords.U = self.UVs[VERTEX_X2];
quad.TopLeft.TexCoords.V = self.UVs[VERTEX_Y2];
quad.TopRight.TexCoords.U = self.UVs[VERTEX_X3];
quad.TopRight.TexCoords.V = self.UVs[VERTEX_Y3];
quad.BottomRight.TexCoords.U = self.UVs[VERTEX_X4];
quad.BottomRight.TexCoords.V = self.UVs[VERTEX_Y4];
}
public Attachment NewAttachment(AttachmentType type, String name)
{
switch (type) {
case AttachmentType.region:
AtlasRegion region = atlas.FindRegion(name);
if (region == null) throw new Exception("Region not found in atlas: " + name + " (" + type + ")");
RegionAttachment attachment = new RegionAttachment(name);
attachment.Region = region;
return attachment;
}
throw new Exception("Unknown attachment type: " + type);
}
private void DrawSlot(Skeleton skeleton, RegionAttachment attachment, Slot slot)
{
var region = (AtlasRegion)attachment.RendererObject;
var thisMaterial = (Material)region.page.rendererObject;
var thisBlendMode = slot.Data.AdditiveBlending ? BlendMode.Additive : BlendMode.Normal;
var thisBatch = (Batch2D)renderer.FindOrCreateBatch(thisMaterial, thisBlendMode);
if (currentBatch != null && currentBatch != thisBatch)
renderer.FlushDrawBuffer(currentBatch);
currentBatch = thisBatch;
attachment.ComputeWorldVertices(skeleton.X, skeleton.Y, slot.Bone, vertices);
currentColor = new Color(color.RedValue * slot.R, color.GreenValue * slot.G,
color.BlueValue * slot.B, color.AlphaValue * slot.A);
AddSlotIndicesAndVertices(attachment.UVs);
}
public RegionAttachment NewRegionAttachment (Skin skin, String name, String path) {
AtlasRegion region = atlas.FindRegion(path);
if (region == null) throw new Exception("Region not found in atlas: " + path + " (region attachment: " + name + ")");
RegionAttachment attachment = new RegionAttachment(name);
attachment.RendererObject = region;
attachment.SetUVs(region.u, region.v, region.u2, region.v2, region.rotate);
attachment.regionOffsetX = region.offsetX;
attachment.regionOffsetY = region.offsetY;
attachment.regionWidth = region.width;
attachment.regionHeight = region.height;
attachment.regionOriginalWidth = region.originalWidth;
attachment.regionOriginalHeight = region.originalHeight;
return attachment;
}
public void Attach () {
var skeletonRenderer = GetComponent<SkeletonRenderer>();
if (loader == null)
//create loader instance, tell it what sprite and shader to use
loader = new SpriteAttachmentLoader(sprite, Shader.Find("Spine/Skeleton"));
if (attachment == null)
attachment = loader.NewRegionAttachment(null, sprite.name, "");
skeletonRenderer.skeleton.FindSlot(slot).Attachment = attachment;
if (!keepLoaderInMemory)
loader = null;
}
// update the attachment with the current slot data
public void Update(Slot slot)
{
_attachment = slot.Attachment as RegionAttachment;
//_attachment.UpdateOffset();
//_attachment.UpdateVertices(slot.Bone);
_attachment.ComputeWorldVertices(slot.Bone, vertices);
element = _attachment.RendererObject as FAtlasElement;
element = null;
base.color = _slotCustomColor * new Color(slot.R, slot.G, slot.B, slot.A);
UpdateLocalVertices();
}
public Attachment NewAttachment(Skin skin, AttachmentType type, String name)
{
switch (type) {
case AttachmentType.region:
AtlasRegion region = atlas.FindRegion(name);
if (region == null) throw new Exception("Region not found in atlas: " + name + " (" + type + ")");
RegionAttachment attachment = new RegionAttachment(name);
attachment.RendererObject = region.page.rendererObject;
attachment.SetUVs(region.u, region.v, region.u2, region.v2, region.rotate);
attachment.RegionOffsetX = region.offsetX;
attachment.RegionOffsetY = region.offsetY;
attachment.RegionWidth = region.width;
attachment.RegionHeight = region.height;
attachment.RegionOriginalWidth = region.originalWidth;
attachment.RegionOriginalHeight = region.originalHeight;
return attachment;
}
throw new Exception("Unknown attachment type: " + type);
}
/// <summary>
/// Creates the region attachment by texture.
/// </summary>
/// <returns>The region attachment by texture.</returns>
/// <param name="slot">Slot.</param>
/// <param name="texture">Texture.</param>
private Attachment CreateRegionAttachmentByTexture(Spine.Slot slot, Texture2D texture)
{
if (slot == null)
{
return(null);
}
Spine.RegionAttachment oldAtt = slot.Attachment as Spine.RegionAttachment;
if (oldAtt == null || texture == null)
{
return(null);
}
Spine.RegionAttachment att = new Spine.RegionAttachment(oldAtt.Name);
att.RendererObject = CreateRegion(texture);
att.Width = oldAtt.Width;
att.Height = oldAtt.Height;
att.offset = oldAtt.offset;
att.Path = oldAtt.Path;
att.R = oldAtt.R;
att.G = oldAtt.G;
att.B = oldAtt.B;
att.A = oldAtt.A;
att.X = oldAtt.X;
att.y = oldAtt.Y;
att.Rotation = oldAtt.Rotation;
att.ScaleX = oldAtt.ScaleX;
att.ScaleY = oldAtt.ScaleY;
att.SetUVs(0f, 1f, 1f, 0f, false);
Material mat = new Material(Shader.Find("Sprites/Default"));
mat.mainTexture = texture;
(att.RendererObject as Spine.AtlasRegion).page.rendererObject = mat;
slot.Attachment = att;
return(slot.Attachment);
}
public void Attach () {
var skeletonComponent = GetComponent<ISkeletonComponent>();
var skeletonRenderer = skeletonComponent as SkeletonRenderer;
if (skeletonRenderer != null)
this.applyPMA = skeletonRenderer.pmaVertexColors;
else {
var skeletonGraphic = skeletonComponent as SkeletonGraphic;
if (skeletonGraphic != null)
this.applyPMA = skeletonGraphic.SpineMeshGenerator.PremultiplyVertexColors;
}
Shader attachmentShader = applyPMA ? Shader.Find(DefaultPMAShader) : Shader.Find(DefaultStraightAlphaShader);
loader = loader ?? new SpriteAttachmentLoader(sprite, attachmentShader, applyPMA);
if (attachment == null)
attachment = loader.NewRegionAttachment(null, sprite.name, "");
skeletonComponent.Skeleton.FindSlot(slot).Attachment = attachment;
if (!keepLoaderInMemory)
loader = 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(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 void Draw(Skeleton skeleton)
{
List <Slot> drawOrder = skeleton.DrawOrder;
float x = skeleton.X, y = skeleton.Y;
float skeletonR = skeleton.R, skeletonG = skeleton.G, skeletonB = skeleton.B, skeletonA = skeleton.A;
for (int i = 0, n = drawOrder.Count; i < n; i++)
{
Slot slot = drawOrder[i];
RegionAttachment regionAttachment = slot.Attachment as RegionAttachment;
if (regionAttachment != null)
{
BlendState blend = slot.Data.AdditiveBlending ? BlendState.Additive : defaultBlendState;
if (device.BlendState != blend)
{
End();
device.BlendState = blend;
}
SpriteBatchItem item = batcher.CreateBatchItem();
AtlasRegion region = (AtlasRegion)regionAttachment.RendererObject;
item.Texture = (Texture2D)region.page.rendererObject;
Color color;
float a = skeletonA * slot.A;
if (premultipliedAlpha)
{
color = new Color(skeletonR * slot.R * a, skeletonG * slot.G * a, skeletonB * slot.B * a, a);
}
else
{
color = new Color(skeletonR * slot.R, skeletonG * slot.G, skeletonB * slot.B, a);
}
item.vertexTL.Color = color;
item.vertexBL.Color = color;
item.vertexBR.Color = color;
item.vertexTR.Color = color;
float[] vertices = this.vertices;
regionAttachment.ComputeWorldVertices(x, y, slot.Bone, vertices);
item.vertexTL.Position.X = vertices[RegionAttachment.X1];
item.vertexTL.Position.Y = vertices[RegionAttachment.Y1];
item.vertexTL.Position.Z = 0;
item.vertexBL.Position.X = vertices[RegionAttachment.X2];
item.vertexBL.Position.Y = vertices[RegionAttachment.Y2];
item.vertexBL.Position.Z = 0;
item.vertexBR.Position.X = vertices[RegionAttachment.X3];
item.vertexBR.Position.Y = vertices[RegionAttachment.Y3];
item.vertexBR.Position.Z = 0;
item.vertexTR.Position.X = vertices[RegionAttachment.X4];
item.vertexTR.Position.Y = vertices[RegionAttachment.Y4];
item.vertexTR.Position.Z = 0;
float[] uvs = regionAttachment.UVs;
item.vertexTL.TextureCoordinate.X = uvs[RegionAttachment.X1];
item.vertexTL.TextureCoordinate.Y = uvs[RegionAttachment.Y1];
item.vertexBL.TextureCoordinate.X = uvs[RegionAttachment.X2];
item.vertexBL.TextureCoordinate.Y = uvs[RegionAttachment.Y2];
item.vertexBR.TextureCoordinate.X = uvs[RegionAttachment.X3];
item.vertexBR.TextureCoordinate.Y = uvs[RegionAttachment.Y3];
item.vertexTR.TextureCoordinate.X = uvs[RegionAttachment.X4];
item.vertexTR.TextureCoordinate.Y = uvs[RegionAttachment.Y4];
}
}
}
//virtual cocos2d::CCTextureAtlas* getTextureAtlas (RegionAttachment regionAttachment);
#region SpinesCocos2d
void UpdateRegionAttachmentQuad(RegionAttachment self, Slot slot, ref CCV3F_C4B_T2F_Quad quad, bool premultipliedAlpha = false)
{
float[] vertices = new float[8];
self.ComputeWorldVertices(slot.Skeleton.X, slot.Skeleton.Y, slot.Bone, vertices);
float r = slot.Skeleton.R * slot.R * 255;
float g = slot.Skeleton.G * slot.G * 255;
float b = slot.Skeleton.B * slot.B * 255;
float normalizedAlpha = slot.Skeleton.A * slot.A;
if (premultipliedAlpha)
{
r *= normalizedAlpha;
g *= normalizedAlpha;
b *= normalizedAlpha;
}
float a = normalizedAlpha * 255;
quad.BottomLeft.Colors.R = (byte)r;
quad.BottomLeft.Colors.G = (byte)g;
quad.BottomLeft.Colors.B = (byte)b;
quad.BottomLeft.Colors.A = (byte)a;
quad.TopLeft.Colors.R = (byte)r;
quad.TopLeft.Colors.G = (byte)g;
quad.TopLeft.Colors.B = (byte)b;
quad.TopLeft.Colors.A = (byte)a;
quad.TopRight.Colors.R = (byte)r;
quad.TopRight.Colors.G = (byte)g;
quad.TopRight.Colors.B = (byte)b;
quad.TopRight.Colors.A = (byte)a;
quad.BottomRight.Colors.R = (byte)r;
quad.BottomRight.Colors.G = (byte)g;
quad.BottomRight.Colors.B = (byte)b;
quad.BottomRight.Colors.A = (byte)a;
quad.BottomLeft.Vertices.X = vertices[RegionAttachment.X1];
quad.BottomLeft.Vertices.Y = vertices[RegionAttachment.Y1];
quad.TopLeft.Vertices.X = vertices[RegionAttachment.X2];
quad.TopLeft.Vertices.Y = vertices[RegionAttachment.Y2];
quad.TopRight.Vertices.X = vertices[RegionAttachment.X3];
quad.TopRight.Vertices.Y = vertices[RegionAttachment.Y3];
quad.BottomRight.Vertices.X = vertices[RegionAttachment.X4];
quad.BottomRight.Vertices.Y = vertices[RegionAttachment.Y4];
quad.BottomLeft.TexCoords.U = self.UVs[RegionAttachment.X1];
quad.BottomLeft.TexCoords.V = self.UVs[RegionAttachment.Y1];
quad.TopLeft.TexCoords.U = self.UVs[RegionAttachment.X2];
quad.TopLeft.TexCoords.V = self.UVs[RegionAttachment.Y2];
quad.TopRight.TexCoords.U = self.UVs[RegionAttachment.X3];
quad.TopRight.TexCoords.V = self.UVs[RegionAttachment.Y3];
quad.BottomRight.TexCoords.U = self.UVs[RegionAttachment.X4];
quad.BottomRight.TexCoords.V = self.UVs[RegionAttachment.Y4];
}
public void Draw(Skeleton skeleton)
{
float[] vertices = this.vertices;
List <Slot> drawOrder = skeleton.DrawOrder;
float skeletonR = skeleton.R, skeletonG = skeleton.G, skeletonB = skeleton.B, skeletonA = skeleton.A;
for (int i = 0, n = drawOrder.Count; i < n; i++)
{
Slot slot = drawOrder[i];
Attachment attachment = slot.Attachment;
if (attachment is RegionAttachment)
{
RegionAttachment regionAttachment = (RegionAttachment)attachment;
BlendState blend = slot.Data.AdditiveBlending ? BlendState.Additive : defaultBlendState;
if (device.BlendState != blend)
{
End();
device.BlendState = blend;
}
MeshItem item = batcher.NextItem(4, 6);
item.triangles = quadTriangles;
VertexPositionColorTexture[] itemVertices = item.vertices;
AtlasRegion region = (AtlasRegion)regionAttachment.RendererObject;
item.texture = (Texture2D)region.page.rendererObject;
Color color;
float a = skeletonA * slot.A * regionAttachment.A;
if (premultipliedAlpha)
{
color = new Color(
skeletonR * slot.R * regionAttachment.R * a,
skeletonG * slot.G * regionAttachment.G * a,
skeletonB * slot.B * regionAttachment.B * a, a);
}
else
{
color = new Color(
skeletonR * slot.R * regionAttachment.R,
skeletonG * slot.G * regionAttachment.G,
skeletonB * slot.B * regionAttachment.B, a);
}
itemVertices[TL].Color = color;
itemVertices[BL].Color = color;
itemVertices[BR].Color = color;
itemVertices[TR].Color = color;
regionAttachment.ComputeWorldVertices(slot.Bone, vertices);
itemVertices[TL].Position.X = vertices[RegionAttachment.X1];
itemVertices[TL].Position.Y = vertices[RegionAttachment.Y1];
itemVertices[TL].Position.Z = 0;
itemVertices[BL].Position.X = vertices[RegionAttachment.X2];
itemVertices[BL].Position.Y = vertices[RegionAttachment.Y2];
itemVertices[BL].Position.Z = 0;
itemVertices[BR].Position.X = vertices[RegionAttachment.X3];
itemVertices[BR].Position.Y = vertices[RegionAttachment.Y3];
itemVertices[BR].Position.Z = 0;
itemVertices[TR].Position.X = vertices[RegionAttachment.X4];
itemVertices[TR].Position.Y = vertices[RegionAttachment.Y4];
itemVertices[TR].Position.Z = 0;
float[] uvs = regionAttachment.UVs;
itemVertices[TL].TextureCoordinate.X = uvs[RegionAttachment.X1];
itemVertices[TL].TextureCoordinate.Y = uvs[RegionAttachment.Y1];
itemVertices[BL].TextureCoordinate.X = uvs[RegionAttachment.X2];
itemVertices[BL].TextureCoordinate.Y = uvs[RegionAttachment.Y2];
itemVertices[BR].TextureCoordinate.X = uvs[RegionAttachment.X3];
itemVertices[BR].TextureCoordinate.Y = uvs[RegionAttachment.Y3];
itemVertices[TR].TextureCoordinate.X = uvs[RegionAttachment.X4];
itemVertices[TR].TextureCoordinate.Y = uvs[RegionAttachment.Y4];
}
else if (attachment is MeshAttachment)
{
MeshAttachment mesh = (MeshAttachment)attachment;
int vertexCount = mesh.Vertices.Length;
if (vertices.Length < vertexCount)
{
vertices = new float[vertexCount];
}
mesh.ComputeWorldVertices(slot, vertices);
int[] triangles = mesh.Triangles;
MeshItem item = batcher.NextItem(vertexCount, triangles.Length);
item.triangles = triangles;
AtlasRegion region = (AtlasRegion)mesh.RendererObject;
item.texture = (Texture2D)region.page.rendererObject;
Color color;
float a = skeletonA * slot.A * mesh.A;
if (premultipliedAlpha)
{
color = new Color(
skeletonR * slot.R * mesh.R * a,
skeletonG * slot.G * mesh.G * a,
skeletonB * slot.B * mesh.B * a, a);
}
else
{
color = new Color(
skeletonR * slot.R * mesh.R,
skeletonG * slot.G * mesh.G,
skeletonB * slot.B * mesh.B, a);
}
float[] uvs = mesh.UVs;
VertexPositionColorTexture[] itemVertices = item.vertices;
for (int ii = 0, v = 0; v < vertexCount; ii++, v += 2)
{
itemVertices[ii].Color = color;
itemVertices[ii].Position.X = vertices[v];
itemVertices[ii].Position.Y = vertices[v + 1];
itemVertices[ii].Position.Z = 0;
itemVertices[ii].TextureCoordinate.X = uvs[v];
itemVertices[ii].TextureCoordinate.Y = uvs[v + 1];
}
}
else if (attachment is SkinnedMeshAttachment)
{
SkinnedMeshAttachment mesh = (SkinnedMeshAttachment)attachment;
int vertexCount = mesh.UVs.Length;
if (vertices.Length < vertexCount)
{
vertices = new float[vertexCount];
}
mesh.ComputeWorldVertices(slot, vertices);
int[] triangles = mesh.Triangles;
MeshItem item = batcher.NextItem(vertexCount, triangles.Length);
item.triangles = triangles;
AtlasRegion region = (AtlasRegion)mesh.RendererObject;
item.texture = (Texture2D)region.page.rendererObject;
Color color;
float a = skeletonA * slot.A * mesh.A;
if (premultipliedAlpha)
{
color = new Color(
skeletonR * slot.R * mesh.R * a,
skeletonG * slot.G * mesh.G * a,
skeletonB * slot.B * mesh.B * a, a);
}
else
{
color = new Color(
skeletonR * slot.R * mesh.R,
skeletonG * slot.G * mesh.G,
skeletonB * slot.B * mesh.B, a);
}
float[] uvs = mesh.UVs;
VertexPositionColorTexture[] itemVertices = item.vertices;
for (int ii = 0, v = 0; v < vertexCount; ii++, v += 2)
{
itemVertices[ii].Color = color;
itemVertices[ii].Position.X = vertices[v];
itemVertices[ii].Position.Y = vertices[v + 1];
itemVertices[ii].Position.Z = 0;
itemVertices[ii].TextureCoordinate.X = uvs[v];
itemVertices[ii].TextureCoordinate.Y = uvs[v + 1];
}
}
}
}
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);
}
public CCTextureAtlas GetTextureAtlas(RegionAttachment attachment)
{
AtlasRegion regionAtlas = (AtlasRegion)attachment.RendererObject;
var texture2D = (Microsoft.Xna.Framework.Graphics.Texture2D)regionAtlas.page.rendererObject;
//Console.WriteLine(texture2D.IsDisposed);
return spine_cocos2dx.CreateAtlasFromTexture2D(texture2D);
}
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 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(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(Skin skin, int slotIndex, String name, Dictionary <String, Object> map)
{
string skinKey = name;
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);
string sourceSkin = GetString(map, "skin", null);
bool sourceDefaultSkin = sourceSkin == null || sourceSkin == "default";
linkedMeshes.Add(new LinkedMesh(mesh, sourceSkin, slotIndex, sourceDefaultSkin ? parent : skinKey));
}
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;)
{
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.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);
string sourceSkin = GetString(map, "skin", null);
bool sourceDefaultSkin = sourceSkin == null || sourceSkin == "default";
linkedMeshes.Add(new LinkedMesh(mesh, sourceSkin, slotIndex, sourceDefaultSkin ? parent : skinKey));
}
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);
}
static Mesh ExtractRegionAttachment (string name, RegionAttachment attachment, Mesh mesh = null) {
var bone = GetExtractionBone();
bone.X = -attachment.X;
bone.Y = -attachment.Y;
bone.UpdateWorldTransform();
Vector2[] uvs = ExtractUV(attachment.UVs);
float[] floatVerts = new float[8];
attachment.ComputeWorldVertices(bone, floatVerts);
Vector3[] verts = ExtractVerts(floatVerts);
//unrotate verts now that they're centered
for (int i = 0; i < verts.Length; i++) {
verts[i] = Quaternion.Euler(0, 0, -attachment.Rotation) * verts[i];
}
int[] triangles = new int[6] { 1, 3, 0, 2, 3, 1 };
Color color = new Color(attachment.R, attachment.G, attachment.B, attachment.A);
if (mesh == null)
mesh = new Mesh();
mesh.triangles = new int[0];
mesh.vertices = verts;
mesh.uv = uvs;
mesh.triangles = triangles;
mesh.colors = new Color[] { color, color, color, color };
mesh.RecalculateBounds();
mesh.RecalculateNormals();
mesh.name = name;
return mesh;
}
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);
}
public void Draw(Skeleton skeleton)
{
List <Slot> drawOrder = skeleton.DrawOrder;
for (int i = 0, n = drawOrder.Count; i < n; i++)
{
Slot slot = drawOrder[i];
RegionAttachment regionAttachment = slot.Attachment as RegionAttachment;
if (regionAttachment != null)
{
SpriteBatchItem item = batcher.CreateBatchItem();
item.Texture = (Texture2D)regionAttachment.RendererObject;
byte r = (byte)(skeleton.R * slot.R * 255);
byte g = (byte)(skeleton.G * slot.G * 255);
byte b = (byte)(skeleton.B * slot.B * 255);
byte a = (byte)(skeleton.A * slot.A * 255);
item.vertexTL.Color.R = r;
item.vertexTL.Color.G = g;
item.vertexTL.Color.B = b;
item.vertexTL.Color.A = a;
item.vertexBL.Color.R = r;
item.vertexBL.Color.G = g;
item.vertexBL.Color.B = b;
item.vertexBL.Color.A = a;
item.vertexBR.Color.R = r;
item.vertexBR.Color.G = g;
item.vertexBR.Color.B = b;
item.vertexBR.Color.A = a;
item.vertexTR.Color.R = r;
item.vertexTR.Color.G = g;
item.vertexTR.Color.B = b;
item.vertexTR.Color.A = a;
float[] vertices = this.vertices;
regionAttachment.ComputeVertices(slot.Bone, vertices);
item.vertexTL.Position.X = vertices[RegionAttachment.X1];
item.vertexTL.Position.Y = vertices[RegionAttachment.Y1];
item.vertexTL.Position.Z = 0;
item.vertexBL.Position.X = vertices[RegionAttachment.X2];
item.vertexBL.Position.Y = vertices[RegionAttachment.Y2];
item.vertexBL.Position.Z = 0;
item.vertexBR.Position.X = vertices[RegionAttachment.X3];
item.vertexBR.Position.Y = vertices[RegionAttachment.Y3];
item.vertexBR.Position.Z = 0;
item.vertexTR.Position.X = vertices[RegionAttachment.X4];
item.vertexTR.Position.Y = vertices[RegionAttachment.Y4];
item.vertexTR.Position.Z = 0;
float[] uvs = regionAttachment.UVs;
item.vertexTL.TextureCoordinate.X = uvs[RegionAttachment.X1];
item.vertexTL.TextureCoordinate.Y = uvs[RegionAttachment.Y1];
item.vertexBL.TextureCoordinate.X = uvs[RegionAttachment.X2];
item.vertexBL.TextureCoordinate.Y = uvs[RegionAttachment.Y2];
item.vertexBR.TextureCoordinate.X = uvs[RegionAttachment.X3];
item.vertexBR.TextureCoordinate.Y = uvs[RegionAttachment.Y3];
item.vertexTR.TextureCoordinate.X = uvs[RegionAttachment.X4];
item.vertexTR.TextureCoordinate.Y = uvs[RegionAttachment.Y4];
}
}
}
private Attachment ReadAttachment(Stream input, Skin skin, String attachmentName, bool nonessential)
{
float scale = Scale;
String name = ReadString(input);
if (name == null)
{
name = attachmentName;
}
AttachmentType t = (AttachmentType)input.ReadByte();
switch (t)
{
case AttachmentType.region: {
String path = ReadString(input);
if (path == null)
{
path = name;
}
RegionAttachment region = attachmentLoader.NewRegionAttachment(skin, name, path);
//if (region == null) return null;
if (region == null)
{
region = new RegionAttachment(name);
}
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;
if (box == null)
{
box = new BoundingBoxAttachment(name);
}
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;
if (mesh == null)
{
mesh = new MeshAttachment(name);
}
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;
if (mesh == null)
{
mesh = new SkinnedMeshAttachment(name);
}
//ReadInt(input, true);
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 void GetBounds(out float x, out float y, out float width, out float height, ref float[] vertexBuffer)
{
float[] worldVertices = vertexBuffer;
if (worldVertices != null)
{
worldVertices = worldVertices;
}
else
{
worldVertices = new float[8];
}
Slot[] items = this.drawOrder.Items;
float num = 2.147484E+09f;
float num2 = 2.147484E+09f;
float num3 = -2.147484E+09f;
float num4 = -2.147484E+09f;
int index = 0;
int count = this.drawOrder.Count;
while (index < count)
{
Slot slot = items[index];
int worldVerticesLength = 0;
float[] numArray2 = null;
Attachment attachment = slot.attachment;
RegionAttachment attachment2 = attachment as RegionAttachment;
if (attachment2 != null)
{
worldVerticesLength = 8;
numArray2 = worldVertices;
if (numArray2.Length < 8)
{
numArray2 = worldVertices = new float[8];
}
attachment2.ComputeWorldVertices(slot.bone, worldVertices, 0, 2);
}
else
{
MeshAttachment attachment3 = attachment as MeshAttachment;
if (attachment3 != null)
{
MeshAttachment attachment4 = attachment3;
worldVerticesLength = attachment4.WorldVerticesLength;
numArray2 = worldVertices;
if (numArray2.Length < worldVerticesLength)
{
numArray2 = worldVertices = new float[worldVerticesLength];
}
attachment4.ComputeWorldVertices(slot, 0, worldVerticesLength, worldVertices, 0, 2);
}
}
if (numArray2 != null)
{
for (int i = 0; i < worldVerticesLength; i += 2)
{
float num9 = numArray2[i];
float num10 = numArray2[i + 1];
num = Math.Min(num, num9);
num2 = Math.Min(num2, num10);
num3 = Math.Max(num3, num9);
num4 = Math.Max(num4, num10);
}
}
index++;
}
x = num;
y = num2;
width = num3 - num;
height = num4 - num2;
vertexBuffer = worldVertices;
}
public void Draw(Skeleton skeleton)
{
List <Slot> drawOrder = skeleton.DrawOrder;
for (int i = 0, n = drawOrder.Count; i < n; i++)
{
Slot slot = drawOrder[i];
Attachment attachment = slot.Attachment;
if (attachment is RegionAttachment)
{
RegionAttachment regionAttachment = (RegionAttachment)attachment;
SpriteBatchItem item = batcher.CreateBatchItem();
item.Texture = (Texture2D)regionAttachment.Region.Atlas.Texture;
byte r = (byte)(slot.R * 255);
byte g = (byte)(slot.G * 255);
byte b = (byte)(slot.B * 255);
byte a = (byte)(slot.A * 255);
item.vertexTL.Color.R = r;
item.vertexTL.Color.G = g;
item.vertexTL.Color.B = b;
item.vertexTL.Color.A = a;
item.vertexBL.Color.R = r;
item.vertexBL.Color.G = g;
item.vertexBL.Color.B = b;
item.vertexBL.Color.A = a;
item.vertexBR.Color.R = r;
item.vertexBR.Color.G = g;
item.vertexBR.Color.B = b;
item.vertexBR.Color.A = a;
item.vertexTR.Color.R = r;
item.vertexTR.Color.G = g;
item.vertexTR.Color.B = b;
item.vertexTR.Color.A = a;
regionAttachment.UpdateVertices(slot.Bone);
float[] vertices = regionAttachment.Vertices;
item.vertexTL.Position.X = vertices[RegionAttachment.X1];
item.vertexTL.Position.Y = vertices[RegionAttachment.Y1];
item.vertexTL.Position.Z = 0;
item.vertexBL.Position.X = vertices[RegionAttachment.X2];
item.vertexBL.Position.Y = vertices[RegionAttachment.Y2];
item.vertexBL.Position.Z = 0;
item.vertexBR.Position.X = vertices[RegionAttachment.X3];
item.vertexBR.Position.Y = vertices[RegionAttachment.Y3];
item.vertexBR.Position.Z = 0;
item.vertexTR.Position.X = vertices[RegionAttachment.X4];
item.vertexTR.Position.Y = vertices[RegionAttachment.Y4];
item.vertexTR.Position.Z = 0;
float[] uvs = regionAttachment.UVs;
item.vertexTL.TextureCoordinate.X = uvs[RegionAttachment.X1];
item.vertexTL.TextureCoordinate.Y = uvs[RegionAttachment.Y1];
item.vertexBL.TextureCoordinate.X = uvs[RegionAttachment.X2];
item.vertexBL.TextureCoordinate.Y = uvs[RegionAttachment.Y2];
item.vertexBR.TextureCoordinate.X = uvs[RegionAttachment.X3];
item.vertexBR.TextureCoordinate.Y = uvs[RegionAttachment.Y3];
item.vertexTR.TextureCoordinate.X = uvs[RegionAttachment.X4];
item.vertexTR.TextureCoordinate.Y = uvs[RegionAttachment.Y4];
}
}
}
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);
}
}
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;
mesh.vertices = GetFloatArray(map, "vertices", Scale);
mesh.triangles = GetIntArray(map, "triangles");
mesh.regionUVs = GetFloatArray(map, "uvs", 1);
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);
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.bones = bones.ToArray();
mesh.weights = weights.ToArray();
mesh.triangles = GetIntArray(map, "triangles");
mesh.regionUVs = 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 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);
}
}
public RegionAttachment NewRegionAttachment (Skin skin, String name, String path) {
ProcessSpriteDefinition(path);
RegionAttachment region = new RegionAttachment(name);
region.Path = path;
region.RendererObject = material;
region.SetUVs(u, v, u2, v2, regionRotated);
region.RegionOriginalWidth = regionOriginalWidth;
region.RegionOriginalHeight = regionOriginalHeight;
region.RegionWidth = regionWidth;
region.RegionHeight = regionHeight;
region.RegionOffsetX = regionOffsetX;
region.RegionOffsetY = regionOffsetY;
return region;
}
public void Draw(Skeleton skeleton)
{
var drawOrder = skeleton.DrawOrder;
var drawOrderItems = skeleton.DrawOrder.Items;
float skeletonR = skeleton.R, skeletonG = skeleton.G, skeletonB = skeleton.B, skeletonA = skeleton.A;
Color color = new Color();
if (VertexEffect != null)
{
VertexEffect.Begin(skeleton);
}
for (int i = 0, n = drawOrder.Count; i < n; i++)
{
Slot slot = drawOrderItems[i];
Attachment attachment = slot.Attachment;
float attachmentColorR, attachmentColorG, attachmentColorB, attachmentColorA;
Texture2D texture = null;
int verticesCount = 0;
float[] vertices = this.vertices;
int indicesCount = 0;
int[] indices = null;
float[] uvs = null;
if (attachment is RegionAttachment)
{
RegionAttachment regionAttachment = (RegionAttachment)attachment;
attachmentColorR = regionAttachment.R; attachmentColorG = regionAttachment.G; attachmentColorB = regionAttachment.B; attachmentColorA = regionAttachment.A;
AtlasRegion region = (AtlasRegion)regionAttachment.RendererObject;
texture = (Texture2D)region.page.rendererObject;
verticesCount = 4;
regionAttachment.ComputeWorldVertices(slot.Bone, vertices, 0, 2);
indicesCount = 6;
indices = quadTriangles;
uvs = regionAttachment.UVs;
}
else if (attachment is MeshAttachment)
{
MeshAttachment mesh = (MeshAttachment)attachment;
attachmentColorR = mesh.R; attachmentColorG = mesh.G; attachmentColorB = mesh.B; attachmentColorA = mesh.A;
AtlasRegion region = (AtlasRegion)mesh.RendererObject;
texture = (Texture2D)region.page.rendererObject;
int vertexCount = mesh.WorldVerticesLength;
if (vertices.Length < vertexCount)
{
vertices = new float[vertexCount];
}
verticesCount = vertexCount >> 1;
mesh.ComputeWorldVertices(slot, vertices);
indicesCount = mesh.Triangles.Length;
indices = mesh.Triangles;
uvs = mesh.UVs;
}
else if (attachment is ClippingAttachment)
{
ClippingAttachment clip = (ClippingAttachment)attachment;
clipper.ClipStart(slot, clip);
continue;
}
else
{
continue;
}
// set blend state
BlendState blend = slot.Data.BlendMode == BlendMode.Additive ? BlendState.Additive : defaultBlendState;
if (device.BlendState != blend)
{
//End();
//device.BlendState = blend;
}
// calculate color
float a = skeletonA * slot.A * attachmentColorA;
if (premultipliedAlpha)
{
color = new Color(
skeletonR * slot.R * attachmentColorR * a,
skeletonG * slot.G * attachmentColorG * a,
skeletonB * slot.B * attachmentColorB * a, a);
}
else
{
color = new Color(
skeletonR * slot.R * attachmentColorR,
skeletonG * slot.G * attachmentColorG,
skeletonB * slot.B * attachmentColorB, a);
}
Color darkColor = new Color();
if (slot.HasSecondColor)
{
if (premultipliedAlpha)
{
darkColor = new Color(slot.R2 * a, slot.G2 * a, slot.B2 * a);
}
else
{
darkColor = new Color(slot.R2 * a, slot.G2 * a, slot.B2 * a);
}
}
darkColor.A = premultipliedAlpha ? (byte)255 : (byte)0;
// clip
if (clipper.IsClipping)
{
clipper.ClipTriangles(vertices, verticesCount << 1, indices, indicesCount, uvs);
vertices = clipper.ClippedVertices.Items;
verticesCount = clipper.ClippedVertices.Count >> 1;
indices = clipper.ClippedTriangles.Items;
indicesCount = clipper.ClippedTriangles.Count;
uvs = clipper.ClippedUVs.Items;
}
if (verticesCount == 0 || indicesCount == 0)
{
continue;
}
// submit to batch
MeshItem item = batcher.NextItem(verticesCount, indicesCount);
item.texture = texture;
for (int ii = 0, nn = indicesCount; ii < nn; ii++)
{
item.triangles[ii] = indices[ii];
}
VertexPositionColorTextureColor[] itemVertices = item.vertices;
for (int ii = 0, v = 0, nn = verticesCount << 1; v < nn; ii++, v += 2)
{
itemVertices[ii].Color = color;
itemVertices[ii].Color2 = darkColor;
itemVertices[ii].Position.X = vertices[v];
itemVertices[ii].Position.Y = vertices[v + 1];
itemVertices[ii].Position.Z = 0;
itemVertices[ii].TextureCoordinate.X = uvs[v];
itemVertices[ii].TextureCoordinate.Y = uvs[v + 1];
if (VertexEffect != null)
{
VertexEffect.Transform(ref itemVertices[ii]);
}
}
clipper.ClipEnd(slot);
}
clipper.ClipEnd();
if (VertexEffect != null)
{
VertexEffect.End();
}
}
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;
}
public void GetBounds(out float x, out float y, out float width, out float height, ref float[] vertexBuffer)
{
float[] array = vertexBuffer;
array = (array ?? new float[8]);
Slot[] items = drawOrder.Items;
float num = 2.14748365E+09f;
float num2 = 2.14748365E+09f;
float num3 = -2.14748365E+09f;
float num4 = -2.14748365E+09f;
int i = 0;
for (int count = drawOrder.Count; i < count; i++)
{
Slot slot = items[i];
int num5 = 0;
float[] array2 = null;
Attachment attachment = slot.attachment;
RegionAttachment regionAttachment = attachment as RegionAttachment;
if (regionAttachment != null)
{
num5 = 8;
array2 = array;
if (array2.Length < 8)
{
array2 = (array = new float[8]);
}
regionAttachment.ComputeWorldVertices(slot.bone, array, 0);
}
else
{
MeshAttachment meshAttachment = attachment as MeshAttachment;
if (meshAttachment != null)
{
MeshAttachment meshAttachment2 = meshAttachment;
num5 = meshAttachment2.WorldVerticesLength;
array2 = array;
if (array2.Length < num5)
{
array2 = (array = new float[num5]);
}
meshAttachment2.ComputeWorldVertices(slot, 0, num5, array, 0);
}
}
if (array2 != null)
{
for (int j = 0; j < num5; j += 2)
{
float val = array2[j];
float val2 = array2[j + 1];
num = Math.Min(num, val);
num2 = Math.Min(num2, val2);
num3 = Math.Max(num3, val);
num4 = Math.Max(num4, val2);
}
}
}
x = num;
y = num2;
width = num3 - num;
height = num4 - num2;
vertexBuffer = array;
}