private static Animation ParseVDF(BinaryReader reader)
{
Animation animation;
Dictionary <uint, AnimationObject> animationObjects;
AnimationFrame GetNextAnimationFrame(AnimationObject animationObject)
{
var animationFrames = animationObject.AnimationFrames;
var frameTime = (uint)animationFrames.Count;
var frame = new AnimationFrame {
FrameTime = frameTime, AnimationObject = animationObject
};
animationFrames.Add(frameTime, frame);
if (frameTime >= animation.FrameCount)
{
animation.FrameCount = frameTime + 1;
}
return(frame);
}
AnimationObject GetAnimationObject(uint objectId)
{
if (animationObjects.ContainsKey(objectId))
{
return(animationObjects[objectId]);
}
var animationObject = new AnimationObject {
Animation = animation, ID = objectId, TMDID = objectId
};
animationObjects.Add(objectId, animationObject);
return(animationObject);
}
var frameCount = reader.ReadUInt32();
if (frameCount < Program.MinVDFFrames || frameCount > Program.MaxVDFFrames)
{
return(null);
}
animation = new Animation();
var rootAnimationObject = new AnimationObject();
animationObjects = new Dictionary <uint, AnimationObject>();
if (Program.Debug)
{
Program.Logger.WriteLine("VDF---------------------------------");
Program.Logger.WriteLine("VDF frameCount:" + frameCount);
}
for (uint f = 0; f < frameCount; f++)
{
var objectId = reader.ReadUInt32();
if (objectId > Program.MaxVDFObjects)
{
return(null);
}
if (Program.Debug)
{
Program.Logger.WriteLine(" VDF objectId:" + objectId);
}
var vertexOffset = reader.ReadUInt32();
var skippedVertices = vertexOffset / 8;
var vertexCount = reader.ReadUInt32();
if (vertexCount + skippedVertices == 0 || vertexCount + skippedVertices > Program.MaxVDFVertices)
{
return(null);
}
if (Program.Debug)
{
Program.Logger.WriteLine(" VDF skippedVertices:" + skippedVertices);
}
if (Program.Debug)
{
Program.Logger.WriteLine(" VDF vertexCount:" + vertexCount);
}
var animationObject = GetAnimationObject(objectId);
//if (f == 0)
//{
// var firstAnimationFrame = GetAnimationFrame(animationObject, 0);
// var firstVertices = new Vector3[vertexCount + skippedVertices];
// firstAnimationFrame.Vertices = firstVertices;
// firstAnimationFrame.TempVertices = new Vector3[firstAnimationFrame.Vertices.Length];
//}
var animationFrame = GetNextAnimationFrame(animationObject);
var vertices = new Vector3[vertexCount + skippedVertices];
for (var i = 0; i < vertexCount; i++)
{
var vx = reader.ReadInt16();
var vy = reader.ReadInt16();
var vz = reader.ReadInt16();
reader.ReadInt16();
var vertex = new Vector3(vx, vy, vz);
vertices[i + skippedVertices] = vertex;
//if (Program.Debug)
//{
// Program.Logger.WriteLine(" VDF vertex:" + vertex);
//}
}
animationFrame.Vertices = vertices;
animationFrame.TempVertices = new Vector3[animationFrame.Vertices.Length];
}
foreach (var animationObject in animationObjects.Values)
{
if (animationObject.ParentID != 0 && animationObjects.ContainsKey(animationObject.ParentID))
{
var parent = animationObjects[animationObject.ParentID];
animationObject.Parent = parent;
parent.Children.Add(animationObject);
continue;
}
animationObject.Parent = rootAnimationObject;
rootAnimationObject.Children.Add(animationObject);
}
animation.AnimationType = AnimationType.VertexDiff;
animation.RootAnimationObject = rootAnimationObject;
animation.ObjectCount = animationObjects.Count;
animation.FPS = 1f;
return(animation);
}
private Animation ProcessMimeVertexData(Dictionary <uint, List <Triangle> > groupedTriangles, BinaryReader reader, uint driver, uint primitiveType, uint primitiveHeaderPointer, uint nextPrimitivePointer, uint diffTop, uint dataCount, bool rst)
{
Animation animation;
Dictionary <uint, AnimationObject> animationObjects;
AnimationFrame GetNextAnimationFrame(AnimationObject animationObject)
{
var animationFrames = animationObject.AnimationFrames;
var frameTime = (uint)animationFrames.Count;
var frame = new AnimationFrame {
FrameTime = frameTime, AnimationObject = animationObject
};
animationFrames.Add(frameTime, frame);
if (frameTime >= animation.FrameCount)
{
animation.FrameCount = frameTime + 1;
}
return(frame);
}
AnimationObject GetAnimationObject(uint objectId)
{
if (animationObjects.ContainsKey(objectId))
{
return(animationObjects[objectId]);
}
var animationObject = new AnimationObject {
Animation = animation, ID = objectId, TMDID = objectId
};
animationObjects.Add(objectId, animationObject);
return(animationObject);
}
animation = new Animation();
var rootAnimationObject = new AnimationObject();
animationObjects = new Dictionary <uint, AnimationObject>();
var primitiveDataTop = reader.BaseStream.Position;
ProcessMimeVertexPrimitiveHeader(reader, primitiveHeaderPointer, out var coordTop, out var mimeDiffTop, out var mimeOrgTop, out var mimeVertTop, out var mimeNormTop, out var mimeTop);
reader.BaseStream.Seek(primitiveDataTop, SeekOrigin.Begin);
for (uint i = 0; i < dataCount; i++)
{
reader.BaseStream.Seek(_offset + mimeDiffTop, SeekOrigin.Begin);
var oNum = reader.ReadUInt16();
var numDiffs = reader.ReadUInt16();
if (numDiffs > Program.MaxHMDMimeDiffs)
{
return(null);
}
var flags = reader.ReadUInt32();
var animationObject = GetAnimationObject(oNum);
for (uint j = 0; j < numDiffs; j++)
{
var position = reader.BaseStream.Position;
var diffDataTop = reader.ReadUInt32() * 4;
reader.BaseStream.Seek(_offset + mimeDiffTop + diffTop + diffDataTop, SeekOrigin.Begin);
var vertexStart = reader.ReadUInt32();
var res = reader.ReadUInt16();
var vertexCount = reader.ReadUInt16();
if (vertexCount + vertexStart == 0 || vertexCount + vertexStart >= Program.MaxHMDVertCount)
{
return(null);
}
var animationFrame = GetNextAnimationFrame(animationObject);
var vertices = new Vector3[vertexCount + vertexStart];
for (var k = 0; k < vertexCount; k++)
{
var x = reader.ReadInt16();
var y = reader.ReadInt16();
var z = reader.ReadInt16();
var pad = reader.ReadUInt16();
vertices[vertexStart + k] = new Vector3(x, y, z);
}
animationFrame.Vertices = vertices;
animationFrame.TempVertices = new Vector3[animationFrame.Vertices.Length];
reader.BaseStream.Seek(position, SeekOrigin.Begin);
}
if (flags == 1)
{
var resetOffset = reader.ReadUInt32() * 4;
}
}
foreach (var animationObject in animationObjects.Values)
{
if (animationObject.ParentID != 0 && animationObjects.ContainsKey(animationObject.ParentID))
{
var parent = animationObjects[animationObject.ParentID];
animationObject.Parent = parent;
parent.Children.Add(animationObject);
continue;
}
animationObject.Parent = rootAnimationObject;
rootAnimationObject.Children.Add(animationObject);
}
animation.AnimationType = AnimationType.VertexDiff;
animation.RootAnimationObject = rootAnimationObject;
animation.ObjectCount = animationObjects.Count;
animation.FPS = 1f;
return(animation);
}
private bool ProcessAnimationObject(AnimationObject animationObject, float frameIndex, RootEntity selectedRootEntity, Matrix4 worldMatrix)
{
switch (_animation.AnimationType)
{
case AnimationType.VertexDiff:
case AnimationType.NormalDiff:
{
if (selectedRootEntity != null && animationObject.Parent != null)
{
var objectId = animationObject.TMDID.GetValueOrDefault();
foreach (ModelEntity childModel in selectedRootEntity.ChildEntities)
{
if (childModel.TMDID == objectId)
{
var intFrameIndex = (uint)frameIndex;
if (intFrameIndex > animationObject.AnimationFrames.Count - 1)
{
return(false);
}
var animationFrame = animationObject.AnimationFrames[intFrameIndex];
if (intFrameIndex > 0)
{
var lastFrame = animationObject.AnimationFrames[intFrameIndex - 1];
for (uint j = 0; j < animationFrame.Vertices.Length; j++)
{
if (j < lastFrame.Vertices.Length)
{
animationFrame.TempVertices[j] = lastFrame.Vertices[j];
}
else
{
animationFrame.TempVertices[j] = Vector3.Zero;
}
}
}
else
{
for (uint j = 0; j < animationFrame.Vertices.Length; j++)
{
animationFrame.TempVertices[j] = Vector3.Zero;
}
}
var interpolator = frameIndex % 1;
var initialVertices = _animation.AnimationType == AnimationType.VertexDiff ? animationFrame.TempVertices : null;
var finalVertices = _animation.AnimationType == AnimationType.VertexDiff ? animationFrame.Vertices : null;
var initialNormals = _animation.AnimationType == AnimationType.NormalDiff ? animationFrame.TempVertices : null;
var finalNormals = _animation.AnimationType == AnimationType.NormalDiff ? animationFrame.Vertices : null;
childModel.Interpolator = interpolator;
childModel.InitialVertices = initialVertices;
childModel.FinalVertices = finalVertices;
childModel.InitialNormals = initialNormals;
childModel.FinalNormals = finalNormals;
childModel.TempMatrix = Matrix4.Identity;
//_scene.MeshBatch.BindModelBatch(childModel, childModel.WorldMatrix, _scene.TextureBinder, initialVertices, initialNormals, finalVertices, finalNormals, interpolator);
}
}
}
break;
}
case AnimationType.Common:
{
if (selectedRootEntity != null)
{
var animationFrames = animationObject.AnimationFrames;
var totalFrames = animationFrames.Count;
var localMatrix = Matrix4.Identity;
for (uint f = 0; f <= frameIndex && f < totalFrames; f++)
{
if (!animationFrames.ContainsKey(f))
{
continue;
}
var frameMatrix = Matrix4.Identity;
var sumFrame = animationFrames[f];
if (sumFrame.Rotation != null)
{
var r = Matrix4.CreateFromQuaternion(sumFrame.Rotation.Value);
frameMatrix = frameMatrix * r;
}
else if (sumFrame.EulerRotation != null)
{
var r = GeomUtils.CreateR(sumFrame.EulerRotation.Value);
frameMatrix = frameMatrix * r;
}
if (sumFrame.Scale != null)
{
var scale = (Vector3)sumFrame.Scale;
var s = GeomUtils.CreateS(scale.X);
frameMatrix = frameMatrix * s;
}
if (sumFrame.Translation != null)
{
var translation = (Vector3)sumFrame.Translation;
var t = GeomUtils.CreateT(translation);
frameMatrix = frameMatrix * t;
}
var absoluteMatrixValue = sumFrame.AbsoluteMatrix;
if (!absoluteMatrixValue)
{
frameMatrix *= localMatrix;
}
localMatrix = frameMatrix;
}
//if (parentMatrix != null)
//{
worldMatrix = localMatrix * worldMatrix;
//_scene.SkeletonBatch.AddLine(Vector3.TransformPosition(Vector3.One, parentMatrix.Value), Vector3.TransformPosition(Vector3.One, worldMatrix), animationObject == selectedAnimationObject ? Color.Blue : Color.Red);
//}
//else
//{
// worldMatrix = localMatrix;
//}
//if (selectedRootEntity != null)
//{
var objectId = animationObject.TMDID.GetValueOrDefault();
if (objectId > 0)
{
var models = selectedRootEntity.GetModelsWithTMDID(objectId - 1);
foreach (var childModel in models)
{
childModel.Interpolator = 0;
childModel.InitialVertices = null;
childModel.FinalVertices = null;
childModel.InitialNormals = null;
childModel.FinalNormals = null;
childModel.TempMatrix = worldMatrix;
//_scene.MeshBatch.BindModelBatch(childModel, worldMatrix, _scene.TextureBinder);
}
}
//}
}
break;
}
}
foreach (var childAnimationObject in animationObject.Children)
{
if (!ProcessAnimationObject(childAnimationObject, frameIndex, selectedRootEntity, worldMatrix))
{
return(false);
}
}
return(true);
}
private Animation ParseAN(BinaryReader reader)
{
Animation animation;
Dictionary <uint, AnimationObject> animationObjects;
AnimationFrame GetAnimationFrame(AnimationObject animationObject, uint frameTime)
{
var animationFrames = animationObject.AnimationFrames;
if (!animationObject.AnimationFrames.TryGetValue(frameTime, out var animationFrame))
{
animationFrame = new AnimationFrame {
FrameTime = frameTime, AnimationObject = animationObject
};
animationFrames.Add(frameTime, animationFrame);
}
if (frameTime >= animation.FrameCount)
{
animation.FrameCount = frameTime + 1;
}
return(animationFrame);
}
AnimationObject GetAnimationObject(uint objectId)
{
if (animationObjects.ContainsKey(objectId))
{
return(animationObjects[objectId]);
}
var animationObject = new AnimationObject {
Animation = animation, ID = objectId, TMDID = objectId
};
animationObjects.Add(objectId, animationObject);
return(animationObject);
}
var version = reader.ReadByte();
var numJoints = reader.ReadByte();
if (numJoints == 0 || numJoints > Program.MaxANJoints)
{
return(null);
}
var numFrames = reader.ReadUInt16();
if (numFrames == 0 || numFrames > Program.MaxANFrames)
{
return(null);
}
var frameRate = reader.ReadUInt16();
if (frameRate == 0 || frameRate > 60)
{
return(null);
}
animation = new Animation();
animationObjects = new Dictionary <uint, AnimationObject>();
var rootAnimationObject = new AnimationObject();
var translationTop = reader.ReadUInt32();
var rotationTop = reader.ReadUInt32();
for (uint f = 0; f < numFrames; f++)
{
for (uint i = 0; i < numJoints; i++)
{
reader.BaseStream.Seek(_offset + translationTop + 64 * f, SeekOrigin.Begin);
var animationObject = GetAnimationObject(i);
var animationFrame = GetAnimationFrame(animationObject, f);
var x = reader.ReadUInt16();
var y = reader.ReadUInt16();
var z = reader.ReadUInt16();
var pad = reader.ReadUInt16();
animationFrame.Translation = new Vector3(x, y, z);
}
for (uint i = 0; i < numJoints; i++)
{
reader.BaseStream.Seek(_offset + rotationTop + 64 * f, SeekOrigin.Begin);
var animationObject = GetAnimationObject(i);
var animationFrame = GetAnimationFrame(animationObject, f);
var x = reader.ReadUInt16();
var y = reader.ReadUInt16();
var z = reader.ReadUInt16();
var pad = reader.ReadUInt16();
animationFrame.EulerRotation = new Vector3(x, y, z);
}
}
foreach (var animationObject in animationObjects.Values)
{
if (animationObject.ParentID != 0 && animationObjects.ContainsKey(animationObject.ParentID))
{
var parent = animationObjects[animationObject.ParentID];
animationObject.Parent = parent;
parent.Children.Add(animationObject);
continue;
}
animationObject.Parent = rootAnimationObject;
rootAnimationObject.Children.Add(animationObject);
}
animation.AnimationType = AnimationType.Common;
animation.RootAnimationObject = rootAnimationObject;
animation.ObjectCount = animationObjects.Count;
animation.FPS = frameRate;
return(animation);
}
private Animation ParseTOD(BinaryReader reader)
{
Animation animation;
Dictionary <uint, AnimationObject> animationObjects;
AnimationFrame GetAnimationFrame(AnimationObject animationObject, uint frameTime)
{
var animationFrames = animationObject.AnimationFrames;
if (animationFrames.ContainsKey(frameTime))
{
return(animationFrames[frameTime]);
}
var frame = new AnimationFrame {
FrameTime = frameTime, AnimationObject = animationObject
};
animationFrames.Add(frameTime, frame);
return(frame);
}
AnimationObject GetAnimationObject(ushort objectId)
{
if (animationObjects.ContainsKey(objectId))
{
return(animationObjects[objectId]);
}
var animationObject = new AnimationObject {
Animation = animation, ID = objectId, TMDID = (uint?)(objectId + 1)
};
animationObjects.Add(objectId, animationObject);
return(animationObject);
}
var version = reader.ReadByte();
var resolution = reader.ReadUInt16();
if (resolution == 0)
{
return(null);
}
var frameCount = reader.ReadUInt32();
if (frameCount == 0 || frameCount > Program.MaxTODFrames)
{
return(null);
}
animation = new Animation();
var rootAnimationObject = new AnimationObject();
animationObjects = new Dictionary <uint, AnimationObject>();
for (var f = 0; f < frameCount; f++)
{
var frameTop = reader.BaseStream.Position;
var frameSize = reader.ReadUInt16();
var packetCount = reader.ReadUInt16();
if (packetCount > Program.MaxTODPackets)
{
return(null);
}
var frameNumber = reader.ReadUInt32();
//if (frameNumber != f)
//{
// return null;
//}
if (packetCount == 0 || frameSize == 0)
{
continue;
//reader.BaseStream.Position = frameTop + (frameSize * 4);
}
for (var p = 0; p < packetCount; p++)
{
var packetTop = reader.BaseStream.Position;
var objectId = reader.ReadUInt16();
var packetTypeAndFlag = reader.ReadByte();
var packetType = (packetTypeAndFlag & 0xF);
var flag = (packetTypeAndFlag & 0xF0) >> 0x4;
var packetLength = reader.ReadByte();
var animationObject = GetAnimationObject(objectId);
var animationFrame = GetAnimationFrame(animationObject, frameNumber);
switch (packetType)
{
case 0x01: //Coordinate
var matrixType = (flag & 0x1);
var rotation = (flag & 0x2) >> 0x1;
var scaling = (flag & 0x4) >> 0x2;
var translation = (flag & 0x8) >> 0x3;
if (rotation != 0x00)
{
var rx = (reader.ReadInt32() / 4096f) * GeomUtils.Deg2Rad;
var ry = (reader.ReadInt32() / 4096f) * GeomUtils.Deg2Rad;
var rz = (reader.ReadInt32() / 4096f) * GeomUtils.Deg2Rad;
animationFrame.EulerRotation = new Vector3(rx, ry, rz);
}
if (scaling != 0x00)
{
var sx = reader.ReadInt16() / 4096f;
var sy = reader.ReadInt16() / 4096f;
var sz = reader.ReadInt16() / 4096f;
reader.ReadUInt16();
animationFrame.Scale = new Vector3(sx, sy, sz);
}
if (translation != 0x00)
{
float tx = reader.ReadInt32();
float ty = reader.ReadInt32();
float tz = reader.ReadInt32();
animationFrame.Translation = new Vector3(tx, ty, tz);
}
animationFrame.AbsoluteMatrix = matrixType == 0x00;
//if ((reader.BaseStream.Position - packetTop) / 4 != packetLength)
//{
// return null;
//}
break;
case 0x02: //TMD data ID
animationObject.TMDID = reader.ReadUInt16();
reader.ReadUInt16();
//if ((reader.BaseStream.Position - packetTop) / 4 != packetLength)
//{
// return null;
//}
break;
case 0x03: //Parent Object ID
animationObject.ParentID = reader.ReadUInt16();
reader.ReadUInt16();
//if ((reader.BaseStream.Position - packetTop) / 4 != packetLength)
//{
// return null;
//}
break;
case 0x04:
float r00 = reader.ReadInt16() / 4096f;
float r01 = reader.ReadInt16() / 4096f;
float r02 = reader.ReadInt16() / 4096f;
float r10 = reader.ReadInt16() / 4096f;
float r11 = reader.ReadInt16() / 4096f;
float r12 = reader.ReadInt16() / 4096f;
float r20 = reader.ReadInt16() / 4096f;
float r21 = reader.ReadInt16() / 4096f;
float r22 = reader.ReadInt16() / 4096f;
reader.ReadInt16();
var x = reader.ReadInt32();
var y = reader.ReadInt32();
var z = reader.ReadInt32();
var matrix = new Matrix3(
new Vector3(r00, r01, r02),
new Vector3(r10, r11, r12),
new Vector3(r20, r21, r22)
);
animationFrame.Translation = new Vector3(x, y, z);
animationFrame.Rotation = matrix.ExtractRotation();
animationFrame.Scale = matrix.ExtractScale();
animationFrame.AbsoluteMatrix = true;
//if ((reader.BaseStream.Position - packetTop) / 4 != packetLength)
//{
// return null;
//}
break;
default:
if (packetType <= 0xF)
{
reader.BaseStream.Position = packetTop + packetLength * 4;
continue;
}
return(null);
}
}
}
foreach (var animationObject in animationObjects.Values)
{
if (animationObject.ParentID != 0 && animationObjects.ContainsKey(animationObject.ParentID))
{
var parent = animationObjects[animationObject.ParentID];
animationObject.Parent = parent;
parent.Children.Add(animationObject);
continue;
}
animationObject.Parent = rootAnimationObject;
rootAnimationObject.Children.Add(animationObject);
}
animation.RootAnimationObject = rootAnimationObject;
animation.FrameCount = frameCount;
animation.ObjectCount = animationObjects.Count;
animation.FPS = 1f / resolution * 60f;
if (float.IsInfinity(animation.FPS) || animation.FPS % 1 > 0)
{
return(null);
}
return(animation);
}
