public void SetMaterialUnknowns(int idx, int unknown1, string unknown2)
{
remMaterial mat = Parser.MATC[idx];
mat.unk_or_flag = unknown1;
mat.unknown = new remId(unknown2);
}
public remBone Clone(bool mesh, bool childFrames, remParser parser, List <remMaterial> clonedMaterials, List <remMesh> clonedMeshes, List <remSkin> clonedSkins)
{
remBone frame = new remBone(Count);
frame.name = name;
frame.matrix = matrix;
if (mesh)
{
remMesh remMesh = rem.FindMesh(this, parser.MESC);
if (remMesh != null)
{
foreach (remId matId in remMesh.materials)
{
remMaterial mat = rem.FindMaterial(matId, parser.MATC);
if (!clonedMaterials.Contains(mat))
{
clonedMaterials.Add(mat.Clone());
}
}
remMesh clone = remMesh.Clone(true, true, parser, clonedSkins);
clone.frame = frame.name;
clonedMeshes.Add(clone);
}
}
if (childFrames)
{
for (int i = 0; i < Count; i++)
{
frame.AddChild(this[i].Clone(mesh, true, parser, clonedMaterials, clonedMeshes, clonedSkins));
}
}
return(frame);
}
public void CopyMaterial(int idx)
{
remMaterial clone = Parser.MATC[idx].Clone();
clone.name = new remId(clone.name + "_copy");
Parser.MATC.AddChild(clone);
}
public static void ReplaceMaterial(remParser parser, ImportedMaterial material)
{
remMaterial mat = CreateMaterial(material);
bool found = false;
for (int i = 0; i < parser.MATC.Count; i++)
{
if (parser.MATC[i].name == material.Name)
{
remMaterial original = parser.MATC[i];
CopyUnknown(original, mat);
parser.MATC.RemoveChild(i);
parser.MATC.InsertChild(i, mat);
found = true;
break;
}
}
if (!found)
{
CreateUnknown(mat);
parser.MATC.AddChild(mat);
}
}
public void SetMaterialPhong(int idx, object[] diffuse, object[] ambient, object[] specular, object[] emissive, int shininess)
{
remMaterial mat = Parser.MATC[idx];
mat.diffuse = new Color3((float)(double)diffuse[0], (float)(double)diffuse[1], (float)(double)diffuse[2]);
mat.ambient = new Color3((float)(double)ambient[0], (float)(double)ambient[1], (float)(double)ambient[2]);
mat.specular = new Color3((float)(double)specular[0], (float)(double)specular[1], (float)(double)specular[2]);
mat.emissive = new Color3((float)(double)emissive[0], (float)(double)emissive[1], (float)(double)emissive[2]);
mat.specularPower = shininess;
}
private void PullNewMaterials(List <remMaterial> materialClones)
{
for (int i = 0; i < materialClones.Count; i++)
{
remMaterial mat = materialClones[i];
if (rem.FindMaterial(mat.name, Parser.MATC) != null)
{
materialClones.RemoveAt(i);
i--;
}
}
Parser.MATC.ChildList.AddRange(materialClones);
}
public static remMaterial CreateMaterial(ImportedMaterial impMat)
{
remMaterial remMat = new remMaterial();
remMat.name = new remId(impMat.Name);
remMat.diffuse = new Color3(impMat.Diffuse.Red, impMat.Diffuse.Green, impMat.Diffuse.Blue);
remMat.ambient = new Color3(impMat.Ambient.Red, impMat.Ambient.Green, impMat.Ambient.Blue);
remMat.specular = new Color3(impMat.Specular.Red, impMat.Specular.Green, impMat.Specular.Blue);
remMat.emissive = new Color3(impMat.Emissive.Red, impMat.Emissive.Green, impMat.Emissive.Blue);
remMat.specularPower = (int)impMat.Power;
remMat.texture = new remId(impMat.Textures[0]);
return(remMat);
}
public remMaterial Clone()
{
remMaterial mat = new remMaterial();
mat.name = new remId(name);
for (int i = 0; i < properties.Length; i++)
{
mat.properties[i] = properties[i];
}
mat.specularPower = specularPower;
rem.CopyUnknown(this, mat);
mat.texture = new remId(texture);
return(mat);
}
public void RemoveMaterial(int idx)
{
remMaterial mat = Parser.MATC[idx];
for (int i = 0; i < Parser.MESC.Count; i++)
{
remMesh mesh = Parser.MESC[i];
for (int j = 0; j < mesh.numMats; j++)
{
remId matId = mesh.materials[j];
if (matId == mat.name)
{
mesh.materials[j] = null;
}
}
}
Parser.MATC.RemoveChild(idx);
}
private static remMATCsection ReadMaterials(string sectionName, int sectionLength, int numMaterials, byte[] sectionBuffer)
{
remMATCsection matSec = new remMATCsection(numMaterials);
int secBufIdx = 0;
for (int subSection = 0; subSection < numMaterials; subSection++)
{
byte[] type = new byte[4] {
sectionBuffer[secBufIdx + 0], sectionBuffer[secBufIdx + 1], sectionBuffer[secBufIdx + 2], sectionBuffer[secBufIdx + 3]
};
int length = BitConverter.ToInt32(sectionBuffer, secBufIdx + 4);
remMaterial mat = new remMaterial();
Trace.Assert(TypeCheck(remMaterial.ClassType, type));
mat.name = GetIdentifier(sectionBuffer, secBufIdx + 8);
for (int i = 0; i < mat.properties.Length; i++)
{
mat[i] = BitConverter.ToSingle(sectionBuffer, secBufIdx + 8 + 256 + i * 4);
}
mat.specularPower = BitConverter.ToInt32(sectionBuffer, secBufIdx + 8 + 256 + 12 * 4);
mat.unk_or_flag = BitConverter.ToInt32(sectionBuffer, secBufIdx + 8 + 256 + 12 * 4 + 4);
mat.unknown = GetIdentifier(sectionBuffer, secBufIdx + 8 + 256 + 12 * 4 + 4 + 4);
if (length >= 0x240 + 256)
{
mat.texture = GetIdentifier(sectionBuffer, secBufIdx + 0x240);
}
matSec.AddChild(mat);
secBufIdx += length;
}
if (secBufIdx != sectionLength)
{
Report.ReportLog("Warning! MATC section has wrong length.");
}
return(matSec);
}
public void MergeMaterial(remMaterial mat)
{
var newMat = mat.Clone();
bool found = false;
for (int i = 0; i < Parser.MATC.Count; i++)
{
var oldMat = Parser.MATC[i];
if (oldMat.name == newMat.name)
{
Parser.MATC.ChildList.RemoveAt(i);
Parser.MATC.ChildList.Insert(i, newMat);
found = true;
break;
}
}
if (!found)
{
Parser.MATC.AddChild(newMat);
}
InitTextures(false, false);
}
private static List <string> Export(string dest, remParser parser, List <remMesh> meshes, bool worldCoords)
{
List <string> usedTextures = new List <string>(parser.MATC.Count);
DirectoryInfo dir = new DirectoryInfo(Path.GetDirectoryName(dest));
if (!dir.Exists)
{
dir.Create();
}
List <rem.Mesh> convertedMeshes = new List <rem.Mesh>(meshes.Count);
List <int> materialList = new List <int>(parser.MATC.Count);
using (StreamWriter writer = new StreamWriter(dest, false))
{
for (int i = 0; i < meshes.Count; i++)
{
rem.Mesh meshListSome = new rem.Mesh(meshes[i], null);
convertedMeshes.Add(meshListSome);
for (int j = 0; j < meshListSome.Count; j++)
{
rem.Submesh meshObj = meshListSome[j];
remMaterial mat = rem.FindMaterial(meshObj.MaterialName, parser.MATC);
if (mat != null)
{
int meshObjMatIdx = parser.MATC.IndexOf(mat);
if (!materialList.Contains(meshObjMatIdx))
{
materialList.Add(meshObjMatIdx);
}
}
else
{
Report.ReportLog("Warning: Mesh " + meshes[i].name + " Object " + j + " has an invalid material");
}
}
}
writer.WriteLine("Metasequoia Document");
writer.WriteLine("Format Text Ver 1.0");
writer.WriteLine();
writer.WriteLine("Material " + materialList.Count + " {");
foreach (int matIdx in materialList)
{
remMaterial mat = parser.MATC[matIdx];
string s = "\t\"" + mat.name + "\" col(0.800 0.800 0.800 1.000) dif(0.500) amb(0.100) emi(0.500) spc(0.100) power(30.00)";
string matTexName = mat.texture;
if (matTexName != null)
{
s += " tex(\"" + Path.GetFileName(matTexName) + "\")";
}
writer.WriteLine(s);
}
writer.WriteLine("}");
Random rand = new Random();
for (int i = 0; i < meshes.Count; i++)
{
remBone parent = rem.FindFrame(meshes[i].frame, parser.BONC.rootFrame);
float scale = Math.Abs(parent.matrix.M11);
Matrix transform = Matrix.Scaling(-1f, 1f, 1f);
if (worldCoords)
{
while (parent != parser.BONC.rootFrame)
{
transform *= parent.matrix;
parent = parent.Parent as remBone;
}
}
string meshName = meshes[i].name;
if (scale != 1f)
{
meshName += "(Scale=" + scale.ToString() + ")";
}
rem.Mesh meshListSome = convertedMeshes[i];
for (int j = 0; j < meshListSome.Count; j++)
{
rem.Submesh meshObj = meshListSome[j];
remMaterial mat = rem.FindMaterial(meshObj.MaterialName, parser.MATC);
int mqoMatIdx = -1;
if (mat != null)
{
int meshObjMatIdx = parser.MATC.IndexOf(mat);
mqoMatIdx = materialList.IndexOf(meshObjMatIdx);
}
float[] color = new float[3];
for (int k = 0; k < color.Length; k++)
{
color[k] = (float)((rand.NextDouble() / 2) + 0.5);
}
string mqoName = meshName + "[" + j + "]";
if (worldCoords)
{
mqoName += "[W]";
}
writer.WriteLine("Object \"" + mqoName + "\" {");
writer.WriteLine("\tshading 1");
writer.WriteLine("\tcolor " + color[0].ToFloatString() + " " + color[1].ToFloatString() + " " + color[2].ToFloatString());
writer.WriteLine("\tcolor_type 1");
List <ImportedVertex> vertList = worldCoords ?
rem.ImportedVertexListUnskinnedWorld(meshObj.VertexList, transform)
:
rem.ImportedVertexListUnskinned(meshObj.VertexList, scale);
List <ImportedFace> faceList = rem.ImportedFaceList(meshObj.FaceList);
SB3Utility.Mqo.ExporterCommon.WriteMeshObject(writer, vertList, faceList, mqoMatIdx, null);
writer.WriteLine("}");
}
}
writer.WriteLine("Eof");
}
foreach (int matIdx in materialList)
{
remMaterial mat = parser.MATC[matIdx];
string matTexName = mat.texture;
if (matTexName != null && !usedTextures.Contains(matTexName))
{
usedTextures.Add(matTexName);
}
}
return(usedTextures);
}
public static void remMaterial(remMaterial mat)
{
mat.unk_or_flag = 0;
mat.unknown = new remId(null);
}
private void ConvertMeshes(List <remMesh> meshes, remParser parser)
{
MeshList = new List <ImportedMesh>(meshes.Count);
MaterialList = new List <ImportedMaterial>(meshes.Count);
TextureList = new List <ImportedTexture>(parser.MATC.Count);
foreach (remMesh mesh in meshes)
{
ImportedMesh iMesh = new ImportedMesh();
MeshList.Add(iMesh);
iMesh.BoneList = new List <ImportedBone>();
Dictionary <remId, byte> boneDic = new Dictionary <remId, byte>();
remSkin skin = rem.FindSkin(mesh.name, parser.SKIC);
rem.Mesh convertedMesh = new rem.Mesh(mesh, skin);
iMesh.SubmeshList = new List <ImportedSubmesh>(convertedMesh.Count);
remBone meshFrame = rem.FindFrame(mesh.frame, parser.BONC.rootFrame);
ImportedFrame iFrame = ImportedHelpers.FindFrame(mesh.frame, FrameList[0]);
float s = (float)Math.Round(Math.Abs(meshFrame.matrix.M11), 5);
iFrame.Name = iMesh.Name = mesh.name + (s != 1f ? "(Scale=" + s.ToString() + ")" : String.Empty);
foreach (rem.Submesh submesh in convertedMesh)
{
ImportedSubmesh iSubmesh = new ImportedSubmesh();
iMesh.SubmeshList.Add(iSubmesh);
remMaterial mat = rem.FindMaterial(submesh.MaterialName, parser.MATC);
if (mat != null)
{
iSubmesh.Material = mat.name;
ImportedMaterial iMat = ImportedHelpers.FindMaterial(iSubmesh.Material, MaterialList);
if (iMat == null)
{
iMat = new ImportedMaterial();
MaterialList.Add(iMat);
iMat.Name = iSubmesh.Material;
iMat.Diffuse = new Color4(mat.diffuse);
iMat.Ambient = new Color4(mat.ambient);
iMat.Specular = new Color4(mat.specular);
iMat.Emissive = new Color4(mat.emissive);
iMat.Power = mat.specularPower;
iMat.Textures = new string[4] {
String.Empty, String.Empty, String.Empty, String.Empty
};
if (mat.texture != null)
{
iMat.Textures[0] = mat.texture;
if (ImportedHelpers.FindTexture(iMat.Textures[0], TextureList) == null)
{
try
{
ImportedTexture iTex = rem.ImportedTexture(mat.texture, parser.RemPath, true);
TextureList.Add(iTex);
}
catch
{
Report.ReportLog("cant read texture " + iMat.Textures[0]);
}
}
}
}
}
List <Tuple <byte, float> >[] iSkin = new List <Tuple <byte, float> > [submesh.numVertices];
for (int i = 0; i < submesh.numVertices; i++)
{
iSkin[i] = new List <Tuple <byte, float> >(4);
}
List <remBoneWeights> boneList = submesh.BoneList;
if (boneList != null)
{
if (iMesh.BoneList.Capacity < boneList.Count)
{
iMesh.BoneList.Capacity += boneList.Count;
}
foreach (remBoneWeights boneWeights in boneList)
{
byte idx;
if (!boneDic.TryGetValue(boneWeights.bone, out idx))
{
ImportedBone iBone = new ImportedBone();
iMesh.BoneList.Add(iBone);
iBone.Name = boneWeights.bone;
Vector3 scale, translate;
Quaternion rotate;
meshFrame.matrix.Decompose(out scale, out rotate, out translate);
scale.X = Math.Abs(scale.X);
scale.Y = Math.Abs(scale.Y);
scale.Z = Math.Abs(scale.Z);
iBone.Matrix = Matrix.Scaling(1f, 1f, -1f) * Matrix.Invert(meshFrame.matrix) * Matrix.Scaling(scale) * boneWeights.matrix;
boneDic.Add(boneWeights.bone, idx = (byte)boneDic.Count);
}
for (int i = 0; i < boneWeights.numVertIdxWts; i++)
{
iSkin[boneWeights.vertexIndices[i]].Add(new Tuple <byte, float>(idx, boneWeights.vertexWeights[i]));
}
}
}
iSubmesh.VertexList = new List <ImportedVertex>(submesh.numVertices);
for (int i = 0; i < submesh.numVertices; i++)
{
remVertex vert = submesh.VertexList[i];
ImportedVertex iVert = new ImportedVertex();
iSubmesh.VertexList.Add(iVert);
iVert.Position = new Vector3(vert.Position.X, vert.Position.Z, -vert.Position.Y);
iVert.Normal = new Vector3(vert.Normal.X, vert.Normal.Z, -vert.Normal.Y);
iVert.UV = new float[] { vert.UV[0], vert.UV[1] };
iVert.BoneIndices = new byte[4];
iVert.Weights = new float[4];
for (int j = 0; j < 4; j++)
{
if (j < iSkin[i].Count)
{
Tuple <byte, float> vertIdxWeight = iSkin[i][j];
iVert.BoneIndices[j] = vertIdxWeight.Item1;
iVert.Weights[j] = vertIdxWeight.Item2;
}
else
{
iVert.BoneIndices[j] = 0xFF;
}
}
}
iSubmesh.FaceList = rem.ImportedFaceList(submesh.FaceList);
}
}
}
public static void ReplaceMesh(remBone frame, remParser parser, WorkspaceMesh mesh, List <ImportedMaterial> materials, List <ImportedTexture> textures, bool merge, CopyMeshMethod normalsMethod, CopyMeshMethod bonesMethod, bool meshFrameCorrection)
{
remMesh frameREMMesh = rem.FindMesh(frame, parser.MESC);
int startPos = 0;
if (meshFrameCorrection)
{
// frame.matrix = Matrix.Scaling(-1f, 1f, 1f) * Matrix.RotationYawPitchRoll(0f, (float)(Math.PI / 2), (float)Math.PI);
frame.matrix = Matrix.Identity;
frame.matrix.M22 = frame.matrix.M33 = 0f;
frame.matrix.M23 = frame.matrix.M32 = 1f;
startPos = mesh.Name.IndexOf("(Scale");
if (startPos > 0)
{
int endPos = mesh.Name.IndexOf(')');
float scale;
if (Single.TryParse(mesh.Name.Substring(startPos + 7, endPos - startPos - 7), out scale))
{
frame.matrix *= Matrix.Scaling(new Vector3(scale));
}
remId newFrameName = new remId(mesh.Name.Substring(0, startPos));
if (newFrameName != frame.name)
{
if (rem.FindFrame(newFrameName, parser.BONC.rootFrame) == null)
{
frame.name = newFrameName;
}
else
{
Report.ReportLog("Warning! Cant rename frame (and mesh) " + mesh.Name + " automatically to " + newFrameName + ".");
}
}
}
}
Matrix transform = Matrix.Scaling(-1f, 1f, 1f);
remBone transformFrame = frame;
while (transformFrame != parser.BONC.rootFrame)
{
transform *= transformFrame.matrix;
transformFrame = transformFrame.Parent as remBone;
}
transform.Invert();
string[] materialNames;
int[] indices;
bool[] worldCoords;
bool[] replaceSubmeshesOption;
remMesh newREMMesh = CreateMesh(mesh, out materialNames, out indices, out worldCoords, out replaceSubmeshesOption);
if (startPos > 0)
{
newREMMesh.name = frame.name;
}
Mesh newMesh = new Mesh(newREMMesh, CreateBoneList(mesh, transform));
remSkin frameMeshSkin = null;
Mesh frameMesh = null;
if (frameREMMesh != null)
{
newMesh.name = frameREMMesh.name;
frameMeshSkin = rem.FindSkin(frameREMMesh.name, parser.SKIC);
frameMesh = new Mesh(frameREMMesh, frameMeshSkin);
}
Submesh[] replaceSubmeshes = frameMesh != null ? new Submesh[frameMesh.Count] : null;
List <Submesh> addSubmeshes = new List <Submesh>(newMesh.Count);
for (int i = 0; i < newMesh.Count; i++)
{
remMaterial mat = rem.FindMaterial(new remId(materialNames[i]), parser.MATC);
if (materials != null)
{
if (mat == null)
{
mat = CreateMaterial(ImportedHelpers.FindMaterial(materialNames[i], materials));
parser.MATC.AddChild(mat);
}
/* if (textures != null)
* {
* string texName = materials[i].Textures[0];
* remMaterial texMat = rem.FindMaterial(parser.MATC, new remId(texName));
* if (texMat == null)
* {
* for (int k = 0; k < textures.Count; k++)
* {
* if (textures[k].Name == texName)
* {
* // texMat = CreateTexture(textures[k], Path.GetDirectoryName(parser.ODFPath));
* break;
* }
* }
* }
* }*/
}
Submesh newSubmesh = newMesh[i];
if (mat != null)
{
newSubmesh.MaterialName = mat.name;
}
if (worldCoords[i])
{
List <remVertex> newVertexList = newSubmesh.VertexList;
for (int j = 0; j < newVertexList.Count; j++)
{
newVertexList[j].Position = Vector3.TransformCoordinate(newVertexList[j].Position, transform);
}
}
Submesh baseSubmesh = null;
List <remBoneWeights> newBones = null;
int idx = indices[i];
if ((frameMesh != null) && (idx >= 0) && (idx < frameMesh.Count))
{
baseSubmesh = frameMesh[idx];
if ((bonesMethod == CopyMeshMethod.CopyOrder) || (bonesMethod == CopyMeshMethod.CopyNear))
{
List <remBoneWeights> baseBones = baseSubmesh.BoneList;
if (baseBones != null)
{
newBones = new List <remBoneWeights>(baseBones.Count);
foreach (remBoneWeights boneWeights in baseBones)
{
remBoneWeights copy = boneWeights.Clone();
newBones.Add(copy);
}
newSubmesh.BoneList = newBones;
}
}
else if (bonesMethod == CopyMeshMethod.Replace)
{
newBones = newSubmesh.BoneList;
}
}
else
{
newBones = newSubmesh.BoneList;
}
if (baseSubmesh != null)
{
if (normalsMethod == CopyMeshMethod.CopyOrder)
{
rem.CopyNormalsOrder(baseSubmesh.VertexList, newSubmesh.VertexList);
}
else if (normalsMethod == CopyMeshMethod.CopyNear)
{
rem.CopyNormalsNear(baseSubmesh.VertexList, newSubmesh.VertexList);
}
if (bonesMethod == CopyMeshMethod.CopyOrder)
{
rem.CopyBonesOrder(baseSubmesh.VertexList, newSubmesh.VertexList, newBones);
}
else if (bonesMethod == CopyMeshMethod.CopyNear)
{
rem.CopyBonesNear(baseSubmesh.VertexList, newSubmesh.VertexList, newBones);
}
}
if ((baseSubmesh != null) && merge && replaceSubmeshesOption[i])
{
replaceSubmeshes[idx] = newSubmesh;
}
else
{
addSubmeshes.Add(newSubmesh);
}
}
if ((frameMesh != null) && merge)
{
newMesh.ChildList.Clear();
newMesh.ChildList.Capacity = replaceSubmeshes.Length + addSubmeshes.Count;
for (int i = 0, submeshesRemoved = 0; i < replaceSubmeshes.Length; i++)
{
if (replaceSubmeshes[i] == null)
{
Submesh newSubmesh = frameMesh[i - submeshesRemoved++];
newMesh.AddChild(newSubmesh);
}
else
{
newMesh.AddChild(replaceSubmeshes[i]);
}
}
newMesh.ChildList.AddRange(addSubmeshes);
}
remSkin skin;
newREMMesh = newMesh.CreateMesh(out skin);
newREMMesh.frame = frame.name;
if (frameREMMesh != null)
{
CopyUnknowns(frameREMMesh, newREMMesh);
parser.MESC.InsertChild(parser.MESC.IndexOf(frameREMMesh), newREMMesh);
RemoveMesh(parser, frameREMMesh);
}
else
{
CreateUnknowns(newREMMesh);
parser.MESC.AddChild(newREMMesh);
}
if (skin.Count > 0)
{
parser.SKIC.AddChild(skin);
}
}
public static void CreateUnknown(remMaterial material)
{
UnknownDefaults.remMaterial(material);
}
public static void CopyUnknown(remMaterial srcMat, remMaterial dstMat)
{
dstMat.unk_or_flag = srcMat.unk_or_flag;
dstMat.unknown = srcMat.unknown;
}
private AnimationFrame CreateFrame(remBone frame, remParser parser, HashSet <string> extractFrames, remMesh mesh, Device device, Matrix combinedParent, List <AnimationFrame> meshFrames)
{
AnimationFrame animationFrame = new AnimationFrame();
animationFrame.Name = frame.name.ToString();
animationFrame.TransformationMatrix = frame.matrix;
animationFrame.OriginalTransform = animationFrame.TransformationMatrix;
animationFrame.CombinedTransform = combinedParent * animationFrame.TransformationMatrix;
if (frame.name == mesh.frame)
{
ExtendedMaterial[] materials = new ExtendedMaterial[mesh.numMats];
List <List <remVertex> > submeshVertLists = new List <List <remVertex> >(mesh.numMats);
List <List <ushort> > submeshFaceLists = new List <List <ushort> >(mesh.numMats);
List <int[]> submeshVertIndices = new List <int[]>(mesh.numMats);
SplitMesh(mesh, submeshVertLists, submeshFaceLists, submeshVertIndices);
remSkin boneList = rem.FindSkin(mesh.name, parser.SKIC);
bool skinned = boneList != null;
int numBones = skinned ? boneList.Count : 0;
List <string> boneNamesList = new List <string>(numBones);
List <Matrix> boneOffsetsList = new List <Matrix>(numBones);
for (int boneIdx = 0; boneIdx < numBones; boneIdx++)
{
boneNamesList.Add(boneList[boneIdx].bone.ToString());
boneOffsetsList.Add(boneList[boneIdx].matrix);
}
List <string> boneFrameParentNames = new List <string>(numBones);
List <Matrix> boneFrameParentMatrices = new List <Matrix>(numBones);
for (int boneIdx = 0; boneIdx < numBones; boneIdx++)
{
remBone boneFrame = rem.FindFrame(boneList[boneIdx].bone, parser.BONC.rootFrame);
if (boneFrame == null)
{
continue;
}
remBone boneFrameParent = boneFrame.Parent;
if (!boneNamesList.Contains(boneFrameParent.name) && !boneFrameParentNames.Contains(boneFrameParent.name))
{
boneFrameParentNames.Add(boneFrameParent.name);
Matrix incompleteMeshFrameCorrection = Matrix.Invert(frame.matrix);
boneFrameParentMatrices.Add(incompleteMeshFrameCorrection * Matrix.Invert(boneFrame.matrix) * boneList[boneIdx].matrix);
}
}
boneNamesList.AddRange(boneFrameParentNames);
string[] boneNames = boneNamesList.ToArray();
boneOffsetsList.AddRange(boneFrameParentMatrices);
Matrix[] boneOffsets = boneOffsetsList.ToArray();
AnimationMeshContainer[] meshContainers = new AnimationMeshContainer[submeshFaceLists.Count];
Vector3 min = new Vector3(Single.MaxValue);
Vector3 max = new Vector3(Single.MinValue);
for (int i = 0; i < submeshFaceLists.Count; i++)
{
List <ushort> faceList = submeshFaceLists[i];
List <remVertex> vertexList = submeshVertLists[i];
Mesh animationMesh = new Mesh(device, faceList.Count, vertexList.Count, MeshFlags.Managed, PositionBlendWeightsIndexedNormalTexturedColoured.Format);
using (DataStream indexStream = animationMesh.LockIndexBuffer(LockFlags.None))
{
for (int j = 0; j < faceList.Count; j++)
{
indexStream.Write(faceList[j]);
}
animationMesh.UnlockIndexBuffer();
}
byte[][] vertexBoneIndices = null;
float[][] vertexWeights = ConvertVertexWeights(vertexList, submeshVertIndices[i], boneList, out vertexBoneIndices);
FillVertexBuffer(animationMesh, vertexList, vertexWeights, vertexBoneIndices, -1);
var normalLines = new PositionBlendWeightsIndexedColored[vertexList.Count * 2];
for (int j = 0; j < vertexList.Count; j++)
{
remVertex vertex = vertexList[j];
Vector3 position = vertex.Position;
Vector3 normal = vertex.Normal;
float[] boneWeights = vertexWeights[j];
normalLines[j * 2] = new PositionBlendWeightsIndexedColored(position, boneWeights, vertexBoneIndices[j], Color.Coral.ToArgb());
normalLines[(j * 2) + 1] = new PositionBlendWeightsIndexedColored(position + normal, boneWeights, vertexBoneIndices[j], Color.Blue.ToArgb());
#if !DONT_MIRROR
position.Z *= -1f;
#endif
min = Vector3.Minimize(min, position);
max = Vector3.Maximize(max, position);
}
AnimationMeshContainer meshContainer = new AnimationMeshContainer();
meshContainer.Name = animationFrame.Name;
meshContainer.MeshData = new MeshData(animationMesh);
meshContainer.NormalLines = normalLines;
meshContainer.BoneNames = boneNames;
meshContainer.BoneOffsets = boneOffsets;
meshContainers[i] = meshContainer;
remMaterial mat = rem.FindMaterial(mesh.materials[i], parser.MATC);
if (mat != null)
{
Material material3D = new Material();
material3D.Ambient = new Color4(mat.ambient);
material3D.Diffuse = new Color4(mat.diffuse);
material3D.Emissive = new Color4(mat.emissive);
material3D.Specular = new Color4(mat.specular);
material3D.Power = mat.specularPower;
int matIdx = parser.MATC.IndexOf(mat);
Materials[matIdx] = material3D;
meshContainer.MaterialIndex = matIdx;
int texIdx = 0;
if (mat.texture != null && !TextureDic.TryGetValue(mat.texture.ToString(), out texIdx))
{
ImportedTexture importedTex = null;
if (!ImportedTextures.TryGetValue(mat.texture.ToString(), out importedTex))
{
importedTex = rem.ImportedTexture(mat.texture, parser.RemPath, true);
if (importedTex == null)
{
Report.ReportLog("Export textures of TEXH.FPK!");
continue;
}
ImportedTextures.Add(mat.texture.ToString(), importedTex);
}
Texture memTex = Texture.FromMemory(device, importedTex.Data);
texIdx = TextureDic.Count;
TextureDic.Add(mat.texture.ToString(), texIdx);
Textures.Add(memTex);
}
meshContainer.TextureIndex = texIdx;
}
}
for (int i = 0; i < (meshContainers.Length - 1); i++)
{
meshContainers[i].NextMeshContainer = meshContainers[i + 1];
}
min = Vector3.TransformCoordinate(min, animationFrame.CombinedTransform);
max = Vector3.TransformCoordinate(max, animationFrame.CombinedTransform);
animationFrame.Bounds = new BoundingBox(min, max);
animationFrame.MeshContainer = meshContainers[0];
meshFrames.Add(animationFrame);
}
for (int i = 0; i < frame.Count; i++)
{
remBone child = frame[i];
if (extractFrames.Contains(child.name.ToString()))
{
AnimationFrame childAnimationFrame = CreateFrame(child, parser, extractFrames, mesh, device, animationFrame.CombinedTransform, meshFrames);
childAnimationFrame.Parent = animationFrame;
animationFrame.AppendChild(childAnimationFrame);
}
}
numFrames++;
return(animationFrame);
}