public void RemoveMesh(int idx, bool deleteMorphs)
{
odfMesh mesh = Parser.MeshSection[idx];
odfFrame meshFrame = odf.FindMeshFrame(mesh.Id, Parser.FrameSection.RootFrame);
odf.RemoveMesh(Parser, mesh, meshFrame, deleteMorphs);
}
public void SetFrameMatrix(int idx,
double m11, double m12, double m13, double m14,
double m21, double m22, double m23, double m24,
double m31, double m32, double m33, double m34,
double m41, double m42, double m43, double m44)
{
odfFrame frame = Frames[idx];
Matrix m = new Matrix();
m.M11 = (float)m11;
m.M12 = (float)m12;
m.M13 = (float)m13;
m.M14 = (float)m14;
m.M21 = (float)m21;
m.M22 = (float)m22;
m.M23 = (float)m23;
m.M24 = (float)m24;
m.M31 = (float)m31;
m.M32 = (float)m32;
m.M33 = (float)m33;
m.M34 = (float)m34;
m.M41 = (float)m41;
m.M42 = (float)m42;
m.M43 = (float)m43;
m.M44 = (float)m44;
frame.Matrix = m;
}
void MergeFrame(odfFrame newFrame, int destParentIdx)
{
odfFrame srcParent = new odfFrame(new ObjectName("A new frame", null), ObjectID.INVALID, 1);
srcParent.AddChild(newFrame);
odfFrame destParent;
if (destParentIdx < 0)
{
destParent = new odfFrame(new ObjectName("Another new frame", null), ObjectID.INVALID, 1);
destParent.AddChild(Parser.FrameSection.RootFrame);
}
else
{
destParent = Frames[destParentIdx];
}
MergeFrame(srcParent, destParent);
if (destParentIdx < 0)
{
Parser.FrameSection.RootFrame = srcParent[0];
srcParent.RemoveChild(0);
}
Frames.Clear();
InitFrames(Parser.FrameSection.RootFrame);
}
public void ConvertAnimation(odfANIMSection anim, odfParser odaParser, bool odaSkeleton)
{
if (odaSkeleton)
{
FrameList.Clear();
ConvertFrames(odaParser.FrameSection.RootFrame);
}
ImportedKeyframedAnimation iAnim = new ImportedKeyframedAnimation();
AnimationList.Add(iAnim);
iAnim.TrackList = new List <ImportedAnimationKeyframedTrack>(anim.Count);
string notFound = String.Empty;
foreach (odfTrack track in anim)
{
odfFrame boneFrame = odf.FindFrame(track.BoneFrameId, odaParser.FrameSection.RootFrame);
if (boneFrame == null)
{
notFound += (notFound.Length > 0 ? ", " : "") + track.BoneFrameId;
continue;
}
ImportedAnimationKeyframedTrack iTrack = new ImportedAnimationKeyframedTrack();
iAnim.TrackList.Add(iTrack);
iTrack.Name = boneFrame.Name;
iTrack.Keyframes = ConvertTrack(track.KeyframeList);
}
if (notFound.Length > 0)
{
Report.ReportLog("Warning: Animations weren't converted for the following missing frame IDs: " + notFound);
}
}
bool ZeroCheckFrames(odfFrame root)
{
Tuple <string, byte[]>[] checkMembers = new Tuple <string, byte[]>[] {
new Tuple <string, byte[]>("AlwaysZero1", root.AlwaysZero1),
new Tuple <string, byte[]>("AlwaysZero2", root.AlwaysZero2),
new Tuple <string, byte[]>("AlwaysZero7", root.AlwaysZero7),
new Tuple <string, byte[]>("AlwaysZero9", root.AlwaysZero9),
new Tuple <string, byte[]>("AlwaysZero11", root.AlwaysZero11),
};
foreach (var member in checkMembers)
{
for (int i = 0; i < member.Item2.Length; i++)
{
if (member.Item2[i] != 0)
{
Report.ReportLog("Zero check failed: Frame " + root.Name + " " + member.Item1 + " @" + i + " value=" + member.Item2[i]);
return(false);
}
}
}
foreach (odfFrame child in root)
{
if (!ZeroCheckFrames(child))
{
return(false);
}
}
return(true);
}
void ReplaceFrame(odfFrame newFrame, int destParentIdx, bool deleteMorphs)
{
if (destParentIdx < 0)
{
Parser.FrameSection.RootFrame = newFrame;
}
else
{
var destParent = Frames[destParentIdx];
bool found = false;
for (int i = 0; i < destParent.Count; i++)
{
var dest = destParent[i];
if (dest.Name.ToString() == newFrame.Name.ToString())
{
DeleteMeshesInSubframes(dest, deleteMorphs);
destParent.RemoveChild(i);
destParent.InsertChild(i, newFrame);
found = true;
break;
}
}
if (!found)
{
destParent.AddChild(newFrame);
}
}
Frames.Clear();
InitFrames(Parser.FrameSection.RootFrame);
}
public void MergeFrame(ImportedFrame srcFrame, int destParentIdx)
{
odfFrame newFrame = odf.CreateFrame(srcFrame, Parser);
odf.CopyOrCreateUnknowns(newFrame, Parser);
MergeFrame(newFrame, destParentIdx);
}
public void ReplaceFrame(ImportedFrame srcFrame, int destParentIdx, bool deleteMorphs)
{
odfFrame newFrame = odf.CreateFrame(srcFrame, Parser);
odf.CopyOrCreateUnknowns(newFrame, Parser);
ReplaceFrame(newFrame, destParentIdx, deleteMorphs);
Parser.CollectObjectIDs();
}
public void AddFrame(ImportedFrame srcFrame, int destParentIdx)
{
odfFrame newFrame = odf.CreateFrame(srcFrame, Parser);
odf.CopyOrCreateUnknowns(newFrame, Parser);
AddFrame(newFrame, destParentIdx);
Parser.CollectObjectIDs();
}
void InitFrames(odfFrame frame)
{
Frames.Add(frame);
for (int i = 0; i < frame.Count; i++)
{
InitFrames(frame[i]);
}
}
public static void odfFrame(odfFrame frame, bool emptyFieldsOnly)
{
if (!emptyFieldsOnly || frame.AlwaysZero1 == null)
{
frame.AlwaysZero1 = new byte[44];
}
if (!emptyFieldsOnly || frame.AlwaysZero2 == null)
{
frame.AlwaysZero2 = new byte[216];
}
if (!emptyFieldsOnly)
{
frame.Unknown3 = 0;
}
if (!emptyFieldsOnly)
{
frame.Unknown4 = new float[8] {
0, 90, -90, 90, -90, 0, 0, 0
}
}
;
if (!emptyFieldsOnly)
{
frame.Unknown5 = 0;
}
if (!emptyFieldsOnly)
{
frame.Unknown6 = 0;
}
if (!emptyFieldsOnly || frame.AlwaysZero7 == null)
{
frame.AlwaysZero7 = new byte[4];
}
if (!emptyFieldsOnly)
{
frame.Unknown8 = 0;
}
if (!emptyFieldsOnly || frame.AlwaysZero9 == null)
{
frame.AlwaysZero9 = new byte[0x1FC];
}
if (!emptyFieldsOnly)
{
frame.Unknown10 = 0.25f;
}
if (!emptyFieldsOnly || frame.AlwaysZero11 == null)
{
frame.AlwaysZero11 = new byte[8];
}
if (!emptyFieldsOnly)
{
frame.Unknown12 = 0;
}
}
public static void RemoveMesh(odfParser parser, odfMesh mesh, odfFrame meshFrame, bool deleteMorphs)
{
while (mesh.Count > 0)
{
odfSubmesh submesh = mesh[0];
RemoveSubmesh(parser, submesh, deleteMorphs);
}
meshFrame.MeshId = ObjectID.INVALID;
parser.MeshSection.RemoveChild(mesh);
parser.UsedIDs.Remove((int)mesh.Id);
}
public void MergeFrame(odfFrame srcFrame, odfParser srcParser, int destParentIdx)
{
List <ObjectID> newMeshIDs = new List <ObjectID>();
odfFrame newFrame = srcFrame.Clone(true, newMeshIDs, true);
List <odfMesh> newMeshes = new List <odfMesh>(newMeshIDs.Count);
List <odfBoneList> newBoneLists = new List <odfBoneList>(srcParser.EnvelopeSection != null ? srcParser.EnvelopeSection.Count : 0);
string boneWarning = String.Empty;
foreach (ObjectID meshID in newMeshIDs)
{
odfMesh srcMesh = odf.FindMeshListSome(meshID, srcParser.MeshSection);
odfMesh mesh = srcMesh.Clone();
newMeshes.Add(mesh);
if (srcParser.EnvelopeSection != null)
{
foreach (odfSubmesh submesh in mesh)
{
odfBoneList boneList = odf.FindBoneList(submesh.Id, srcParser.EnvelopeSection);
if (boneList != null)
{
if (Parser.EnvelopeSection != null)
{
odfBoneList copy = boneList.Clone();
newBoneLists.Add(copy);
}
else
{
boneWarning += (boneWarning != String.Empty ? ", " : "") + mesh.ToString();
break;
}
}
}
}
}
MergeFrame(newFrame, destParentIdx);
foreach (odfMesh mesh in newMeshes)
{
Parser.MeshSection.AddChild(mesh);
}
if (Parser.EnvelopeSection != null)
{
foreach (odfBoneList boneList in newBoneLists)
{
Parser.EnvelopeSection.AddChild(boneList);
}
}
Parser.CollectObjectIDs();
if (boneWarning != String.Empty)
{
Report.ReportLog("Warning! Bones of " + boneWarning + " dropped because the destination had no Envelope section.");
}
}
public void SetFrameUnknowns(int idx,
int Unknown3, object[] Unknown4, int Unknown5, int Unknown6, double Unknown8, double Unknown10, double Unknown12)
{
odfFrame frame = Frames[idx];
frame.Unknown3 = Unknown3;
frame.Unknown4 = Utility.ConvertToFloatArray(Unknown4);
frame.Unknown5 = (UInt32)Unknown5;
frame.Unknown6 = Unknown6;
frame.Unknown8 = (float)Unknown8;
frame.Unknown10 = (float)Unknown10;
frame.Unknown12 = (float)Unknown12;
}
public void SetBoneFrameId(int boneListIdx, int boneIdx, string frameId)
{
ObjectID newBoneFrameId = new ObjectID(frameId);
odfFrame boneFrame = odf.FindFrame(newBoneFrameId, Parser.FrameSection.RootFrame);
if (boneFrame == null)
{
throw new FormatException("Frame not found");
}
odfBone bone = Parser.EnvelopeSection[boneListIdx][boneIdx];
bone.FrameId = boneFrame.Id;
}
public static odfFrame CreateFrame(ImportedFrame frame, odfParser parser)
{
odfFrame newFrame = new odfFrame(new ObjectName(frame.Name, null), null, frame.Count);
newFrame.MeshId = ObjectID.INVALID;
newFrame.Matrix = frame.Matrix;
for (int i = 0; i < frame.Count; i++)
{
newFrame.AddChild(CreateFrame(frame[i], parser));
}
return(newFrame);
}
void DeleteMeshesInSubframes(odfFrame frame, bool deleteMorphs)
{
if ((int)frame.MeshId != 0)
{
odfMesh mesh = odf.FindMeshListSome(frame.MeshId, Parser.MeshSection);
odf.RemoveMesh(Parser, mesh, frame, deleteMorphs);
}
for (int i = 0; i < frame.Count; i++)
{
odfFrame subframe = frame[i];
DeleteMeshesInSubframes(subframe, deleteMorphs);
}
}
private bool loadFRAM(BinaryReader reader, odfFileSection fileSec)
{
odfFrameSection objSection = new odfFrameSection();
for (int secOffset = 0; secOffset < fileSec.Size; secOffset += 64 + 4 + 16 * 4 + 44 + 4 + 4 + 216 + 4 + 8 * 4 + 12 + 4 + 0x1FC + 4 + 8 + 4)
{
ObjectName name = new ObjectName(reader.ReadBytes(64));
ObjectID id = new ObjectID(reader.ReadBytes(4));
odfFrame frame = new odfFrame(name, id, 4);
frame.Matrix = reader.ReadMatrix();
frame.AlwaysZero1 = reader.ReadBytes(44);
frame.ParentId = new ObjectID(reader.ReadBytes(4));
frame.MeshId = new ObjectID(reader.ReadBytes(4));
frame.AlwaysZero2 = reader.ReadBytes(216);
frame.Unknown3 = reader.ReadInt32();
frame.Unknown4 = reader.ReadSingleArray(8);
frame.Unknown5 = reader.ReadUInt32();
frame.Unknown6 = reader.ReadInt32();
frame.AlwaysZero7 = reader.ReadBytes(4);
frame.Unknown8 = reader.ReadSingle();
frame.AlwaysZero9 = reader.ReadBytes(0x1FC);
frame.Unknown10 = reader.ReadSingle();
frame.AlwaysZero11 = reader.ReadBytes(8);
frame.Unknown12 = reader.ReadSingle();
if (objSection.Count > 0)
{
odfFrame parentFrame = odf.FindFrame(frame.ParentId, objSection.RootFrame);
if (parentFrame == null)
{
Console.WriteLine("Error in FRAM : ParentId " + frame.ParentId + " not found for frame " + frame.Name);
return(false);
}
else
{
parentFrame.AddChild(frame);
}
}
else
{
objSection.AddChild(frame);
}
}
fileSec.Section = objSection;
this.FrameSection = objSection;
return(true);
}
public static void CopyUnknowns(odfFrame src, odfFrame dest)
{
dest.AlwaysZero1 = (byte[])src.AlwaysZero1.Clone();
dest.AlwaysZero2 = (byte[])src.AlwaysZero2.Clone();
dest.Unknown3 = src.Unknown3;
dest.Unknown4 = (float[])src.Unknown4.Clone();
dest.Unknown5 = src.Unknown5;
dest.Unknown6 = src.Unknown6;
dest.AlwaysZero7 = (byte[])src.AlwaysZero7.Clone();
dest.Unknown8 = src.Unknown8;
dest.AlwaysZero9 = (byte[])src.AlwaysZero9.Clone();
dest.Unknown10 = src.Unknown10;
dest.AlwaysZero11 = (byte[])src.AlwaysZero11.Clone();
dest.Unknown12 = src.Unknown12;
}
private void numericMeshId_ValueChanged(object sender, EventArgs e)
{
textBoxMeshFrameName.Text = (numericMeshId.Value < 0) ? String.Empty : editor.Frames[Decimal.ToInt32(numericMeshId.Value)].Name;
odfFrame frame = odf.FindFrame(textBoxMeshFrameName.Text, editor.Parser.FrameSection.RootFrame);
textBoxMeshName.Text = String.Empty;
if ((int)frame.MeshId != 0)
{
odfMesh mesh = odf.FindMeshListSome(frame.MeshId, editor.Parser.MeshSection);
if (mesh != null)
{
textBoxMeshName.Text = mesh.Name;
}
}
}
private static void SearchHierarchy(odfFrame root, odfFrame frame, HashSet <int> meshIDs, HashSet <int> exportFrames)
{
if ((int)frame.MeshId != 0 && meshIDs.Contains((int)frame.MeshId))
{
odfFrame parent = frame;
while (parent != null && exportFrames.Add((int)parent.Id))
{
parent = parent.Parent as odfFrame;
}
}
for (int i = 0; i < frame.Count; i++)
{
SearchHierarchy(root, frame[i], meshIDs, exportFrames);
}
}
void AddFrame(odfFrame newFrame, int destParentIdx)
{
if (destParentIdx < 0)
{
Parser.FrameSection.RootFrame = newFrame;
newFrame.ParentId = ObjectID.INVALID;
}
else
{
Frames[destParentIdx].AddChild(newFrame);
newFrame.ParentId = new ObjectID(((odfFrame)newFrame.Parent).Id);
}
Frames.Clear();
InitFrames(Parser.FrameSection.RootFrame);
}
public void SetMeshId(int idx, string id)
{
ObjectID newMeshID = new ObjectID(id);
if (Parser.IsUsedID(newMeshID))
{
throw new FormatException("ID is already in use");
}
odfMesh mesh = Parser.MeshSection[idx];
ObjectID oldMeshId = mesh.Id;
odfFrame meshFrame = odf.FindMeshFrame(mesh.Id, Parser.FrameSection.RootFrame);
meshFrame.MeshId = mesh.Id = newMeshID;
Parser.UsedIDs.Add((int)newMeshID, typeof(odfMesh));
Parser.UsedIDs.Remove((int)oldMeshId);
}
private ImportedFrame ConvertFrames(odfFrame frame)
{
ImportedFrame iFrame = new ImportedFrame();
iFrame.InitChildren(frame.Count);
iFrame.Name = frame.Name;
iFrame.Matrix = frame.Matrix;
FrameList.Add(iFrame);
foreach (odfFrame child in frame)
{
ImportedFrame iChild = ConvertFrames(child);
iFrame.AddChild(iChild);
}
return(iFrame);
}
public static odfFrame FindMeshFrame(ObjectID id, odfFrame frame)
{
if (frame.MeshId == id)
{
return(frame);
}
for (int i = 0; i < frame.Count; i++)
{
odfFrame found = FindMeshFrame(id, frame[i]);
if (found != null)
{
return(found);
}
}
return(null);
}
void MergeFrame(odfFrame srcParent, odfFrame destParent)
{
for (int i = 0; i < destParent.Count; i++)
{
var dest = destParent[i];
for (int j = 0; j < srcParent.Count; j++)
{
var src = srcParent[j];
if (src.Name.ToString() == dest.Name.ToString())
{
MergeFrame(src, dest);
srcParent.RemoveChild(j);
if (dest.MeshId != null && (int)dest.MeshId != 0)
{
odfMesh mesh = odf.FindMeshListSome(dest.MeshId, Parser.MeshSection);
odf.RemoveMesh(Parser, mesh, dest, false);
}
destParent.RemoveChild(i);
destParent.InsertChild(i, src);
break;
}
}
}
if (srcParent.Name.ToString() == destParent.Name.ToString())
{
while (destParent.Count > 0)
{
var dest = destParent[0];
destParent.RemoveChild(0);
srcParent.AddChild(dest);
}
}
else
{
while (srcParent.Count > 0)
{
var src = srcParent[0];
srcParent.RemoveChild(0);
destParent.AddChild(src);
}
}
}
private new void listViewAnimationTrack_ItemSelectionChanged(object sender, ListViewItemSelectionChangedEventArgs e)
{
List <DockContent> formODFList;
if (!Gui.Docking.DockContents.TryGetValue(typeof(FormMeshView), out formODFList))
{
return;
}
foreach (FormMeshView formMesh in formODFList)
{
odfFrame boneFrame = odf.FindFrame(e.Item.Text, formMesh.Editor.Parser.FrameSection.RootFrame);
if (boneFrame == null)
{
continue;
}
for (int i = 0; i < formMesh.renderObjectMeshes.Count; i++)
{
RenderObjectODF mesh = formMesh.renderObjectMeshes[i];
if (mesh != null && formMesh.renderObjectIds[i] > -1)
{
odfMesh odfMesh = formMesh.Editor.Parser.MeshSection[i];
for (int j = 0; j < odfMesh.Count; j++)
{
odfSubmesh submesh = odfMesh[j];
odfBoneList bones = odf.FindBoneList(submesh.Id, formMesh.Editor.Parser.EnvelopeSection);
if (bones == null)
{
continue;
}
for (int k = 0; k < bones.Count; k++)
{
if (bones[k].FrameId == boneFrame.Id)
{
mesh.HighlightBone(formMesh.Editor.Parser, i, j, e.IsSelected ? k : -1);
Gui.Renderer.Render();
break;
}
}
}
}
}
}
}
public static odfFrame FindFrame(string name, odfFrame root)
{
odfFrame frame = root;
if (frame.Name == name)
{
return(frame);
}
for (int i = 0; i < root.Count; i++)
{
if ((frame = FindFrame(name, (odfFrame)root[i])) != null)
{
return(frame);
}
}
return(null);
}
public static HashSet <int> SearchHierarchy(odfParser parser, HashSet <int> meshIDs)
{
HashSet <int> exportFrames = new HashSet <int>();
SearchHierarchy(parser.FrameSection.RootFrame, parser.FrameSection.RootFrame, meshIDs, exportFrames);
if (parser.EnvelopeSection != null)
{
for (int meshIdx = 0; meshIdx < parser.MeshSection.Count; meshIdx++)
{
odfMesh mesh = parser.MeshSection[meshIdx];
if (!meshIDs.Contains((int)mesh.Id))
{
continue;
}
for (int meshObjIdx = 0; meshObjIdx < mesh.Count; meshObjIdx++)
{
odfSubmesh meshObj = mesh[meshObjIdx];
for (int envIdx = 0; envIdx < parser.EnvelopeSection.Count; envIdx++)
{
odfBoneList boneList = parser.EnvelopeSection[envIdx];
if (meshObj.Id != boneList.SubmeshId)
{
continue;
}
for (int i = 0; i < boneList.Count; i++)
{
ObjectID boneID = boneList[i].FrameId;
if (!exportFrames.Contains((int)boneID))
{
odfFrame boneParent = FindFrame(boneID, parser.FrameSection.RootFrame);
while (boneParent != null && exportFrames.Add((int)boneParent.Id))
{
boneParent = boneParent.Parent as odfFrame;
}
}
}
}
}
}
}
return(exportFrames);
}
public static void CopyOrCreateUnknowns(odfFrame dest, odfParser parser)
{
odfFrame src = FindFrame(dest.Name, parser.FrameSection.RootFrame);
if (src == null)
{
dest.Id = parser.GetNewID(typeof(odfFrame));
CreateUnknowns(dest);
}
else
{
dest.Id = new ObjectID(src.Id);
CopyUnknowns(src, dest);
}
for (int i = 0; i < dest.Count; i++)
{
CopyOrCreateUnknowns(dest[i], parser);
}
}