public void Import(string fileName)
{
// Only need to Update the HEADER, and Animation.Duration, ASETHEADER is auto handled
this.File = new BrgFile();
BrgFile model = this.File; // just ref here so I don't have to rename model to this.File
Grendgine_Collada cModel = Grendgine_Collada.Grendgine_Load_File(fileName);
//Materials
BrgMaterial mat = new BrgMaterial(model);
model.Materials.Add(mat);
mat.AmbientColor = new Color3D();
mat.DiffuseColor = new Color3D();
mat.SpecularColor = new Color3D(0.5f);
mat.SpecularExponent = 5;
mat.Id = 100;
mat.Opacity = 1f;
mat.Flags |= BrgMatFlag.HasTexture | BrgMatFlag.SpecularExponent;
model.Header.NumMaterials = model.Materials.Count();
//Meshes
foreach (Grendgine_Collada_Geometry geo in cModel.Library_Geometries.Geometry)
{
BrgMesh mesh = new BrgMesh(model);
model.Meshes.Add(mesh);
mesh.Header.Flags |= BrgMeshFlag.MATERIAL;
mesh.Header.Flags |= model.Meshes.Count == 1 ? 0 : BrgMeshFlag.SECONDARYMESH;
mesh.Header.AnimationType |= BrgMeshAnimType.KeyFrame;
mesh.Header.Format |= 0;
mesh.ExtendedHeader.NumMaterials = (byte)model.Header.NumMaterials;
mesh.ExtendedHeader.AnimationLength = 30;
mesh.ExtendedHeader.NumUniqueMaterials = 0;
string polyVertSourceID;
string polyNormalsSourceID;
string materialID;
int[] vertCountPerPoly;
int[] vertLinkPerPoly;
int[] vertNormalBindings;
//Locate the vertices and convert them
string vertexPosSourceID = geo.Mesh.Vertices.Input.First<Grendgine_Collada_Input_Unshared>(x => x.Semantic == Grendgine_Collada_Input_Semantic.POSITION).source;
Grendgine_Collada_Float_Array vertsArray = FindSourceByID(geo.Mesh, vertexPosSourceID).Float_Array;
mesh.Vertices = FloatToVectorArray(vertsArray);
mesh.Header.NumVertices = (short)mesh.Vertices.Count;
//Check for polygons otherwise skip mesh
if (geo.Mesh.Polylist != null || geo.Mesh.Polylist.Length > 0)
{
mesh.Header.NumFaces = (short)geo.Mesh.Polylist[0].Count;
polyVertSourceID = geo.Mesh.Polylist[0].Input.First<Grendgine_Collada_Input_Unshared>(x => x.Semantic == Grendgine_Collada_Input_Semantic.VERTEX).source;
polyNormalsSourceID = geo.Mesh.Polylist[0].Input.First<Grendgine_Collada_Input_Unshared>(x => x.Semantic == Grendgine_Collada_Input_Semantic.NORMAL).source;
vertCountPerPoly = geo.Mesh.Polylist[0].VCount.Value();
materialID = geo.Mesh.Polylist[0].Material;
vertLinkPerPoly = geo.Mesh.Polylist[0].P.Value();
mesh.Faces = new List<Face>(mesh.Header.NumFaces);
vertNormalBindings = new int[mesh.Header.NumVertices];
int polyindex = 0;
Face ff;
foreach (int count in vertCountPerPoly)
{
if (count == 3) //If triangle
{
ff = new Face();
ff.Indices = new List<short>(3);
ff.Indices.Add((short)vertLinkPerPoly[polyindex]);
ff.Indices.Add((short)vertLinkPerPoly[polyindex + 4]);
ff.Indices.Add((short)vertLinkPerPoly[polyindex + 2]);
//List correct normal bindings
vertNormalBindings[ff.Indices[0]] = vertLinkPerPoly[polyindex + 1];
vertNormalBindings[ff.Indices[1]] = vertLinkPerPoly[polyindex + 5];
vertNormalBindings[ff.Indices[2]] = vertLinkPerPoly[polyindex + 3];
//Bind materials
if (mesh.Header.Flags.HasFlag(BrgMeshFlag.MATERIAL))
ff.MaterialIndex = (short)mat.Id;
mesh.Faces.Add(ff);
}
polyindex += count * 2; //Including face normal bindings
}
}
else
{
break;
}
//Locate the vertex normals
Grendgine_Collada_Float_Array normalsArray = FindSourceByID(geo.Mesh, polyNormalsSourceID).Float_Array;
if (normalsArray.Count != vertsArray.Count)
{
System.Windows.Forms.MessageBox.Show("The mesh hash only face normals instead of vertex normals. Be sure to export only smooth shaded models.", "Model Import Error", System.Windows.Forms.MessageBoxButtons.OK, System.Windows.Forms.MessageBoxIcon.Warning);
}
List<Vector3D> unsortedNormals = FloatToVectorArray(normalsArray);
mesh.Normals = new List<Vector3D>(mesh.Header.NumVertices);
for (int i = 0; i < mesh.Header.NumVertices; i++)
{
mesh.Normals.Add(unsortedNormals[vertNormalBindings[i]]);
}
mesh.VertexMaterials = new List<short>(mesh.Header.NumVertices);
for (int i = 0; i < mesh.Header.NumVertices; i++)
{
mesh.VertexMaterials.Add((short)mat.Id);
}
}
model.Header.NumMeshes = model.Meshes.Count();
}
public void ReadJson(JsonReader reader)
{
int count = 0;
while (reader.Read())
{
if (reader.TokenType == JsonToken.EndObject)
{
break;
}
if (reader.TokenType == JsonToken.PropertyName)
{
switch ((string)reader.Value)
{
case nameof(Header):
Header.ReadJson(reader);
break;
case nameof(ExtendedHeader):
ExtendedHeader.ReadJson(reader);
break;
case nameof(UserDataEntries):
while (reader.Read())
{
if (reader.TokenType == JsonToken.StartArray)
{
continue;
}
if (reader.TokenType == JsonToken.EndArray)
{
break;
}
// TODO
}
break;
case nameof(particleData):
while (reader.Read())
{
if (reader.TokenType == JsonToken.StartArray)
{
continue;
}
if (reader.TokenType == JsonToken.EndArray)
{
break;
}
// TODO
}
break;
case nameof(NonUniformKeys):
while (reader.Read())
{
if (reader.TokenType == JsonToken.StartArray)
{
continue;
}
if (reader.TokenType == JsonToken.EndArray)
{
break;
}
NonUniformKeys.Add((float)(double)reader.Value);
}
break;
case nameof(Attachpoints):
while (reader.Read())
{
if (reader.TokenType == JsonToken.StartArray)
{
continue;
}
if (reader.TokenType == JsonToken.EndArray)
{
break;
}
BrgAttachpoint a = new BrgAttachpoint();
a.ReadJson(reader);
Attachpoints.Add(a);
}
break;
case nameof(Vertices):
reader.Read(); // StartArray
while (reader.Read())
{
if (reader.TokenType == JsonToken.EndArray)
{
break;
}
Vector3 v = reader.ReadAsVector3();
Vertices.Add(v);
}
break;
case nameof(Normals):
reader.Read(); // StartArray
while (reader.Read())
{
if (reader.TokenType == JsonToken.EndArray)
{
break;
}
Vector3 v = reader.ReadAsVector3();
Normals.Add(v);
}
break;
case nameof(TextureCoordinates):
reader.Read(); // StartArray
while (reader.Read())
{
if (reader.TokenType == JsonToken.EndArray)
{
break;
}
Vector3 v = reader.ReadAsVector3();
TextureCoordinates.Add(v);
}
break;
case nameof(Colors):
reader.Read(); // StartArray
while (reader.Read())
{
if (reader.TokenType == JsonToken.EndArray)
{
break;
}
Color4D c = new Color4D();
c.ReadJson(reader);
Colors.Add(c);
}
break;
case nameof(Faces):
count = 0;
reader.Read(); // StartArray
while (reader.Read())
{
if (reader.TokenType == JsonToken.EndArray)
{
break;
}
Face f;
if (Faces.Count <= count)
{
f = new Face();
Faces.Add(f);
}
else
{
f = Faces[count];
}
++count;
while (reader.Read())
{
if (reader.TokenType == JsonToken.StartArray)
{
continue;
}
if (reader.TokenType == JsonToken.EndArray)
{
break;
}
f.Indices.Add((Int16)(Int64)reader.Value);
}
}
break;
case "FaceMaterials":
count = 0;
reader.Read(); // StartArray
while (reader.Read())
{
if (reader.TokenType == JsonToken.EndArray)
{
break;
}
Face f;
if (Faces.Count <= count)
{
f = new Face();
Faces.Add(f);
}
else
{
f = Faces[count];
}
++count;
f.MaterialIndex = (Int16)(Int64)reader.Value;
}
break;
case nameof(MeshAnimations):
reader.Read(); // StartArray
while (reader.Read())
{
if (reader.TokenType == JsonToken.EndArray)
{
break;
}
BrgMesh m = new BrgMesh(this.ParentFile);
m.ReadJson(reader);
MeshAnimations.Add(m);
}
break;
default:
throw new Exception("Unexpected property name!");
}
}
else if (reader.TokenType != JsonToken.StartObject)
{
throw new Exception("Unexpected token type! " + reader.TokenType);
}
}
}
private void ImportBrgMesh(string mainObject, BrgMesh mesh, float time)
{
string vertArray = "";
string normArray = "";
string texVerts = "";
string faceMats = "";
string faceArray = "";
if (!mesh.Header.Flags.HasFlag(BrgMeshFlag.SECONDARYMESH))
{
vertArray = Maxscript.NewArray("vertArray");
normArray = Maxscript.NewArray("normArray");
texVerts = Maxscript.NewArray("texVerts");
faceMats = Maxscript.NewArray("faceMats");
faceArray = Maxscript.NewArray("faceArray");
}
Maxscript.CommentTitle("Load Vertices/Normals/UVWs");
Maxscript.Command("uvwSetVertPosFunc = {0}.Unwrap_UVW.SetVertexPosition", mainObject);
for (int i = 0; i < mesh.Vertices.Count; i++)
{
if (mesh.Header.Flags.HasFlag(BrgMeshFlag.SECONDARYMESH))
{
Maxscript.AnimateAtTime(time, "meshSetVertFunc {0} {1} {2}", mainObject, i + 1,
Maxscript.Point3Literal(-mesh.Vertices[i].X, -mesh.Vertices[i].Z, mesh.Vertices[i].Y));
if (mesh.Header.Flags.HasFlag(BrgMeshFlag.ANIMTEXCOORDS) &&
mesh.Header.Flags.HasFlag(BrgMeshFlag.TEXCOORDSA))
{
Maxscript.Animate("uvwSetVertPosFunc {0}s {1} {2}", time, i + 1,
Maxscript.Point3Literal(mesh.TextureCoordinates[i].X, mesh.TextureCoordinates[i].Y, 0));
}
if (mesh.Header.Flags.HasFlag(BrgMeshFlag.ANIMVERTCOLORALPHA))
{
if (mesh.Header.Flags.HasFlag(BrgMeshFlag.COLORALPHACHANNEL))
{
Maxscript.AnimateAtTime(time, "meshop.setVertAlpha {0} -2 {1} {2}",
mainObject, i + 1, mesh.Colors[i].A);
}
else if (mesh.Header.Flags.HasFlag(BrgMeshFlag.COLORCHANNEL))
{
Maxscript.AnimateAtTime(time, "meshop.setVertColor {0} 0 {1} (color {2} {3} {4})", mainObject, i + 1,
mesh.Colors[i].R, mesh.Colors[i].G, mesh.Colors[i].B);
}
}
}
else
{
Maxscript.Append(vertArray, Maxscript.Point3Literal(-mesh.Vertices[i].X, -mesh.Vertices[i].Z, mesh.Vertices[i].Y));
if (mesh.Header.Flags.HasFlag(BrgMeshFlag.TEXCOORDSA))
{
Maxscript.Append(texVerts, Maxscript.Point3Literal(mesh.TextureCoordinates[i].X, mesh.TextureCoordinates[i].Y, 0));
}
if (mesh.Header.Flags.HasFlag(BrgMeshFlag.COLORALPHACHANNEL))
{
//Maxscript.Command("meshop.supportVAlphas {0}", mainObject);
Maxscript.Command("meshop.setVertAlpha {0} -2 {1} {2}",
mainObject, i + 1, mesh.Colors[i].A);
}
else if (mesh.Header.Flags.HasFlag(BrgMeshFlag.COLORCHANNEL))
{
Maxscript.Command("meshop.setVertColor {0} 0 {1} (color {2} {3} {4})", mainObject, i + 1,
mesh.Colors[i].R, mesh.Colors[i].G, mesh.Colors[i].B);
}
}
}
if (!mesh.Header.Flags.HasFlag(BrgMeshFlag.SECONDARYMESH))
{
if (mesh.Header.Flags.HasFlag(BrgMeshFlag.MATERIAL))
{
Maxscript.CommentTitle("Load Face Materials");
foreach (var fMat in mesh.Faces)
{
Maxscript.Append(faceMats, fMat.MaterialIndex);
}
}
Maxscript.CommentTitle("Load Faces");
foreach (var face in mesh.Faces)
{
Maxscript.Append(faceArray, Maxscript.Point3Literal(face.Indices[0] + 1, face.Indices[2] + 1, face.Indices[1] + 1));
}
int mObjNum = 0;
while (Maxscript.QueryInteger("($objects/{0}* as array).count", mainObject + mObjNum) > 0) { ++mObjNum; }
Maxscript.Command("{0} = {1}", mainObject, Maxscript.NewMeshLiteral(mainObject + mObjNum, vertArray, faceArray, faceMats, texVerts));
//Maxscript.Command("{0} = getNodeByName \"{0}\"", mainObject);
Maxscript.Command("dummy name:\"Dummy_hotspot\" pos:{0} boxsize:[10,10,0]", Maxscript.Point3Literal(-mesh.Header.HotspotPosition.X, -mesh.Header.HotspotPosition.Z, mesh.Header.HotspotPosition.Y));
Maxscript.CommentTitle("TVert Hack"); // Needed <= 3ds Max 2014; idk about 2015+
Maxscript.Command("buildTVFaces {0}", mainObject);
for (int i = 1; i <= mesh.Faces.Count; i++)
{
Maxscript.Command("setTVFace {0} {1} {2}[{1}]", mainObject, i, faceArray);
}
Maxscript.CommentTitle("Load Normals for first Frame");
Maxscript.Command("max modify mode");
Maxscript.Command("select {0}", mainObject);
Maxscript.Command("addModifier {0} (Edit_Normals()) ui:off", mainObject);
Maxscript.Command("modPanel.setCurrentObject {0}.modifiers[#edit_normals]", mainObject);
Maxscript.Command("{0}.modifiers[#edit_normals].Break selection:#{{1..{1}}}", mainObject, mesh.Normals.Count);
Maxscript.Command("meshSetNormalIdFunc = {0}.modifiers[#edit_normals].SetNormalID", mainObject);
for (int i = 0; i < mesh.Faces.Count; ++i)
{
Maxscript.Command("meshSetNormalIdFunc {0} {1} {2}",
i + 1, 1, mesh.Faces[i].Indices[0] + 1);
Maxscript.Command("meshSetNormalIdFunc {0} {1} {2}",
i + 1, 2, mesh.Faces[i].Indices[2] + 1);
Maxscript.Command("meshSetNormalIdFunc {0} {1} {2}",
i + 1, 3, mesh.Faces[i].Indices[1] + 1);
}
Maxscript.Command("{0}.modifiers[#edit_normals].MakeExplicit selection:#{{1..{1}}}", mainObject, mesh.Normals.Count);
Maxscript.Command("meshSetNormalFunc = {0}.modifiers[#edit_normals].SetNormal", mainObject);
for (int i = 0; i < mesh.Normals.Count; i++)
{
Maxscript.Command("meshSetNormalFunc {0} {1}", i + 1,
Maxscript.Point3Literal(-mesh.Normals[i].X, -mesh.Normals[i].Z, mesh.Normals[i].Y));
}
Maxscript.Command("collapseStack {0}", mainObject);
if (mesh.Header.Flags.HasFlag(BrgMeshFlag.ANIMTEXCOORDS))
{
Maxscript.Command("select {0}", mainObject);
Maxscript.Command("addModifier {0} (Unwrap_UVW()) ui:off", mainObject);
Maxscript.Command("select {0}.verts", mainObject);
Maxscript.Animate("{0}.Unwrap_UVW.moveSelected [0,0,0]", mainObject);
}
}
Maxscript.CommentTitle("Load Attachpoints");
string attachDummyArray = "attachDummyArray";
if (!mesh.Header.Flags.HasFlag(BrgMeshFlag.SECONDARYMESH))
{
Maxscript.NewArray(attachDummyArray);
}
for (int i = 0; i < mesh.Attachpoints.Count; ++i)
{
BrgAttachpoint att = mesh.Attachpoints[i];
if (mesh.Header.Flags.HasFlag(BrgMeshFlag.SECONDARYMESH))
{
Maxscript.Command("attachpoint = {0}[{1}]", attachDummyArray, i + 1);
Maxscript.AnimateAtTime(time, "attachpoint.rotation = {0}", att.GetMaxTransform());
Maxscript.AnimateAtTime(time, "attachpoint.position = {0}", att.GetMaxPosition());
if (this.uniformAttachpointScale)
{
Maxscript.AnimateAtTime(time, "attachpoint.scale = [1,1,1]");
}
else
{
Maxscript.AnimateAtTime(time, "attachpoint.scale = {0}", att.GetMaxScale());
}
}
else
{
string attachDummy;
if (this.uniformAttachpointScale)
{
attachDummy = Maxscript.NewDummy("attachDummy", att.GetMaxName(), att.GetMaxTransform(), att.GetMaxPosition(), "[0.25,0.25,0.25]", "[1,1,1]");
}
else
{
attachDummy = Maxscript.NewDummy("attachDummy", att.GetMaxName(), att.GetMaxTransform(), att.GetMaxPosition(), att.GetMaxBoxSize(), att.GetMaxScale());
}
Maxscript.Command("append {0} {1}", attachDummyArray, attachDummy);
}
}
}
public void Export()
{
BrgFile brg = this.File;
Maxscript.Command("exportStartTime = timeStamp()");
//Maxscript.Command("print heapSize");
BrgMeshFlag flags = brg.Meshes[0].Header.Flags;
BrgMeshFormat format = brg.Meshes[0].Header.Format;
BrgMeshAnimType animationType = brg.Meshes[0].Header.AnimationType;
BrgMeshInterpolationType interpolationType = brg.Meshes[0].Header.InterpolationType;
Maxscript.Command("ExportBrgData()");
int totalNumVerts = Maxscript.QueryInteger("brgtotalNumVerts");
int totalNumFaces = Maxscript.QueryInteger("brgtotalNumFaces");
int meshCount = Maxscript.QueryInteger("brgMeshes.count");
if (meshCount == 0)
{
throw new Exception("No Editable_Mesh objects detected!");
}
if (Maxscript.QueryBoolean("keys.Count == 0"))
{
throw new Exception("Could not acquire animation keys!");
}
brg.Header.NumMeshes = Maxscript.QueryInteger("keys.Count");
brg.Animation = new Animation();
for (int i = 1; i <= brg.Header.NumMeshes; ++i)
{
brg.Animation.MeshKeys.Add(Maxscript.QueryFloat("keys[{0}]", i));
}
if (brg.Header.NumMeshes == 1)
{
brg.Animation.Duration = 0;
}
else
{
brg.Animation.Duration = Maxscript.QueryFloat("(animationRange.end.ticks - animationRange.start.ticks) / 4800.0");
}
brg.Animation.TimeStep = brg.Animation.Duration / (float)brg.Header.NumMeshes;
string mainObject = "mainObject";
brg.Materials = new List<BrgMaterial>();
brg.Meshes = new List<BrgMesh>(brg.Header.NumMeshes);
for (int m = 0; m < meshCount; ++m)
{
Maxscript.Command("{0} = brgMeshes[{1}]", mainObject, m + 1);
// Materials
Dictionary<int, int> matIdMapping = new Dictionary<int, int>();
if (Maxscript.QueryBoolean("classof {0}.material == Multimaterial", mainObject))
{
brg.Header.NumMaterials = Maxscript.QueryInteger("{0}.material.materialList.count", mainObject);
for (int i = 0; i < brg.Header.NumMaterials; i++)
{
BrgMaterial mat = new BrgMaterial(brg);
mat.Id = brg.Materials.Count + 1;
Maxscript.Command("mat = {0}.material.materialList[{1}]", mainObject, i + 1);
this.ExportBrgMaterial(mainObject, mat);
int matListIndex = brg.Materials.IndexOf(mat);
int actualMatId = Maxscript.QueryInteger("{0}.material.materialIdList[{1}]", mainObject, i + 1);
if (matListIndex >= 0)
{
if (!matIdMapping.ContainsKey(actualMatId))
{
matIdMapping.Add(actualMatId, brg.Materials[matListIndex].Id);
}
}
else
{
brg.Materials.Add(mat);
if (matIdMapping.ContainsKey(actualMatId))
{
matIdMapping[actualMatId] = mat.Id;
}
else
{
matIdMapping.Add(actualMatId, mat.Id);
}
}
}
}
else if (Maxscript.QueryBoolean("classof {0}.material == Standardmaterial", mainObject))
{
BrgMaterial mat = new BrgMaterial(brg);
mat.Id = brg.Materials.Count + 1;
Maxscript.Command("mat = {0}.material", mainObject);
this.ExportBrgMaterial(mainObject, mat);
int matListIndex = brg.Materials.IndexOf(mat);
if (matListIndex >= 0)
{
matIdMapping.Add(1, brg.Materials[matListIndex].Id);
}
else
{
brg.Materials.Add(mat);
matIdMapping.Add(1, mat.Id);
}
}
else
{
if (flags.HasFlag(BrgMeshFlag.MATERIAL))
{
throw new Exception("Not all meshes have a material applied! " + Maxscript.QueryString("{0}.name", mainObject));
}
}
// Mesh Animations
for (int i = 0; i < brg.Header.NumMeshes; i++)
{
if (i > 0)
{
if (m == 0)
{
BrgMesh mesh = new BrgMesh(brg);
mesh.Vertices = new List<Vector3D>(totalNumVerts);
mesh.Normals = new List<Vector3D>(totalNumVerts);
mesh.TextureCoordinates = new List<Vector3D>(totalNumVerts);
mesh.Faces = new List<Face>(totalNumFaces);
brg.Meshes[0].MeshAnimations.Add(mesh);
}
brg.UpdateMeshSettings(i, flags, format, animationType, interpolationType);
this.ExportBrgMesh(mainObject, (BrgMesh)brg.Meshes[0].MeshAnimations[i - 1], brg.Animation.MeshKeys[i], matIdMapping);
}
else
{
if (m == 0)
{
BrgMesh mesh = new BrgMesh(brg);
mesh.Vertices = new List<Vector3D>(totalNumVerts);
mesh.Normals = new List<Vector3D>(totalNumVerts);
mesh.TextureCoordinates = new List<Vector3D>(totalNumVerts);
mesh.Faces = new List<Face>(totalNumFaces);
brg.Meshes.Add(mesh);
}
brg.UpdateMeshSettings(i, flags, format, animationType, interpolationType);
this.ExportBrgMesh(mainObject, brg.Meshes[i], brg.Animation.MeshKeys[i], matIdMapping);
}
}
}
// Export Attachpoints, and Update some Mesh data
HashSet<int> usedFaceMaterials = new HashSet<int>();
string attachDummy = Maxscript.NewArray("attachDummy");
Maxscript.Command("{0} = for helpObj in ($helpers/Dummy_*) where classof helpObj == Dummy collect helpObj", attachDummy);//"$helpers/Dummy_* as array");
for (int i = 0; i < brg.Header.NumMeshes; i++)
{
BrgMesh mesh;
if (i > 0)
{
mesh = (BrgMesh)brg.Meshes[0].MeshAnimations[i - 1];
}
else
{
mesh = brg.Meshes[i];
}
this.ExportAttachpoints(attachDummy, mesh, brg.Animation.MeshKeys[i]);
HashSet<int> diffFaceMats = new HashSet<int>();
if (!mesh.Header.Flags.HasFlag(BrgMeshFlag.SECONDARYMESH) &&
mesh.Header.Flags.HasFlag(BrgMeshFlag.MATERIAL))
{
for (int j = 0; j < mesh.Faces.Count; ++j)
{
diffFaceMats.Add(mesh.Faces[j].MaterialIndex);
}
if (diffFaceMats.Count > 0)
{
mesh.ExtendedHeader.NumMaterials = (byte)(diffFaceMats.Count - 1);
mesh.ExtendedHeader.NumUniqueMaterials = diffFaceMats.Count;
}
}
usedFaceMaterials.UnionWith(diffFaceMats);
mesh.ExtendedHeader.AnimationLength = this.File.Animation.Duration;
}
List<BrgMaterial> usedMats = new List<BrgMaterial>(brg.Materials.Count);
for (int i = 0; i < brg.Materials.Count; ++i)
{
if (usedFaceMaterials.Contains(brg.Materials[i].Id))
{
usedMats.Add(brg.Materials[i]);
}
}
brg.Materials = usedMats;
brg.Header.NumMaterials = brg.Materials.Count;
//Maxscript.Command("print heapSize");
Maxscript.Command("exportEndTime = timeStamp()");
Maxscript.Format("Export took % seconds\n", "((exportEndTime - exportStartTime) / 1000.0)");
}
private void ExportBrgMesh(string mainObject, BrgMesh mesh, float time, Dictionary<int, int> matIdMapping)
{
time += Maxscript.QueryFloat("animationRange.start.ticks / 4800.0");
string mainMesh = "mainMesh";
string mainObjectName = Maxscript.QueryString("{0}.name", mainObject);
// Figure out the proper data to import
if (!mesh.Header.Flags.HasFlag(BrgMeshFlag.SECONDARYMESH))
{
Maxscript.Command("{0} = ExportPreservedTexCoordData (GetMeshSnapshotAtTime {1} {2})", mainMesh, mainObject, time);
}
else
{
Maxscript.Command("{0} = GetMeshSnapshotAtTime {1} {2}", mainMesh, mainObject, time);
}
Maxscript.Command("ExportBrgVertNormals {0}", time);
Maxscript.SetVarAtTime(time, "meshCenter", "{0}.center", mainObject);
mesh.Header.CenterPosition = new Vector3D
(
-Maxscript.QueryFloat("meshCenter.x"),
Maxscript.QueryFloat("meshCenter.z"),
-Maxscript.QueryFloat("meshCenter.y")
);
Maxscript.Command("grnd = getNodeByName \"Dummy_hotspot\"");
if (!Maxscript.QueryBoolean("grnd == undefined"))
{
mesh.Header.HotspotPosition = new Vector3D
(
-Maxscript.QueryFloat("grnd.position.x"),
Maxscript.QueryFloat("grnd.position.z"),
-Maxscript.QueryFloat("grnd.position.y")
);
}
Maxscript.SetVarAtTime(time, "{0}BBMax", "{0}.max", mainObject);
Maxscript.SetVarAtTime(time, "{0}BBMin", "{0}.min", mainObject);
Vector3D bBoxMax = new Vector3D(Maxscript.QueryFloat("{0}BBMax.X", mainObject), Maxscript.QueryFloat("{0}BBMax.Y", mainObject), Maxscript.QueryFloat("{0}BBMax.Z", mainObject));
Vector3D bBoxMin = new Vector3D(Maxscript.QueryFloat("{0}BBMin.X", mainObject), Maxscript.QueryFloat("{0}BBMin.Y", mainObject), Maxscript.QueryFloat("{0}BBMin.Z", mainObject));
Vector3D bBox = (bBoxMax - bBoxMin) / 2;
mesh.Header.MinimumExtent = new Vector3D(-bBox.X, -bBox.Z, -bBox.Y);
mesh.Header.MaximumExtent = new Vector3D(bBox.X, bBox.Z, bBox.Y);
int numVertices = Maxscript.QueryInteger("brgVertIndices.count");
int numFaces = Maxscript.QueryInteger("brgFaceArray.count");
int currNumVertices = mesh.Vertices.Count;
//System.Windows.Forms.MessageBox.Show("1 " + numVertices);
for (int i = 0; i < numVertices; i++)
{
//System.Windows.Forms.MessageBox.Show("1.1");
try
{
Maxscript.Command("vertex = getVert {0} brgVertIndices[{1}]", mainMesh, i + 1);
//System.Windows.Forms.MessageBox.Show("1.4");
mesh.Vertices.Add(new Vector3D(-Maxscript.QueryFloat("vertex.x"), Maxscript.QueryFloat("vertex.z"), -Maxscript.QueryFloat("vertex.y")));
//System.Windows.Forms.MessageBox.Show("1.5");
mesh.Normals.Add(new Vector3D(
-Maxscript.QueryFloat("{0}[{1}].x", "averagedNormals", i + 1),
Maxscript.QueryFloat("{0}[{1}].z", "averagedNormals", i + 1),
-Maxscript.QueryFloat("{0}[{1}].y", "averagedNormals", i + 1)));
//System.Windows.Forms.MessageBox.Show("1.7");
}
catch (Exception ex)
{
throw new Exception("In mesh " + mainObjectName + " error exporting verts/normals index " + (i + 1) + ".", ex);
}
}
//System.Windows.Forms.MessageBox.Show("2");
if (!mesh.Header.Flags.HasFlag(BrgMeshFlag.SECONDARYMESH) || mesh.Header.Flags.HasFlag(BrgMeshFlag.ANIMTEXCOORDS))
{
if (mesh.Header.Flags.HasFlag(BrgMeshFlag.TEXCOORDSA))
{
for (int i = 0; i < numVertices; i++)
{
Maxscript.Command("tVert = getTVert {0} brgVertTVIndices[{1}]", mainMesh, i + 1);
mesh.TextureCoordinates.Add(new Vector3D(Maxscript.QueryFloat("tVert.x"), Maxscript.QueryFloat("tVert.y"), 0f));
}
}
}
//System.Windows.Forms.MessageBox.Show("3");
if (!mesh.Header.Flags.HasFlag(BrgMeshFlag.SECONDARYMESH))
{
if (mesh.Header.Flags.HasFlag(BrgMeshFlag.MATERIAL))
{
mesh.VertexMaterials.AddRange(new Int16[numVertices]);
}
for (int i = 0; i < numFaces; ++i)
{
Face f = new Face();
mesh.Faces.Add(f);
if (mesh.Header.Flags.HasFlag(BrgMeshFlag.MATERIAL))
{
int faceMatId = Maxscript.QueryInteger("getFaceMatId {0} {1}", mainMesh, i + 1);
if (matIdMapping.ContainsKey(faceMatId))
{
f.MaterialIndex = (Int16)matIdMapping[faceMatId];
}
else
{
throw new Exception("In mesh " + mainObjectName + " face index " + (i + 1) + " has an invalid material id " + faceMatId + ".");
}
}
//System.Windows.Forms.MessageBox.Show("3.1");
Maxscript.Command("face = brgFaceArray[{0}]", i + 1);
f.Indices.Add((Int16)(Maxscript.QueryInteger("face.x") - 1 + currNumVertices));
f.Indices.Add((Int16)(Maxscript.QueryInteger("face.z") - 1 + currNumVertices));
f.Indices.Add((Int16)(Maxscript.QueryInteger("face.y") - 1 + currNumVertices));
//System.Windows.Forms.MessageBox.Show("3.2");
if (mesh.Header.Flags.HasFlag(BrgMeshFlag.MATERIAL))
{
mesh.VertexMaterials[f.Indices[0]] = f.MaterialIndex;
mesh.VertexMaterials[f.Indices[1]] = f.MaterialIndex;
mesh.VertexMaterials[f.Indices[2]] = f.MaterialIndex;
}
}
}
Maxscript.Command("delete {0}", mainMesh);
}
private void ExportAttachpoints(string attachDummy, BrgMesh mesh, float time)
{
time += Maxscript.QueryFloat("animationRange.start.ticks / 4800.0");
//System.Windows.Forms.MessageBox.Show("4");
int numAttachpoints = Maxscript.QueryInteger("{0}.count", attachDummy);
//System.Windows.Forms.MessageBox.Show("5 " + numAttachpoints);
if (mesh.Header.Flags.HasFlag(BrgMeshFlag.ATTACHPOINTS))
{
mesh.Attachpoints = new List<BrgAttachpoint>();
for (int i = 0; i < numAttachpoints; i++)
{
string aName = Maxscript.QueryString("{0}[{1}].name", attachDummy, i + 1);
int nameId;
if (!BrgAttachpoint.TryGetIdByName(aName.Substring(6), out nameId)) continue;
BrgAttachpoint att = new BrgAttachpoint();
//System.Windows.Forms.MessageBox.Show(aName);
//System.Windows.Forms.MessageBox.Show("5.1");
//System.Windows.Forms.MessageBox.Show(mesh.Attachpoints.Count + " " + i);
att.NameId = nameId;
Maxscript.Command("{0}[{1}].name = \"{2}\"", attachDummy, i + 1, att.GetMaxName());
//System.Windows.Forms.MessageBox.Show("5.2");
Maxscript.SetVarAtTime(time, "{0}Transform", "{0}[{1}].rotation as matrix3", attachDummy, i + 1);
Maxscript.SetVarAtTime(time, "{0}Position", "{0}[{1}].position", attachDummy, i + 1);
Maxscript.SetVarAtTime(time, "{0}Scale", "{0}[{1}].scale * {0}[{1}].boxsize", attachDummy, i + 1);
//System.Windows.Forms.MessageBox.Show("5.3");
Vector3D scale = new Vector3D(Maxscript.QueryFloat("{0}Scale.X", attachDummy), Maxscript.QueryFloat("{0}Scale.Y", attachDummy), Maxscript.QueryFloat("{0}Scale.Z", attachDummy));
Vector3D bBox = scale / 2;
//System.Windows.Forms.MessageBox.Show("5.4");
att.XVector.X = -Maxscript.QueryFloat("{0}Transform[1].z", attachDummy);
att.XVector.Y = Maxscript.QueryFloat("{0}Transform[3].z", attachDummy);
att.XVector.Z = -Maxscript.QueryFloat("{0}Transform[2].z", attachDummy);
att.YVector.X = -Maxscript.QueryFloat("{0}Transform[1].y", attachDummy);
att.YVector.Y = Maxscript.QueryFloat("{0}Transform[3].y", attachDummy);
att.YVector.Z = -Maxscript.QueryFloat("{0}Transform[2].y", attachDummy);
att.ZVector.X = -Maxscript.QueryFloat("{0}Transform[1].x", attachDummy);
att.ZVector.Y = Maxscript.QueryFloat("{0}Transform[3].x", attachDummy);
att.ZVector.Z = -Maxscript.QueryFloat("{0}Transform[2].x", attachDummy);
att.Position.X = -Maxscript.QueryFloat("{0}Position.x", attachDummy);
att.Position.Z = -Maxscript.QueryFloat("{0}Position.y", attachDummy);
att.Position.Y = Maxscript.QueryFloat("{0}Position.z", attachDummy);
//System.Windows.Forms.MessageBox.Show("5.5");
att.BoundingBoxMin.X = -bBox.X;
att.BoundingBoxMin.Z = -bBox.Y;
att.BoundingBoxMin.Y = -bBox.Z;
att.BoundingBoxMax.X = bBox.X;
att.BoundingBoxMax.Z = bBox.Y;
att.BoundingBoxMax.Y = bBox.Z;
mesh.Attachpoints.Add(att);
}
//System.Windows.Forms.MessageBox.Show("# Atpts: " + Attachpoint.Count);
}
}