public SkeletonData ReadSkeletonData(NewStream input)
{
if (input == null)
{
throw new ArgumentNullException("input");
}
float scale = Scale;
var skeletonData = new SkeletonData();
skeletonData.hash = ReadString(input);
if (skeletonData.hash.Length == 0)
{
skeletonData.hash = null;
}
skeletonData.version = ReadString(input);
if (skeletonData.version.Length == 0)
{
skeletonData.version = null;
}
skeletonData.width = ReadFloat(input);
skeletonData.height = ReadFloat(input);
bool nonessential = ReadBoolean(input);
if (nonessential)
{
skeletonData.fps = ReadFloat(input);
skeletonData.imagesPath = ReadString(input);
if (skeletonData.imagesPath.Length == 0)
{
skeletonData.imagesPath = null;
}
}
// Bones.
for (int i = 0, n = ReadVarint(input, true); i < n; i++)
{
String name = ReadString(input);
BoneData parent = i == 0 ? null : skeletonData.bones.Items[ReadVarint(input, true)];
BoneData data = new BoneData(i, name, parent);
data.rotation = ReadFloat(input);
data.x = ReadFloat(input) * scale;
data.y = ReadFloat(input) * scale;
data.scaleX = ReadFloat(input);
data.scaleY = ReadFloat(input);
data.shearX = ReadFloat(input);
data.shearY = ReadFloat(input);
data.length = ReadFloat(input) * scale;
data.transformMode = TransformModeValues[ReadVarint(input, true)];
if (nonessential)
{
ReadInt(input); // Skip bone color.
}
skeletonData.bones.Add(data);
}
// Slots.
for (int i = 0, n = ReadVarint(input, true); i < n; i++)
{
String slotName = ReadString(input);
BoneData boneData = skeletonData.bones.Items[ReadVarint(input, true)];
SlotData slotData = new SlotData(i, slotName, boneData);
int color = ReadInt(input);
slotData.r = ((color & 0xff000000) >> 24) / 255f;
slotData.g = ((color & 0x00ff0000) >> 16) / 255f;
slotData.b = ((color & 0x0000ff00) >> 8) / 255f;
slotData.a = ((color & 0x000000ff)) / 255f;
slotData.attachmentName = ReadString(input);
slotData.blendMode = (BlendMode)ReadVarint(input, true);
skeletonData.slots.Add(slotData);
}
// IK constraints.
for (int i = 0, n = ReadVarint(input, true); i < n; i++)
{
IkConstraintData data = new IkConstraintData(ReadString(input));
data.order = ReadVarint(input, true);
for (int ii = 0, nn = ReadVarint(input, true); ii < nn; ii++)
{
data.bones.Add(skeletonData.bones.Items[ReadVarint(input, true)]);
}
data.target = skeletonData.bones.Items[ReadVarint(input, true)];
data.mix = ReadFloat(input);
data.bendDirection = ReadSByte(input);
skeletonData.ikConstraints.Add(data);
}
// Transform constraints.
for (int i = 0, n = ReadVarint(input, true); i < n; i++)
{
TransformConstraintData data = new TransformConstraintData(ReadString(input));
data.order = ReadVarint(input, true);
for (int ii = 0, nn = ReadVarint(input, true); ii < nn; ii++)
{
data.bones.Add(skeletonData.bones.Items[ReadVarint(input, true)]);
}
data.target = skeletonData.bones.Items[ReadVarint(input, true)];
data.offsetRotation = ReadFloat(input);
data.offsetX = ReadFloat(input) * scale;
data.offsetY = ReadFloat(input) * scale;
data.offsetScaleX = ReadFloat(input);
data.offsetScaleY = ReadFloat(input);
data.offsetShearY = ReadFloat(input);
data.rotateMix = ReadFloat(input);
data.translateMix = ReadFloat(input);
data.scaleMix = ReadFloat(input);
data.shearMix = ReadFloat(input);
skeletonData.transformConstraints.Add(data);
}
// Path constraints
for (int i = 0, n = ReadVarint(input, true); i < n; i++)
{
PathConstraintData data = new PathConstraintData(ReadString(input));
data.order = ReadVarint(input, true);
for (int ii = 0, nn = ReadVarint(input, true); ii < nn; ii++)
{
data.bones.Add(skeletonData.bones.Items[ReadVarint(input, true)]);
}
data.target = skeletonData.slots.Items[ReadVarint(input, true)];
data.positionMode = (PositionMode)Enum.GetValues(typeof(PositionMode)).GetValue(ReadVarint(input, true));
data.spacingMode = (SpacingMode)Enum.GetValues(typeof(SpacingMode)).GetValue(ReadVarint(input, true));
data.rotateMode = (RotateMode)Enum.GetValues(typeof(RotateMode)).GetValue(ReadVarint(input, true));
data.offsetRotation = ReadFloat(input);
data.position = ReadFloat(input);
if (data.positionMode == PositionMode.Fixed)
{
data.position *= scale;
}
data.spacing = ReadFloat(input);
if (data.spacingMode == SpacingMode.Length || data.spacingMode == SpacingMode.Fixed)
{
data.spacing *= scale;
}
data.rotateMix = ReadFloat(input);
data.translateMix = ReadFloat(input);
skeletonData.pathConstraints.Add(data);
}
// Default skin.
Skin defaultSkin = ReadSkin(input, "default", nonessential);
if (defaultSkin != null)
{
skeletonData.defaultSkin = defaultSkin;
skeletonData.skins.Add(defaultSkin);
}
// Skins.
for (int i = 0, n = ReadVarint(input, true); i < n; i++)
{
skeletonData.skins.Add(ReadSkin(input, ReadString(input), nonessential));
}
// Linked meshes.
for (int i = 0, n = linkedMeshes.Count; i < n; i++)
{
SkeletonJson.LinkedMesh linkedMesh = linkedMeshes[i];
Skin skin = linkedMesh.skin == null ? skeletonData.DefaultSkin : skeletonData.FindSkin(linkedMesh.skin);
if (skin == null)
{
throw new Exception("Skin not found: " + linkedMesh.skin);
}
Attachment parent = skin.GetAttachment(linkedMesh.slotIndex, linkedMesh.parent);
if (parent == null)
{
throw new Exception("Parent mesh not found: " + linkedMesh.parent);
}
linkedMesh.mesh.ParentMesh = (MeshAttachment)parent;
linkedMesh.mesh.UpdateUVs();
}
linkedMeshes.Clear();
// Events.
for (int i = 0, n = ReadVarint(input, true); i < n; i++)
{
EventData data = new EventData(ReadString(input));
data.Int = ReadVarint(input, false);
data.Float = ReadFloat(input);
data.String = ReadString(input);
skeletonData.events.Add(data);
}
// Animations.
for (int i = 0, n = ReadVarint(input, true); i < n; i++)
{
ReadAnimation(ReadString(input), input, skeletonData);
}
skeletonData.bones.TrimExcess();
skeletonData.slots.TrimExcess();
skeletonData.skins.TrimExcess();
skeletonData.events.TrimExcess();
skeletonData.animations.TrimExcess();
skeletonData.ikConstraints.TrimExcess();
skeletonData.pathConstraints.TrimExcess();
return(skeletonData);
}
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);
}
/// <summary>
/// Submit change to files/stream
/// TODO : NEED OPTIMISATION FOR LARGE FILE... IT'S AS BEGINING :) USE TEMPS FILE ?
/// TODO : USE TEMPS FILE FOR LARGE FILE
/// </summary>
public void SubmitChanges()
{
if (CanWrite)
{
//Set percent of progress to zero and create and iterator for help mesure progress
LongProcessProgress = 0;
int i = 0;
//Create appropriate temp stream for new file.
Stream NewStream = null;
if (Length < ConstantReadOnly.LARGE_FILE_LENGTH)
{
NewStream = new MemoryStream();
}
else
{
NewStream = File.Open(Path.GetTempFileName(), FileMode.Open, FileAccess.ReadWrite);
}
//Fast change only nothing byte deleted or added
if (ByteModifieds(ByteAction.Deleted).Count() == 0 &&
ByteModifieds(ByteAction.Added).Count() == 0)
{
//Launch event at process strated
IsOnLongProcess = true;
LongProcessProgressStarted?.Invoke(this, new EventArgs());
var bytemodifiedList = ByteModifieds(ByteAction.Modified);
double countChange = bytemodifiedList.Count();
i = 0;
//Fast save. only save byteaction=modified
foreach (ByteModified bm in bytemodifiedList)
{
if (bm.IsValid)
{
//Set percent of progress
LongProcessProgress = i++ / countChange;
//Break process?
if (!IsOnLongProcess)
{
break;
}
_stream.Position = bm.BytePositionInFile;
_stream.WriteByte(bm.Byte.Value);
}
}
//Launch event at process completed
IsOnLongProcess = false;
LongProcessProgressCompleted?.Invoke(this, new EventArgs());
}
else
{
//Launch event at process strated
IsOnLongProcess = true;
LongProcessProgressStarted?.Invoke(this, new EventArgs());
byte[] buffer = new byte[ConstantReadOnly.COPY_BLOCK_SIZE];
long bufferlength = 0;
var SortedBM = ByteModifieds(ByteAction.All).OrderBy(b => b.BytePositionInFile);
double countChange = SortedBM.Count();
i = 0;
//Set position
Position = 0;
////Start update and rewrite file.
foreach (ByteModified nextByteModified in SortedBM)
{
//Set percent of progress
LongProcessProgress = (i++ / countChange);
//Break process?
if (!IsOnLongProcess)
{
break;
}
//Reset buffer
buffer = new byte[ConstantReadOnly.COPY_BLOCK_SIZE];
//start read/write / use little block for optimize memory
while (Position != nextByteModified.BytePositionInFile)
{
bufferlength = nextByteModified.BytePositionInFile - Position;
//TEMPS
if (bufferlength < 0)
{
bufferlength = 1;
}
//EOF
if (bufferlength < ConstantReadOnly.COPY_BLOCK_SIZE)
{
buffer = new byte[bufferlength];
}
_stream.Read(buffer, 0, buffer.Length);
NewStream.Write(buffer, 0, buffer.Length);
}
//Apply ByteAction!
switch (nextByteModified.Action)
{
case ByteAction.Added:
//TODO : IMPLEMENTING ADD BYTE
break;
case ByteAction.Deleted:
//NOTHING TODO we dont want to add deleted byte
Position++;
break;
case ByteAction.Modified:
Position++;
NewStream.WriteByte(nextByteModified.Byte.Value);
break;
}
//Read/Write the last section of file
if (nextByteModified.BytePositionInFile == SortedBM.Last().BytePositionInFile)
{
while (!EOF)
{
bufferlength = _stream.Length - Position;
//EOF
if (bufferlength < ConstantReadOnly.COPY_BLOCK_SIZE)
{
buffer = new byte[bufferlength];
}
_stream.Read(buffer, 0, buffer.Length);
NewStream.Write(buffer, 0, buffer.Length);
}
}
}
//Write new data to current stream
Position = 0;
NewStream.Position = 0;
buffer = new byte[ConstantReadOnly.COPY_BLOCK_SIZE];
while (!EOF)
{
//Set percent of progress
LongProcessProgress = ((double)Position / (double)Length);
//Break process?
if (!IsOnLongProcess)
{
break;
}
bufferlength = _stream.Length - Position;
//EOF
if (bufferlength < ConstantReadOnly.COPY_BLOCK_SIZE)
{
buffer = new byte[bufferlength];
}
NewStream.Read(buffer, 0, buffer.Length);
_stream.Write(buffer, 0, buffer.Length);
}
_stream.SetLength(NewStream.Length);
//dispose resource
NewStream.Close();
buffer = null;
//Launch event at process completed
IsOnLongProcess = false;
LongProcessProgressCompleted?.Invoke(this, new EventArgs());
}
//Launch event
ChangesSubmited?.Invoke(this, new EventArgs());
}
else
{
throw new Exception("Cannot write to file.");
}
}
